PitchBook API Documentation and Python Guide (2026)

TL;DR

PitchBook has a REST API, but it is a separate, contract-based Direct Data product rather than a self-serve add-on. PitchBook provisions access with an API key or authentication token and does not publish fixed API prices or a complete public request example. Use it for licensed private-market records. For facts that companies and investors publish openly, the tested ScrapeGraphAI workflow below extracts funding, portfolio news, and company profiles into one CSV.

What is the PitchBook API?

The PitchBook API is a REST interface for bringing selected PitchBook records into an internal system on demand. It belongs to PitchBook Direct Data and requires its own contract. It is not the same thing as logging into the PitchBook Platform, and platform access alone should not be read as API entitlement.

That distinction answers the common question, "Does PitchBook have an API?" Yes, but there is no public signup flow where a developer creates a key and immediately sends a documented request. PitchBook says its Direct Data team works with customers to provision an API key or authentication token and map purchased data into the customer's structure. The public help page exposes the base URL, https://api.pitchbook.com, but not enough of the authenticated request shape to write an honest working example.

So the rest of the page stays in two lanes. The official product gets a source-backed explanation of access, pricing, and delivery. Then a separate public-web workflow collects facts directly from company, investor, and accelerator pages. That workflow never queries PitchBook or tries to reproduce its proprietary database.

PitchBook Platform vs API vs Data Feed

PitchBook sells access to data through different surfaces. They solve related problems, but they are not interchangeable.

Product	How you use it	Delivery pattern	Sensible fit
PitchBook Platform	Analysts search, filter, and read records in PitchBook's interface	Interactive	Research, sourcing, diligence, and ad-hoc analysis
PitchBook API	An application requests selected data on demand	REST and JSON	CRM enrichment, internal tools, and changing queries
PitchBook Data Feed	PitchBook delivers datasets into customer infrastructure	Scheduled .dat, .csv, Parquet, cloud, or database delivery	Warehouses, recurring bulk refreshes, and analytics pipelines

The PitchBook API help page calls the API a separate offering from the Platform that needs a standalone contract. PitchBook's Direct Data page describes the operational split more clearly: the API retrieves specific points when requested, while Data Feed sends files or tables on a schedule.

PitchBook API help page captured July 28, 2026. View the live source.

The choice is mostly about query shape. If a CRM needs one fresh company record when a rep opens an account, an on-demand API is a natural fit. If a data team rebuilds the same company, deal, investor, and fund tables every night, a feed avoids thousands of individual calls. If humans are still deciding which filters matter, the Platform is easier to explore.

PitchBook Direct Data comparison captured July 28, 2026. View the live source.

What data can the API return?

PitchBook's public materials describe a relational private-capital dataset rather than a single company endpoint. The help page mentions financing details, deal stock information, and VC exit-predictor data. Its broader data catalog covers companies, investors, deals, funds, people, limited partners, lenders, debt, credit, and service providers.

Do not convert that catalog into imaginary endpoint names. PitchBook says data for each entity type is packaged across several endpoints and links customers to an endpoint overview after access. The fields your contract permits, their identifiers, and their response relationships belong in the provisioned documentation, not in a guessed tutorial.

Customers are paying for much more than JSON transport. PitchBook maintains normalized records, relationships, historical financing, analyst research, and licensed contact or professional data that may not appear on public pages at all. A public Crunchbase scraping workflow can collect visible funding facts. It does not recreate PitchBook's private-company history or research process.

For an implementation review, ask for a sample response that covers your hardest relationship: for example, one company with several financings, investors, funds, and people. A flat happy-path company record will not tell you how pagination, deleted relationships, corrections, currencies, or point-in-time values behave.

Access, API keys, sandbox, and documentation

Getting API access starts with a commercial conversation. The public instructions tell prospects to contact the Direct Data team. Existing PitchBook customers can request access from Plugins & Apps inside the Platform. PitchBook then helps establish the connection through an API key or authentication token.

That is the complete public authentication picture. It is not enough to publish code with a header name, token exchange, or refresh flow, so this guide does not fabricate one. The same caution applies to a PitchBook API sandbox. PitchBook says customers can test specific endpoints from the Platform, but the public pages do not define a universal sandbox hostname, test credential, or mock-data contract.

