# Y Combinator Jobs Scraper (`automation-lab/ycombinator-jobs-scraper`) Actor

Extract public YC Work at a Startup jobs with company, batch, location, salary, equity, visa, skills, and apply URLs.

- **URL**: https://apify.com/automation-lab/ycombinator-jobs-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

Extract public job postings from YC Work at a Startup.

### What does Y Combinator Jobs Scraper do?

Y Combinator Jobs Scraper collects the public job postings currently embedded on the YC jobs page at `https://www.ycombinator.com/jobs`.

It returns a clean dataset with job titles, company names, YC batches, locations, role categories, salary ranges, equity ranges, visa requirements, experience requirements, skills, public job URLs, and apply URLs.

Use it when you want a fast, HTTP-only way to monitor publicly visible roles at YC-backed startups.

### Who is it for?

Recruiters can use it to watch hiring demand across YC companies.

Startup analysts can track which YC batches and sectors are actively hiring.

Job-board operators can enrich startup job feeds with YC-specific company metadata.

Candidates can export the currently public YC jobs list for research and shortlisting.

Sales and partnership teams can find recently hiring startups that may need recruiting, payroll, developer tooling, finance, or HR products.

### Why use this actor?

⚡ It is HTTP-only and lightweight.

🏢 It includes YC company context, not just raw job titles.

💼 It extracts compensation and role metadata when YC exposes it.

🔎 It supports keyword, role, type, batch, and remote filters.

📦 It produces a flat dataset that is easy to export to CSV, JSON, Google Sheets, or your own pipeline.

### What data can I extract?

| Field | Description |
| --- | --- |
| `id` | YC job posting ID |
| `title` | Job title |
| `url` | Public YC job URL |
| `applyUrl` | Apply URL exposed by YC |
| `companyName` | YC company name |
| `companySlug` | Company slug from YC URL |
| `companyBatch` | YC batch, for example W21 or S21 |
| `companyOneLiner` | YC one-line company description |
| `location` | Location text from YC |
| `isRemote` | Boolean derived from the location text |
| `type` | Employment type |
| `role` | YC role code |
| `roleSpecificType` | More specific role subtype |
| `prettyRole` | Human-readable role category |
| `salaryRange` | Salary range when present |
| `equityRange` | Equity range when present |
| `minExperience` | Minimum experience text |
| `minSchoolYear` | School year requirement when present |
| `visa` | Visa requirement text |
| `skills` | Skills/tags listed by YC |
| `createdAt` | Relative posting age shown by YC |
| `lastActive` | Relative company/activity metadata shown by YC |
| `scrapedAt` | Timestamp of the actor run |

### How much does it cost to scrape YC jobs?

This actor uses pay-per-event pricing.

You pay a small run start event plus one result event for each YC job posting saved to the dataset.

The default intended price is $0.50 per 1,000 job results, plus the run start event.

Because the scraper is HTTP-only and does not use a browser, typical runs are designed to be inexpensive.

### How to scrape YC jobs

1. Open the actor on Apify.
2. Set `maxItems` to the number of jobs you want.
3. Optionally add a keyword such as `software engineer`, `sales`, or `remote`.
4. Optionally filter by role, job type, YC batch, or remote-only jobs.
5. Run the actor.
6. Export the dataset as JSON, CSV, Excel, XML, or HTML.

### Input options

#### `maxItems`

Maximum number of matching jobs to save.

Start with 25 for a quick test.

#### `query`

A free-text search across title, company, one-liner, location, role, salary, equity, experience, visa, and skills.

#### `role`

Filter by YC role/category. Examples include `eng`, `Engineering`, `product`, `sales`, `design`, or `operations`.

#### `jobType`

Filter by employment type such as `Full-time`, `Internship`, or `Cofounder`.

#### `remoteOnly`

When enabled, only jobs whose location text includes `Remote` are saved.

#### `companyBatch`

Filter to a YC batch such as `W24`, `S21`, or `F24`.

#### `includeIncomplete`

YC marks some listings as incomplete. This is disabled by default so the output stays cleaner.

### Example input

```json
{
  "maxItems": 25,
  "query": "software engineer",
  "remoteOnly": false
}
````

### Example output

```json
{
  "id": 93174,
  "title": "Forward Deployed Engineer",
  "url": "https://www.ycombinator.com/companies/confido/jobs/XgiWhOL-forward-deployed-engineer",
  "companyName": "Confido",
  "companyBatch": "S21",
  "location": "NYC Office",
  "isRemote": false,
  "type": "Full-time",
  "prettyRole": "Engineering",
  "salaryRange": "$150K - $200K",
  "equityRange": "0.05% - 0.10%",
  "minExperience": "3+ years",
  "visa": "US citizen/visa only"
}
```

### Tips for better results

Use a broad `query` if you want to search multiple fields at once.

Use `companyBatch` when you want to focus on a specific YC cohort.

Use `remoteOnly` for candidate sourcing workflows.

Leave `includeIncomplete` disabled unless you specifically need all public rows YC exposes.

Use small `maxItems` values for scheduled monitoring runs.

### Integrations

Send new YC jobs to Google Sheets for recruiting dashboards.

Load the dataset into Airtable to build a startup hiring tracker.

Connect Apify webhooks to Slack to notify your team when matching jobs appear.

Export JSON to enrich your own job-board database.

Use the Apify API to run daily monitoring jobs from cron or CI.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/ycombinator-jobs-scraper').call({
  maxItems: 25,
  query: 'software engineer'
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/ycombinator-jobs-scraper').call(run_input={
    'maxItems': 25,
    'query': 'software engineer',
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~ycombinator-jobs-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"maxItems":25,"query":"software engineer"}'
```

