# CalPERS Private Equity Fund Returns Scraper (`parseforge/public-pension-pe-returns-scraper`) Actor

Scrape CalPERS private equity and private debt fund performance: vintage, commitments, cash flows, net IRR and multiple, with DPI and TVPI computed.

- **URL**: https://apify.com/parseforge/public-pension-pe-returns-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.90 / 1,000 private equity fund rows

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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?

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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### CalPERS Private Equity Fund Returns Scraper: IRR, TVPI

**Scrape all 466 CalPERS private equity funds and 64 private debt funds, fund by fund, with vintage year, capital committed, cash in, cash out, net IRR and investment multiple.** Every row also carries DPI, TVPI, RVPI and unfunded commitment, which CalPERS does not publish and this Actor computes from the cash flows. No login or API key. Export to CSV, JSON, Excel, or XML.

CalPERS is the largest public pension in the United States and it publishes fund level performance as a plain HTML table that nobody can filter, sort by vintage, or export. This Actor reads that table, filters it on the raw record, computes the multiples an LP actually uses, and adds two roll-ups: one row per manager and one row per vintage year.

| Who uses it | What they scrape fund performance for |
|---|---|
| Limited partners | Benchmarking a GP against every other fund of the same vintage |
| Secondaries buyers | Finding funds with high residual value and a long call history |
| Fund of funds and consultants | Building a manager track record from a public source |
| Investor relations at GPs | Seeing exactly what a public LP discloses about their fund |
| Journalists and researchers | Eighteen years of public pension private markets returns |

### What it does

This Actor collects the CalPERS private equity and private debt performance tables and returns each fund as a flat row. Every row carries:

- 🧾 **Fund core:** fund name, programme, vintage year, fund age, capital committed, cash in, cash out, cash out plus remaining value.
- 📈 **Published returns:** net IRR and investment multiple, with a flag for the funds CalPERS marks as too young to measure.
- 🧮 **Computed multiples:** DPI, TVPI, RVPI, remaining value and net gain, from the published cash flows.
- 💰 **Commitment math:** unfunded commitment, called percentage, distributed percentage and a fully called flag.
- 🏢 **Manager parse:** manager, fund family and fund sequence number, so Fund VII lines up with Fund VI.
- 📊 **Vintage benchmark:** the median net IRR of the fund's vintage, the gap against it, and whether the fund beats it.

Results export to CSV, JSON, Excel, or XML, or stream from the API.

### What you can do with public pension PE data

**📐 Benchmark a manager against its vintage.**

Turn on the vintage benchmark and every fund row carries the median net IRR of its vintage year and the distance to it. That is the comparison an investment committee asks for, in one column.

**🔎 Screen for secondaries.**

Residual value to paid-in, remaining value in dollars and the called percentage are all on the row. A filter on vintage plus RVPI is a shortlist of positions that still have value left to run.

**🏗️ Build a GP track record.**

The manager summary rolls every fund of a manager into one row: fund count, first and latest vintage, committed capital, commitment weighted net IRR, DPI and TVPI.

**📉 Study a bad vintage.**

The vintage summary gives you fund count, committed capital, TVPI and the median, best and worst IRR of every year, which is the shape of a cycle in one table.

### Why choose this scraper

| | What you get |
|---|---|
| The full universe | 466 private equity funds and 64 private debt funds, not a sample |
| Multiples CalPERS omits | DPI, TVPI and RVPI computed from the published cash flows |
| Two roll-ups | One row per manager and one row per vintage year, computed across the whole table |
| Honest sentinels | Funds CalPERS marks N/M are flagged, not silently turned into zero |
| Filters before billing | Vintage, committed capital, IRR range, fund name and manager run on the raw record |
| No key, no login | The source is a public page, so there is nothing to register |

### How it compares

There is no other Apify Actor that reads public pension fund level performance. The commercial alternatives are Preqin, PitchBook and Pregin-style databases, which license the same public disclosures back to you inside an annual contract. The trade off is coverage: they aggregate hundreds of LPs, this Actor reads one, and it reads it completely and for a few dollars a run.

| | This Actor | Preqin and PitchBook | Reading the page yourself |
|---|---|---|---|
| Fund level IRR and multiple | Yes | Yes | Yes |
| DPI, TVPI, RVPI | Computed | Yes | No |
| Vintage benchmark | Computed | Yes | No |
| LPs covered | CalPERS | Hundreds | One page at a time |
| Cost | A few dollars per run | Annual licence | Free and unusable at scale |

### What a fund row looks like

