# Y Combinator Companies Scraper (`scrapers-hub/yc-companies-scraper`) Actor

Y Combinator Companies Scraper extracts startup profiles with founders, open jobs and job counts, batch, industry, sub-industry, stage, status, location and descriptions, plus diversity highlight filters. 🚀 Deep YC directory research.

- **URL**: https://apify.com/scrapers-hub/yc-companies-scraper.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:** Developer tools, Lead generation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Companies Scraper – YC Startup, Founder & Job Data Extraction

The **Y Combinator Companies Scraper** extracts the full YC startup directory as structured data: company profiles, batch and status, industry and sub-industry, team size, funding stage, locations, websites, social links, founder records and open job postings. Set your filters — batch, industry, region, status, free-text query — press Start, and you get a clean dataset of Y Combinator companies instead of an afternoon of scrolling an infinite-scroll directory.

This YC companies scraper is built for the people who actually work with startup data: investors tracking new batches, recruiters sourcing from YC-backed teams, founders researching competitors and comparables, sales teams targeting well-funded early-stage companies, and analysts studying how a cohort's industry mix shifts over time. Everything it returns comes from the public YC companies directory — no login, no account, no cookies.

***

### 📊 What Data Can You Extract with This YC Companies Scraper?

Each dataset item is one Y Combinator company. The fields group into seven categories:

| Category | Fields | What it tells you |
|---|---|---|
| 🆔 Identity | `id`, `slug`, `name`, `formerNames`, `url`, `website`, `logoThumb` | The company's YC identifier and URL slug, current and previous names, its YC directory page, its own site, and its logo |
| 📝 Description | `shortDescription`, `longDescription` | The one-line pitch and the full description as published on the YC profile |
| 🏷️ Classification | `batch`, `industry`, `subIndustry`, `tags`, `status`, `stage`, `nonprofit`, `topCompany` | Which YC batch, the industry and sub-industry, tag list, operating status, funding stage, and YC's own top-company flag |
| 📍 Location & size | `location`, `allLocations`, `regions`, `teamSize` | Primary location, the full location string, region tags and current headcount |
| 📅 Timeline | `foundingYear`, `launchedAt`, `scrapedAt` | Founding year, launch timestamp, and when this record was collected |
| 👥 Founders | `founders` | An array of founder records with name, title, bio, LinkedIn, Twitter and an email-availability flag |
| 💼 Hiring | `isHiring`, `jobCount`, `openJobs` | Whether the company is hiring, how many roles are open, and the full job array with title, URL, location, role, type, skills, experience, visa, equity and salary range |
| 🔗 Social | `linkedin`, `twitter` | Company social profiles where published |

The field that makes this scraper genuinely different is `openJobs`. Each entry carries not just a title and location but `skills`, `experience`, `visa`, `equityRange`, `salaryMin` and `salaryMax` where YC publishes them — which means a single run gives you a live, structured view of early-stage hiring demand and compensation, not just a list of company names.

***

### 🌟 Key Features of the Y Combinator Companies Scraper

| Feature | Description |
|---|---|
| 🎓 Batch filtering | `batch` accepts short codes such as `S13`, `W22`, `F24`, `X25` or full names like `Summer 2013`, with `any` for no filter |
| 🏭 Industry and tag filters | `industry` matches exactly (`B2B`, `Consumer`, `Fintech`, `Healthcare`) while `tags` takes a list of industry tags such as `SaaS` or `B2B` |
| 🌍 Region filtering | `regions` accepts one or more region values, e.g. `United States of America`, `Europe`, `Remote` |
| 📊 Status filtering | `status` selects from `any`, `Active`, `Inactive`, `Acquired` or `Public` |
| 🔎 Free-text search | `query` runs the same free-text search against name and description that the YC directory search box does |
| 👥 Optional founder data | `scrapeFounders` (default `true`) attaches the founders array with names, titles, bios, LinkedIn, Twitter and email availability |
| 💼 Optional job data | `scrapeOpenJobs` (default `true`) attaches the openJobs array with titles, locations, skills, salary ranges and visa information |
| 🎯 Diversity highlight filters | Three boolean filters restrict results to companies YC flags with Black, Hispanic/Latino or women founders |
| 🔢 Result limiting | `maxItems` caps the run, defaulting to 3 so a first exploratory run is instant; set 0 for no limit |
| 🔄 Automatic proxy rotation | Requests route through rotating proxies managed automatically by the actor, with nothing to configure |

***