Before signing, get written answers to the questions that affect engineering work:

• Which entity types and fields are included in the proposed contract?
• Is access granted by a static API key, a renewable authentication token, or both?
• Where are the provisioned PitchBook API docs and endpoint overview hosted?
• Is there a test environment, and does its schema match production?
• How do pagination, filtering, corrections, and record deletions work?
• What request limits, concurrency rules, and retry guidance apply to this contract?
• May records be stored, enriched, displayed internally, or redistributed?

The last question is not paperwork. A technically successful integration can still violate a data license if the product exposes records to customers or trains models on them. Treat the contract and the PitchBook API documentation as one specification.

PitchBook API pricing and cost

PitchBook does not publish a fixed API price. Its pricing page says pricing varies with seat count, firm type, and premium products such as Direct Data or CRM Integration. The Direct Data page says customers can choose the data they need and pay for that scope. Neither page provides a public dollar figure, quota table, or overage schedule for the API.

Any blog that claims a standard monthly PitchBook API cost is either quoting a private deal, mixing the Platform with Direct Data, or guessing. None is a reliable budget.

Build a quote around the workload instead. Bring these numbers to the sales call:

• entity types and fields required;
• estimated lookups per day and peak concurrency;
• historical backfill size;
• refresh frequency;
• number of internal applications and users;
• retention and redistribution requirements;
• regions and asset classes in scope;
• need for API, Data Feed, or both.

Then ask PitchBook to state what is included: licensed records, request or delivery allowances, support, test access, renewal terms, and charges for more fields or volume. Comparing only the contract total hides the expensive part. A cheaper package that omits one required relationship is not cheaper once your team rebuilds that relationship from other sources.

If you are comparing other sales-led intelligence products, the Similarweb API pricing guide uses the same rule: separate proprietary data value from the delivery mechanism before comparing cost.

When the official PitchBook API is the right tool

Use the official product when the missing information is the product.

• Normalized private-market history. You need financings, ownership, investors, funds, and relationships across time, not one press release.
• Analyst-maintained coverage. Your decision depends on researched records and corrections rather than whatever a company chose to announce.
• Licensed professional data. Your workflow needs contact or people records under a commercial license.
• Consistent identifiers. Several internal systems must join the same companies, deals, funds, and people without fuzzy matching each source.
• Auditability and support. A vendor contract, documented field definitions, and a support path matter more than the lowest extraction cost.

Calling any scraper a blanket "PitchBook API alternative" muddies the decision. A portfolio model that depends on PitchBook's historical, normalized private-market dataset needs that licensed dataset. A scraper supplies a different input with different gaps.

A public-web alternative for market research

Some research jobs start with data that is already public: a company's funding announcement, an investor's latest portfolio news, or an accelerator's public company profile. ScrapeGraphAI can fetch those named sources and return fields that match your Pydantic model.

The products separate cleanly once you name the source:

Need	PitchBook Direct Data	ScrapeGraphAI public-web extraction
Proprietary historical coverage	Yes, subject to contract	No
Normalized cross-source private-market records	Yes	No, you design and review normalization
Analyst research and licensed contacts	Yes, subject to entitlement	No
Facts published on a public page	May include them in PitchBook's dataset	Yes, extracted from the named page
Output shape	Provisioned endpoints and licensed fields	Your JSON Schema or Pydantic model
Access	Sales-led Direct Data contract	Self-serve ScrapeGraphAI key

This is useful for market research scraping, small watchlists, source monitoring, and evidence collection. It is not permission to scrape PitchBook. Never point the workflow at authenticated PitchBook records, evade access controls, or describe public extraction as a way around a license.

The examples below use only three public sources: an Airbyte funding announcement, Accel's portfolio-news page, and Orthogonal's Y Combinator profile.

Set up the tested Python workflow

The final script ran in a clean Python 3.12 environment on July 28, 2026 with scrapegraph-py==2.1.0, pydantic==2.13.4, and pandas==2.3.3. It completed three extractions in three calls. None needed the JavaScript retry.

python -m pip install "scrapegraph-py==2.1.0" "pydantic==2.13.4" "pandas==2.3.3"
export SGAI_API_KEY="your-key"

The key stays in the environment. The companion Colab uses getpass, so it does not echo or save the credential.

