# Wellfound Jobs Scraper $0.60/1K: All Jobs, Salary & Funding (`alexmorain/wellfound-jobs-scraper`) Actor

Every startup job on Wellfound for a city or a role, not just the 3 per startup the listing pages show: salary and equity parsed into numbers, company website, funding and founders without a browser. Duplicates are removed before you pay. New-jobs-only mode and webhook for daily feeds.

- **URL**: https://apify.com/alexmorain/wellfound-jobs-scraper.md
- **Developed by:** [Alexis Morain](https://apify.com/alexmorain) (community)
- **Categories:** Jobs, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 jobs

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

### What does Wellfound Jobs Scraper do?

Wellfound Jobs Scraper collects startup job listings from [Wellfound](https://wellfound.com) (formerly AngelList Talent) for a city, a country, remote work or a role, and returns them as clean rows: title, salary and equity as numbers, job type, remote policy, locations, posting date, full description and the startup behind it. It works as a Wellfound jobs API without an account, a login or a browser.

Its difference is coverage. A Wellfound listing page shows at most 3 jobs per startup, whatever the startup actually posts, so any scraper that pages through `/location/...` or `/role/...` silently loses the rest. This Actor also reads the narrower role × place pages, which are exact subsets of your search, and gets most of the hidden jobs back.

| Search (measured 31 October 2026) | Jobs Wellfound announces | Read from the listing page alone | Returned by this Actor |
|---|---|---|---|
| San Francisco, all roles | 3,015 | 1,300 (43%) | 2,558 (85%) |
| Software Engineer, all places | 4,942 | 2,507 (51%) | 3,511 (71%) |

The run summary gives the same three numbers for each of your searches, so you can check the coverage yourself.

### Why scrape Wellfound?

Wellfound is where early-stage and venture-backed startups hire, with salary and equity ranges on most posts. Typical uses:

- Recruiting and sourcing agencies: a complete list of startups hiring for a role in a city, with founders to contact.
- Sales teams selling to startups: hiring is a buying signal, and the company details give website, funding stage and last round.
- Job boards and newsletters: a daily feed of new startup jobs with the New jobs only mode and a webhook.
- Compensation research: salary and equity bands parsed into numbers for a role, a city or a stage.

On Apify you can schedule the Actor, call it by API, export to CSV or Excel, and connect it to Make, Zapier, n8n, Google Sheets or a webhook.

### What data can you extract from Wellfound?

| Field | Example |
|---|---|
| `title`, `primaryRole`, `jobType` | Staff Database Reliability Engineer, DevOps, full-time |
| `salaryMin`, `salaryMax`, `salaryCurrency` | 195000, 229000, USD |
| `equityMinPct`, `equityMaxPct` | 0.5, 1.0 |
| `remote`, `locations`, `remoteLocations` | false, \["Denver", "San Francisco"] |
| `postedAt`, `yearsExperienceMin` | 2026-10-27T08:05:52Z, 5 |
| `description` | full job description in Markdown |
| `atsSource` | Greenhouse, Lever, Ashby... when the job comes from an ATS |
| `startupName`, `startupUrl`, `startupSize`, `startupBadges` | Checkr, 501-1000, \["YC Funded", "Top Investors"] |
| `companyWebsite`, `companyHq`, `companyIndustries` | with Company details |
| `fundingTotal`, `fundingRounds`, `lastRoundType`, `lastRoundAmountUsd`, `lastRoundDate` | $399M, 4, Series E, 250000000, Sep 2021 |
| `founders`, `employeesJoinedFrom` | \[{"name": "Daniel Yanisse", "title": "CEO"}], \["Apple", "Google"] |

Company details come from a public job page, read once per startup and copied to all its jobs. Wellfound's company pages sit behind a Cloudflare check that usually takes a real browser to pass; this Actor does not need one.

### How to scrape Wellfound jobs

1. Open the Input tab.
2. Type one or more places in Locations (`San Francisco`, `New York`, `London`, `India`, `Remote`) and/or roles in Roles (`Software Engineer`, `Product Manager`, `Account Executive`). You can also paste Wellfound list URLs.
3. Keep Complete coverage on to get the jobs the listing pages hide.
4. Turn on Company details if you need funding, founders and website.
5. Set Max jobs, click Start, and download the dataset as JSON, CSV, Excel or HTML.

Roles and places combine: `Software Engineer` with `San Francisco` and `New York` runs two searches. A role alone searches every place; a place alone searches every role.

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

You pay per job returned, plus a small start fee per run. Duplicates and jobs removed by your filters are never charged.

| Event | Free plan | Bronze | Silver | Gold and above |
|---|---|---|---|---|
| Job | $1.50 / 1,000 | $1.20 / 1,000 | $0.95 / 1,000 | $0.60 / 1,000 |
| Job with company details (instead of Job) | $3.00 / 1,000 | $2.40 / 1,000 | $1.90 / 1,000 | $1.20 / 1,000 |
| Run start | $0.002 per GB of memory (512 MB by default) | | | |

All 2,558 San Francisco jobs cost about $3.84 on the Free plan, platform usage included. Set a maximum cost per run in the run options and the Actor stops there.

### Input

See the Input tab for every option. The ones worth knowing:

- Complete coverage (on by default) reads the role × place pages. Turn it off only if you want the listing pages exactly as Wellfound shows them.
- New jobs only remembers what earlier runs returned and gives you only new jobs. Give it a Monitor name to keep the memory when you edit the searches.
- Job types, Remote only and Posted within (days) are applied by the Actor before you are charged, since Wellfound offers no such filters to visitors.
- Job URLs reads single jobs (full URL with the title part) and always includes company details.

### Output

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel. One row per job:

```json
{
  "jobId": "4897467",
  "jobUrl": "https://wellfound.com/jobs/4897467-staff-database-reliability-engineer",
  "title": "Staff Database Reliability Engineer",
  "primaryRole": "DevOps",
  "jobType": "full-time",
  "remote": false,
  "locations": ["Denver", "San Francisco"],
  "compensation": "$195k – $229k",
  "salaryMin": 195000,
  "salaryMax": 229000,
  "salaryCurrency": "USD",
  "postedAt": "2026-10-27T08:05:52Z",
  "atsSource": "Greenhouse",
  "startupName": "Checkr",
  "startupUrl": "https://wellfound.com/company/checkr",
  "startupSize": "501-1000",
  "startupBadges": ["Actively Hiring", "YC Funded", "Valuation $1B+"],
  "companyWebsite": "http://www.checkr.com/",
  "companyHq": "Denver",
  "fundingTotal": "$399M",
  "lastRoundType": "Series E",
  "lastRoundAmountUsd": 250000000,
  "founders": [{ "name": "Daniel Yanisse", "title": "CEO", "location": "San Francisco" }]
}
```

The key-value store also holds a `SUMMARY` record: for each search, jobs announced, jobs on the listing page alone, jobs returned, coverage and why the search ended.

### Tips

- One search per run is enough for most needs: a whole city returns in about two minutes.
- For a daily feed, schedule the Actor with New jobs only and a Webhook URL. The webhook gets the run id, dataset id and job count when the run ends.
- A startup that posts more than 3 jobs in the same role and the same city still shows only 3 of them on every Wellfound page a visitor can open. Those are the jobs still missing from the coverage above.

### FAQ, disclaimers and support

#### Is it legal to scrape Wellfound?

Our Actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our Actors, when used for ethical purposes by Apify users, are safe. However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

#### Do I need a Wellfound account or a proxy?

No. The Actor reads public pages and handles its own connection, at no extra cost to you.

#### Why do I get fewer jobs than Wellfound announces?

See the Tips section: Wellfound never shows a visitor more than 3 jobs of a startup for the same role and place. The run summary tells you how many jobs that leaves out for each search.

#### Something is missing or broken?

Open an issue in the Issues tab and it gets fixed. To call the Actor from your code, see the API tab.

### Guide and use cases

Use cases for outbound and automation, the output fields, pricing and common questions are on the [Wellfound Jobs Scraper page](https://alexis.morain.fr/en/scrapers/wellfound-jobs-scraper/) of my site. The [Job boards family page](https://alexis.morain.fr/en/scrapers/families/jobs/) puts it side by side with the other scrapers of the same family.

# Actor input Schema

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

Cities, regions or countries, one per line: <code>San Francisco</code>, <code>New York</code>, <code>London</code>, <code>India</code>, <code>Germany</code>. Use <code>Remote</code> for remote jobs. Names are matched to Wellfound's own pages (<code>wellfound.com/location/\<name></code>). With roles, each role is searched in each location. Without roles, you get every job in the location.

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

Wellfound roles, one per line: <code>Software Engineer</code>, <code>Product Manager</code>, <code>Account Executive</code>, <code>Data Scientist</code>. Matched to Wellfound's role pages (<code>wellfound.com/role/\<name></code>). Without locations, you get the role everywhere.

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

Wellfound list pages instead of (or on top of) roles and locations: <code>/location/\<place></code>, <code>/remote</code>, <code>/role/\<role></code>, <code>/role/r/\<role></code> (remote) and <code>/role/l/\<role>/\<place></code>. Company pages (<code>/company/...</code>) are not supported: Wellfound blocks them. Use a list URL with <b>Company details</b> instead. Single jobs go in <b>Job URLs</b>.

## `jobUrls` (type: `array`):

Single jobs to read, one full URL per line: <code>https://wellfound.com/jobs/4897467-staff-database-reliability-engineer</code>. The title part of the URL is required (Wellfound answers 404 without it). Each job comes with its company details; filters do not apply to these.

## `completeCoverage` (type: `boolean`):

Listing pages hide every job past the 3rd of a startup. On: for a place, the Actor also reads the role × place pages; for a role, the remote page and the role × place pages for the main places, then removes duplicates. This returns up to twice as many jobs as the listing page alone and costs nothing extra besides the extra jobs. A role × place search has no safe split and is read as is. Off: only the listing pages, fastest.

## `includeCompanyDetails` (type: `boolean`):

Reads one job page per startup and adds to each of its jobs: website, headquarters, industries, funding raised and number of rounds, last round (type, amount, date), founders (name, title, location) and where employees joined from. Charged as a detailed job instead of a job. Wellfound shows only the latest funding round.

## `jobTypes` (type: `array`):

Keep only these job types. Empty keeps all. Applied before you are charged.

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

Keep only the jobs Wellfound flags as remote. Applied before you are charged. Not applied to Job URLs.

## `postedWithinDays` (type: `integer`):

Keep only jobs posted in the last N days. Wellfound lists no date filter for visitors, so the Actor applies it itself, before you are charged.

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

Total jobs returned by the run, across all searches. The run stops cleanly when it is reached.

## `newOnly` (type: `boolean`):

Remembers the jobs returned by earlier runs and returns only jobs not delivered before. The first run returns everything that matches. Schedule it daily for a feed of fresh startup jobs that never repeats.

## `monitorName` (type: `string`):

Without a name, the memory of delivered jobs belongs to this exact set of searches. With a name, every run using that name shares it, even if you change the searches.

## `webhookUrl` (type: `string`):

If set, the Actor POSTs a small JSON summary to this URL at the end of the run, <b>only when at least one job was returned</b>: <code>actor</code>, <code>runId</code>, <code>datasetId</code>, <code>jobs</code>, <code>newOnly</code> and one line per search. Use the final URL: a redirect is not followed, except a 307 or 308. An unreachable webhook is logged and never fails the run. Stored encrypted.

## Actor input object example

```json
{
  "locations": [
    "San Francisco"
  ],
  "roles": [
    "Software Engineer"
  ],
  "completeCoverage": true,
  "includeCompanyDetails": false,
  "remoteOnly": false,
  "maxItems": 50,
  "newOnly": false
}
```

# Actor output Schema

## `results` (type: `string`):

All jobs in the default dataset.

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

For each search: jobs announced by Wellfound, jobs the listing page alone shows (baseOnlyRead), jobs read with the role × place pages (read), jobs returned (delivered, deliveredBeyondBase), pages read, filtered and duplicate jobs, and why the search stopped.

# 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 = {
    "locations": [
        "San Francisco"
    ],
    "roles": [
        "Software Engineer"
    ],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("alexmorain/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 = {
    "locations": ["San Francisco"],
    "roles": ["Software Engineer"],
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("alexmorain/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 '{
  "locations": [
    "San Francisco"
  ],
  "roles": [
    "Software Engineer"
  ],
  "maxItems": 50
}' |
apify call alexmorain/wellfound-jobs-scraper --silent --output-dataset

```

## MCP server setup

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