# YC Companies Scraper: Founders & Jobs, No Login (`cliqtomedia/y-combinator-companies`) Actor

Scrape the Y Combinator company directory by batch, industry, region, status and hiring. Get founders, LinkedIn/X links, open jobs and team size. Only-new mode for tracking new YC startups. No login or API key.

- **URL**: https://apify.com/cliqtomedia/y-combinator-companies.md
- **Developed by:** [Cliqto Media](https://apify.com/cliqtomedia) (community)
- **Categories:** Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 company with founders

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?

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

Scrape the public Y Combinator company directory (ycombinator.com/companies) and get one clean row per YC startup: batch, status, industry, location, team size, website, founders with LinkedIn and X links, open jobs and the YC partner. No login, no cookies and no API key.

Filter by batch (for example `W24`), industry, region, status, hiring and team size, or look up a list of companies by slug or URL. The ready-made example (batch `W24`, 30 companies) finishes in about 10 seconds and costs about $0.06.

![YC Companies Scraper: filter the Y Combinator directory by batch, industry and hiring, and get companies with founders, LinkedIn and X links and open jobs](https://api.apify.com/v2/key-value-stores/iVv6VyF2BSHNiiftD/records/README-HERO.png)

### Table of contents

- [What it does](#what-it-does)
- [Quick start](#quick-start)
- [Use cases](#use-cases)
- [Input](#input)
- [Output](#output)
- [Pricing and limits](#pricing-and-limits)
- [Track new YC companies](#track-new-yc-companies)
- [API, export and integrations](#api-export-and-integrations)
- [Switching from another YC scraper](#switching-from-another-yc-scraper)
- [Troubleshooting](#troubleshooting)
- [FAQ](#faq)
- [Related Actors](#related-actors)
- [Support](#support)

### What it does

The Actor reads the public [Y Combinator startup directory](https://www.ycombinator.com/companies) — the same list you see in a browser. It has two modes:

- **Search the directory** (`mode: "search"`, default): keep the companies that match your filters, newest batches first.
- **Look up specific companies** (`mode: "companies"`): give up to 1000 company slugs or YC URLs and get one row for each.

With **Include founders, socials and jobs** on (default), the Actor also opens each company page and adds the founders (name, title, short bio, LinkedIn, X), the company's LinkedIn, X, Facebook, GitHub and Crunchbase links, the YC group partner, year founded and the list of open jobs. With it off, you get the directory fields only — faster and cheaper.

#### Good fit

- Build a lead list of YC startups from one batch, industry or region.
- Find founders of YC companies and their public LinkedIn and X profiles.
- Find YC startups that are hiring now, with job titles, salary and equity ranges as listed on YC.
- Get only the companies added since your last run (for a weekly or daily schedule).

#### Not a fit / limits

- **No emails or phone numbers.** The Actor never returns founder emails or phone numbers, and it removes them from descriptions and bios.
- Only public data from ycombinator.com. No Bookface, no private YC data, no funding amounts or valuations.
- The Actor does not visit company websites, LinkedIn or X. Links are copied as YC shows them.
- Data is as fresh as the YC directory at run time. Team size, status and jobs are what founders reported to YC; they can be out of date.

### Quick start

1. Open the **Input** tab.
2. Keep the example: **Batches** = `W24`, **Max companies** = `30`.
3. Keep **Include founders, socials and jobs** on.
4. Click **Start**.
5. Open the **Output** tab. The **Companies** view shows one row per company; the **Founders & socials** view shows founders, links and jobs.

Expected result: 30 Winter 2024 companies with founders and open jobs, in about 10 seconds.

### Use cases

| Buyer job | Input path | Output entity | Key fields | Next integration |
| --- | --- | --- | --- | --- |
| Lead list of startups in one YC batch | `batches`, `industries` | company | `name`, `website`, `oneLiner`, `linkedinUrl`, `teamSize` | CSV/Excel to a CRM |
| Reach out to founders | `batches`, `includeFounders` | company with founders | `founders[].name`, `founders[].title`, `founders[].linkedinUrl` | LinkedIn outreach tools |
| Startups that are hiring | `isHiring`, `regions` | company with jobs | `openJobsCount`, `jobs[].title`, `jobs[].salaryRange`, `jobs[].url` | Recruiting spreadsheet |
| Market map of an industry | `industries`, `status`, `minTeamSize` | company | `industry`, `subindustry`, `tags`, `status`, `batchCode` | BI tool / Google Sheets |
| Enrich your own list of YC companies | `mode: companies`, `companies` | company with founders | `slug`, `groupPartner`, `yearFounded`, `founders` | Your database via API |
| Alert on new YC companies | `onlyNew`, `stateKey` + a schedule | new companies only | `name`, `batchCode`, `launchedAt`, `url` | Slack / email via webhook |

### Input

#### Input fields

| Field | Plain name | Type | Required | Default / prefill | Allowed values | Effect | Example | Recommendation |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| `mode` | Mode | string | no | default `search` | `search`, `companies` | Search the directory or look up a list of companies | `"search"` | Use `companies` when you already know which companies you want |
| `batches` | Batches | string list | no | prefill `["W24"]`; empty = all batches | up to 200 codes or names: `W24`, `S23`, `X25` (Spring), `F24` (Fall), `Winter 2024`, `Unspecified` | Keep companies from these batches | `["W25", "S25"]` | The fastest way to keep a run small |
| `search` | Keyword | string | no | empty | up to 200 characters | Full-text search in names and descriptions, like the search box on YC | `"developer tools"` | Combine with batches for a narrow list |
| `industries` | Industries | string list | no | empty = all | YC industry names, any case | Keep companies in these industries | `["Fintech", "Healthcare"]` | An unknown name stops the run and lists valid names |
| `regions` | Regions | string list | no | empty = all | YC region names | Keep companies in these regions | `["Europe", "India"]` | An unknown name stops the run and lists valid names |
| `status` | Company status | list | no | empty = all | `Active`, `Acquired`, `Public`, `Inactive` | Keep only these statuses | `["Active"]` | Use `Active` for sales lists |
| `isHiring` | Hiring now only | boolean | no | `false` | true / false | Keep only companies with open jobs on YC | `true` | For recruiting and "hiring" signals |
| `topCompaniesOnly` | Top companies only | boolean | no | `false` | true / false | Keep only companies YC marks as top companies | `true` | |
| `minTeamSize` | Min team size | integer | no | empty = no minimum | 0 or more | Keep companies with at least this many people | `10` | |
| `maxTeamSize` | Max team size | integer | no | empty = no maximum | 0 or more, not below `minTeamSize` | Keep companies with at most this many people | `50` | |
| `includeFounders` | Include founders, socials and jobs | boolean | no | `true` | true / false | Opens each company page for founders, social links, partner and jobs. Each row is billed as a full row | `false` | Turn off for large directory exports when you need directory fields only. Always on in `companies` mode |
| `companies` | Companies (companies mode) | string list | only in `companies` mode | empty | up to 1000 slugs or `ycombinator.com/companies/...` URLs | Companies to look up | `["airbnb", "https://www.ycombinator.com/companies/doordash"]` | Duplicates are removed (same slug in any case or URL form) |
| `onlyNew` | Only new companies | boolean | no | `false` | true / false | Skip companies delivered by earlier runs with the same state key | `true` | Use with a schedule |
| `stateKey` | State key | string | no | `default` | 1–40 letters, digits, `-`, `_` | Name of the remembered list for `onlyNew` | `"w26-fintech"` | Use a different key for each saved search |
| `maxItems` | Max companies | integer | no | default `100`, prefill `30` | 1–10000 | Maximum rows to save. Each row is charged | `500` | The whole directory has about 6300 companies |

Empty input (`{}`) searches all batches and saves the 100 newest companies with founders. Unknown input fields stop the run with a list of allowed fields, so a typo never silently changes what you pay for.

#### Interacting settings

| When | Input A | Input B | Effective behavior | Example | Cost/result effect |
| --- | --- | --- | --- | --- | --- |
| Several filters | `batches`, `industries`, `regions`, `status`, `search` | each other | All filters must match (AND). Inside one list, any value matches (OR) | `W24` + `Fintech` | Fewer rows |
| Companies mode | `mode: companies` | search filters | Search filters are ignored; only `companies` is used | | |
| Companies mode | `mode: companies` | `includeFounders` | Always reads company pages, so every found company is a full row | | Full-row price |
| Tracking | `onlyNew` | `maxItems` | `maxItems` counts only new companies. Already delivered companies are skipped and not charged | | Unchanged run: only the start fee |
| Large exports | `includeFounders: true` | `maxItems` above ~1000 | About 0.28 seconds per full row. 1500 full rows took 7 minutes | 5000 full rows ≈ 23 minutes | Raise the run timeout (see [Troubleshooting](#run-stopped-early-with-run-timeout-is-close)) |

#### Input examples

##### Founders of one batch (the prefilled example)

```json
{
  "batches": ["W24"],
  "maxItems": 30
}
```

Expected behavior: reads the W24 batch and opens 30 company pages.
Expected output: 30 companies with `founders`, `linkedinUrl`, `jobs`.
Limit or cost note: about 10 seconds, $0.057 at the Free tier price.

##### Hiring fintech startups in Europe, directory fields only

```json
{
  "industries": ["Fintech"],
  "regions": ["Europe"],
  "isHiring": true,
  "includeFounders": false,
  "maxItems": 200
}
```

Expected behavior: searches all batches, newest first, without opening company pages.
Expected output: companies with `name`, `website`, `teamSize`, `isHiring`, `batchCode`.

##### Look up companies you already know

```json
{
  "mode": "companies",
  "companies": ["airbnb", "https://www.ycombinator.com/companies/doordash"]
}
```

Expected behavior: one row per company. A slug that does not exist on YC returns one `not_found` row.

##### Weekly list of new YC companies

```json
{
  "onlyNew": true,
  "stateKey": "all-new",
  "includeFounders": false,
  "maxItems": 10000
}
```

Expected behavior: the first run builds the baseline and saves the whole directory (about 6300 rows, about 2.5 minutes, about $5.67). To start smaller, add a filter such as `batches`. Later runs save only companies that were not delivered before.

### Output

Each company is one item in the default Dataset. Two views are ready in the **Output** tab:

- **Companies** — name, batch, status, one-liner, website, industry, location, team, hiring, founders count, LinkedIn, YC page, row status.
- **Founders & socials** — founders, company LinkedIn, X, GitHub, Crunchbase, year founded, YC partner, open jobs.

#### Output fields

| Field | Meaning | Type | Can be empty? | Example / enum | Source / notes |
| --- | --- | --- | --- | --- | --- |
| `recordStatus` | Row status | string | no | `complete`, `partial`, `not_found`, `error` | see [Output entities](#output-entities-and-surfaces) |
| `ycId` | YC company ID | integer | yes (not_found/error) | `29517` | directory |
| `name` | Company name | string | yes (not_found/error) | `RetailReady` | directory |
| `slug` | YC slug, usable in `companies` mode | string | no | `retailready` | directory |
| `url` | YC company page | string | no | `https://www.ycombinator.com/companies/retailready` | |
| `website` | Company website | string | yes | `https://www.retailreadyai.com/` | directory |
| `oneLiner` | Short tagline | string | yes | `An AI-powered supply chain compliance engine` | emails/phones removed |
| `longDescription` | Long description | string | yes | | emails/phones removed |
| `batch` | Batch name | string | yes | `Winter 2024` | |
| `batchCode` | Short batch code | string | yes | `W24`, `X25`, `F24` | built from `batch` |
| `status` | Company status | string | yes | `Active`, `Acquired`, `Public`, `Inactive` | |
| `industry` | Main industry | string | yes | `B2B` | |
| `subindustry` | Industry path | string | yes | `B2B -> Supply Chain and Logistics` | |
| `industries` | All industry labels | string\[] | empty list | `["B2B", "Supply Chain and Logistics"]` | |
| `tags` | YC tags | string\[] | empty list | `["AI", "Logistics"]` | |
| `regions` | YC regions | string\[] | empty list | `["United States of America", "America / Canada"]` | |
| `location` | Locations as shown in the directory | string | yes | `San Francisco, CA, USA` | |
| `teamSize` | Team size reported to YC | integer | yes | `12` | |
| `isHiring` | Has open jobs on YC | boolean | yes | `true` | |
| `isTopCompany` | YC top company | boolean | yes | `false` | |
| `isNonprofit` | Nonprofit | boolean | yes | `false` | |
| `stage` | Stage label | string | yes | `Early`, `Growth` | |
| `launchedAt` | When the YC profile was launched | string (ISO 8601) | yes | `2024-01-16T16:52:04.000Z` | |
| `formerNames` | Previous names | string\[] | empty list | `[]` | |
| `logoUrl` | Logo image | string | yes | | only stable links |
| `detailsIncluded` | Company page was read | boolean | no | `true` | `false` when `includeFounders` is off or the page failed |
| `yearFounded` | Year founded | integer | yes | `2024` | company page |
| `city` | City | string | yes | `San Francisco` | company page |
| `country` | Country code | string | yes | `US` | company page |
| `linkedinUrl` | Company LinkedIn | string | yes | `https://www.linkedin.com/company/...` | company page |
| `twitterUrl` | Company X/Twitter | string | yes | | company page |
| `facebookUrl` | Company Facebook | string | yes | | company page |
| `githubUrl` | Company GitHub | string | yes | | company page |
| `crunchbaseUrl` | Company Crunchbase | string | yes | | company page |
| `groupPartner` | YC group partner | string | yes | | company page |
| `foundersCount` | Number of founders | integer | yes | `2` | `null` when details were not read |
| `founders` | Founders: `name`, `title`, `bio`, `linkedinUrl`, `twitterUrl` | object\[] | yes | | `null` when details were not read. Never emails or phones |
| `openJobsCount` | Open jobs on YC | integer | yes | `4` | `null` when details were not read |
| `jobs` | Jobs: `title`, `url`, `location`, `type`, `role`, `salaryRange`, `equityRange`, `minExperience`, `visa` | object\[] | yes | | `null` when details were not read |
| `errorMessage` | Why a row is partial, not_found or error | string | yes | | `null` for complete rows |
| `source` | Always `ycombinator.com` | string | no | | |
| `fetchedAt` | When the row was fetched | string (ISO 8601) | no | | |

#### Output entities and surfaces

| Situation | Where | Result shape | User action |
| --- | --- | --- | --- |
| Normal company | Dataset | `recordStatus: "complete"` | Use the row |
| Company page failed (search mode) | Dataset | `recordStatus: "partial"`, directory fields filled, `detailsIncluded: false`, `errorMessage` says why | Run the slug again in `companies` mode later |
| Slug does not exist on YC (companies mode) | Dataset | `recordStatus: "not_found"`; only `slug`, `url`, `errorMessage` and the service fields `detailsIncluded`, `source`, `fetchedAt` are filled | Check the slug |
| Page failed (companies mode) | Dataset | `recordStatus: "error"`, not charged | Retry later. If YC renamed the company, its old slug can fail this way: find the new slug with `search` |
| No company matches the filters | Dataset empty; run `SUCCEEDED`; status message `No YC companies match these filters.` | — | Loosen the filters |
| Every run | Key-value store record `RUN_SUMMARY` | status, message, counts, charged events, input echo | Read in API or webhooks |

`RUN_SUMMARY.status` is one of `COMPLETE`, `PARTIAL`, `NO_RESULTS`, `NOT_FOUND`, `INVALID_INPUT`, `ERROR`, `CANCELLED`. The same short message is shown as the run status message.

#### Output example

One real row from the prefilled `W24` run. Founder names, bios and profile links are replaced with placeholders here; the YC group partner is shortened. Jobs list is trimmed to one item, and some long or empty fields (`longDescription`, `formerNames`, `logoUrl`, `facebookUrl`) are left out to keep the example short. Real rows always have every field from the table above.

```json
{
  "recordStatus": "complete",
  "ycId": 29517,
  "name": "RetailReady",
  "slug": "retailready",
  "url": "https://www.ycombinator.com/companies/retailready",
  "website": "https://www.retailreadyai.com/",
  "oneLiner": "An AI-powered supply chain compliance engine",
  "batch": "Winter 2024",
  "batchCode": "W24",
  "status": "Active",
  "industry": "B2B",
  "subindustry": "B2B -> Supply Chain and Logistics",
  "industries": ["B2B", "Supply Chain and Logistics"],
  "tags": ["B2B", "Compliance", "Logistics", "Supply Chain", "AI"],
  "regions": ["United States of America", "America / Canada"],
  "location": "San Francisco, CA, USA",
  "teamSize": 12,
  "isHiring": true,
  "isTopCompany": false,
  "isNonprofit": false,
  "stage": "Early",
  "launchedAt": "2024-01-16T16:52:04.000Z",
  "detailsIncluded": true,
  "yearFounded": 2024,
  "city": "San Francisco",
  "country": "US",
  "linkedinUrl": "https://www.linkedin.com/company/retailreadyai/",
  "twitterUrl": null,
  "githubUrl": null,
  "crunchbaseUrl": null,
  "groupPartner": "<YC partner name>",
  "foundersCount": 2,
  "founders": [
    { "name": "<Founder 1>", "title": "Founder", "bio": "<short bio from YC>", "linkedinUrl": "https://linkedin.com/in/<profile>", "twitterUrl": null },
    { "name": "<Founder 2>", "title": "Founder", "bio": "<short bio from YC>", "linkedinUrl": "https://linkedin.com/in/<profile>", "twitterUrl": null }
  ],
  "openJobsCount": 4,
  "jobs": [
    {
      "title": "Full Stack Software Engineer",
      "url": "https://www.ycombinator.com/companies/retailready/jobs/wEGXWv4-full-stack-software-engineer",
      "location": "San Francisco, CA, US",
      "type": "Full-time",
      "role": "Engineering",
      "salaryRange": "$110K - $170K",
      "equityRange": "0.05% - 0.25%",
      "minExperience": "Any (new grads ok)",
      "visa": "US citizen/visa only"
    }
  ],
  "errorMessage": null,
  "source": "ycombinator.com",
  "fetchedAt": "2026-10-14T02:07:18.929Z"
}
```

`null` means YC does not show this value for the company (or details were not read). An empty list means the label list is empty on YC.

### Pricing and limits

#### Pricing unit

You pay per event (pay-per-event). Platform usage (compute, storage, traffic) is included — you pay only the events below.

| Event | When it is charged | Free | Bronze | Silver | Gold |
| --- | --- | ---: | ---: | ---: | ---: |
| Actor start | Once per run | $0.003 | $0.003 | $0.003 | $0.003 |
| Company (directory fields) | Each saved row with `includeFounders: false`, each `partial` row, each `not_found` lookup | $0.0009 | $0.00085 | $0.0008 | $0.00075 |
| Company with founders | Each saved row with founders, socials and jobs | $0.0018 | $0.0017 | $0.0016 | $0.0015 |

That is $0.90 per 1000 directory rows and $1.80 per 1000 full rows at the Free tier, less on higher Apify plans.

- A run with no matching companies, an unchanged `onlyNew` run and a run with invalid input are charged only the start fee ($0.003).
- `error` rows (company page failed in `companies` mode) are free.
- If you set a **maximum cost per run**, the Actor stops before it would go over it, keeps the rows it already saved and finishes with a `PARTIAL` status.

#### Cost examples

Free tier prices.

| Scenario | Input scope | Rows | Start | Row charges | Total |
| --- | --- | ---: | ---: | ---: | ---: |
| Prefilled example | `W24`, 30 companies, founders on | 30 | $0.003 | 30 × $0.0018 | $0.057 |
| One batch with founders | ~250 companies, founders on | 250 | $0.003 | 250 × $0.0018 | $0.453 |
| 1000 companies, directory fields | founders off | 1000 | $0.003 | 1000 × $0.0009 | $0.903 |
| Whole directory, directory fields | all batches, founders off, `maxItems` 10000 | ~6300 | $0.003 | ~6300 × $0.0009 | ~$5.67 |
| No matches / nothing new | | 0 | $0.003 | — | $0.003 |

#### Limits

- `maxItems` up to 10000; the directory has about 6300 companies.
- `companies` mode: up to 1000 slugs or URLs per run.
- Full rows take about 0.28 seconds each, because the Actor opens one company page per row and keeps a polite request rate. The default run timeout is 300 seconds (enough for about 900 full rows). For larger runs with founders, raise the timeout in **Run options**: about 3600 seconds for the whole directory.
- If the timeout is close, the Actor stops on its own, keeps all saved rows and finishes with `PARTIAL`.
- Links are returned as companies wrote them on YC. Some of them are outdated or point to a wrong page; the Actor does not check them.

### Track new YC companies

1. Set `onlyNew: true` and a `stateKey` (for example `w26-fintech`). Keep the other filters the same in every run.
2. Run once. All matching companies are saved and remembered.
3. Create a **Schedule** in Apify Console (for example every Monday).
4. Each next run saves only companies that were not delivered before with the same `stateKey`. If there is nothing new, the run succeeds with 0 rows and the message `No new companies: N matches were already delivered earlier.`

A company is remembered as soon as it is saved, also as a `partial` row. To get full details for such a row later, run its slug in `companies` mode without `onlyNew`.

The remembered list is stored in your account, in the named key-value store `y-combinator-companies-state`, record `SEEN_<stateKey>`. Use a new `stateKey` to start over.

### API, export and integrations

- **API:** start a run with `POST https://api.apify.com/v2/acts/cliqtomedia~y-combinator-companies/runs` and the input JSON; read rows from the run's default Dataset.
- **Export:** download the Dataset as JSON, CSV, Excel, XML or RSS from the **Output** tab or the Dataset API.
- **Scheduling:** Apify Schedules with `onlyNew` (see above).
- **Webhooks / no-code:** use an Apify webhook on run success, or the Make, Zapier or n8n Apify integrations, to send new rows to Google Sheets, Slack or a CRM.

#### Use with AI agents (MCP)

- MCP server with only this Actor: `https://mcp.apify.com?tools=cliqtomedia/y-combinator-companies`
- Smallest useful input: `{"batches": ["W24"], "maxItems": 30}`
- Key output fields: `name` (company), `batchCode` (YC batch), `website`, `founders` (name, title, LinkedIn, X), `jobs` (open roles).
- A 30-company run takes about 10 seconds and costs about $0.06. Keep `maxItems` small for interactive use; full rows take about 0.28 seconds each.

### Switching from another YC scraper

Field names differ from other YC directory Actors. Common mappings:

| This Actor | Often called |
| --- | --- |
| `ycId` | `id`, `company_id` |
| `name` | `company_name` |
| `oneLiner` / `longDescription` | `short_description` / `long_description` |
| `location` | `allLocations`, `company_location` |
| `isTopCompany` / `isNonprofit` | `topCompany` / `nonprofit`, `top_company` |
| `launchedAt` (ISO 8601 text) | `launchedAt` (Unix seconds) |
| `logoUrl` | `logo`, `company_image` |
| `linkedinUrl`, `twitterUrl`, `githubUrl` | `company_linkedin`, `company_x`, `company_github` |
| `groupPartner` | `primary_partner` |
| `openJobsCount` / `jobs` | `number_of_open_jobs` / `open_jobs` |
| `teamSize`, `yearFounded` (numbers) | `team_size`, `year_founded` (sometimes text) |

### Troubleshooting

#### The run failed with "Unknown input field(s)"

Symptom: run `FAILED` right after start.
Likely reason: a misspelled field name, for example `includeDetails` instead of `includeFounders`.
Action: use the field names from the [Input fields](#input-fields) table. The error lists all allowed names.

#### The run failed with "Unknown industries" or "Unknown regions"

Likely reason: a name that YC does not use.
Action: copy one of the valid names from the error message (case does not matter).

#### "Batch ... is not a YC batch"

Action: use a code like `W24`, `S23`, `X25`, `F24` or a name like `Winter 2024`.

#### 0 rows and "No YC companies match these filters."

Likely reason: filters exclude each other (for example a batch with no companies in that region).
Check: open [ycombinator.com/companies](https://www.ycombinator.com/companies) with the same filters.
Action: remove one filter at a time. The run cost only the start fee.

#### Run stopped early with "Run timeout is close"

Likely reason: many full rows and the default 300-second timeout.
Action: raise **Timeout** in **Run options** (for example 3600 seconds), lower `maxItems`, or turn off `includeFounders`. Saved rows are kept.

#### Some rows have `recordStatus: "partial"`

Likely reason: a company page did not load; directory fields are still filled.
Action: run those slugs again in `companies` mode.

#### "YC company pages failed ... times in a row" or "Source refused access"

Likely reason: ycombinator.com is slow or temporarily unavailable. The Actor stops instead of saving empty rows.
Action: try again later. Rows saved before the stop are kept.

### FAQ

#### Do I need a YC account, cookies or an API key?

No. The Actor reads only the public directory and public company pages.

#### Does it return founder emails or phone numbers?

No. Emails and phone numbers are never returned and are removed from descriptions and bios. You get public LinkedIn and X profile links that founders list on YC.

#### How fresh is the data?

Every run reads the YC directory live. Team size, status, hiring and jobs are what each company shows on YC at that moment; YC does not guarantee they are current.

#### Why are some fields `null`?

YC does not show that value for this company, or details were not read (`includeFounders: false` or a `partial` row).

#### Can I get all YC companies?

Yes. Leave the filters empty and set `maxItems` to 10000. Without founders it takes about 2.5 minutes. With founders, raise the run timeout to about 3600 seconds: 5000 full rows took 23 minutes in our tests, so the whole directory is expected to take about 30 minutes.

#### Is this an official Y Combinator product?

No. It is an independent tool that reads the public Y Combinator website. Please follow [ycombinator.com terms](https://www.ycombinator.com/legal) and data protection laws when you use personal data such as founder names.

### Related Actors

- [Ashby Jobs Scraper](https://apify.com/cliqtomedia/ashby-jobs-scraper) — full job boards of startups that use Ashby, many of them YC companies.
- [Greenhouse Jobs Scraper & Monitor](https://apify.com/cliqtomedia/greenhouse-jobs-monitor-scraper) — job boards on Greenhouse.
- [Wellfound Jobs Scraper](https://apify.com/cliqtomedia/wellfound-jobs-scraper) — startup jobs from Wellfound.

### Support

For a bug, a question or a feature request, open an issue in the **Issues** tab of this Actor. Include the run ID, the input mode and the error text. Never send tokens, cookies or private data.

# Changelog

This Actor's version history is a separate document: https://apify.com/cliqtomedia/y-combinator-companies/changelog.md

# Actor input Schema

## `mode` (type: `string`):

search (default): filter the YC directory. companies: look up the companies listed below by slug or URL.

## `batches` (type: `array`):

YC batches, e.g. W24, S23, X25 (Spring 2025), F24 (Fall 2024) or Winter 2024. Empty = all batches.

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

Free-text search in names and descriptions, e.g. fintech or developer tools. Empty = no keyword.

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

YC industry names, e.g. B2B, Fintech, Healthcare, Consumer. Case does not matter; unknown names stop the run with a list of valid ones.

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

YC region names, e.g. United States of America, Europe, India, Latin America.

## `status` (type: `array`):

Keep only these statuses. Empty = all.

## `isHiring` (type: `boolean`):

Keep only companies with open jobs on YC.

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

Keep only companies YC marks as top companies.

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

Keep companies with at least this many people. Empty = no minimum.

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

Keep companies with at most this many people. Empty = no maximum.

## `includeFounders` (type: `boolean`):

Read each company page for founders (name, title, bio, LinkedIn, X), company social links, YC partner and open jobs. Slower and priced as a full row. Off = directory fields only, cheaper. Always on in companies mode.

## `companies` (type: `array`):

Up to 1000 YC company slugs or URLs, e.g. doordash or https://www.ycombinator.com/companies/airbnb. Used only when Mode is companies.

## `onlyNew` (type: `boolean`):

Skip companies already delivered by earlier runs with the same state key. Use with a schedule to get only newly added YC companies.

## `stateKey` (type: `string`):

Name of the remembered list for Only new companies, e.g. w26-fintech. Letters, digits, - and \_. Default: default.

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

Maximum company rows, 1–10000. Each row is charged.

## Actor input object example

```json
{
  "mode": "search",
  "batches": [
    "W24"
  ],
  "isHiring": false,
  "topCompaniesOnly": false,
  "includeFounders": true,
  "onlyNew": false,
  "stateKey": "default",
  "maxItems": 30
}
```

# Actor output Schema

## `companies` (type: `string`):

Company table.

## `founders` (type: `string`):

Founders, social links and jobs.

## `runSummary` (type: `string`):

Status, counts, charged rows and request statistics.

# 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 = {
    "batches": [
        "W24"
    ],
    "maxItems": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("cliqtomedia/y-combinator-companies").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 = {
    "batches": ["W24"],
    "maxItems": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("cliqtomedia/y-combinator-companies").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 '{
  "batches": [
    "W24"
  ],
  "maxItems": 30
}' |
apify call cliqtomedia/y-combinator-companies --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cliqtomedia/y-combinator-companies"
        }
    }
}
```

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/FdSEKbnJ4zbZ0UkIc/builds/IWK0xJSWkoSMAfY4M/openapi.json