```json
{
  "rowType": "fund",
  "pension": "CalPERS",
  "program": "Private Equity Program",
  "fundName": "57 Stars Global Opportunities Fund 2 (CalPERS), LLC",
  "vintageYear": 2009,
  "fundAgeYears": 17,
  "capitalCommittedUsd": 500000000,
  "cashInUsd": 530736052,
  "cashOutUsd": 539723168,
  "cashOutAndRemainingValueUsd": 735901763,
  "netIrrPct": 5.3,
  "investmentMultiple": 1.4,
  "returnsMeasurable": "Yes",
  "reportAsOf": "December 31, 2025",
  "dpi": 1.017,
  "tvpi": 1.387,
  "rvpi": 0.37,
  "remainingValueUsd": 196178595,
  "netGainUsd": 205165711,
  "unfundedCommitmentUsd": 0,
  "calledPct": 106.15,
  "distributedPctOfCommitment": 107.94,
  "fullyCalled": "Yes",
  "managerName": "57 Stars Global Opportunities",
  "fundFamily": "57 Stars Global Opportunities Fund 2 (CalPERS)",
  "vintageMedianNetIrrPct": 5.3,
  "netIrrVsVintageMedianPct": 0,
  "beatsVintageMedian": "Yes",
  "sourceUrl": "https://www.calpers.ca.gov/investments/about-investment-office/investment-organization/pep-fund-performance",
  "scrapedAt": "2026-08-28T20:11:42.774Z"
}
```

### Configure the run

Pick what you want in **Data to scrape**, then filter. Filters run on the full fund record before the row is built, so you can screen by net IRR without buying the benchmark block. When you select several datasets the row cap is split between them.

Every fund, with the computed multiples:

```json
{
  "datasets": ["privateEquity", "privateDebt"],
  "includeMultiples": true,
  "includeCommitmentMath": true,
  "maxItems": 600
}
```

Post 2015 vintages that beat 15% net IRR:

```json
{
  "datasets": ["privateEquity"],
  "minVintageYear": 2015,
  "minNetIrr": 15,
  "onlyMeasurableReturns": true,
  "includeVintageBenchmark": true,
  "maxItems": 200
}
```

A manager track record and the vintage context around it:

```json
{
  "datasets": ["managerSummary", "vintageSummary"],
  "managerContains": "Blackstone",
  "maxItems": 100
}
```

### Pricing

Pay per event. You are charged per row written, plus one event per performance page scanned and one start event per run.

| Event | Price |
|---|---|
| Actor start | $0.02 per run |
| Performance table scanned | $0.01 per page |
| Private equity and private debt fund rows | $0.01 per row |
| Manager and vintage summary rows | $0.008 per row |
| DPI/TVPI, commitment math and vintage benchmark blocks | $0.003 per row each |
| Manager parse block | $0.002 per row |

| Rows | Typical cost |
|---|---|
| 100 fund rows | $1.03 |
| 530 fund rows, the whole universe | $5.33 |
| 530 fund rows with all four blocks | $11.16 |

Volume tiers apply: Bronze pays 3.8% less, Silver 7.4% less, Gold and above 11% less.

### Free users

