# Wellfound Scraper — Startup Jobs, Salaries & Companies (`logiover/wellfound-scraper`) Actor

Export Wellfound (AngelList Talent) startup jobs by role and location: parsed salary and equity, remote policy, experience and full description, plus company size, stage, funding, founders, website and LinkedIn. Thousands of jobs per run, no login. Not affiliated with Wellfound.

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

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 Scraper

**Wellfound Scraper** exports startup jobs and hiring startups from Wellfound (formerly **AngelList Talent**) — the largest startup job board — into clean JSON, CSV, Excel or Google Sheets. Search by role and location ("software engineer" in "new york", "product manager" remote, "data scientist" in "london"), and get every job with its **parsed salary range, equity range, remote policy, experience, posting date and full description**, plus the startup behind it: **company size, stage, badges, funding, founders, website and LinkedIn**. It is the practical **Wellfound API alternative** and **AngelList scraper** for anyone who needs startup jobs data at scale.

No Wellfound account, no login, no cookies and no browser extension: this **AngelList Talent jobs scraper** reads Wellfound's public job pages and turns them into structured rows. **Scrape startup jobs without login**, collect **10,000+ jobs in one run** (measured: 10,000 jobs in about 100 seconds), and **export to CSV, Excel, JSON, XML or HTML**, push to Google Sheets, or call it from the API, Make, Zapier, n8n or an AI agent through MCP.

> **Measured on the live site on 2026-10-13:** 100 jobs in 5 s (first rows after 2 s) · 1,000 jobs in 21 s · 5,000 jobs in 67 s · **10,000 jobs in ~100 s** · 0 duplicate rows · runs that find nothing finish with a plain-English reason instead of crashing.

***

### ✨ What you get

| Group | Fields |
|---|---|
| **Job** | job ID, title, URL, Wellfound role category, job type (full-time / contract / internship / co-founder), workplace type (Remote / On-site / Hybrid / On-site or remote), remote flag, office locations, countries a remote hire may live in, posting date, full description (plain text), applicant tracking system (Greenhouse, Ashby, Lever, Workable …) |
| **Pay** | compensation exactly as shown, **salary min / max**, **currency** (USD, EUR, GBP, INR, CAD …), **period** (year / month / hour), **equity min / max in %**, equity offered yes/no, minimum years of experience |
| **Company (always)** | company ID, name, slug, Wellfound URL, logo, tagline, **employee range**, **stage** (Seed / Early / Growth / Scale), all badges, **B2B / B2C**, **actively hiring**, **response speed** ("Top 10% of responders", "Responds within a week"), **YC funded**, **top investors**, **valuation $500M+ / $1B+**, growing fast, Glassdoor rating |
| **Job details** *(option)* | **visa sponsorship**, **relocation**, **skills**, remote work policy, where remote hires may live, **hiring contact** (name, title, location), city/region/country of every location, industry, direct apply, recruiter activity |
| **Company profile** *(option)* | **website**, **headquarters**, company type, industries, **total raised (USD)**, number of funding rounds, **latest round type, date and amount**, **founders** with profile links, companies and schools the team came from |
| **Company links** *(option)* | **LinkedIn**, **X / Twitter**, Facebook, blog, Product Hunt, company description, markets, office locations, **number of open jobs** |
| **Companies mode** | one row per hiring startup with its matching jobs (count, titles, URLs), salary range across them, equity offered, remote hiring, job locations |

Every row also carries the role and location you searched (`searchRole`, `searchLocation`), the Wellfound page it came from (`sourceUrl`) and a timestamp (`scrapedAt`).

***

### 🎯 Who uses Wellfound data and why

#### Recruiting and talent sourcing

Agencies and in-house recruiters track which startups are hiring for which roles, at what salary, with how much equity, and whether they sponsor visas. Filter by stage, YC backing or "actively hiring", then go straight to the hiring contact. A daily scheduled run with **Posted within = 1 day** gives you a fresh feed of new startup roles every morning.

#### Sales prospecting to hiring startups (B2B lead generation)

A startup that is hiring has budget. Switch to **Companies mode** and you get a lead list of startups hiring for a role — with **website, LinkedIn, founders, headcount, total raised, latest round and the ATS they use**. Sell HR tech, recruiting services, payroll, benefits, developer tools, cloud credits or office space to companies that just raised and are growing their team. The `applicantTrackingSystem` column alone tells ATS vendors and integrators who uses Greenhouse, Ashby, Lever or Workable.

#### Salary and equity benchmarking

Wellfound is one of the few job boards where most listings show **both salary and equity**. The scraper parses "$170k – $250k • 0.5% – 1.0%" into numbers — `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod`, `equityMin`, `equityMax` — so you can compare pay by role, city, remote policy, company stage and size in a spreadsheet or BI tool without any cleaning. In a 10,000-job sample, 71% of jobs had a salary range.

