PitchBook Pricing and Cost: Is There an API Instead?

Copy this line to your agent to look up a company's funding rounds.

set up https://monid.ai/SKILL.md and use crunchbase /search_organizations then /get_company_funding_rounds

No, and the useful part of the answer is not the no. PitchBook sells a licensed seat into a private-markets database, and there is no public API you can sign up for. What matters is which half of what you wanted is reachable another way, so on 2026-09-07 we measured it: the round list comes back, and the money does not. This guide runs through Monid, the OpenRouter for agent tools.

How much does PitchBook cost?

PitchBook does not publish a price, and that fact is the most useful thing to know about its pricing.

The model

It is sold as an annual licence, priced per seat, and quoted after a sales conversation. There is no self-serve tier, no monthly plan, no published rate card and no free API key. Procurement platforms that aggregate what companies actually paid put typical contracts in the tens of thousands of dollars a year, and the spread between a small team and an enterprise is wide. Those figures are other buyers' invoices, not a list price, which is why this article does not repeat one.

Why it is priced that way

The data is hand-researched as well as aggregated, the customers are investors and bankers for whom a wrong valuation costs more than the seat, and an API cheap enough for a developer to script against would replace the product it is bundled with. The price is for the seat, the research team behind it and the redistribution terms, and comparing it to a per-call API is comparing two different purchases.

What people asking about cost usually want

One of three things, and only one of them is what PitchBook sells.

A number to budget. You will not get one from the website. Request a quote, or ask a peer what they paid.

A cheaper way to get valuations and cap tables. There is none. That data is licensed everywhere it exists, and the rest of this article measures exactly how much of it is reachable for free: the round list, not the money.

A funding signal for a prospect list. This is the common case and it does not need PitchBook at all. It needs "did this company raise, how many times, how recently", and that is reachable per call for cents. The sections below are about that.

The honest split

If the question is "how much does PitchBook cost", the answer is "more than a signal is worth and less than a wrong valuation costs", and which of those describes you decides whether you should be reading a quote or reading on. The same seat-versus-call split runs through the B2B data provider comparison.

Does PitchBook have a public API?

Not one you can buy access to as a developer, and the reason is the business rather than the technology.

What PitchBook is

A licensed research product for private markets: funding rounds with amounts, pre and post-money valuations, cap tables, investor lists, fund performance and comparables. It is sold as seats to investors, bankers and corporate development teams, priced accordingly, and the data is manually researched as well as aggregated.

Why there is no open API

The data is the product. An API that let anyone pull valuations and cap tables by the thousand would replace the seat it is sold alongside. Enterprise customers can get data delivery as part of a contract, which is a negotiation rather than a signup, and it comes with redistribution terms.

What people usually actually need

Rarely the cap table. Usually one of: has this company raised recently, how big is it, who invested, and is it growing. Two of those four are reachable from public sources, and knowing which two before you plan a pipeline is the point of the next section.

The honest framing

If your product depends on valuations, licensed data is the only route and no amount of endpoint shopping changes that. If your product depends on funding as a signal rather than a figure, keep reading.

📖 See also Crunchbase API Alternatives for Funding Data

What do the funding endpoints actually return?

Less than the endpoint name promises, and the gap is specific enough to design around.

The measurement

Three calls on 2026-09-07, subject Databricks.

Step one, find the company. crunchbase/search_organizations with query returned three matches, the first carrying a uuid and a short description.

Step two, list the rounds. crunchbase/get_company_funding_rounds with that org_uuid reported count: 17 and returned the page requested. Each round carried exactly three property keys:

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

The types across the returned page: private_equity, private_equity, debt_financing, series_j, series_d.

What is not there. No money_raised. No announced_on. No post_money_valuation. No num_investors. The round exists, it has a type and a name, and that is the whole record.

Step three, try the company profile instead. crunchbase/get_organization_profile with slug returned identifier, short_description, rank_org, categories, location_identifiers, num_employees_enum and status. No funding_total, no last_funding_at, no round count.

So what you get is the shape, not the size

You can say: this company has raised seventeen times, the recent ones include private equity and debt financing, and it is at series J. That is a real signal. You cannot say how much, when, or at what valuation.

Why that distinction matters more than it sounds

A funding signal is enough for most go-to-market work: a company that just raised has budget and is hiring, which is the trigger a prospecting motion needs. We built a whole campaign on exactly that signal rather than on amounts. A funding figure is what you need for valuation comparables or market sizing, and that is the licensed half.

Decide which one your product needs before you build, because the pipeline is completely different and only one of them is affordable.

One thing to watch in the plumbing

Three sibling endpoints on the same provider take three different identifiers for the same company: search_organizations wants query, get_company_funding_rounds wants org_uuid, get_organization_profile wants slug. Passing the wrong one returns a clear 422 naming the field, which is the good kind of failure, but it means every hop needs its own lookup rather than reusing what you already hold.

