# Y Combinator Startups Scraper (`automation-lab/ycombinator-scraper`) Actor

Extract Y Combinator startup data: company names, websites, descriptions, team sizes, batches, industries, and hiring status. Filter by batch (W24, S23), status, industry, or tags. Uses the official YC API — no proxy needed. Export as JSON, CSV, or Excel.

- **URL**: https://apify.com/automation-lab/ycombinator-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **Stats:** 81 total users, 3 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 company scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Y Combinator Startups Scraper

### What does Y Combinator Startups Scraper do?

**Y Combinator Startups Scraper** extracts structured data from the [Y Combinator startup directory](https://www.ycombinator.com/companies). It uses the official YC API to collect company profiles including names, websites, descriptions, team sizes, batch info, industries, funding status, and hiring data.

The scraper covers **5,800+ YC-backed startups** from all batches (2005-present). Filter by batch (W24, S23), status (Active, Acquired, Public), industry, region, tags, or hiring status. No browser, no proxy, no login needed — pure HTTP API access.

Try it now on Apify with the **"Start"** button — the prefilled input scrapes 25 AI startups in seconds.

### Who is it for?

**Venture Capital & Angel Investors**

- Track new YC batches as they launch to discover investment opportunities early
- Filter by industry + status to find active startups in your investment thesis
- Monitor acquired/public companies for exit pattern analysis

**Sales & Business Development Teams**

- Build targeted lead lists of YC-backed companies by industry and team size
- Identify companies currently hiring (growing = budget for new tools)
- Enrich with website URLs for outbound prospecting campaigns

**Market Researchers & Analysts**

- Analyze YC batch composition trends across industries and regions
- Track startup survival rates by batch vintage
- Study which industries YC is betting on each season

**Recruiters & Talent Teams**

- Find YC startups that are actively hiring
- Target companies by team size (early-stage vs growth-stage)
- Build lists of potential employer partners by industry

### Why use Y Combinator Startups Scraper?

- **Reliable data source** — uses the official YC API, not fragile HTML scraping. No breakage when YC redesigns their website
- **Complete coverage** — access all 5,800+ companies in the YC directory, including historical batches back to 2005
- **Rich filtering** — search by keyword, batch, status, industry, region, tags, hiring status, and top company designation
- **No proxy or login needed** — the YC API is public and free. Zero anti-bot measures
- **Pay only for what you scrape** — PPE pricing means you pay per company extracted, not per run
- **API-first** — integrate with any workflow via the Apify API. Schedule runs, export to Google Sheets, trigger webhooks
- **Fast** — HTTP-only actor runs at 256 MB. Scrapes hundreds of companies in seconds

### What data can you extract?

Each Y Combinator company profile includes:

| Field | Description |
|-------|-------------|
| `name` | Company name |
| `slug` | URL slug on YC |
| `website` | Company website URL |
| `oneLiner` | Short company description |
| `longDescription` | Full company description |
| `teamSize` | Number of employees |
| `batch` | YC batch (e.g., W24, S23, F25) |
| `status` | Active, Acquired, Inactive, or Public |
| `industries` | Array of industries (e.g., B2B, Healthcare, Fintech) |
| `regions` | Geographic regions |
| `locations` | Specific city/state/country |
| `tags` | Tags (e.g., Artificial Intelligence, SaaS) |
| `isHiring` | Whether the company is currently hiring |
| `isTopCompany` | YC top company designation |
| `smallLogoUrl` | Company logo URL |
| `ycUrl` | Full YC profile URL |
| `scrapedAt` | Timestamp of data extraction |

### How much does it cost to scrape Y Combinator startups?

This Actor uses **pay-per-event** pricing — you pay only for what you scrape.
No monthly subscription. All platform costs are **included**.

| | Free | Starter ($29/mo) | Scale ($199/mo) | Business ($999/mo) |
|---|---|---|---|---|
| **Per company** | $0.0023 | $0.002 | $0.00156 | $0.0012 |
| **100 companies** | $0.23 | $0.20 | $0.156 | $0.12 |
| **1,000 companies** | $2.30 | $2.00 | $1.56 | $1.20 |
| **All 5,800 companies** | $13.34 | $11.60 | $9.05 | $6.96 |

Higher-tier plans get additional volume discounts.

**Real-world cost examples:**

| Query | Results | Duration | Cost (Free tier) |
|---|---|---|---|
| "AI" startups, 25 companies | 25 | ~3s | ~$0.06 |
| W24 batch, all companies | ~50 | ~5s | ~$0.12 |
| All active startups currently hiring | ~300 | ~15s | ~$0.70 |

With the free $5 Apify credit, you can scrape **~2,100 companies** at no cost.

### How to scrape Y Combinator startups

1. Go to the [Y Combinator Startups Scraper](https://apify.com/automation-lab/ycombinator-scraper) page on Apify Store
2. Click **"Start"** to open the actor in Apify Console
3. Configure your search filters:
   - Enter a **search query** (e.g., "AI", "fintech") or leave empty for all companies
   - Select a **YC batch** (e.g., "W24") to focus on a specific cohort
   - Choose a **status** filter (Active, Acquired, Inactive, Public)
   - Toggle **Currently hiring only** to find growing companies
4. Set the **Max companies** limit (start small with 25 to preview results)
5. Click **"Start"** to run the scraper
6. Download results in JSON, CSV, Excel, or connect via API

**Example input — scrape all W24 AI startups:**

```json
{
    "searchQuery": "AI",
    "batch": "W24",
    "maxCompanies": 100
}
```

**Example input — find hiring startups in healthcare:**

```json
{
    "industry": "Healthcare",
    "isHiring": true,
    "maxCompanies": 200
}
```

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQuery` | string | `""` | Search by company name or description |
| `batch` | string | `""` | YC batch filter (e.g., W24, S23, F25) |
| `status` | string | `""` | Company status: Active, Acquired, Inactive, Public |
| `industry` | string | `""` | Industry filter (e.g., Healthcare, Fintech, B2B) |
| `region` | string | `""` | Region filter (e.g., United States, Europe) |
| `isHiring` | boolean | `false` | Only companies currently hiring |
| `tags` | string | `""` | Tag filter (e.g., Artificial Intelligence, SaaS) |
| `isTopCompany` | boolean | `false` | Only YC top companies |
| `maxCompanies` | integer | `100` | Max companies to scrape (0 = unlimited) |

### Output example

```json
{
    "id": 30837,
    "name": "AirCaps",
    "slug": "aircaps",
    "website": "https://aircaps.com/",
    "smallLogoUrl": "https://bookface-images.s3.amazonaws.com/small_logos/839111803eb4ccce6e6e411847617a96d8d7d880.png",
    "oneLiner": "The AI copilot for in-person conversations.",
    "longDescription": "AirCaps is bringing AI assistance to in-person conversations...",
    "teamSize": 2,
    "ycUrl": "https://www.ycombinator.com/companies/aircaps",
    "batch": "F25",
    "status": "Active",
    "industries": ["Consumer"],
    "regions": ["United States of America", "America / Canada"],
    "locations": ["San Francisco, CA, USA"],
    "tags": ["Artificial Intelligence", "Productivity", "AI", "Conversational AI"],
    "badges": [],
    "isHiring": false,
    "isTopCompany": false,
    "scrapedAt": "2026-03-30T12:00:00.000Z"
}
```

### Tips for best results

- **Start small** — use `maxCompanies: 25` for your first run to preview the data and estimate costs
- **Use server-side filters first** — `searchQuery`, `batch`, `status`, `tags`, and `isHiring` are filtered server-side and run faster than `industry` or `region` (which require scanning all pages)
- **Combine filters** — narrow down results by combining batch + status + tags for precise targeting
- **Schedule weekly runs** — set up a scheduled run to track new YC companies as batches launch
- **Export to Google Sheets** — use the Apify Google Sheets integration for automatic updates to your CRM or deal flow tracker
- **All 5,800+ companies** — set `maxCompanies: 0` to scrape the entire YC directory (takes ~2 minutes)

### Integrations

- **Y Combinator Scraper → Google Sheets** — automatically update your deal flow spreadsheet with new YC startups each week
- **Y Combinator Scraper → Slack** — get notified when new companies match your investment criteria (e.g., Healthcare + hiring)
- **Y Combinator Scraper → Zapier/Make** — trigger outbound email sequences when new startups appear in your target industry
- **Y Combinator Scraper → CRM (HubSpot, Salesforce)** — enrich your pipeline with YC company data including website, team size, and description
- **Scheduled runs** — run weekly to catch new batch announcements and company status changes
- **Webhooks** — trigger downstream processing as soon as a scrape completes

### API usage

You can access Y Combinator Startups Scraper programmatically using the Apify API.

#### Node.js

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('automation-lab/ycombinator-scraper').call({
    searchQuery: 'AI',
    batch: 'W24',
    maxCompanies: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')

run = client.actor('automation-lab/ycombinator-scraper').call(run_input={
    'searchQuery': 'AI',
    'batch': 'W24',
    'maxCompanies': 50,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~ycombinator-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQuery": "AI", "batch": "W24", "maxCompanies": 50}'
```

### Use with AI agents via MCP

Y Combinator Startups Scraper is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).

Add the Apify MCP server to your AI client — this gives you access to all Apify actors, including this one:

#### Setup for Claude Code

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

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

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

Your AI assistant will use OAuth to authenticate with your Apify account on first use.

#### Example prompts

Once connected, try asking your AI assistant:

- "Use automation-lab/ycombinator-scraper to find all AI startups from the W24 YC batch"
- "Scrape Y Combinator companies that are currently hiring in healthcare"
- "Get the full list of YC top companies with their websites and team sizes"

Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

### Legality

This actor accesses publicly available data from the Y Combinator company directory through their public API. The data is freely accessible without authentication.

We follow ethical scraping practices:

- Only access publicly available information
- Use the official public API (no bypassing access controls)
- Respect rate limits and server resources
- Do not collect personal data beyond what companies voluntarily publish

For more information, see the [Apify ethical web scraping guide](https://blog.apify.com/is-web-scraping-legal/).

### FAQ

**How fast is the scraper?**
Very fast — since it uses a direct API, there's no browser rendering or HTML parsing. It can scrape 100 companies in about 5 seconds and the entire 5,800+ company database in under 2 minutes.

**How much does it cost to scrape all YC companies?**
On the free tier, scraping all 5,800+ companies costs approximately $13.34. With the free $5 Apify credit, you can scrape about 2,100 companies at no cost.

**Is this better than scraping the YC website directly?**
Yes — this actor uses the official YC API, which is faster, more reliable, and less likely to break than HTML scraping. You get structured JSON data directly without any parsing.

**Why do some companies have empty descriptions?**
Some YC companies don't fill in their `longDescription` on the YC directory. The `oneLiner` field is almost always populated, but `longDescription` may be empty for newer or less active companies.

**Why does the industry filter take longer?**
The YC API doesn't support industry filtering server-side, so the scraper must scan all pages and filter locally. Use `searchQuery`, `batch`, `status`, or `tags` filters for faster results — those are processed server-side.

### Related actors

- [Greenhouse Jobs Scraper](https://apify.com/automation-lab/greenhouse-jobs-scraper) — scrape job listings from Greenhouse-powered career pages
- [Google Jobs Scraper](https://apify.com/automation-lab/google-jobs-scraper) — extract job postings from Google Jobs search
- [LinkedIn Jobs Scraper](https://apify.com/automation-lab/linkedin-jobs-scraper) — scrape LinkedIn job listings
- [ProductHunt Scraper](https://apify.com/automation-lab/producthunt-scraper) — extract products and launches from Product Hunt
- [Clutch Scraper](https://apify.com/automation-lab/clutch-scraper) — scrape company profiles from Clutch.co
- [Glassdoor Reviews Scraper](https://apify.com/automation-lab/glassdoor-reviews-scraper) — extract company reviews from Glassdoor

# Actor input Schema

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

Search by company name or description. Leave empty to scrape all companies.

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

Filter by YC batch (e.g., W24, S23, W22). Leave empty for all batches.

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

Filter by company status.

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

Filter by industry (e.g., B2B, Healthcare, Fintech). Leave empty for all industries.

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

Filter by region (e.g., United States of America, Europe). Leave empty for all regions.

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

Only include companies that are currently hiring.

## `tags` (type: `string`):

Filter by tags (e.g., Artificial Intelligence, SaaS). Leave empty for all tags.

## `isTopCompany` (type: `boolean`):

Only include YC top companies.

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

Maximum number of companies to scrape. Set to 0 for unlimited.

## Actor input object example

```json
{
  "searchQuery": "AI",
  "status": "",
  "isHiring": false,
  "isTopCompany": false,
  "maxCompanies": 20
}
```

# Actor output Schema

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

No description

# 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 = {
    "searchQuery": "AI",
    "batch": "",
    "status": "",
    "industry": "",
    "region": "",
    "tags": "",
    "maxCompanies": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/ycombinator-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQuery": "AI",
    "batch": "",
    "status": "",
    "industry": "",
    "region": "",
    "tags": "",
    "maxCompanies": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/ycombinator-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQuery": "AI",
  "batch": "",
  "status": "",
  "industry": "",
  "region": "",
  "tags": "",
  "maxCompanies": 20
}' |
apify call automation-lab/ycombinator-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/ycombinator-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/eNlUgahrtGPs1kZCc/builds/ekFfAkwN65rdYdHYj/openapi.json