# A16z Speedrun Companies Scraper (`automation-lab/a16z-speedrun-companies-scraper`) Actor

Export public a16z Speedrun companies, cohorts, industries, locations, profile links, and founder team roles for accelerator research and investment sourcing.

- **URL**: https://apify.com/automation-lab/a16z-speedrun-companies-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 item extracteds

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

## A16z Speedrun Companies Scraper

Export **a16z Speedrun companies** as structured records for accelerator landscape research, investment sourcing, and portfolio monitoring.

The Actor reads the public Speedrun company directory and returns company identity, cohort, industry, location, team size, profile and social links, plus nested founder names, biographies, LinkedIn URLs, and team roles. Use directory filters or supply exact public company profile URLs.

### What does this Actor do?

A16z Speedrun Companies Scraper turns the public accelerator directory into integration-ready JSON, CSV, Excel, or other Apify dataset formats.

It can:

- browse the current public company directory;
- search names, summaries, descriptions, and industry labels;
- select one or more cohort codes;
- filter by exact industry, region, country, or team-size range;
- extract one or more supplied Speedrun company profile URLs;
- include public founder and team-role records inside each company result;
- cap output for predictable runs and recurring snapshots.

It does not enrich records from private databases or guess missing contact details.

### Who is it for?

- **Investors and scouts** building an accelerator sourcing list.
- **Accelerator researchers** comparing cohorts, sectors, and geographies.
- **Portfolio operations teams** taking scheduled snapshots for downstream change detection.
- **Founders and market analysts** mapping companies and public founder roles.
- **Data teams** loading a normalized Speedrun dataset into a warehouse, spreadsheet, CRM, or notebook.

### Why use it?

The directory is useful for browsing, but repeated research benefits from a stable row contract.

This Actor provides:

- one default-dataset row per matching company;
- the public source ID and canonical profile URL for deduplication;
- nested public founder/team-role data without a separate charge event;
- identical filters for discovered and explicitly supplied company URLs;
- bounded retries on temporary API failures;
- direct public JSON extraction without a browser or proxy.

### What data can I extract?

| Field | Meaning |
| --- | --- |
| `companyId`, `slug`, `name` | Stable public company identity |
| `profileUrl` | Canonical Speedrun company profile |
| `cohort` | Published cohort code such as `SR003` |
| `industries` | Published industry labels |
| `foundedYear`, `teamSize` | Published company year and team size, when present |
| `country`, `region`, `state`, `city` | Published geography |
| `preamble`, `description`, `keySignal` | Public profile narrative fields |
| `websiteUrl` | Company website |
| `linkedinUrl`, `xUrl`, `githubUrl` | Published company social links |
| `logoUrl`, `coverImageUrl` | Public image URLs; images are not downloaded |
| `demoDayVideoUrl` | Published Demo Day video URL, when present |
| `founders` | Nested founder names, roles, introductions, LinkedIn and profile image URLs |
| `scrapedAt` | UTC timestamp for the snapshot |

Missing optional source values are returned as `null`; list fields are returned as arrays.

### Getting started

1. Open the Actor in Apify Console.
2. Leave company URLs empty to search the directory, or add exact `/companies/<slug>` profile URLs.
3. Add cohort, industry, geography, search, or team-size filters if needed.
4. Set **Maximum companies** for the size of the snapshot.
5. Click **Start**.
6. Open the **Dataset** tab and export results as JSON, CSV, Excel, XML, or RSS.

The prefilled input extracts a real public profile and is suitable for a small first run.

### Input parameters

| Input | Type | Default | Description |
| --- | --- | --- | --- |
| `startUrls` | array | empty | Exact public `https://speedrun.a16z.com/companies/<slug>` URLs |
| `search` | string | empty | Case-insensitive company/description/industry text search |
| `cohorts` | string array | empty | Exact cohort codes; matches any selected value |
| `industries` | string array | empty | Exact public industry labels; matches any selected value |
| `regions` | string array | empty | Exact Speedrun region labels |
| `countries` | string array | empty | Exact published country names |
| `minTeamSize` | integer | empty | Minimum published team size |
| `maxTeamSize` | integer | empty | Maximum published team size |
| `maxItems` | integer | `100` | Maximum saved companies, from 1 to 1,000 |

