Wellfound (AngelList) Jobs Scraper: Startup Jobs & Salaries

Wellfound Jobs Scraper: startup jobs by role and location

Get startup jobs from Wellfound (formerly AngelList Talent) as structured JSON for $2 per 1,000 jobs ($0.002 per job, no start fee). Pick roles and locations, and this Wellfound jobs scraper reads Wellfound's public role and location pages and returns one record per job: title, startup (with size, pitch and badges such as Actively Hiring or YC Funded), locations and country codes, remote policy, pay range as numbers, equity, years of experience, posting date, the full description and the job link.

Records use the same schema as our Career Site Jobs API, so startup jobs and company career-site jobs can share one dataset. Filter by keywords, countries, remote, employment type and date. In monitor mode a scheduled run returns only the jobs that are new since last time.

It reads the pages Wellfound publishes for search engines (wellfound.com/role/l/<role>/<location> and friends) without logging in: one ordinary request every 1.5 seconds, no proxies, no browser automation. Company pages and the logged-in search are not read.

What you get

One record per job:

• Identity: a stable id (wellfound:companySlug:jobId), Wellfound's jobId and the jobUrl.
• The role: title, primaryRole (Wellfound's role category), employmentType, and yearsExperienceMin / yearsExperienceMax where given.
• The startup: company, companyUrl, companySize ("11-50", "1000-5000", "5000+"), companyTagline, companyBadges and companyLogoUrl.
• Where: location, locations, ISO codes in country and countries, a remote flag, Wellfound's own policy in remoteKind and, for remote roles, acceptedRemoteLocations.
• Pay and equity: salaryMin, salaryMax, salaryCurrency and salaryPeriod parsed from Wellfound's range, the original in salaryText, and the equity part in equityText.
• The posting: descriptionText (optionally descriptionHtml), postedAt and scrapedAt.
• Monitor fields: changeType and firstSeenAt in monitor mode.

A full record looks like this:

{
  "id": "wellfound:humaans-1:2563805",
  "ats": "wellfound",
  "atsName": "Wellfound",
  "source": "wellfound.com",
  "company": "Humaans",
  "companySlug": "humaans-1",
  "jobId": "2563805",
  "title": "Senior Software Engineer (Full Stack)",
  "department": null,
  "team": "Software Engineer",
  "employmentType": "full-time",
  "employmentTypeRaw": "full-time",
  "location": "London",
  "locations": ["London"],
  "country": "GB",
  "countries": ["GB"],
  "remote": true,
  "workplaceType": null,
  "salaryMin": 66000,
  "salaryMax": 80000,
  "salaryCurrency": "USD",
  "salaryPeriod": "year",
  "salaryText": "$66k – $80k • No equity",
  "descriptionText": "About us\n\nHumaans is building the next generation of infrastructure for the workplace…",
  "descriptionHtml": null,
  "jobUrl": "https://wellfound.com/jobs/2563805-senior-software-engineer-full-stack",
  "applyUrl": "https://wellfound.com/jobs/2563805-senior-software-engineer-full-stack",
  "postedAt": "2026-11-04T12:21:51.000Z",
  "updatedAt": null,
  "changeType": null,
  "firstSeenAt": null,
  "input": "software-engineer | london",
  "detectedBy": "search",
  "scrapedAt": "2026-11-07T22:40:00.000Z",
  "companyUrl": "https://wellfound.com/company/humaans-1",
  "companySize": "11-50",
  "companyTagline": "Humaans is the fastest way for companies to onboard and manage employees",
  "companyBadges": ["Actively Hiring", "Top 10% of responders", "Early Stage", "Top Investors", "YC Funded", "Growing fast"],
  "companyLogoUrl": "https://photos.wellfound.com/startups/i/8383274-….jpg",
  "equityText": "No equity",
  "yearsExperienceMin": null,
  "yearsExperienceMax": null,
  "remoteKind": "ONSITE_OR_REMOTE",
  "acceptedRemoteLocations": ["United Kingdom"],
  "primaryRole": "Software Engineer"
}

• id is stable, so you can de-duplicate or upsert, and merge with Career Site Jobs API datasets.
• remoteKind is Wellfound's own policy: REMOTE, ONSITE or ONSITE_OR_REMOTE. remote is true for the first and last, and workplaceType is set only when the policy is one thing.
• salaryMin and salaryMax are yearly figures parsed from Wellfound's range ("$180k – $300k"). salaryText keeps the original, including the equity part, and equityText holds the equity on its own.
• countries are read from the city names. acceptedRemoteLocations lists where a remote role can be done from.
• postedAt is when the listing went live.
• team repeats primaryRole, and department is always empty: both exist so the record matches the shared job schema.
• Descriptions are cut at 20,000 characters.

The dataset has three table views: Overview, Pay and equity and Startups. The run's key-value store also gets an OUTPUT record with one entry per search: the page URL, Wellfound's own job count, pages read, jobs listed, matched and returned, and any role/location combination that has no page.

Quick start

Give roles, locations or both. This input returns up to 50 software-engineering jobs at London startups and costs at most $0.10:

{
  "roles": ["software-engineer"],
  "locations": ["london"],
  "maxResults": 50
}

In Apify Console the form opens with these values already filled in, so you can press Start straight away. When you call the Actor from the API and leave maxResults out, it defaults to 500 jobs.

New engineering roles in London or remote, posted this week, every day:

{
  "roles": ["software-engineer", "backend-engineer"],
  "locations": ["london"],
  "remote": true,
  "postedWithinDays": 7,
  "onlyNew": true,
  "monitorKey": "london-remote-eng"
}

Save the input as a Task, add a daily Schedule, and each run returns only the new jobs.

Input reference

Field	Type	Default	What it does
roles	list of text	none	Wellfound role names or slugs, e.g. software-engineer or Product Manager. Each role is combined with each location.
locations	list of text	none	Cities or countries as Wellfound names them, e.g. london, new-york, united-kingdom.
remote	true/false	false	Also read each role's remote page (/role/r/<role>). Needs at least one role.
urls	list of text	none	Wellfound role or location page URLs, instead of or as well as roles and locations.
keywords	list of text	none	Keep jobs whose title or primary role contains ANY of these.
searchDescriptions	true/false	false	Also match keywords against the description.
excludeKeywords	list of text	none	Drop jobs whose title contains ANY of these.
countries	list of text	none	Keep jobs in ANY of these countries (ISO codes or names), read from the job's locations.
remoteOnly	true/false	false	Keep only jobs Wellfound marks as remote or onsite-or-remote.
employmentTypes	list	none	full-time, part-time, contract, temporary, internship, apprenticeship, other (which includes cofounder posts).
postedWithinDays	number 1-365	none	Keep jobs that went live in this many days.
postedSince	date	none	Keep jobs that went live on or after this date. Overrides postedWithinDays.
includeDescriptions	true/false	true	Include the description as plain text. It comes with the listing, so it costs no extra requests.
includeHtml	true/false	false	Also return the description as HTML with the exact posting date, read from each job's own page (one request per job).
maxPagesPerSearch	number 1-50	5	Pages to read per role/location combination. Each page lists about 20 startups.
maxResults	number 1-20,000	500	Stop the run after this many jobs in total.
onlyNew	true/false	false	Monitor mode: return only jobs that earlier runs have not returned.
monitorKey	text	automatic	A name for the monitor's memory. Without one, each set of searches and filters gets its own.

A run needs at least one role, location or URL, and at most 200 role/location combinations. Invalid input fails at once with a message that lists every problem.

Which pages are read

You give	Page read
a role and a location	wellfound.com/role/l/<role>/<location>
a role and remote: true	wellfound.com/role/r/<role>
a role only	wellfound.com/role/<role> (worldwide)
a location only	wellfound.com/location/<location>

Roles that have pages include software-engineer, frontend-engineer, backend-engineer, full-stack-engineer, mobile-engineer, devops-engineer, data-scientist, data-engineer, machine-learning-engineer, product-manager, designer, product-designer, sales, account-executive, marketing, growth, customer-success, recruiter, operations-manager and finance. Locations are cities (london, new-york, san-francisco, berlin, paris, bangalore…) and countries (united-kingdom, germany, india…). Wellfound's own role and location indexes list them all. A combination without a page is reported in OUTPUT and costs nothing.

Monitor mode: only new startup jobs

With onlyNew on, the Actor remembers the jobs it has returned for this set of searches and filters (or under your monitorKey) in a key-value store called wellfound-jobs-monitor in your account. Each run returns, and charges for, only jobs it has not returned before, and stops paging a search as soon as a page holds nothing new.

Changing roles, locations or filters starts a new memory unless you give the same monitorKey. Date windows and limits are not part of the memory, so a rolling postedWithinDays does not reset it.

Use cases

• Startup hiring signals. Which startups in a city are hiring for which roles, how big they are and what they pay.
• Job boards and newsletters. A daily feed of new startup roles for a role, a city or remote.
• Salary and equity research. Published ranges and equity by role, city and company size.
• Recruiting and sales. Spot growing startups (badges, open roles) early.
• AI agents. A small, predictable JSON schema that an agent can call as a tool through Apify's MCP server.

Pricing

$0.002 per job returned, which is $2 per 1,000 jobs. There is no start fee and no monthly rental.

You pay for each job the Actor returns. You pay nothing for jobs that your filters drop, for jobs already returned in monitor mode, or for role/location pages that do not exist. Descriptions cost nothing extra.

What you run	Jobs returned	Cost
The pre-filled first run	50	$0.10
One role in one city, all 5 pages	about 200	about $0.40
The default API limit	500	$1.00
Ten roles in three cities	up to about 6,000	up to about $12.00
A daily monitor of six searches that finds 25 new jobs a day	about 750 a month	about $1.50 a month

To cap spending, set Max cost per run in the run options, or lower maxResults. The Actor stops cleanly at the limit and says so in its status message.

Use it from the API

Run the Actor and get the jobs back in one request:

curl -X POST "https://api.apify.com/v2/acts/localwire~wellfound-jobs/run-sync-get-dataset-items" \
  -H "Authorization: Bearer <YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"roles": ["data-scientist"], "locations": ["berlin"], "maxPagesPerSearch": 2, "maxResults": 50}'

That endpoint waits up to five minutes. For a long run, such as many combinations or includeHtml, start it with POST /v2/acts/localwire~wellfound-jobs/runs and read the run's dataset when it has finished.

With the Apify client for JavaScript:

import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor("localwire/wellfound-jobs").call({
  roles: ["product-manager"],
  locations: ["new-york", "san-francisco"],
  maxResults: 200,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();

With the Apify client for Python:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("localwire/wellfound-jobs").call(run_input={
    "roles": ["backend-engineer"],
    "remote": True,
    "remoteOnly": True,
    "maxResults": 100,
})
jobs = list(client.dataset(run["defaultDatasetId"]).iterate_items())

Results can be downloaded from the dataset as JSON, CSV, Excel, XML or JSON Lines.

Use it from an AI agent (MCP)

Apify's hosted MCP server is at https://mcp.apify.com. Add it to any MCP client that supports remote servers and sign in with your Apify account when the browser opens (or send an Authorization: Bearer <APIFY_TOKEN> header).

To give the agent only this Actor as a tool, use this server URL:

https://mcp.apify.com?tools=localwire/wellfound-jobs

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=localwire/wellfound-jobs"
    }
  }
}

