# YC Jobs Scraper (`axlymxp/yc-jobs-scraper`) Actor

Scrape open jobs at Y Combinator startups — title, salary, equity, visa sponsorship, skills, experience, role and location — plus company batch and industry. Filter by role, location, batch or company. Live postings as structured JSON. Pay only for the results you get.

- **URL**: https://apify.com/axlymxp/yc-jobs-scraper.md
- **Developed by:** [axly](https://apify.com/axlymxp) (community)
- **Categories:** Jobs, Lead generation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 dataset items

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

# README

## Y Combinator Jobs Scraper

Export **open jobs at Y Combinator startups** as clean, structured JSON — each role
with **salary range, equity range, visa sponsorship, required skills, minimum
experience, role and location**, plus the hiring company's **batch, industry, size
and website**. Filter by role, location, batch, industry or specific companies.

Jobs are read from each company's **live postings** on Y Combinator's own pages
(an official, unauthenticated path with **no anti-bot**), so the feed is current and
reliable — not a stale sitemap dump.

### Who uses this

- **Recruiters & staffing** — live startup roles with compensation and visa data to
  source candidates and benchmark offers.
- **Job boards & aggregators** — a clean, deduplicated feed of YC startup jobs.
- **Candidates & career tools** — salary, equity and visa-sponsorship intelligence
  across the YC ecosystem.
- **Talent-market researchers** — hiring trends by role, batch and geography.

### Output fields

| Field                                    | Type    | Description                                |
| ---------------------------------------- | ------- | ------------------------------------------ |
| `title`, `url`, `applyUrl`               | string  | Job title, YC job URL, application URL     |
| `role`, `prettyRole`, `roleSpecificType` | string  | Role group and sub-type                    |
| `type`                                   | string  | Employment type (e.g. Full-time)           |
| `location`                               | string  | Job location                               |
| `remote`                                 | boolean | Whether the role is remote                 |
| `salaryRange`                            | string  | Salary range as published                  |
| `equityRange`                            | string  | Equity range as published                  |
| `minExperience`                          | string  | Minimum experience required                |
| `minSchoolYear`                          | string  | Minimum school year (for new-grad roles)   |
| `visa`                                   | string  | Visa sponsorship policy                    |
| `skills`                                 | array   | Required skills                            |
| `hiringManager`                          | object  | `{name, title, avatarUrl}` where published |
| `createdAt`, `lastActive`                | string  | Posting age and last-active signal         |
| `description`                            | string  | Full job description (when enabled)        |
| `interviewProcess`                       | string  | Interview process (when enabled)           |
| `companySlug`, `companyName`             | string  | Hiring company identity                    |
| `companyBatch`, `companyIndustry`        | string  | YC batch and industry                      |
| `companyTeamSize`                        | number  | Company team size                          |
| `companyWebsite`, `companyUrl`           | string  | Company website and YC profile             |
| `companyOneLiner`, `companyLogoUrl`      | string  | Company tagline and logo                   |
| `scrapedAt`                              | string  | ISO-8601 UTC timestamp                     |

`description` and `interviewProcess` are populated when **Include full description**
is enabled (the default).

### High-value use cases

1. **Sourcing pipelines** — pull every open Engineering role across a batch or
   industry, with salary and visa data, straight into your ATS.
2. **Salary & equity benchmarking** — build a compensation dataset across YC
   startups by role and stage.
3. **Niche job boards** — power a "startup jobs" board with a fresh, structured
   feed filtered by role or location.
4. **Company-specific tracking** — watch named companies (`companySlugs`) for new
   roles and react fast.
5. **Remote-only search** — filter `remoteOnly` to surface distributed roles.

### Input parameters

| Field                | Type    | Default | Description                                                       |
| -------------------- | ------- | ------- | ----------------------------------------------------------------- |
| `companyQuery`       | string  | `""`    | Only companies matching this search; empty = all hiring companies |
| `companySlugs`       | array   | `[]`    | Only these companies (YC slugs); overrides the search             |
| `batches`            | array   | `[]`    | Filter companies by YC batch                                      |
| `industries`         | array   | `[]`    | Filter companies by industry                                      |
| `regions`            | array   | `[]`    | Filter companies by region                                        |
| `roles`              | array   | `[]`    | Keep only these roles (e.g. Engineering, Sales, Design)           |
| `location`           | string  | `""`    | Keep only jobs whose location contains this text                  |
| `remoteOnly`         | boolean | `false` | Keep only remote roles                                            |
| `includeDescription` | boolean | `true`  | Add full description + interview process                          |
| `maxItems`           | integer | `100`   | Cap the number of jobs                                            |
| `proxyConfiguration` | object  | direct  | Optional Apify proxy                                              |

#### Example input

```json
{
    "companyQuery": "fintech",
    "roles": ["Engineering"],
    "remoteOnly": true,
    "includeDescription": true,
    "maxItems": 100
}
```

#### Example output (one row, truncated)

```json
{
    "jobId": 249,
    "title": "Software Engineer, Android",
    "url": "https://www.ycombinator.com/companies/doordash/jobs/BV8AJW4Tt-software-engineer-android",
    "prettyRole": "Engineering",
    "type": "Full-time",
    "location": "San Francisco, CA",
    "remote": false,
    "salaryRange": "$150K - $200K",
    "equityRange": "0.10% - 0.25%",
    "minExperience": "3+ years",
    "visa": "US citizen/visa only",
    "skills": ["Android", "Kotlin"],
    "companyName": "DoorDash",
    "companyBatch": "Summer 2013",
    "companyIndustry": "Consumer",
    "scrapedAt": "2026-08-17T12:00:00Z"
}
```

### Scheduling & integrations

- **Schedule** daily/weekly runs from the Apify Console to keep a live jobs feed.
- **Webhooks** on run completion can push new roles into your ATS or Slack.
- Export to **JSON, CSV, Excel or Google Sheets**, pull via the Apify **API**, or
  connect to **Make**, **Zapier** and **n8n**.

### Use it from an AI agent (MCP)

This Actor works with the **Apify MCP server**, so assistants like Claude or
ChatGPT can call it as a tool and receive the structured jobs data directly — handy
for job-search and recruiting agents.

### FAQ

**Where do the jobs come from?** From each YC company's live postings on
ycombinator.com — the current, on-site source (not a stale jobs sitemap), so
results reflect what's actually open.

**How many jobs can I get?** Thousands of roles are open across YC companies at any
time. Use `maxItems` to cap a run, or filters to target a subset.

**Is salary/equity/visa always present?** These are included whenever the company
publishes them on the posting; some fields may be blank when the company omits them.

**How fresh is the data?** Every run reads live pages, so postings reflect YC's
current data at run time.

**Is it reliable?** It uses YC's own page data (no HTML scraping tricks and no
anti-bot to fight), so it is stable and fast.

