# Y Combinator Scraper — 6,100+ Startups, Founder LinkedIn (`themineworks/y-combinator-scraper`) Actor

Extract Y Combinator startups straight from YC's own directory: company, batch, description, website, industries, and founder names with LinkedIn/Twitter URLs. No login, no browser, pure JSON. Use it as an MCP server in Claude, ChatGPT & AI agents.

- **URL**: https://apify.com/themineworks/y-combinator-scraper.md
- **Developed by:** [The Mine Works](https://apify.com/themineworks) (community)
- **Categories:** Lead generation, Business, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.40 / 1,000 startup lead 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

# README

## 🚀 Y Combinator Scraper: Startups, Founders & LinkedIn (No Login)

Y Combinator's own directory at [ycombinator.com/companies](https://www.ycombinator.com/companies) lists over 6,100 funded startups — but it's a JavaScript-driven grid with no bulk export, no public REST API, and no way to filter by batch, industry and hiring status and get a clean spreadsheet back. This actor queries YC's own public search index directly and turns the directory into structured leads: company, batch, description, website, industries, and — where YC itself publishes them — founder full names, titles, LinkedIn and X/Twitter URLs.

### What it does

For every company matching your filters, you get:

- **Company details**: name, YC batch (both "Winter 2024" and shorthand "W24"), one-liner, full description, website, industries, tags, status (Active/Inactive/Acquired/Public), stage, team size, location, founded year, and whether YC currently marks it as hiring.
- **Founder identity**: full name, title (e.g. "Founder/CEO"), and personal LinkedIn/X URLs for every founder YC lists on the company's own profile page — real, public data, not a guess.
- **Company socials**: LinkedIn, X/Twitter and Crunchbase pages for the company itself, pulled from the same profile page.
- **Optional website contact**: a genuinely-published email address, if you turn on the website-contact check and the company has one live on their homepage.

### How it works (and what it deliberately does not do)

YC's `/companies` page is a Rails + Inertia.js app. The company grid itself is **not** server-rendered — it's populated client-side by a call to YC's own public Algolia search index, using a scoped, read-only key that YC ships to every visitor's browser and restricts (server-side, via Algolia's own security rules) to only ever return publicly-listed companies. This actor calls that exact same index with that exact same key — the same request your browser makes when you load the page — over plain HTTP. No browser, no residential proxy, no anti-bot wall: this is a JSON API call, not a scrape of rendered pixels, which is why it's fast and priced the way it is.

Founder identity is different: it genuinely only exists on each company's individual profile page (`ycombinator.com/companies/{slug}`), which **is** server-rendered — the page ships the founder list as an embedded JSON payload inside the HTML. Fetching it costs one extra plain HTTP request per company (still no browser needed), which is why founder lookups are a togglable option — turn them off for a faster, company-only pull.

**We do not guess or generate email addresses.** YC's own public data never contains a founder's email — the company profile page ships an internal `has_email` flag but gates the actual address behind YC's own logged-in "request an intro" feature, which this actor cannot and does not access. The only email this actor will ever report is one your target company chose to publish itself, and only when you explicitly enable `scrapeWebsiteContact` — it visits the company's own homepage once and reports a `mailto:` link if one is genuinely there. Nothing is inferred, pattern-matched, or verified by SMTP probe.

### 🧾 Input configuration

| Field | Type | Description |
|---|---|---|
| `keyword` | string | Full-text search across name, one-liner and description (e.g. "AI agents for sales"). |
| `batch` | array | YC batch(es), shorthand ("W24", "S23", "F24", "Sp25") or full form ("Winter 2024"). |
| `industries` | array | YC's broad category, exact match (e.g. "B2B", "Fintech", "Healthcare"). |
| `tags` | array | YC's finer tags, exact match (e.g. "SaaS", "Developer Tools", "Generative AI"). |
| `hiringStatus` | select | `any` / `hiring` / `not_hiring` — filters on YC's own "currently hiring" flag. |
| `maxResults` | integer | Max companies to return leads for (1-500), most-relevant/most-recent first. |
| `fetchFounders` | boolean | Pull founder names, titles and LinkedIn/X URLs from each company's profile page. Default on. |
| `scrapeWebsiteContact` | boolean | Check the company's own homepage for a published contact email. Default off. |

### 📤 Example input

```json
{
  "keyword": "developer tools",
  "batch": ["W24"],
  "hiringStatus": "any",
  "maxResults": 25,
  "fetchFounders": true,
  "scrapeWebsiteContact": false
}
```

### Example output record

```json
{
  "company": "Hatchet",
  "slug": "hatchet-run",
  "batch": "Winter 2024",
  "batch_code": "W24",
  "one_liner": "The orchestration platform for teams who ship.",
  "website": "https://hatchet.run",
  "yc_url": "https://www.ycombinator.com/companies/hatchet-run",
  "industries": "B2B, Infrastructure",
  "tags": "Developer Tools, Open Source, Infrastructure",
  "status": "Active",
  "stage": "Early",
  "is_hiring": false,
  "team_size": 7,
  "location": "New York City, NY, USA",
  "founded_year": 2023,
  "company_linkedin_url": "https://www.linkedin.com/company/hatchet-run",
  "company_twitter_url": "https://twitter.com/hatchet_dev",
  "founder_name": "Alexander Belanger",
  "founder_title": "Founder",
  "founder_linkedin_url": "https://linkedin.com/in/alexander-belanger-aa3974135",
  "source": "yc-directory",
  "retrieved_live": true,
  "scraped_at": "2026-08-02T14:23:39.588Z"
}
```

Each founder at a company gets its own row (all company fields repeated), so a 3-founder startup yields 3 rows. If founder lookups are off, or a company genuinely has no public founders listed, you still get one company-level row — no company is ever silently dropped from your results.

### Billing

Charged once per row actually delivered to your dataset (`startup-lead-scraped`). A company-only row and a founder row both count as one. Non-billable `summary`/`info` rows carry run stats and never count against you. Nothing is charged for a filter combination that matches zero companies.

### 💼 Common use cases

- **VC & investor sourcing** — pull every company in a batch or vertical to build a deal-flow tracker, with founder LinkedIn ready for warm intros.
- **Recruiting & talent sourcing** — filter to `hiringStatus: hiring` in your target stack to find funded, actively-hiring teams before they post to a job board.
- **B2B sales prospecting** — target startups by industry/tag (e.g. "Fintech", "Developer Tools") as a qualified account list, then hand founder names to your outbound sequence.
- **Competitive & market mapping** — pull every company under a tag ("Generative AI", "Vertical SaaS") to map a category as it evolves batch over batch.
- **Journalism & research** — track a batch as it launches, or trend a tag's growth across batches using `founded_year` and `batch`.
- **Founder community building** — find and connect with founders in your city, stage, or vertical using the LinkedIn/X handles YC itself publishes.

### 🔁 Run on a schedule

Turn a one-off pull into a standing feed with Apify's built-in Schedules — useful for catching each new batch as it launches.

1. Run the actor once with your filters, then **Save as a task** to keep that input.
2. In the Apify Console, go to **Schedules** → **Create new**, pick a frequency (e.g. weekly).
3. Add the saved task under **Actors or tasks to run**, then **Save**.

Or via the API:

```bash
curl -X POST "https://api.apify.com/v2/schedules?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "yc-scraper-weekly",
    "cronExpression": "0 9 * * 1",
    "isEnabled": true,
    "actions": [{ "type": "RUN_ACTOR", "actorId": "themineworks/y-combinator-scraper" }]
  }'
```

### FAQ

**Does this touch YC's non-public data (applications, Bookface, internal metrics)?**
No. Every field comes from either YC's own public search index (the same one the public `/companies` page queries) or the public HTML of each company's own public profile page. Nothing behind YC's login is accessed.

**Why no email addresses from YC directly?**
Because YC doesn't publish them. The company profile page only ships a `has_email` boolean and gates the real address behind a logged-in "request an intro" flow. We report what's genuinely public: LinkedIn and X/Twitter. The optional website-contact check can find a real email if the company published one on their own site — nothing is guessed.

**How current is the data?**
Fully live — every run queries YC's index directly at run time. There is no cached database and no staleness beyond however recently YC itself updated a company's listing.

**What does `batch_code` vs `batch` mean?**
`batch` is YC's own full form ("Winter 2024"); `batch_code` is the common shorthand ("W24") used in filters and conversation. Input accepts either form.

**Can I filter to multiple batches or industries at once?**
Yes — `batch`, `industries` and `tags` all accept arrays and are OR'd within each field, then AND'd against each other and against `keyword`/`hiringStatus`.

**Can I use it inside an AI agent?**
Yes. It is exposed as an MCP tool. See below.

### Use in Claude, ChatGPT & any MCP agent

```
https://mcp.apify.com/?tools=themineworks/y-combinator-scraper
```

Or call it programmatically with the Apify client:

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

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

const run = await client.actor('themineworks/y-combinator-scraper').call({
  industries: ['Fintech'],
  hiringStatus: 'hiring',
  maxResults: 50,
  fetchFounders: true,
});

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

### 🛠️ Complete your outbound pipeline

Pair this with the rest of The Mine Works' B2B lead-gen wedge:

- **[B2B Leads Finder](https://apify.com/themineworks/b2b-leads-finder)**: turn any company name or domain into business emails and phone numbers, searched live.
- **[LinkedIn Employees Scraper](https://apify.com/themineworks/linkedin-employees)**: every public employee profile at a target company, by role.
- **[LinkedIn Profile Scraper](https://apify.com/themineworks/linkedin-profile-scraper)**: full work history and education from a founder's LinkedIn URL, before you reach out.
- **[Company Resolver](https://apify.com/themineworks/company-resolver)**: resolve a messy company name to its canonical domain and firmographics.

Typical flow: this actor finds the startups and founders, linkedin-profile-scraper enriches each founder's full history, b2b-leads-finder adds a business email if you need one beyond what the company itself publishes.

# Actor input Schema

## `keyword` (type: `string`):

Full-text search across company name, one-liner and description (e.g. 'AI agents for sales', 'fintech infrastructure'). Leave empty to browse/filter without a keyword.

## `batch` (type: `array`):

Filter to one or more YC batches. Accepts shorthand ('W24' = Winter 2024, 'S23' = Summer 2023, 'F24' = Fall 2024, 'Sp25' = Spring 2025) or the full form ('Winter 2024'). Leave empty for all batches.

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

Filter by YC's broad industry category — must match YC's own names exactly, e.g. 'B2B', 'Consumer', 'Fintech', 'Healthcare', 'Industrials', 'Real Estate and Construction'. Leave empty for all industries.

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

Filter by YC's finer-grained tags, e.g. 'SaaS', 'Artificial Intelligence', 'Marketplace', 'Developer Tools', 'Generative AI', 'Fintech'. Leave empty for all tags.

## `hiringStatus` (type: `string`):

Filter by whether YC's directory currently marks the company as hiring.

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

Maximum number of companies to return leads for (most-relevant/most-recent first per YC's own ranking).

## `fetchFounders` (type: `boolean`):

Visit each matched company's YC profile page to pull founder full names, titles, and LinkedIn/Twitter URLs — all public data YC itself displays. Adds one extra request per company. Turn off for a faster, company-only run.

## `scrapeWebsiteContact` (type: `boolean`):

Visit the company's own website homepage and look for a publicly listed contact email (a mailto: link). Off by default. This does NOT guess, pattern-generate, or verify emails — it only reports one if the company has genuinely published it on their own site.

## Actor input object example

```json
{
  "keyword": "developer tools",
  "batch": [
    "W24"
  ],
  "industries": [],
  "tags": [],
  "hiringStatus": "any",
  "maxResults": 10,
  "fetchFounders": true,
  "scrapeWebsiteContact": false
}
```

# Actor output Schema

## `results` (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 = {
    "keyword": "developer tools",
    "batch": [
        "W24"
    ],
    "industries": [],
    "tags": [],
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("themineworks/y-combinator-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 = {
    "keyword": "developer tools",
    "batch": ["W24"],
    "industries": [],
    "tags": [],
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("themineworks/y-combinator-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "keyword": "developer tools",
  "batch": [
    "W24"
  ],
  "industries": [],
  "tags": [],
  "maxResults": 10
}' |
apify call themineworks/y-combinator-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=themineworks/y-combinator-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

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