# PitchBook Public Profile Scraper (`khadinakbar/pitchbook-scraper`) Actor

Extract public PitchBook profile and research metadata from supplied URLs. No account, cookies, CAPTCHA solving, or third-party API is used.

- **URL**: https://apify.com/khadinakbar/pitchbook-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** AI, Lead generation, MCP servers
- **Stats:** 3 total users, 0 monthly users, 90.5% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 public record extracteds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## PitchBook Public Profile Scraper

PitchBook Public Profile Scraper is an Apify Actor for investors, researchers, operations teams, and AI agents that already have public PitchBook profile, research, or news URLs. It accepts supplied HTTPS URLs and saves one dataset record per validated public URL. Each record represents public metadata exposed by the reachable page or by an exact-match public Google result, including entity type from the URL path, source and canonical URLs, page title, public description, public image URL when exposed, published timestamp when present, retrieval method, and scrape timestamp. The outcome is a structured dataset of public PitchBook metadata, plus run-level output and summary records for automation and review.

### Best fit and connected workflows

Use this Actor when your workflow starts with known public PitchBook URLs and you want a compact, provenance-aware metadata extract.

This Actor fits well into workflows such as:

- collecting public PitchBook metadata for internal research notes
- enriching a lead list that already contains PitchBook URLs
- routing public profile, research, or news URLs into an Apify dataset for downstream AI processing
- using public metadata as an input signal in an Apify MCP workflow for agents that need URL-level provenance

PitchBook Public Profile Scraper is designed as a focused workflow.

### Practical scenario

A research analyst receives a list of public PitchBook company profile URLs from a colleague. They paste the URLs into `profileUrls`, set `maxItems` to the number of URLs they want processed, and run the Actor. The dataset returns `sourceUrl`, `canonicalUrl`, `title`, `description`, `retrievalMethod`, and `scrapedAt` for each saved public record. The analyst then uses `retrievalMethod` to separate direct public-page metadata from public Google metadata before passing the records into a CRM enrichment step.

### Input

Provide public PitchBook URLs that you already have. The Actor accepts up to 25 HTTPS URLs, with a default processing cap of 10 accepted URLs.

| Field | Type | Purpose |
| --- | --- | --- |
| `profileUrls` | array of strings | Public PitchBook profile, research, or news URLs to process |
| `maxItems` | integer | Sets the number of accepted URLs to process, from 1 to 25 |
| `useApifyProxy` | boolean | Uses Apify Residential proxy for the initial direct request to a public PitchBook URL |
| `useGoogleSearchFallback` | boolean | Uses exact-match public Google metadata fallback when direct public HTML is unavailable |

#### Focused JSON input example

```json
{
  "profileUrls": [
    "https://pitchbook.com/profiles/company/127635-40"
  ],
  "maxItems": 1,
  "useApifyProxy": true,
  "useGoogleSearchFallback": true
}
```

### Output

The Actor saves validated public metadata records to the dataset and also writes `OUTPUT` and `RUN_SUMMARY` to the key-value store. The dataset is the main record output. `OUTPUT` provides the terminal run outcome, and `RUN_SUMMARY` contains detailed telemetry, including billed event counts and access-block details when present.

| Field | Type | Meaning |
| --- | --- | --- |
| `entityType` | string | Type inferred from the public PitchBook URL path |
| `sourceUrl` | string | The public PitchBook URL that was requested |
| `canonicalUrl` | string | Canonical URL declared by the publicly reachable page, or the supplied source URL when absent |
| `title` | string or null | Public HTML title or Open Graph title |
| `description` | string or null | Public meta or Open Graph description |
| `imageUrl` | string or null | Public Open Graph image URL when exposed |
| `publishedAt` | string or null | Publication timestamp exposed in public HTML metadata |
| `retrievalMethod` | string | `direct` or `google-serp` |
| `scrapedAt` | string | ISO 8601 timestamp when the record was saved |