### MCP integration

Use this actor through Apify MCP with Claude Code or Claude Desktop.

MCP server URL:

```text
https://mcp.apify.com/?tools=automation-lab/ycombinator-jobs-scraper
```

Claude Code setup:

```bash
claude mcp add apify-yc-jobs https://mcp.apify.com/?tools=automation-lab/ycombinator-jobs-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-yc-jobs": {
      "url": "https://mcp.apify.com/?tools=automation-lab/ycombinator-jobs-scraper"
    }
  }
}
```

Example prompts:

- “Run the YC jobs scraper for remote software engineer roles and summarize the companies.”
- “Find public YC jobs with salary ranges and export them as a CSV.”
- “Compare YC batches represented in the latest public jobs dataset.”

### Scheduling

You can schedule this actor daily or weekly to monitor public YC hiring signals.

For monitoring workflows, keep `maxItems` modest and use a keyword or role filter.

### Data freshness

The actor reads the public YC jobs page at run time.

Fields such as `createdAt` and `lastActive` are relative strings as displayed by YC.

The `scrapedAt` field records when your run collected the row.

### Limitations

The actor does not log in to YC or Work at a Startup.

It only extracts job data visible in the public HTML response.

Apply URLs may lead to YC account or candidate profile flows.

If YC changes the embedded page structure, the actor may need an update.

### Legality

This actor collects publicly visible information from YC pages.

Use the data responsibly and respect applicable laws, website terms, and privacy requirements.

Do not use scraped data for spam or abusive outreach.

### FAQ and troubleshooting

#### Why did I get fewer jobs than `maxItems`?

Your filters may match fewer public postings than requested, or the public YC page may expose fewer rows at that moment.

#### Why is `applyUrl` an account URL?

YC may route applications through an account or candidate profile flow. The actor records the URL exposed publicly by YC.

#### Why are salary or equity fields empty?

Not every posting includes compensation details.

### Related scrapers

Explore related actors by Automation Lab:

- https://apify.com/automation-lab/ycombinator-scraper
- https://apify.com/automation-lab/linkedin-company-scraper
- https://apify.com/automation-lab/company-funding-tracker
- https://apify.com/automation-lab/google-jobs-scraper

### Changelog

#### 0.1

Initial build for public YC job postings.

### Support

If the actor stops returning public YC jobs, open an issue with your run URL and input.

### Summary

Y Combinator Jobs Scraper is a lightweight way to collect structured hiring data from public YC job listings.

# Actor input Schema

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

Maximum number of YC job postings to save. The actor reads the public YC jobs page and stops after this many matching jobs.

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

Optional free-text filter across job title, company name, one-liner, location, role, salary, visa, and skills.

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

Optional YC role/category filter. Examples: eng, Engineering, sales, product, operations, design.

## `jobType` (type: `string`):

Optional employment type filter such as Full-time, Internship, or Cofounder.

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

Only save postings whose YC location text includes Remote.

## `companyBatch` (type: `string`):

Optional exact YC batch filter such as W24, S21, or F24.

## `includeIncomplete` (type: `boolean`):

YC marks some postings as incomplete. Leave disabled for cleaner recruiting datasets.

## Actor input object example

```json
{
  "maxItems": 20,
  "remoteOnly": false,
  "includeIncomplete": false
}
```

# Actor output Schema

## `overview` (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 = {
    "maxItems": 20,
    "remoteOnly": false,
    "includeIncomplete": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/ycombinator-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 = {
    "maxItems": 20,
    "remoteOnly": False,
    "includeIncomplete": False,
}

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

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

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

```

## CLI example

```bash
echo '{
  "maxItems": 20,
  "remoteOnly": false,
  "includeIncomplete": false
}' |
apify call automation-lab/ycombinator-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/ycombinator-jobs-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Y Combinator Jobs Scraper",
        "description": "Extract public YC Work at a Startup jobs with company, batch, location, salary, equity, visa, skills, and apply URLs.",
        "version": "0.1",
        "x-build-id": "Kd4IaJeUPSbqdcW7l"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~ycombinator-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-ycombinator-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~ycombinator-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-ycombinator-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~ycombinator-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-ycombinator-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of YC job postings to save. The actor reads the public YC jobs page and stops after this many matching jobs.",
                        "default": 100
                    },
                    "query": {
                        "title": "Keyword search",
                        "type": "string",
                        "description": "Optional free-text filter across job title, company name, one-liner, location, role, salary, visa, and skills."
                    },
                    "role": {
                        "title": "Role / category",
                        "type": "string",
                        "description": "Optional YC role/category filter. Examples: eng, Engineering, sales, product, operations, design."
                    },
                    "jobType": {
                        "title": "Job type",
                        "type": "string",
                        "description": "Optional employment type filter such as Full-time, Internship, or Cofounder."
                    },
                    "remoteOnly": {
                        "title": "Remote jobs only",
                        "type": "boolean",
                        "description": "Only save postings whose YC location text includes Remote.",
                        "default": false
                    },
                    "companyBatch": {
                        "title": "YC batch",
                        "type": "string",
                        "description": "Optional exact YC batch filter such as W24, S21, or F24."
                    },
                    "includeIncomplete": {
                        "title": "Include incomplete postings",
                        "type": "boolean",
                        "description": "YC marks some postings as incomplete. Leave disabled for cleaner recruiting datasets.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