Start with schemas that express required fields and keep copied source text apart from your classifications:

from typing import Literal
 
from pydantic import BaseModel, Field
 
 
class FundingEvent(BaseModel):
    company_name: str = Field(min_length=1)
    round_name: str = Field(min_length=1)
    amount_raised: str = Field(min_length=1)
    valuation: str | None = None
    announcement_date: str = Field(min_length=1)
    lead_investors: list[str] = Field(min_length=1)
    participating_investors: list[str] = Field(default_factory=list)
    product_description: str = Field(min_length=20)
    source_title: str = Field(min_length=1)
 
 
class PortfolioActivity(BaseModel):
    company_name: str = Field(
        min_length=1,
        description="First company or paired label at the start of the headline",
    )
    source_category: str = Field(min_length=1)
    normalized_event_type: Literal[
        "investment", "acquisition", "merger", "funding", "other"
    ]
    headline: str = Field(min_length=1)
    publication_date: str = Field(min_length=1)
    article_url: str = Field(min_length=1)
 
 
class InvestorActivity(BaseModel):
    investor_name: str = Field(min_length=1)
    latest_items: list[PortfolioActivity] = Field(min_length=5, max_length=5)
 
 
class Founder(BaseModel):
    name: str = Field(min_length=1)
    title: str = Field(min_length=1)
    background_summary: str | None = None
 
 
class CompanyProfile(BaseModel):
    company_name: str = Field(min_length=1)
    one_sentence_description: str = Field(min_length=20)
    batch: str = Field(min_length=1)
    status: str = Field(min_length=1)
    location: str | None = None
    team_size: int | None = Field(default=None, ge=1)
    founders: list[Founder] = Field(min_length=1)
    website_url: str | None = None
    primary_partner: str | None = None

The helper below performs one normal extraction. It retries once with the documented JavaScript fetch configuration only if the request fails or Pydantic rejects required data. Provenance comes from the input and the clock, not from the model.

import json
import os
from datetime import datetime, timezone
from typing import Any
 
from scrapegraph_py import FetchConfig, ScrapeGraphAI
 
 
def parse_json_data(response: Any) -> Any:
    data = response.data.json_data
    return json.loads(data) if isinstance(data, str) else data
 
 
def extract_validated(
    client: ScrapeGraphAI,
    *,
    url: str,
    prompt: str,
    model: type[BaseModel],
) -> dict[str, Any]:
    errors: list[str] = []
 
    for attempt, fetch_config in enumerate(
        [None, FetchConfig(mode="js", stealth=True, wait=2000)],
        start=1,
    ):
        try:
            options = {"url": url, "schema": model.model_json_schema()}
            if fetch_config is not None:
                options["fetch_config"] = fetch_config
 
            response = client.extract(prompt, **options)
            if response.status != "success":
                raise RuntimeError(f"extract returned status={response.status}")
 
            validated = model.model_validate(parse_json_data(response))
            return {
                "source_url": url,
                "retrieved_at": datetime.now(timezone.utc).isoformat(),
                "attempts": attempt,
                "data": validated.model_dump(mode="json"),
            }
        except Exception as error:
            errors.append(f"attempt {attempt}: {error}")
 
    raise RuntimeError("; ".join(errors))
 
 
client = ScrapeGraphAI(api_key=os.environ["SGAI_API_KEY"])

Workflow 1: extract a funding event

This call asks for claims made in Airbyte's announcement. It preserves the displayed currency strings instead of pretending $1.5b is a clean numeric valuation.

airbyte = extract_validated(
    client,
    url="https://airbyte.com/blog/a-150m-series-b-to-power-the-movement-of-data",
    model=FundingEvent,
    prompt=(
        "Extract the funding event stated on this public company announcement. "
        "Return only facts explicitly visible on the page: company, round, amount, "
        "valuation if stated, announcement date, lead investors, participating "
        "investors, a concise product description, and the page title. Preserve "
        "the currency shown by the source. Do not infer missing facts."
    ),
)

The July 28 run returned Airbyte, Series B, $150M, a stated $1.5b valuation, and December 20, 2021. It identified Altimeter Capital and Coatue Management as leads, with Thrive Capital, Salesforce Ventures, Benchmark, Accel, and SV Angel participating. Those are source claims, not values backfilled from PitchBook.

