# Y Combinator · YC · Only $1💰 · Jobs & Companies scraper (`scrapers-hub/y-jobs-companies-scrapers`) Actor

Y Combinator Jobs & Companies Scraper covers both YC companies and open roles - batch, industry, regions, team size, stage, top-company and hiring flags, launch date, website and tags. 🚀 Dual-mode startup intelligence in one run.

- **URL**: https://apify.com/scrapers-hub/y-jobs-companies-scrapers.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:**
- **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 Jobs & Companies Scraper – YC Startup Directory, Hiring & Salary Data

The **Y Combinator Jobs & Companies Scraper** extracts structured data from both halves of the YC ecosystem: the Work at a Startup job board and the YC startup directory. Switch `mode` to `jobs` and you get job listings with salary ranges, equity ranges, required experience, visa policy, skills and the hiring company. Switch it to `companies` and you get the startup directory — batch, industry, team size, stage, region, launch date, website and long description — with optional founder details, open roles and best-effort contact emails layered on top.

Y Combinator's portfolio is one of the most-watched datasets in technology. Investors track which sectors each batch is weighted towards, recruiters mine Work at a Startup for openings that never reach the big job boards, sales teams build lists of newly funded companies before anyone else is calling them, and job seekers want salary and equity bands they can compare. This YC scraper gives all of them the same underlying data in a form that can be filtered, joined and monitored over time.

***

### 📊 What Data Can You Extract with This Y Combinator Scraper?

The actor emits two record shapes depending on `mode`. Grouped by theme, the available fields cover:

| Category | Fields | What you get |
|---|---|---|
| 🏢 Company identity | `id`, `slug`, `name`, `url`, `website`, `logo`, `formerNames` | The YC company record, its directory URL, its own website and branding assets |
| 🏷️ Company classification | `batch`, `industry`, `subindustry`, `industries`, `tags`, `stage`, `status`, `nonprofit`, `topCompany` | How YC categorises the startup, including batch, sector taxonomy and top-company flag |
| 📍 Company profile | `oneLiner`, `longDescription`, `teamSize`, `regions`, `allLocations`, `launchedAt`, `isHiring` | The pitch, the narrative description, headcount, geography and hiring status |
| 💼 Job listing core | `title`, `role`, `roleSpecificType`, `prettyRole`, `type`, `location`, `skills` | The role as posted, its category, employment type, location and listed skills |
| 💰 Compensation & requirements | `salaryRange`, `equityRange`, `minExperience`, `minSchoolYear`, `visa` | Pay band, equity band, experience floor and visa eligibility as published |
| 🔗 Job application routing | `applyUrl`, `ctaUrl`, `hiringManager`, `createdAt`, `lastActive`, `isIncomplete` | Where to apply, who is hiring, and how fresh the posting is |
| 🏭 Job's employer context | `companyName`, `companyBatchName`, `companyOneLiner`, `companyUrl`, `companyLogoUrl` | The hiring startup attached to each job record |
| 🧭 Run metadata | `scrapedAt`, `isNew`, `sourceRole`, `sourceLocation`, `demoDayVideoPublic`, `appVideoPublic` | When the record was captured, whether it is new since the last run, and which query produced it |

The standout field for most users is `salaryRange`, paired with `equityRange` and `minExperience`. YC job postings publish compensation openly far more often than the wider market does, which makes this one of the few places you can benchmark startup pay by role and seniority using primary data rather than survey estimates.

***

### 🌟 Key Features of the Y Combinator Scraper

| Feature | Description |
|---|---|
| 🔀 Dual mode | One actor covers both Work at a Startup job listings and the YC company directory via the `mode` input |
| 🎛️ Rich directory filtering | Filter companies by `batch`, `industries`, `regions`, team size range, `isHiring`, `nonprofit` and `topCompany` |
| 🔗 Direct URL targeting | `startUrls` accepts company search pages, individual company pages or job-role pages and overrides mode defaults |
| 👥 Founder enrichment | `scrapeFounderDetails` pulls founder names, titles, bios and social links from each company page |
| 📋 Per-company open roles | `scrapeOpenJobs` fetches the live job postings listed on each company's YC page |
| 📧 Best-effort email enrichment | `enrichEmails` visits each company's own website looking for a public contact or mailto address |
| 🔔 Change monitoring | `monitoringMode` compares against the previous run via the key-value store and tags each item with `isNew` |
| ⚙️ Concurrency control | `maxConcurrency`, `minConcurrency` and `maxRequestRetries` let you tune throughput against reliability |
| 💰 Open compensation data | Job records carry `salaryRange`, `equityRange`, `minExperience` and `visa` exactly as published |