All supplied filters also apply to `startUrls`. Unknown profile slugs produce no row rather than unrelated directory results.

### Input examples

Search for public AI-related profiles:

```json
{
  "search": "AI",
  "maxItems": 10
}
```

Extract one exact company profile:

```json
{
  "startUrls": [
    { "url": "https://speedrun.a16z.com/companies/2weeks" }
  ],
  "maxItems": 1
}
```

Take a cohort snapshot:

```json
{
  "cohorts": ["SR006"],
  "maxItems": 50
}
```

### Output example

A current exact-profile run returns a record shaped like this:

```json
{
  "companyId": "91edd679-b699-4a39-8695-a7a8decb9398",
  "slug": "2weeks",
  "name": "2weeks",
  "profileUrl": "https://speedrun.a16z.com/companies/2weeks",
  "cohort": "SR003",
  "industries": ["Gaming"],
  "foundedYear": 2024,
  "teamSize": 4,
  "country": "United States of America",
  "region": "America/Canada",
  "city": "New York",
  "websiteUrl": "https://2weeks.games",
  "founders": [
    {
      "name": "Brandon Dillon",
      "role": "CEO and Co-Founder",
      "linkedinUrl": "https://www.linkedin.com/in/noughtceratops/"
    }
  ],
  "scrapedAt": "2026-08-31T21:13:15.623Z"
}
```

The actual record includes all schema fields and every founder published by the source.

### How much does it cost to export a16z Speedrun companies?

This Actor uses pay per event:

- a one-time **Start** event per run;
- one **Item processed** event per saved company.

Nested founders and team roles are included in the company item and do not create a separate charge event. Volume tiers automatically reduce the per-company price.

| Apify tier | Price per saved company |
| --- | ---: |
| FREE | $0.0067068 |
| BRONZE | $0.005832 |
| SILVER | $0.004549 |
| GOLD | $0.0034992 |
| PLATINUM | $0.0023328 |
| DIAMOND | $0.001633 |

The start event is $0.005. At the BRONZE item price, 1 saved company costs about $0.010832, 10 cost about $0.06332, and 100 cost about $0.5882. Filters that return no companies incur only the start event. Platform compute may also count against your Apify plan according to Apify's billing rules.

### Monitoring accelerator cohorts

For recurring portfolio monitoring:

1. save a Task with a cohort filter and a stable `maxItems`;
2. schedule it daily, weekly, or monthly;
3. export each dataset to cloud storage or a warehouse;
4. compare by `companyId` to identify new, removed, or changed public records.

The Actor creates snapshots. It does not itself send alerts or calculate historical diffs.

### Integration patterns

- Send the dataset to Google Sheets with an Apify integration.
- Trigger a webhook when a run finishes and ingest rows into a CRM.
- Join `cohort`, `industries`, and geography in a BI dashboard.
- Store `companyId` and `scrapedAt` in a warehouse for longitudinal comparisons.
- Use founder `role` and `linkedinUrl` fields in a public-profile research workflow.

Avoid treating missing public values as evidence that a company has no such attribute.

