How to Use Claude to Source Startups by Thesis (2026)

Claude and a live company database can turn a partner's written thesis into a scored list of matching startups, then keep adding new matches each week.

Published

Written by

Chris Pisarski

Reviewed by

Manmohit Grewal

Read time

21

minutes

Claude and a live company database can turn a partner's written thesis into a scored list of matching startups, then keep adding new matches each week.

Funds that work this way pull a wide list with filters and have Claude read every company and founder against the thesis. A partner sees only the short list. A principal at a European pre-seed fund described the plan to our team as agents that "essentially filter through everything, and then go, this is within our thesis."

A company database answers the thesis lines that have a field behind them, like headcount, last round and country. Most lines have no field. Does the company sell to hospitals or to insurers? Does the AI do the work, or sit on top of an old product? Has one of the founders run a billing team? Claude reads the company description and the founders' work histories, answers those questions, and writes one line on why each company fits.

I tested this on one healthcare-AI thesis. Filters on stage, size, country and round date matched 4,554 companies, a keyword filter on the description cut that to 52, and only 31 of those fit cleanly. The other 21 included prior-authorization tools sold to insurers and legal software that used "revenue cycle" to mean a sales cycle. All 21 passed the filters, and only a read of each description caught them.

For the founders, Crustdata's people data gives past titles, employers and degrees, and Claude judges who counts as a clinician or a revenue-cycle operator. Of 20 companies that fit, 4 had a physician among the founders and 12 had a founder who had worked in healthcare before.

You end up with:

  • A list short enough to read. Dozens of companies, not thousands.

  • A score and a reason for every company. One line of evidence per thesis line.

  • A weekly feed of new matches. Claude reads each one against the same thesis, so the list stays current without a quarterly rebuild.

You can run it in Claude through the Crustdata MCP server with no code, or through the API when you want new matches sent to Slack, email or your own tools on a schedule.

What you need:

  • Claude, on the web, in the desktop app or in Claude Code

  • A Crustdata account, which comes with free credits for new self-serve users

  • Your thesis, written down in a few sentences

  • Three to five companies you already know fit, so you can check the list finds them

At a glance


What this builds

Company filters, a semantic query, founder checks and a scoring rubric, plus a weekly feed

My test

4,554 companies on hard filters, 52 after keywords, 31 that fit

Refresh

A discovery watch re-checks your filters and sends only new matches

Search cost

0.03 credits per result, plus premium field groups

Main limit

Private-company revenue is an estimated range

What does thesis-based deal sourcing with Claude do?

Thesis-based sourcing with Claude finds companies that match a thesis you wrote and keeps finding new ones. Follow the thesis from top to bottom, from the written bet to the weekly feed:

From thesis to a live list for one healthcare-AI thesis: hard filters alone match 4,554 companies; narrowing two ways gives 52 from keyword filters (31 fit) and 25 from a semantic query (17 fit); Claude then scores the fits and a weekly watch adds new matches only.

The filters and the query narrow the market to a list you can read. Claude then scores each company and its founders, and the watch adds new matches. Finding stealth founders, reading talent flow, diligence and portfolio monitoring are separate workflows.

What is deal sourcing?

Deal sourcing is how investors find companies to back before a round is crowded. Venture funds look for startups, and private equity firms look for companies to buy or recapitalize.

Deals come from referrals, events, inbound pitches and outbound searches. Thesis-based sourcing is outbound: you start from what you want to own and search for it.

What is an investment thesis?

An investment thesis is a written bet on which companies will win in a market, and why. A searchable one describes the company and the founders closely enough that you could check a stranger's company against it.

"AI in healthcare" is a theme. A thesis names the product, the buyer, the pricing, the stage, the traction and the kind of founders who should be building it, plus what rules a company out.

How does Claude turn an investment thesis into a list of companies?

Claude splits the thesis by what can answer each line, then reads every result against the parts no field holds:

  1. You write the thesis in plain sentences.

  2. Claude sorts the lines. Numbers and labels become company filters, the product and buyer become a semantic query, and the founder lines become people searches. Anything left is a judgment call for the scoring rubric.

  3. Crustdata returns the matching companies and their founders' records.

  4. Claude reads each company and its founders against the rubric, then writes a score and a reason.

  5. A discovery watch sends new matches each week, and Claude reads each one the same way.

  6. You decide who to contact.

Investors who talked to our team describe the same split. A growth lead at a US growth equity firm suggested the database make the first cut, with a second pass to sort out "what industry verticals they were."

How do I write an investment thesis Claude can search?

Write it in two halves, the company and the founders, and spell out what's out. The more specific each line, the less Claude has to guess when it scores.