***

### 🚀 Why Choose This Y Combinator Scraper?

**Two datasets, one consistent interface.** Jobs and companies are usually scraped by separate tools with incompatible outputs. Here they share an input schema and a dataset, so joining a job's `companyName` back to a company record from a second run is trivial.

**Filtering happens at the source, not after export.** Batch, industry, region, team size and hiring status are all applied as part of the directory query. You are not downloading five thousand companies to keep forty — you request the slice you want.

**Monitoring is built in.** With `monitoringMode` enabled, the actor diffs each run against the previous one and stamps every record with `isNew`. That turns a scraper into a change feed: new batch members, newly opened roles, companies that just started hiring.

**Enrichment goes beyond the listing page.** `scrapeFounderDetails`, `scrapeOpenJobs` and `enrichEmails` each fetch additional pages to attach founder profiles, live openings and public contact addresses — the fields that turn a directory dump into a workable prospect or candidate list.

***

### 📥 Input

```json
{
  "mode": "jobs",
  "startUrls": [],
  "role": "software-engineer",
  "location": "san-francisco",
  "batch": ["All Batches"],
  "industries": ["All industries"],
  "regions": ["Anywhere"],
  "minEmployeeSize": "1+",
  "maxEmployeeSize": "1000+",
  "isHiring": false,
  "scrapeOpenJobs": false,
  "scrapeFounderDetails": false,
  "enrichEmails": false,
  "monitoringMode": false,
  "maxItems": 100,
  "maxConcurrency": 10,
  "proxy": { "useApifyProxy": true }
}
```

#### 🔧 Y Combinator Scraper Input Fields

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `mode` | string (`jobs`, `companies`) | Yes | `jobs` | `jobs` scrapes Work at a Startup job listings; `companies` scrapes the YC startup directory. |
| `startUrls` | array | No | `[]` | Direct ycombinator.com URLs: a company search page, a single company page, or a job-role page. Overrides mode-based defaults when present. |
| `role` | string | No | `""` | Role slug used to build a jobs URL when no `startUrls` are given, e.g. `software-engineer`. |
| `location` | string | No | `""` | Location slug used to build a jobs URL when no `startUrls` are given, e.g. `san-francisco`. |
| `queries` | array | No | `[]` | Free-text search terms applied against the companies index (company name / description). |
| `batch` | array | No | `["All Batches"]` | Filter companies by YC batch, e.g. `Spring 2026`. Use `All Batches` for no filter. |
| `industries` | array | No | `["All industries"]` | Filter companies by industry, e.g. `B2B`. Use `All industries` for no filter. |
| `regions` | array | No | `["Anywhere"]` | Filter companies by region. Use `Anywhere` for no filter. |
| `minEmployeeSize` | string | No | `1+` | Minimum team size, e.g. `1+`. |
| `maxEmployeeSize` | string | No | `1000+` | Maximum team size. A `+` suffix means no upper bound. |
| `isHiring` | boolean | No | `false` | Only include companies currently marked as hiring. |
| `nonprofit` | boolean | No | `false` | Only include nonprofit companies. |
| `topCompany` | boolean | No | `false` | Only include companies YC has flagged as a top company. |
| `scrapeOpenJobs` | boolean | No | `false` | For each company result, also fetch its open job postings from its company page. |
| `scrapeFounderDetails` | boolean | No | `false` | For each company result, also fetch founder names, titles, bios and social links. |
| `enrichEmails` | boolean | No | `false` | Best-effort: visit each company's own website and look for a public contact/mailto email address. Not always available. |
| `monitoringMode` | boolean | No | `false` | Compare this run's results against the previous run and tag each item with `isNew`. |
| `maxItems` | integer | No | `100` | Maximum number of items to output across all sources. |
| `maxConcurrency` | integer | No | `10` | Maximum number of concurrent requests. |
| `minConcurrency` | integer | No | `1` | Starting/minimum number of concurrent requests. |
| `maxRequestRetries` | integer | No | `3` | Maximum retry attempts per failed request. |
| `proxy` | object | No | `{ "useApifyProxy": true }` | Apify proxy configuration. Residential proxies are strongly recommended. |

