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

Scrape startup jobs from Wellfound (formerly AngelList Talent) with the full job description, parsed salary and equity ranges, funding-stage and investor badges, and the ATS each startup runs. Filter by role, location or remote. No login, no API key.

- **URL**: https://apify.com/webdata\_labs/wellfound-jobs-scraper.md
- **Developed by:** [WebData Labs](https://apify.com/webdata_labs) (community)
- **Categories:** Jobs, Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.60 / 1,000 job scrapeds

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

## Wellfound Jobs Scraper

Scrapes startup jobs from [Wellfound](https://wellfound.com), formerly AngelList Talent -
the board where seed-to-Series-C startups post and where the company behind the job is half
the reason to care about it.

Every other Wellfound scraper on the Store hands you the same listing: title, company,
location, pay. This one also gives you three columns none of them return:

- **`atsVendor`** - which applicant tracking system the startup runs: Greenhouse, Ashby,
  Lever, Workable, Dover. Present on about two thirds of jobs. If you sell to recruiting
  teams, that is your segmentation column, and it is not available anywhere else on the
  Store.
- **Company signals as real columns** - funding stage, YC-backed, top investors, recently
  funded, valuation, B2B or B2C, actively hiring, how fast the company replies, and the
  numeric ratings Wellfound shows for the company overall, work/life balance and leadership.
- **The full job description, on every row, at no extra cost.** It arrives as markdown in
  the same request as the listing, so there is no second fetch and no surcharge for it.
  Measured 100% of rows across every test run.

No login, no API key, no proxy configuration to think about. Deep crawls rotate their exit
address automatically, because Wellfound rate limits per IP once a single run goes past a
few dozen pages.

### What you get per job

```json
{
  "jobId": "3272257",
  "jobSlug": "software-engineer",
  "title": "Software Engineer",
  "url": "https://wellfound.com/jobs/3272257-software-engineer",
  "primaryRoleTitle": "Software Engineer",
  "jobType": "full-time",
  "isRemote": false,
  "remoteKind": "ONSITE",
  "wfhFlexible": false,
  "locationNames": ["San Francisco"],
  "acceptedRemoteLocationNames": [],
  "yearsExperienceMin": 1,
  "yearsExperienceMax": null,
  "postedAt": "2026-08-21T16:30:58Z",
  "autoPosted": false,
  "compensationText": "$130k - $210k * 0.05% - 0.2%",
  "salaryMin": 130000.0,
  "salaryMax": 210000.0,
  "salaryCurrency": "USD",
  "equityMin": 0.05,
  "equityMax": 0.2,
  "atsSource": "AtsIntegration::Ashby::Listing",
  "atsVendor": "Ashby",
  "description": "## About the role\n\n**tl;dr**: Fresh off a $15M Series A led by Accel ...",
  "companyId": "8975809",
  "companyName": "Agave API",
  "companySlug": "agave-api",
  "companyUrl": "https://wellfound.com/company/agave-api",
  "companyLogoUrl": "https://photos.wellfound.com/startups/i/8975809-...-medium_jpg.jpg",
  "companySize": "SIZE_11_50",
  "companyHighConcept": "Field and finance, finally in sync",
  "companyBadges": ["Actively Hiring", "Top 5% of responders", "Responds within a few days",
                    "Early Stage", "Top Investors", "YC Funded", "Growing fast"],
  "activelyHiring": true,
  "responseSpeed": "Top 5% of responders",
  "companyStage": "early_stage",
  "companyStageLabel": "Early Stage",
  "recentlyFunded": false,
  "topInvestors": true,
  "ycBacked": true,
  "valuationOver1B": false,
  "isB2B": false,
  "isB2C": false,
  "growingFast": true,
  "ratingOverall": null,
  "ratingWorkLifeBalance": null,
  "ratingLeadership": null,
  "searchRole": "software-engineer",
  "searchLocation": null,
  "sourceUrl": "https://wellfound.com/role/software-engineer",
  "sourcePage": 1,
  "scrapedAt": "2026-09-06T18:19:42Z"
}
```

`description`, `title`, `url`, `postedAt` and the company block come back on every job.
`compensationText` and the salary and equity numbers parsed from it were present on 290 of
300 jobs in a full New York run; `atsVendor` on 232 of 300; the funding-stage and rating
columns only when Wellfound shows that badge on the company.

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `roles` | array | `[]` | Wellfound role slugs, one search per role: `software-engineer`, `data-scientist`, `product-manager`. All 515 slugs are listed on [wellfound.com/browse/tech-jobs](https://wellfound.com/browse/tech-jobs). |
| `locations` | array | `[]` | Wellfound location slugs: `san-francisco`, `new-york`, `london`, `berlin`, `united-states`. Combined with `roles`, searches each role in each location. |
| `remoteOnly` | boolean | `false` | Search Wellfound's remote pages. Applies when `roles` is set without `locations`, because Wellfound has no remote variant of the role-and-location page. |
| `startUrls` | array | `[]` | Landing pages you already have. Accepts `/role/l/<role>/<location>`, `/role/r/<role>`, `/role/<role>` and `/location/<location>`. |
| `maxResults` | integer | `200` | Stop after this many jobs. One job is one charged result. |
| `maxPagesPerQuery` | integer | `0` | Optional page cap per search. `0` means page until Wellfound runs out. |
| `onlyNewJobs` | boolean | `false` | Return only jobs no previous run of this Actor delivered. Nothing new means nothing charged. |

Leave `roles`, `locations` and `startUrls` all empty and the Actor scrapes
`/location/united-states`, the whole US board.

### Ready-made searches

Each of these runs with one click, no input to fill in:

- [Software engineer jobs in San Francisco](https://apify.com/webdata_labs/wellfound-jobs-scraper/examples/wellfound-software-engineer-jobs-in-san-francisco)
- [Remote software engineer jobs](https://apify.com/webdata_labs/wellfound-jobs-scraper/examples/wellfound-remote-software-engineer-jobs)
- [All startup jobs in New York](https://apify.com/webdata_labs/wellfound-jobs-scraper/examples/wellfound-startup-jobs-in-new-york)
- [Data scientist jobs across the US](https://apify.com/webdata_labs/wellfound-jobs-scraper/examples/wellfound-data-scientist-jobs-usa)
- [Product manager jobs in London](https://apify.com/webdata_labs/wellfound-jobs-scraper/examples/wellfound-product-manager-jobs-in-london)
- [Remote product designer jobs](https://apify.com/webdata_labs/wellfound-jobs-scraper/examples/wellfound-remote-product-designer-jobs)
- [Startup jobs with the ATS and badge columns](https://apify.com/webdata_labs/wellfound-jobs-scraper/examples/wellfound-startup-jobs-with-ats-and-badges)
- [New startup jobs, daily monitor](https://apify.com/webdata_labs/wellfound-jobs-scraper/examples/wellfound-new-startup-jobs-daily-monitor)

### What Wellfound does and does not cover

**Coverage is the public landing pages, and they are the whole product.** Wellfound's
logged-in search is not reachable without an account, but the public role and location pages
carry the same jobs with the same fields, including the full description. Nothing is missing
from a row because you are not logged in.

**One search is bounded by Wellfound's own page count**, and that number varies a lot by
query: 771 jobs for software-engineer in San Francisco, about 5,000 for software-engineer
across the US, about 11,900 across all remote jobs, 37 for software-engineer in Berlin. A
full walk of the US software-engineer pages returned **2,670 unique jobs across 92 pages**
with no duplicates.

The Actor walks to the last real page and stops there. It never pages past the end and never
re-bills you for a page you already have: asking Wellfound for a page beyond the last one
returns page 1 again with HTTP 200 and no error, so the Actor stops on the first page that
brings no new job ids as well as on the page count Wellfound reports.

To go wider than one search, split it: add more roles, or more locations, rather than
expecting one query to return everything.

**Slugs have to be real.** On the role-and-location pages Wellfound does not reject an
unknown slug: it drops that filter and answers a broader query at HTTP 200. This Actor
checks the arguments Wellfound actually applied against the ones you asked for, refuses the
mismatched rows, and tells you which slug was ignored. That is why a typo returns an error
instead of 3,000 jobs from the wrong search.

**Locations are not US-only.** `london`, `berlin`, `toronto`, `bangalore` and others work,
though volumes outside the US hubs are much smaller.

**`onlyNewJobs` stops at the first page where everything was already delivered.** It is
built for a schedule: run it daily and you get what appeared since yesterday, not a backfill
of older listings you would be charged for.

### Pricing

Pay per result. You are charged for each job row pushed to the dataset, nothing else - no
start fee, no per-request charge, and no surcharge for the full description because it costs
the Actor nothing extra to include.

A run that returns nothing costs nothing. That matters most with `onlyNewJobs` on a
schedule: on a quiet day the run is free.

### 🧩 Related Actors

- [XING Jobs Scraper](https://apify.com/webdata_labs/xing-jobs-scraper) - German-speaking roles with salary ranges and the employer's own apply URL.
- [ATS Jobs Scraper](https://apify.com/webdata_labs/greenhouse-lever-ashby-jobs-scraper) - pull the same roles straight from Greenhouse, Lever, Ashby and Workday boards, with no job-board middleman.
- [Company Career Page Jobs API](https://apify.com/webdata_labs/company-career-page-jobs-api) - read jobs off a company's own careers page when it is not on any board.
- [Indeed Jobs Scraper](https://apify.com/webdata_labs/indeed-jobs-scraper) - the largest general job board, for volume rather than niche.
- [Buyer Fit Brief API](https://apify.com/webdata_labs/buyer-fit-brief-api) - score a finished lead list against your ideal customer profile.

### FAQ

**Do I need a Wellfound account or cookie?**
No. Nothing in this Actor is logged in.

**Is the description the complete posting or a preview?**
Complete, as markdown, exactly as Wellfound stores it. It arrives inline with the listing,
which is why there is no option to turn it off - turning it off would not save a request.

**Why is `atsVendor` empty on some jobs?**
Because Wellfound only exposes it for jobs synced from an ATS. Jobs posted directly in
Wellfound have no ATS behind them. Roughly two thirds of rows carry it.

**Can I filter by funding stage, YC or ATS?**
Not at the source - Wellfound offers no such filter on these pages. Scrape the roles or
locations you care about and filter the dataset on `companyStage`, `ycBacked` or
`atsVendor`, which are plain columns in the output.

**What is `compensationText` versus `salaryMin` and `salaryMax`?**
`compensationText` is Wellfound's own display string, kept verbatim so nothing is lost.
The numeric fields are parsed from it: salary range, currency, and the equity range when
the posting quotes one.

**Why did my run fail with "Wellfound ignored every slug"?**
A role or location slug does not exist. Check it against
[wellfound.com/browse/tech-jobs](https://wellfound.com/browse/tech-jobs). The Actor fails
loudly rather than handing you rows from a query you did not ask for.

# Actor input Schema

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

Wellfound role slugs, one search per role, for example software-engineer or data-scientist. The full list of 515 role slugs is linked from https://wellfound.com/browse/tech-jobs. Combined with Locations, this searches each role in each location.

## `locations` (type: `array`):

Wellfound location slugs, for example san-francisco, new-york, london or united-states. Leave both Roles and Locations empty to scrape the whole United States board.

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

Search Wellfound's remote pages instead of the all-jobs pages. Applies when Roles are set without Locations, because Wellfound has no remote variant of the role-and-location page.

## `startUrls` (type: `array`):

Wellfound landing pages to scrape directly, if you already have the page you want. Accepts /role/l/<role>/<location>, /role/r/<role>, /role/<role> and /location/<location>. Any other Wellfound URL is rejected, because no other page carries job data.

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

Stop after this many jobs across all searches. Each job is one charged result.

## `maxPagesPerQuery` (type: `integer`):

Optional cap on pages per role or location. Leave at 0 to page until Wellfound runs out of results for that search, which it reports per query and which varies from 2 to 90-plus pages.

## `onlyNewJobs` (type: `boolean`):

Remember every job delivered by previous runs of this Actor and return only jobs that are new since then. Nothing is charged when there is nothing new, which makes a scheduled run cheap.

## Actor input object example

```json
{
  "roles": [
    "software-engineer"
  ],
  "locations": [
    "san-francisco"
  ],
  "remoteOnly": false,
  "startUrls": [],
  "maxResults": 200,
  "maxPagesPerQuery": 0,
  "onlyNewJobs": false
}
```

# Actor output Schema

## `jobs` (type: `string`):

One row per Wellfound job, with the full description, parsed pay and equity, the ATS vendor and the company badge columns.

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

The same rows, trimmed to the fields most buyers scan first.

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

The startup side of each row: size, funding stage, investor and rating badges, and the ATS the company runs.

## `OUTPUT` (type: `string`):

Jobs per search, how many Wellfound reported, where each search stopped, and any slug Wellfound ignored.

# 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 = {
    "roles": [
        "software-engineer"
    ],
    "locations": [
        "san-francisco"
    ],
    "maxResults": 200
};

// Run the Actor and wait for it to finish
const run = await client.actor("webdata_labs/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 = {
    "roles": ["software-engineer"],
    "locations": ["san-francisco"],
    "maxResults": 200,
}

# Run the Actor and wait for it to finish
run = client.actor("webdata_labs/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 '{
  "roles": [
    "software-engineer"
  ],
  "locations": [
    "san-francisco"
  ],
  "maxResults": 200
}' |
apify call webdata_labs/wellfound-jobs-scraper --silent --output-dataset

```

## MCP server setup

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