# Wellfound Scraper | Startup Jobs with Salary AND Equity (`tqm/wellfound-scraper`) Actor

Scrape Wellfound (AngelList) startup jobs with the data most boards never publish: equity ranges parsed into numbers, alongside salary, company size and stage. Pick the role pages you want by slug. No browser, no proxy, no login, no cookies. Filter by equity, remote, tech stack or salary.

- **URL**: https://apify.com/tqm/wellfound-scraper.md
- **Developed by:** [TQM](https://apify.com/tqm) (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.60 / 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?

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 Job Scraper extracts startup job listings from [Wellfound](https://wellfound.com) (formerly AngelList Talent) — including the data Wellfound is uniquely good for: **salary *and* equity ranges**, company size and stage.

It reads Wellfound's public role pages over plain HTTP. **No browser, no proxy, no login, no cookies.**

### What data can I extract from Wellfound?

| Field | Description |
|---|---|
| `title` | Job title as posted |
| `company` | Hiring company |
| `companyUrl` | Link to the company's Wellfound profile |
| `companySize` | Employee-count band as stated by the company |
| `funding` | The company's own one-line positioning ("high concept"), when set |
| `jobUrl` | Link to the original Wellfound posting |
| `description` | Posting body, HTML stripped, truncated to 1,000 characters |
| `location` | Location(s) as listed, or `Remote` |
| `remote` | Whether the role is remote |
| `salary` | Compensation string as posted |
| `salaryMin` / `salaryMax` | Parsed salary bounds |
| `currency` | Salary currency |
| `equity` | Equity string as posted, e.g. `0.1% - 0.5%` |
| `equityMin` / `equityMax` | Parsed equity percentage bounds |
| `hasEquity` | Whether the posting offers equity at all |
| `role` | Wellfound's own role classification |
| `experienceLevel` | Derived from the posting's years-of-experience range |
| `techStack` / `skills` | Technologies detected in the title and description |
| `postedAt` | Publication timestamp |
| `jobId` | Stable id, useful as a deduplication key |
| `scrapedAt` | When this run collected the row |

**Equity data is the differentiator.** Most job boards do not publish it; Wellfound does, and this actor parses it into numeric bounds you can filter and sort on.

### How do I use Wellfound Job Scraper?

1. Click **Try for free**.
2. Set `roles` to the Wellfound role pages you want, by slug — `["devops-engineer", "backend-engineer"]`. This is the one input that matters most.
3. Click **Save & Start**.
4. Export as JSON, CSV, Excel or XML from the **Storage** tab.

### Input reference

| Option | Type | Default | What it does |
|---|---|---|---|
| `roles` | array | `["devops-engineer"]` | Wellfound role pages to scrape, by slug (e.g. `devops-engineer`, `backend-engineer`, `product-manager`). **At least one is required**; each page carries roughly 25 listings. |
| `maxJobs` | integer | `100` | Cap across all selected roles, up to **200**. |
| `techStackFilter` | array | *(none)* | Keep only postings mentioning these technologies. Word-boundary matched. |
| `minSalary` | integer | `0` | Drop postings below this annual figure. |
| `equityOnly` | boolean | `false` | Keep only postings that offer equity. |
| `remoteOnly` | boolean | `false` | Keep only remote roles. |
| `failOnZeroResults` | boolean | `true` | Fail the run, with a reason, when it returns nothing. |
| `useResidentialProxies` | boolean | `false` | **Deprecated and ignored.** See below. |

> **`useResidentialProxies` does nothing.** Version 2 replaced the headless browser with a single HTTP request that needs no proxy at all. The input is kept only so existing saved configurations do not break. It costs you nothing and changes nothing — earlier documentation describing it as "recommended, avoids blocks" was wrong and has been corrected.

#### Input sample

```json
{
  "roles": ["devops-engineer", "backend-engineer"],
  "maxJobs": 200,
  "equityOnly": true,
  "remoteOnly": true,
  "failOnZeroResults": true
}
```

### Output sample

```json
{
  "source": "wellfound",
  "jobId": "3418872",
  "title": "Senior DevOps Engineer",
  "company": "Northwind Labs",
  "companyUrl": "https://wellfound.com/company/northwind-labs",
  "companySize": "11-50",
  "funding": "Infrastructure automation for regulated industries",
  "jobUrl": "https://wellfound.com/jobs/3418872-senior-devops-engineer",
  "description": "We're an early-stage team building deployment tooling for banks...",
  "location": "Remote",
  "remote": true,
  "salary": "$130k - $170k",
  "salaryMin": 130000,
  "salaryMax": 170000,
  "currency": "USD",
  "equity": "0.1% - 0.5%",
  "equityMin": 0.1,
  "equityMax": 0.5,
  "hasEquity": true,
  "role": "DevOps Engineer",
  "experienceLevel": "Senior",
  "techStack": ["aws", "terraform", "kubernetes"],
  "skills": ["aws", "terraform", "kubernetes"],
  "postedAt": "2026-08-30T00:00:00.000Z",
  "scrapedAt": "2026-09-04T09:15:31.204Z"
}
```

### How many jobs can I scrape from Wellfound?

**About 25 per role page, and `maxJobs` is capped at 200 for that reason.**

Each Wellfound role page is a single un-paginated request carrying roughly 25 listings. The way to get more rows is to request **more roles**, not a higher `maxJobs` — eight role slugs will get you far closer to 200 than one slug ever can.

That cap is a measured ceiling, not a marketing number. An earlier version of this actor advertised a maximum of 1,000, which it could not reach.

### A run that returns nothing tells you why

With `failOnZeroResults: true` (the default), an empty run **fails** and names the cause: filters that removed everything, a role slug that does not exist, every role page refused, or a change in Wellfound's page structure. On pay-per-result pricing a silent zero-row "success" is you paying for nothing.

Set it to `false` for scheduled monitoring runs where quiet results are expected.

### How much does it cost?

Low. Each role page is one HTTP request with no browser and no proxy — version 2 removed both, which is where nearly all the cost of a startup-jobs scraper normally goes. Cost scales with the number of role slugs you request, not with how aggressively you filter, because filtering happens after the fetch.

Run it once with your real input and read the exact figure from the **Runs** tab.

### Who is this for?

- **Job seekers targeting startups**, who want salary *and* equity side by side before applying.
- **Recruiters** benchmarking startup compensation, including equity bands competitors are offering.
- **Investors and market researchers** tracking which startups are hiring, at what size and stage — hiring is a leading indicator of funding and growth.
- **Lead generation** — a company posting engineering roles is a company spending on engineering.

### FAQ

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

No. This actor reads public role pages only. There is no login, no cookie and no account to be banned.

#### Why do I need to specify roles?

Wellfound organises listings by role page rather than offering a single global feed, so the role slug is how you tell the actor where to look. Use the slug from the URL: `wellfound.com/role/r/devops-engineer` → `devops-engineer`.

#### Will I get blocked?

Version 2 makes a single ordinary HTTP request per role page, which is far less conspicuous than the headless browser it replaced. If a page is refused, the run says so rather than returning an unexplained empty result.

#### Does every posting have equity data?

No — only where the company published it. `hasEquity` tells you which ones did, and `equityMin`/`equityMax` are populated only when a range was stated.

#### Is it legal to scrape Wellfound?

This actor collects only publicly published job listings and extracts no private user data. Results may still contain personal data. You should not scrape or store personal data without a legitimate reason; if unsure, consult your lawyers. See Apify's background on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

#### Can I export to Excel or Google Sheets?

Yes — JSON, CSV, XML and Excel from the **Storage** tab, plus a direct Google Sheets integration.

### Integrations and API

Trigger runs and collect results via the [Apify API](https://docs.apify.com/api/v2), the JavaScript or Python client, or Apify's built-in integrations — **Zapier, Make, Slack, Google Drive, GitHub and webhooks**.

### Support

Missing a role slug, a field, or seeing something wrong? Open an issue on this actor's **Issues** tab.

# Actor input Schema

## `maxJobs` (type: `integer`):

Maximum postings to return across all selected roles. Each Wellfound role page is a single un-paginated request carrying roughly 25 listings (measured 2026-08-27), so the real ceiling is about 25 x the number of roles. Asking for more cannot return more.

## `techStackFilter` (type: `array`):

Only return jobs mentioning these technologies

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

Wellfound role pages to scrape, by slug (e.g. devops-engineer, backend-engineer, product-manager). Each page carries roughly 25 listings. At least one is required — leaving this empty falls back to devops-engineer rather than returning nothing.

## `minSalary` (type: `integer`):

Filter jobs with salary below this amount

## `equityOnly` (type: `boolean`):

Only return jobs offering equity

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

Only return remote jobs

## `useResidentialProxies` (type: `boolean`):

Deprecated and ignored. v2 replaced the headless browser with a single HTTP request that needs no proxy, so this input does nothing. Kept only so existing saved inputs do not error; it will be removed.

## `failOnZeroResults` (type: `boolean`):

When on (default), a run that finds no postings FAILS with a message explaining why — too-narrow filters, every role page refused, or a change in Wellfound's page data. Turn it off if you run this on a schedule and want quiet runs to stay green.

## Actor input object example

```json
{
  "maxJobs": 100,
  "techStackFilter": [],
  "roles": [
    "devops-engineer"
  ],
  "minSalary": 0,
  "equityOnly": false,
  "remoteOnly": false,
  "useResidentialProxies": false,
  "failOnZeroResults": true
}
```

# Actor output Schema

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

Every job posting this run returned from Wellfound, one row each, including equity and salary where the company published them.

# 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": [
        "devops-engineer"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("tqm/wellfound-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": ["devops-engineer"] }

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

```

## MCP server setup

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