#### 💡 Input Examples

Scrape software engineering jobs in San Francisco:

```json
{
  "mode": "jobs",
  "role": "software-engineer",
  "location": "san-francisco",
  "maxItems": 200
}
```

Pull a filtered slice of the company directory with founder details:

```json
{
  "mode": "companies",
  "batch": ["Spring 2026"],
  "industries": ["B2B"],
  "isHiring": true,
  "scrapeFounderDetails": true,
  "maxItems": 150
}
```

Monitor new listings from direct URLs:

```json
{
  "mode": "companies",
  "startUrls": [
    "https://www.ycombinator.com/companies?batch=Spring%202026&industry=B2B"
  ],
  "monitoringMode": true,
  "scrapeOpenJobs": true,
  "maxItems": 300
}
```

***

### 📤 Output

```json
{
  "id": 101592,
  "title": "Principal Data Engineer",
  "url": "https://www.ycombinator.com/companies/tilt-fka-delphia/jobs/J4WV5Bg-principal-data-engineer",
  "type": "Full-time",
  "role": "eng",
  "roleSpecificType": "Data science",
  "prettyRole": "Engineering",
  "location": "Remote (US)",
  "salaryRange": "$210K - $270K",
  "equityRange": "",
  "minExperience": "6+ years",
  "visa": "US citizen/visa only",
  "skills": ["ETL"],
  "createdAt": "15 days",
  "lastActive": "12 days",
  "isIncomplete": false,
  "companyName": "Tilt (f.k.a. Delphia)",
  "companyBatchName": "W18"
}
```

#### 🧾 Y Combinator Job Output Fields

| Field | Type | Description |
|---|---|---|
| `id` | integer | null | Unique identifier of the job posting. |
| `title` | string | null | Job title as posted. |
| `url` | string | null | Canonical URL of the job listing. |
| `applyUrl` | string | null | URL to apply for this job. |
| `ctaUrl` | string | null | URL of the listing's call-to-action. |
| `type` | string | null | Employment type, e.g. Full-time. |
| `role` | string | null | Role category slug. |
| `roleSpecificType` | string | null | More granular role specialisation. |
| `prettyRole` | string | null | Human-readable role category. |
| `location` | string | null | Location of the role. |
| `salaryRange` | string | null | Published salary band. |
| `equityRange` | string | null | Published equity band. |
| `minExperience` | string | null | Minimum experience required. |
| `minSchoolYear` | — | Minimum school year, where specified. |
| `visa` | string | null | Visa eligibility statement. |
| `skills` | array | null | Skills required or listed. |
| `hiringManager` | — | Hiring manager attached to the posting. |
| `createdAt` | string | null | When the posting was created. |
| `lastActive` | string | null | When the posting was last active. |
| `isIncomplete` | boolean | null | Whether the posting is incomplete. |
| `companyName` | string | null | Hiring company name. |
| `companyBatchName` | string | null | YC batch of the hiring company. |
| `companyOneLiner` | string | null | One-line company pitch. |
| `companyUrl` | string | null | Company URL. |
| `companyLogoUrl` | string | null | Company logo URL. |
| `sourceRole` | string | null | Role slug that produced this item. |
| `sourceLocation` | string | null | Location slug that produced this item. |

#### 🧾 Y Combinator Company Output Fields