The agent then sees the Actor's input fields with their descriptions and defaults. It needs to send roles, locations or urls, using Wellfound's slugs (software-engineer, london). Tell it to set maxResults (for example 50), because the default is 500 jobs. Questions that work well:

• "Which London startups are hiring backend engineers, and what salary ranges do they publish?"
• "Find remote product-manager roles at startups with fewer than 50 people."
• "What equity do early-stage startups in Berlin offer data scientists?"

Integrations

Runs can be started on a schedule or by another system, and results can be sent on:

• Make, n8n and Zapier have Apify integrations that run an Actor and pass its dataset to the next step, for example to a spreadsheet, a CRM, email or a chat channel.
• Webhooks call your endpoint when a run succeeds or fails.
• LangChain and other agent frameworks can use Apify Actors as tools.
• The Apify API and the JavaScript and Python clients cover everything else.

FAQ

Is there a Wellfound API for jobs?

We know of no public Wellfound jobs API. Wellfound does publish role and location pages that anyone can open without an account, and this Actor reads those and returns the jobs on them as structured data.

How do I scrape startup jobs from Wellfound?

Put a role in roles and a city in locations, written the way Wellfound writes them in its page addresses (software-engineer, london), and start the run. Each job listed on the matching Wellfound page becomes one record.

Is this an AngelList jobs scraper?

