# Y Combinator Jobs Scraper | YC Startup Hiring Data (`tqm/ycombinator-scraper`) Actor

Scrape Y Combinator's Work at a Startup board: every YC-backed company currently hiring, with role, company, YC batch, location, salary and detected tech stack. A small, high-signal board - every row is a funded startup. No browser, no proxy, no login. Schedule it daily to track new postings.

- **URL**: https://apify.com/tqm/ycombinator-scraper.md
- **Developed by:** [TQM](https://apify.com/tqm) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 3 total users, 2 monthly users, 83.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

# README

Y Combinator Job Scraper extracts startup job listings from [Y Combinator's Work at a Startup](https://www.ycombinator.com/jobs) board — the hiring board for YC-backed companies — as structured rows with company, role, location, batch and detected tech stack.

It reads the public jobs list over plain HTTP. **No browser, no proxy, no login.**

### What data can I extract from Y Combinator?

| Field | Description |
|---|---|
| `title` | Job title as posted |
| `company` | YC-backed company that is hiring |
| `companyUrl` | Link to the company's YC profile |
| `companyDescription` | The company's one-line description, when the list carries it |
| `ycBatch` | The company's YC batch, e.g. `W24`, when stated |
| `jobUrl` | Link to the original posting |
| `location` | Location as listed |
| `remote` | Whether the role is remote |
| `salary` | Compensation string as posted |
| `salaryMin` / `salaryMax` | Parsed salary bounds |
| `currency` | Salary currency |
| `hasEquity` | Whether equity is mentioned in the listing text |
| `role` | Role classification, when stated |
| `jobType` | Employment type, when stated |
| `techStack` / `skills` | Technologies inferred from the title and blurb |
| `postedAt` | Publication date, when stated |
| `jobId` | Stable id, useful as a deduplication key |
| `scrapedAt` | When this run collected the row |

### How do I use Y Combinator Job Scraper?

1. Click **Try for free**.
2. Leave the input empty for the whole current board — that is the recommended first run.
3. Click **Save & Start**.
4. Export as JSON, CSV, Excel or XML from the **Storage** tab.

Filters are available, but read the section on them below before switching any on: this board publishes less per listing than most, and narrow filters remove more than you would expect.

### Input reference

| Option | Type | Default | What it does |
|---|---|---|---|
| `maxJobs` | integer | `50` | How many postings to return, up to **50**. See the ceiling section — the board rarely holds that many. |
| `roles` | array | *(none)* | Filter by role, e.g. `["Engineering", "Design", "Sales"]`. |
| `remoteOnly` | boolean | `false` | Keep only remote roles. |
| `minSalary` | integer | `0` | Drop postings below this annual figure. Most YC listings state no salary, so this removes most of the board. |
| `techStackFilter` | array | *(none)* | Keep only postings whose **inferred** stack matches. Read the warning below. |
| `equityOnly` | boolean | `false` | Keep only postings mentioning equity. **Almost always returns nothing** — see below. |
| `failOnZeroResults` | boolean | `true` | Fail the run, with a reason, when it returns nothing. |

#### Input sample

```json
{
  "maxJobs": 50,
  "remoteOnly": true,
  "failOnZeroResults": true
}
```

### Output sample

```json
{
  "source": "ycombinator",
  "jobId": "yc-northwind-founding-engineer",
  "title": "Founding Engineer",
  "company": "Northwind",
  "companyUrl": "https://www.ycombinator.com/companies/northwind",
  "companyDescription": "AI-native observability for backend teams",
  "ycBatch": "W24",
  "jobUrl": "https://www.ycombinator.com/companies/northwind/jobs/abc123-founding-engineer",
  "location": "San Francisco, CA",
  "remote": false,
  "salary": "$150K - $200K",
  "salaryMin": 150000,
  "salaryMax": 200000,
  "currency": "USD",
  "hasEquity": true,
  "role": "Engineering",
  "jobType": "Full-time",
  "techStack": ["python", "kubernetes"],
  "skills": ["python", "kubernetes"],
  "scrapedAt": "2026-09-04T09:16:48.902Z"
}
```

### How many jobs can I scrape from Y Combinator?

**Around 20 — and that is the entire board, not a limit we imposed.**

Y Combinator's jobs page is a single un-paginated list. Measured on 2026-08-27 it carried **20 postings**, and the actor does not paginate beyond it because there is nothing to paginate to. `maxJobs` is capped at 50 to leave headroom for busier days, not because 50 is typically reachable.

This is a **small, high-signal board**, and it should be used that way: every company on it is YC-backed, recently funded and actively hiring. If you need volume, schedule the actor daily and deduplicate on `jobId` — the board turns over continuously.

### Two filters that will surprise you

We would rather you read this here than discover it in a paid run.

#### `equityOnly` almost always returns nothing

Equity is detected from the words on YC's jobs list, and **that list does not state equity for most postings** — even though most YC roles do offer it. Measured against a live board, `equityOnly` rejected **20 of 20** listings. Leave it off unless you specifically want the handful that spell equity out.

#### `techStackFilter` matches an *inferred* stack

YC's list page carries a job title and a short blurb, not a full description. The tech stack is therefore inferred from those few words, and it is often empty. Measured against a live board, `techStackFilter` rejected **19 of 20** listings. Use it only when you genuinely want that narrow a slice, and expect small numbers.

Both filters now **fail loudly and name themselves** in the run's status message when they remove everything, so a zero-row run tells you which filter did it rather than leaving you guessing.

### A run that returns nothing tells you why

With `failOnZeroResults: true` (the default), an empty run **fails** with a message naming the cause — a specific filter, a refused page, or a change in YC's page structure. On pay-per-result pricing a silent zero-row "success" is you paying for nothing. Set it to `false` for scheduled monitoring runs.

### How much does it cost?

Very low. One HTTP request to a public page, no browser, no proxy. Filtering happens after the fetch, so filters do not change the cost of a run.

Run it once with your real input and read the exact figure from the **Runs** tab.

### Who is this for?

- **Job seekers targeting early-stage startups** — this is the most concentrated list of YC-backed companies hiring right now.
- **Recruiters** tracking which YC batches are staffing up and for what roles.
- **Investors and researchers** using hiring as a growth signal across the YC portfolio.
- **Lead generation** — recently funded startups that are hiring engineers are among the most reliable buyers of developer tooling and services.

### FAQ

#### Do I need a Y Combinator account?

No. This actor reads the public jobs list. There is no login and no account to be banned.

#### Why does it return so few results?

Because the board is small. This is a curated list of YC-backed companies, not a general job board — roughly 20 live postings is normal. That concentration is the point: every row is a funded startup.

#### Will I get blocked?

Unlikely. The actor makes a single ordinary HTTP request to a public page.

#### Is it legal to scrape Y Combinator's job board?

This actor collects only publicly published job listings and extracts no private user data. Results may still contain personal data. You should not scrape or store personal data without a legitimate reason; if unsure, consult your lawyers. See Apify's background on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

#### Can I export to Excel or Google Sheets?

Yes — JSON, CSV, XML and Excel from the **Storage** tab, plus a direct Google Sheets integration.

### Integrations and API

Trigger runs and collect results via the [Apify API](https://docs.apify.com/api/v2), the JavaScript or Python client, or Apify's integrations — **Zapier, Make, Slack, Google Drive, GitHub and webhooks**. A daily schedule plus a completion webhook gives you a live feed of new YC startup roles.

### Support

Missing a field or seeing something wrong? Open an issue on this actor's **Issues** tab.

# Actor input Schema

## `maxJobs` (type: `integer`):

Maximum postings to return. YCombinator's jobs page is a single un-paginated list: measured 2026-08-27 it carried 20 postings, and the actor does not paginate. Asking for more cannot return more.

## `techStackFilter` (type: `array`):

Only return jobs whose detected tech stack matches. ⚠️ Matches against the stack inferred from the listing's title and blurb, which YCombinator's list page keeps very short — measured 2026-08-27, filtering on devops/kubernetes/aws rejected 19 of 20. Filter your own side if you need recall.

## `roles` (type: `array`):

Filter by roles (e.g., Engineering, Design, Sales)

## `remoteOnly` (type: `boolean`):

Only return remote jobs

## `minSalary` (type: `integer`):

Filter jobs with salary below this amount

## `equityOnly` (type: `boolean`):

⚠️ Almost always returns nothing. Equity is detected from the words on YCombinator's jobs list, and that list does not state equity for most postings — measured 2026-08-27, this rejected 20 of 20. Nearly every YC role does grant equity; the list page simply does not say so. Leave off unless you specifically want the few postings that mention it in their title or blurb.

## `failOnZeroResults` (type: `boolean`):

When on (default), a run that finds no postings FAILS with a message explaining why — too-narrow filters, a refused page, or a change in YCombinator's markup. Turn it off if you run this on a schedule and want quiet runs to stay green.

## Actor input object example

```json
{
  "maxJobs": 50,
  "techStackFilter": [],
  "roles": [],
  "remoteOnly": false,
  "minSalary": 0,
  "equityOnly": false,
  "failOnZeroResults": true
}
```

# Actor output Schema

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

Every job posting this run returned from the Y Combinator jobs board, one row each.

# 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("tqm/ycombinator-scraper").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {}

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

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

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

```

## CLI example

```bash
echo '{}' |
apify call tqm/ycombinator-scraper --silent --output-dataset

```

## MCP server setup

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

```

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

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/5lhzgrlm7KmpXbgsr/builds/FDgI80abhJIjO4Izy/openapi.json