PitchBook Data API: Extract Structured JSON in 2026

This guide covers extracting publicly accessible data. Always review a site's robots.txt and Terms of Service before scraping.

TL;DR

Use AlterLab's Extract API to turn a PitchBook URL into typed JSON. Define a JSON schema for the fields you need (ticker, price, change_percent, volume, market_cap), POST the URL and schema, and receive validated data—no HTML parsing required.

Why use PitchBook data?

PitchBook pages contain structured finance information that powers several workflows:

• AI training: Historical pricing and valuation data improve models for market prediction.
• Analytics: Combine ticker and market cap trends with internal datasets for portfolio analysis.
• Competitive intelligence: Monitor funding rounds, valuations, and ownership changes across private companies.

What data can you extract?

Publicly visible PitchBook pages typically display:

• ticker: Stock symbol (e.g., AAPL).
• price: Current share price.
• change_percent: Percentage change from previous close.
• volume: Number of shares traded.
• market_cap: Total market valuation. These fields appear in consistent HTML structures, making them ideal for schema-based extraction.

The extraction approach

Attempting to parse PitchBook pages with raw HTTP requests and regex or BeautifulSoup is fragile:

• Frequent UI changes break selectors.
• JavaScript‑rendered content requires a headless browser.
• Anti‑bot mechanisms (CAPTCHAs, rate limits) demand rotating proxies and retry logic. AlterLab's Extract API abstracts these challenges. It renders pages with a managed browser, applies anti‑bot bypass, and returns data that matches a JSON schema you provide. The result is typed, ready‑to‑consume JSON—no post‑processing needed.

Quick start with AlterLab Extract API

First, install the AlterLab Python client:

pip install alterlab

Then run a basic extraction. The example below requests ticker, price, and change_percent from a sample PitchBook page.

import alterlab

client = alterlab.Client("YOUR_API_KEY")

schema = {
  "type": "object",
  "properties": {
    "ticker": {
      "type": "string",
      "description": "The ticker field"
    },
    "price": {
      "type": "string",
      "description": "The price field"
    },
    "change_percent": {
      "type": "string",
      "description": "The change percent field"
    }
  }
}

result = client.extract(
    url="https://pitchbook.com/example-page",
    schema=schema,
)
print(result.data)

The call returns a JSON object like:

{
  "ticker": "MSFT",
  "price": "420.15",
  "change_percent": "1.23"
}

For users who prefer cURL, the equivalent request is:

curl -X POST https://api.alterlab.io/v1/extract \
  -H "X-API-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://pitchbook.com/example-page",
    "schema": {"properties": {"ticker": {"type": "string"}, "price": {"type": "string"}, "change_percent": {"type": "string"}}}
  }'

Both examples hit the AlterLab Extract API endpoint documented here. The platform handles rendering, proxy rotation, and schema validation behind the scenes.

Define your schema

Passing a JSON schema gives you two guarantees:

1. Field selection – Only the keys you list appear in the output.
2. Type safety – Values are coerced to the declared type (string, number, boolean) or set to null if extraction fails. A richer schema for all five finance fields looks like this:

schema = {
  "type": "object",
  "properties": {
    "ticker": {"type": "string"},
    "price": {"type": "string"},
    "change_percent": {"type": "string"},
    "volume": {"type": "string"},
    "market_cap": {"type": "string"}
  },
  "required": ["ticker", "price"]
}

Setting "required" ensures critical fields are present; optional fields may be null when the source page omits them. AlterLab validates the extracted payload against this schema before returning it, so downstream code can trust the shape.

Handle pagination and scale

When extracting many PitchBook pages (e.g., a list of company profiles), consider:

• Batching: Group 50‑100 URLs per async job to amortize connection overhead.
• Rate limiting: AlterLab enforces per‑account limits; stay below the threshold to avoid HTTP 429 responses.
• Cost estimation: Use the /v1/extract/estimate endpoint to preview spend before launching a large job. Pricing details are available on the pricing page. Here’s a Python snippet that submits a batch of URLs and polls for completion:

import alterlab, time

client = alterlab.Client("YOUR_API_KEY")
urls = [
    "https://pitchbook.com/company/1",
    "https://pitchbook.com/company/2",
    # … add more
]

jobs = []
for url in urls:
    resp = client.extract(
        url=url,
        schema={"type": "object", "properties": {"ticker": {"type": "string"}}},
        async_=True,
    )
    jobs.append(resp.job_id)

# Poll until all jobs finish
results = []
while len(results) < len(urls):
    for jid in jobs:
        status = client.job_status(jid)
        if status.state == "completed":
            results.append(status.output)
            jobs.remove(jid)
        elif status.state == "failed":
            raise RuntimeError(f"Job {jid} failed")
    time.sleep(2)

print(results)

The async_=True flag tells AlterLab to run the extraction in the background, returning a job ID immediately. This pattern scales to thousands of pages while keeping your script responsive.

Key takeaways

• AlterLab's Extract API converts public PitchBook pages into typed JSON using a schema you define.
• No need to maintain fragile parsers; the platform handles rendering, anti‑bot bypass, and validation.
• Start with a simple schema, test on a single URL, then scale with async jobs and cost estimation.
• Always verify that your extraction complies with PitchBook's robots.txt and Terms of Service.