Yes. AngelList Talent was renamed Wellfound, and the jobs that used to be on angel.co are on wellfound.com. Old angel.co role and location links are accepted in urls.

Does it return salary and equity?

Where the startup published them. The pay range is parsed into salaryMin, salaryMax and salaryCurrency as yearly figures, and equity is kept as text in equityText ("0.1% – 0.5%", "No equity"). Jobs without a published range have empty salary fields.

Can I filter Wellfound jobs by salary?

There is no salary filter in the input. Run the search, then filter the dataset on salaryMin or salaryMax, which are plain numbers.

Can I get every job at one startup?

No. Company pages sit behind Wellfound's security check and the Actor never requests them. You get the jobs each startup has highlighted on the role and location pages, which for a startup with many openings may not be all of them.

How do I get only new startup jobs each day?

Turn on onlyNew and schedule the Actor daily. Each run returns, and charges for, only jobs it has not returned before.

How many jobs does one search return?

About 35 to 45 per page (roughly 20 startups and their highlighted jobs), and Wellfound shows up to 5 pages per role/location combination, so around 200. Add more roles or locations to cover more.

How much does it cost to scrape 1,000 Wellfound jobs?

$2.00. The price is $0.002 per job returned.

Does it need proxies or a login?

No. It makes plain requests with one ordinary browser User-Agent, and never logs in.