This is the thesis I tested, written the way a partner would hand it to an associate:




Which parts of a thesis become filters, and which go to semantic search?

Numbers and fixed labels become company filters. The product and buyer go to Crustdata's semantic search, which matches on meaning as well as words. Founder lines go to people data, and whatever no field can answer, Claude judges when it scores.

Thesis line

Where it goes

How to write it

Seed or Series A in the past 24 months

Company filter

funding.last_round_type in ["seed", "series_a"], funding.last_fundraise_date => a date

10 to 150 employees

Company filter

headcount.total => 10 and =< 150

Headcount up 15% in six months

Company filter

headcount.growth_percent.6m > 15

Headquartered in the US

Company filter

locations.country in ["USA"]

Sells documentation, prior auth, coding or claims software to providers

Semantic query

The product and buyer sentences, word for word

A physician among the founders

People data

education.schools.degree on the founders' records, read by Claude

A founder who worked inside healthcare

People data, then Claude

Past titles and employers from a people search

A technical co-founder

People data, then Claude

Founder titles and past roles

A founder who started a company before

People data, then Claude

Past titles that include founder or co-founder

A first head of sales hired

People data

A people search on the company's domain for "head of sales" or "VP of sales"

The AI does the work itself

Claude judgment

A weighted line in the rubric

Charges per provider, claim or encounter

Claude judgment

Scored unknown when the description doesn't say

Not sold to insurers, not services

Claude judgment

A gate in the rubric

The company filters come from the Company Search reference and the founder fields from the Person Search reference.

Semantic search has four limits to know before you rely on it, per the Company Search docs:

  • No total count. A ranked search always returns total_count as null, so read the count from a filter-only search first.

  • At most 1,000 ranked candidates. The first 100 are reranked, and later results use retrieval order only.

  • No sorting. You can't sort by a field and rank by relevance in the same request.

  • No score per company. In my test, the order of the results was the only ranking signal that came back. Claude writes the scores.

How do I check the founders against the thesis?

Search Crustdata's people data for each company's founders, then have Claude read their histories against the thesis. One people search covers a whole list: filter on the companies' website domains and on a current title containing "founder."

I did this for 20 of the companies that fit. The search returned 44 founder records with past titles, employers and degrees. Read against the founder lines:

Founder line

Companies that met it, of 20

A physician among the founders

4

A founder who had worked inside healthcare

12

A technical co-founder

16

A founder who had started a company before

13

Two records needed a human eye. One title was "Founder Product Lead," which matched the word "founder" without being a founder. And three companies returned only one founder record, so their full team wasn't visible from that search.

The founder search, as a direct API call:

curl --request POST \
  --url https://api.crustdata.com/person/search \
  --header 'authorization: Bearer YOUR_API_KEY' \
  --header 'content-type: application/json' \
  --header 'x-api-version: 2025-11-01' \
  --data '{
    "filters": {
      "op": "and",
      "conditions": [
        {"field": "experience.employment_details.current.company_website_domain", "type": "in", "value": ["example-one.ai", "example-two.com"]},
        {"field": "experience.employment_details.current.title", "type": "(.)", "value": "founder"}
      ]
    },
    "fields": ["basic_profile", "experience", "education"],
    "limit": 50
  }'
curl --request POST \
  --url https://api.crustdata.com/person/search \
  --header 'authorization: Bearer YOUR_API_KEY' \
  --header 'content-type: application/json' \
  --header 'x-api-version: 2025-11-01' \
  --data '{
    "filters": {
      "op": "and",
      "conditions": [
        {"field": "experience.employment_details.current.company_website_domain", "type": "in", "value": ["example-one.ai", "example-two.com"]},
        {"field": "experience.employment_details.current.title", "type": "(.)", "value": "founder"}
      ]
    },
    "fields": ["basic_profile", "experience", "education"],
    "limit": 50
  }'
curl --request POST \
  --url https://api.crustdata.com/person/search \
  --header 'authorization: Bearer YOUR_API_KEY' \
  --header 'content-type: application/json' \
  --header 'x-api-version: 2025-11-01' \
  --data '{
    "filters": {
      "op": "and",
      "conditions": [
        {"field": "experience.employment_details.current.company_website_domain", "type": "in", "value": ["example-one.ai", "example-two.com"]},
        {"field": "experience.employment_details.current.title", "type": "(.)", "value": "founder"}
      ]
    },
    "fields": ["basic_profile", "experience", "education"],
    "limit": 50
  }'

How does the thesis change for growth equity or private equity?

For growth equity, the thesis trades a funding stage for size, revenue and capital raised. The question becomes which companies grew without much outside money.