### 🚀 Why Choose This Y Combinator Companies Scraper?

**Filters that match how you actually search.** Batch, industry, sub-industry, region, status and free-text query are all available as inputs, so you narrow the directory before the run rather than exporting everything and filtering afterwards. A query like "active B2B fintech companies from W24 in Europe" is four input fields, not a spreadsheet exercise.

**Founders and jobs in the same record.** Most directory scrapers give you company rows. This one nests `founders` and `openJobs` inside each company, so one dataset answers who runs the company, how to reach them on LinkedIn, what roles they are hiring for, and what those roles pay.

**Compensation and visa data where YC publishes it.** The `openJobs` entries include `salaryMin`, `salaryMax`, `equityRange`, `visa`, `skills` and `experience`. That turns the dataset into a genuine source for startup compensation benchmarking, not just a job board mirror.

**Safe defaults for exploration.** `maxItems` defaults to 3 rather than unlimited, which means your first run finishes in seconds and shows you the exact record shape before you commit to a full directory pull.

***

### 📥 Input

Every field is optional — running with no input at all uses the defaults below.

```json
{
  "directoryUrl": "https://www.ycombinator.com/companies",
  "maxItems": 3,
  "query": "",
  "industry": "",
  "scrapeFounders": true,
  "scrapeOpenJobs": true,
  "batch": "any",
  "status": "any",
  "regions": [],
  "tags": [],
  "highlightBlackFounders": false,
  "highlightHispanicFounders": false,
  "highlightWomenFounders": false
}
```

#### 🔧 Y Combinator Companies Scraper Input Fields

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `directoryUrl` | string | ❌ No | `https://www.ycombinator.com/companies` | The YC companies directory URL. Only this URL is supported — kept as an input for compatibility and future sub-paths |
| `maxItems` | integer | ❌ No | `3` | Maximum number of companies to scrape. Leave unset or `0` for no limit |
| `query` | string | ❌ No | — | Optional free-text search against the YC directory, matching name and description, same as the search box on ycombinator.com/companies |
| `industry` | string | ❌ No | — | Exact-match industry filter, e.g. `B2B`, `Consumer`, `Fintech`, `Healthcare` |
| `scrapeFounders` | boolean | ❌ No | `true` | Fetch and include the founders array (name, title, bio, LinkedIn/Twitter, email availability) for each company |
| `scrapeOpenJobs` | boolean | ❌ No | `true` | Fetch and include the openJobs array (title, location, skills, salary range, visa, etc.) for each company |
| `batch` | string | ❌ No | `"any"` | Filter by YC batch. Accepts short codes (`S13`, `W22`, `F24`, `X25`) or full names (`Summer 2013`). Use `any` for no filter |
| `status` | string (enum) | ❌ No | `"any"` | Filter by company status: `any`, `Active`, `Inactive`, `Acquired`, `Public` |
| `regions` | array | ❌ No | `[]` | Filter by region(s), e.g. `United States of America`, `Europe`, `Remote`. Empty means all regions |
| `tags` | array | ❌ No | `[]` | Filter by industry tag(s), e.g. `SaaS`, `Fintech`, `B2B`. Empty means all tags |
| `highlightBlackFounders` | boolean | ❌ No | `false` | Only return companies flagged with Black founders. Depends on YC currently exposing this signal in its search index — if no companies are flagged, the filter yields zero results even though it queries correctly |
| `highlightHispanicFounders` | boolean | ❌ No | `false` | Only return companies flagged with Hispanic/Latino founders. Same caveat as above |
| `highlightWomenFounders` | boolean | ❌ No | `false` | Only return companies flagged with women founders. Same caveat as above |

#### 💡 Input Examples

**Latest batch, full data** — every company in a recent cohort with founders and jobs:

```json
{
  "batch": "W26",
  "maxItems": 0,
  "scrapeFounders": true,
  "scrapeOpenJobs": true
}
```

**Active European fintech companies** — investor screening:

```json
{
  "industry": "Fintech",
  "status": "Active",
  "regions": ["Europe"],
  "maxItems": 200
}
```

**Hiring-focused pull** — companies only, jobs attached, founders skipped for speed:

```json
{
  "query": "developer tools",
  "tags": ["SaaS", "B2B"],
  "scrapeFounders": false,
  "scrapeOpenJobs": true,
  "maxItems": 100
}
```

***

### 📤 Output

One dataset item per Y Combinator company. This is a real record from an actual run of the YC companies scraper:

```json
{
  "type": "yc_company",
  "id": "martini",
  "slug": "martini",
  "url": "https://www.ycombinator.com/companies/martini",
  "name": "Martini",
  "shortDescription": "AI Video Production for Professionals",
  "batch": "W26",
  "industry": "B2B",
  "subIndustry": "Engineering, Product and Design",
  "status": "Active",
  "stage": "Early",
  "location": "San Francisco",
  "allLocations": "San Francisco, CA, USA",
  "teamSize": 2,
  "launchedAt": 1768440972,
  "foundingYear": 2025,
  "website": "https://martini.film",
  "logoThumb": "https://bookface-images.s3.amazonaws.com/small_logos/6c61a438eef6d3a1fe29d67dd180ddaaac257b9d.png",
  "demoDayVideo": false,
  "appVideo": false,
  "topCompany": false
}
```

#### 🧾 Y Combinator Company Output Fields

| Field | Type | Description |
|---|---|---|
| `type` | string | null | Record type, e.g. `yc_company` |
| `id` | string | null | Unique identifier of the company |
| `slug` | string | null | URL-friendly identifier |
| `url` | string | null | Canonical YC directory URL for the company |
| `name` | string | null | Company name |
| `formerNames` | array | null | Previous names the company has traded under |
| `shortDescription` | string | null | One-line description |
| `longDescription` | string | null | Full description from the YC profile |
| `batch` | string | null | YC batch the company belongs to |
| `industry` | string | null | Industry of the company |
| `subIndustry` | string | null | Sub-industry classification |
| `status` | string | null | Company status |
| `stage` | string | null | Funding or company stage |
| `location` | string | null | Primary location |
| `allLocations` | string | null | Full location string |
| `regions` | array | null | Region values for the company |
| `tags` | array | null | Industry tags attached to the company |
| `teamSize` | integer | null | Current team size |
| `foundingYear` | integer | null | Year the company was founded |
| `launchedAt` | integer | null | Launch timestamp |
| `website` | string | null | Company website address |
| `logoThumb` | string | null | Company logo thumbnail URL |
| `linkedin` | string | null | Company LinkedIn URL |
| `twitter` | string | null | Company Twitter/X URL |
| `nonprofit` | boolean | null | Whether the company is a nonprofit |
| `topCompany` | boolean | null | Whether YC flags it as a top company |
| `demoDayVideo` | boolean | null | Whether a demo day video exists |
| `appVideo` | boolean | null | Whether an app video exists |
| `isHiring` | boolean | null | Whether the company is currently hiring |
| `jobCount` | integer | null | Number of open jobs found |
| `founders` | array | null | Founder records — name, title, bio, LinkedIn, Twitter and email availability |
| `openJobs` | array | null | Open job records — title, URL, apply URL, location, type, role, remote flag, skills, experience, visa, equity range and salary range |
| `scrapedAt` | string | null | When this record was scraped |

#### 🧾 Run Status Fields

Some records describe the run rather than a company:

| Field | Type | Description |
|---|---|---|
| `type` | string | null | Record type identifying the record as a status entry |
| `reason` | string | null | Reason associated with the record |
| `input` | object | null | The input the run executed with |

***

### 💻 How to Use the Y Combinator Companies Scraper (Step by Step)

#### Step 1: Decide What Slice of the YC Directory You Need

The directory holds thousands of companies, and the value of this scraper comes from narrowing it before the run. Work out which dimension matters most to you: a specific batch if you are tracking new cohorts, an industry and region if you are building a target account list, or a free-text query if you are looking for companies working on a specific problem. You can combine all of these, and combining them usually produces a far more useful dataset than a single broad filter.

#### Step 2: Set Your Filters

Fill in `batch`, `industry`, `status`, `regions`, `tags` and `query` as needed. `batch` is flexible about format — `W22` and `Winter 2022` both work — while `industry` is exact-match, so `Fintech` will match and `fintech services` will not. `regions` and `tags` are lists, so you can pass several values to widen a filter without abandoning it.

#### Step 3: Choose Whether You Need Founders and Jobs

`scrapeFounders` and `scrapeOpenJobs` both default to `true`. Each requires additional fetching per company, so if you only need the company-level fields, turning them off makes large runs noticeably lighter. Turn them on when you specifically want contact routes into the company or hiring and compensation data.

#### Step 4: Start Small with `maxItems`

The default is 3, which exists precisely so your first run finishes immediately and shows you the record shape. Confirm the filters return the companies you expected before scaling. When you are ready for the full set, set `maxItems` to `0` for no limit or to a specific number if you want a bounded run.