#### VC deal flow and market mapping

Hiring is a leading indicator of growth. Investors and analysts use the stage, funding, valuation, YC and "growing fast" signals, plus job counts per startup, to spot companies scaling a team before the next round is announced, map a market by role demand, and watch competitors' hiring plans.

#### Job boards, newsletters and market research

Niche job boards and newsletters ("remote ML jobs", "Berlin startup jobs", "jobs with visa sponsorship") feed their listings from Wellfound exports — full descriptions, clean locations, stable job IDs. Analysts count open roles by category and city, track the remote share and watch pay move with scheduled runs.

***

### 🚀 How to scrape Wellfound jobs in 3 steps

1. **Enter roles and locations** — plain words like `software engineer`, `product manager`, `sales`, and `new york`, `london`, `remote`. Or type `all` in Roles to collect every role Wellfound has.
2. **Set Max results** and, if you want them, the enrichment options (job details, company profile, company links, all company jobs).
3. **Click Start** and download the results as **CSV, Excel, JSON, XML or HTML** from the Output tab — or let the API, a webhook or an integration pick them up.

***

### ⚙️ How it works

Wellfound publishes its job search on public pages: one page per role (`/role/software-engineer`), per role and location (`/role/l/software-engineer/new-york`), per remote role (`/role/r/designer`), per location (`/location/london`) and for remote jobs (`/remote`). Each page lists 20 startups with up to 3 of their matching jobs, and the page itself already contains every job's full description, pay, equity, locations and remote policy. The scraper reads those pages directly — no browser, no login — which is why it is fast.

What the Actor does for you on top:

- **Understands plain words.** "Full stack developer", "SWE", "ML engineer", "UX designer", "PM" and "NYC", "SF", "Bay Area", "DC", "UK", "USA" are mapped to Wellfound's own pages. If Wellfound has no page for a role in a city, it reads the smaller of the role's pages and the city's pages and keeps only the matching jobs — you still get the right jobs.
- **Reads the whole search, not just one walk through it.** Wellfound shuffles its result pages on every request (measured: 10 pages fetched together held 154 distinct startups out of 200 slots). One pass would miss part of the search, so the scraper keeps walking while new jobs keep appearing — for "software engineer" it saw 1,757 of the 1,768 startups Wellfound reports.
- **Shares the limit fairly.** With 3 roles × 4 cities and Max results = 1,200, each search gets its fair share; searches that run dry hand their share to the others.
- **De-duplicates** by job ID (or company ID in Companies mode) across all searches, and stops at exactly Max results.
- **Stays fast.** Up to 32 pages load in parallel, refused IPs are replaced at once, slow pages get a duplicate request and the first answer wins, and rows are saved as soon as they are parsed.
- **Fails honestly.** An unknown role or city ends as a successful empty run that tells you what Wellfound does have; a site outage ends as a failed run with the reason. You never get a silent "succeeded with 0 rows".

***

### 📥 Input reference

| Field | Type | Default | What it does |
|---|---|---|---|
| `roles` | array of strings | `[]` | Roles in plain words. Every role is searched in every location. `all` searches every Wellfound role page (10,000+ jobs). |
| `locations` | array of strings | `[]` | Cities, states, countries, or `remote`. Empty = everywhere. |
| `startUrls` | array | `[]` | Wellfound search, job or company URLs. |
| `mode` | `jobs` / `companies` | `jobs` | One row per job, or one row per hiring startup. |
| `maxItems` | integer | `1000` | Stop after this many unique jobs (or companies). `0` = no limit. |
| `postedWithinDays` | integer | `0` | Only jobs that went live in the last N days. |
| `jobType` | `any` / `full-time` / `contract` / `internship` / `cofounder` | `any` | Keep one kind of job. |
| `withSalaryOnly` | boolean | `false` | Skip jobs without a salary range. |
| `includeJobDetails` | boolean | `false` | Open each job page: visa, relocation, skills, hiring contact, exact salary, company funding and founders. |
| `includeCompanyDetails` | boolean | `false` | Company website, HQ, industries, funding, latest round, founders, team background (one page per company). |
| `includeCompanyLinks` | boolean | `false` | LinkedIn, X/Twitter, Facebook, blog, Product Hunt, description, open-job count (slower). |
| `allCompanyJobs` | boolean | `false` | Also export every other open job of each startup found (slower). |
| `maxPagesPerSearch` | integer | `0` | Cap on page requests per search. `0` = as many as the search needs. |
| `concurrency` | integer | `32` | Pages loaded in parallel (1–64). |
| `proxyConfiguration` | object | Residential | Keep Apify Residential. Company pages use Apify's unblocking proxy automatically. |

#### Example: remote software engineering jobs

