# Y Combinator Companies Scraper - YC Startup Directory, Founders (`s-r/ycombinator-companies`) Actor

Export Y Combinator companies from the YC startup directory: filter by batch, industry, region, status, team size and hiring. Get websites, domains, descriptions and team size, plus optional founders and social profiles for VC research, deal sourcing and CRM enrichment.

- **URL**: https://apify.com/s-r/ycombinator-companies.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Categories:** Business, Lead generation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 company records

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 Scraper - YC Startup Directory Export

Y Combinator Companies Scraper exports Y Combinator companies from the public YC startup directory into a clean, filterable list. Search by keyword, batch, industry, region, company status and team size, then add public founder profiles and company social links when you need more context.

The output is designed for venture capital research, private equity analysis, startup scouting and B2B account research. Each delivered row represents one company. Its website domain provides a practical key for matching the company against your own CRM records, repository research or product launch datasets.

### What data you get for each Y Combinator company

Search results include the company name, YC profile URL, website, normalized domain, short tagline, longer description, full batch name, company status, stage, industry labels, tags, published locations, regions, team size and directory publication date. The YC hiring flag and top-company flag are included when the directory provides them.

Optional details add the founding year, country, city, public founder names, founder titles and biographies, founder LinkedIn and X links, company social profiles, the published YC partner and the number of listed jobs. Founder email addresses and job descriptions are outside this output. A publication date describes when a profile appeared in the directory; it does not replace the company's founding year.

Unknown values remain null rather than being guessed. A company can have an empty founder list when its page publishes no founders. Company status is normalized to active, inactive, acquired, public or unknown, making comparisons easier across exports.

### Input: filter the YC companies list

Start with a small company search:

```json
{
  "query": "stripe",
  "max_results": 5
}
```

To select an accelerator cohort and include founder information:

```json
{
  "batches": ["Summer 2025"],
  "max_results": 3,
  "include_details": true
}
```

The `query` field searches the public company directory. An empty query searches all companies. Use `batches`, `industries`, `regions`, `statuses` and `tags` for exact directory values. Values within one list are alternatives; different filter lists are combined. For example, two batches select either batch, while adding an industry requires a company to match that industry as well.

Batch names such as Summer 2025 and short codes such as S25 are accepted. The short-code letters are W for Winter, S for Summer, F for Fall and X for Spring. Status filters use Active, Inactive, Acquired and Public. Headcount filters use `team_size_min` and `team_size_max`, both inclusive. Setting `is_hiring`, `top_company` or `nonprofit` to true enables that filter; false leaves it disabled.

`max_results` limits the entire export and defaults to 100 for search, with a maximum of 10,000. `maxResults` is an accepted alternative name; when both are present, the lower limit applies. `isHiring` and `topCompany` are also supported. `include_details` defaults to false. Select `sort: "launch_date"` for recently published directory profiles or retain the default relevance order.

For known companies, supply `company_slugs`, for example `["f2", "stripe", "airbnb"]`. YC company profile URLs are also accepted. This mode reads the profiles directly, removes duplicate inputs and ignores search filters. Without an explicit max_results or maxResults limit, it requests all unique profiles. Some search-only fields, including stage, full region lists and hiring flags, are unavailable from a direct profile lookup and remain null or empty.

### Output: one row per YC company

Results are delivered to the default dataset and can be downloaded as JSON, CSV or Excel through Apify. The run summary in OUTPUT contains delivery counts, detail counts, warnings and charge information. Useful fields include `name`, `profile_id`, `url`, `website`, `domain`, `tagline`, `description`, `batch`, `status`, `team_size`, `founded_year`, `is_hiring`, `founders` and `details_fetched`.

Below is an excerpt of a real delivered row for F2 (Summer 2025), requested with `{"batches": ["Summer 2025"], "max_results": 1, "include_details": true}`. Long text, logo and avatar fields are left out here for readability; they are present in the dataset.

