Wellfound Startup Jobs Scraper & Hiring Signals

Pain points

• Wellfound publishes no API, so every job has to be read out of the page's embedded application cache rather than requested.
• That cache is nested one level deeper than it looks — pageProps.apolloState holds a single 'data' key, and reading the level above it returns one useless entry that looks exactly like an empty result.
• Jobs and companies are stored as separate normalised entries linked by reference, so a scraper that does not resolve those links returns jobs with no employer attached.
• Wellfound keeps three different search indexes — role, city, and role-plus-city — and they answer very different questions: 'data scientist' nationwide is 4,981 jobs where 'data scientist in San Francisco' is 396.
• Typing 'remote' as the location silently redirects to the nationwide role page, so the run answers a far broader question than the one that was asked, and nothing in the response says so.
• Pay is published as one display string ('$150k – $176k • No equity'), so it cannot be sorted or filtered on until someone parses it.
• Wellfound serves at most 15 pages of search results however many matches it reports, so a total on screen is not a total you can download.

What we solve

• Job, employer, pay, description and hiring badges all come from one fetch per page, because they are all already in the page cache.
• The salary range is parsed into salary_min and salary_max, and left null rather than guessed when the string is not two dollar figures.
• 'remote' as a location is refused with an explanation pointing at the remoteOnly filter, instead of quietly widening the search.
• Every row says which index answered it in matched_by, and echoes the role and city that were requested.
• Wellfound's own stated match count is read and logged, so a capped run can be compared against the source's figure.
• A refusal, a source change and a genuinely empty search each return a distinct free marker row — never zero rows on a successful-looking run.
• The proxy is off by default because measurement says that is the working path: Wellfound answers Apify's plain egress and serves the datacenter proxy pool a Cloudflare 403.

Summary

Ask for a role ('software engineer'), a city ('san francisco') or both, and get one row per job: title, the pay range both as Wellfound displays it and parsed into salary_min/salary_max, job type, years of experience, remote flag, posting date and the complete job description — joined to the startup that posted it, with its size, one-line tagline, logo and hiring badges (actively hiring, quick responder, YC, top investors, valuation). Wellfound ships its entire page cache in the HTML, so the employer half of every row costs no extra request and no extra fee. Roles and cities combine as a product, so three roles across four cities is twelve searches in one run, each with its own result cap. Built for recruiters sourcing startup talent, job boards and aggregators, VC talent teams tracking portfolio hiring, and anyone who needs the rows rather than a dashboard.

Who it's for

• Recruiters and sourcers hiring into startups
• Job boards and aggregators that need structured startup listings
• VC talent teams tracking which portfolio companies are hiring
• Market and compensation researchers building startup pay datasets

How to use

Set the input, run the actor, and collect results from the run's dataset (export to JSON/CSV/Excel, or pull via the Apify API). Example input:

{
  "role": "software engineer",
  "location": "san francisco",
  "maxResults": 100
}

See Inputs below for every available field.

What you get

One row per record:

Field	Description
title	The job title as posted
role	Wellfound's normalised primary role for the posting
job_type	full-time, contract, internship, and so on
compensation	Wellfound's own pay string, e.g. '$150k – $176k • No equity'
salary_min	Low end of the pay range in dollars, parsed; null when the string is not two dollar figures
salary_max	High end of the pay range in dollars, parsed
has_equity	True when equity is offered, false when the posting says none, null when unstated
remote	Wellfound's remote flag for the posting
locations	Every city the job is listed under
remote_locations	Locations the employer accepts remote candidates from
posted_date	Date the listing went live, as an ISO date
description	The complete job description as posted
years_experience_min	Minimum years of experience where the posting states one
company_name	The startup that posted the job
company_size	Wellfound's headcount bucket, e.g. SIZE_501_1000
company_tagline	The company's one-line description of itself
company_logo_url	The company's logo as hosted by Wellfound
company_url	The company's Wellfound profile
hiring_badges	Signals Wellfound awards the company — ACTIVELY_HIRING, QUICK_RESPONDER, YC, TOP_INVESTORS, VALUATION_1B and others
actively_hiring	True when the company carries Wellfound's actively-hiring badge
matched_by	Which index answered — role_and_location, role, location or all_jobs
requested_role	The role that was asked for, echoed back
requested_location	The city that was asked for, echoed back
source_url	The job's own page on Wellfound