```json
{
  "roles": ["software engineer"],
  "locations": ["remote"],
  "maxItems": 500
}
```

#### Example: a role × city grid for salary benchmarking

```json
{
  "roles": ["software engineer", "product manager", "data scientist"],
  "locations": ["new york", "san francisco", "london", "berlin"],
  "withSalaryOnly": true,
  "maxItems": 3000
}
```

#### Example: lead list of startups hiring sales people, with funding and LinkedIn

```json
{
  "mode": "companies",
  "roles": ["sales", "account executive", "sales manager"],
  "locations": ["united states"],
  "includeCompanyDetails": true,
  "includeCompanyLinks": true,
  "maxItems": 300
}
```

#### Example: jobs with visa sponsorship details, skills and hiring contact

```json
{
  "roles": ["machine learning engineer", "backend engineer"],
  "locations": ["remote", "london"],
  "includeJobDetails": true,
  "maxItems": 400
}
```

#### Example: the whole board — every role, 10,000+ jobs

```json
{
  "roles": ["all"],
  "maxItems": 20000
}
```

#### Example: daily feed of new jobs (use with a schedule)

```json
{
  "roles": ["all"],
  "postedWithinDays": 1,
  "maxItems": 0
}
```

#### Example: specific Wellfound pages, jobs and companies

```json
{
  "startUrls": [
    { "url": "https://wellfound.com/role/l/product-designer/san-francisco" },
    { "url": "https://wellfound.com/jobs/4787364-software-engineer" },
    { "url": "https://wellfound.com/company/scale-ai" }
  ]
}
```

A company URL exports all of that company's open jobs (up to 400). A job URL exports that job with all job-page details.

#### Which words work for roles and locations?

**Roles** — anything Wellfound has a role page for: software engineer, frontend engineer, backend engineer, full stack engineer, machine learning engineer, AI engineer, data scientist, data analyst, devops engineer, mobile engineer, engineering manager, QA engineer, security engineer, product manager, product designer, designer, UI/UX designer, sales, sales manager, account manager, account executive, growth marketer, content manager, copywriter, operations manager, HR manager, recruiter, financial analyst, CFO, react developer, java developer, go developer, solidity, smart contract and about a hundred more. Seniority words ("senior", "lead", "staff", "founding") are understood and mapped to the base role.

**Locations** — cities, states, countries and regions as Wellfound writes them: new york, san francisco, san francisco bay area, los angeles, boston, seattle, austin, chicago, denver, washington dc, london, berlin, paris, amsterdam, toronto, bangalore, singapore, dubai, united states, united kingdom, india, germany, europe, and `remote`. Shortcuts like NYC, SF, LA, DC, UK and USA work. "City, ST" is accepted ("Austin, TX").

***

### 📤 Output

#### Real output example

A job collected on 2026-10-13 with **Open every job page** switched on (description shortened):

```json
{
  "jobId": "3310675",
  "title": "Product Manager",
  "url": "https://wellfound.com/jobs/3310675-product-manager",
  "role": "Product Manager",
  "jobType": "full-time",
  "workplaceType": "Remote",
  "remote": true,
  "locations": "New York City",
  "remoteLocations": "United States",
  "compensation": "$120k – $130k • 0.0% – 0.15%",
  "salaryMin": 120000,
  "salaryMax": 130000,
  "salaryCurrency": "USD",
  "salaryPeriod": "year",
  "equityMin": 0,
  "equityMax": 0.15,
  "hasEquity": true,
  "yearsExperienceMin": 3,
  "postedAt": "2026-04-09T21:39:11.000Z",
  "description": "Who we are\nFlexPoint is a rapidly growing venture backed Software as a Service (SaaS) provider of payments and financial solutions for the Managed IT Services (MSP) industry…",
  "applicantTrackingSystem": null,
  "remoteWorkPolicy": "Remote only",
  "hiresRemotelyIn": "United States",
  "visaSponsorship": "Not Available",
  "relocation": "Not Allowed",
  "skills": "Payments | FinTech",
  "hiringContact": "Sam Kushner — Founder (United States)",
  "jobLocationsDetailed": "New York, New York, United States",
  "jobCountries": "United States",
  "industry": "SaaS and Finance Technology",
  "directApply": true,
  "recruiterActivity": null,
  "companyId": "9774290",
  "companyName": "FlexPoint",
  "companySlug": "flexpoint-1",
  "companyUrl": "https://wellfound.com/company/flexpoint-1",
  "companyLogoUrl": "https://photos.wellfound.com/startups/i/9774290-2e7c9834933eb6f73f13a18af8093208-medium_jpg.jpg?buster=1783967932",
  "companyTagline": "AR Automation + AI platform purpose-built for Managed Service Providers",
  "companySize": "11-50",
  "companyStage": "Growth Stage",
  "companyBadges": "Actively Hiring | B2B | Growth Stage",
  "companyBusinessModel": "B2B",
  "companyActivelyHiring": true,
  "companyResponseSignal": null,
  "companyYcFunded": false,
  "companyTopInvestors": false,
  "companyValuation": null,
  "companyGrowingFast": false,
  "companyGlassdoorRating": null,
  "companyWebsite": "https://www.getflexpoint.com",
  "companyHeadquarters": "Denver",
  "companyType": "Startup | Early Stage",
  "companyIndustries": "SaaS | Finance Technology",
  "companyTotalRaised": 19500000,
  "companyFundingRounds": 2,
  "companyLastRoundType": "Series A",
  "companyLastRoundDate": "2025-05",
  "companyLastRoundAmount": 12000000,
  "companyFounders": null,
  "companyFounderProfiles": null,
  "companyTeamBackground": "CompTIA | Nexus Solutions | Afloat | Alliant International University | NetSearch Direct",
  "searchRole": "product manager",
  "searchLocation": "new york",
  "sourceUrl": "https://wellfound.com/role/l/product-manager/new-york",
  "scrapedAt": "2026-10-13T10:53:50.473Z"
}
```