| Field | Type | Description |
|---|---|---|
| `id` | integer | null | Unique identifier of the company. |
| `slug` | string | null | URL-friendly identifier. |
| `name` | string | null | Company name. |
| `url` | string | null | Canonical YC directory URL. |
| `website` | string | null | Company's own website address. |
| `batch` | — | YC batch the company belongs to. |
| `industry` | — | Primary industry. |
| `subindustry` | — | Sub-industry classification. |
| `industries` | — | All industry tags. |
| `regions` | — | Regions associated with the company. |
| `allLocations` | — | All listed locations. |
| `oneLiner` | — | Short company pitch. |
| `longDescription` | string | null | Long-form company description. |
| `teamSize` | — | Headcount. |
| `status` | string | null | Company status. |
| `stage` | — | Company stage. |
| `topCompany` | — | Whether YC flags it as a top company. |
| `isHiring` | boolean | null | Whether the company is currently hiring. |
| `nonprofit` | — | Whether the company is a nonprofit. |
| `launchedAt` | string | null | When the company launched. |
| `logo` | — | Logo image URL. |
| `tags` | array | null | Tags attached to the company. |
| `formerNames` | — | Previous company names. |
| `appVideoPublic` | — | Whether the application video is public. |
| `demoDayVideoPublic` | — | Whether the demo day video is public. |
| `scrapedAt` | string | null | When this record was scraped. |
| `isNew` | boolean | null | Whether the record is new since the previous run, when monitoring mode is on. |

***

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

#### Step 1: Choose jobs or companies mode

`mode` is the first decision and it shapes everything else. Set it to `jobs` to scrape Work at a Startup listings, which produces records centred on `title`, `salaryRange`, `location` and the hiring company. Set it to `companies` to scrape the YC startup directory, which produces records centred on `name`, `batch`, `industry`, `teamSize` and `longDescription`. The filter inputs for batch, industry, region and team size apply to companies mode.

#### Step 2: Target by role and location, or by direct URL

For jobs mode without any URLs, set `role` and `location` to slugs — `software-engineer` and `san-francisco`, for instance — and the actor constructs the jobs URL for you. If you already know the exact page you want, put it into `startUrls`. That accepts a company search page with query parameters, a single company page, or a job-role page, and it overrides the mode-based defaults entirely.

#### Step 3: Narrow the company directory with filters

In companies mode the filters do the heavy lifting. `batch` selects cohorts such as "Spring 2026", `industries` restricts to sectors such as "B2B", `regions` limits geography, and `minEmployeeSize` with `maxEmployeeSize` bracket headcount. The boolean filters `isHiring`, `nonprofit` and `topCompany` narrow further. Leave the defaults — "All Batches", "All industries", "Anywhere" — in place for an unfiltered sweep.

#### Step 4: Turn on the enrichment you actually need

`scrapeOpenJobs`, `scrapeFounderDetails` and `enrichEmails` each fetch additional pages per company, so each one lengthens the run. Enable `scrapeFounderDetails` when you need names and bios of the people behind a startup, `scrapeOpenJobs` when you want live roles attached to each company record, and `enrichEmails` when you need a public contact address — bearing in mind that it is best-effort and not always available.

#### Step 5: Enable monitoring mode for recurring runs

If you plan to run the scraper on a schedule, set `monitoringMode` to true. The actor stores the previous run's results in its key-value store and compares against them, tagging every item with `isNew`. Filtering on `isNew` afterwards gives you a clean change feed of newly listed companies or newly posted roles instead of a full re-export each time.

#### Step 6: Tune limits, concurrency and proxying

`maxItems` caps total output across all sources — keep it low for a first run. `maxConcurrency` and `minConcurrency` control how aggressively the scraper fetches, and `maxRequestRetries` decides how many attempts a failed request gets. The `proxy` input takes a standard Apify proxy configuration and defaults to using Apify Proxy; residential proxies are strongly recommended for this target.

#### Step 7: Run, review and export the YC data

Start the run and follow the log as it works through pages and enrichment steps. When it finishes, open the Dataset tab. For jobs, sorting on `salaryRange` and filtering on `prettyRole` gives an immediate view of the compensation landscape; for companies, grouping on `batch` and `industry` shows how a cohort is distributed. Export to CSV, JSON or Excel, or pull the items via the API.

***

### 🔌 API Access & Integrations

Run the Y Combinator scraper and get dataset items back in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers-hub~y-jobs-companies-scrapers/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "mode": "jobs",
    "role": "software-engineer",
    "location": "san-francisco",
    "maxItems": 100
  }'
```

The same run in Python, filtering the results as they stream in:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("scrapers-hub/y-jobs-companies-scrapers").call(
    run_input={
        "mode": "companies",
        "batch": ["Spring 2026"],
        "industries": ["B2B"],
        "isHiring": True,
        "scrapeFounderDetails": True,
        "maxItems": 150,
    }
)

for company in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(company["name"], "|", company.get("teamSize"), "|", company.get("website"))
```