Sample:

{
  "source_url": "https://wellfound.com/jobs/4639821-software-engineer",
  "title": "Software Engineer",
  "role": "Software Engineer",
  "job_type": "full-time",
  "compensation": "$150k \u2013 $176k",
  "salary_min": 150000,
  "salary_max": 176000,
  "has_equity": null,
  "remote": false,
  "locations": [
    "Denver",
    "San Francisco"
  ],
  "remote_locations": null,
  "posted_date": "2026-06-23",
  "years_experience_min": null,
  "company_name": "Checkr",
  "company_size": "SIZE_501_1000",
  "company_tagline": "The only background check company using artificial intelligence and machine learning",
  "company_url": "https://wellfound.com/company/checkr",
  "hiring_badges": [
    "ACTIVELY_HIRING",
    "B2B",
    "HIGHLY_RATED",
    "QUICK_RESPONDER",
    "TOP_INVESTORS",
    "VALUATION_1B",
    "YC"
  ],
  "actively_hiring": true,
  "matched_by": "role_and_location",
  "requested_role": "software engineer",
  "requested_location": "san francisco"
}

Inputs

Field	Required	Type	Default	Description
role	no	string	"software engineer"	A job role, e.g. 'software engineer', 'product designer', 'data scientist'. Type it normally — spacing and capitals do not matter. Kept forever alongside 'Roles' because saved tasks and API callers send it.
roles	no	array	[]	Pull several roles in ONE run, e.g. software engineer and product designer. Combined with 'Role' if you fill both. Every role is searched in every location, and 'Maximum results' applies to each role+location pair, so adding one can never truncate the others.
location	no	string	"san francisco"	A city, e.g. 'san francisco', 'new york', 'london'. Leave it out to search the role nationwide. Do NOT type 'remote' — Wellfound redirects that to the nationwide page and silently widens the search; use 'Remote jobs only' below instead.
locations	no	array	[]	Pull several cities in ONE run. Combined with 'Location' if you fill both. Roles and locations combine as a product: 3 roles across 4 cities is 12 searches in one run.
remoteOnly	no	boolean	false	Keep only jobs Wellfound flags as remote. This filters the search results rather than changing the search, because Wellfound has no remote-only index.
maxResults	no	integer	100	Cap on the number of jobs returned PER role+location pair, not per run — so adding a city cannot silently truncate the ones before it. Wellfound serves at most 15 pages of search results (roughly 500-600 jobs) per search whatever total it reports; the run says so on the row when you ask for more than it can reach.
proxyConfiguration	no	object	{"useApifyProxy": false}	Leave OFF. Measured 2026-09-08: Wellfound answers Apify's plain egress normally and serves the datacenter proxy pool a Cloudflare 403, so switching a proxy on is what breaks this actor. Residential also works if your own runs ever start getting refused.

Pricing (Pay Per Event)

You pay per result (job) — no charge for empty runs. Example: 1000 job listings at $0.00175/result ≈ $1.75.

The default input returns up to 100 jobs for one role and city, so a default run costs about $0.18. You are charged per job returned, not per role or city submitted. Apify platform usage (compute) is billed separately per your plan.

Use cases

• Pull every software engineering job in San Francisco with its pay range, and sort by salary_max.
• Track which startups carry the 'actively hiring' badge across a set of roles, week over week.
• Build a compensation dataset for a role across four cities in one run.
• Feed a job board with fresh startup listings that already include the full description.
• Find companies at a given stage or size that are hiring for a role you place.

Why this actor

