# General Atlantic Investments Report — Target Book (`nexgenwatch/general-atlantic-investments-report`) Actor

Filtered, normalized target book of General Atlantic's published investments, with coverage stated and a source link per company.

- **URL**: https://apify.com/nexgenwatch/general-atlantic-investments-report.md
- **Developed by:** [NexGen Watch](https://apify.com/nexgenwatch) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $33.50 / 1,000 portfolio company records

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

## General Atlantic Investments Report

Build a **filtered, normalized target book of General Atlantic's published investments**, with
a link to GA's own page behind every company.

Built for deal sourcing, competitive mapping and BD teams who need a workable list.

### Coverage is the headline, not the footnote

Every report states, in the record **and** on the first line of the brief:

```
universe_total       406     investments General Atlantic publishes
companies_examined   150     investments this run actually read
coverage_complete    false
coverage_caveat      "maxCompanies=150 bounded the sweep to the first 150 of 406"
```

**A company missing from a partial book has not been ruled out — it was never read.** Raise
`maxCompanies` toward 406 for a complete book; budget about a minute per 120 investments.

### Three things measured live that a naive read gets wrong

#### 1. `/investments/` serves 24 of 406, and its pagination is fake

The page is server-rendered and its 24 rows are real. But GA publishes **406** investments,
and every attempt to page or filter returns the identical first 24 — control vs test,
2026-07-31:

```
/investments/                    -> 24 rows, first = Grupo Águilas
/investments/page/2/             -> 24 rows, first = Grupo Águilas
/investments/page/3/             -> 24 rows, first = Grupo Águilas
/investments/page/17/            -> 24 rows, first = Grupo Águilas
/investments/page/18/            -> 24 rows, first = Grupo Águilas
/investments/?sector=technology  -> 24 rows, first = Grupo Águilas
```

The server ignores both. **This actor never reads that page**, and offers no filter that
depends on it — selling a parameter the source discards is selling a lie.

#### 2. The list API carries no attributes

`/wp-json/wp/v2/investment` returns all 406 with title, slug, canonical link and dates — but
`acf` is `[]` and no taxonomy is registered for the `investment` type. Sector, region and year
invested exist **only** on each investment's own page, so the book is built list-then-detail.

#### 3. An optional field sits in the middle of the record row

```
Company | Description | Sector | Region | Year Invested
<description> | [View Site] | <sector> | <region> | <year>
```

`View Site` is present on some companies and absent on others. A parser that counts positions
from the header is **off by one on every company without a website link** — it reports the
*region* as the sector. Values are located by anchoring on the four-digit year and walking
backwards, and both traps are asserted against verbatim excerpts of live pages.

### What this source does not carry

**Exit status is not available.** `Year Exited` appears on the 24-row listing but on no
individual investment page, so a 406-company book cannot state it. This actor **does not guess
one**, and says so in every report rather than leaving you to assume every company is still
held.

### Filters

| filter | what it does |
|---|---|
| `sectors` | Technology, Financial Services, Consumer, Healthcare, Life Sciences, Energy Transition |
| `regions` | United States, EMEA, China, Latin America, India, Southeast Asia |
| `yearInvestedFrom` / `yearInvestedTo` | year range, 2000–2026 in the measured corpus |
| `nameContains` | free text across company name and GA's own description |
| `maxCompanies` | how much of the 406 to read — **default 150, a partial sweep** |

Filtering runs here, over parsed fields, because the site's own filter is measurably ignored.
Every parameter therefore provably changes the result set, proven control-vs-test in the
suite.

Each report returns `vocabularies_in_examined_set` — the sectors and regions **counted from
the investments this run read**, not a hard-coded list. (For the record: GA's own site
navigation lists an *Infrastructure* sector, and no investment in the 406 carries it.)

### Output

- one `investment` record per match — name, description, sector, region, year invested, and
  the GA URL it came from
- one `investments_report` record — the filter, coverage numbers, vocabularies
- one `source_receipt` — terminal, HTTP statuses, request counts, pacing
- a rendered markdown brief in the key-value store

### Reading policy

`generalatlantic.com/robots.txt` is a **zero-byte file** — no rules at all. This actor paces
itself at **2 requests/second** anyway, with a contact User-Agent. **The rate is not an
input.**

### Pricing

| Event | FREE | BRONZE | SILVER | GOLD+ |
|---|---|---|---|---|
| Actor Start (`apify-actor-start`) | $0.02 | $0.02 | $0.02 | $0.02 |
| Portfolio company record (`portfolio-company-record`) | $0.05 | $0.045 | $0.04 | $0.0335 |

Prices are the filed pay-per-event amounts per plan tier (PLATINUM/DIAMOND match GOLD). Blocked and refused runs do not intentionally charge value events.

# Actor input Schema

## `sectors` (type: `array`):

Keep only investments General Atlantic tags with one of these sectors, e.g. Technology, Healthcare, Financial Services, Consumer, Life Sciences. Case-insensitive. Leave empty for every sector. The vocabulary the run actually saw is reported back in vocabularies\_in\_examined\_set.

## `regions` (type: `array`):

Keep only these regions as GA publishes them, e.g. United States, EMEA, India, Southeast Asia, Latin America, China. Leave empty for every region.

## `nameContains` (type: `string`):

Free text kept only if it appears in the company name or General Atlantic's own description.

## `yearInvestedFrom` (type: `integer`):

Earliest year of investment, inclusive. Companies with no published year are excluded when this is set.

## `yearInvestedTo` (type: `integer`):

Latest year of investment, inclusive. Companies with no published year are excluded when this is set.

## `maxCompanies` (type: `integer`):

The sweep reads this many investments at 2 requests/second. General Atlantic published 406 when this build was measured, so the default of 150 is a PARTIAL sweep and the report says so on its first line. Raise it toward 406 for a complete book — expect roughly one minute per 120 investments.

## Actor input object example

```json
{
  "sectors": [
    "Healthcare"
  ],
  "maxCompanies": 150
}
```

# Actor output Schema

## `results` (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 = {
    "sectors": [
        "Healthcare"
    ],
    "maxCompanies": 150
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgenwatch/general-atlantic-investments-report").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 = {
    "sectors": ["Healthcare"],
    "maxCompanies": 150,
}

# Run the Actor and wait for it to finish
run = client.actor("nexgenwatch/general-atlantic-investments-report").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 '{
  "sectors": [
    "Healthcare"
  ],
  "maxCompanies": 150
}' |
apify call nexgenwatch/general-atlantic-investments-report --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexgenwatch/general-atlantic-investments-report"
        }
    }
}

```

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/gvpD8igVRTt5KBb0L/builds/dvegNrexrVU7VRluY/openapi.json