I run a visa agency in Bali, and half of my clients are remote engineers who want to know one thing before they move: what does a startup job actually pay, and is there equity in it. Wellfound (the board that used to be AngelList Talent) is the obvious place to look, because its whole pitch is that the salary and the equity range sit on the card, next to the company's stage.

So I built a scraper for it and, a few weeks in, finally sat down with one plain search — remote software engineer, first 40 jobs, pulled on 22 November 2026 — to check how much of that pitch shows up in the data. The answer depends almost entirely on one field most people would drop as noise: atsSource.

Where the data actually lives

Wellfound's public listing pages are Next.js. Each one ships the whole search result as JSON inside <script id="__NEXT_DATA__">, as an Apollo cache: job listings, startups, and references between them. You do not need a browser or a login to read it — one HTTP request per page, about 45 jobs per page, and the full job description is already in there.

The remote listing for software engineers (/role/r/software-engineer) reported 1,813 jobs at 900 startups across 45 pages that evening.

What you cannot read cheaply is anything deeper. Company pages and individual job pages sit behind a bot check: a 403 with "Security Check" in the first couple of kilobytes. So everything below — and everything my Actor returns — comes from listing pages only. That rules out founder names and funding rounds, and I would rather say so than pretend otherwise.

Two kinds of job behind one card

Every listing carries an atsSource. On my 40 rows it took three values:

atsSource Jobs
Ashby 18
Greenhouse 8
empty (posted on Wellfound directly) 14

So 26 of 40 — 65% — were not written on Wellfound at all. They were pulled in from the company's applicant tracking system. On the card they look identical. In the data they are not:

Field ATS imports (26) Native posts (14)
salary range present 25 10
equity range as numbers 1 6
explicit "No equity" 0 4
yearsExperienceMin 2 14
remoteConfig filled 6 14
median lower salary bound $162k $70k

Read that table as two datasets that happen to share column names.

Equity is a native-post feature. Only one imported job out of 26 carried an equity range (an embedded-systems role at 0.005%–0.01%). On the native side, 6 of 14 had numbers and 4 more said, in words, "No equity". In other words, the thing Wellfound is known for is only reliably present on jobs that someone typed into Wellfound's own form, because that form asks for it. An Ashby feed has no equity field to sync.

Experience and remote policy too. yearsExperienceMin was filled on all 14 native posts and on 2 imports. remoteConfig (REMOTE, ONSITE_OR_REMOTE, ONSITE) was filled on every native post and on 6 imports; the other 20 imports were in the remote listing with remote: true but no policy value at all.

And the salaries live in different worlds. The imported jobs were mostly from big, late-stage companies — 12 "Scale Stage", 3 "Public Stage", sizes up to 501–1000 — with a median lower bound of $162k. The native posts were small early-stage teams (7 of 14 "Early Stage", several with 1–10 or 11–50 people), median lower bound $70k, and three of them were the same company posting the same role three times with country-specific pay: $30k – $40k (USA only), $20k – $30k (UK only), $20k – $30k (India only).

If you average salaryMin across the whole search, you are averaging a Series D company's Greenhouse feed with a five-person team's hand-typed post. Split by atsSource first.

The bug that sat in my own parser

Wellfound gives compensation as a single human string, and I split it into numbers:

"$170k – $250k • 0.5% – 1.0%" → salaryMin 170000, salaryMax 250000, equityMinPct 0.5, equityMaxPct 1.0 "1.0% – 2.0%" → no salary, equity 1–2% "$110k – $140k • No equity" → salary, and... hasEquity? 

My hasEquity was true if the string had a percent sign or matched /equity/i. You can guess what "No equity" matched. All four "No equity" rows in this sample came back with hasEquity: true. I found it while building the table above, fixed it the same evening (the flag now ignores an explicit "No equity"), and re-ran the same search on the old and new build side by side: the only field that changed on matching job IDs was hasEquity on exactly those four rows. If you scraped Wellfound before and filtered on a boolean like this, check it against the raw string once.

