Wellfound Jobs API

A Wellfound jobs API that searches startup jobs by role, city or remote and returns one row per listing: title, company with its one-line pitch, headcount and Actively Hiring state, the salary range exactly as posted, location, workplace model, remote flag, experience required, posting age, company badges and the listing URL.

By Aldo Morese, founder of QuanticData · Published Aug 21, 2026 · Updated Sep 3, 2026

Get my free API key See the request

$0.001 per delivered job · $2 free every month · Failed runs never billed

POST /v1/scraper/collectors/wellfound_jobs/run

$ curl $QD/wellfound_jobs/run \
    -H "Authorization: Bearer $QD_API_KEY" \
    -d '{"role": "software engineer", "location": "Austin", "max_results": 50}'
{ "status": "done", "count": 50,
  "results": [
    {
      "id": "…",
      "title": "…",
      "company": "…",
      "company_slug": "…" } ],
  "cost": 0.05 }
# 50 jobs × $0.001 · nothing delivered, nothing charged

Wellfound Jobs API: role and location in, a residential exit in the middle, delivered rows with id, title and company on the right, $0.001 per job. — You send role and location; the run goes out through a residential exit and comes back as jobs with id, title and company — 19 fields on every row — and you are billed $0.001 for each job actually delivered, nothing for a run that delivers none.

$0.001 / job2,000 jobs on the free $2 every month

Semantic inputrole, location, remote — no URL lists

Up to 300jobs per run, pagination handled for you

No browserread over HTTP/TLS — cheaper and faster than rendering

Try it

Wellfound startup jobs, running now

Change the input and run it against the live collector — nothing to install, no sign-up.

Run it from your own code, on your own inputs

Same collector, same rows — $2 of free API credit every month, no card.

Get my free API key

What a Wellfound jobs API does

Wellfound is a Next.js site and every search page ships an embedded Apollo cache with the job and company entities you would want. It is also, on some renders, incomplete: on one city page the cache materialised only the first seven of twenty companies — sixteen job entities against forty-four rows the same HTML rendered — while another city page the same day materialised all twenty. A source that silently drops two thirds of the page on an unpredictable subset of renders cannot be the contract, so the rows are read from the server-rendered markup, which renders every row every time. Where both were populated they agreed on every field checked across 39 rows, so the DOM is not a lossy fallback here; it is the same data, complete.

The markup’s class names are utilities that churn, and nothing keys on them. The anchors are a URL contract — the job link carrying the numeric id rows are deduplicated on — a test hook Wellfound maintains deliberately for each company block, and structure: cards and rows are found by containment, and the three meta chips are told apart by what they say, never by position. The cache is still read for the two page-level facts it always carries — the resolved role and location, and the result totals used for pagination notes.

Limits, in plain numbers

Everything that bounds one run of this collector. No hidden throttles.

Max per run

300 jobs

Price

$0.001 / job

Per 1,000

$1.00

Failed runs

Free zero rows, zero charge

Free every month

$2 no card

Rate limit

60 req/min on the free tier

What one job looks like

Every delivered job carries these fields. Nullable means the source did not publish it — the field stays empty instead of being guessed.

Field	Type	What it holds
`id`	string	Wellfound job listing id — stable, and the de-duplication key.
`title`	string	Job title as the listing states it.
`company`	string · nullable	Company name.
`company_slug`	string · nullable	Company handle in Wellfound URLs.
`company_description`	string · nullable	The company's one-line pitch.
`company_size`	string · nullable	Headcount band as shown, e.g. "501-1000", "5000+".
`actively_hiring`	boolean	True when the card carries Wellfound's "Actively Hiring" marker.
`salary`	string · nullable	Compensation exactly as posted, e.g. "$150k – $215k" or "$85k – $105k • No equity". Null when the listing states none.
`location`	string · nullable	Primary location, e.g. "Austin", "Everywhere".
`extra_locations`	integer · nullable	Additional locations the listing accepts, from its "+N" chip. Null when it shows none.
`workplace`	string · nullable	Workplace model as labelled: "In office", "Remote", "Remote only", "Onsite or remote". Null when unlabelled.
`remote`	boolean	True when the workplace model allows remote work.
`job_type`	string · nullable	Employment type, e.g. "Full-time".
`experience`	string · nullable	Required experience as shown, e.g. "5 years of exp". Null when unstated.
`posted`	string · nullable	Posting age as shown, e.g. "yesterday", "3 weeks ago".
`tags`	string[]	Company badges the card renders, e.g. "B2B", "Scale Stage", "Top Investors".
`tags_hidden`	integer · nullable	Badges collapsed behind the card's "+N" chip. Null when none were collapsed.
`url`	string	Listing URL on wellfound.com.
`company_url`	string · nullable	Company profile URL on wellfound.com.

Inputs

The whole request. Anything you leave out falls back to the default shown in the catalog.

Input	Type	Required	What it does
`role`	string	yes	Job family, e.g. "software engineer", "product manager", "data engineer". Matched against Wellfound's own role pages — a role it does not publish is reported rather than silently widened.
`location`	string	no	City, state or country, e.g. "Austin", "New York", "United States". Omit to search every location.
`remote`	boolean	no	Search Wellfound's remote listings for the role. Ignored when a location is given — Wellfound has no remote page scoped to a city; read the per-row remote field instead.
`country`	string	no	ISO 3166-1 alpha-2 code — proxy exit geo and Google locale (gl). Omit for the default pool.
`max_results`	integer	no	How many jobs to deliver at most (1–300). You pay only for delivered jobs.