In place of the stage and round lines, filter on a headcount band (headcount.total), an estimated revenue range (revenue.estimated.lower_bound_usd and revenue.estimated.upper_bound_usd), a cap on prior funding (funding.total_investment_usd), a founding year (basic_info.year_founded) and states or metro areas, plus a round-date filter with six-month headcount growth for companies still hiring long after their last round. All are in the search reference.

A growth lead at a US growth equity firm described a thesis to our team in these terms. He wanted companies "between 15 and 50 employees, prior raise no more than 10 million," and companies "750 days, 1,000 days past their seed, but they're organically hiring."

Why build your own thesis search instead of using Harmonic or Grata?

Build your own when you want to set the filters and weights yourself. Buy a packaged tool when you want search, lists and alerts working on day one and are happy with its ranking. Both tools do a lot well, going by their own pages:

  • Harmonic has ready-made startup discovery. Its site describes filters across companies, people and investors, one-click market maps, and Scout, an agent you describe a job to once and that runs it on a schedule. It also lists alerts, CRM and network sync, a Chrome extension, an API and an MCP server.

  • Grata is built for private-company M&A. Its site describes proprietary data on 22M+ companies, including bootstrapped and founder-owned businesses, seller intent signals and transaction data. Its agent, Blueflame, handles market mapping and target screening. Grata also lists an API and an MCP server.

The trade-off is control over the ranking. Harmonic's page says you can "Create, tune and save hyper-specific searches." Neither page explains how results are ranked or scored, though, and neither describes setting your own weights.

Building your own means you pick the filters, write the semantic query and set the rubric weights in Step 4, and every company comes back with the reasons behind its score. The cost is setup time and owning the rubric. Since both list an API and an MCP server, you could also build that scoring on their data. To test the choice, search the same thesis both ways and check which of your known-good companies each list finds and which it misses.

Can't I just ask Claude for a list of startups?

Not reliably, because on its own Claude works from training data and web search, and neither lets you filter on headcount, round date or stage.

Connected to a company database, Claude searches records at the moment you ask, and does the reading and scoring.

What can't company data tell me about a startup?

Company data can't tell you a private company's reported revenue, and it can blur the line between close industries. Plan for four gaps:

  • Revenue is an estimate: Private companies usually don't publish revenue. Crustdata carries an estimated range you can filter on, so read it next to headcount, hiring and funding.

  • Records refresh on a cycle: Crustdata refreshes every indexed company profile at least every 30 days, and the most active ones as often as daily (data updates). Each record carries an updated_at timestamp, so you can check before you act.

  • Some rounds are undisclosed. A company can show no disclosed amount, or a round dated the first day of a year. Check the round itself before you trust an amount or a date filter on it.

  • Industry tags are coarse: In one growth lead's view, the hard question is "is this a hardware business or the med device company?" Put the product sentence in the semantic query.

Step 1: How do I get the exact filter values?

Look up the stored labels first, because a filter matches only exact values. Company autocomplete returns those values and is free (pricing).

For my thesis, two lookups mattered:

  • Round types: The stored labels include seed, pre_seed, series_a, series_unknown and undisclosed. If you want pre-seed too, you have to name it.

  • Industries: A search for "Hospital" returned four labels: "Hospitals and Health Care", "Hospitality", "Hospitals" and "Hospital & Health Care". I left industry out of the filters, because the companies I wanted often carry a software label instead.

In Claude with the Crustdata MCP server, you can ask in plain English:




Step 2: How big should the list be before I read it?

Read the count before you pull a single company. A filter-only search returns total_count, so ask for one result and read the number.

My four hard filters (US, 10 to 150 employees, seed or Series A, a round in the past 24 months) matched 4,554 companies, far too many to read. My rule of thumb is a first list you'd read in one sitting, somewhere between 30 and 60 companies. Thousands means the product and buyer lines aren't in the search yet. Under ten usually means one filter, often the round date or headcount ceiling, is too tight.

Step 3: How do I narrow thousands of companies down to the thesis?

Narrow the pool two ways and compare the results, since each misses different companies.

Option A: semantic search on the thesis description

Send the product and buyer lines as the query and keep the hard rules as filters. I sent this search through the Crustdata MCP server in hybrid mode. As a direct API call, it looks like this:

