PitchBook API: Get Funding Round Data Without a Seat

Get a company's funding rounds without a PitchBook seat. Paste this into your agent:

Set up https://monid.ai/SKILL.md, and then use Monid to look up Databricks on Crunchbase, list its funding rounds, and give me a table with the round type, how many rounds it has raised in total, and which fields are missing.

One prompt returns the round list. 1 min setup · 10-20 hrs saved.

You searched for a PitchBook API because you want funding data inside a spreadsheet, a CRM or an agent, not in a browser tab behind a seat. This guide covers what database vendors offer developers, the way to pull round data for a whole list of companies instead, and what that data does and does not contain, tested live on 2026-10-16. The short version: the round list, its count and each round's type come back; the amounts, dates and valuations do not. It runs through Monid, the OpenRouter for agent tools: one key, one balance, every tool priced per call.

Is there a PitchBook API, and what is the easiest way to get its data?

Database vendors such as PitchBook typically sell API access and data feeds as part of a licence rather than as a self-serve key, and the easiest way to pull funding data without a licence is Monid. Install it once, add a key, and your agent resolves a company and lists its funding rounds with no seat, no sales call and no vendor account to set up.

• Pay per call. Each lookup is billed on its own, at $0.02 for the company search and $0.02 for the funding rounds (Verified 2026-10-16 on the company enrichment tools page). Buy calls as you need them: no monthly plan and no minimum top-up. Discovery and inspection are free; only a run bills.
• One install, every tool. The same key and the same balance call funding rounds, firmographics, news and everything else on Monid. When the list needs a website or a contact for each account, it is another call on the same balance, not another vendor.
• Lives inside your agent. Install the CLI, add your key, run the prompt above, and the tools are there whenever your agent needs them, on demand, with nothing to keep running. Your agent reads SKILL.md and learns the rest, so setup is about a minute.

At those prices one company costs $0.04 to look up and list rounds for (Verified 2026-10-16), and a list of 40 companies costs $1.60.

📖 See also Crunchbase API alternatives for funding data

How do you get funding rounds for a list of companies?

Resolve each name to an id, list the rounds for that id, and loop the pair over your list. There are four routes to the data, and the table says which job each one fits.

The per-call route fits a list because the unit of work is one company. Forty accounts is eighty calls, billed as you run them. B2B data provider: dataset or API compares the dataset and API routes in general. The commands below are the two-step chain that returned the data on 2026-10-16.

For agents

Grab an API key at app.monid.ai, then paste this to your agent and hand it the key:

set up https://monid.ai/SKILL.md

It learns the whole discover, inspect, run workflow itself. More in the agent quickstart.

For humans

npm install -g @monid-ai/cli
monid keys add -k <your-api-key> -l main

Step 1. Resolve the company to an id

monid run -p crunchbase -e /search_organizations --query '{"query": "Databricks"}'

The search returned three organizations for Databricks: the company itself, its venture arm, and a consultancy with the name in its title. The first carried uuid b70eee8a-83db-997a-509c-464724b37278 and permalink databricks. Keep both, because the next calls want different ones.

Step 2. List the rounds

monid run -p crunchbase -e /get_company_funding_rounds --query '{"org_uuid": "<uuid>", "limit": 25}'

The response carries a count and a page of rounds. Our call reported count: 17 and returned the 5 we asked for with limit: 5, so read count for the total and size limit to what you need. To run a list, hand the loop to your agent:

Can you scrape PitchBook yourself with Python?

You can try, and it fails in a predictable order. Data sold by the seat usually sits behind a licensed login, so a scraper needs an account that a seat pays for, a session that survives, and pages that are rendered for a signed-in user rather than served to a crawler.

Then comes the rules side. A database sold by the seat usually limits automated extraction and redistribution in its terms, so what you may do with scraped rows depends on your agreement and how you use them. A scraper that works today is also a scraper you maintain: layouts move, sessions expire, and matching a scraped name to the right company is a repair job of its own. The Python route pays off for a one-off look at a handful of pages, and it stops paying off the first time you run it on a schedule.

For anything you will run more than once, Monid is the better pick. The collection is maintained for you, the output is typed JSON instead of HTML you parse, and you pay for the calls you run rather than for a seat. The Python snippet above is the whole integration.

What does funding data look like, and what can you build with it?

Each record is a typed event, not a financial statement. Here is what came back for Databricks on 2026-10-16, in three layers.

The company. The search row carries identifier (name and permalink), short_description, rank_org (303 for Databricks), categories, location_identifiers, num_employees_enum (c_05001_10000) and status (operating).

The round list. count: 17 for Databricks, and a page of rounds. Each round carried exactly three properties:

{
  "identifier": { "value": "Private Equity Round - Databricks", "uuid": "bee9ac2e-..." },
  "investment_type": "private_equity",
  "funded_organization_identifier": { "value": "Databricks", "permalink": "databricks" }
}

