# PitchBook Private Fund Profile Extractor (`dataspryva/pitchbook-private-fund-profile-extractor`) Actor

Collect PitchBook fund profiles by URL, keyword search, or in bulk, with fund size, vintage year, strategy, status, manager and limited-partner counts for each fund.

- **URL**: https://apify.com/dataspryva/pitchbook-private-fund-profile-extractor.md
- **Developed by:** [Dataspryva](https://apify.com/dataspryva) (community)
- **Categories:** Lead generation, Automation, Other
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## PitchBook Private Fund Profile Extractor

PitchBook publishes a free preview of every fund profile: who manages it, when it was raised, its strategy, status, reported size, where it is domiciled, a handful of portfolio deals and a handful of limited partners. This actor reads those public pages without a login, so you can turn a list of funds, a keyword or the public fund index into a structured dataset.

### Three ways to collect funds

| Mode | How to trigger it | What happens |
| --- | --- | --- |
| **Direct** | Add one or more `profileUrls` (full links or bare IDs such as `11295-73F`). | Every listed fund is fetched and returned. `maxItems` does not limit this mode. |
| **Keyword** | Leave `profileUrls` empty and enter a `searchQuery`. | PitchBook's public best match is tried first; then public fund profiles are scanned until `maxItems` matches are found. |
| **Sitemap** | Leave both `profileUrls` and `searchQuery` empty. | Fund profile URLs are streamed from PitchBook's public fund sitemap, filtered, and returned up to `maxItems`. |

Optional filters work in all three modes: fund type, status, category, country/region, vintage range, fund-size range and a free-text filter. Filtering happens on the already-fetched public record, so no extra requests are made.

### What you get per fund

| Field | Meaning |
| --- | --- |
| `name` | Fund name. |
| `profileUrl` | Canonical PitchBook fund profile URL. |
| `description` | Public fund summary. |
| `fundStrategy` | Published strategy, for example Buyout or Venture Capital. |
| `fundStatus` | Lifecycle state, for example Liquidated or Open. |
| `fundSize` | Reported fund size exactly as published, for example `$6.11B`. |
| `fundSizeMillions` | The same size converted to millions of the fund's native currency. |
| `vintageYear` | Year the fund was raised. |
| `fundCategory` | Asset class, for example Private Equity or Venture Capital. |
| `fundFamily` | Fund family or series name, when published. |
| `fundManager` | Managing firm. |
| `fundManagerUrl` | PitchBook investor-profile URL for the manager. |
| `fundManagerWebsite` | Manager's external website. |
| `fundDomiciles` | Legal domicile jurisdiction(s). |
| `nativeCurrency` | Reporting currency. |
| `totalInvestments` | Total number of investments shown in the section heading. |
| `totalLimitedPartners` | Total number of limited partners shown in the section heading. |
| `investments` | Public preview rows: company name, company URL, deal date, deal type, industry and company stage. Most funds publish five rows. |
| `limitedPartners` | Public preview rows: LP name, LP URL, type, status, commitment date and commitment type. Most funds publish five rows. |
| `streetAddress`, `postalCode`, `city`, `state`, `country` | Manager address, as published. |
| `logoUrl` | Manager logo image URL. |
| `socialLinks` | Manager social profiles, when published. |
| `scrapedAt` | ISO timestamp for the capture. |

Fields the profile does not publish are left out of that record. A failed lookup produces a record with `type`, `inputUrl`, `error` and `scrapedAt`, so failures remain visible. If every fetch in a run is blocked, a single `pitchbook_fund_blocked` diagnostic record is written instead of an empty dataset.

### Inputs

| Input | Type | Default | Notes |
| --- | --- | --- | --- |
| `profileUrls` | String list | – | Fund links or bare IDs. Takes priority over the other source fields. |
| `searchQuery` | String | – | Fund name, manager or strategy keyword. |
| `maxItems` | Integer | 3 | Output cap for keyword and sitemap modes. |
| `fundTypes` | Multi-select | – | Keep only these published strategies. |
| `fundStatuses` | Multi-select | – | Keep only these lifecycle states. |
| `fundCategories` | Multi-select | – | Keep only these asset classes. |
| `countries` | String list | – | Country or region names, matched against country and domicile. |
| `minVintage` / `maxVintage` | Integer | – | Vintage-year bounds. |
| `minFundSize` / `maxFundSize` | Number | – | Size bounds in millions of native currency. |
| `searchText` | String | – | All words must appear in the fund's public text fields. |

#### Examples

Fetch two known funds:

```json
{
  "profileUrls": ["11295-73F", "https://pitchbook.com/profiles/fund/10909-00F"]
}
```

Find liquidated buyout funds:

```json
{
  "searchQuery": "buyout europe",
  "maxItems": 20,
  "fundStatuses": ["Liquidated"],
  "minVintage": 1995,
  "maxVintage": 2010
}
```

Sample recent venture funds from the public index:

```json
{
  "maxItems": 50,
  "fundTypes": ["Venture - General", "Venture Capital - Early Stage"],
  "minVintage": 2018
}
```

### How the public data is reached

Profile pages are served to anonymous visitors with browser-grade TLS. The actor starts with a direct request; if PitchBook blocks that route it moves to Apify Proxy's datacenter pool and only then to residential addresses. You do not need to configure a proxy, and no PitchBook account or cookie is required.

### Use cases

- **LP and fund-of-funds research** — compare fund sizes and vintages across a manager's series.
- **Deal sourcing** — build lists of active funds in a strategy, region or vintage range.
- **CRM enrichment** — add manager website, address and domicile to existing fund records.
- **Portfolio mapping** — collect the public investment preview for a set of funds.
- **Market scans** — sample the public fund index and filter it down to a target profile.

### FAQ

**Do I need a PitchBook subscription?**
No. The actor reads only the free profile preview pages that PitchBook serves to anonymous visitors.

**Why are IRR, DPI, RVPI and TVPI missing?**
PitchBook renders those performance figures as locked placeholders on public profiles. They are not readable without a subscription, so the actor does not invent them.

**Why do investment and LP lists have five rows?**
PitchBook publishes a five-row preview for most funds. The `totalInvestments` and `totalLimitedPartners` fields give the full counts, while the arrays contain the public preview rows.

**How complete is keyword search?**
PitchBook's public endpoint returns one best match per query. To find more than one fund, the actor also scans public fund profiles for the same keywords. Direct URLs are the most precise option; the sitemap mode is best for broad sampling.

**Can I get more than 100,000 funds in one run?**
The public fund sitemap lists more than 150,000 profiles. Raise `maxItems` to collect more, but expect a longer run and larger dataset.

**How do I tell a fund link from an investor link?**
Fund profile IDs end in `F` (for example `11295-73F`). Investor IDs do not have that suffix.

**Is this affiliated with PitchBook?**
No. This is an independent tool and is not affiliated with, endorsed by, or sponsored by PitchBook Data, Inc.

# Actor input Schema

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

PitchBook fund profile links or bare IDs (for example https://pitchbook.com/profiles/fund/11295-73F or 11295-73F). When supplied, every listed fund is processed and the other source fields are ignored.

## `searchQuery` (type: `string`):

Fund name, manager or strategy keyword, for example 'Sequoia Capital Fund XV', 'growth equity' or 'buyout europe'. PitchBook's public best match is tried first, then public profiles are scanned for more matches. Used only when no profile URLs are supplied.

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

Upper limit on fund records returned. Direct-URL runs process every listed URL; search and sitemap runs stop once this many funds match.

## `fundTypes` (type: `array`):

Keep only funds whose published strategy matches one of these types. Leave empty for all types.

## `fundStatuses` (type: `array`):

Keep only funds in one of these lifecycle states, for example Liquidated or Open.

## `fundCategories` (type: `array`):

Keep only funds in one of these asset classes.

## `countries` (type: `array`):

Keep funds whose country or domicile contains any of these names, for example United States, Europe or Germany.

## `minVintage` (type: `integer`):

Minimum vintage year. Leave empty for no lower bound.

## `maxVintage` (type: `integer`):

Maximum vintage year. Leave empty for no upper bound.

## `minFundSize` (type: `number`):

Minimum published fund size in millions of the fund's native currency (6.11B becomes 6110). Leave empty for no lower bound.

## `maxFundSize` (type: `number`):

Maximum published fund size in millions of the fund's native currency. Leave empty for no upper bound.

## `searchText` (type: `string`):

Keep funds whose name, manager, description, strategy, category or location contains all of these words.

## Actor input object example

```json
{
  "profileUrls": [
    "11295-73F"
  ],
  "maxItems": 3
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset containing scraped fund profile records

# 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": [
        "11295-73F"
    ],
    "maxItems": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("dataspryva/pitchbook-private-fund-profile-extractor").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": ["11295-73F"],
    "maxItems": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("dataspryva/pitchbook-private-fund-profile-extractor").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": [
    "11295-73F"
  ],
  "maxItems": 3
}' |
apify call dataspryva/pitchbook-private-fund-profile-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dataspryva/pitchbook-private-fund-profile-extractor"
        }
    }
}
```

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/A1RXyx68EtpLlajuD/builds/tJfl0X7ez7lhSRi3g/openapi.json