curl --request POST \
  --url https://api.crustdata.com/company/search \
  --header 'authorization: Bearer YOUR_API_KEY' \
  --header 'content-type: application/json' \
  --header 'x-api-version: 2025-11-01' \
  --data '{
    "filters": {
      "op": "and",
      "conditions": [
        {"field": "locations.country", "type": "in", "value": ["USA"]},
        {"field": "headcount.total", "type": "=>", "value": 10},
        {"field": "headcount.total", "type": "=<", "value": 150},
        {"field": "funding.last_round_type", "type": "in", "value": ["seed", "series_a"]},
        {"field": "funding.last_fundraise_date", "type": "=>", "value": "2024-10-28"}
      ]
    },
    "search": {
      "query": "AI software sold to hospitals, health systems and physician practices that automates clinical documentation, prior authorization, or revenue cycle work",
      "mode": "hybrid"
    },
    "fields": [
      "basic_info.name", "basic_info.primary_domain", "basic_info.description",
      "headcount.total", "headcount.growth_percent.6m",
      "funding.last_round_type", "funding.last_fundraise_date", "funding.total_investment_usd",
      "taxonomy.professional_network_industry"
    ],
    "limit": 25
  }'
curl --request POST \
  --url https://api.crustdata.com/company/search \
  --header 'authorization: Bearer YOUR_API_KEY' \
  --header 'content-type: application/json' \
  --header 'x-api-version: 2025-11-01' \
  --data '{
    "filters": {
      "op": "and",
      "conditions": [
        {"field": "locations.country", "type": "in", "value": ["USA"]},
        {"field": "headcount.total", "type": "=>", "value": 10},
        {"field": "headcount.total", "type": "=<", "value": 150},
        {"field": "funding.last_round_type", "type": "in", "value": ["seed", "series_a"]},
        {"field": "funding.last_fundraise_date", "type": "=>", "value": "2024-10-28"}
      ]
    },
    "search": {
      "query": "AI software sold to hospitals, health systems and physician practices that automates clinical documentation, prior authorization, or revenue cycle work",
      "mode": "hybrid"
    },
    "fields": [
      "basic_info.name", "basic_info.primary_domain", "basic_info.description",
      "headcount.total", "headcount.growth_percent.6m",
      "funding.last_round_type", "funding.last_fundraise_date", "funding.total_investment_usd",
      "taxonomy.professional_network_industry"
    ],
    "limit": 25
  }'
curl --request POST \
  --url https://api.crustdata.com/company/search \
  --header 'authorization: Bearer YOUR_API_KEY' \
  --header 'content-type: application/json' \
  --header 'x-api-version: 2025-11-01' \
  --data '{
    "filters": {
      "op": "and",
      "conditions": [
        {"field": "locations.country", "type": "in", "value": ["USA"]},
        {"field": "headcount.total", "type": "=>", "value": 10},
        {"field": "headcount.total", "type": "=<", "value": 150},
        {"field": "funding.last_round_type", "type": "in", "value": ["seed", "series_a"]},
        {"field": "funding.last_fundraise_date", "type": "=>", "value": "2024-10-28"}
      ]
    },
    "search": {
      "query": "AI software sold to hospitals, health systems and physician practices that automates clinical documentation, prior authorization, or revenue cycle work",
      "mode": "hybrid"
    },
    "fields": [
      "basic_info.name", "basic_info.primary_domain", "basic_info.description",
      "headcount.total", "headcount.growth_percent.6m",
      "funding.last_round_type", "funding.last_fundraise_date", "funding.total_investment_usd",
      "taxonomy.professional_network_industry"
    ],
    "limit": 25
  }'

Of the top 25, 17 were clear fits, 4 were partial and 4 were misses, all of them healthcare companies. Two of the misses sold prior-authorization tools to health plans, because my query named the buyer but never excluded insurers.

Option B: keyword filters on the company description

I added the product words as filters on the company description, an OR group of four phrases with the (.) operator, which matches all the words in any order: "revenue cycle", "clinical documentation", "prior authorization" and "medical coding".

The keyword filters cut 4,554 companies to 52: 31 fit, 6 were partial and 15 missed. Seven misses weren't in healthcare at all but legal, marketing, sales and payments software, and most used "revenue" and "cycle" in a sales sense, which the all-words operator matched.

The description filter worked in my test, but basic_info.description isn't in the public list of searchable fields (search reference). Confirm it on your account before you build a standing search on it.

Which one should I use?

Use both. The semantic search finds companies that describe the thesis in other words, and the keyword list is the one a standing search can hold.

The two lists overlapped heavily: 19 of the semantic top 25 were also in the keyword 52. The other six included three clear fits the keywords missed, because their descriptions said "notes" or "charting" in place of "clinical documentation." The keyword list found fits the top 25 never showed, like two pharmacy prior-authorization tools sold to health systems.


Semantic search (Option A)

Keyword filters (Option B)

Companies returned

Top 25 of a ranked list

52, the full match

Clear fits

17

31

Partial

4

6

Misses

4

15

Misses outside healthcare

0

7

Total count available

No

Yes

Can a discovery watch hold it

No

