# Y Combinator Companies API — Directory by Batch & Industry (`highbrow_fame/y-combinator-companies-api`) Actor

All YC companies with batch, status, industry, team size, location, website, one-liner and tags from the public YC Startup Directory; search by keyword, batch or industry. Unofficial Y Combinator API.

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

## Pricing

$0.50 / 1,000 companies

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/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 API — Directory by Batch & Industry

Every company in the YC Startup Directory as one clean JSON record: name, batch, status (Active, Acquired, Public, Inactive), industry and sub-industry, tags, team size, location and regions, website, one-liner, long description, stage, launch date, hiring and Top Company flags, former names and logo. Search by keyword, filter by batch (W24, S23, X25 …), industry, status or region — the same public search index the directory page itself uses, read without a login or key of your own.

**Try it in 1 minute:**

1. Press **Start** — the prefilled input searches the directory for "AI agents" and returns the first 100 matches.
2. Seconds later the **Output** tab shows one record per company: batch, status, industry, team size, location, website, one-liner, tags and the YC page link.
3. Download JSON, CSV or Excel, or add **Batches** (one per line) to read whole batches — or the whole directory — and narrow by **Industries**, **Status** or **Regions**.

Price: **$0.50 per 1,000 companies** (one company = one record). A search without matches and a search that could not be run are free.

**Use it to:**

- Build a lead list of every YC company in a batch or industry — fintech in W24 and S24, say — with website, location and team size, straight into your CRM.
- Keep a startup database or market map fresh: the directory holds about 6,300 companies, and a run per batch reads all of them.
- Find companies that are hiring in a region ("hiring" plus "Europe" or "Remote") for a job board or an outreach campaign.
- Feed an AI agent or research notebook: ask for "climate", "robotics" or "developer tools" and get structured, deduplicated results with descriptions.
- Track a batch over time — status changes (Acquired, Public, Inactive), team-size growth and new launches — on a schedule.

### How it works