Lists are pipe-separated strings (`"Python | Rust | C++"`) so they stay readable in CSV and Excel. Missing values are `null`, never `0` or `""` — an empty salary means "not shown", not "zero".

#### Data dictionary

**Job fields** (always)

| Field | Type | Meaning |
|---|---|---|
| `jobId` | string | Wellfound job ID, stable across searches |
| `title` | string | Job title |
| `url` | string | Job page on Wellfound |
| `role` | string | Wellfound role category |
| `jobType` | string | full-time, contract, internship, cofounder |
| `workplaceType` | string | Remote, On-site, Hybrid, On-site or remote |
| `remote` | boolean | Wellfound's remote flag |
| `locations` | string | Office locations |
| `remoteLocations` | string | Where a remote hire may live |
| `compensation` | string | Pay and equity exactly as shown |
| `salaryMin`, `salaryMax` | number | Salary range |
| `salaryCurrency` | string | ISO code |
| `salaryPeriod` | string | year, month, hour |
| `equityMin`, `equityMax` | number | Equity range in percent |
| `hasEquity` | boolean | true = equity range shown, false = "No equity", null = not stated |
| `yearsExperienceMin` | number | Minimum years of experience |
| `postedAt` | string | When the job went live (ISO 8601) |
| `description` | string | Full description, plain text |
| `applicantTrackingSystem` | string | Greenhouse, Ashby, Lever, Workable …; null = posted on Wellfound directly |

**Company fields** (always)

| Field | Type | Meaning |
|---|---|---|
| `companyId`, `companyName`, `companySlug` | string | Startup identity |
| `companyUrl`, `companyLogoUrl` | string | Wellfound page, logo |
| `companyTagline` | string | One-line pitch |
| `companySize` | string | Employee range, e.g. 51-200 |
| `companyStage` | string | Seed / Early / Growth / Scale Stage |
| `companyBadges` | string | All badges |
| `companyBusinessModel` | string | B2B, B2C |
| `companyActivelyHiring` | boolean | Actively hiring badge |
| `companyResponseSignal` | string | Response-time badges |
| `companyYcFunded`, `companyTopInvestors`, `companyGrowingFast` | boolean | Badges |
| `companyValuation` | string | $500M+ or $1B+ |
| `companyGlassdoorRating` | number | Glassdoor rating shown by Wellfound |

**Job details** (`includeJobDetails`)

| Field | Type | Meaning |
|---|---|---|
| `remoteWorkPolicy` | string | In office, Remote only, Onsite or remote … |
| `hiresRemotelyIn` | string | Where remote hires may be |
| `visaSponsorship` | string | Available / Not Available |
| `relocation` | string | Allowed / Not Allowed |
| `skills` | string | Skills listed on the job |
| `hiringContact` | string | Name — title (location) |
| `jobLocationsDetailed` | string | City, region, country of every location |
| `jobCountries` | string | Countries |
| `industry` | string | Industry of the posting |
| `directApply` | boolean | Apply on Wellfound itself |
| `recruiterActivity` | string | e.g. Recruiter recently active |

**Company profile** (`includeCompanyDetails`, also filled by job details)

| Field | Type | Meaning |
|---|---|---|
| `companyWebsite` | string | Website |
| `companyHeadquarters` | string | Location shown by Wellfound |
| `companyType` | string | e.g. Enterprise Software Company |
| `companyIndustries` | string | Industry tags |
| `companyTotalRaised` | number | Total funding, USD |
| `companyFundingRounds` | number | Number of rounds |
| `companyLastRoundType` | string | Pre-Seed … Series D, Acquired, IPO |
| `companyLastRoundDate` | string | YYYY-MM |
| `companyLastRoundAmount` | number | USD, when disclosed |
| `companyFounders` | string | Founders with title |
| `companyFounderProfiles` | string | Founder profile links |
| `companyTeamBackground` | string | Where the team came from |

