# Y Combinator Companies, Batches & Founders (`insight.solutions/yc-companies-directory`) Actor

Scrape the Y Combinator startup directory as data. One row per company: name, website, one-liner, description, batch (W25), status, industry, tags, team size, region, launch date — filtered by batch, industry, status, region or keyword. Optionally adds founders and socials. No API key, no login.

- **URL**: https://apify.com/insight.solutions/yc-companies-directory.md
- **Developed by:** [Insight Solutions](https://apify.com/insight.solutions) (community)
- **Categories:** Business, Lead generation, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 company returneds

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

## Y Combinator Companies, Batches & Founders

**The whole Y Combinator startup directory as a flat table.** Every YC company — around 6,200 of them, from Summer 2005 to the current batch — with its name, website, one-liner, full description, batch, status, industry, tags, team size, region, location and launch date. Filter by batch (`W25`, `S24`), by industry, by status, by region, by tag, by whether the company is hiring, or by a full-text search across everything they wrote about themselves. Turn on `includeFounders` and each row also carries its founders with their LinkedIn and X profiles, the company's socials, the year it was founded, and its recent press.

No API key. No login. No scraping of anything a logged-out visitor cannot see. **$0.50 per 1,000 companies, proxy included** — the entire directory is about $3 — companies that could not be read are free, and a run that returns nothing costs nothing at all.

### Try it in 30 seconds

**Input** — this is the Store prefill; paste it and run:

```json
{
  "batches": ["Winter 2025"],
  "maxCompanies": 500
}
```

One batch, every company in it, four HTTP requests, a few seconds. `W25` reaches the same batch, and so does `Winter 2025`.

Want all of it? `{"maxCompanies": 10000}` with no filters at all returns the whole directory. Want a slice? `{"industries": ["Fintech"], "statuses": ["Active"], "isHiring": "yes"}`. Want to search? `{"queries": ["AI agents"]}`.

**Output** — one row per company; the fields you will use most are `name`, `batch`, `status`, `website` and `oneLiner` (full list under *Output reference*). Anything that could not be read comes back as a free diagnostic row (`ok: false`, `errorType`, `error`) instead of a charge.

**Price** — $0.50 per 1,000 companies on the FREE tier (+ $0.001 per run, charged only after the first paid row); volume tiers are Scale $0.40 and Business $0.30 per 1,000, founder rows are $0.25 per 1,000, and a batch or industry name that does not exist, a filter set that matched nothing, a company page that has gone, a company the run never reached and a request the site blocked are all free. Pay-per-event, no API key, no browser, limited permissions — works over the Apify MCP server (`mcp.apify.com`) and with agentic (x402) payments.

**From code** — `client.actor("insight.solutions/yc-companies-directory").call(run_input={…})` with `apify-client`, or `POST https://api.apify.com/v2/acts/insight.solutions~yc-companies-directory/run-sync-get-dataset-items`.

### What comes back

One `company` row per company:

```jsonc
{
  "ok": true,
  "rowType": "company",                // "company" | "founder" | "diagnostic"

  "id": 271,                           // YC's own numeric ID — the join key
  "name": "Airbnb",
  "slug": "airbnb",
  "url": "https://www.ycombinator.com/companies/airbnb",
  "website": "http://airbnb.com",
  "oneLiner": "Book accommodations around the world.",
  "description": "Founded in August of 2008 and based in San Francisco, California, Airbnb is a trusted community marketplace for people to list, discover, and book unique accommodations around the world…",

  "batch": "Winter 2009",
  "batchShort": "W09",                 // YC's own abbreviation
  "status": "Public",                  // "Active" | "Acquired" | "Public" | "Inactive"
  "stage": "Growth",                   // "Early" | "Growth"

  "industry": "Consumer",
  "industries": ["Consumer", "Travel, Leisure and Tourism"],
  "subindustry": "Consumer -> Travel, Leisure and Tourism",
  "tags": ["Marketplace", "Travel"],
  "regions": ["United States of America", "America / Canada"],
  "location": "San Francisco, CA, USA",

  "teamSize": 6132,
  "launchedAt": "2012-01-17T09:00:56.000Z",
  "isHiring": false,
  "topCompany": true,                  // YC's own "top company" flag — 91 of 6,213
  "nonprofit": false,
  "formerNames": [],                   // every name it traded under before this one
  "logoUrl": "https://bookface-images.s3.amazonaws.com/small_logos/3e9a0092…png",

  "position": 2,
  "query": null,
  "batchFilter": "Winter 2009",
  "source": "index",                   // "index" | "both" (both = its page was read too)
  "scrapedAt": "2026-09-11T21:13:01.000Z",
  "sourceUrl": "https://www.ycombinator.com/companies/airbnb"
}
```

With `includeFounders: true` the same row also carries:

```jsonc
{
  "founders": [
    { "name": "Brian Chesky",       "title": "Founder/CEO", "linkedin": "https://www.linkedin.com/in/brianchesky/",  "twitter": "https://twitter.com/bchesky"  },
    { "name": "Nathan Blecharczyk", "title": "Founder/CTO", "linkedin": "https://www.linkedin.com/in/blecharczyk/",  "twitter": "https://twitter.com/nathanblec" },
    { "name": "Joe Gebbia",         "title": "Founder/CPO", "linkedin": "https://www.linkedin.com/in/jgebbia/",      "twitter": "https://x.com/jgebbia"        }
  ],
  "founderNames": "Brian Chesky, Nathan Blecharczyk, Joe Gebbia",   // for spreadsheets
  "founderCount": 3,
  "yearFounded": 2008,                 // often earlier than the batch
  "city": "San Francisco",
  "country": "US",
  "linkedin": "https://www.linkedin.com/company/airbnb/",
  "twitter": "https://twitter.com/Airbnb",
  "facebook": "https://www.facebook.com/airbnb/",
  "crunchbase": "https://www.crunchbase.com/organization/airbnb",
  "github": null,
  "jobPostingCount": 0,
  "newsItems": [                       // YC's own curated press list, up to 10
    { "title": "Airbnb launches Airbnb Rooms listing category for budget travel", "url": "https://www.usatoday.com/…", "date": "May 03, 2023" }
  ],
  "source": "both"
}
```

Add `founderRows: true` and each founder also gets a row of their own — `company`, `companySlug`, `batch`, `name`, `title`, `linkedin`, `twitter` — for when the person is your unit of analysis rather than the company.

Every row carries the same columns, so companies, founders and diagnostics export as one rectangular table.

### Use cases

- **The complete YC list, kept fresh.** One scheduled run gives you every company YC has funded, keyed on `id`, with a `launchedAt` you can diff. New batches appear automatically — the Actor reads the batch list from the directory itself rather than from a list baked into its code.
- **Sourcing and lead generation.** 6,200 venture-backed companies with website, team size, stage, industry and location, filtered to the slice you sell to. `teamSize` plus `batch` is a decent proxy for "big enough to buy, young enough to move".
- **Recruiting.** `isHiring: "yes"` is about 1,500 companies at any moment; `includeFounders` adds `jobPostingCount` and the founders' LinkedIn profiles. That is a candidate-side or a client-side pipeline, depending which way you are facing.
- **Market maps and competitor scans.** `queries: ["AI agents"]` searches every company's own description, not just its name. Cross it with `batches` and you get the shape of a category over time.
- **Survivorship-free research.** The directory lists over a thousand `Inactive` companies — YC's word for shut down — alongside 23 that went public. Most public "YC list" datasets quietly drop the failures. `statuses: ["Inactive"]` is the other half of the story.
- **Founder research.** `founderRows: true` turns the directory into a table of several thousand YC founders with their titles and their public profiles.
- **Enrichment.** `formerNames` is the field that reconciles YC's records against a CRM written three rebrands ago.

### How it works, and why it keeps working

The YC directory is a React front end over a **public Algolia search index**. The search-only key that authorises it is handed to the browser in the page itself, and YC rotates it — the key that older public scrapers pass around answers `Invalid Application-ID or API key` today.

So this Actor reads the key from the page, every run, before it does anything else:

| Step | What it reads | Shape |
|---|---|---|
| **1. Key discovery** | `ycombinator.com/companies` | HTML carrying `window.AlgoliaOpts = {"app":…,"key":…}` |
| **2. Vocabulary** | the index, `hitsPerPage: 0` | JSON. Every batch, industry, status, region and tag that exists, with counts — about 2 KB |
| **3. Search** | the index | JSON. Up to 1,000 hits per query, with every field on this page's sample row |
| **4. Company page** *(opt-in)* | `ycombinator.com/companies/<slug>` | HTML with an Inertia `data-page` JSON blob: founders, socials, news |

Three things catch a naive scraper here, and all three are handled:

**The key is not yours to keep.** If the page stops carrying it, the run finishes with zero results, an `unavailable` diagnostic row explaining exactly that and a status message naming the missing key, and bills nothing. It does not fall back to a stale key and return an empty dataset that looks like "YC has no companies".

**Algolia will not serve past the 1,000th hit of any query.** Ask for page 5 at 1,000 per page and you get HTTP 200, zero hits and a polite message about `paginationLimitedTo`. Most tools that scrape this directory silently stop at 1,000 companies. This one reads the batch facet's counts and **runs one query per batch** — 50 of them, merged and de-duplicated by company ID — because every batch YC has ever run is under 400 companies. That is how a no-filter run returns all 6,213 in about fifty requests.

**A typo in a filter looks exactly like an empty result.** Every batch, status, industry, region and tag you pass is checked against the list the directory itself returned seconds earlier. `W205` does not silently return nothing; it produces a free `invalid-input` row saying *"W205" is not a known batch. Did you mean "Winter 2025"?*

Underneath: **Apify proxy** (datacenter by default — both endpoints answer it happily), one pinned session per parallel worker, 250–600 ms between a worker's requests. When an endpoint refuses an exit IP — HTTP 429 or 403 — that session is retired and **the same request goes out once more from a different address**. Retrying on an address that was just refused only deepens the block, so it is never done. If the second address is refused too, that batch stops, **every row already delivered is kept**, and one free `blocked` row says where it stopped.

### How it compares

- **It reads the whole directory, not the first thousand.** The 1,000-hit ceiling is the single thing that separates a complete YC dataset from a truncated one, and partitioning by batch is the only way past it that does not need a private API.
- **The search key is never hard-coded.** Every published YC scraper that pins a key eventually returns an empty dataset without saying why. This one reads it fresh and says so loudly — an `unavailable` row and a status message — when it cannot.
- **Bad input is answered, not swallowed.** An unknown batch or industry gets a free row naming the nearest valid values, drawn from the live facet lists.
- **Failures are free and legible.** A dead company page, a filter that matched nothing, a block — each produces a diagnostic row with an `errorType` you can branch on, and no charge. A run whose filters were all usable but produced nothing — a filter set that matched no company, a search index that did not answer, a block — finishes **SUCCEEDED with zero results**, a status message that says so, and a free diagnostic row telling you why; nothing is charged, start fee included. A run finishes **FAILED** only when there was nothing usable to attempt (every value you gave for a filter is unknown to the directory), or the Actor itself hit an error.
- **A partial run is kept, not thrown away.** Hit `maxRunSecs` or your charge ceiling halfway through and you keep every company already written.
- **Honest about what the public directory does not contain.** No funding amounts, no valuations, no investor lists, no contact emails — see *Limits*, in detail, rather than as a footnote.
- **No login, ever.** No YC account, no Bookface, no cookie jar, no session token. Public endpoints only, which is also why it runs under Apify's **limited permissions**.

### Input reference

| Field | Type | Default | What it does |
|---|---|---|---|
| `batches` | array | `["Winter 2025"]` | Batches to return: `Winter 2025`, `W25`, `S13`, `X26` (Spring), `F25` (Fall). Empty means every batch |
| `queries` | array | `[]` | Full-text search across names, one-liners and descriptions. Each term is a separate search; results are merged and de-duplicated |
| `industries` | array | `[]` | YC's industry taxonomy, parents and children in one list (`B2B`, `Fintech`, `Payments`, `Climate`) |
| `statuses` | array | `[]` | `Active`, `Acquired`, `Public`, `Inactive` |
| `regions` | array | `[]` | `United States of America`, `Europe`, `India`, `Remote`, `Fully Remote`… |
| `tags` | array | `[]` | YC's free-form labels: `SaaS`, `Marketplace`, `Generative AI`, `Open Source` |
| `isHiring` | string | `"any"` | `any`, `yes` or `no`. The API also accepts `true` / `false` / `null` |
| `topCompaniesOnly` | boolean | `false` | Only YC's own "top companies" — 91 of 6,213 |
| `nonprofitOnly` | boolean | `false` | Only YC's nonprofits. Applied to the results, not in the query — see *Limits* |
| `maxCompanies` | integer | `500` | Ceiling on company rows across the whole run. Max 10,000 |
| `sortBy` | string | `"default"` | `default` (YC's ranking) or `launchDate` (newest first) |
| `includeFounders` | boolean | `false` | Read each company's own page too: founders, socials, year founded, city, open roles, press. **One extra request per company** |
| `founderRows` | boolean | `false` | Also emit one row per founder. Needs `includeFounders` |
| `maxConcurrency` | integer | `4` | Searches, and company pages, in flight at once |
| `maxRunSecs` | integer | `240` | Wall-clock budget. Rows already written are kept and billed |
| `proxyConfiguration` | object | `{"useApifyProxy": true}` | Datacenter by default; switch to residential only if you see `blocked` rows |

Filters combine as an intersection: several values inside one field are "any of these", and different fields are "and". `{"batches": ["W25","S24"], "industries": ["B2B"], "isHiring": "yes"}` is *B2B companies from either batch that are hiring*.

### Output reference

| Column | Rows | Meaning |
|---|---|---|
| `ok`, `rowType` | all | `company`, `founder` or a free `diagnostic` |
| `id`, `name`, `slug`, `url`, `website` | company | YC's ID, name, directory page and the company's own site |
| `oneLiner`, `description` | company | The one-line pitch and the long description, as the founders wrote them |
| `batch`, `batchShort`, `status`, `stage` | company, founder | `Winter 2009` / `W09`; `Active` `Acquired` `Public` `Inactive`; `Early` or `Growth` |
| `industry`, `industries`, `subindustry`, `tags` | company | YC's taxonomy and its free-form labels |
| `regions`, `location`, `city`, `country` | company | Where the company is, at three levels of precision |
| `teamSize`, `launchedAt`, `yearFounded` | company | Headcount, when the profile went live, when the company was founded |
| `isHiring`, `jobPostingCount` | company | Whether it is hiring, and how many roles are posted |
| `topCompany`, `nonprofit`, `formerNames`, `logoUrl` | company | YC's flags, previous names, logo |
| `hasDemoDayVideo`, `hasAppVideo` | company | Whether those videos are public. The videos themselves are not returned |
| `founders`, `founderNames`, `founderCount` | company | The founders, nested and flattened. Needs `includeFounders` |
| `linkedin`, `twitter`, `facebook`, `crunchbase`, `github` | company, founder | The company's socials, or the founder's. Needs `includeFounders` |
| `name`, `title`, `company`, `companySlug` | founder | The person, their role, and the company they founded |
| `newsItems` | company | Up to ten press mentions YC has curated |
| `input`, `query`, `batchFilter`, `position` | all | Which filter or search produced this row, and its rank in the merged result |
| `error`, `errorType` | diagnostic | What went wrong, and a type to branch on |
| `source`, `sourceUrl`, `scrapedAt` | all | `index` or `both`, the company's page, and when the row was written |

`errorType` is one of `invalid-input`, `no-results`, `not-found`, `blocked`, `timeout`, `unavailable`.

### Pricing

**$0.50 per 1,000 companies.** Pay-per-event, with proxy already inside that number — there is no separate proxy line on your bill for this Actor.

| Event | What triggers it | FREE | Starter | Scale | Business |
|---|---|---|---|---|---|
| **Company returned** *(primary)* | One company row written to your dataset | $0.0005 | $0.0005 | $0.0004 | $0.0003 |
| Founder returned | One `founder` row, when `founderRows` is on | $0.00025 | $0.00025 | $0.00025 | $0.00025 |
| Run started | Once per run, after the first paid row | $0.001 | $0.001 | $0.001 | $0.001 |

**The whole directory.** `{"maxCompanies": 10000}`, no filters: 6,213 companies × $0.0005 + $0.001 = **$3.1075**, from 52 requests in a couple of minutes.

**One batch.** `{"batches": ["W25"]}`: 166 × $0.0005 + $0.001 = **$0.084**, from four requests.

**A hiring list, weekly.** `{"isHiring": "yes", "industries": ["B2B"], "maxCompanies": 1000}`: about 840 rows = **$0.421** a run, **$1.82** a month.

**With founders.** `includeFounders` costs nothing extra per row — the company price is the same either way. It costs *time*: one page load per company, so 500 companies is about four minutes. `founderRows: true` on top adds roughly 2.2 founder rows per company at $0.00025 each.

What you are never charged for: a batch or industry name that does not exist, a filter set that matched nothing, a company page that has gone, a company the run never reached before `maxRunSecs`, or a request the site blocked. If a whole run comes back empty it finishes SUCCEEDED with zero results and a status message that says why ("0 companies. N diagnostic row(s) explain why …"), and bills **nothing at all**, start fee included.

Set `ACTOR_MAX_TOTAL_CHARGE_USD` on a run and the Actor stops fetching once the ceiling is in sight, rather than handing you rows it cannot bill or billing you for rows it cannot hand over. It finishes SUCCEEDED with the ceiling named in its status message, and everything already delivered is yours.

### Limits, and the ones that might bite

**This is the public directory, and the public directory is what YC chose to publish.** There is **no funding amount, no valuation, no round history, no investor list, no revenue, no headcount history and no founder email address** in it — not because they are hard to scrape, but because they are not there. What is there is the sample row above: identity, category, status, size, place, time, and the founders' own public profiles. Anything claiming to be "YC data with funding" is joining this to another source.

**Team size is self-reported and lags.** YC updates it when the company does. Treat it as an order of magnitude, not a headcount.

**`status` is coarse.** `Acquired` does not say by whom or for how much. `Inactive` is YC's word for shut down and carries no date. `Public` is 23 companies.

**The 1,000-hit ceiling is real, and partitioning is the whole answer to it.** Every query — including each per-batch one — stops at 1,000 hits. It has never been reached by a batch query, because YC's largest batch is 398 companies, but a *search term* inside a single batch is also capped, and if YC ever runs a batch of over a thousand the run will report it rather than silently truncate.

**`nonprofitOnly` is applied after the fact.** `nonprofit` is a field on every company but not one of the index's filterable facets, so the run fetches the results and drops the rest. It costs the same requests as the unfiltered query and returns fewer rows.

**`includeFounders` is one page load per company.** A whole-directory run with it on is 6,265 requests and will not fit in the default `maxRunSecs`. Raise the budget, or filter first.

**News items are YC's list, not a news feed.** They are whatever YC curated onto the company's page, often years old, capped at ten.

**Ordering is YC's, not yours.** `default` is Algolia's relevance ranking for an empty query, which puts well-known companies first; `launchDate` is newest first. Neither is alphabetical, and `maxCompanies` cuts from the bottom of whichever you chose.

**The upstream format may change.** YC rewrites this front end periodically — it has been a Rails app, a Gatsby site and now a React/Inertia app — and the search key rotates on its own schedule. When a shape changes you get free `unavailable` or `blocked` diagnostic rows and a status message saying so rather than quietly wrong data, and a run that returns nothing bills nothing.

**Rate and reliability.** Requests go out through proxy sessions pinned per worker, one rotation per block, and 250–600 ms between requests of the same worker. Four in parallel is the default.

### Use it from an AI agent, or from code

One JSON object in, one flat array out — the shape agent runtimes want. The Actor runs with **limited permissions**, uses **pay-per-event** pricing and never enters Standby, so it works over the Apify MCP server and with x402 agentic payments. The **Integrations** tab pushes results to Slack, a webhook, Zapier, Make, Google Sheets, Snowflake or BigQuery.

```bash
curl -X POST "https://api.apify.com/v2/acts/insight.solutions~yc-companies-directory/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"batches":["W25"],"maxCompanies":500}'
```

```python
## pip install apify-client
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("insight.solutions/yc-companies-directory").call(run_input={
    "industries": ["Fintech"],
    "statuses": ["Active"],
    "isHiring": "yes",
    "maxCompanies": 1000,
})

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row["rowType"] == "company":
        print(row["batchShort"], row["name"], row["teamSize"], row["website"])
```

**Building an app with Lovable?** Apify's Lovable connector runs any Actor from inside a Lovable project with your Apify token. Connect Apify in Lovable once, then ask it: *"Use Apify to run insight.solutions/yc-companies-directory for a batch and industry I pick and build a searchable startup list around the results."* At the default settings a run finishes well inside Lovable's 300-second synchronous limit, and every result is one JSON object per row, so the generated app needs no extra parsing. Usage bills to the Apify account whose token is connected.

### FAQ

**Do I need a YC account?**
No. Everything here is what a logged-out visitor sees at ycombinator.com/companies, read through the same public search index the page's own filters use.

**How do I get the entire directory?**
Leave every filter empty and set `maxCompanies` to `10000`. You will get about 6,200 rows, because that is how many there are.

**Why is it about 6,200 and not "all YC companies ever"?**
Because the public directory lists the companies YC lists. A company that asked to be delisted is not there, and neither is one from a batch YC has not published yet.

**How do I deduplicate between runs?**
On `id`, YC's own numeric company ID, which is also the search index's `objectID`. It survives renames; `slug` does not, which is what `formerNames` is for.

**Can I get a company's funding, investors or revenue?**
Not from here — the public directory does not publish them. See *Limits*.

**Are founder emails included?**
No. YC does not publish them, and this Actor does not guess at them. You get the founders' names, titles and their own public LinkedIn and X profiles.

**Why did my batch name return nothing?**
It probably did not return nothing — check for an `invalid-input` diagnostic row, which names the nearest valid batches. `W25` and `Winter 2025` both work; `W2025` works too; `Spring 2026` is `X26`, not `S26`.

**How fresh is it?**
Live. Every run reads the directory at that moment; nothing is cached between runs, and the batch list itself is read fresh so a new batch appears the day YC publishes it.

**What happens if one batch fails?**
The other 49 still run. The failed one produces a free diagnostic row and the run finishes `SUCCEEDED` with the companies it did get. If *nothing* could be read, the run still finishes `SUCCEEDED`, with zero companies, a status message that says so and nothing billed at all. Only a filter set with nothing valid in it finishes `FAILED`.

### Legal and data-protection notes

- **Public pages and a public index only.** The directory, its search index and each company's page are what ycombinator.com serves to any visitor. The Actor never logs in, never accepts cookies or session tokens, and never uses an API key belonging to anyone else — the search-only key it uses is the one the page hands every browser that loads it, read fresh on every run.
- **Founder names and profiles are personal data.** They are published by YC and by the founders themselves, on purpose, as a public profile — but in most jurisdictions they remain personal data. Have a lawful basis before you use them for outreach, honour opt-outs, and check the marketing rules where you and the recipient are. This Actor returns no email addresses and no phone numbers.
- **Company descriptions belong to their companies.** The one-liners and long descriptions are copyrighted text the founders wrote. Indexing, analysis, filtering and linking are the ordinary uses and are what this is built for; republishing them wholesale is your call and your responsibility.
- **Logo URLs are not a licence.** `logoUrl` is the address YC serves the logo from. Trademarks belong to the companies.
- **Not affiliated with Y Combinator.** "Y Combinator" and "YC" are trademarks of Y Combinator Management, LLC, used here only to describe which public pages this Actor reads.

### Our other Actors

Every Insight Solutions Actor is pay-per-result with no browser, no login and no API key, and every one of them returns free diagnostic rows instead of billing for failures. Prices are per 1,000 results.

**Video, audio & social**

- [YouTube Transcript API](https://apify.com/insight.solutions/youtube-transcript-api) — captions as timed segments, text, SRT or VTT, with language fallback and translation.
- [YouTube Comments API](https://apify.com/insight.solutions/youtube-comments-api) — comments and replies with likes, pinned and hearted flags, newest or top sort.
- [YouTube Channel API](https://apify.com/insight.solutions/youtube-channel-api) — a channel's videos, Shorts and live streams, plus YouTube search.
- [Podcast Search, Episodes & Charts API](https://apify.com/insight.solutions/podcast-api) — Apple Podcasts search, charts and full episode feeds.
- [Bluesky Scraper](https://apify.com/insight.solutions/bluesky-scraper) — profiles, posts, followers and follows from the public AT Protocol API.
- [Telegram Channel Scraper](https://apify.com/insight.solutions/telegram-channel-scraper) — posts, views and channel stats from public Telegram channels.
- [Substack Scraper](https://apify.com/insight.solutions/substack-scraper) — posts with full free text, comments and publication profiles.
- [Hacker News API](https://apify.com/insight.solutions/hacker-news-api) — stories, comments, users, front page and a structured "Who is hiring?" parser from the official HN APIs.
- [GitHub Repos, Trending & Releases API](https://apify.com/insight.solutions/github-repos-api) — repository facts, trending lists, releases and search, no token needed for small runs.
- [Discourse Forum API](https://apify.com/insight.solutions/discourse-forum-api) — topics, posts and categories from any Discourse community via its own JSON endpoints, usernames only.

**News, documents & the web**

- [Google News Search, Topics & Real Article URLs](https://apify.com/insight.solutions/google-news-api) — news search and topic feeds with the publisher's real URL decoded.
- [Website to Markdown — Content Extractor for LLMs & RAG](https://apify.com/insight.solutions/website-content-extractor) — any site as clean Markdown, text and heading-aware chunks.
- [WordPress Posts & Pages API](https://apify.com/insight.solutions/wordpress-posts-api) — posts and pages from any WordPress site as clean text or Markdown, with categories, tags and images.
- [Website Metadata API](https://apify.com/insight.solutions/website-metadata-api) — any URL's meta tags, Open Graph, Twitter cards, hreflang, feeds, JSON-LD and microdata, with normalised Product, Article, Event and FAQ entities.
- [Subdomain Finder API](https://apify.com/insight.solutions/subdomain-finder-api) — every subdomain of a domain from certificate-transparency logs, resolved over DNS, with an optional live HTTP check.
- [Internet Archive API](https://apify.com/insight.solutions/internet-archive-api) — archive.org search, item metadata, files and reviews.
- [Wayback Machine Toolkit](https://apify.com/insight.solutions/wayback-toolkit) — archived URL inventories, snapshots and text diffs between dates.
- [Website Technology Detector](https://apify.com/insight.solutions/website-tech-detector) — the tech stack behind any site, with the evidence for each detection.
- [Domain Intelligence API](https://apify.com/insight.solutions/domain-intelligence-api) — DNS, RDAP registration, TLS certificate and HTTP facts in one row per domain.
- [SEO Page Audit](https://apify.com/insight.solutions/seo-page-audit) — sitemap crawl with on-page checks, structured data and broken-link reports.
- [Keyword Suggestions API](https://apify.com/insight.solutions/keyword-suggestions-api) — Google, YouTube, Bing, Amazon and eBay autocomplete with alphabet and question expansions.
- [Website Contact Extractor](https://apify.com/insight.solutions/website-contact-extractor) — emails, phone numbers and social profiles from any list of websites.
- [Web Search Results API](https://apify.com/insight.solutions/web-search-api) — Bing and DuckDuckGo organic results with snippets, no key, no browser.
- [Company Enrichment API](https://apify.com/insight.solutions/company-enrichment-api) — a domain in, a company profile out: firmographics, contacts, tech stack, DNS and hiring signal.
- [Company Dossier API](https://apify.com/insight.solutions/company-dossier-api) — one company in, twelve sections out: profile, tech, contacts, DNS, open roles, news, SEC filings, federal awards, recalls, YC batch and apps.
- [Press Releases API](https://apify.com/insight.solutions/press-releases-api) — GlobeNewswire and PR Newswire releases plus any newsroom feed, by keyword, company, ticker or subject.
- [Federal Register API](https://apify.com/insight.solutions/federal-register-api) — rules, proposed rules, notices and the Public Inspection desk with dockets, comment deadlines and CFR references.
- [Academic Papers Search API](https://apify.com/insight.solutions/academic-papers-api) — OpenAlex, Crossref, arXiv and PubMed in one row per paper: abstract, citations, open-access PDF, authors and venue.
- [RSS & Atom Feed Monitor](https://apify.com/insight.solutions/rss-feed-monitor) — any RSS, Atom or JSON feed (or an OPML file) in, only the new items out, with keyword filters and a webhook.
- [Website Change Monitor](https://apify.com/insight.solutions/website-change-monitor) — watch any pages, diff the text between runs, get change rows with added/removed lines, keyword alerts and a webhook.
- [Wikipedia & Wikidata API](https://apify.com/insight.solutions/wikipedia-api) — article text, search, daily pageviews and Wikidata entity facts, any language edition.

**Business, finance & jobs**

- [Congress & Insider Trades API](https://apify.com/insight.solutions/congress-insider-trades-api) — STOCK Act periodic transaction reports and SEC Form 4 insider trades in one schema.
- [Federal Contracts, Grants & Lobbying API](https://apify.com/insight.solutions/federal-contracts-grants-api) — SAM.gov opportunities, USAspending awards, Grants.gov notices and Senate lobbying filings in one schema.
- [SEC EDGAR API](https://apify.com/insight.solutions/sec-edgar-api) — filings, XBRL financials and full-text search by ticker or CIK.
- [Clinical Trials & FDA API](https://apify.com/insight.solutions/clinical-trials-fda-api) — ClinicalTrials.gov studies plus openFDA recalls, labels, approvals, 510(k)s and adverse-event reports.
- [Product & Vehicle Recalls API](https://apify.com/insight.solutions/product-recalls-api) — CPSC, NHTSA, FDA and USDA recalls, vehicle complaints and ratings, plus a VIN decoder.
- [Career Site Jobs API](https://apify.com/insight.solutions/ats-jobs-api) — jobs straight from Greenhouse, Lever, Ashby, Workable and 10+ other ATS career sites.
- [Workday Jobs API](https://apify.com/insight.solutions/workday-jobs-api) — every posting on any Workday career site, with facets, search, posted dates and full descriptions.
- [New Job Postings Monitor](https://apify.com/insight.solutions/job-postings-monitor) — new, closed and changed postings on the career sites you watch.
- [Hiring Signals API — Open Roles & Hiring Surge by Company](https://apify.com/insight.solutions/hiring-signals-api) — one row per company per run: open roles, what opened and closed, department and seniority breakdowns, and a hiring-surge flag.
- [Remote Jobs API](https://apify.com/insight.solutions/remote-jobs-api) — RemoteOK, Remotive, We Work Remotely, Himalayas, Jobicy and more in one schema, deduplicated.
- [Shopify Products API](https://apify.com/insight.solutions/shopify-products-api) — any Shopify store's catalogue, variants, prices and stock signals.
- [WooCommerce Products API](https://apify.com/insight.solutions/woocommerce-products-api) — any WooCommerce store's catalogue, prices, variants and stock through its public Store API.
- [Shopify App Store API](https://apify.com/insight.solutions/shopify-app-store-api) — Shopify App Store listings by category, collection or developer: pricing plans, ratings and merchant reviews.
- [Luma Events API](https://apify.com/insight.solutions/luma-events-api) — upcoming Luma events by city, category or calendar: dates, venue, price, capacity and organiser calendar, no host names.
- [Shopify Store Monitor](https://apify.com/insight.solutions/shopify-store-monitor) — price drops, sales, restocks, sell-outs and new products on any Shopify store, one row per change.
- [Public Tenders API](https://apify.com/insight.solutions/public-tenders-api) — EU TED, UK Find a Tender and Contracts Finder notices by keyword, CPV code, country, stage and deadline.
- [Nonprofit & IRS 990 Lookup API](https://apify.com/insight.solutions/nonprofit-990-api) — search US nonprofits and get EIN, NTEE code and multi-year Form 990 financials.
- [OpenStreetMap Places API](https://apify.com/insight.solutions/osm-places-api) — businesses and points of interest by category and area from OpenStreetMap: name, address, coordinates, website, phone, opening hours.

**Apps & games**

- [App Store & Google Play Reviews API](https://apify.com/insight.solutions/app-reviews-api) — reviews from both stores with ratings, versions and developer replies.
- [App Store Top Charts & App Search API](https://apify.com/insight.solutions/app-charts-api) — Apple top charts by country and genre, plus app search and details.
- [App Store Keyword Rank Tracker](https://apify.com/insight.solutions/app-store-keyword-rank-tracker) — where any app ranks for any keyword on the App Store and Google Play, with rank changes and ASO suggestions.
- [Steam Reviews API](https://apify.com/insight.solutions/steam-reviews-api) — Steam reviews with playtime, helpfulness and game details.
- [Steam Game Data API](https://apify.com/insight.solutions/steam-store-stats-api) — prices, tags, review scores, live player counts and top charts.
- [Sports Scores & Schedules API](https://apify.com/insight.solutions/sports-scores-api) — scores, schedules, standings, teams and headlines for the NFL, NBA, MLB, NHL, soccer and more, no key.
- [App Store Monitor](https://apify.com/insight.solutions/app-store-monitor) — App Store and Google Play listings watched between runs: new versions with release notes, price, rating and listing changes, one row per change.

# Actor input Schema

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

Which YC batches to return. Long form (`Winter 2025`, `Summer 2013`, `Spring 2026`, `Fall 2025`) or YC's own short form (`W25`, `S13`, `X26` for Spring, `F25` for Fall); several are read as "any of these". **Leave empty for every batch** — all 6,200-odd companies YC has ever funded. A name that is not a batch gets a free diagnostic row naming the nearest ones that are, checked against the directory's own live list at run start.

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

Only the companies YC itself flags as its top ones — about 90 of 6,200. That is the list Airbnb, Stripe, Coinbase, DoorDash and Instacart are on, and it is one request to get all of it.

## `nonprofitOnly` (type: `boolean`):

Only YC's nonprofit companies. `nonprofit` is a field on every company but it is **not** one of the index's filterable facets, so this one filter is applied after the results arrive rather than in the query — it costs the same requests as the unfiltered run and returns fewer rows.

## `isHiring` (type: `string`):

Restrict to companies with open roles on Work at a Startup, or to those without. About a quarter of the directory is hiring at any moment. The API also accepts `true`, `false` and `null` here, for callers that prefer a boolean.

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

**Relevance** is YC's default ordering — its own ranking, which puts the best-known companies first for an unfiltered read. **Launch date** is the directory's "newest first" index: the most recently launched companies at the top. It changes the order rows arrive in, and therefore which ones you get when `maxCompanies` cuts the list short.

## `queries` (type: `array`):

Full-text search across company names, one-liners and descriptions — `fintech`, `AI agents`, `developer tools`. Each term is a separate search and the results are merged; a company matching two terms is returned once, attributed to the first. Combine with the filters below and you get the intersection: `queries: ["AI agents"]` plus `isHiring: yes` is every hiring YC company whose description mentions AI agents.

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

YC's own industry taxonomy, two levels deep in one flat list: the parents (`B2B`, `Consumer`, `Healthcare`, `Fintech`, `Industrials`, `Real Estate and Construction`) and the children (`Payments`, `Recruiting and Talent`, `Drug Discovery and Delivery`, `Climate`). 59 values at the last count, and the run validates against the live list. Several values are read as "any of these".

## `statuses` (type: `array`):

`Active`, `Acquired`, `Public` or `Inactive` — YC's four. `Inactive` means dead, and there are over a thousand of them: this is the only public list of YC failures, and leaving it out of a market map is how you get survivorship bias. Empty means all four.

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

YC's region facet, which mixes continents, countries and remote-work labels in one list: `United States of America`, `America / Canada`, `Europe`, `India`, `Latin America`, `Remote`, `Fully Remote`, `Partly Remote`. A company usually carries two or three of them. Several values are read as "any of these".

## `tags` (type: `array`):

The free-form labels YC puts on a company: `SaaS`, `Marketplace`, `Artificial Intelligence`, `Generative AI`, `Developer Tools`, `Open Source`, `Biotech`. Finer-grained than `industries` and much longer — several hundred values. Several tags are read as "any of these".

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

Read each company's own YC page as well, adding **founders** (name, title, LinkedIn, X), the company's LinkedIn, X, Facebook, Crunchbase and GitHub links, the year it was founded, its city and country, how many roles it has open, and its recent press. **This is one extra request per company** — 500 companies is 500 extra page loads and several minutes — so it is off by default. The company rows cost the same either way; only the run takes longer.

## `founderRows` (type: `boolean`):

Add a `founder` row for every named founder — company, batch, name, title, LinkedIn, X — alongside the company row that already lists them. Useful when the founder is your unit of analysis rather than the company. Needs `includeFounders`, and founder rows are charged separately.

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

How many company rows to return, across every batch and search term in this run. The whole directory is about 6,200; the default of 500 keeps a first run quick and cheap. Raising it costs one request per extra 1,000 companies, not one per company.

## `maxRunSecs` (type: `integer`):

Wall-clock budget for the whole run. When it is reached the Actor stops fetching, keeps and bills for every row it already wrote, and files a free diagnostic row saying where it stopped. Nothing is charged for work that did not happen. Raise it for a whole-directory run with `includeFounders`, which is thousands of page loads.

## `maxConcurrency` (type: `integer`):

How many searches — and, separately, how many company pages — are read at once. Each parallel worker keeps its own proxy session, so one refused request burns only its own exit IP. Requests within one worker are spaced 250–600 ms apart whatever this is set to.

## `proxyConfiguration` (type: `object`):

Both ycombinator.com and the search index answer datacenter addresses, so the default is Apify's datacenter proxy — much cheaper than residential, and the proxy cost is already inside the per-row price. Switch to residential only if you see `blocked` rows. Sessions rotate automatically when an exit IP is refused.

## Actor input object example

```json
{
  "batches": [
    "W25",
    "S24",
    "Winter 2023"
  ],
  "topCompaniesOnly": false,
  "nonprofitOnly": false,
  "isHiring": "any",
  "sortBy": "default",
  "queries": [
    "fintech",
    "AI agents"
  ],
  "industries": [
    "B2B",
    "Fintech"
  ],
  "statuses": [
    "Active",
    "Acquired"
  ],
  "regions": [
    "Europe",
    "Remote"
  ],
  "tags": [
    "SaaS",
    "Marketplace"
  ],
  "includeFounders": false,
  "founderRows": false,
  "maxCompanies": 500,
  "maxRunSecs": 240,
  "maxConcurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One row per YC company — name, website, one-liner, description, batch, status, industry, tags, team size, region, launch date — plus one row per founder when you ask for them. Delivered as JSON items in the default dataset.

# 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": [
        "Winter 2025"
    ],
    "topCompaniesOnly": false,
    "nonprofitOnly": false,
    "isHiring": "any",
    "sortBy": "default",
    "queries": [],
    "industries": [],
    "statuses": [],
    "regions": [],
    "tags": [],
    "includeFounders": false,
    "founderRows": false,
    "maxCompanies": 500,
    "maxConcurrency": 4,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("insight.solutions/yc-companies-directory").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": ["Winter 2025"],
    "topCompaniesOnly": False,
    "nonprofitOnly": False,
    "isHiring": "any",
    "sortBy": "default",
    "queries": [],
    "industries": [],
    "statuses": [],
    "regions": [],
    "tags": [],
    "includeFounders": False,
    "founderRows": False,
    "maxCompanies": 500,
    "maxConcurrency": 4,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("insight.solutions/yc-companies-directory").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": [
    "Winter 2025"
  ],
  "topCompaniesOnly": false,
  "nonprofitOnly": false,
  "isHiring": "any",
  "sortBy": "default",
  "queries": [],
  "industries": [],
  "statuses": [],
  "regions": [],
  "tags": [],
  "includeFounders": false,
  "founderRows": false,
  "maxCompanies": 500,
  "maxConcurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call insight.solutions/yc-companies-directory --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,insight.solutions/yc-companies-directory"
        }
    }
}
```

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/mXEx9fvriBmduW6tw/builds/Ec8ajATcp9FDcTOZu/openapi.json