#### Step 5: Run the YC Companies Scraper

Press **Start**. The actor queries the YC directory with your filters and collects matching companies, then fetches founder and job detail for each one if those options are enabled. Proxy rotation is handled automatically. The log reports progress as companies are collected.

#### Step 6: Work with the Nested Founder and Job Arrays

`founders` and `openJobs` are arrays of objects, which means a flat CSV export will not represent them well. For spreadsheet work, either export to JSON and flatten programmatically, or run once with `scrapeFounders` on for a founder-level view and once with `scrapeOpenJobs` on for a jobs-level view. In code, iterate the nested arrays directly — that is where the salary, skills and visa detail lives.

#### Step 7: Schedule Batch Tracking

YC announces a new batch roughly twice a year, and existing companies change status, team size and hiring constantly. Schedule a run against the batches you follow and store each dataset with its date. Joining runs on `id` gives you a time series of `teamSize`, `status`, `stage` and `jobCount` — which is how you spot a company scaling or stalling before it is public knowledge.

***

### 🔌 API Access & Integrations

Run the YC companies scraper from your own code. The synchronous endpoint starts a run and returns dataset items in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers-hub~yc-companies-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "batch": "W26",
    "status": "Active",
    "maxItems": 50,
    "scrapeFounders": true,
    "scrapeOpenJobs": true
  }'
```

With the official Python client:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run_input = {
    "industry": "Fintech",
    "status": "Active",
    "regions": ["Europe"],
    "maxItems": 200,
    "scrapeOpenJobs": True,
}

run = client.actor("scrapers-hub/yc-companies-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item.get("type") != "yc_company":
        continue
    print(item["name"], item["batch"], item["teamSize"], item.get("jobCount"))
```

The actor also works with Apify's standard integrations for Zapier, Make, Google Sheets, Slack and generic webhooks, so a scheduled batch run can post new YC companies straight into a channel or a CRM.

***

### 💡 Best Use Cases for Y Combinator Company Data

#### 💰 Investor Deal Flow and Sourcing

Filter by `batch`, `stage` and `industry` to build a screening list the moment a cohort is published. Combining `teamSize`, `foundingYear` and `status` gives you a first-pass sense of traction, and `founders` supplies LinkedIn routes to the people you actually need to reach.

#### 🧑‍💼 Technical Recruitment and Talent Sourcing

`openJobs` carries `title`, `skills`, `experience`, `visa` and salary range per role. Recruiters can filter across hundreds of YC companies for a specific skill and seniority in one pass, and `isHiring` plus `jobCount` show which companies are hiring aggressively enough to be worth a conversation.

#### 🎯 B2B Sales Prospecting

YC-backed companies are well-funded early-stage buyers. Filter on `industry`, `tags`, `regions` and `teamSize` to isolate accounts that match your ideal customer profile, then use `website`, `linkedin` and the `founders` array for outreach routes.

#### 📈 Startup and Market Trend Analysis

Aggregate `batch`, `industry`, `subIndustry` and `tags` across cohorts to see how YC's investment mix shifts over time. A sub-industry that goes from two companies to twenty in three batches is a signal worth acting on, and it is only visible with the full directory in a table.

#### 🔬 Competitive and Comparable Research

Use `query` and `industry` to find companies working on the same problem you are. `shortDescription`, `longDescription`, `stage`, `teamSize` and `foundingYear` together tell you how crowded a space is and how far ahead the incumbents are — essential context for a fundraise or a positioning decision.

#### 💵 Compensation Benchmarking

`salaryMin`, `salaryMax` and `equityRange` inside `openJobs` provide real early-stage compensation data across many companies. Grouping by `role`, `location` and `experience` gives founders and candidates a defensible benchmark rather than an anecdote.

#### 🌍 Geographic Ecosystem Mapping

Group by `location`, `allLocations` and `regions` to see where YC companies actually operate. Comparing regional counts and team sizes across batches shows which startup hubs are gaining ground and which are losing companies to remote-first structures.

***

### ⚙️ Tips for Better YC Companies Scraping Results