**Company links** (`includeCompanyLinks` or `allCompanyJobs`)

| Field | Type | Meaning |
|---|---|---|
| `companyLinkedInUrl`, `companyTwitterUrl`, `companyFacebookUrl`, `companyBlogUrl`, `companyProductHuntUrl` | string | Social and web links |
| `companyDescription` | string | Company description |
| `companyLiveJobCount` | number | Open jobs on Wellfound |
| `companyMarkets`, `companyLocations` | string | Market and office tags |

**Companies mode**

| Field | Type | Meaning |
|---|---|---|
| `matchingJobCount` | number | Jobs that matched your search |
| `matchingJobTitles`, `matchingJobUrls` | string | Those jobs |
| `matchingSalaryMin`, `matchingSalaryMax`, `matchingSalaryCurrency` | number / string | Yearly salary range across them |
| `offersEquity`, `hiresRemotely` | boolean | Any matching job offers equity / is remote |
| `jobLocations` | string | Locations of the matching jobs |
| `openJobTitles`, `openJobUrls` | string | All open jobs (with `allCompanyJobs`) |

**Source fields**: `searchRole`, `searchLocation`, `sourceUrl`, `scrapedAt`.

#### How complete are the fields?

Measured over 10,000 jobs (roles = all, 2026-10-13): title, URL, role, job type, workplace type, description, posting date, company name, size and badges flags 100%; locations 94%; company badges 90%; compensation 76%; salary range 71%; stage 60%; applicant tracking system 51%; experience 45%; equity range 11% (shown when the startup offers equity). With job details on (300 jobs): website, industries, headquarters, visa sponsorship, relocation and countries 99%; hiring contact 79%; latest funding round 59%; total raised 56%. Companies mode with links (40 startups): website 100%, open-job count 90%, LinkedIn 65%, X/Twitter 58%.

***

### 📊 How much data can I get?

| What you ask for | Wellfound shows | Measured result |
|---|---|---|
| `roles: ["all"]`, Max 10,000 | 115 role pages + the remote board | **10,000 jobs in 103 s**, 519 pages, 0 duplicates |
| `roles: ["software engineer"]`, no limit | 4,927 jobs at 1,768 startups, 89 pages | **2,926 unique jobs in 59 s** (1,757 startups seen) |
| 5 roles (software engineer, sales, product manager, designer, data scientist), Max 5,000 | ~19,600 jobs | **5,000 jobs in 67 s** |
| 2 roles × 3 locations, Max 1,000 | ~6,500 jobs | **1,000 jobs in 21 s**, 167 per search |
| "data scientist", no limit | 406 jobs at 253 startups | **353 jobs in 24 s** |

Why a search returns fewer jobs than Wellfound's headline number: Wellfound's result pages show **up to 3 matching jobs per startup**. A search reaches nearly every startup, but a startup with 10 matching jobs shows 3 of them. Two ways to get more:

- **More searches** — add roles and locations, or use `all`. Different role pages surface different jobs of the same startup; that is how `all` passes 10,000 jobs.
- **All company jobs** — `allCompanyJobs: true` opens each startup's own job list and exports every open job (up to 400 per startup).

For the whole board, set `roles: ["all"]` and `maxItems: 0` (no limit).

#### Big runs and "Maximum cost per run"

Apify gives every pay-per-result run a spending cap — the **Maximum cost per run** field in the run options. If you leave it empty, Apify applies its own default cap, which can be lower than a very large run needs. The scraper reads the cap when it starts and collects **exactly as many results as the cap covers**, then stops cleanly: the run ends as **SUCCEEDED** with a status message such as *"Saved 15 results — this run's maximum cost ($0.05) covers 15 result(s) at the current price"* (a real test run with a $0.05 cap and Max results = 5,000). It never fails, never ends as aborted, and never loads pages for results that could not be saved.

**For 10,000+ results, set Maximum cost per run to at least the number of results × the price per result** (see the Pricing tab). Example: at $3.50 per 1,000 results, 10,000 results need a cap of at least $35, and 20,000 results need $70. You only pay for the results actually saved — the cap is a ceiling, not a charge.

***

### ⚡ Speed and cost

All numbers measured on the Apify platform on 2026-10-13 with 32 parallel requests and 1 GB memory (the default is now 2 GB, which roughly halves long runs — the scraper is CPU-bound, and the compute cost per run stays the same):

