DEV Community

Cover image for How to Pull Remote Startup Jobs With Salary and Equity in 2026 (Python + a jobs API)
Truffle Pig Data
Truffle Pig Data

Posted on

How to Pull Remote Startup Jobs With Salary and Equity in 2026 (Python + a jobs API)

#career #python #webscraping #tutorial

Pulling remote startup jobs with real salary and equity numbers attached is harder than it should be. Wellfound, the site formerly known as AngelList Talent, is one of the few places where companies publish both right on the posting, which is why I went there to answer what sounded like a simple question: what does a seed-stage startup actually pay a backend engineer?

Reading a few hundred postings by hand is not a research method. So here is the manual approach, where it falls over, and the jobs API I use instead.

Disclosure: the Apify links in this post are affiliate links. If you run the Actor, I may earn a referral commission at no extra cost to you.

What the API returns

The Wellfound Jobs API returns startup job listings as structured JSON, with the posted compensation parsed into separate salary and equity numbers.

Most job feeds hand you a string like $135k - $165k * 0.05% - 0.15% and wish you luck. This one gives you that string and the parsed numbers next to it:

Field Example Notes
compensationRaw $135k – $165k • 0.05% – 0.15% exactly as posted
salaryMin / salaryMax 135000 / 165000 parsed, null when unpublished
equityMin / equityMax 0.05 / 0.15 percent, null when unpublished
company.ycFunded true Y Combinator flag
company.stage early_stage funding stage
remoteKind REMOTE_ONLY remote arrangement
description full markdown the whole posting

You also get title, url, locationNames, acceptedRemoteLocationNames, jobType, yearsExperienceMin/Max, postedAt, and a company object with size, tagline, and the topInvestors and activelyHiring flags.

Who this is for

  • You are building a job board or an aggregator and want early-stage roles that the big feeds miss.
  • You are weighing an offer and want a defensible comp range instead of a vibe.
  • You are a founder setting a band and have nothing to compare against.

The DIY path, and where it breaks

Wellfound is a Next.js app, so the listing data is sitting in the __NEXT_DATA__ blob rather than the HTML. You can get surprisingly far with requests and a JSON walk:

import json, re, requests

html = requests.get("https://wellfound.com/role/r/software-engineer").text
blob = json.loads(re.search(r'__NEXT_DATA__[^>]*>(.*?)</script>', html, re.S).group(1))
apollo = blob["props"]["pageProps"]["apolloState"]["data"]
jobs = [v for v in apollo.values() if v.get("__typename") == "JobListingSearchResult"]
print(len(jobs), "jobs on page 1")
Enter fullscreen mode Exit fullscreen mode

Three things break this, in the order you hit them:

  1. The compensation is one string. $135k – $165k • 0.05% – 0.15% has to be split into four numbers, and the format varies. Salary only, equity only, hourly, "competitive".
  2. Role slugs are not free text. /role/software is a 404. Only /role/software-engineer exists. You need the real slug list before you can query anything.
  3. The page shapes differ. The role pages use JobListingSearchResult, but the site-wide feed uses a completely different typename with a different nesting. Parse one and the other silently returns nothing.

None of that is unsolvable. It is just a parser you now own forever.

The shortcut: run it as an API

The Wellfound Jobs API handles the parsing, the slug mapping, and both page shapes. Three ways in.

Console. Open the Actor page, click Try for free, set a role, and run it.

REST. Any HTTP client, using the Apify run-sync endpoint:

curl -X POST "https://api.apify.com/v2/acts/johnvc~wellfound-jobs-api/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"roles":["software-engineer"],"remoteOnly":true,"maxItems":25}'
Enter fullscreen mode Exit fullscreen mode

MCP. It runs as a tool for Claude and other MCP clients. Point your config at:

https://mcp.apify.com/?tools=actors,docs,johnvc/wellfound-jobs-api
Enter fullscreen mode Exit fullscreen mode

Then ask in plain language: "find remote startup jobs for a senior backend engineer paying over 160k, and tell me which companies are YC backed." Setup docs are in the Apify MCP guide.

Find remote startup jobs

The one I reach for most. remoteOnly filters to listings that actually accept remote applicants, and acceptedRemoteLocationNames on each row tells you where they accept them from, which is the part that usually disqualifies you.

{"roles": ["software-engineer"], "remoteOnly": true, "minSalary": 150000, "maxItems": 50}
Enter fullscreen mode Exit fullscreen mode

Ready to run: Find Remote Startup Jobs.

Find Y Combinator startup jobs

ycOnly narrows to YC-backed companies, which is the filter I have not found anywhere else. Pair it with companyStage so you are comparing seed against seed rather than seed against Series C.