Pricing

Wellfound Jobs API pricing

$0.001 per delivered job. A run that delivers nothing costs nothing: blocked pages, challenges and retries are on us, and the $2 monthly allowance covers about 2,000 jobs before you spend anything.

$0.001per delivered job$1 per 1,000 delivered jobs

2,000 jobson the free allowance$2 every month, no card

Zero rowszero chargeblocks, captchas and retries are on us

−30%on volume tiersthe catalog returns your key's price

Pay as you go

$0/mo

$2 free credit / month
60 requests / min
List unit prices

Starter

$19/mo

$15 free credit / month
300 requests / min
10% off unit prices

Growth

$79/mo

$50 free credit / month
600 requests / min
20% off unit prices

Scale

$299/mo

$250 free credit / month
1,200 requests / min
30% off unit prices

Same wallet, same key and same $2 monthly allowance as every other Data API. Prices are launch pricing read live from the billing config — GET /v1/scraper/collectors returns the price your key actually pays.

Integration

One POST, typed rows

Base URL https://api.quanticdata.io/v1, Bearer auth, the same key as every other Data API. Endpoint: POST /v1/scraper/collectors/wellfound_jobs/run.

curl -X POST https://api.quanticdata.io/v1/scraper/collectors/wellfound_jobs/run \
  -H "Authorization: Bearer $QD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"role":"software engineer","location":"Austin","max_results":50}'

import requests

r = requests.post(
    "https://api.quanticdata.io/v1/scraper/collectors/wellfound_jobs/run",
    headers={"Authorization": f"Bearer {QD_API_KEY}"},
    json={
        "role": "software engineer",
        "location": "Austin",
        "max_results": 50
    },
    timeout=120,
)
for row in r.json()["payload"]["results"]:
    print(row)

const res = await fetch(
  "https://api.quanticdata.io/v1/scraper/collectors/wellfound_jobs/run",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.QD_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"role":"software engineer","location":"Austin","max_results":50}),
  },
);
const { payload } = await res.json();
console.table(payload.results);

claude mcp add quanticdata \
  -e QUANTICDATA_API_KEY=qd_live_your_key_here \
  -- npx -y quanticdata-mcp

# then, in the chat:
> run the wellfound_jobs collector with role="software engineer" and location="Austin"

What people build with the Wellfound jobs API

Three shapes of work this endpoint was designed around.

Startup hiring signals

Which companies are Actively Hiring for a role in a city, with headcount and pitch — a sourcing list for sales or recruiting.

Compensation research

Salary ranges as posted, including equity where Wellfound states it, across roles and locations.

Remote-work mapping

Workplace model and remote flag per listing, filtered by remote at query time.

Wellfound Jobs API versus rolling your own

The differences that actually cost time when you build this in-house.

	DIY scraper	This collector
Source	The embedded cache — two thirds of the rows missing on some renders	The rendered rows, complete every time, verified against the cache
Anchors	Utility class names	The job URL, a maintained test hook, and structure
Salary	A parsed number that loses the equity part	Exactly as posted
Identity	Title plus company text	The numeric job id from the URL

What people search for

Live autocomplete demand around Wellfound startup jobs, pulled with our own Keyword ideas collector.

Wellfound Jobs API: the POST to /v1/scraper/collectors/wellfound_jobs/run with role and location on the left, and the JSON envelope on the right with 50 jobs and usage.cost_usd $0.05. — The same call you would paste into a terminal: a Bearer key, role, location and remote in the body, and back the envelope every QuanticData endpoint returns — type, message, payload — where count is how many jobs arrived and usage.cost_usd is $0.05, which is 50 × $0.001. A run that delivers nothing costs nothing. The key is good for 60 req/min on the free tier.

Sources and standards

The platform documentation and standards this collector is built against — check any claim on this page against the primary source:

FAQ

Questions we get about the Wellfound jobs API.

Something else? Ask us →

Why not read the embedded JSON?

Because it is sometimes incomplete — on one measured page it held 16 job entities against 44 rendered rows — and it fails silently. The rendered rows carry every job, and they were cross-checked against the cache wherever it was complete.

How is salary delivered?

Exactly as Wellfound states it, including equity ranges when present. Parsing it to a single number would throw away the part that makes startup compensation different.

Can I search remote-only?

Yes: set remote to true, with or without a location. The row also states the workplace model.

Does Wellfound have an API?

Not a public jobs API. This reads the public role and location landing pages.

Is there a free Wellfound jobs API?

Every account gets $2 of credit every month with no card, which is about 2,000 delivered jobs on this endpoint at $0.001 each. It renews monthly, and a run that delivers nothing is never billed — so a failed or blocked attempt does not eat the allowance.

How much does one run cost?

Multiply the rows you actually receive by $0.001. A run capped at 300 jobs — the maximum for this collector — costs $0.3 if every row comes back, and less when the source has fewer. Volume tiers take up to 30% off, and GET /v1/scraper/collectors returns the price your key actually pays.

Run the Wellfound jobs API now

$2 of free credit every month, no card. Your key returns its own prices from GET /v1/scraper/collectors.

Get my free API key