Free Apify accounts get a 10 row preview per run, which is enough to check the schema and the field names. [Upgrade to a paid plan](https://apify.com/pricing?fpr=vmoqkp) to lift the cap to a million rows per run.

### Run it

1. Create a free [Apify account](https://apify.com/?fpr=vmoqkp). New accounts get $5 in free credit.
2. Open the Actor, leave the default input, and press Start to see ten funds.
3. Add your filters, tick the blocks you want, then raise Max Items to 600 for the full universe.
4. Export the dataset to CSV, JSON, Excel or XML, or read it from the API.

### Use with AI agents (MCP)

```
claude mcp add apify --transport sse https://mcp.apify.com/sse --header "Authorization: Bearer YOUR_APIFY_TOKEN"
```

Then ask in plain language:

- "Which CalPERS private equity funds from 2018 or later beat a 20% net IRR?"
- "Give me the manager summary for every GP with more than three CalPERS funds."
- "What was the median net IRR of the 2019 vintage, and which funds beat it?"

### Troubleshooting

**Net IRR says Not Disclosed.** CalPERS prints N/M for funds too young for a meaningful return, and for the entire private debt programme. The `returnsMeasurable` flag tells you which rows those are, and the multiples block still computes DPI and TVPI from the cash flows.

**Fewer rows than I asked for.** The whole universe is 530 funds. Above that, the only extra rows are the manager and vintage summaries.

**A manager name looks wrong.** The manager is parsed from the fund name, which is the only place it appears. Fund families with unusual naming can parse imperfectly; the raw `fundName` is always on the row.

**The as-of date is missing on private debt rows.** The private debt page does not carry an as-of line. The private equity page does, and it is on every private equity row.

**No rows came back.** A net IRR filter drops every fund CalPERS marks N/M, which is most recent vintages. Turn the IRR filter off to see them.

### FAQ

| Question | Answer |
|---|---|
| Which pension is covered? | CalPERS, the California Public Employees Retirement System, private equity and private debt programmes. |
| Will other pensions be added? | They are on the roadmap. Most other large systems publish fund performance only as an annual PDF, which is a different build. |
| How current is the data? | CalPERS refreshes the table quarterly. The row carries the as-of date it publishes, currently December 31, 2025. |
| What is DPI, TVPI and RVPI? | Distributed, total value and residual value over paid-in capital. This Actor computes all three from cash in, cash out and remaining value. |
| Why is IRR missing on private debt? | CalPERS publishes the column but prints N/M for every private debt fund. Measured: zero percentage values in the whole table. |
| Can I filter by IRR without buying a block? | Yes. Filters run on the raw record before projection. |
| Does it need a proxy? | No. The source answers plain HTTP requests. |
| How fast is it? | Measured at 921 rows in 11 seconds with a 158 MB peak. |

### Related actors

- [SEC Form D Scraper](https://apify.com/parseforge/sec-form-d-scraper?fpr=vmoqkp) for the private fund offerings these managers file.
- [SEC 13F Holdings Scraper](https://apify.com/parseforge/sec-13f-holdings-scraper?fpr=vmoqkp) for the public side of the same institutions.
- [ICSID Arbitration Cases Scraper](https://apify.com/parseforge/icsid-arbitration-cases-scraper?fpr=vmoqkp) for investor state disputes.
- [GAO Bid Protest Docket Scraper](https://apify.com/parseforge/gao-bid-protest-docket-scraper?fpr=vmoqkp) for federal procurement disputes.
- [Securities Class Action Filings Scraper](https://apify.com/parseforge/securities-class-action-filings-scraper?fpr=vmoqkp) for litigation risk on portfolio companies.

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

Need help? Email parseforge@protonmail.com with your run ID, your input, and what you expected.

Disclaimer: this is an unofficial tool, not affiliated with CalPERS. It reads only the performance tables CalPERS publishes without a login. The data is about funds and firms, not individuals, so it carries no personal data under GDPR, CCPA or PIPL.

# Actor input Schema

## `datasets` (type: `array`):

Fund level rows from the CalPERS private equity and private debt programs, plus two roll-ups computed from them: one row per manager and one row per vintage year.

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

Free users: limited to 10 items (preview). Paid users: up to 1,000,000.

## `minVintageYear` (type: `integer`):

Keep only funds whose vintage year is this or later, for example 2015.

## `maxVintageYear` (type: `integer`):

Keep only funds whose vintage year is this or earlier.

## `minCapitalCommitted` (type: `number`):

Keep only funds with at least this much committed, in dollars. Decimals are honoured.

## `minNetIrr` (type: `number`):

Keep only funds at or above this net IRR, in percent. Funds too young to have a meaningful return are dropped by this filter.

## `maxNetIrr` (type: `number`):

Keep only funds at or below this net IRR, in percent. Use a negative number to find the losers.

## `fundNameContains` (type: `string`):

Case-insensitive substring on the fund name, for example 'Blackstone' or 'Growth'.

## `managerContains` (type: `string`):

Case-insensitive substring on the manager name parsed from the fund name, for example 'Carlyle'.

## `onlyMeasurableReturns` (type: `boolean`):

Drop funds where CalPERS prints N/M because the fund is too young for a meaningful IRR.

## `includeMultiples` (type: `boolean`):

Adds distributed to paid-in, total value to paid-in, residual value to paid-in, remaining value and net gain. CalPERS does not publish these; they are computed from the cash flows.

## `includeCommitmentMath` (type: `boolean`):

Adds unfunded commitment, called percentage, distributed percentage of commitment and a fully called flag.

## `includeManagerParse` (type: `boolean`):

Splits the fund name into manager, fund family and fund sequence number, so successive funds of the same family line up.

## `includeVintageBenchmark` (type: `boolean`):

Adds the median net IRR of the fund's vintage year across the whole programme, the difference against it, and whether the fund beats it.

## Actor input object example

```json
{
  "datasets": [
    "privateEquity"
  ],
  "maxItems": 10,
  "onlyMeasurableReturns": false,
  "includeMultiples": false,
  "includeCommitmentMath": false,
  "includeManagerParse": false,
  "includeVintageBenchmark": false
}
```

# Actor output Schema

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

No description

## `csv` (type: `string`):

No description

# 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 = {
    "datasets": [
        "privateEquity"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/public-pension-pe-returns-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 = {
    "datasets": ["privateEquity"],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/public-pension-pe-returns-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 '{
  "datasets": [
    "privateEquity"
  ],
  "maxItems": 10
}' |
apify call parseforge/public-pension-pe-returns-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/public-pension-pe-returns-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/wzxBlu7EAZQpnBYE3/builds/Xq47qnj8o3mXmAmYT/openapi.json