{"roles": ["software-engineer"], "ycOnly": true, "includeDescription": false, "maxItems": 150}
Enter fullscreen mode Exit fullscreen mode

Ready to run: Find Y Combinator Startup Jobs.

Startup jobs in San Francisco

locations takes city slugs and pairs with any role. Each role and city combination becomes its own search, so three roles across four cities is twelve searches, not seven. Watch maxItems accordingly.

{"roles": ["product-manager"], "locations": ["san-francisco"], "maxItems": 50}
Enter fullscreen mode Exit fullscreen mode

Ready to run: Find Startup Jobs in San Francisco.

Startup jobs in New York

Same shape, different slug. Worth running separately rather than together, because the comp distributions are genuinely different and averaging across cities hides that.

{"roles": ["data-scientist"], "locations": ["new-york"], "minSalary": 140000, "maxItems": 50}
Enter fullscreen mode Exit fullscreen mode

Ready to run: Find Startup Jobs in New York.

Startup jobs in London

Non-US cities work the same way. Check salaryCurrency on the rows before you compare anything, because a London posting quoting GBP next to a SF posting quoting USD is not a comparison.

{"roles": ["backend-engineer"], "locations": ["london"], "maxItems": 50}
Enter fullscreen mode Exit fullscreen mode

Ready to run: Find Startup Jobs in London.

Get startup salary and equity data

The comp use case, with descriptions off because nobody averages prose. Drop the rows where the field is null before you compute anything, and report how many survived.

rows = [r for r in items if r.get("result_type") == "job"]
with_salary = [r for r in rows if r.get("salaryMin") is not None]
with_equity = [r for r in rows if r.get("equityMin") is not None]
print(f"{len(with_salary)}/{len(rows)} published salary, {len(with_equity)}/{len(rows)} published equity")
Enter fullscreen mode Exit fullscreen mode

On a 30-row YC sample I ran while writing this, 28 published a salary and only 5 published equity. Those are different sample sizes and deserve separate sentences.

Ready to run: Get Startup Salary and Equity Data.

The example repo

GitHub logo johnisanerd / Apify-Wellfound-Jobs-API

Startup jobs API example: pull Wellfound (AngelList) jobs with parsed salary, equity, remote status and YC signals. Python + uv quick start and MCP setup.

💼 Wellfound Jobs API: A Startup Jobs API for Salary and Equity Data

A startup jobs API for Wellfound (formerly AngelList Talent). Search by role, location, and remote status, and get one clean JSON row per job: the full description, parsed salary and equity ranges, and the hiring startup's signals including Y Combinator backing, top investors, and funding stage.

Actor: https://apify.com/johnvc/wellfound-jobs-api?fpr=9n7kx3

Video Walkthrough

Watch the walkthrough

Text walkthrough

This jobs API turns Wellfound's public startup listings into structured data. You give it roles (Wellfound slugs like software-engineer, or plain words like "software" and "pm", which are mapped for you) and optionally locations such as san-francisco, new-york, or london. Each role and location pair becomes its own search, and the API walks the paginated results for you.

Every row comes back with title, url, the full markdown description, and compensation parsed into real numbers: salaryMin, salaryMax…


View on GitHub


Python quick start plus MCP setup walkthroughs for Claude Code, Cursor, and ChatGPT.

FAQ about scraping Wellfound jobs

Should I build my own Wellfound scraper or use an API?

Build it if the parser is the interesting part of your problem. Use the API if the data is. The three breakages above are the ones you will spend your time on, and they change without warning.

Can I use this jobs scraper from Claude or another AI agent?

Yes. It runs as an MCP tool at https://mcp.apify.com/?tools=actors,docs,johnvc/wellfound-jobs-api. There are also two open agent skills built on it, linked below.

Can I schedule this scraper to run automatically?

Yes, through Apify Schedules, on any cron you like. Dedupe on url, which is canonical and survives a company editing the job title.

Does the scraper return salary and equity for every job?

No, and this is the honest limitation that matters most. It returns what the company published. Plenty of postings carry neither. Always report your coverage count alongside any figure you quote.

Can the scraper search Wellfound by keyword?

Not site-wide, because Wellfound does not serve a site-wide free-text search. keyword filters the jobs on the pages a run already fetched. Drive the search with roles and locations and use keyword to narrow further.

More from Truffle Pig Data

Two open agent skills wrap this API around ready-made workflows, both installable with npx skills add:

Wrapping up

If you want the parser, the code above is a fine starting point. If you want the data, the Wellfound Jobs API bills per job returned with no start fee, so a run that matches nothing costs essentially nothing.

Top comments (0)