Yes

The fit grades are my read of each description against the thesis.

Step 4: How does Claude score each company against the thesis?

Claude checks the hard gates first, then scores each company on a weighted rubric with one weight per thesis line. You set the weights, so the ranking follows your thesis.

Write the rubric as a file Claude reads. These are the weights I'd start with for the test thesis, and your partners should tune them:

{
  "gates": [
    "sells to hospitals, health systems or physician practices (health plans fail this gate)",
    "sells a software product (services, care delivery and marketplaces fail this gate)",
    "inside the stage, size, country and round-date filters"
  ],
  "weights": {
    "product automates clinical documentation, prior authorization, medical coding, or claims and denials": 25,
    "buyer is named in the description as hospitals, health systems or practices": 15,
    "AI does the work itself (drafts the note, assigns the code, writes the appeal)": 10,
    "a founder has worked inside healthcare, as a physician or running billing, coding or operations": 20,
    "a technical co-founder who has shipped production software or machine learning": 10,
    "six-month headcount growth (headcount.growth_percent.6m) above 15%": 10,
    "a head of sales or VP of sales hired, a move away from founder-led sales": 10
  },
  "unknown_field_rule": "score an empty field as unknown at half credit and say 'unknown' in the reason",
  "output": "score 0-100, then one line of evidence per weighted item"
}
{
  "gates": [
    "sells to hospitals, health systems or physician practices (health plans fail this gate)",
    "sells a software product (services, care delivery and marketplaces fail this gate)",
    "inside the stage, size, country and round-date filters"
  ],
  "weights": {
    "product automates clinical documentation, prior authorization, medical coding, or claims and denials": 25,
    "buyer is named in the description as hospitals, health systems or practices": 15,
    "AI does the work itself (drafts the note, assigns the code, writes the appeal)": 10,
    "a founder has worked inside healthcare, as a physician or running billing, coding or operations": 20,
    "a technical co-founder who has shipped production software or machine learning": 10,
    "six-month headcount growth (headcount.growth_percent.6m) above 15%": 10,
    "a head of sales or VP of sales hired, a move away from founder-led sales": 10
  },
  "unknown_field_rule": "score an empty field as unknown at half credit and say 'unknown' in the reason",
  "output": "score 0-100, then one line of evidence per weighted item"
}
{
  "gates": [
    "sells to hospitals, health systems or physician practices (health plans fail this gate)",
    "sells a software product (services, care delivery and marketplaces fail this gate)",
    "inside the stage, size, country and round-date filters"
  ],
  "weights": {
    "product automates clinical documentation, prior authorization, medical coding, or claims and denials": 25,
    "buyer is named in the description as hospitals, health systems or practices": 15,
    "AI does the work itself (drafts the note, assigns the code, writes the appeal)": 10,
    "a founder has worked inside healthcare, as a physician or running billing, coding or operations": 20,
    "a technical co-founder who has shipped production software or machine learning": 10,
    "six-month headcount growth (headcount.growth_percent.6m) above 15%": 10,
    "a head of sales or VP of sales hired, a move away from founder-led sales": 10
  },
  "unknown_field_rule": "score an empty field as unknown at half credit and say 'unknown' in the reason",
  "output": "score 0-100, then one line of evidence per weighted item"
}

The founder lines carry 30 of the 100 points, because a seed check mostly backs the team. Move weight until the top ten look like companies your partners would meet.

The last weight comes from one person's view. A sourcing lead at a European seed fund called a new "VP of sales or head of sales" hire "super interesting for us." Keep the weight if that matches how your partners think, or drop it.

The scoring prompt checks the gates before it scores:




The same sourcing lead gave our team his rule on false positives: "I rather not see anything than to see something wrong." Strict gates trade a few missed companies for fewer wrong ones.

Spot-check the top ten by hand, because a thin description or a missing founder record can push a good company down.

How do I send each company to the right partner?

Give each partner a short text file of what they want, and have Claude match each company to one. A partner file can be five lines:




Add the partner files to the scoring prompt, and ask Claude to name the partner and the matching line. When two partners fit, Claude lists both.

What if the first list is wrong?

Each wrong company points to a missing gate or a weight in the wrong place. My two lists made the misses easy to sort:

What came back

What to add to the thesis

Prior-authorization tools sold to health plans

A buyer gate for providers only

Legal and sales software matched on "revenue" and "cycle"

The exact-phrase operator [.], or a required healthcare word

Care-delivery services

A gate for software products only

A health IT buyer's marketplace

A gate for companies selling their own product

Write each fix back into the thesis file.

Step 5: How do I keep the list refreshing instead of rebuilding it every quarter?

