# Y Combinator Scraper — All YC Companies & Startups (`pixflor/ycombinator-companies-scraper`) Actor

Export every Y Combinator company from YC's official API: name, one-liner, website, batch, team size, industries, regions, status and badges. Filters that YC's API silently ignores are applied properly here.

- **URL**: https://apify.com/pixflor/ycombinator-companies-scraper.md
- **Developed by:** [Pixflor](https://apify.com/pixflor) (community)
- **Categories:** Lead generation, MCP servers, Developer tools
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 company scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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

## Y Combinator Scraper — All YC Companies & Startups

Every company Y Combinator has ever funded — about **6,115** of them — as clean rows. Name,
one-liner, full description, website, batch, team size, industries, regions, status and badges.

No API key. No login. Set a filter, press start, export CSV or JSON.

***

### The thing that makes this different: filters that actually filter

YC has an official public API, and it accepts any filter you send it with a cheerful HTTP 200.
It does **not** apply all of them.

| Filter | What YC's API does |
|---|---|
| `batch`, `status`, `tags`, `regions` | Applied correctly |
| **`industry`** | **Accepted and silently ignored** |
| **`team_size`** | **Accepted and silently ignored** |
| **`q`** (search) | **Accepted and silently ignored** |

Measured: asking YC's API for `industry=Healthcare` returned 25 companies, of which **1** was
in healthcare. Asking for `team_size=1` returned 25, of which **1** had a team of one. No
error, no warning — just the entire unfiltered directory wearing a filter's clothes.

The only tell is the page size: an applied filter returns **20** rows per page, an ignored one
returns the default **25**. That's it. That's the whole signal, and it's documented nowhere.

**This Actor sends only the filters YC honours and applies the rest itself** — and it keeps
paging until it has the number of matching companies you asked for. Ask for 25 healthcare
companies and you get 25 healthcare companies (it scanned 258 to find them). Ask YC's API the
same question and you get 25 rows with 1 match.

It also tells you in the run log which filters went to the API and which were applied here, so
you never have to wonder.

***

### What you get

| Column | Example |
|---|---|
| `name` / `slug` | Lambda Robotics · `lambda-robotics` |
| `oneLiner` | Robotics for AI Infrastructure |
| `description` | full long description |
| `website` / `domain` | `https://lambdarobotics.ai` · `lambdarobotics.ai` |
| `ycUrl` | YC profile page |
| `batch` / `batchYear` / `batchSeason` | `F26` · `2026` · `Fall` |
| `status` / `isActive` | `Active` · `true` |
| `teamSize` | `6` |
| `tags` | `["Robotics","Infrastructure","AI"]` |
| `industries` | `["Industrials","Manufacturing and Robotics"]` |
| `regions` / `locations` | `["United States of America"]` |
| `badges` / `isTopCompany` / `isHiring` / `isNonprofit` | YC's own badges, parsed out |
| `logoUrl` | company logo |

***

### Typical uses

- **Lead generation.** Every YC company in an industry, with website and domain, filtered to
  the team sizes and batches you care about. Startups that just raised are startups that spend.
- **Competitive and market mapping.** Who else is building in your space, which batch they came
  from, how big they are now.
- **Investor and analyst research.** Batch-over-batch trends by industry, region or team size.
- **Recruiting.** Companies YC flags as hiring, filtered by stage and location.
- **Sales prospecting.** Filter to `Active`, a recent batch year, and a team-size band that
  matches your ideal customer.
- **Feeding an LLM or agent.** One row per company, consistent field names, no HTML.

***

### Example input

Healthcare companies from recent batches, still active, with a website:

```json
{
  "industry": "Healthcare",
  "status": "Active",
  "batchYearFrom": 2024,
  "hasWebsiteOnly": true,
  "sortBy": "newest",
  "maxItems": 250
}
```

Sales prospecting — a specific batch, sized to your ideal customer:

```json
{
  "batch": "W25",
  "minTeamSize": 10,
  "maxTeamSize": 100,
  "sortBy": "teamSize",
  "maxItems": 100
}
```

Recruiting — companies YC currently flags as hiring:

```json
{ "hiringOnly": true, "status": "Active", "maxItems": 200 }
```

***

### Settings that matter

- **`maxItems`** — your cost ceiling, and the thing that makes filters work. The Actor keeps
  paging until it has this many *matching* companies, so ask for what you actually need.
- **`industry` / `tag` / `region`** — the filters YC's own API accepts and then ignores. These
  are applied here for real, which is the whole point of this Actor.
- **`batchYearFrom` / `batchYearTo`** — usually more useful than a single `batch`, since a year
  spans two batches and "recently funded" rarely means one exact cohort.
- **`minTeamSize` / `maxTeamSize`** — the best proxy for stage. Under 10 is pre-traction; 10–100
  is where most B2B buying happens.
- **`topCompaniesOnly`** — YC's own badge. A short, high-signal list rather than a filter.

***

### Reliability

This uses YC's own public JSON API. There is no HTML parsing and no bot-detection workaround
anywhere in this Actor, which is why it doesn't quietly break when the directory page changes.

A 59-assertion live test suite runs against the real API before every release — including
assertions that check, filter by filter, which parameters YC still honours and which it
ignores. If YC ever fixes `industry`, the test says so.

The suite also walks to the end of the directory on every run rather than assuming where it
ends, so YC adding companies is never mistaken for the Actor breaking.

**One thing this Actor does not claim:** founder names and contact details. `/v0.1/founders`
and `/v0.1/jobs` are both 404 — they don't exist. Any Actor promising YC founder emails is
scraping HTML and will break when the page changes.

***

### Pricing

Pay per event. You are charged for the run start and for each company returned — nothing else,
and platform compute is included free. Filters run during the sweep, so you're only billed for
companies that actually match.

***

### Questions or a bug?

Open an issue on the **Issues** tab of this Actor. Include your input JSON and the run ID —
that's usually enough to reproduce it immediately.

# Actor input Schema

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

Keep only companies whose name, one-liner, description, tags or industries contain this. Applied by this Actor: YC's API accepts a q parameter and ignores it.

## `batch` (type: `string`):

YC batch code, e.g. W22, S24, F26. This one YC's API really does apply. Leave empty for every batch.

## `status` (type: `string`):

Company status. Applied by YC's API.

## `industry` (type: `string`):

Keep only companies in this industry, e.g. Healthcare, Fintech, B2B. Applied by this Actor — YC's API accepts industry and silently ignores it, returning the entire directory as though it were filtered.

## `tag` (type: `string`):

YC tag, e.g. AI, Robotics, Developer Tools. Applied by YC's API.

## `region` (type: `string`):

e.g. Europe, United States of America, Latin America. Applied by YC's API.

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

Keep only companies with at least this many people. Applied by this Actor — YC's API ignores team\_size.

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

Keep only companies with at most this many people. Useful for finding early-stage startups.

## `batchYearFrom` (type: `integer`):

Earliest batch year to include, e.g. 2020. 0 means no limit.

## `batchYearTo` (type: `integer`):

Latest batch year to include. 0 means no limit.

## `hasWebsiteOnly` (type: `boolean`):

Drop companies with no website listed. Useful when building a lead list.

## `topCompaniesOnly` (type: `boolean`):

Keep only companies YC badges as a top company.

## `hiringOnly` (type: `boolean`):

Keep only companies YC badges as currently hiring.

## `sortBy` (type: `string`):

How to order the results. 'default' keeps YC's own order, which is newest batch first.

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

How many companies to return, and what you pay for. The whole directory is about 6,115 companies.

## Actor input object example

```json
{
  "searchQuery": "fintech",
  "batch": "W22",
  "status": "",
  "industry": "Healthcare",
  "tag": "AI",
  "region": "Europe",
  "minTeamSize": 0,
  "maxTeamSize": 0,
  "batchYearFrom": 0,
  "batchYearTo": 0,
  "hasWebsiteOnly": false,
  "topCompaniesOnly": false,
  "hiringOnly": false,
  "sortBy": "default",
  "maxItems": 100
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("pixflor/ycombinator-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("pixflor/ycombinator-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 '{}' |
apify call pixflor/ycombinator-companies-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,pixflor/ycombinator-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/PCuviPjtjIWULWgxy/builds/OAumOwDAHYKScj4xb/openapi.json