# Which YC Companies Are Hiring (`artemlazarevm/which-yc-companies-are-hiring`) Actor

Returns every Y Combinator company that is hiring right now, around 1,500 of the 6,200 in the YC directory. Filter by batch, industry, location, stage, team size and remote. Every row links straight to that company's live YC job listings.

- **URL**: https://apify.com/artemlazarevm/which-yc-companies-are-hiring.md
- **Developed by:** [Artem Lazarev](https://apify.com/artemlazarevm) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.08 / actor start

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

## Which YC Companies Are Hiring

Get the full list of Y Combinator companies that are hiring right now, as structured data, in one run.

Right now that is **1,477 of YC's 6,202 companies** — about 24% of the portfolio. The list changes every day as companies open and close roles, and this Actor gives you the current version of it whenever you ask.

No login, no cookies, no browsing 6,000 company pages. A full run takes a few seconds.

### What this Actor does

The YC company directory hides a useful signal: which startups are actively hiring. That signal is scattered across thousands of individual company pages and mixed in with companies that are dormant, acquired, or fully staffed.

This Actor returns just the hiring ones, filtered the way you want them, as a clean list you can send to a spreadsheet, a CRM, a database, or your own app.

Ask it things like:

- Every Fintech company from the last four batches that is hiring
- Remote-friendly startups with fewer than 10 people that are hiring
- Companies in London or Bangalore that are hiring
- Every YC "top company" that is hiring

### Who it's for

**Job seekers and recruiters.** Skip the companies that are not hiring. Every row includes a direct link to that company's live YC job listings, so you can go from list to application in one click. 760 of the companies currently hiring are remote-friendly.

**Sales and BD teams.** Hiring is the cheapest public signal that a startup has money and is growing. Filter to your ICP — B2B, Fintech, 10+ people, US-based — and you have a prospect list of companies that just raised or are scaling, complete with website, location, team size, and description for personalization.

**VCs and analysts.** Track hiring as a growth proxy across batches, industries, and regions. Run it on a schedule and diff the results to see who started hiring this week.

**Builders.** Power a job board, a newsletter, a Slack alert, or an AI agent with a reliable, structured feed of hiring startups.

### What you get

One row per company:

| Field | Example |
| --- | --- |
| `name` | `Tesora` |
| `oneLiner` | `Frontier AI for Actuaries` |
| `description` | Full YC company description |
| `website` | `https://tesora.ai` |
| `jobsUrl` | `https://www.ycombinator.com/companies/tesora/jobs` |
| `ycUrl` | `https://www.ycombinator.com/companies/tesora` |
| `logoUrl` | Company logo |
| `batch` | `Summer 2025` |
| `industry` / `subindustry` | `Fintech` / `Fintech -> Insurance` |
| `industries` / `tags` | `["Fintech", "Insurance"]` / `["API", "Insurance", "AI"]` |
| `teamSize` | `5` |
| `stage` | `Early` or `Growth` |
| `status` | `Active` or `Public` |
| `allLocations` | `San Francisco, CA, USA` |
| `regions` | `["United States of America", "America / Canada"]` |
| `isRemoteFriendly` | `true` when YC lists the company as remote or partly remote |
| `topCompany` | `true` for YC's top companies |
| `nonprofit` | `false` |
| `launchedAt` | `2025-08-19` |
| `ycCompanyId` | `30663` |
| `slug` | `tesora` |
| `checkedAt` | Timestamp of this run |

#### Sample output

```json
{
  "name": "Tesora",
  "slug": "tesora",
  "oneLiner": "Frontier AI for Actuaries",
  "description": "Tesora builds frontier AI agents for actuaries at P&C carriers, reinsurers, and MGAs...",
  "website": "https://tesora.ai",
  "ycUrl": "https://www.ycombinator.com/companies/tesora",
  "jobsUrl": "https://www.ycombinator.com/companies/tesora/jobs",
  "logoUrl": "https://bookface-images.s3.amazonaws.com/small_logos/2793bc4802e1c1cddfc383aed3ac255ec33a0465.png",
  "batch": "Summer 2025",
  "industry": "Fintech",
  "subindustry": "Fintech -> Insurance",
  "industries": ["Fintech", "Insurance"],
  "tags": ["API", "Insurance", "AI"],
  "teamSize": 5,
  "stage": "Early",
  "status": "Active",
  "allLocations": "San Francisco, CA, USA",
  "regions": ["United States of America", "America / Canada"],
  "isRemoteFriendly": false,
  "topCompany": false,
  "nonprofit": false,
  "launchedAt": "2025-08-19",
  "ycCompanyId": 30663,
  "checkedAt": "2026-09-05T15:54:05+00:00"
}
```

Every run also writes a summary to the key-value store under `OUTPUT`:

```json
{ "totalHiring": 1477, "totalReturned": 5, "checkedAt": "2026-09-05T15:54:05+00:00" }
```

### How to use it

1. Click **Start** with empty input to get every YC company that is hiring.
2. Add filters to narrow it down (all optional, see below).
3. Export the results as JSON, CSV, Excel, or XML, or pull them from the [Apify API](https://docs.apify.com/api/v2).
4. Optional: set a **schedule** to re-run it daily and watch the list change.

### Input

Everything is optional. An empty input returns the complete list.

| Field | Type | What it does |
| --- | --- | --- |
| `maxCompanies` | integer | Cap the number of companies returned |
| `search` | string | Free-text match on name, tagline, and description |
| `batch` | array | `W25`, `S25`, or `Summer 2025` — both styles work |
| `industry` | array | Matches industry, sub-industry, industries, and tags |
| `location` | array | Matches locations and regions |
| `stage` | array | `Early` or `Growth` |
| `minTeamSize` | integer | Only companies with at least this many people |
| `remoteOnly` | boolean | Only companies whose YC regions include remote |
| `topCompaniesOnly` | boolean | Only YC's top companies |

Filters combine with AND. Values inside one filter combine with OR. Text matching is case-insensitive and partial, so `"industry": ["fin"]` catches Fintech.

**Example — small remote-friendly fintech startups from the newest batches:**

```json
{
  "batch": ["S25", "F25", "W26"],
  "industry": ["Fintech"],
  "remoteOnly": true,
  "maxCompanies": 50
}
```

**Example — everything, no filters:**

```json
{}
```

### Pricing

**$0.15 per run** on the free plan, dropping to $0.08 on higher Apify plans.

You are charged once per run, regardless of what comes back. Pulling all ~1,500 hiring companies costs exactly the same as pulling three, so there is no reason to hold back on the broad queries. A daily schedule works out to roughly $4.50 a month.

There is no per-result fee and no compute surprise: the Actor caps at 1 GB of memory, which is one billable event per run.

### Integrations

Because the output is a plain list, it drops straight into the rest of the Apify ecosystem: push results to Google Sheets, Slack, Airtable, Zapier, Make, or your own webhook, or query the dataset from the API. Schedule it daily and you have a live feed of hiring YC startups.

### Where the data comes from

[`yc-oss/api`](https://github.com/yc-oss/api), a community-maintained mirror of Y Combinator's public company directory, rebuilt daily. This Actor reads its `companies/hiring.json` slice — exactly the set of companies flagged `isHiring: true`, the same flag that puts a company on the YC jobs board.

### FAQ

**How fresh is the data?**
The upstream mirror rebuilds daily, so the list reflects YC's directory as of the last sync rather than the last minute. For a hiring list that turns over across days and weeks, that is the right resolution.

**Does "hiring" mean a specific role is open?**
It means the company has open roles listed with YC. Individual postings can be filled between syncs, which is why every row carries `jobsUrl` pointing at that company's live listings.

**Can I get the individual job postings, titles, and salaries?**
Not from this Actor — it returns companies, by design. For per-role detail including titles, salary ranges, equity, and founders, use [YC Jobs Scraper](https://apify.com/artemlazarevm/yc-jobs-scraper).

**Does it need a YC login or proxy?**
No. It reads a public data source, so there is nothing to authenticate and nothing to get blocked.

**Is this legal?**
It reads public company directory data, no personal data and nothing behind a login. As always, what you do with the data afterwards is on you — check the [Apify guide on ethical scraping](https://blog.apify.com/is-web-scraping-legal/) if you plan to use it commercially.

### Feedback

Found a bug or want another filter? Open an issue on the Actor's [GitHub repo](https://github.com/artem-lazarev/which-yc-companies-are-hiring) or use the Issues tab on the Actor page.

# Actor input Schema

## `maxCompanies` (type: `integer`):

Cap on how many companies to return. Leave empty for all of them.

## `search` (type: `string`):

Free-text match against company name, tagline and description (e.g. 'agents', 'biotech').

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

YC batches to keep. Accepts either shorthand or the full name: 'W25', 'S25', 'Summer 2025'.

## `industry` (type: `array`):

Industry, sub-industry or tag keywords, e.g. 'B2B', 'Fintech', 'Healthcare', 'Robotics'.

## `location` (type: `array`):

Location or region keywords, e.g. 'San Francisco', 'New York', 'United Kingdom', 'India'.

## `stage` (type: `array`):

Company stage. YC uses 'Early' and 'Growth'.

## `minTeamSize` (type: `integer`):

Only return companies with at least this many people.

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

Only return companies whose YC regions include remote work.

## `topCompaniesOnly` (type: `boolean`):

Only return companies YC flags as top companies.

## Actor input object example

```json
{
  "batch": [],
  "industry": [],
  "location": [],
  "stage": [],
  "remoteOnly": false,
  "topCompaniesOnly": false
}
```

# Actor output Schema

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

Full list of matching companies

## `overview` (type: `string`):

Table view of the companies that are hiring

## `summary` (type: `string`):

How many companies are hiring and how many matched the filters

# 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 = {
    "batch": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("artemlazarevm/which-yc-companies-are-hiring").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 = { "batch": [] }

# Run the Actor and wait for it to finish
run = client.actor("artemlazarevm/which-yc-companies-are-hiring").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 '{
  "batch": []
}' |
apify call artemlazarevm/which-yc-companies-are-hiring --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,artemlazarevm/which-yc-companies-are-hiring"
        }
    }
}
```

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/vjKXtRhJPkYg0Xdd2/builds/GScO7815AP0OCUfnq/openapi.json