How do you pull what is available?

Three steps, and the first is free.

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

What it does. Turns a name into the identifier the other endpoints need.

The endpoints. crunchbase/search_organizations, billed per call.

The call.

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

What comes back. Ranked matches with a uuid, a permalink and a short description. Store both the uuid and the permalink, because the next two endpoints want different ones.

What it costs. A couple of cents per call. Current figures at monid.ai/tools.

Step 2. List the rounds

What it does. Gives you the funding history as a sequence of typed events.

The endpoints. crunchbase/get_company_funding_rounds, per call, takes org_uuid and limit.

The call.

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

What comes back. A count and a page of rounds carrying type and identifier. Read count rather than the array length: our call reported 17 and returned 8, because 8 was the limit we asked for.

What it costs. Per call.

Step 3. Assert on the field you actually need

What it does. Stops you building on a field that is never populated.

The call. No endpoint:

ROUND_FIELDS = ("investment_type",)          # present
MONEY_FIELDS = ("money_raised", "announced_on", "post_money_valuation")

sample = rounds[0]["properties"]
missing = [f for f in MONEY_FIELDS if f not in sample]
if missing:
    log.warning("not available from this source: %s", missing)

Run that once, on day one, against a company you know raised large public rounds. If the money fields are absent for Databricks they are absent for everyone, and finding that out before you design a schema saves the week where half your columns are null and nobody knows whether that is the source or the company. It is the same discipline as asserting on values rather than status codes.

📖 See also Turn a Domain Into Full Firmographics

What can you not get at any price here?

Four things, and being clear about them is more useful than another endpoint list.

Amounts and valuations

Not in either endpoint we measured. Round amounts are sometimes disclosed in press releases and regulatory filings, so they are partially reconstructable from news, but they do not arrive as a field.

Cap tables and ownership

Never public. Share classes, liquidation preferences and ownership percentages are the core of what a licensed product sells, and there is no public equivalent.

Fund performance

IRR, TVPI and fund-level returns are private except where a public pension discloses them in its own reporting, which is a slow and partial source.

A source that is reliably up

defillama/pre-ipo/v1/raises looked like a promising second route. It returned HTTP 502 on 2026-09-03 and HTTP 502 again on 2026-09-07, four days apart, so it is persistently down rather than briefly unlucky. Worth knowing before you design a fallback around it, and a reminder to check a second route before you need it, which is the argument in not depending on one vendor.

And a fair one in the other direction: get_company_funding_rounds itself returned HTTP 500 on 2026-09-03 and worked normally on 2026-09-07. That one was transient. The difference between the two is only visible if you measure twice, which is why this article dates every observation.

Which endpoint should I use for which job?

Every row was verified with monid inspect on 2026-09-07. The table gives billing shape rather than figures; shape drives design and current numbers live on monid.ai/tools.

Note the third row is doing a different job than its name suggests in this context. It is a firmographics endpoint, not a funding one, and it is the right call when what you actually need is size band and category rather than money. For richer firmographics there are better routes, compared in the firmographics cost breakdown.

When is the licensed product the right answer?

Three cases, and in all three the answer is to buy the seat.

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

You are an investor doing diligence. Cap tables, share classes and fund performance are the job, and they are exactly what is not public.

You need coverage guarantees. Public aggregation is uneven, particularly outside the US and for rounds nobody announced. If a missing round is a business problem rather than an inconvenience, you need a contract behind the data.

Where the licensed product is overkill is the common case: knowing which companies in a list recently raised, so you can prioritise them. That is a signal, it is reachable, and it costs cents.

And the disclosure: this is Monid's blog and we sell per-call access to the endpoints above. The central finding of this article is that they do not return the field most readers came looking for, which is not a flattering thing to publish about your own catalogue and is the only version worth publishing.

Conclusion

There is no PitchBook API to sign up for, and the substitutes return a specific and predictable half of what you want. Measured on 2026-09-07, the round list came back with a count of 17 and each round carrying its type and nothing else: no amount, no date, no valuation, no investor count. The company profile carried a description and a size band and no funding fields at all.

So the decision is about which question you are asking. Funding as a signal, meaning who raised and how far along they are, is available now and cheap. Funding as a figure, meaning how much and at what valuation, is licensed data and always will be.

Test that on day one rather than on launch day: pull one company you know raised large public rounds and check whether the money fields exist at all. If they are absent for a company that has raised seventeen times, they are absent for your whole list.

Free next step: run monid discover -q "private company funding rounds" and read the field lists before writing any schema. Discovery costs nothing, and the field list is the thing that decides whether a source answers your question. Start at monid.ai.

FAQ

Last updated September 2026.