Workflow 2: extract investor activity

Investor pages mix exact labels with interpretation. Accel labels every row here Portfolio News; that label alone does not prove an investment or acquisition. The prompt therefore requests both the exact category and a constrained normalized event.

accel = extract_validated(
    client,
    url="https://www.accel.com/news/portfolio",
    model=InvestorActivity,
    prompt=(
        "Read this public investment-firm portfolio news page. Return the investor "
        "name and exactly the first five visible portfolio-news items in page order. "
        "For every item, use the first company or paired label at the start of the "
        "headline as company_name, then extract the exact source category, exact "
        "headline, displayed publication date, and absolute article URL. Normalize "
        "the event into investment, acquisition, merger, funding, or other. Use other "
        "when the headline does not support a narrower classification. Do not guess."
    ),
)

The source-checked run found Cyera + Oasis, Paper, Arrakis, Cognition, and Oak as the first five items. Cognition Acquires TierZero supported acquisition. Cyera + Oasis: Securing the AI-Native Enterprise stayed other. That restraint matters more than filling every row with a confident label.

Workflow 3: extract a company profile

The final call reads a public Y Combinator profile. Founder titles and biographies are separate fields on purpose.

orthogonal = extract_validated(
    client,
    url="https://www.ycombinator.com/companies/orthogonal",
    model=CompanyProfile,
    prompt=(
        "Extract this public Y Combinator company profile. Return only facts visible "
        "on the page: company name, one-sentence description, YC batch, status, "
        "location, team size, founders and their explicit title, a separate "
        "background summary when stated, company website, and primary YC partner. "
        "Do not put employment history in the title field. Do not infer missing data."
    ),
)

On July 28, the page yielded Orthogonal, Winter 2026, Active, San Francisco, a team size of two, founders Christian Pickett and Bera Sogut, and primary partner Tyler Bosmeny. Public profiles change. The stored URL and UTC retrieval time tell a reviewer which source version the row reflects.

What a valid schema can still get wrong

Pydantic checks structure. It cannot know that the model placed a true sentence in the wrong field.

The first founder schema in the preflight used one broad role field. The extraction put prior employment, including Vercel, Coinbase, Google, and Amazon Robotics, into that field. The JSON was valid. The meaning was not. Splitting it into title and background_summary, then telling the prompt that a title is a displayed position such as Founder, corrected the mapping.

Use the same review pattern in production:

1. Inspect several real records before trusting a batch.
2. Keep copied source values separate from normalized or inferred fields.
3. Add constraints only where the source has a stable contract.
4. Reject missing required values, but allow genuinely optional facts to stay None.
5. Save the source URL and retrieval time beside every record.

Schema validation prevents broken shapes. It does not replace source checking.

Export one public-market-intelligence CSV

The final step maps the three schemas into a common table. The CSV keeps record type, company, event, date, amount, valuation, investors or people, status, location, source, and retrieval time. Empty cells remain empty rather than being invented.

import pandas as pd
 
records = [
    {
        "record_type": "funding_event",
        "company_name": airbyte["data"]["company_name"],
        "event_type": airbyte["data"]["round_name"],
        "event_date": airbyte["data"]["announcement_date"],
        "amount_raised": airbyte["data"]["amount_raised"],
        "valuation": airbyte["data"]["valuation"],
        "investors_or_people": "; ".join(
            airbyte["data"]["lead_investors"]
            + airbyte["data"]["participating_investors"]
        ),
        "status": "",
        "location": "",
        "source_url": airbyte["source_url"],
        "retrieved_at": airbyte["retrieved_at"],
    }
]
 
for item in accel["data"]["latest_items"]:
    records.append(
        {
            "record_type": "investor_activity",
            "company_name": item["company_name"],
            "event_type": item["normalized_event_type"],
            "event_date": item["publication_date"],
            "amount_raised": "",
            "valuation": "",
            "investors_or_people": accel["data"]["investor_name"],
            "status": item["source_category"],
            "location": "",
            "source_url": item["article_url"],
            "retrieved_at": accel["retrieved_at"],
        }
    )
 