Because results sit in a standard Apify dataset, they connect straight to Zapier, Make, Google Sheets or Slack, and a webhook on run completion can push new YC jobs or companies into your ATS, CRM or data warehouse.

***

### 💡 Best Use Cases for Y Combinator Jobs & Companies Data

#### 💼 Startup job search and role tracking

Job seekers can filter listings by `prettyRole`, `location` and `minExperience`, then compare `salaryRange` and `equityRange` across companies. Because `createdAt` and `lastActive` show posting freshness, it is easy to prioritise roles that are actively being worked rather than stale listings.

#### 💰 Startup compensation benchmarking

YC roles publish pay bands unusually openly. Aggregating `salaryRange` by `prettyRole`, `location` and `minExperience` produces a primary-source benchmark of startup compensation — far more grounded than survey data, and refreshable whenever you rerun the scraper.

#### 🎯 Sales prospecting into funded startups

Companies mode with `batch` set to a recent cohort and `isHiring` set to true gives you a list of startups that are both newly funded and actively growing. Adding `enrichEmails` and `scrapeFounderDetails` turns that into a contactable prospect list with named decision makers.

#### 📈 Venture and market research

Filtering the directory by `batch`, `industry` and `regions` and counting the results shows how YC's sector weighting shifts cohort to cohort. Combining `teamSize`, `stage` and `launchedAt` gives a rough view of company maturity across a portfolio without any manual data entry.

#### 🧑‍💻 Technical recruiting and talent market analysis

Recruiters can track which `skills` appear across postings, how `visa` policies differ between companies, and where roles are concentrated by `location`. Running the scraper weekly with `monitoringMode` on gives an `isNew` flag that surfaces fresh openings the moment they appear.

#### 🔍 Competitive intelligence on hiring signals

A company's open roles are a public statement of strategy. Using `scrapeOpenJobs` against a target set of companies and watching how `title` and `roleSpecificType` change over time reveals where a competitor is investing before any announcement is made.

#### 📊 Building a YC portfolio dataset

For anyone maintaining a longitudinal dataset of YC companies, `id`, `slug` and `scrapedAt` make records stable and versionable, while `longDescription`, `tags` and `industries` supply enough text and taxonomy for classification and search.

***

### ⚙️ Tips for Better Y Combinator Scraping Results

- **Start with a low `maxItems`.** Confirm the record shape and filter behaviour on 20 items before committing to a full directory sweep with enrichment enabled.
- **Enable enrichment selectively.** `scrapeOpenJobs`, `scrapeFounderDetails` and `enrichEmails` each add page fetches per company; turning all three on for a large run multiplies the work considerably.
- **Use `startUrls` when you have already built the filter in the browser.** Constructing the search on ycombinator.com and pasting the resulting URL is often faster and more precise than reproducing the same filters through individual inputs.
- **Pair `monitoringMode` with a schedule.** The `isNew` flag is only meaningful across consecutive runs, so it earns its value on a recurring schedule rather than a one-off run.
- **Use residential proxies.** The `proxy` input defaults to Apify Proxy, and residential proxies are strongly recommended for this target — lower-quality egress leads to more retries and slower runs.
- **Lower `maxConcurrency` if requests start failing.** High concurrency is efficient until it is not; dropping it and raising `maxRequestRetries` usually stabilises a run that is producing errors.

***

### 🛠️ Troubleshooting

**The run returned no items.**
Check your filters first. Combining a narrow `batch` with a specific `industry`, a restrictive team size range and `topCompany` can legitimately match nothing. Widen the filters back to their defaults and reintroduce them one at a time to find the one that is over-constraining.

**Jobs mode is not using my role and location.**
`startUrls` overrides mode-based defaults. If it contains any URL, the `role` and `location` slugs are ignored. Clear `startUrls` to have the jobs URL built from `role` and `location` instead.

**Email enrichment produced almost no addresses.**
`enrichEmails` is explicitly best-effort — it visits each company's own website looking for a public contact or mailto address, and many startups do not publish one. Sparse results here are expected rather than a fault.

**Several fields are null on company records.**
YC directory entries vary a great deal in completeness. Fields such as `stage`, `subindustry`, `formerNames` and the video flags are only populated where the company has supplied them, so nulls reflect the source data.