Set up a discovery watch on the thesis filters, and have Claude score each new company it sends. A Company Discovery Watcher re-checks your filters on a schedule and delivers only the companies that newly match, to a webhook, Slack, Google Chat or email.

To create the watch with the Option B keyword filters, checked weekly:

curl --request POST \
  --url https://api.crustdata.com/watch/company/search \
  --header 'authorization: Bearer YOUR_API_KEY' \
  --header 'content-type: application/json' \
  --header 'x-api-version: 2025-11-01' \
  --data '{
    "filters": {
      "op": "and",
      "conditions": [
        {"field": "locations.country", "type": "in", "value": ["USA"]},
        {"field": "headcount.total", "type": "=>", "value": 10},
        {"field": "headcount.total", "type": "=<", "value": 150},
        {"field": "funding.last_round_type", "type": "in", "value": ["seed", "series_a"]},
        {"field": "funding.last_fundraise_date", "type": "=>", "value": "2024-10-28"},
        {"op": "or", "conditions": [
          {"field": "basic_info.description", "type": "(.)", "value": "revenue cycle"},
          {"field": "basic_info.description", "type": "(.)", "value": "clinical documentation"},
          {"field": "basic_info.description", "type": "(.)", "value": "prior authorization"},
          {"field": "basic_info.description", "type": "(.)", "value": "medical coding"}
        ]}
      ]
    },
    "fields": ["basic_info", "headcount", "funding", "locations"],
    "config": {"trigger": {"type": "interval", "every_hours": 168}, "max_results_per_run": 25},
    "notifications": [{"type": "webhook", "url": "https://your-app.com/webhooks/thesis"}]
  }'
curl --request POST \
  --url https://api.crustdata.com/watch/company/search \
  --header 'authorization: Bearer YOUR_API_KEY' \
  --header 'content-type: application/json' \
  --header 'x-api-version: 2025-11-01' \
  --data '{
    "filters": {
      "op": "and",
      "conditions": [
        {"field": "locations.country", "type": "in", "value": ["USA"]},
        {"field": "headcount.total", "type": "=>", "value": 10},
        {"field": "headcount.total", "type": "=<", "value": 150},
        {"field": "funding.last_round_type", "type": "in", "value": ["seed", "series_a"]},
        {"field": "funding.last_fundraise_date", "type": "=>", "value": "2024-10-28"},
        {"op": "or", "conditions": [
          {"field": "basic_info.description", "type": "(.)", "value": "revenue cycle"},
          {"field": "basic_info.description", "type": "(.)", "value": "clinical documentation"},
          {"field": "basic_info.description", "type": "(.)", "value": "prior authorization"},
          {"field": "basic_info.description", "type": "(.)", "value": "medical coding"}
        ]}
      ]
    },
    "fields": ["basic_info", "headcount", "funding", "locations"],
    "config": {"trigger": {"type": "interval", "every_hours": 168}, "max_results_per_run": 25},
    "notifications": [{"type": "webhook", "url": "https://your-app.com/webhooks/thesis"}]
  }'
curl --request POST \
  --url https://api.crustdata.com/watch/company/search \
  --header 'authorization: Bearer YOUR_API_KEY' \
  --header 'content-type: application/json' \
  --header 'x-api-version: 2025-11-01' \
  --data '{
    "filters": {
      "op": "and",
      "conditions": [
        {"field": "locations.country", "type": "in", "value": ["USA"]},
        {"field": "headcount.total", "type": "=>", "value": 10},
        {"field": "headcount.total", "type": "=<", "value": 150},
        {"field": "funding.last_round_type", "type": "in", "value": ["seed", "series_a"]},
        {"field": "funding.last_fundraise_date", "type": "=>", "value": "2024-10-28"},
        {"op": "or", "conditions": [
          {"field": "basic_info.description", "type": "(.)", "value": "revenue cycle"},
          {"field": "basic_info.description", "type": "(.)", "value": "clinical documentation"},
          {"field": "basic_info.description", "type": "(.)", "value": "prior authorization"},
          {"field": "basic_info.description", "type": "(.)", "value": "medical coding"}
        ]}
      ]
    },
    "fields": ["basic_info", "headcount", "funding", "locations"],
    "config": {"trigger": {"type": "interval", "every_hours": 168}, "max_results_per_run": 25},
    "notifications": [{"type": "webhook", "url": "https://your-app.com/webhooks/thesis"}]
  }'

The watcher docs describe how a watch behaves once it exists:

  • The first check is a free sample. It delivers up to 5 matches so you can check the setup, and records everything that already matches.

  • Later checks send only what's new. Each delivers companies that newly match since the last check, up to max_results_per_run.

  • A check that finds nothing costs nothing. You pay per company delivered.

  • The baseline has a cap. A filter that matches more than 500,000 companies is refused when you create the watch.