The lesson I keep re-learning: when a site gives you prose, keep the prose next to the numbers you derive from it. The compensation column stays in every row for exactly that reason.

Dates: the listing is not sorted by freshness

postedAt comes straight from Wellfound. In a 40-job pull, 10 were posted in the last week, most were from October–November — and two were dated 25 April 2022, both from the same early-stage company, both still live in the remote listing with equity ranges. Imported jobs carry the ATS's own date, which can be months old (one Greenhouse import was from April 2026).

So "first 40 jobs" is not "40 newest jobs". If you want a daily feed, keep the job id (stable across runs) and diff against yesterday, rather than trusting page order.

Roles and cities must use Wellfound's own words

The listing URLs are built from slugs: /role/l/<role>/<city>, /role/r/<role> for remote, /location/<city>. A role Wellfound doesn't know does not return an empty page — it redirects. Two examples I hit:

  • frontend developer redirects away; frontend engineer has more than a thousand jobs. Most engineering roles exist under only one of the two spellings.
  • A misspelled city redirects to the role's generic page, which would silently give you the wrong geography if you followed the redirect.

My Actor does not follow redirects. It tries the engineer/developer twin once, and if that also fails it writes one free notice row naming which part (role or city) Wellfound doesn't recognise. Cheaper than discovering a week later that "remote" data was global data.

Calling it

The Actor is Wellfound Jobs Scraper. Input:

{ "roles": ["software engineer"], "locations": ["remote"], "maxJobsPerSearch": 40 } 

From the command line:

curl -X POST "https://api.apify.com/v2/acts/lergassy~wellfound-jobs-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \ -H "Content-Type: application/json" \ -d '{"roles":["software engineer"],"locations":["remote"],"maxJobsPerSearch":40}' 

Two real rows from that run, trimmed — one native, one imported:

{ "title": "Software Engineer", "compensation": "$110k – $140k • No equity", "salaryMin": 110000, "salaryMax": 140000, "hasEquity": false, "equityMinPct": null, "remote": true, "remoteConfig": "REMOTE", "yearsExperienceMin": 2, "atsSource": null, "companyName": "The Prompt Academy", "companySize": "1-10", "companyStage": null, "companyBadges": ["Actively Hiring", "B2C"] } 
{ "title": "Software Engineer", "compensation": "$114k – $148k", "salaryMin": 114000, "salaryMax": 148000, "hasEquity": false, "remote": true, "remoteConfig": null, "yearsExperienceMin": null, "atsSource": "Ashby", "postedAt": "2026-10-12T23:30:14.000Z", "companySize": "501-1000", "companyStage": "Scale Stage", "companyBadges": ["Actively Hiring", "B2C", "B2B", "Scale Stage", "Top Investors", "Valuation $1B+"] } 

And the split I'd do first in Python:

import pandas as pd df = pd.DataFrame(rows) df = df[df["type"] == "job"] # drop the free notice/summary rows df["origin"] = df["atsSource"].fillna("wellfound") print(df.groupby("origin")[["salaryMin", "equityMinPct", "yearsExperienceMin"]].count()) 

Pricing is per job row ($1.50 per 1,000 on the free plan); notice and error rows are free.

When not to use this

  • You need funding rounds, investors or founders. Those are on company pages behind the bot check. Listing pages give you size, stage, tagline and badges like "YC Funded" or "Valuation $1B+", and that's it.
  • You want keyword search inside descriptions. Wellfound searches by role and city, not free text. Pull the role and filter description yourself.
  • You want an equity benchmark across the market. With 1 of 26 imported jobs carrying equity, any "average startup equity" you compute is the average of companies that chose to post natively. That's a real population, but it is not "startups".
  • You only care about large companies. If most of what you need is Ashby or Greenhouse imports, reading those boards directly gets you the same jobs with the ATS's full fields.

For my own use — telling a client which remote roles pay in dollars and whether there's equity attached — the useful filter turned out to be atsSource IS NULL. Fourteen jobs out of forty, but they are the fourteen that answer the question.