#### Illustrative output record

```json
{
  "entityType": "company",
  "sourceUrl": "https://pitchbook.com/profiles/company/127635-40",
  "canonicalUrl": "https://pitchbook.com/profiles/company/127635-40",
  "title": "Example Co - PitchBook",
  "description": "Example company summary.",
  "imageUrl": "https://images.example/logo.png",
  "publishedAt": "2026-07-22T12:00:00Z",
  "retrievalMethod": "direct",
  "scrapedAt": "2026-07-22T12:00:00.000Z"
}
```

### How it works

The Actor follows a two-route public metadata flow:

1. It requests each supplied public PitchBook URL directly.
2. If the public page is unavailable through that route and the fallback is enabled, it queries the exact URL identifier through Apify's Google SERP proxy and accepts only a result whose destination exactly matches the supplied URL.
3. It stores only public metadata exposed in page HTML or public search metadata.
4. It writes the validated record to the dataset and records run outcome details in the key-value store.

The live contract defines two charged events: `apify-actor-start` for initialization and public URL validation, and `public-record-extracted` for each validated public metadata record saved to the dataset.

### Pricing

PitchBook Public Profile Scraper uses Pay per event plus Apify platform usage. The live Pricing tab in the Apify Console is the source of truth for current charges.

Billing is event-based:

- one actor start event per run
- one public record extracted event per validated public metadata record saved

Example: if a execution processes three public URLs and saves three validated records, the execution includes one start event and three record events.

Check the live Pricing tab for current Pay per event details and Apify platform usage information before running at scale.

### Use with AI agents (MCP)

This Actor is usable through Apify MCP as a tool for retrieving public PitchBook metadata from known URLs. The exact Actor identity is `khadinakbar/pitchbook-scraper`.

Tool description:

- accepts public PitchBook profile, research, and news URLs
- returns one dataset record per validated public metadata result
- exposes provenance through `retrievalMethod`, `sourceUrl`, and `canonicalUrl`
- supports processing up to 25 supplied URLs with `maxItems`
- supports cost control through the accepted URL count and the live Pay per event model

> Extract public metadata for these PitchBook URLs and return one record per URL. Keep the provenance fields so I can tell whether each record came from a direct page or the exact-match public Google fallback.

Output interpretation:

- `direct` means the record came from the public PitchBook page
- `google-serp` means the record came from an exact-match public Google result
- `sourceUrl` identifies the URL you supplied
- `canonicalUrl` identifies the canonical URL exposed by the public page when available
- `scrapedAt` shows when the record was saved

Provenance, scope, pagination, and cost guidance:

- supply only public URLs that are already known
- use `maxItems` to match the number of URLs you want processed
- review the live Pricing tab for current Pay per event plus Apify platform usage details
- the dataset contains only validated public metadata records saved during the run

### Apify API example

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({
  token: process.env.APIFY_TOKEN,
});

const input = {
  profileUrls: [
    'https://pitchbook.com/profiles/company/127635-40',
  ],
  maxItems: 1,
  useApifyProxy: true,
  useGoogleSearchFallback: true,
};

const run = await client.actor('khadinakbar/pitchbook-scraper').call(input);

const { items } = await client.dataset(run.defaultDatasetId).listItems({
  clean: true,
  format: 'json',
});