records.append(
    {
        "record_type": "company_profile",
        "company_name": orthogonal["data"]["company_name"],
        "event_type": orthogonal["data"]["batch"],
        "event_date": "",
        "amount_raised": "",
        "valuation": "",
        "investors_or_people": "; ".join(
            f'{founder["name"]} ({founder["title"]})'
            for founder in orthogonal["data"]["founders"]
        ),
        "status": orthogonal["data"]["status"],
        "location": orthogonal["data"]["location"] or "",
        "source_url": orthogonal["source_url"],
        "retrieved_at": orthogonal["retrieved_at"],
    }
)
 
frame = pd.DataFrame.from_records(records)
frame.to_csv("public_market_intelligence.csv", index=False)
 
round_trip = pd.read_csv("public_market_intelligence.csv")
assert len(frame) == 7
assert frame["company_name"].str.len().gt(0).all()
assert frame["source_url"].str.startswith("https://").all()
assert len(round_trip) == len(frame)
assert os.environ["SGAI_API_KEY"] not in frame.to_csv(index=False)

The clean run produced seven readable rows: one funding event, five investor-activity records, and one company profile. If a source redesign causes a required field to disappear, the helper makes one JavaScript-rendered retry and then fails with both attempt errors. It does not silently write a partial row.

For a larger pipeline, add URL allowlists, source-specific review rules, stable record IDs, raw-response retention, and diffs against the last successful run. The web scraping API guide covers the extraction layer. The lead generation scraping guide covers the extra consent and accuracy problems that appear when market research turns into prospecting.

Run it in Google Colab

The public PitchBook API public-web alternative notebook contains the pinned install, hidden key input, all three schemas, the retry helper, the source calls, CSV assertions, and download cell. It is shared as view-only to anyone with the link. The published file was anonymously downloaded and parsed before this badge was added.

Copy the notebook to your Drive before editing it. Rerun all cells when you need current data because Accel's news list and accelerator profiles are dynamic. A saved July 28 snapshot is evidence that the workflow ran, not a promise that the same facts will remain on the pages.

Production, privacy, and source rights

Public does not mean unrestricted. Check source terms, robots directives, applicable privacy law, retention needs, and whether your output will stay internal or be redistributed. Use reasonable request rates and collect only fields your workflow needs. The web scraping legality guide is a starting point, not legal advice.

Do not use this code against authenticated PitchBook pages. Do not reuse a PitchBook session cookie, evade a paywall, or blend PitchBook-derived records into the public-source output. If your product needs PitchBook data, negotiate the Direct Data rights and use the provisioned documentation.

For public research, keep evidence close to every row. A market database without source URLs and retrieval dates becomes a pile of plausible facts that nobody can audit. That is especially risky for funding amounts, people, and investment activity, where corrections and role changes are normal.

Common PitchBook API questions

Does PitchBook have an API?

Yes. PitchBook offers a REST API through Direct Data. It is a separate, contract-based product, not an automatically included self-serve feature of the PitchBook Platform.

Where can I find the PitchBook API docs?

The public PitchBook API help page explains the product, base URL, and access process. Complete endpoint and authentication details are provisioned to customers. The public material is not sufficient for a truthful request example.

How do I get a PitchBook API key?

Contact the Direct Data team or, if you are already a customer, request API access through Plugins & Apps in the PitchBook Platform. PitchBook says it establishes access through an API key or authentication token.

Is there a public PitchBook API sandbox?

PitchBook says customers can test specific endpoints inside the Platform, but its public pages do not document a universal sandbox URL or public test credential. Ask what test environment is included in your proposed contract.

How much does the PitchBook API cost?

There is no public fixed price. PitchBook says pricing varies by customer needs and premium offerings such as Direct Data. Request a quote based on required datasets, volume, delivery method, users, retention, and licensing rights.

Can ScrapeGraphAI replace PitchBook?

Not for proprietary private-market history, analyst research, normalized relationships, or licensed contacts. It can structure facts from public company, investor, accelerator, and news pages when those sources are the data you actually need.

Related Articles

• Best Crunchbase Scraper: Company and Funding Data
• Lead Generation Scraping: Build Better Prospect Data
• Market Research Scraping: From Public Pages to Evidence
• Similarweb API Pricing: What Developers Actually Pay
• Web Scraping API Guide for Developers
• Is Web Scraping Legal?