# Wellfound Startup Jobs Scraper 🚀 (salary + equity) (`tagadanar/wellfound-scraper`) Actor

Every job on Wellfound (ex AngelList Talent) with the numbers the site makes you click for: salary and equity range, remote policy, full description, plus the startup's stage, headcount, YC / top-investor badges and reply speed. No login, no API key, one flat price per job.

- **URL**: https://apify.com/tagadanar/wellfound-scraper.md
- **Developed by:** [Tagada Data](https://apify.com/tagadanar) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.05 / 1,000 job listings

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/platform/actors/running/actors-in-store#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 Startup Jobs Scraper 🚀 (salary + equity)

Wellfound (the old AngelList Talent) is where startups post the jobs they are
actually hiring for, and it is one of the very few job boards where the pay is
public: a salary band and, on a lot of listings, an equity band too. This actor
pulls those listings out as a clean table, with the hiring startup's profile
folded into every row.

You get the salary range, the equity range, the remote policy, how many years of
experience the role asks for, the full job description, and what kind of company
is behind it: headcount, stage, whether it is YC funded, whether it took money
from top investors, whether it is growing fast, and how quickly it replies to
applicants.

No login, no API key, no browser. One flat price per job.

### What you get, per job

| Field | Example |
| --- | --- |
| `title` | Software Engineer |
| `companyName`, `companySlug`, `companyUrl` | StepSecurity |
| `companyPitch` | We are on a mission to build the best software supply chain security platform |
| `companySize` | 11-50 |
| `companyStageLabel`, `companyStage` | Early Stage, `early_stage` |
| `ycFunded`, `topInvestors`, `recentlyFunded`, `growingFast` | true / false |
| `valuationBadge` | Valuation $1B+ |
| `responseSpeed`, `responderRank` | Responds within a day, Top 5% of responders |
| `businessModel` | B2B |
| `compensation` | $135k – $175k • 0.05% – 0.25% |
| `salaryMin`, `salaryMax`, `salaryCurrency` | 135000, 175000, USD |
| `equityMin`, `equityMax`, `hasEquity` | 0.05, 0.25, true |
| `remote`, `remotePolicy`, `wfhFlexible` | true, REMOTE, false |
| `locations`, `remoteHiringLocations` | \["Seattle"], \["Canada", "United States"] |
| `yearsExperienceMin`, `yearsExperienceMax` | 2 |
| `jobType` | full-time, contract or internship |
| `postedAt` | 2026-08-10T23:00:32.000Z |
| `description` | the full posting text |
| `autoPosted`, `atsSource` | whether it was imported from the startup's ATS |
| `url` | link back to the listing |

Turn on "Add company website and industry" and each row also gets
`companyWebsite`, `companyIndustries`, `jobBenefits`, `applicantLocations` and
Wellfound's own `estimatedSalaryMin` / `estimatedSalaryMax`. That pass opens one
extra page per job, so it is slower, and it is only charged for the jobs where
the extra data was actually found.

Where a startup did not publish something, the field is `null`. Nothing is
guessed or filled in from a model. About 8 listings in 10 carry a salary band;
"No equity" is recorded as `hasEquity: false`, which is different from a listing
that simply says nothing about equity (`null`).

### Who uses it

**Recruiters and sourcers.** Watch which startups are hiring for your niche
right now, filtered to the stage and headcount you place into. `activelyHiring`,
`growingFast` and `responseSpeed` tell you who will actually answer.

**Job seekers and career coaches.** Pull every remote engineering role with a
posted salary above your floor, into a spreadsheet, once a week. The equity
columns let you compare offers that a job board would show you as two identical
salary numbers.

**Compensation benchmarking.** Wellfound is one of the few public sources of
startup pay bands with the company's stage and size attached, which is exactly
what you need to answer "what does a Series A B2B company in New York pay a
senior PM, and how much equity comes with it".

**Sales and lead gen.** Hiring is a buying signal. A startup that just posted
five engineering roles is a startup that is spending. With company details on,
you get its website too, which is usually the only enrichment step you needed.

**VC and market research.** Headcount growth by stage, by city, by role, week
over week.

### Input

Search by role, by city, or both. Roles are written the way Wellfound writes
them: the slug at the end of a Wellfound URL. `wellfound.com/role/r/`**`software-engineer`**.
Plain English (`Software Engineer`) is converted for you.

Every remote software engineering job:

```json
{
  "roles": ["software-engineer"],
  "remoteOnly": true,
  "maxResults": 200
}
```

Product and design roles in two cities (four searches, run in turn):

```json
{
  "roles": ["product-manager", "product-designer"],
  "locations": ["new-york", "san-francisco"],
  "maxResults": 500
}
```

Everything hiring in Berlin, with the company website and industry attached:

```json
{
  "locations": ["berlin"],
  "includeCompanyDetails": true,
  "maxResults": 100
}
```

Or paste Wellfound URLs straight in:

```json
{
  "startUrls": [
    "https://wellfound.com/role/r/data-scientist",
    "https://wellfound.com/role/l/product-manager/new-york",
    "https://wellfound.com/location/london"
  ],
  "maxResults": 300
}
```

### FAQ

**Do I need a Wellfound account or an API key?**
No. Everything comes from public pages.

**Is this an AngelList scraper?**
Yes. AngelList Talent was renamed Wellfound; `angel.co` job URLs redirect there,
and this actor accepts them.

**Which roles and locations can I use?**
Anything Wellfound has a page for. Open the site, filter to the role or city you
want, and copy the slug out of the address bar. If a role is not recognised, the
run says so in the log and skips that search rather than returning a pile of
unrelated jobs.

**Does it get the salary and the equity, or just the salary?**
Both, wherever the startup published them, split into numeric min/max columns as
well as the original string. Roughly four listings in five state a salary band;
equity is stated less often, and "No equity" is recorded explicitly.

**Does it get the full job description?**
Yes, in the same row, without opening the job page. That is not true of most job
scrapers, which need a second request per listing to get the text.

**How fresh is the data?**
`postedAt` is the timestamp the listing went live. Wellfound puts the most
recently active startups first, so page 1 is the freshest.

**How many jobs are there per search?**
The log tells you at the start of each search: a role like `software-engineer`
remote is roughly 1,800 jobs over 46 pages; a city page like `berlin` is a few
hundred. Set `maxResults` to what you need.

**Can I run it on a schedule?**
Yes. Set it up as a task with a daily or weekly schedule and diff the datasets
to see what is new.

**What about jobs on LinkedIn or Greenhouse?**
Different sources, different actors. See `linkedin-jobs-scraper` and
`ats-jobs-aggregator` in the same store profile if you want to combine boards.

***

Wellfound scraper, AngelList jobs scraper, startup jobs scraper, startup salary
data, equity data, remote startup jobs, YC jobs, tech recruiting leads, salary
benchmarking, hiring signals, wellfound.com scraper, angel.co scraper.

# Actor input Schema

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

One role per entry, written the way Wellfound writes it: <code>software-engineer</code>, <code>product-manager</code>, <code>data-scientist</code>, <code>designer</code>. Plain English works too (<code>Software Engineer</code>). The role slug is the last part of a Wellfound role URL: <code>wellfound.com/role/r/<b>software-engineer</b></code>. Combine with locations to get every role in every city.

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

Cities as Wellfound slugs: <code>san-francisco</code>, <code>new-york</code>, <code>london</code>, <code>berlin</code>, <code>bangalore</code>. Leave empty to search everywhere (or turn on remote-only below for remote jobs). Each role is searched in each location.

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

Return only jobs the startup will hire remotely for. Applies when no locations are given, since a location search is by definition not remote-only.

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

Paste Wellfound search pages instead of typing roles and locations, for example <code>https://wellfound.com/role/r/software-engineer</code>, <code>https://wellfound.com/role/l/product-manager/new-york</code> or <code>https://wellfound.com/location/berlin</code>.

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

Total jobs to return across all searches. Wellfound lists the freshest and most actively hiring startups first, so a few hundred usually covers a hiring search.

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

Also open each job's own page to add the startup's website URL, its industry tags, the listed benefits and Wellfound's salary estimate. Useful for outreach and lead lists. It adds one request per job, so runs take noticeably longer, and it is only charged for jobs where the extra data was actually found.

## Actor input object example

```json
{
  "roles": [
    "software-engineer"
  ],
  "locations": [],
  "remoteOnly": true,
  "startUrls": [],
  "maxResults": 40,
  "includeCompanyDetails": true
}
```

# Actor output Schema

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

One item per job listing in the default dataset.

# 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": [],
    "remoteOnly": true,
    "startUrls": [],
    "maxResults": 40,
    "includeCompanyDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("tagadanar/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": ["software-engineer"],
    "locations": [],
    "remoteOnly": True,
    "startUrls": [],
    "maxResults": 40,
    "includeCompanyDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("tagadanar/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": [
    "software-engineer"
  ],
  "locations": [],
  "remoteOnly": true,
  "startUrls": [],
  "maxResults": 40,
  "includeCompanyDetails": true
}' |
apify call tagadanar/wellfound-scraper --silent --output-dataset

```

## MCP server setup

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