| Run | Result | Time |
|---|---|---|
| Prefilled input (100 remote software engineering jobs) | 100 jobs | **5 s** (first rows after 2 s) |
| 2 roles × 3 locations | 1,000 jobs | **21 s** |
| 5 roles | 5,000 jobs | **67 s** |
| `all` roles | 10,000 jobs | **103 s** (first rows after 1 s) |
| Job details on | 300 jobs | 47 s with 2 GB (101 s with 1 GB) |
| Companies mode + profile + links | 40 startups | 184 s |
| All company jobs | 300 jobs | 161 s |
| Unknown role or city | explained empty result | 6 s |

**Pricing is per result** — see the Pricing tab. Residential proxy, unblocking proxy and compute are included; there is no separate proxy bill and no subscription.

Tips for speed:

- The plain search (no options) is the fastest: ~100 jobs per second.
- **Job details** open one extra page per job: about 6 jobs per second with the default 2 GB memory.
- **Company links** and **All company jobs** use Apify's unblocking proxy, which needs 10–40 s per company page; keep Max results moderate or run them on a schedule.

***

### 🔌 Integrations

#### Apify API (curl)

Run the Actor and get the results in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/logiover~wellfound-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN&format=json" \
  -H "Content-Type: application/json" \
  -d '{"roles":["software engineer"],"locations":["remote"],"maxItems":200}'
```

Use `format=csv` or `format=xlsx` to get a file instead of JSON.

#### Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('logiover/wellfound-scraper').call({
    roles: ['product manager'],
    locations: ['new york', 'remote'],
    withSalaryOnly: true,
    maxItems: 1000,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, items[0].title, items[0].salaryMin, items[0].companyName);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("logiover/wellfound-scraper").call(run_input={
    "mode": "companies",
    "roles": ["sales"],
    "locations": ["united states"],
    "includeCompanyDetails": True,
    "maxItems": 300,
})
for company in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(company["companyName"], company["companyWebsite"], company["companyTotalRaised"])
```

#### Make, Zapier, n8n

Use the Apify app in **Make** or **Zapier**, or the Apify node in **n8n**: "Run Actor" with `logiover/wellfound-scraper`, then "Get dataset items". Typical flows: new jobs → Slack channel, new hiring startups → CRM (HubSpot, Pipedrive, Salesforce), salary rows → Airtable.

#### Google Sheets

Add the Google Sheets integration on the Integrations tab, or import the CSV link of the dataset into a sheet with `=IMPORTDATA("https://api.apify.com/v2/datasets/DATASET_ID/items?format=csv&token=YOUR_TOKEN")`.

#### Webhooks and schedules

Create a schedule (for example every morning with `postedWithinDays: 1`) and a webhook on "Run succeeded" that posts the dataset ID to your server — your system receives each day's new startup jobs automatically.

#### AI agents and MCP

The Actor works as a tool for AI agents through **Apify's MCP server** (`https://mcp.apify.com/?actors=logiover/wellfound-scraper`) in Claude, Cursor, VS Code and other MCP clients — an agent can ask for "remote senior backend jobs at Series A startups with equity" and get structured rows back. It also works from LangChain, LlamaIndex and CrewAI through the Apify integrations.

***

### 🆚 Wellfound Scraper vs other options

| | Manual browsing | Wellfound job alerts | Generic web scraper | **Wellfound Scraper** |
|---|---|---|---|---|
| Account or login | needed for some views | needed | often | **not needed** |
| Jobs per hour | ~100 | a few per day | depends on setup | **10,000 in under 2 minutes** |
| Salary and equity as numbers | no | no | you write the parser | **yes** |
| Company funding, founders, LinkedIn | click every page | no | you write the parser | **one switch** |
| Shuffled result pages handled | no | n/a | no — silently misses startups | **yes, multi-pass** |
| De-duplication across searches | by hand | n/a | you build it | **built in** |
| Export | copy-paste | email | varies | **CSV, Excel, JSON, API, Sheets** |
| Maintenance when the site changes | — | — | yours | **ours** |