**Requests are failing or the run is slow.**
Reduce `maxConcurrency`, raise `maxRequestRetries`, and make sure the `proxy` configuration is using Apify Proxy with residential proxies, which are strongly recommended for this target.

***

### ❓ Frequently Asked Questions About Y Combinator Scraping

**What does this Y Combinator scraper extract?**
In `jobs` mode it extracts Work at a Startup listings with titles, salary and equity ranges, locations, skills, experience requirements, visa policy and the hiring company. In `companies` mode it extracts the YC startup directory with batch, industry, team size, stage, region, website and descriptions.

**Can I scrape both YC jobs and YC companies in one run?**
Each run uses a single `mode`. To collect both, run the actor twice and join the results on the company name or slug.

**How do I scrape YC jobs for a specific role and city?**
Set `mode` to `jobs`, leave `startUrls` empty, and set `role` and `location` to the appropriate slugs, for example `software-engineer` and `san-francisco`.

**Does the scraper return salary data for YC jobs?**
Yes, where the posting publishes it. The `salaryRange` field carries the band exactly as listed, alongside `equityRange` for equity.

**Can I filter YC companies by batch?**
Yes. The `batch` array accepts values such as "Spring 2026", and "All Batches" disables the filter.

**How do I find only YC companies that are currently hiring?**
Set `isHiring` to true in companies mode. Combine it with `scrapeOpenJobs` to attach each company's live postings to its record.

**What does monitoring mode do?**
With `monitoringMode` enabled, the actor compares the current run against the previous one stored in its key-value store and tags every item with `isNew`, giving you a change feed rather than a full re-export.

**Can I get founder names and profiles from YC company pages?**
Yes. Enable `scrapeFounderDetails` and the actor fetches founder names, titles, bios and social links from each company page.

**Does the YC scraper find company email addresses?**
`enrichEmails` makes a best-effort attempt by visiting each company's own website and looking for a public contact or mailto address. It is not always available.

**How many YC companies or jobs can I scrape in one run?**
Up to `maxItems`, which defaults to 100 and applies across all sources in the run.

**Can I scrape a single YC company page?**
Yes. Put the company page URL, in the form `/companies/{slug}`, into `startUrls`. It overrides the mode-based defaults.

**Do I need to configure a proxy for this YC scraper?**
The `proxy` input takes a standard Apify proxy configuration and defaults to using Apify Proxy. Residential proxies are strongly recommended for this target.

**How do I export YC job listings to a spreadsheet?**
Export the dataset as CSV or Excel from the run's Dataset tab, or connect it to Google Sheets, Zapier or Make.

**What is the difference between `role`, `prettyRole` and `roleSpecificType`?**
`role` is the underlying role category slug, `prettyRole` is its human-readable form such as "Engineering", and `roleSpecificType` is a finer specialisation such as "Data science".

**Can I schedule the Y Combinator scraper to track new listings?**
Yes. Schedule it on Apify and enable `monitoringMode` so each run flags newly appeared companies and jobs with `isNew`.

***

### 🆘 Support & Feedback

If the Y Combinator scraper returns something unexpected for a particular filter combination or URL, open a report on the actor's **Issues** tab and include the input JSON you used. That makes the behaviour reproducible and the fix much faster.

For custom work — additional fields, a different output shape, or an integration into your ATS, CRM or warehouse — email **scraperhubapi@gmail.com** with what you need.

If this YC scraper is useful, a review on the actor page is genuinely appreciated and helps others find it.

***

### ⚖️ Disclaimer

This Y Combinator scraper collects only publicly accessible pages from ycombinator.com. It does not log in, access private or gated content, or bypass any authentication.

You are responsible for how the extracted data is used. Founder names, bios, social links and any contact emails collected through enrichment are personal data under GDPR, the UK GDPR, CCPA and comparable laws — process them only with a lawful basis, keep no more than you need, honour erasure requests, and comply with anti-spam rules such as CAN-SPAM, CASL and PECR before contacting anyone. Job and compensation data should be treated as published snapshots, not verified facts.

Use of this actor must also comply with Y Combinator's terms of service and Apify's platform terms. Scrape at a reasonable rate and use the concurrency controls responsibly.