Is it legal to scrape Wellfound?

This is not legal advice. The Actor reads only public job listings and returns company and job data, never applicant, recruiter or founder profiles. You are responsible for how you use the data, including Wellfound's terms and the employers' rights.

Limitations

• What is read. Wellfound's public role and location pages: about 20 startups a page with each startup's highlighted jobs, up to 5 pages per combination as Wellfound shows them.
• What is not read. Company pages (/company/<slug>/jobs), the logged-in job search, and applicant or founder profiles. Those sit behind Wellfound's security check or a login, and the Actor does not try to get past either.
• If Wellfound stops serving pages, the run stops. On an HTTP 403, a 429, a bot challenge or Wellfound's "Security Check" page the Actor waits once and tries one more time. If it is still refused, the run stops, keeps the jobs it already has and says so in the status message. It does not use proxies, rotate headers or solve challenges.
• robots.txt. The Actor reads Wellfound's robots.txt at the start of each run, honours any crawl delay, and lists in the OUTPUT record any requested path that robots.txt disallows.
• Roles and locations must exist as Wellfound pages. The Actor cannot run a free-text search. Use urls for any role or location page you find on the site.
• Pay appears only where the startup published a range. Figures are yearly, and the currency comes from the symbol Wellfound shows.
• Countries come from city names. Unusual places leave country empty, and regions such as "Europe" always do.
• Keywords match anywhere in the title, so java also matches "JavaScript".
• No removed-job tracking. Monitor mode reports new jobs only.

Data, privacy and terms

Job listings are published by startups for anyone to read. This Actor reads Wellfound's public pages only, never logs in, and does not try to get around any access control or rate limit.

It returns company and job data, never applicant, recruiter or founder profiles, and has no fields for people's names or contact details. Email addresses and phone numbers in descriptions are replaced with [email removed] and [phone removed]. Names that a startup wrote into its own description can remain.

You are responsible for how you use the data, including Wellfound's terms and the employers' rights.

This Actor is not affiliated with or endorsed by Wellfound or AngelList.

More from this developer

Jobs:

• Career Site Jobs API: jobs straight from company career sites on Workday, Greenhouse, Lever and eight more platforms, in the same schema.
• Workday Jobs API: every job from a Workday career site.
• Reed.co.uk Jobs Scraper: UK job-board search in the same schema.
• Hacker News API: stories, comments and structured "Who is hiring?" jobs.

Other data:

• Public Tenders API: UK and EU tenders and contract awards.
• Google Trends Trending Now: trending searches for 125 countries.
• App Store Reviews: reviews, app details and top charts.
• Telegram Channel Scraper: posts from public channels.
• ESPN Sports Data and Flashscore Results & Fixtures: scores, standings and fixtures.
• Eventbrite Scraper and Meetup Scraper: events by place and topic.
• Gumtree Scraper: UK classified listings.

Feedback

Found a page that does not work, or need a field we do not return? Open an issue on the Actor's Issues tab and we will reply within a few days.