### Run with the Apify API

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~a16z-speedrun-companies-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"cohorts":["SR006"],"maxItems":50}'
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/a16z-speedrun-companies-scraper').call({
  search: 'AI',
  maxItems: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token='YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/a16z-speedrun-companies-scraper').call(
    run_input={'startUrls': [{'url': 'https://speedrun.a16z.com/companies/2weeks'}], 'maxItems': 1}
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

Keep tokens in environment variables or a secret manager, not in source code.

### Use with Apify MCP

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/a16z-speedrun-companies-scraper"
```

#### Claude Desktop, Cursor, and VS Code

Use this equivalent configuration in Claude Desktop, Cursor, or VS Code:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/a16z-speedrun-companies-scraper"
    }
  }
}
```

Example prompts:

- “Run the a16z Speedrun scraper for SR006 and summarize industries by company count.”
- “Extract the 2weeks Speedrun profile and list each published founder role.”
- “Find up to 20 Speedrun profiles related to AI and save the dataset URL.”

### Limits and reliability

- Coverage is limited to records currently exposed by the public Speedrun directory.
- The source can add, remove, or rename fields and filter labels.
- A company may omit team size, geography, social links, biographies, or other optional values.
- Search is a substring match over current public text; it is not semantic search.
- The Actor retries temporary network, rate-limit, and server failures three times with bounded backoff.
- Stable 4xx responses, invalid input, malformed JSON, and unexpected API shapes fail the run instead of returning a misleading empty success.
- No proxy or browser is used in the current implementation.

### Responsible use and legality

The Actor collects public company and professional-profile information from the public Speedrun directory. You are responsible for complying with the source's terms, applicable privacy and database laws, and the rules of systems receiving exported data.

Do not use results for harassment, unlawful discrimination, spam, or decisions that require independent verification. Respect deletion requests and retain personal data only as long as necessary for a legitimate purpose.

### Troubleshooting

#### Why did my run return zero companies?

Check exact cohort, industry, region, and country spelling. Filters are combined, so every filter group must match. Also confirm that supplied profile URLs use `speedrun.a16z.com/companies/<slug>`.

#### Why is a field null?

The source did not publish that optional value for the company. The Actor does not infer missing information.

#### Why did the run fail after retries?

Inspect the run log for the HTTP status or response-shape error. A temporary upstream issue can be retried later. Persistent errors may indicate a source API change.

#### Can I export every company?

Yes. Leave filters and profile URLs empty and set `maxItems` above the current directory size. The directory changes over time, so the result count is not guaranteed.

### FAQ

#### Is this an official a16z API?

No. This is an independent Actor that structures records exposed by the public Speedrun website and its public data surface.

#### Does it scrape the full a16z portfolio?

No. It is intentionally scoped to the public a16z Speedrun company directory.

#### Are founders charged separately?

No. Published founder and team-role objects are nested in the company record and included in the company item charge.

#### Does it monitor changes automatically?

The Actor produces a timestamped snapshot. Save it as an Apify Task and schedule runs; compare snapshots in your own workflow.

#### Can I provide arbitrary websites?

No. `startUrls` accepts only public a16z Speedrun company profile URLs. Invalid hosts or paths fail input validation.

### Related Automation Lab Actors

- [Company Leadership Scraper](https://apify.com/automation-lab/company-leadership-contact-finder) — collect source-attributed public leadership records from supplied company websites.
- [Company Career Page Jobs Scraper](https://apify.com/automation-lab/company-career-page-jobs-scraper) — turn public company career pages into normalized hiring-intelligence records.

Use those Actors only when you need their separate website-level workflows; this Actor remains focused on Speedrun's public accelerator directory.

# Actor input Schema

## `startUrls` (type: `array`):

Optional a16z Speedrun company profile URLs. Filters below also apply to these profiles.

## `search` (type: `string`):

Case-insensitive text matched against company name, summary, description, and industries.

## `cohorts` (type: `array`):

Only return exact cohort codes, for example SR003 or SR006.

## `industries` (type: `array`):

Return companies matching at least one exact industry label, such as Gaming or AI Agents.

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

Return companies matching at least one exact Speedrun region label.

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

Return companies matching at least one exact country name.

## `minTeamSize` (type: `integer`):

Exclude companies whose published team size is below this value.

## `maxTeamSize` (type: `integer`):

Exclude companies whose published team size is above this value.

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

Maximum number of matching company records to save.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://speedrun.a16z.com/companies/2weeks"
    }
  ],
  "cohorts": [
    "SR006"
  ],
  "maxItems": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

Open matched company records in the overview dataset view.

# 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 = {
    "startUrls": [
        {
            "url": "https://speedrun.a16z.com/companies/2weeks"
        }
    ],
    "cohorts": [
        "SR006"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/a16z-speedrun-companies-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 = {
    "startUrls": [{ "url": "https://speedrun.a16z.com/companies/2weeks" }],
    "cohorts": ["SR006"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/a16z-speedrun-companies-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 '{
  "startUrls": [
    {
      "url": "https://speedrun.a16z.com/companies/2weeks"
    }
  ],
  "cohorts": [
    "SR006"
  ],
  "maxItems": 20
}' |
apify call automation-lab/a16z-speedrun-companies-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/a16z-speedrun-companies-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/gfHhbJSO4E1EbgsR4/builds/DLysNyvqFdSHHReqk/openapi.json