```json
{
  "name": "F2",
  "url": "https://www.ycombinator.com/companies/f2",
  "website": "http://f2.ai",
  "domain": "f2.ai",
  "tagline": "The AI platform for private markets investors",
  "status": "active",
  "batch": "Summer 2025",
  "batch_code": "S25",
  "stage": "Early",
  "industry": "B2B",
  "subindustry": "B2B -> Engineering, Product and Design",
  "tags": ["AI"],
  "location": "New York City, NY, USA",
  "country": "US",
  "team_size": 15,
  "founded_year": 2025,
  "launched_at": "2025-11-10T15:49:41.000Z",
  "is_hiring": true,
  "top_company": false,
  "linkedin_url": "https://www.linkedin.com/company/f2aihq",
  "twitter_url": "https://x.com/F2aiHQ",
  "crunchbase_url": "https://www.crunchbase.com/organization/f2-ai",
  "primary_partner": "Jared Friedman",
  "open_jobs_count": 3,
  "details_fetched": true,
  "founders": [
    {
      "name": "Don Muir",
      "title": "Founder/CEO",
      "linkedin_url": "https://www.linkedin.com/in/don-muir",
      "twitter_url": null,
      "is_active": true
    }
  ]
}
```

For example, the measured F2 company profile lists the website `http://f2.ai`, domain `f2.ai`, batch Summer 2025, team size 15 and founding year 2025. Its public founder profile names Don Muir with the title Founder/CEO. These are observed source values from October 5, 2026; company profiles can change after that date. The repository examples preserve the source responses rather than presenting sample companies as current records.

Large exports continue automatically on Apify. The total limit applies across all pages, and repeated company profiles are removed before delivery. Relevance exports covering more than 1,000 companies use a stable sequence of batch groups, with directory relevance inside each group. Launch-date exports are merged into global publication-date order. The directory can change during a run, so the export is a live collection rather than a historical snapshot.

### Use cases for a YC companies list

- **Venture capital and deal sourcing.** Pull every company from the latest batch, filter on industry and team size, and review new Y Combinator startups before demo day follow-ups.
- **Private equity and market maps.** Export all acquired or public YC companies in a sector to see who exited, who is still active and how large the teams are.
- **B2B sales and lead generation.** Build an account list of YC startups that are hiring, then match on `domain` with your CRM to avoid duplicates and route new accounts.
- **Startup scouting and research.** Track which tags and industries appear in recent batches, or monitor newly published directory profiles with `sort: "launch_date"`.
- **Data enrichment.** Join the `domain` field with code-repository, product-launch or company-profile datasets to combine YC status with growth signals from other sources.

### How this YC startup directory export compares

Several Apify actors export the Y Combinator directory, and they differ mainly in price model and output depth. Some charge per run plus per row, some charge well above a cent per company, and several return a reduced field set without a normalized domain. This actor charges per delivered company, with founder details as a separate optional event, so a plain batch export stays inexpensive and you only pay for detail pages you request.

Differences you can verify in the output:

- A normalized lowercase `domain` on every row with a website, ready for joins.
- Status normalized to a fixed set of values, and unknown values kept as null instead of guessed.
- Explicit distinction between the directory hiring flag and the count of listed jobs.
- Exports beyond the directory's 1,000-result search window, with duplicate profiles removed.
- No invented founder emails, funding amounts or valuations.

### Pricing

The actor uses two result events: `company` for each delivered company and `company_detail` for each company whose requested detail page was successfully read. A detail-enabled company therefore contributes one company event and one detail event. The active prices are shown in the actor's Apify Pricing tab. There is no actor start event in this product's charge map.

Empty searches and missing company profiles do not produce charged company rows. If a search result is available but its detail page cannot be read, the basic company row is delivered and only the company event applies. Accounts without a paid plan receive at most ten company rows per run, including when explicit company slugs are used. Charges are counted from the delivered rows after that cap.