Investors who talked to our team asked for a feed like this. The principal quoted earlier told our team, "I want there to be, like, a constant stream of companies coming into our platform." A sourcing operations lead at a US seed fund described what finding a company late costs: "We're really excited about the deal, but we were just like two weeks too late."

Have Claude check every new match, with the thesis, the rubric and a founder search on its domain, before a partner sees it:

  • Drop the matches that fail a gate: A new prior-authorization tool sold to health plans never reaches a partner.

  • Drop duplicates: Skip companies already on your list, in your pipeline or showing up again under a second domain.

  • Add a reason line to every match it keeps: The partner sees the score and the evidence behind it.

A sourcing-project lead at a US pre-seed accelerator told our team why that check matters: "Because the worst thing that I can do is ask a partner to reach out to somebody that it's a false positive."

Will a keyword watch miss companies that fit?

Yes, some. A discovery watch holds filters only and can't take a semantic query, and in my test the keyword filters missed three clear fits the semantic search found. Cover the gap two ways:

  • Repeat the semantic search monthly on the same filters, and add any new fits to your list by hand.

  • Widen the keyword group with the words the missed companies used, like "notes" and "charting," then read what it lets in.

How often should the watch check?

Weekly suits most theses, because a narrow thesis won't produce new matches daily. The interval is every_hours in the watch config, for example 24 for daily or 168 for weekly.

The price depends on the refresh level, how fresh the data behind each notification is (pricing):

Refresh level

Credits per new company

When to pick it

30-day (default)

2

Most theses

1-day, a realtime watch

150

Only when hours matter, like a funding watch on a hot sector

A realtime watch runs on a live search with its own, shorter list of filters, and at most once a day, so check that your filters are supported before you choose it.

A workflow builder at a US growth equity firm made the same point about cadence. With filters as specific as theirs, "there's not going to be 100 new companies every single day that are going to fit everything."

How do I stop seeing companies I've already passed on?

The watch already skips companies it has sent before. For companies already in your pipeline, add their domains to a not_in filter on basic_info.primary_domain when you create the watch. Keep the domain list in a file Claude can read, and rebuild the watch when the list grows a lot, because watch filters are fixed once created.

What happens when my thesis changes?

Create a new watch and cancel the old one. A discovery watch's filters are fixed at creation, while its schedule, notification channels and status can be changed in place (discovery watcher docs). Version the thesis file at the same time.

Step 6: How do I write the first note to a founder?

Have Claude draft the first note from the score's reason lines. Check your CRM for an existing relationship first, keep the draft short, and send it yourself after you've read it:




How do I connect Crustdata to Claude?

There are three routes, and all of them reach the same data.

Option A: Claude Code with the Crustdata MCP server

Add the server from your terminal, then run /mcp inside Claude Code, pick crustdata and sign in (MCP server docs):

claude mcp add --transport
claude mcp add --transport
claude mcp add --transport

Or install the Crustdata plugin, which registers the same server and adds ready-made skills, then sign in with /crustdata:login (plugin docs):




Option B: Claude on the web or the desktop app, with a connector

On a Pro or Max plan, open Customize, then Connectors, click Add, then Add custom connector, and use https://install.crustdata.com/mcp (Anthropic's connector guide). Connectors are account-wide, so Crustdata shows up on claude.ai, Claude Desktop and mobile once it's added (MCP server docs).

On a Team or Enterprise plan, an Owner has to add the custom connector for the organization first, under Organization settings, then Connectors. Members then connect it under Customize, then Connectors. Free plans are limited to one custom connector.

Option C: the API, for a feed inside your own tools

Call Company Search, Person Search and the discovery watch from your code, and send each new match to Claude with the thesis and the rubric. This is the route for a team that wants matches scored automatically and written to its CRM.

How do funds run this at scale?

Funds at scale plug the Crustdata MCP server into the agent they already run, and the agent searches, reads and scores in a fixed call order without anyone typing prompts.

A platform engineer at a large multi-stage fund told our team they had "exposed to your guys' MCP to our agent and just let it rip."

Which Crustdata calls should the agent make first?

Indexed calls first, live calls only when the indexed ones fall short. The order, with list prices from the pricing docs:

  1. Indexed search first. Company Search and Person Search read the indexed database at 0.03 credits a result, plus premium field groups.

  2. Live search only when it misses companies. If a company you know fits is missing, live company search and live people search cost 2 credits a result.

  3. Live enrichment only on the short list. Live person enrichment costs 7 credits a profile, so save it for the founders a partner will meet.

