# Wellfound Jobs Scraper - Startup Jobs, Salary & Equity (`akhil_rajesh/wellfound-jobs-scraper`) Actor

Scrape startup jobs from Wellfound (formerly AngelList Talent): salary and equity ranges parsed into numbers, full descriptions, company size, tagline and badges, and an exact Y Combinator flag. Search by role and city, filter to YC or remote jobs, and export to JSON, CSV or Excel.

- **URL**: https://apify.com/akhil\_rajesh/wellfound-jobs-scraper.md
- **Developed by:** [Akhil rajesh](https://apify.com/akhil_rajesh) (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 $1.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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

Scrape **startup jobs from Wellfound** (formerly AngelList Talent) — job title, company, location, the **full job description**, **salary ranges**, and the one thing conventional job boards don't give you as data: **equity**.

```
Senior Software Engineer — Confident LIMS
$100k – $180k • 0.05% – 0.25%        ← salary AND equity, parsed into numbers
```

**Try it now:** keep the example input (software engineer) and press **Start**. It returns 100 jobs in about 10 seconds.

### What does Wellfound Jobs Scraper do?

It searches Wellfound by **job role**, **city** or both, and returns one row per job: salary and equity parsed into numbers, the full description, and the startup behind it, with its size, tagline, badges and an exact **Y Combinator** flag. It reads the data Wellfound already ships inside its own pages, so there is no login, no API key and no browser to wait for.

Because it runs on Apify, you can start it from the Console or the API, schedule it, export the results as JSON, CSV or Excel, and send them on to your own tools through Apify's integrations.

### What data can you extract from Wellfound?

One row per job listing:

| Group | Fields |
|---|---|
| **Job** | `title`, `jobType`, `primaryRole`, `yearsExperienceMin`, `description` |
| **Pay** | `salaryText`, `salaryMin`, `salaryMax`, `salaryCurrency`, `equityMin`, `equityMax` |
| **Location** | `locations`, `isRemote`, `remoteLocations` |
| **Startup** | `company`, `companySize`, `companyTagline`, `companyBadges`, `isYCombinator`, `companyLogo`, `companyUrl`, `companySlug`, `companyId` |
| **Timing** | `postedAt`, `scrapedAt` |
| **Provenance** | `jobId`, `url`, `atsSource`, `autoPosted`, `searchQuery`, `searchLocation` |

What sets Wellfound data apart from a general job board:

- **Equity ranges**, parsed into `equityMin` / `equityMax` as percentages
- **Pay in the listing's own currency** — US, Canadian, Australian and Singapore dollars, pounds, euros or rupees — named in `salaryCurrency`
- **Y Combinator flag** — taken from Wellfound's own company badge, so it is exact rather than a name match
- **Startup signals** — company size, tagline and Wellfound's badges, such as `ACTIVELY_HIRING`, `TOP_INVESTORS`, `RECENTLY_FUNDED`, `GROWING_FAST` and `QUICK_RESPONDER`
- **Minimum years of experience**, as a number you can filter on
- **Full job descriptions**, not truncated snippets

### How to scrape Wellfound jobs

1. Enter a **job role**, such as `software engineer`, `product manager` or `data scientist`. Wellfound's roles are broad; a seniority word in front, as in `senior software engineer`, is handled for you: the run searches `software engineer` and keeps the senior titles.
2. Add a **city** if you want one: `San Francisco`, `New York`, `Toronto, ON` or `London`. Type `remote` for remote jobs anywhere. A role, a city, or both will do.
3. Set **Max results**, and switch on **Remote only** or **Y Combinator companies only** if you need them.
4. Press **Start**, then open the **Output** tab or export the dataset.

```json
{
  "searchQuery": "software engineer",
  "location": "san francisco",
  "maxResults": 200
}
```

#### Only Y Combinator companies

```json
{
  "searchQuery": "product manager",
  "yCombinatorOnly": true,
  "maxResults": 100
}
```

Wellfound tags YC companies itself, so this filter is exact — it will not sweep in a company that merely has "Y" in its name.

#### Run it from the API

```bash
curl -X POST "https://api.apify.com/v2/actors/akhil_rajesh~wellfound-jobs-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQuery": "data scientist",
    "location": "new york",
    "maxResults": 100
  }'
```

#### Run it from Python

```python
from apify_client import ApifyClient  # pip install apify-client

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("akhil_rajesh/wellfound-jobs-scraper").call(run_input={
    "searchQuery": "software engineer",
    "location": "toronto",
    "maxResults": 200,
})
for job in client.dataset(run.default_dataset_id).iterate_items():
    print(job["title"], job["company"], job["salaryText"], job["equityMin"], job["equityMax"])
```

Every row has the same fields; a value Wellfound doesn't publish is `null`.

### How much does it cost to scrape Wellfound?

Pay-per-event, with platform usage included — there is nothing else to pay. What a job costs depends on your Apify plan:

| Your plan | Per 1,000 jobs |
|---|---|
| Free | $2.00 |
| Starter | $1.80 |
| Scale | $1.40 |
| Business and above | $1.00 |

Plus **$0.001** each time a run starts, on every plan (charged per GB of memory; the default is 512 MB, so that's one start fee per run).

| Run | Jobs returned | On Free | On Business |
|---|---|---|---|
| The example input | 100 | $0.201 | $0.101 |
| Every software engineer job in Toronto (September 2026) | 89 | $0.179 | $0.090 |
| 1,000 jobs of one role | 1,000 | $2.00 | $1.00 |

Apify's Free plan includes $5 of credit every month, enough for about 2,400 jobs. You're charged only for jobs that are delivered, so a search that finds nothing costs only the start fee. To cap spending, lower **Max results** or set a maximum cost per run in the run options; the Actor stops cleanly at the limit and says so.

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `searchQuery` | string | — | The role to search. Give this, a location, or both |
| `location` | string | — | A city — `Toronto`, `Toronto, ON` and `Montréal` all work. `remote` means remote roles anywhere |
| `maxResults` | integer | 100 | Stop after this many jobs. This is also your cost ceiling |
| `remoteOnly` | boolean | false | Keep only jobs Wellfound marks remote |
| `yCombinatorOnly` | boolean | false | Keep only Y Combinator companies |
| `maxPages` | integer | derived | Optional cap on pages walked; worked out from Max results unless you set it, and unlimited with the remote or Y Combinator filter on |
| `proxy` | object | Apify Proxy | Optional — Wellfound serves ordinary requests, so no residential group is needed |

### Sample output

A real row, with the description shortened:

```json
{
  "jobId": "4697947",
  "url": "https://wellfound.com/jobs/4697947-senior-software-engineer",
  "title": "Senior Software Engineer",
  "description": "Confident powers analytical testing labs — the labs that test samples…",
  "jobType": "full-time",
  "isRemote": true,
  "remoteLocations": ["Canada", "South America", "United States", "Latin America"],
  "locations": ["San Francisco Bay Area"],
  "primaryRole": "Software Engineer",
  "yearsExperienceMin": 5,
  "postedAt": "2026-09-10T17:59:14Z",
  "atsSource": null,
  "autoPosted": false,
  "salaryText": "$100k – $180k • 0.05% – 0.25%",
  "salaryMin": 100000,
  "salaryMax": 180000,
  "salaryCurrency": "USD",
  "equityMin": 0.05,
  "equityMax": 0.25,
  "company": "Confident LIMS",
  "companyId": "829771",
  "companySlug": "confidentlims",
  "companyUrl": "https://wellfound.com/company/confidentlims",
  "companySize": "SIZE_11_50",
  "companyTagline": "The easiest way to test",
  "companyLogo": "https://photos.wellfound.com/startups/i/829771-0deed706d7c625c16e51b403c4b1ad20-medium_jpg.jpg?buster=1742329133",
  "companyBadges": ["ACTIVELY_HIRING", "TOP_RESPONDER", "QUICK_RESPONDER", "B2B", "COMPANY_STAGE", "TOP_INVESTORS", "YC"],
  "isYCombinator": true,
  "searchQuery": "software engineer",
  "searchLocation": null,
  "scrapedAt": "2026-09-22T22:22:21Z"
}
```

Download the dataset as JSON, CSV, Excel, XML or HTML, or read it through the API. Three dataset views are included: **Jobs** (the overview), **Pay & equity** (numeric ranges), and **Startups** (who is hiring).

### Use cases

- **Compensation research** — salary *and* equity ranges side by side, across thousands of startup jobs
- **Startup lead generation** — companies actively hiring, with size, tagline, funding and responsiveness badges
- **Job monitoring** — schedule a daily run that sweeps a whole role, and keep the jobs whose `postedAt` is newer than your last run
- **YC ecosystem tracking** — every Y Combinator company currently hiring, in one dataset

### Good to know

- **Pay coverage**, measured over a 1,200-job run: **68%** carry a salary range, **15%** carry equity, **100%** carry a full description. The first page or two runs closer to 85% — Wellfound surfaces its better-filled listings first — so a small run looks more complete than a deep one.
- **Pay is not always in US dollars.** Canadian, Australian and Singapore listings use a bare `$` with the currency code after the range (`$200k – $200k CAD`); UK, European and Indian listings use `£`, `€` and `₹`, with Indian pay in Lakhs and Crores converted to rupees. `salaryCurrency` names the currency actually written — on a Toronto search, three-quarters of priced jobs were in CAD. Filter or convert on it before comparing figures.
- **Some roles offer equity and no salary** (`5.0% – 10.0%`, often founding roles). Those rows carry `equityMin`/`equityMax` with no salary figures.
- **Wellfound shuffles its results on every request**, even for the same search a second later. A run that stops before the end of a role is therefore a *sample*: two 1,200-job runs of the same role, started together, shared about 89% of their jobs. A run that sweeps the **whole** role is far steadier — two full sweeps of a ~500-job role differed by under 3%. For monitoring, set Max results above the role's size and filter on `postedAt`, rather than comparing today's list with yesterday's: a job that simply moved position would otherwise look new.
- **Experience is a floor, not a range.** Wellfound publishes `yearsExperienceMin` only; there is no maximum on search results, so the field is not shipped.
- **Compensation is a display string first.** `salaryText` is always Wellfound's own wording; the numeric fields are parsed from it. When parsing cannot be trusted, the text is still there.
- **Each page holds about 30–45 jobs**, so a run that wants 1,000 jobs walks about 30 pages, pausing a second between each to stay a polite client.
- **The filters read further.** Only about 1 job in 6 carries the Y Combinator badge, so with **Y Combinator companies only** (or **Remote only**) on, the run keeps reading pages until it has Max results matching jobs or the role runs out. Those runs take longer, but you're still charged only for the jobs returned.
- The run stops early, rather than spinning, once two consecutive pages return nothing new.

### FAQ

#### Does it need a Wellfound login or API key?

No. Wellfound serves these pages to ordinary visitors, so there is no account, cookie or key to manage.

#### Why did my search stop with a message instead of returning jobs?

Wellfound only recognises its own **broad role names** and **city names**. When it doesn't recognise one it quietly shows other jobs instead — remote jobs of any role, or the role's jobs from everywhere — so the Actor stops rather than hand you the wrong results, and the message says what to change:

- **Roles** are broad: `software engineer`, `product manager`, `data scientist`, `designer`. A seniority word in front (`senior`, `junior`, `staff`, `principal`, `lead`, `entry level`, or `intern` after the role) is handled for you: Wellfound has no `senior software engineer` role, so the run searches `software engineer` and keeps the senior titles, and its status message says so.
- **Locations** are cities. `Toronto, ON`, `New York, NY` and accented names such as `Montréal` are handled for you; `remote` switches on remote-only.

A search Wellfound *does* recognise but has no jobs for — a small city, say — finishes successfully with zero results and a note saying so.

#### How fresh are the listings?

`postedAt` carries the timestamp Wellfound put the job live. Sort or filter on it to keep only recent roles.

#### Is it legal to scrape Wellfound?

This Actor reads only job listings that Wellfound shows to every visitor, without signing in. Rows describe jobs and companies rather than people, though a job description can occasionally name a hiring contact. Whether your use is allowed depends on what you do with the data and where you are: check Wellfound's terms and the laws that apply to you, such as GDPR, and ask a lawyer if you are unsure.

#### Can you add company detail pages, or job-level applicant counts?

Ask through the Issues tab. The search payload is rich, but some fields only exist on the individual job page and would cost an extra request each.

### Other Actors by this developer

- [Indeed Jobs Scraper](https://apify.com/akhil_rajesh/indeed-jobs-scraper): job listings from Indeed in Canada, the US and six more countries, with full descriptions, pay and the employer's apply link
- [Canadian Job Market Scraper - Job Bank](https://apify.com/akhil_rajesh/canadian-jobs-scraper): Canadian job postings from the Government of Canada's job board, with salary, employer, location and NOC code
- [SEEK, JobStreet & JobsDB Jobs Scraper](https://apify.com/akhil_rajesh/seek-jobstreet-jobsdb-scraper): jobs from SEEK, JobStreet and JobsDB in Australia, New Zealand and six Asian markets, with pay as numbers, applicant counts and change tracking

### Data source

All data comes from **Wellfound** (wellfound.com, formerly AngelList Talent), a public job board, read from the same page payload the site renders for visitors. No login, no account, no browser automation.

# Changelog

This Actor's version history is a separate document: https://apify.com/akhil\_rajesh/wellfound-jobs-scraper/changelog.md

# Actor input Schema

## `searchQuery` (type: `string`):

The role to search, using Wellfound's broad role names: 'software engineer', 'product manager', 'data scientist', 'designer'. A seniority word in front ('senior software engineer', 'junior data scientist') is handled for you: Wellfound has no such role, so the run searches the base role and keeps the titles at that level. Give a role, a location, or both.

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

A city, e.g. 'Toronto', 'New York', 'San Francisco', 'London'. 'Toronto, ON' and 'New York, NY' work too, and accents are fine. Type 'remote' for remote roles anywhere. If Wellfound doesn't recognise the place, the run stops and says so rather than returning jobs from elsewhere.

## `maxResults` (type: `integer`):

Stop once this many jobs have been collected. Each result is charged, so this is also your cost ceiling. A big role such as software engineer holds well over 1,000 jobs across all locations, while a single city holds far fewer; asking for more than a search holds simply ends when it runs out.

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

Keep only jobs Wellfound marks as remote.

## `yCombinatorOnly` (type: `boolean`):

Keep only jobs at Y Combinator companies. Wellfound tags these itself, so this is exact rather than a name match.

## `maxPages` (type: `integer`):

Optional safety stop on how many search pages to request. Leave empty and it is worked out from Max results (a page holds about 30-45 jobs); with Remote only or Y Combinator companies only switched on, the run instead reads on until it has Max results or the role runs out, since only some jobs on each page pass. Set it only to cap a run explicitly.

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

Wellfound serves ordinary requests, so the proxy is optional. Leave it on for long runs; a residential group is not required.

## Actor input object example

```json
{
  "searchQuery": "software engineer",
  "location": "san francisco",
  "maxResults": 100,
  "remoteOnly": false,
  "yCombinatorOnly": false,
  "proxy": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Job records produced by this run.

# 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 = {
    "searchQuery": "software engineer"
};

// Run the Actor and wait for it to finish
const run = await client.actor("akhil_rajesh/wellfound-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 = { "searchQuery": "software engineer" }

# Run the Actor and wait for it to finish
run = client.actor("akhil_rajesh/wellfound-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 '{
  "searchQuery": "software engineer"
}' |
apify call akhil_rajesh/wellfound-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,akhil_rajesh/wellfound-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/6siksLQAjPv0w6XdV/builds/0WBT6LODyHH0Rj7of/openapi.json