### FAQ

#### Can I export all Y Combinator companies in one YC batch?

Yes. Supply its full batch name or short code, and choose a `max_results` limit large enough for the cohort. Larger exports continue automatically. The actor checks batch coverage so that the directory's search limit does not silently truncate a large request.

#### Does this include founder emails or funding amounts?

The actor exports publicly published founder profiles and social links. The company directory does not provide public founder email addresses, funding rounds, valuations or revenue in these responses, so those fields are not invented or inferred.

#### What happens if a detail page is unavailable?

An available search row is retained with `details_fetched: false` and a warning, and no detail event is charged for that row. A missing explicit company slug produces no company row. Other available companies can still be delivered.

#### How should I match these companies to another dataset?

Use `platform` plus `profile_id` to identify a YC profile, and use the normalized `domain` to match a company website across sources. Domains are lowercase without a leading www. Confirm ambiguous matches when a company changes websites or shares a domain with another organization.

#### Is the hiring flag the same as the number of jobs?

They are separate source fields. Search results contain the directory hiring flag; details provide a count of listed jobs. The actor preserves that distinction and does not infer one from the other.

#### Can I export every company in the YC startup directory?

Yes. Leave `query` empty, set no filters and raise `max_results` to the size of the directory. The actor uses batch groups for relevance order and publication-date continuation for launch_date order so the full list is not cut off at the first 1,000 results.

# Actor input Schema

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

Search company names, taglines and descriptions. Default: empty (all companies).

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

YC batches, for example Summer 2025 or S25. OR within this list.

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

Exact YC industry values, such as B2B or Fintech. OR within the list.

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

Exact YC regions, such as Europe, America / Canada or Remote.

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

YC company statuses. OR within the list.

## `is_hiring` (type: `boolean`):

When true, return companies marked as hiring. False leaves this filter disabled.

## `top_company` (type: `boolean`):

When true, return YC top companies. False leaves this filter disabled.

## `nonprofit` (type: `boolean`):

When true, return nonprofit companies. False leaves this filter disabled.

## `team_size_min` (type: `integer`):

Minimum published headcount, inclusive.

## `team_size_max` (type: `integer`):

Maximum published headcount, inclusive.

## `sort` (type: `string`):

YC relevance or most recently published directory profiles. Partitioned relevance exports use stable batch groups.

## `max_results` (type: `integer`):

Maximum delivered companies over all cursor pages. Default: 100 for search, all unique company_slugs for profile lookup. If maxResults is also present, the lower limit applies.

## `include_details` (type: `boolean`):

Read public founder profiles, company socials, founding year and job count. Default: false.

## `company_slugs` (type: `array`):

YC slugs or company profile URLs; duplicates are removed. Uses detail mode and ignores search filters. Without max_results or maxResults, all unique profiles are requested.

## `cursor` (type: `string`):

Opaque continuation returned as next_cursor. Keep the other inputs identical.

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

Alias of max_results. When both are supplied, the lower limit applies.

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

Alias of is_hiring. Conflicting values are invalid.

## `topCompany` (type: `boolean`):

Alias of top_company. Conflicting values are invalid.

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

Exact YC tags, such as AI.

## Actor input object example

```json
{
  "query": "stripe",
  "sort": "relevance",
  "max_results": 5,
  "include_details": false
}
```

# Actor output Schema

## `companies` (type: `string`):

Delivered company profiles.

## `output` (type: `string`):

Delivery counts, detail counts, charges and warnings.

# 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": "stripe",
    "max_results": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/ycombinator-companies").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": "stripe",
    "max_results": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("s-r/ycombinator-companies").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": "stripe",
  "max_results": 5
}' |
apify call s-r/ycombinator-companies --silent --output-dataset

```

## MCP server setup

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

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/J2bHc1lZ8v8BY3dqu/builds/hKd6NEW7ioFSjCqVq/openapi.json