1. The Actor opens the public directory page (`ycombinator.com/companies`) once per run and reads the Algolia application id and the search-only key the page embeds. That key is minted for every page load and expires after about a day, so it is never stored — it is read fresh each run. (The index name is decoded from the key's own restrictions; the application id and index name also have built-in fallbacks.)
2. It then queries the same Algolia index the page uses: your **Search query** as the full-text query, and your batches, industries, statuses, regions, hiring and top-company switches as facet filters. Results come in pages of 100, up to **Max results** per search.
3. Algolia stops every search at 1,000 hits, which is why **Batches** are searched one at a time: a batch has a few hundred companies, so a list of batches reads the whole directory. `position` is the company's place in its search; `input` says which search it came from.
4. One record per company. Only the company attributes are requested from the index — founder names are never retrieved — and e-mail addresses and phone numbers are removed from descriptions.

Requests go directly to ycombinator.com and Algolia (no proxy, unless a connection drops); a rate limit (HTTP 429) is waited out and retried.

### Input

| Field | What it does |
|---|---|
| `query` | Keywords to search for (names, one-liners, descriptions, tags). Empty = filters only. |
| `batches` | Batches, one per line: `W24`, `S23`, `F25`, `X25` (Spring 2025) or `Winter 2024`. Each batch is its own search. |
| `industries` | Industry names, one per line: `B2B`, `Fintech`, `Healthcare`, `Consumer`, `Industrials`, or a sub-industry such as `Infrastructure`, `Security`, `Legal`. Case does not matter. |
| `statuses` | `Active`, `Acquired`, `Public`, `Inactive` (any of them). |
| `maxResults` | Companies per search (per batch), up to 1,000; default 100. |
| `includeDescription` | Add the long description (default on). |
| `regions` | Region or country names: `Europe`, `United States of America`, `United Kingdom`, `India`, `Remote`, `Fully Remote` … |
| `onlyHiring` | Only companies marked as hiring. |
| `onlyTopCompanies` | Only companies on YC's Top Companies list. |
| `maxConcurrency` | Batches searched in parallel (default 2). |
| `proxyConfiguration` | Used only to retry after a network error; the first try is direct. |

### Output

One record per company:

| Field | What it is |
|---|---|
| `id`, `name`, `slug`, `url` | Identity and the company's page on ycombinator.com |
| `website`, `logo` | The company's site and small logo |
| `oneLiner`, `description` | The pitch and the long description (contacts removed; `description` null when switched off) |
| `batch`, `companyStatus`, `stage`, `launchedAt` | `Winter 2024`-style batch, Active / Acquired / Public / Inactive, Early / Growth, launch date (ISO 8601) |
| `industry`, `subindustry`, `industries[]`, `tags[]` | Classification as the directory files it |
| `teamSize`, `location`, `regions[]` | People (integer), locations text, region and country names plus Remote flags |
| `isHiring`, `isTopCompany`, `isNonprofit`, `formerNames[]` | Flags and earlier names |
| `input`, `position` | Which search the record came from (query and filters in words) and its 1-based position there |
| `status`, `error`, `scrapedAt` | `OK` / `NO_RESULTS` / `FAILED`, the reason, and when |

#### Example

```json
{
  "input": "\"AI agents\" [batch: Fall 2026]",
  "position": 1,
  "id": 35422,
  "name": "Praxis",
  "slug": "praxis",
  "url": "https://www.ycombinator.com/companies/praxis",
  "website": "https://runpraxis.ai",
  "oneLiner": "AI agents that run law firm operations.",
  "description": "At Praxis, we've built AI agents that run law firm operations, from first inquiry to paid invoice.",
  "batch": "Fall 2026",
  "companyStatus": "Active",
  "industry": "B2B",
  "subindustry": "B2B -> Legal",
  "industries": ["B2B", "Legal"],
  "tags": ["Legal", "LegalTech", "AI"],
  "teamSize": 2,
  "location": "San Francisco, CA, USA",
  "regions": ["United States of America", "America / Canada"],
  "stage": "Early",
  "launchedAt": "2026-10-14T21:59:49.000Z",
  "isHiring": false,
  "isTopCompany": false,
  "isNonprofit": false,
  "formerNames": [],
  "logo": "https://bookface-images.s3.amazonaws.com/small_logos/aac3b9688bfcfe828ca1449c50d9d85d7e55ad89.png",
  "status": "OK",
  "error": null,
  "scrapedAt": "2026-10-19T12:00:00.000Z"
}
```

### FAQ

**Is this an official API?** No, it's an unofficial API built on public pages — the YC Startup Directory and the public, search-only Algolia index that renders it. The data is exactly what the directory shows; this Actor only shapes it into stable JSON records.

**How do I get the whole directory?** List every batch in **Batches** (W05 … S26 and the newer F and X batches) and set **Max results** to 1,000. Each batch is one search of a few hundred companies, so nothing is cut off. A single unfiltered search stops at 1,000 — that is Algolia's limit, not ours.

**Does it include founders?** No. Founder names and profiles are not requested from the index and never appear in the output. Descriptions are scrubbed of e-mail addresses and phone numbers.

**Why does my batch give NO_RESULTS?** Batches are spelled `W24`, `S23`, `F25`, `X25` or `Winter 2024`; a typo such as `WI24` matches nothing. Industry and region names must be the directory's own (`Fintech`, `Real Estate and Construction`, `United Kingdom`); case does not matter.

**What happens when YC changes the page?** The search key is read from the page on every run. If the page stops exposing it, the run ends with a free `FAILED` record saying so instead of guessing — tell us on the Issues tab and we fix it.

**Like it?** A short review on the Store page helps other people find this Actor. Something missing or broken? Tell us on the Issues tab — we read every one.

### Related Actors

- [Hacker News Scraper](https://apify.com/highbrow_fame/hacker-news-stories) — stories, comments and search
- [Website Tech Stack Detector](https://apify.com/highbrow_fame/website-tech-stack) — CMS, frameworks and analytics of any site
- [Google News API](https://apify.com/highbrow_fame/google-news-api) — headlines by keyword and topic
- [Sitemap Extractor](https://apify.com/highbrow_fame/sitemap-url-extractor) — every URL, date and image from a site's sitemaps
- [Article Extractor API](https://apify.com/highbrow_fame/article-extractor-api) — title, author, date and full text of any article

# Actor input Schema

## `query` (type: `string`):

Keywords to search the YC Startup Directory for — matched against company names, one-liners, descriptions and tags (e.g. "AI agents", "climate", "payments"). Leave empty to list companies by the filters below only.

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

YC batches, one per line: W24, S23, F25, X25 (Spring 2025) or spelled out ("Winter 2024"). Each batch is searched separately, so a list of batches is the way to read the whole directory (Algolia pages at most 1,000 companies per search). Empty = every batch.

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

Industry names as the directory spells them, one per line: B2B, Fintech, Healthcare, Consumer, Industrials, Education, Government, Real Estate and Construction, or a sub-industry such as Infrastructure, Security, Sales, Legal. Case does not matter; any of them matches.

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

Keep only companies with these statuses. Empty = all.

## `maxResults` (type: `integer`):

Companies per search (per batch when batches are given). The directory's search pages at most 1,000 companies per search; filter by batch to go beyond that.

## `includeDescription` (type: `boolean`):

Add the company's long description (`description`). Switch off for a compact, spreadsheet-friendly record.

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

Region or country names as the directory spells them, one per line: United States of America, America / Canada, Europe, United Kingdom, Germany, India, South Asia, Remote, Fully Remote, Partly Remote … Any of them matches.

## `onlyHiring` (type: `boolean`):

Keep only companies the directory marks as hiring.

## `onlyTopCompanies` (type: `boolean`):

Keep only companies on YC's Top Companies list.

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

How many batches are searched at the same time (each search reads its pages one after another).

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

Used only to try again after a network error: ycombinator.com and Algolia answer directly, so the first try of every request goes out without a proxy.

## Actor input object example

```json
{
  "query": "AI agents",
  "batches": [],
  "industries": [],
  "statuses": [],
  "maxResults": 100,
  "includeDescription": true,
  "regions": [],
  "onlyHiring": false,
  "onlyTopCompanies": false,
  "maxConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Every result as a JSON record, with a status for each input.

## `resultsCsv` (type: `string`):

The same records as CSV, for a spreadsheet.

# 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 = {
    "query": "AI agents",
    "batches": [],
    "industries": [],
    "statuses": [],
    "regions": [],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("highbrow_fame/y-combinator-companies-api").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 = {
    "query": "AI agents",
    "batches": [],
    "industries": [],
    "statuses": [],
    "regions": [],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("highbrow_fame/y-combinator-companies-api").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 '{
  "query": "AI agents",
  "batches": [],
  "industries": [],
  "statuses": [],
  "regions": [],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call highbrow_fame/y-combinator-companies-api --silent --output-dataset

```

## MCP server setup

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

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/yp0IVW5Eof3tYxC26/builds/u6BvVHB7mqhY8tqDt/openapi.json