- **Start with `maxItems` at its default.** Three companies is enough to confirm your filters and see the record shape. Only then set `maxItems` to `0` for the full run.
- **Remember `industry` is exact-match.** Use the values YC itself uses — `B2B`, `Consumer`, `Fintech`, `Healthcare`. If a filter returns nothing, an inexact industry string is the most likely cause.
- **Turn off `scrapeFounders` and `scrapeOpenJobs` for large company-level pulls.** Each adds per-company fetching. If you only need the directory fields, disabling both makes a full-directory run substantially lighter.
- **Use `tags` to widen, `industry` to narrow.** `industry` selects one value; `tags` accepts several. Combining a narrow industry with a broad tag list is usually the most precise way to describe a target segment.
- **Export to JSON when you need founders or jobs.** Nested arrays do not survive a flat CSV export intact. Use JSON, or run separately for company-level and job-level views.
- **Treat the diversity highlight filters as index-dependent.** They query correctly, but they return results only while YC exposes that signal in its search index. Zero results does not necessarily mean zero companies.
- **Join runs on `id`, not `name`.** Companies rename — `formerNames` exists for exactly that reason — but the `id` is stable across runs.

***

### 🛠️ Troubleshooting

**My filter combination returned no companies.**
Start by relaxing one filter at a time. The usual culprits are an `industry` value that does not exactly match YC's own label, a `batch` code that does not exist, or a combination that is genuinely empty — a specific batch plus a narrow industry plus a single region can easily have no members.

**A diversity highlight filter returned zero results.**
These filters depend on YC exposing that signal in its search index. If YC currently flags no companies, the filter yields zero results even though the query itself is correct. This is documented behaviour rather than a fault.

**`founders` or `openJobs` is missing from my records.**
Check that `scrapeFounders` and `scrapeOpenJobs` are enabled. Both default to `true`, but if either is turned off the corresponding array is not fetched. Note also that `openJobs` only appears where the company actually has job postings.

**My CSV export lost the founder and job detail.**
Nested arrays do not flatten cleanly into CSV columns. Export as JSON and flatten in your own code, or run twice — once for company-level data and once specifically for the nested arrays you need.

**Only three companies came back.**
`maxItems` defaults to 3. Set it to `0` for no limit, or to whatever bounded number you want.

**Salary fields are missing on some jobs.**
`salaryMin`, `salaryMax`, `equityRange` and `visa` are only present when the company publishes them on the posting. Many early-stage roles omit compensation entirely, so expect partial coverage.

***

### ❓ Frequently Asked Questions About Y Combinator Company Scraping

**What does the Y Combinator Companies Scraper do?**
It extracts companies from the public YC startup directory as structured data — identity, description, batch, industry, status, stage, location, team size, website, social links, and optionally founder records and open job postings.

**Do I need a Y Combinator account to use this YC scraper?**
No. It reads only the public companies directory. There is no login, cookie or token required.

**How do I scrape a specific YC batch?**
Set `batch` to the batch code or full name — `W26`, `S24`, `F24`, `X25` or `Summer 2013` all work. Use `any` to include every batch.

**Can I scrape the entire YC directory?**
Yes. Set `maxItems` to `0` for no limit and leave the filters at their defaults. Consider turning off `scrapeFounders` and `scrapeOpenJobs` for a run of that size.

**What founder information does the YC companies scraper return?**
Each entry in the `founders` array carries name, title, bio, LinkedIn and Twitter links where published, and a flag indicating whether an email address is available.

**Does it return founder email addresses?**
The founder records include an email-availability indicator rather than the address itself.

**What job data is included?**
Each `openJobs` entry can include title, job URL, apply URL, location, employment type, role, a remote flag, required skills, minimum experience, visa information, equity range and a salary range split into `salaryMin` and `salaryMax` — subject to what the company publishes.

**Can I filter by region?**
Yes. `regions` takes a list of values such as `United States of America`, `Europe` or `Remote`. Leaving it empty includes every region.

**What is the difference between `industry` and `tags`?**
`industry` is a single exact-match value such as `B2B` or `Fintech`. `tags` is a list of industry tags, so it can match several categories at once.

**What does the `status` filter cover?**
`any`, `Active`, `Inactive`, `Acquired` and `Public` — useful for excluding companies that no longer operate or have already exited.

**Why is `maxItems` set to 3 by default?**
So an exploratory run finishes immediately and shows you the exact record shape before you commit to a large pull. Raise it or set `0` once you are satisfied with the filters.

**Can I change `directoryUrl`?**
Only `https://www.ycombinator.com/companies` is supported. The field exists for compatibility and possible future sub-paths.

**Do I need to configure proxies?**
No. Proxy rotation is handled automatically by the actor and is not user-configurable.