• $1.75 per 1,000 jobs, against $0.99 to $5 across this category on the Store (2026-09-08).
• The full job description, job type, role title, company size and company tagline are on every row from the base fetch — no enrichment pass, no extra fee.
• Hiring badges (actively hiring, quick responder, YC, top investors, valuation, work-life balance) come through decoded.
• salary_min and salary_max are parsed from Wellfound's display string, so pay is sortable.
• Roles and cities combine in one run, with the result cap applied per pair so adding a city never truncates the others.
• 'remote' as a location is caught rather than silently answered with nationwide results.

Limitations & updates

Wellfound serves at most 15 pages per search, so one search reaches roughly 500-600 jobs regardless of the total it reports. Jobs come from Wellfound's search indexes; a listing that is not surfaced by a role or city search will not appear. Company size is Wellfound's own bucket (SIZE_501_1000), not an exact headcount. Funding stage, total raised, founders and company social profiles are not returned — they are not in the search page's payload. salary_min and salary_max are left null where the pay string is not two dollar amounts, for example equity-only or hourly postings.

FAQ

Why does it return the full job description when other Wellfound scrapers need an extra enrichment step?

Because of where the data is read from, not because of any trick. Wellfound is a Next.js site and every search page embeds its entire Apollo cache in the HTML — the job description, job type, normalised role, the employer's headcount bucket, tagline, logo and badges are all sitting in that blob already. This Actor parses the blob rather than the rendered page, so those fields cost no extra request. Scrapers that read the visible listing cards instead have to fetch each job's detail page to fill them in, which is why they expose it as a separate, extra-cost option. Measured 2026-09-08 against the category leader on the same query: description, job type, role title, company size and company tagline were empty on its default run and populated on all of ours.

Can I search for remote jobs?

Yes — with the 'Remote jobs only' switch, not by typing 'remote' as the location. Wellfound has no remote index: the URL /role/l/

How many jobs can I actually get for one search?

Wellfound serves at most 15 pages of search results per search — roughly 500 to 600 jobs — however many matches it reports on the page. If you ask for more than a search can reach, the run returns everything it can and adds one free row saying so, with Wellfound's own stated total. To go deeper, narrow the search: a role plus a city reaches a different, smaller set than the role alone, and running several cities in one run is the intended way to cover more ground.

Should I turn the proxy on?

No, and switching one on is the most likely way to break a run. Measured from inside an Apify run on 2026-09-08: the container's own address answered 200 with the full page, and Apify's datacenter proxy pool was served a Cloudflare 403 on the same request in the same run. Residential also works but buys nothing today. The input is left available in case your own runs are ever refused, and it defaults to off.

Does it return candidate or applicant data?

No. Everything here comes from public job postings and public company profiles — the job, its pay range, its description, and the hiring company. No candidate profiles, no applicant information and no personal contact details are collected.

What happens when a search returns nothing, or Wellfound refuses the request?

You get a free, unbilled row that says which. A search that genuinely matched nothing returns a 'no_results' marker; a refusal returns 'blocked'; a page whose structure no longer parses returns 'source_changed'. That distinction matters on a jobs feed, because zero rows otherwise reads as 'nobody is hiring' when the real answer may be that the source did not answer.

Which actor to choose

Other Actors that pair with this one:

• Google Ads Transparency Center & Competitor Ad Scraper — You want to see which of these startups are spending on ads, not just hiring.
• Business Email & Phone Contact Details Scraper — You have the hiring companies and now need contact details for outreach.

Works with AI assistants (MCP)

Callable as an MCP tool, so Claude, Cursor, VS Code Copilot and other MCP clients can run it directly. Grab the config from the MCP tab on this page — Apify hosts the server and keeps that snippet current, and OAuth signs you in on first connect, so no API token goes in your config file.

Then just ask:

"Find software engineering jobs in San Francisco on Wellfound paying over $150k, and tell me which of those companies are actively hiring."

Role and location are separate inputs and combine as a product, so several roles across several cities is one run. Do not pass 'remote' as the location — use the remoteOnly flag, or Wellfound answers with nationwide results instead. Runs started this way bill exactly like any other run.