Live company and people endpoints are plan-gated. An agent free to pick any call can use up credits fast, so write the order into its instructions first.

When should a script call the API instead of a chat?

Move to a script once the thesis holds up in chat and you want it searched every week. The script applies the same filters, rubric and call order on a schedule and sends each result to Claude for scoring. Chat stays the place to test a new thesis.

How much does thesis sourcing cost to run?

You pay credits per search result and per company a watch delivers, plus the Claude usage for scoring. Crustdata credits cost $0.30 to $0.01 per credit, lower depending on plan. List prices from the pricing docs:

Step

List price

Autocomplete

Free

Company search

0.03 credits per result, plus 0.2 per result for each premium group you filter on (headcount, funding) and 0.2 for each you get back (taxonomy is 0.1)

Person search

0.03 credits per result, plus 0.1 for experience filtered on, 0.1 for experience returned and 0.1 for education returned

A search with no results

Free

Discovery watch, 30-day refresh

2 credits per new company, first check free

Discovery watch, 1-day refresh

150 credits per new company

My company searches filtered on headcount and funding and pulled them back, so at list price they come to about 67 credits: 25 semantic results at 0.93 each, 52 keyword results at 0.83 each, and two count checks at 0.43 each. The founder search returned 44 records at 0.33 each, about 14.5 credits.

Those list prices at three points on the credit range:


At $0.30 a credit

At $0.17 a credit

At $0.01 a credit

My company searches, 67.27 credits

$20.18

$11.44

$0.67

The founder search, 14.52 credits

$4.36

$2.47

$0.15

A watch sending 10 new companies a month, 20 credits

$6.00

$3.40

$0.20

Your account's own search prices are in the free /account/endpoints response, and your watch prices are in the dashboard's watch builder (pricing docs).

How can I cut the search bill?

Ask only for the fields you'll read, because filtering on a premium group and getting it back are billed separately.

Pulling my 52 companies with basic fields only would cost 0.43 each, about 22 credits, against about 43 with headcount and funding returned. Read the count first with a one-result search, and pull founder records only for companies that pass the company gates.

What should I do after the thesis list is built?

Hand the companies that pass to the next workflow: diligence and the memo for the companies you'll meet, talent-flow checks on who they are hiring, and portfolio monitoring once you invest. Stealth-founder searches cover the people who haven't started a company yet.

Where do I start this week?

Start with one thesis and read the first list yourself before you automate anything, because the first list tells you what the thesis left out.

  1. Write the thesis in two halves, with the buyer and the exclusions spelled out.

  2. Read the count, then add the product and buyer lines until the list fits one sitting.

  3. Run the semantic and keyword searches, then pull the founders of the overlap.

  4. Score the overlap, fix the thesis for every miss, then set up the watch.

You can start on a free Crustdata account or book a demo at crustdata.com.

Frequently asked questions

What is deal sourcing in venture capital?

It is how a fund finds startups to back before their rounds fill up. Funds mix referrals, events and inbound pitches with outbound searches built from their own thesis.

How do I build an investment thesis?

Start from a market you understand and a bet on who wins there. To make it searchable, describe the company (product, buyer, pricing, size, stage, traction) and the founders (background, technical depth, prior companies), then list what's out.

Can alerts work off my criteria, or only a fixed list of companies?

Both, since a discovery watch re-checks your filters and sends companies that newly match, while an entity watch tracks a fixed list you supply for changes (discovery watcher docs).

Does Crustdata have private company revenue?

Crustdata carries estimated revenue ranges you can filter on, in revenue.estimated.lower_bound_usd and revenue.estimated.upper_bound_usd (search reference). Treat them as estimates.

Can I find companies I've never heard of?

Yes, the semantic search matches companies that describe the thesis in their own words, not names your team already knows.

Should I build my own sourcing platform instead?

Build a full platform when your fund sources at high volume with its own scoring model. At very high volume, teams load the data into their own warehouse and score it there rather than through a chat. For one thesis or a few, Claude with a company database gets you a working list this week. Our guide to building deal sourcing, founder discovery and portfolio monitoring tools covers the platform route.

Do VCs actually use Claude for deal sourcing?

Yes, investors who talked to our team describe a wide pull and a model, Claude or another, screening it against the thesis, with a partner reviewing the short list and the model often drafting the first note.

Should I use the MCP or the API, and do I need code?

Use the MCP server to test a thesis in Claude with no code. Claude can do the search, the founder checks and the scoring from plain-English prompts. Move to the API once the search repeats weekly or you want the watch to feed your CRM, because it gives you a call order you control and costs you can predict at volume.

Crustdata is now live in Claude!

Find the best leads, candidates and companies with only a prompt.

Sign In