**Is this legal?** The Actor collects only publicly available job postings. You are
responsible for using the data in line with YC's terms and applicable laws.

**Support?** Issues and feature requests are welcome on the Actor's Issues tab.

# Actor input Schema

## `companyQuery` (type: `string`):

Only collect jobs from Y Combinator companies matching this search (e.g. "fintech", "developer tools"). Leave empty to scan all companies that are currently hiring.

## `companySlugs` (type: `array`):

Only collect jobs from these companies (YC slugs, e.g. "stripe", "doordash"). Overrides the company search and filters below.

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

Only include jobs from companies in these YC batches, e.g. "Winter 2024".

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

Only include jobs from companies in these industries, e.g. "B2B", "Fintech", "Healthcare".

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

Only include jobs from companies in these regions, e.g. "America / Canada", "Europe".

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

Only keep jobs whose role matches one of these (case-insensitive), e.g. "Engineering", "Sales", "Design", "Operations", "Marketing".

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

Only keep jobs whose location contains this text (case-insensitive), e.g. "New York", "London", "Remote".

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

Only keep jobs whose location indicates a remote role.

## `includeDescription` (type: `boolean`):

Fetch each job's detail page to add the full job description and interview process (one extra request per job).

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

Stop after this many jobs.

## `proxyConfiguration` (type: `object`):

Optional Apify proxy. The YC API works without a proxy; use one only if you need a specific egress region.

## Actor input object example

```json
{
  "companySlugs": [
    "stripe",
    "doordash"
  ],
  "batches": [],
  "industries": [],
  "regions": [],
  "roles": [
    "Engineering",
    "Design"
  ],
  "remoteOnly": false,
  "includeDescription": true,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "companyQuery": "",
    "companySlugs": [],
    "batches": [],
    "industries": [],
    "regions": [],
    "roles": [],
    "location": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("axlymxp/yc-jobs-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 = {
    "companyQuery": "",
    "companySlugs": [],
    "batches": [],
    "industries": [],
    "regions": [],
    "roles": [],
    "location": "",
}

# Run the Actor and wait for it to finish
run = client.actor("axlymxp/yc-jobs-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 '{
  "companyQuery": "",
  "companySlugs": [],
  "batches": [],
  "industries": [],
  "regions": [],
  "roles": [],
  "location": ""
}' |
apify call axlymxp/yc-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,axlymxp/yc-jobs-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/qrPr2oxuPmdrH4DlM/builds/Id1hFtWQ2QpCdBMJ0/openapi.json