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

Scrape startup jobs from Wellfound (AngelList Talent): salary and equity as numbers, remote or onsite, startup stage, size, YC and badges, company website. Plus a startup lead table and a salary report per search. No login, no API key.

- **URL**: https://apify.com/precious_bathmat/wellfound-jobs-scraper.md
- **Developed by:** [Mariam Ahmed](https://apify.com/precious_bathmat) (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 $2.00 / 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.

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

## Wellfound Jobs Scraper: Startup Jobs, Salary & Equity

Scrape **startup jobs from Wellfound** (formerly AngelList Talent) with no login and no API key, and get a **startup lead table** and a **salary and equity report for every search**:

- **Every job**: title, startup, tagline, stage, size, YC, badges, locations, remote or onsite, countries remote hires may live in, job type, years of experience, posted date, **full description** and link
- **Salary and equity as numbers**: "$170k – $250k • 1.0% – 3.0%" becomes `salaryMin` 170000, `salaryMax` 250000, `currency` USD, `equityMin` 1, `equityMax` 3. Dollars, pounds, euros, Canadian dollars, rupees (lakh) and won are understood
- **Startup table**: one row per hiring startup with its roles, locations, salary range, equity, stage, size, badges and latest posting, ready for outreach or market maps
- **Company website and industry** with Job details on
- **Filters Wellfound's own pages do not have**: minimum salary, equity only, startup stage, startup size, YC only, posted within, job type, remote or onsite
- **Report per search**: salary median and middle half by currency, equity share and typical range, remote share, startup stages and sizes, YC share, top startups, locations, badges and freshness

### What does this Wellfound scraper do?

```
Wellfound · "software engineer" · San Francisco · 779 jobs at 290 startups
 Salary shown on 89% · median $200,000 ($167,000 to $225,000)
 Equity offered on 75% of jobs that say · typical top of range 1%
 18.5% remote-friendly · 15% of startups YC funded
```

1. Enter **roles** ("software engineer", "product manager", "designer") and **locations** ("San Francisco", "London", "India", or "remote").
2. Pick filters: **minimum salary**, **equity only**, **stage**, **size**, **YC only**, **posted within**, **job type**.
3. You get **one row per job**, **one row per startup** and **one report per role and location**.

```mermaid
flowchart LR
    A[Roles,<br/>locations or remote] --> C[Wellfound<br/>job search]
    B[Filters<br/>salary, equity, stage,<br/>size, YC, date] --> C
    C --> D[Jobs<br/>salary + equity<br/>as numbers]
    D --> E[Startups<br/>one row each]
    D --> F[Report<br/>salary, equity,<br/>remote, stages]
    C -. Job details on .-> G[Job page<br/>website, industry]
    G --> D
```

### Who is it for?

- **Job seekers** in tech and startups: real salary and equity ranges by role and city, and which startups are hiring now
- **Recruiters and staffing agencies**: a list of funded startups hiring for your specialty, with size, stage and website, as sales leads
- **Founders and hiring managers**: what other startups pay and offer in equity for the same role and city
- **VCs and analysts**: which startups are hiring hardest, by stage and badge (YC funded, top investors, growing fast)
- **Sales and marketing teams** selling to startups: who is growing and where

### What data do you get?

**Jobs** (dataset, one row per job)

| Field | What it tells you |
|---|---|
| `jobId`, `title`, `roleCategory`, `url`, `description` | The job, with the full description |
| `company`, `companyUrl`, `companyTagline` | The startup and its one-line pitch |
| `companySize`, `companyStage`, `ycFunded`, `companyBadges` | Employees, early / growth / scale / public, YC, and Wellfound badges such as Top Investors or Growing fast |
| `locations`, `remote`, `workplace`, `remoteCountries` | Where, and whether it is remote, onsite or either |
| `compensation` | The salary text exactly as shown |
| `salaryMin`, `salaryMax`, `currency`, `salaryPeriod` | Yearly salary as numbers |
| `equityMin`, `equityMax`, `equityOffered` | Equity in percent, and whether any is offered |
| `jobType`, `yearsExperienceMin`, `postedAt`, `postedVia` | Full-time, contract, internship or cofounder; experience; when it went live; Wellfound or the startup's ATS (Ashby, Greenhouse...) |

**With Job details on**, each job also gets `companyWebsite`, `companyIndustry`, `companyLocations`, `datePosted`, `applicantCountries`, `experienceMonths`, `jobLocations` and the salary from the job page.

**Startups** (`STARTUPS`, JSON and CSV, one row per startup)

| Field | What it tells you |
|---|---|
| `company`, `companyUrl`, `companyWebsite`, `companyTagline` | Who they are |
| `companySize`, `companyStage`, `ycFunded`, `badges`, `companyIndustry` | How big, how far along, how funded |
| `openRolesFound`, `roleTitles`, `jobTypes`, `locations`, `remoteRolesPercent` | What they are hiring for and where |
| `salaryCurrency`, `salaryLow`, `salaryHigh`, `equityOffered`, `latestPostedAt` | What they pay and how recently they posted |

**Report** (`REPORTS`, one per role and location)

| Field | What it tells you |
|---|---|
| `totalJobsOnWellfound`, `totalStartupsOnWellfound`, `jobsRead`, `startupsRead` | Size of the market and how much was read |
| `salaryShownPercent`, `yearlySalary` | Median and middle half, per currency |
| `equity` | Share offering equity and the typical range |
| `workplace`, `jobTypes`, `experience` | Remote share, job types, years asked for |
| `companyStages`, `companySizes`, `ycFundedPercent`, `topBadges` | What kind of startups are hiring |
| `topStartups`, `topLocations`, `topRemoteCountries`, `postedVia`, `freshness`, `highestPaid` | Who, where, how new, best-paid jobs |

### Example: 4 October 2026

Six roles in four places, up to 200 jobs each: **3,911 jobs at 1,137 startups and 24 reports in 3 minutes 9 seconds.**

| Search | Jobs on Wellfound | Median salary (middle half) | Equity offered | Remote |
|---|---|---|---|---|
| Software engineer, San Francisco | 779 at 290 startups | $200,000 ($167,000 – $225,000) | 75% | 18.5% |
| Software engineer, New York | 784 at 338 startups | $207,250 ($172,500 – $230,000) | 84% | 19% |
| Software engineer, remote | 1,874 at 893 startups | $180,000 ($143,500 – $212,500) | 67% | 78.5% |
| Software engineer, London | 176 at 101 startups | £80,000 (£58,750 – £102,500) | 44% | 23% |
| Product manager, San Francisco | 537 at 197 startups | $195,000 ($160,000 – $234,500) | 74% | 12.5% |
| Data scientist, San Francisco | 68 at 43 startups | $210,000 ($162,500 – $249,750) | 88% | 23% |
| Designer, New York | 167 at 113 startups | $159,000 ($125,625 – $193,750) | 52% | 24% |
| Sales, San Francisco | 973 at 340 startups | $162,500 ($113,125 – $210,375) | 71% | 32.5% |
| Marketing, remote | 3,214 at 1,690 startups | $142,500 ($100,000 – $170,000) | 37% | 91.5% |

- **San Francisco startups offer equity far more often** than remote ones: 75% of SF software jobs that mention equity offer some, against 67% remote and 44% in London.
- **London pays less and shows salary less often**: 37–51% of London jobs carry a salary, against 78–95% in San Francisco and New York.
- A single search for **all remote jobs read 5,000 jobs at 2,913 startups in under 5 minutes**. Three in four were fully remote; the US, India and Canada were the countries most often allowed.

### Pricing

**$0.002 per job**, **$0.001 per job page** (only with Job details on) and **$0.02 per search report**.

- 200 jobs with a report: **$0.42**
- The same with Job details (company website): **$0.62**
- The run above (3,911 jobs, 24 reports): **$8.30**

Turn off reports to pay for jobs only. The startup table is included at no charge.

### Good to know

- **Up to three jobs per startup**: Wellfound's search shows at most three roles per startup, so a startup with ten openings appears with three of them. `totalJobsOnWellfound` is Wellfound's own full count.
- **Roles and locations** must be ones Wellfound has pages for ("San Francisco, CA" is read as San Francisco). Common roles ("software engineer", "product manager", "data scientist", "designer", "marketing", "sales", "machine learning engineer", "frontend engineer") and big cities and countries work. Unknown ones are skipped and listed in `RUN_SUMMARY` with a hint.
- **Salary**: "$170k" style figures are yearly. A plain figure with no "k" or "L" has no stated period, so it stays in `compensation` only and is left out of the numbers.
- **Equity share** in the report counts only jobs that say something about equity.
- **Stage**: many startups show no stage (about 30% in San Francisco searches, over half in broad remote searches); filtering by stage leaves them out.
- **Nothing new is not an error**: a scheduled run with no matching jobs finishes normally and costs nothing. Job pages are charged only when their details were read.
- **Speed**: pages are read one at a time. If Wellfound asks the run to slow down, it pauses a minute and carries on (up to eight minutes) instead of failing.
- **No people**: founder and recruiter names are not collected; emails and phone numbers in descriptions are hidden.
- Data comes from **Wellfound's public job pages**. **Not affiliated with Wellfound.**

### Input

| Field | Meaning |
|---|---|
| **Roles** | One search each; empty = all roles |
| **Locations** | Cities, countries or "remote"; each role is searched in each; empty = everywhere |
| **Job type** | Full-time, contract, internship, cofounder |
| **Remote or onsite** | Remote-friendly only, or not remote-only |
| **Minimum salary** | Yearly, in the listing's currency |
| **Equity offered only** | Jobs with an equity range above 0% |
| **Startup size / stage** | Employees; early, growth, scale, public |
| **YC startups only** | Startups with the YC Funded badge |
| **Posted within** | 24 hours, 3 days, a week, 2 weeks, 30 days |
| **Jobs per search** | 1 to 10,000 (default 200) |
| **Job details** | Off by default; turns on company website and industry |
| **Reports** | On by default |

### Integrations

Export to JSON, CSV, Excel or Google Sheets, or connect through the Apify API, webhooks, Make, Zapier and n8n. **Schedule it daily** with "Last 24 hours" for a feed of new startup jobs, or weekly with Job details for a fresh list of hiring startups and their websites.

# Actor input Schema

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

Job roles as Wellfound names them, one search each, e.g. "software engineer", "product manager", "data scientist", "designer", "marketing", "sales". Empty = all roles in the locations below.

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

Cities or countries, e.g. "San Francisco", "New York", "London", "Bangalore", "India", "Germany", or "remote" for remote jobs. Each role is searched in each. Empty = every location.

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

Optional: only these job types.

## `workplace` (type: `string`):

Remote-friendly = fully remote or onsite-or-remote.

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

Only jobs whose salary range reaches at least this, e.g. 150000. Jobs without a salary are left out when set.

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

Only jobs that list an equity range above 0%.

## `companySizes` (type: `array`):

Optional: only startups of these sizes (employees).

## `companyStages` (type: `array`):

Optional: only startups at these stages (startups that show no stage are left out when set).

## `ycOnly` (type: `boolean`):

Only startups with Wellfound's YC Funded badge.

## `postedWithinDays` (type: `string`):

Only jobs that went live in this period.

## `maxJobsPerSearch` (type: `integer`):

Most jobs to save per role and location (1 to 10,000), after filters.

## `includeJobDetails` (type: `boolean`):

Open each job's page for the startup's website, industry, exact posting date, countries applicants may live in, months of experience and salary as numbers. One extra request and charge per job.

## `includeReports` (type: `boolean`):

One report per role and location: salary median and middle half by currency, equity, remote share, startup stages and sizes, YC share, top startups, locations and badges, freshness.

## Actor input object example

```json
{
  "roles": [
    "software engineer"
  ],
  "locations": [
    "remote"
  ],
  "workplace": "any",
  "equityOnly": false,
  "ycOnly": false,
  "postedWithinDays": "any",
  "maxJobsPerSearch": 200,
  "includeJobDetails": false,
  "includeReports": true
}
```

# Actor output Schema

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

One row per job: title, startup, stage, size, badges, locations, remote, salary and equity as numbers, job type, experience, posted date, full description, link.

## `startups` (type: `string`):

One row per hiring startup: tagline, size, stage, YC, badges, roles found, locations, salary range, equity, latest posting, website (with job details).

## `startupsCsv` (type: `string`):

The startup table as CSV.

## `reports` (type: `string`):

Per search: salary by currency, equity, remote share, stages, sizes, YC share, top startups, locations, badges, freshness.

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

Requests, problems and the limits of the data.

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

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

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

```

## MCP server setup

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