If you believe personal data collected through this actor should be removed, contact **scraperhubapi@gmail.com** and the request will be handled.

# Actor input Schema

## `mode` (type: `string`):

"jobs" scrapes Work at a Startup job listings (ycombinator.com/jobs). "companies" scrapes the YC startup directory (ycombinator.com/companies).

## `startUrls` (type: `array`):

Direct ycombinator.com URLs to scrape: a company search page (e.g. /companies?batch=...\&industry=...), a single company page (/companies/{slug}), or a job-role page (/jobs/role/{role}/{location}). Overrides mode-based defaults when present.

## `role` (type: `string`):

Role slug used to build a jobs URL when no startUrls are given, e.g. "software-engineer".

## `location` (type: `string`):

Location slug used to build a jobs URL when no startUrls are given, e.g. "san-francisco".

## `queries` (type: `array`):

Free-text search terms applied against the companies index (company name / description).

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

Filter companies by YC batch, e.g. "Spring 2026". Use "All Batches" for no filter.

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

Filter companies by industry, e.g. "B2B". Use "All industries" for no filter.

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

Filter companies by region. Use "Anywhere" for no filter.

## `minEmployeeSize` (type: `string`):

Minimum team size, e.g. "1+".

## `maxEmployeeSize` (type: `string`):

Maximum team size, e.g. "1000+". A "+" suffix means no upper bound.

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

Only include companies currently marked as hiring.

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

Only include nonprofit companies.

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

Only include companies YC has flagged as "top company".

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

For each company result, also fetch its open job postings from its company page.

## `scrapeFounderDetails` (type: `boolean`):

For each company result, also fetch founder names, titles, bios and social links from its company page.

## `enrichEmails` (type: `boolean`):

Best-effort: visit each company's own website and look for a public contact/mailto email address. Not always available.

## `monitoringMode` (type: `boolean`):

Compare this run's results against the previous run (via the actor's key-value store) and tag each item with isNew.

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

Maximum number of items to output across all sources.

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

Maximum number of concurrent requests.

## `minConcurrency` (type: `integer`):

Starting/minimum number of concurrent requests.

## `maxRequestRetries` (type: `integer`):

Maximum retry attempts per failed request.

## `proxy` (type: `object`):

Apify proxy configuration. Residential proxies are strongly recommended.

## Actor input object example

```json
{
  "mode": "jobs",
  "startUrls": [
    "https://www.ycombinator.com/jobs/role/software-engineer/san-francisco",
    "https://www.ycombinator.com/companies?batch=Spring%202026&industry=B2B"
  ],
  "role": "",
  "location": "",
  "queries": [],
  "batch": [
    "All Batches"
  ],
  "industries": [
    "All industries"
  ],
  "regions": [
    "Anywhere"
  ],
  "minEmployeeSize": "1+",
  "maxEmployeeSize": "1000+",
  "isHiring": false,
  "nonprofit": false,
  "topCompany": false,
  "scrapeOpenJobs": false,
  "scrapeFounderDetails": false,
  "enrichEmails": false,
  "monitoringMode": false,
  "maxItems": 100,
  "maxConcurrency": 10,
  "minConcurrency": 1,
  "maxRequestRetries": 3,
  "proxy": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Records scraped by Y Combinator · YC · Only $1💰 · Jobs & 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 = {
    "startUrls": [
        "https://www.ycombinator.com/jobs/role/software-engineer/san-francisco",
        "https://www.ycombinator.com/companies?batch=Spring%202026&industry=B2B"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/y-jobs-companies-scrapers").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 = { "startUrls": [
        "https://www.ycombinator.com/jobs/role/software-engineer/san-francisco",
        "https://www.ycombinator.com/companies?batch=Spring%202026&industry=B2B",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/y-jobs-companies-scrapers").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 '{
  "startUrls": [
    "https://www.ycombinator.com/jobs/role/software-engineer/san-francisco",
    "https://www.ycombinator.com/companies?batch=Spring%202026&industry=B2B"
  ]
}' |
apify call scrapers-hub/y-jobs-companies-scrapers --silent --output-dataset

```

## MCP server setup

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

```

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/OfuH06Zmcn8OH5bGw/builds/vtIlCUWqfk7VxP5SS/openapi.json