console.log('Run ID:', run.id);
console.log('Dataset items:', items);
```

### Best results and outcome guidance

Start with public PitchBook URLs that already resolve to public pages. Keep the URL list focused on known records, use `maxItems` to match the intended processing count, and inspect `retrievalMethod` alongside `canonicalUrl` when combining records from multiple public sources.

When the direct page route is available, the output reflects public HTML or Open Graph metadata. When the fallback route is used, the output remains limited to publicly indexed title and description metadata from an exact-match public result.

### Continue the workflow

- Then use [Polymarket Leaderboard Scraper](https://apify.com/khadinakbar/polymarket-leaderboard-scraper) to extend PitchBook Public Profile Scraper with a neighboring market research source when the brief calls for Polymarket data.
- Then use [Google Finance Scraper | Stocks, Crypto & Market Data](https://apify.com/khadinakbar/google-finance-stock-news-scraper) to extend PitchBook Public Profile Scraper with a neighboring market research source when the brief calls for Google Finance data.

### Design note

I found that the output contract separates dataset records from run-level telemetry: `records` points to the dataset, while `output` and `runSummary` point to key-value store entries. That makes the dataset the record source of truth and the other two outputs execution metadata.

### FAQ

#### Can I use this Actor with public PitchBook news or research URLs?

Yes. The input contract accepts public PitchBook profile, research, or news URLs as long as they are HTTPS URLs you supply.

#### How do I tell whether a record came from the page or from public search metadata?

Check `retrievalMethod`. `direct` means the public page was used, and `google-serp` means the exact-match public Google fallback was used.

#### What happens if I supply fewer URLs than `maxItems`?

The Actor processes the URLs you provide. `maxItems` sets the maximum number of accepted URLs to process.

#### Does the dataset include private PitchBook fields?

The dataset contract exposes public metadata only: title, description, image URL, canonical URL, published timestamp when present, and related record metadata.

#### Can this Actor be used in an Apify MCP workflow?

Yes. It is an Apify Actor that can be called through Apify MCP as a tool for public PitchBook URL metadata extraction.

### Responsible use

Use only public URLs and data you are authorized to access and use. This Actor is designed for public metadata extraction from supplied URLs and for workflow automation around public records.

# Actor input Schema

## `profileUrls` (type: `array`):

Use this when you already have public PitchBook profile, research, or news URLs. Enter up to 25 HTTPS URLs such as https://pitchbook.com/profiles/company/127635-40. When direct public HTML is unavailable, the optional Google fallback can recover only publicly indexed title and description metadata. The actor rejects login, dashboard, and private subscription URLs.

## `maxItems` (type: `integer`):

Use this when limiting cost and run time. Sets the number of accepted URLs to process, from 1 to 25; default 10. It is not a search-results limit because this actor does not discover or crawl private PitchBook pages.

## `useApifyProxy` (type: `boolean`):

Use this for the initial direct request to a public PitchBook URL. The default true sends an ordinary unauthenticated request through Apify Residential proxy. It does not log in, persist cookies, solve CAPTCHAs, or circumvent access controls. Disable only when testing direct Apify-cloud access.

## `useGoogleSearchFallback` (type: `boolean`):

Use this when PitchBook blocks the direct unauthenticated request. The default true queries the exact URL identifier through Apify's Google SERP proxy and accepts only a result whose destination exactly matches the supplied URL. It returns public indexed title and description metadata, not private PitchBook fields. Disable to require direct-page extraction only.

## Actor input object example

```json
{
  "profileUrls": [
    "https://pitchbook.com/profiles/company/127635-40"
  ],
  "maxItems": 1,
  "useApifyProxy": true,
  "useGoogleSearchFallback": true
}
```

# Actor output Schema

## `records` (type: `string`):

Validated public PitchBook URL metadata saved during this run. Blocked pages create no data row.

## `output` (type: `string`):

Terminal run outcome with counts and a diagnostic message.

## `runSummary` (type: `string`):

Detailed final telemetry, including access blocks and billed event counts.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "profileUrls": [
        "https://pitchbook.com/profiles/company/127635-40"
    ],
    "maxItems": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/pitchbook-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "profileUrls": ["https://pitchbook.com/profiles/company/127635-40"],
    "maxItems": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/pitchbook-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "profileUrls": [
    "https://pitchbook.com/profiles/company/127635-40"
  ],
  "maxItems": 1
}' |
apify call khadinakbar/pitchbook-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/pitchbook-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/AUNBd9g5ZZk4E4YzN/builds/2umH6XWQrBuz2Xh2D/openapi.json