The five types on the page were private_equity, private_equity, debt_financing, series_j and series_d.

The presence flags. Each response also includes preview_properties, which marks whether a field exists upstream without returning it. The company row flagged funding_total, last_funding_at and founded_on as present, and each round flagged announced_on and money_raised as present. The values themselves were not in the response.

Three things worth building on that shape:

A funding trigger for outbound. A company with a long round history and a recent series_ type is growing, hiring and has budget. That is the signal a prospecting list needs. Crunchbase Pro against the API by the call weighs the seat against calls for exactly this kind of lookup.

A stage filter for a market map. Group a list of companies by the latest investment_type and you have early, growth and late-stage cohorts without a single valuation.

A watchlist. Store count per company and re-run weekly. A company whose count goes up has raised again.

What goes wrong when you pull funding data for a list?

Five things, and the first one decides whether this route fits your job.

The amounts and dates are flagged present but not returned

The funding rounds endpoint description lists money raised among its fields, and each round's preview_properties flagged money_raised and announced_on as present. The rounds themselves held only identifier, investment_type and funded_organization_identifier. Put the check at the top of your pipeline:

MONEY_FIELDS = ("money_raised", "announced_on", "post_money_valuation")

props = first_round["properties"]   # first item of the entities array
missing = [f for f in MONEY_FIELDS if f not in props]
if missing:
    raise SystemExit(f"not in this response: {missing}")

Run it once, on day one, against a company you know raised large public rounds. If the fields are absent for Databricks they are absent for your whole list, and you find that out before the schema has half its columns empty.

The first search hit is not always the company

The search for Databricks returned three rows, and only the first was the company. The second was its venture fund, ranked 122,895 on rank_org, and the third a consultancy ranked 4,196,855. Matching on the first row works for a distinctive name, so match on the permalink or the website for common ones, and use rank_org to break a tie.

Three endpoints, three identifiers

The search takes a name as query, the rounds endpoint takes org_uuid, and the profile endpoint takes slug. A wrong identifier returns an error naming the field, which is the good kind of failure, but it means each hop needs its own lookup. Store uuid and permalink side by side from the first call.

Read the count, not the array

count was 17 and the array held 5, because 5 was the limit. Code that reads len(entities) as the number of rounds is wrong whenever the page is shorter than the history. If you page, ask for count and size the loop from it.

These calls are slow

The search finished in about 14 seconds and the rounds call in about 26. Budget for it: run lists in parallel batches rather than one at a time, and let an agent wait on the run instead of polling in a tight loop. Forty companies back to back is around half an hour of waiting; ten at a time is a few minutes.

📖 See also Business entity search API

Which endpoint should I use for which job?

Start with the first two, in that order, and treat the third as optional. The profile endpoint's description lists categories, location, employee count, rank and funding status, and its slug is the permalink from the search. The search row already carried most of those fields in our run, so call the profile only when you need a company you resolved by slug. Current prices for all of them are on the company enrichment tools.

When is another route a better fit?

You are producing valuations. Comparables work needs amounts and post-money figures. A signal that a round happened is not an input to that, and the money fields were not in the response.

You are an investor doing diligence. Cap tables, share classes, investor lists and fund performance are what a licensed database sells. None of them came back from these two endpoints.

You need coverage guarantees. Public aggregation is uneven outside the US and for rounds nobody announced. If a missing round is a business problem, a contract with a data vendor is the answer.

You are looking up one company once. A free search or a news article answers a single question faster than setting up a pipeline.

And the disclosure: we resell these endpoints. The most useful finding in this post is that the one field most readers came for, the amount, is the one that did not come back.

Conclusion

A database vendor's API and data feeds usually belong to licensed customers, and the practical way to get funding data into an agent or a spreadsheet without a licence is the two-step chain through Monid: a company search then a rounds call, $0.02 each (Verified 2026-10-16), one key for this and every other tool, about a minute to set up and ready inside your agent whenever you need it. You get the round count and each round's type. You do not get the amounts, dates or valuations.

Two checks matter more than the choice of route. Decide on day one whether your job needs a signal (who raised, how often, what stage) or a figure (how much, at what valuation), because only the first is reachable here. And match on the permalink, not the first search hit, because a company search for a distinctive name still returned a venture arm and a consultancy.

How we estimated the time saved: finding and testing a source, wiring the name-to-uuid-to-rounds chain, and the first month of upkeep are three jobs at roughly 3 to 7 hours each, so 10 to 20 hours. The 1 minute is the install, key and first call once you already have a Monid key.

Free next step: run monid inspect -p crunchbase -e /get_company_funding_rounds, read the field list, then make one small run on a company you know and print the keys of the first round. Start at monid.ai.

FAQ

Published September 2026.