Wellfound has **no public jobs API** (AngelList's old public API is no longer available), so a scraper like this is the practical way to get the data programmatically.

***

### 💡 Limits and tips

- **3 jobs per startup per search page** is Wellfound's own limit. Use more roles, `all`, or `allCompanyJobs` for complete company job lists.
- **Exact numbers vary slightly between runs** — Wellfound's own totals move by a few jobs from one request to the next, and its result order is shuffled. The scraper keeps reading until new jobs stop appearing.
- **Unusual locations**: if Wellfound has no page for a place, the run says so and suggests the spelling to use. Use the city or country name as Wellfound writes it.
- **Remote jobs**: use `remote` as a location. Combine with a role for remote jobs in that role.
- **Big lists of companies with links**: the unblocking proxy is slow by nature; for thousands of companies, run the search first, then enrich the companies you care about with their company URLs in `startUrls`.
- **Daily monitoring**: schedule a run with `postedWithinDays: 1`; job IDs are stable, so you can de-duplicate across days.
- **Proxy**: keep the Apify Residential group. Wellfound refuses datacenter IPs.

***

### ❓ FAQ

#### Do I need a Wellfound account, login or cookies?

No. The scraper only reads public Wellfound pages. You do not log in, share cookies or install anything.

#### Is there an official Wellfound or AngelList API for jobs?

No. Wellfound does not offer a public API for job listings, and AngelList's old public API is no longer available. This Actor is a Wellfound API alternative: you call the Apify API and get Wellfound jobs as JSON.

#### How many jobs can I scrape in one run?

Measured: 10,000 jobs in about 100 seconds with `roles: ["all"]`, and 2,926 unique jobs from the single "software engineer" search. Set `maxItems: 0` for no limit — and raise **Maximum cost per run** to at least results × price per result, because Apify's default cap can be lower than a very large run needs.

#### Why did my run stop before reaching Max results?

Either Wellfound has no more matching jobs (the status message says how many it found), or the run reached its **Maximum cost per run**. In the second case the run still ends as SUCCEEDED and the status message says exactly how many results the cap covered — raise the cap in the run options (results × price per result) and run again. Nothing is lost or charged beyond the results you received.

#### Why does a startup show only 3 jobs?

Wellfound's search pages list up to 3 matching jobs per startup. Turn on **All open jobs of every company found** (`allCompanyJobs`) to export every open job, or add more roles.

#### How do I get only remote jobs?

Put `remote` in Locations. "Remote software engineer" = role `software engineer` + location `remote`. The `workplaceType`, `remote` and `remoteLocations` columns tell you where a remote hire may live.

#### Which role and location names can I use?

Plain words work: "software engineer", "full stack developer", "PM", "ML engineer", "ux designer" and city or country names like "nyc", "san francisco", "london", "united states". See the lists above. Wellfound URLs work too.

#### What happens if I mistype a role or a city?

The run finishes successfully with no rows and a status message that says which word Wellfound did not recognise and which spellings it does have. It does not crash.

#### Can I get salary and equity as numbers?

Yes. `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod`, `equityMin` and `equityMax` are parsed from Wellfound's pay line, including "k" amounts, currencies (USD, EUR, GBP, INR, CAD …) and "No equity". With job details on, the salary comes from the job posting's structured data.

#### Can I find jobs with visa sponsorship?

Yes. Turn on **Open every job page** — the `visaSponsorship` column shows "Available" or "Not Available", next to `relocation`, `skills` and the hiring contact.

#### Can I get company funding, founders and LinkedIn?

Yes. **Company profile** adds website, HQ, total raised, latest round (type, date, amount), founders and team background. **Company links** adds LinkedIn, X/Twitter, Facebook, blog and Product Hunt.

#### How do I build a lead list of startups that are hiring?

Use **Companies mode** with the roles you sell to, switch on Company profile and Company links, and export. Each row is one startup with its matching jobs, funding, size, website and LinkedIn.

#### How fresh is the data? Can I schedule it?

Every run reads Wellfound live, so data is as fresh as the site. Schedule hourly, daily or weekly runs in Apify; use `postedWithinDays` to get only new jobs.

#### Why are some fields empty?

Startups fill in different parts of their profile: some show no salary, no equity or no founders. Empty means "not shown on Wellfound" — the scraper never invents values. Option fields (details, profile, links) only appear when the option is on.

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

Yes — the Output tab downloads CSV, Excel (XLSX), JSON, XML and HTML, and the Google Sheets integration writes rows straight into a sheet.

#### Does it work with AI agents and MCP?

Yes. Add it to Apify's MCP server and your agent can call it as a tool; results come back as structured JSON.

#### Why is the company-links option slower?

Wellfound serves company pages only through Apify's unblocking proxy, which needs 10–40 seconds per page. The scraper loads many in parallel and duplicates slow requests, but it is still slower than the plain search.

***

### ⚖️ Is it legal to scrape Wellfound?

This Actor collects only publicly available information that Wellfound shows to any visitor without logging in. Scraping public data is generally lawful, but you are responsible for how you use it: respect Wellfound's terms where they apply to you, do not republish content in a way that infringes copyright, and handle personal data (founder and hiring-contact names) in line with GDPR, CCPA and similar laws — for example, use it for legitimate business purposes and honour opt-out requests. If you are unsure, ask a lawyer.

***

### 🛡️ Reliability and support

- Tested end to end on the live site on 2026-10-13: prefill, 1,000, 5,000 and 10,000-job runs, job details, companies mode with links, all company jobs, unknown role, unknown city and over-strict filters — every run finished with the right outcome.
- Refused IPs are replaced immediately, slow pages are duplicated, and every run writes a `SUMMARY` record (outcome, pages read, per-search totals, duplicates skipped) to its key-value store.
- If Wellfound changes its pages, we update the parser — scheduled runs keep working.

**Found a problem or need a field? Open an issue on the Issues tab — answered within 24 hours.**

***

### 📝 Changelog

#### 2026-10-13

First release: role × location search with plain-word aliases, multi-pass reading of Wellfound's shuffled result pages, fair sharing of the result limit, Jobs and Companies modes, parsed salary and equity, job details (visa, relocation, skills, hiring contact), company profile (funding, latest round, founders), company links (LinkedIn, X, Facebook), all company jobs, `all` roles for 10,000+ jobs per run, explained empty results, and a clean stop at the run's "Maximum cost per run" (SUCCEEDED with a message, never aborted).

***

*This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Wellfound, AngelList or any of their subsidiaries. "Wellfound" and "AngelList" are trademarks of their respective owners and are used here only to describe the data source.*

# Changelog

This Actor's version history is a separate document: https://apify.com/logiover/wellfound-scraper/changelog.md

# Actor input Schema

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

Job roles in plain words, e.g. "software engineer", "product manager", "data scientist", "sales", "full stack developer", "ux designer". Common spellings and abbreviations are mapped to Wellfound's role pages (swe, pm, ml engineer, frontend, devops …). Every role is searched in every location. Enter "all" to search every role page Wellfound has (10,000+ jobs per run). Leave empty to list all jobs in the locations.

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

Cities, states or countries as Wellfound writes them, e.g. "new york", "san francisco", "london", "berlin", "bangalore", "united states", or "remote" for remote jobs. NYC, SF, LA, DC, UK, USA and similar shortcuts are understood. Leave empty to search the role everywhere.

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

Optional. Paste Wellfound pages directly: search pages (wellfound.com/role/l/software-engineer/new-york, /role/r/designer, /location/london, /remote), job pages (wellfound.com/jobs/123-title) or company pages (wellfound.com/company/notion — exports all its open jobs).

## `mode` (type: `string`):

Jobs mode gives one row per job. Companies mode gives one row per startup that is hiring for your search — the list for sales prospecting and deal flow — with its matching jobs summarised.

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

Stop after this many unique jobs (or companies in Companies mode). 0 means no limit. The limit is shared fairly between your role × location searches.

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

Keep only jobs that went live in the last N days, e.g. 1 for a daily scheduled run, 7 for a weekly one. 0 keeps every open job.

## `jobType` (type: `string`):

Keep only this kind of job.

## `withSalaryOnly` (type: `boolean`):

Skip jobs without a published salary range — useful for salary benchmarking.

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

Adds visa sponsorship, relocation, skills, remote policy, countries the job hires remotely in, hiring contact, industry and exact salary currency/period — plus the company's website, HQ, industries, total raised, latest round and founders. One extra page per job: about 2-3× slower.

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

Adds each company's website, headquarters, company type, industries, total raised, number of rounds, latest round (type, date, amount), founders with profile links and the companies its team came from. Read from one job page per company, so it stays fast.

## `includeCompanyLinks` (type: `boolean`):

Adds LinkedIn, X/Twitter, Facebook, blog and Product Hunt URLs, the company description, markets, office locations and the number of open jobs. Wellfound serves company pages only through Apify's unblocking proxy, which takes 10-40 s per company — expect slower runs.

## `allCompanyJobs` (type: `boolean`):

Search pages show up to 3 matching jobs per startup. Turn this on to also export every other open job of each startup found (from its company page, up to 400 per company). Includes the company links above. Slower: uses the unblocking proxy.

## `maxPagesPerSearch` (type: `integer`):

Cap on result pages (20 startups, ~40 jobs each) per role × location search. 0 means every page Wellfound has.

## `concurrency` (type: `integer`):

How many Wellfound pages to load at once. Slow pages are re-requested automatically (hedged), and the run stops the moment Max results is reached.

## `proxyConfiguration` (type: `object`):

Keep the RESIDENTIAL group: Wellfound refuses datacenter IPs. Company pages (links / all company jobs) automatically use Apify's UNBLOCKER group.

## Actor input object example

```json
{
  "roles": [
    "software engineer"
  ],
  "locations": [
    "remote"
  ],
  "startUrls": [],
  "mode": "jobs",
  "maxItems": 100,
  "postedWithinDays": 0,
  "jobType": "any",
  "withSalaryOnly": false,
  "includeJobDetails": false,
  "includeCompanyDetails": false,
  "includeCompanyLinks": false,
  "allCompanyJobs": false,
  "maxPagesPerSearch": 0,
  "concurrency": 32,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

All jobs or companies collected in this run.

# 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"
    ],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/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": ["remote"],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/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": [
    "remote"
  ],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call logiover/wellfound-scraper --silent --output-dataset

```

## MCP server setup

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