**How do I track YC companies over time?**
Schedule recurring runs with the same filters and store each dataset. Join runs on `id` to build a time series of `teamSize`, `status`, `stage` and `jobCount`.

**What export formats are available?**
JSON, CSV, Excel, XML, RSS and HTML through the Apify Console, plus programmatic access via the API and official clients. Use JSON when you need the nested `founders` and `openJobs` arrays intact.

***

### 🆘 Support & Feedback

If a filter behaves unexpectedly, or a field you expect is missing from the output, open a ticket on the **Issues** tab of this actor. Including the input JSON and the run ID makes the behaviour reproducible and speeds up a fix considerably.

Need something custom — additional YC fields, a different output shape, founder-level or job-level flat records, or scraping of another startup directory? Email **scraperhubapi@gmail.com** and describe what you are building.

If the Y Combinator Companies Scraper is useful to your sourcing, recruiting or research work, please leave a review on the actor page. Ratings help other investors, recruiters and founders find the tool and guide what gets built next.

***

### ⚖️ Disclaimer

The Y Combinator Companies Scraper collects only publicly available information from the YC companies directory at ycombinator.com — the same content any visitor can see without logging in. It does not use an account, does not require cookies or tokens, and does not access private or authenticated areas of the site. This actor is not affiliated with, endorsed by, or connected to Y Combinator.

Some of the data this YC scraper returns is personal data. Founder names, titles, biographies and LinkedIn and Twitter profile links identify individuals, which brings your use of the dataset within the scope of GDPR, UK GDPR, CCPA and equivalent privacy legislation. You must establish a lawful basis for processing, provide the required privacy information where you contact individuals, honour access and erasure requests, and comply with anti-spam rules such as PECR and CAN-SPAM before using founder details for outreach.

You are also responsible for complying with Y Combinator's terms of service and with any applicable copyright in company descriptions and logos. Company data, team sizes, statuses and job postings are published by third parties and change frequently; verify anything commercially material — particularly compensation figures and company status — directly at source before relying on it.

If you believe data collected by this actor relates to you and should be removed, contact **scraperhubapi@gmail.com** with the details and the request will be actioned.

# Actor input Schema

## `directoryUrl` (type: `string`):

The YC companies directory URL. Only https://www.ycombinator.com/companies is supported - kept as an input for compatibility/future sub-paths.

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

Maximum number of companies to scrape. Leave unset / 0 for no limit.

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

Optional free-text search against the YC directory (matches name/description, same as typing into the search box on ycombinator.com/companies).

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

Exact-match industry filter, e.g. "B2B", "Consumer", "Fintech", "Healthcare".

## `scrapeFounders` (type: `boolean`):

Fetch and include the founders array (name, title, bio, LinkedIn/Twitter, email availability) for each company.

## `scrapeOpenJobs` (type: `boolean`):

Fetch and include the openJobs array (title, location, skills, salary range, visa, etc.) for each company.

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

Filter by YC batch. Accepts short codes (S13, W22, F24, X25) or full names (Summer 2013). Use "any" for no filter.

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

Filter by company status.

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

Filter by region(s), e.g. "United States of America", "Europe", "Remote". Empty = all regions.

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

Filter by industry tag(s), e.g. "SaaS", "Fintech", "B2B". Empty = all tags.

## `highlightBlackFounders` (type: `boolean`):

Only return companies flagged with Black founders. Depends on YC currently exposing this signal in its search index - if YC has no companies flagged, this filter yields zero results even though it queries correctly.

## `highlightHispanicFounders` (type: `boolean`):

Only return companies flagged with Hispanic/Latino founders. Same caveat as highlightBlackFounders.

## `highlightWomenFounders` (type: `boolean`):

Only return companies flagged with women founders. Same caveat as highlightBlackFounders.

## Actor input object example

```json
{
  "directoryUrl": "https://www.ycombinator.com/companies",
  "maxItems": 3,
  "scrapeFounders": true,
  "scrapeOpenJobs": true,
  "batch": "any",
  "status": "any",
  "regions": [],
  "tags": [],
  "highlightBlackFounders": false,
  "highlightHispanicFounders": false,
  "highlightWomenFounders": false
}
```

# Actor output Schema

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

Records scraped by Y Combinator Companies Scraper, stored in the run's 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/yc-companies-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/yc-companies-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 '{}' |
apify call scrapers-hub/yc-companies-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapers-hub/yc-companies-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/G4swuXumWsTVvKe33/builds/PfAQATyS7MqhFRT8Q/openapi.json