Wellfound Startup Jobs Scraper

Scrape startup job listings from Wellfound.com (formerly AngelList Talent) — title, compensation band, locations, remote flag, posted date, plus the startup's name, logo, slug, company-size band, market tags, headcount, and Wellfound's funding-stage / top-investor / recently-funded / growing-fast signals — denormalized into every row. Paste a /role/ search URL — or just type a keyword and let the actor build one — and get back self-contained flat rows ready for CSV, each carrying the full job description.

Why this actor

Wellfound is the largest English-language startup job board. Most scrapers for it read the /jobs landing page — a curated set of about 50 jobs that returns the same rows no matter what filters you pass — and then charge premium prices for that thin slice.

This actor reads Wellfound's role-search surface instead. A single query like /role/software-engineer reaches about 5,000 jobs across ~90 pages (all locations; /role/r/software-engineer is the remote-only subset, about 1,850), filters by role and location server-side, and returns the full job description on every row — no enrichment step, no extra charge. Rows are de-duplicated by job ID across the whole run, so you are never billed for a repeat.

• Three-stack race fetch — impit (Rust + rustls Firefox), gotScraping (Node + headerGenerator), and impers (libcurl-impersonate Chrome 142). The fastest legit response wins per page, so a single fingerprint hiccup doesn't burn the retry budget
• Apollo-state extraction — one JSON.parse of __NEXT_DATA__ resolves JobListing → Startup → Badge / NewTag / JobListingRemoteConfig refs in-memory. No DOM walking
• Real pagination + de-duplication — role searches page through Wellfound's own reported page count, and every row is de-duplicated by job ID across the run, so you are never billed for a repeat. Free-tier users have a global ceiling of 100 rows
• Proxy handled for you: leave the proxy setting at its default and the actor picks a US residential exit, because Wellfound blocks most datacenter IPs on its search pages. Paying runs go out through a dedicated residential pool.
• One flat row per job — company-level fields are denormalized on every row so CSV consumers don't need to join
• Cheap per row — about $0.0011 per job row (~$1.09 / 1,000 jobs), plus a small per-run start fee. See the Pricing table for the exact events

Company enrichment — funding, founders & socials (opt-in)

When you set enrichCompanyProfile: true, after the listings phase completes the actor runs a second pass over each unique startup in the dataset. Wellfound's company pages sit behind a Cloudflare check that plain HTTP clients never pass, so the actor opens one real browser session on a residential IP, lets the check complete, and then fetches every company page with that session (about 1-2 s per company). It parses the Apollo state and merges these fields into every job row for that company:

Field	What it carries	Example (Airbnb)
companyTotalRaised	Total funding amount in USD (integer)	11333560000 ($11.3 B)
companyFundingRoundsCount	Number of recorded rounds	20
companyLatestRoundType	Most recent round name	"IPO"
companyLatestRoundClosedAt	ISO timestamp of latest round	"2020-11-27T..."
companyFundingRounds[]	Full round history (roundType, closedAt, valuation)	20 rounds back to Series B 2011
companyProductDescription	Long-form product/company bio	Full Airbnb marketing copy
companyWebsiteUrl	Official company URL (not Wellfound)	"http://airbnb.com"
companyTwitterUrl / companyLinkedinUrl / companyFacebookUrl / companyBlogUrl / companyProductHuntUrl	All social URLs	Populated when present
companyIsOperating	Whether Wellfound flags it as operational	true
companyIsIncubator	Whether the profile is an incubator	false
companyIsShell	Wellfound's shell-company flag	false
companyIsYcFunded	Y Combinator funding. Now populated for free on every row from Wellfound's YC_BADGE — no enrichment needed	true
companyProfileCompletenessScore	Wellfound's internal 0-100 completeness	78
companyFounders[]	Founder identities resolved from User refs	[{name: "Joe Gebbia", slug: "joegebbia", ...}, {name: "Brian Chesky", ...}]
enrichmentStatus	'enriched' / 'failed' / null	—
enrichmentAttempts	How many fetch attempts the burst used	7

Extra fields unlocked with enrichment

The /company/{slug} Apollo state embeds the company's recent JobListings with richer fields than the listing-page versions. When company enrichment succeeds, the embedded data fills any of these fields that are still empty on the matching job rows — no extra fetches, no extra charges. Rows from a /role/ search usually have them already; this mostly helps /jobs landing-page rows:

Field	Description	Coverage example (Airbnb)
jobDescriptionSnippet	First ~500 chars of the job description as HTML (the "snippet" Wellfound shows in cards). Partial answer to "full job description" without /jobs/{id}.	10/10 jobs populated
jobType	"full_time" / "contract" / "part_time" / "internship"	10/10
equity	Equity component separately from compensation (e.g. "0.1% – 0.5%")	0/10 (Airbnb's public, no equity offered)
yearsExperienceMin / yearsExperienceMax	Required experience range	10/10
autoPosted	true if the job is auto-syndicated from an ATS	10/10 (Airbnb is auto-posted)
atsSource	Original ATS source ("greenhouse" / "lever" / etc.) when syndicated	0/10 (Airbnb returns null)
recruitingContact	Hiring-manager identity when Wellfound exposes it — { name, slug, avatarUrl, pathName }. Typically populated for manually-posted jobs at smaller startups, null for auto-posted ATS jobs.	0/10 (Airbnb is ATS-auto-posted)

Pricing

Event	When charged	Rate
apify-actor-start	Once per run, ×memory GB	$0.01 per GB
apify-default-dataset-item	Every job row written	$0.00099 ($0.99 / 1k rows)
additional-data	Every job row written	$0.0001 ($0.10 / 1k rows); $0.001 ($1.00 / 1k rows) from 30 Sep 2026
company-enrichment	Per successful company (de-duped — a company with 56 jobs = 1 charge)	$0.0015 per company
job-detail-enrichment	Per successful job-detail fetch	$0.0015 per job

Per row that's $0.00109 (~$1.09 / 1,000 jobs) until 29 September 2026, and $0.00199 (~$1.99 / 1,000 jobs) from 30 September 2026, when additional-data moves to $0.001. Rows dropped by the keyword/job filters are never charged — filtering happens before the write.

Enrichment is opt-in and only billed when it succeeds: a 1,000-row run with enrichCompanyProfile on across ~150 unique companies adds roughly $0.225. Failed enrichments cost nothing.

Enrichment reliability

• enrichCompanyProfile works again (September 2026). Measured across three proxy routes: 12 of 12 companies enriched on each. It needs a residential proxy, which is the default; on a datacenter proxy Wellfound shows an interactive check, so the actor skips company enrichment and says so in the log. A company whose page can't be fetched is marked enrichmentStatus: "failed" and not charged. Not every company lists funding: in testing about 60% had a non-zero companyTotalRaised, all had a website and most had LinkedIn.
• enrichJobDetail is mostly unnecessary. Jobs from a /role/ search already include the full description at no extra cost, and the actor skips the enrichment for those rows. It only does anything for /jobs landing-page rows. Failed enrichments are not charged.

---

Field coverage — what every row carries

Coverage depends on which surface you scrape. On a /role/ search (measured over 300 rows, 2026-08-15): jobTitle, jobDescription, jobType, companyName, companySize, remote and postedAt are 100% populated, companyHighConcept 98%, compensation 83%, companyStage 76%, atsSource 66%, yearsExperienceMin 33%. marketTags and liveJobListingsCount are not exposed on that surface and come back empty.

On the /jobs landing page, Wellfound only attaches the full structured graph to featured listings (~4 of ~50 per page); the rest carry the basic job + company-identity fields and leave funding-stage / market-tags / badges / company-size null.

What this means for you:

Always populated (every row)	Sparse — only on featured rows (~8%)
jobId, jobTitle, jobUrl, jobSlug	companySize, companySizeBand
compensation + parsed min/max/currency/equity	companyHighConcept
locations[], remote, remoteKind, wfhFlexible	liveJobListingsCount
primaryRoleSlug, postedAt, postedAtUnix	marketTags[], locationTags[]
companyId, companyName, companySlug, companyUrl, companyLogoUrl	companyStage, companyStageLabel
recentlyFunded, hasTopInvestors, growingFast, activelyHiring, topResponder, quickResponder (default false for non-featured)	businessType (B2B / B2C)
	allBadgeLabels[]

To get only the rich-featured rows, filter your output for companyStage != null post-run. Across multiple pages the featured set rotates, so paginating to ?page=N reveals progressively more featured startups.

Use cases

• Startup hiring tracker — paginate /jobs?market=ai daily to track which AI startups are hiring fastest, what salary bands they advertise, and which companies hit Wellfound's GROWING_FAST or RECENTLY_FUNDED flags
• Sourcer / recruiter tooling — feed companySlug + companyName into outbound CRMs to build a "currently hiring in {market}" lead list; the compensation band on every row lets you pre-filter by salary tier
• Compensation benchmarking — compensationMin / compensationMax / compensationCurrency / hasEquity are parsed from Wellfound's raw band strings, so you can run quantile analysis without re-parsing
• VC / analyst feeds — featured-row signals (companyStage, recentlyFunded, hasTopInvestors, growingFast) are useful for tracking which startups Wellfound itself flags as venture-backed and growing. Note: investor names + raise amounts aren't published on the listing surface, only the boolean flags
• Remote-job aggregation — remote: true + acceptedRemoteLocations[] lets you filter for region-eligible remote roles
• Daily "new startup jobs" alerts — schedule the same search with incrementalMode: true + a Telegram/Slack webhook and get pinged only about jobs that appeared or changed since the last run — you pay only for the diff

Monitoring & alerts — incremental mode + notifications (opt-in)

Turn the scraper into a scheduled monitor. With incrementalMode: true the actor remembers every job it has seen for your search (per stateKey, stored in your account) and later runs emit only NEW / UPDATED / REAPPEARED records — unchanged jobs are detected but not emitted and not charged. A daily schedule on a stable search typically bills 80–95% less than re-scraping everything.

• Emitted records carry monitorStatus (NEW / UPDATED / REAPPEARED), monitorFirstSeen, monitorLastSeen
• emitUnchanged / emitExpired opt the other two statuses back in (expired records are small tombstones with the job title + URL; each emitted record is charged as a normal result)
• skipReposts: true suppresses listings that vanish and come back under a new job ID with identical content
• maxAgeMinutes keeps only jobs newer than N minutes — pair with a daily schedule (maxAgeMinutes: 1440) for a fresh-jobs feed. Wellfound does not list jobs by date, so each run pages until it finds enough recent jobs (up to 25 pages, or 8 pages in a row with none); a very short window such as 70 minutes mostly pays for pages with nothing new
• The first run builds the baseline (everything is NEW); leave stateKey empty and one is derived from your search inputs automatically

Notifications (work with or without incremental mode): set any of telegramBotToken + telegramChatId, slackWebhookUrl, discordWebhookUrl, or webhookUrl (+ optional webhookHeaders) and each run posts a summary with the top new jobs — straight to your hiring channel, n8n, Make, or Zapier flow. notifyOnlyChanges: true keeps scheduled runs silent unless something actually changed. notificationLimit caps how many jobs are listed per message (the dataset always has everything).

Example scheduled-monitor input

{
  "startUrls": ["https://wellfound.com/jobs?market=ai&location=san-francisco"],
  "maxItems": 300,
  "incrementalMode": true,
  "skipReposts": true,
  "notifyOnlyChanges": true,
  "telegramBotToken": "123456:ABC...",
  "telegramChatId": "@my_hiring_channel"
}

Input

Field	Type	Required	Notes
startUrls	string[]	no	Role search (recommended): /role/{role} (all locations), /role/r/{role} (remote only) or /role/l/{role}/{location} — paginated, server-side filtered, full descriptions. Landing page: /jobs (± ?market/?industry/?location) returns the same ~50 curated jobs regardless of filters. Leave empty and the actor builds role searches from your keyword + location; list several roles with commas (data analyst, data engineer) and each gets its own role search, sharing maxItems between them. A single job (/jobs/{id}) or company page (/company/{slug}) is not a listing and is skipped with a message.
maxItems	integer	no	Maximum job rows emitted per startUrl. 3 listings × maxItems: 200 → up to 600 total rows (200 each). Each row = one paid additional-data. Default 1000. Free-tier users have a hidden global ceiling of 100 rows.
maxConcurrency	integer	no	Parallel HTTP requests across listing URLs. Sweet spot 3–5 via Apify Residential US. Default 4.
maxRequestRetries	integer	no	Retry budget per page. Each retry uses a fresh proxy session (a new exit IP); an occasional retry uses a real browser. A page gets at most 150 s in total. Default 10.
proxy	object	no	Leave at the default and the actor picks a US residential exit (Wellfound blocks most datacenter IPs on /role/ pages). On free-plan runs, an explicit proxy group or custom proxy URLs are used exactly as given; paid runs use the actor's own residential pool.
incrementalMode	boolean	no	Only emit (and charge) NEW / UPDATED / REAPPEARED records vs the previous run of the same search. See the Monitoring section. Default false.
stateKey / emitUnchanged / emitExpired / skipReposts / maxAgeMinutes	mixed	no	Incremental-mode tuning — tracked-universe name, opt-in unchanged/expired records, repost suppression, freshness cutoff.
telegramBotToken + telegramChatId, slackWebhookUrl, discordWebhookUrl, webhookUrl (+webhookHeaders)	string	no	Post a run summary with the top new jobs to any of these channels. notifyOnlyChanges silences no-change runs; notificationLimit caps listed jobs per message (1–20, default 5).

Example input

{
  "startUrls": [
    "https://wellfound.com/jobs",
    "https://wellfound.com/jobs?market=ai",
    "https://wellfound.com/jobs?location=san-francisco"
  ],
  "maxItems": 200,
  "maxConcurrency": 4,
  "proxy": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "US" }
}

maxItems is an upper bound, not a target, and what you actually get depends on the URL. A /role/… URL paginates for real — /role/r/software-engineer reports 1,855 matching jobs across 47 pages, and the scraper reads that page count and stops exactly at the end. A /jobs URL exposes roughly 50 distinct jobs and serves that same set for every ?page=/?market=/?location= value, so the scraper stops as soon as a page returns nothing new. Either way rows are de-duplicated by job ID across the whole run — you are never charged for a repeat.

Output schema

One flat row per JobListing. All identity + compensation + remote + posted fields are populated on every row; the structured "featured" fields are sparse (see honest note above).

{
  // ── Job identity ──
  "jobId":           "4246042",
  "jobUrl":          "https://wellfound.com/jobs/4246042-sales-development-representative",
  "jobSlug":         "sales-development-representative",
  "jobTitle":        "Sales Development Representative",

  // ── Compensation (parsed best-effort from Wellfound's free-text band) ──
  "compensation":         "$40k – $80k • No equity",
  "compensationMin":      40000,
  "compensationMax":      80000,
  "compensationCurrency": "USD",
  "hasEquity":            false,

  // ── Location + remote ──
  "locations":               ["Dubai", "New York City", "San Francisco", "London", "Paris", "Bengaluru"],
  "acceptedRemoteLocations": [],
  "remote":                  true,
  "remoteKind":              "REMOTE",       // REMOTE / ONSITE / HYBRID
  "wfhFlexible":             false,

  // ── Role + time ──
  "primaryRoleSlug":  "sales-development-3",
  "postedAt":         "2026-05-22T06:49:02.000Z",
  "postedAtUnix":     1779432542,

  // ── Company identity (denormalized — always populated) ──
  "companyId":         "10559109",
  "companyName":       "CredShields Technologies",
  "companySlug":       "credshields-blockchain-security",
  "companyUrl":        "https://wellfound.com/company/credshields-blockchain-security",
  "companyLogoUrl":    "https://photos.wellfound.com/startups/i/10559109-….jpg",

  // ── Company structured data (FEATURED ROWS ONLY — ~8% of rows have these) ──
  "companySize":           "SIZE_201_500",       // null on non-featured rows
  "companySizeBand":       "201-500 employees",   // null on non-featured rows
  "companyHighConcept":    "Unlock the potential of every investment partnership",  // null on non-featured rows
  "liveJobListingsCount":  56,                    // null on non-featured rows — total open jobs at this company
  "marketTags":            ["Real Estate Tech", "B2B Software"],   // [] on non-featured rows
  "locationTags":          ["San Francisco"],     // [] on non-featured rows

  // ── Wellfound badge signals (FEATURED ROWS ONLY) ──
  "companyStage":      "scale_stage",        // "early_stage" / "scale_stage" / null
  "companyStageLabel": "Scale Stage",         // human label / null
  "recentlyFunded":    false,                  // raised in last 6 months (boolean)
  "hasTopInvestors":   true,                   // Wellfound flagged top investors (boolean)
  "growingFast":       true,                   // strong hiring growth in last month (boolean)
  "activelyHiring":    true,                   // actively processing applications (boolean)
  "topResponder":      false,                  // top 1% of responders (boolean)
  "quickResponder":    false,                  // responds within a day (boolean)
  "businessType":      "B2B",                  // "B2B" / "B2C" / null
  "allBadgeLabels":    ["Actively Hiring", "B2B", "Scale Stage", "Top Investors", "Growing fast"],

  // ── Meta ──
  "sourcePageUrl":    "https://wellfound.com/jobs",
  "sourcePageIndex":  1,
  "scrapedAt":        "2026-05-22T09:13:58.526Z"
}

Key output fields

• jobId + jobUrl — stable Wellfound identifiers. jobUrl is the canonical permalink; useful as a join key even though Wellfound itself blocks HTTP fetches of the URL
• compensation parsed band — compensationMin / compensationMax come from Wellfound's free-text strings via a best-effort regex. null when Wellfound shows "Competitive" or omits a band entirely
• remote + remoteKind + wfhFlexible — three flags so you can distinguish "fully remote", "on-site with WFH flexibility", and "hybrid"
• postedAt ISO + postedAtUnix — the moment Wellfound first published the listing (liveStartAt in their schema)
• Company "rich" fields — only populated on featured rows. The honest note above explains why — Wellfound only attaches the structured graph to paid-promoted listings, and we report what Wellfound actually serves rather than padding non-featured rows with fake data

How it works

1. Resolve the search — pasted /role/… URLs are checked against Wellfound's own list of roles and locations (a misspelt slug is corrected to the closest real one); with no URLs, keyword + location become one role search per listed role, and a term with no role of its own searches the broader role it contains (performance marketing → marketing) with the term kept as a filter there
2. Fetch each page by racing several HTTP stacks on a fresh proxy session; a blocked attempt retries on a new exit IP, with an occasional real-browser attempt, inside a time budget per page
3. Check what Wellfound served — an unknown role redirects to a generic job list, which is detected and skipped rather than billed
4. Parse __NEXT_DATA__ — one JSON.parse resolves the Apollo graph (JobListingSearchResult, StartupResult, Badge, remote settings) into one flat row per job with the company denormalized
5. Filter while paginating — keyword, title, seniority, pay, remote and age filters run on each page, so maxItems counts rows you keep; a narrow filter that keeps under a quarter of the jobs it scans stops after about 25 pages (more for a large maxItems) rather than walking the whole role
6. Push and charge each kept row once; filtered and duplicate rows are never charged

Free Apify plan

On the free Apify plan, the first 3 jobs of each run come back in full, so you can check the data. After that, rows keep the job title, company name, Wellfound links, logo, size, stage, badges, locations, remote flags and posting date, while compensation and equity, base salary, the funding history (total raised is rounded), founders, the company's website and social links, the recruiting contact, the description, benefits and apply URL are left empty (the description snippet is cut to a few characters), and the row carries a freePlanNote. Contact emails from the email add-on stay visible. Monitoring still compares full rows. Any paid Apify plan returns every field.

FAQ

Why are the company-size / badge fields empty on some rows? On /role/ searches every row carries company size, one-liner and badges (measured 100% on 300 rows). On the /jobs landing page Wellfound only attaches the full company payload to featured listings — roughly 4 of every 50 — and the rest get the lean shape (id, name, slug, logoUrl). We surface what Wellfound serves; we don't fabricate data. Market tags are empty on role-search rows because Wellfound does not send them there.

Do I get the full job description? Yes, on every row from a /role/ search, at no extra cost. /jobs landing-page rows carry only a snippet; enrichJobDetail fetches the full job page for those.

Is the actor US-only? With the default proxy setting the actor uses a US residential exit. Wellfound blocks most datacenter IPs on its /role/ search pages: in September 2026, free runs left on the plain automatic proxy were blocked about one time in four, while runs on residential were not. An account without Residential access still runs; the actor falls back to the automatic proxy and says so in the log.

How many jobs can I actually get? It depends entirely on the URL.

/role/ search — thousands. /role/software-engineer reports about 4,970 matching jobs across 91 pages (all locations); the remote-only /role/r/software-engineer about 1,850. Pages are genuinely different from one another and role+location combinations filter server-side, so /role/l/software-engineer/san-francisco and /role/l/product-manager/new-york share no results at all. This is the surface to use. A keyword with no start URL builds the all-locations search, or the remote-only one when remoteOnly is on.

/jobs landing page — about 50. It is an SEO page built from a curated seoLandingPageFeaturedJobs set and returns the same ~50 jobs for ?page=2, ?page=500, ?market=ai, ?location=san-francisco and ?industry=fintech alike. (An earlier version of this README claimed pagination ran to page 500 — every page did return 200 OK with full Apollo state, which is what made it look like it worked, but the contents are identical.)

Either way the scraper de-duplicates by job ID across the entire run, so you are never billed twice for the same job.

What happens if Wellfound changes the Apollo schema? The parser emits a structured warning (apolloState.data missing or malformed) and the page is treated as the end of pagination — noisy degradation rather than silent breakage. You'll see the warning in the log immediately on the first run.

How do I get only remote jobs, or filter by salary? Set remoteOnly: true to keep only remote roles (with a keyword and no start URL it also searches Wellfound's remote-only listing), and/or minSalary / maxSalary to keep jobs in a pay band. Pay filters are applied after the scrape but before charging, so you never pay for filtered-out rows. Jobs with no listed compensation are kept (not dropped just for missing pay).

Why does my narrow filter stop early? With filters or maxAgeMinutes on, a URL is scanned for at most 25 pages (more when maxItems is large enough to need them), or until 8 pages in a row add nothing. Wellfound does not list jobs by date, so a very rare combination could otherwise read every page of a big role. The log says when this happens and how many jobs were scanned.

More filters

Every filter below runs the same way — client-side on the fetched rows, before charging:

Input	What it does
jobTitle	Keeps jobs whose title contains the word or phrase (whole words: intern matches Internship, not Internal). Narrower than keyword (which also searches company, tags and description). Separate several with commas, semicolons or "or"
jobType	full-time / part-time / contract / internship. On /role/ URLs this uses Wellfound's structured employment type, so it is exact. On /jobs URLs it falls back to whole words in the job title
experience	junior / mid / senior / executive, read from the level the job title states (Senior/Lead/Principal/Staff; Head of/Director/VP/Chief/Founder; Junior/Entry-level/Graduate/Intern/Associate). When the title states none, Wellfound's years-of-experience decides (0–2 junior, 3–4 mid, 5+ senior); a title with neither counts as mid-level
includeNoSalary	Default true. Set false to keep only jobs that list pay
companyCategories	Keep companies whose market tags / one-liner / business type match, e.g. ["saas","fintech"]
includeCompanies	Allow-list of company names or slugs
excludeCompanies	Block-list — takes precedence over the allow-list
sort	newest / oldest by posted date. Orders the whole run, not just each page — the actor buffers all rows before writing when sorting is on. Jobs with no posted date go last

experience is a narrowing heuristic based on how the job is titled, not an exact taxonomy. The job description is deliberately not searched for it: words like "leadership" and "director" appear in almost every posting and would make the filter meaningless.

Support

Issues / feature requests / pricing questions — open a ticket on the Apify console issues tab for this actor.

Additional services

Apify hosts a portfolio of complementary actors covering related surfaces. If you need scrapers for LinkedIn jobs, Indeed, Glassdoor reviews, or AmbitionBox employee feedback, check the same author's other listings.

Explore more scrapers

If Wellfound covers your startup-job needs, you may also be interested in:

• AmbitionBox Reviews Scraper — employee reviews from India's leading review platform
• TotalJobs Scraper — UK-wide job listings from the Stepstone Group brands
• Expedia Hotel Reviews Scraper — Expedia + Hotels.com reviews with sort/filter URN support

🤖 For AI Agents & LLM Apps

Compact reference for AI agents calling this actor via the Apify MCP server or the Apify API (actor: memo23/wellfound-jobs-scraper).

Purpose: scrape startup job listings from Wellfound.com (formerly AngelList Talent) role searches — one flat row per job with the full description, compensation, remote flags, employment type, years of experience and denormalized company identity and badges.

Minimal input:

{ "keyword": "data engineer", "location": "london", "maxItems": 50 }

or { "startUrls": ["https://wellfound.com/role/data-engineer"], "maxItems": 50 }. Several roles in one keyword ("data engineer, data analyst") run one search each and share maxItems. A term that is not a Wellfound role but contains one ("performance marketing") searches that broader role (/role/marketing) and keeps only the jobs that mention the term. remoteOnly: true searches the remote-only listing.

Output: one row per job — jobId, jobUrl, jobSlug, jobTitle, compensation, compensationMin, compensationMax, compensationCurrency, hasEquity, locations[], acceptedRemoteLocations[], remote, remoteKind, wfhFlexible, primaryRoleSlug, postedAt, postedAtUnix, companyId, companyName, companySlug, companyUrl, companyLogoUrl, sourcePageUrl, scrapedAt. Featured rows also carry companySize, companySizeBand, companyHighConcept, liveJobListingsCount, marketTags[], locationTags[], companyStage, companyStageLabel, recentlyFunded, hasTopInvestors, growingFast, activelyHiring, businessType, allBadgeLabels[] (null/empty on non-featured rows).

Behaviors an agent should know:

• maxItems is per startUrl (default 1000) and is a ceiling, not a target — rows are de-duplicated by job ID across the whole run. A /role/… URL can supply thousands of jobs; a /jobs URL exposes about 50. Free-tier runs are additionally capped at 100 rows total.
• /role/{role} (all locations), /role/r/{role} (remote only), /role/l/{role}/{location} and /jobs[?…] URLs are accepted. A single job (/jobs/{id}) or company page (/company/{slug}) is not a listing and is skipped with a message. A role Wellfound does not publish is detected and skipped (Wellfound redirects it to a generic list).
• keyword (comma = OR; whole-word match), jobTitle, jobType, experience, remoteOnly, minSalary, maxSalary, includeNoSalary, companyCategories, includeCompanies, excludeCompanies, maxAgeMinutes filter rows while paginating, before charging — you never pay for filtered-out rows, and maxItems counts kept rows. sort orders the whole run by posted date.
• enrichCompanyProfile (funding, founders, socials — charged once per unique company, de-duped) and enrichJobDetail (full description, structured salary) are opt-in; failed enrichments are never charged. enrichEmails is experimental, billed per email found.
• Billing: apify-actor-start $0.01 per GB of memory per run; each job row is apify-default-dataset-item $0.00099 plus additional-data ($0.0001 until 29 Sep 2026, $0.001 from 30 Sep 2026); company-enrichment $0.0015 per successful unique company; job-detail-enrichment $0.0015 per successful job detail; enrichEmails $0.05 per email found. Failed enrichments and filtered rows are never charged.

⚠️ Disclaimer

This actor reads only publicly accessible Wellfound pages: the /role/ job search, the /jobs listing, and (when you turn enrichment on) public job and company pages. It does not log in, use accounts, access private data, or solve interactive CAPTCHAs — when Wellfound asks for one, that page is skipped. You are responsible for compliance with Wellfound's Terms of Service in your jurisdiction. The scraper is provided "as is" without warranty; use is at your own risk.

SEO Keywords

wellfound scraper, wellfound jobs scraper, angellist talent scraper, angellist jobs scraper, startup job scraper, startup hiring scraper, wellfound api, wellfound listings scraper, vc-backed startup jobs, ai startup jobs scraper, fintech startup jobs scraper, san francisco startup jobs scraper, remote startup jobs scraper, wellfound salary scraper, wellfound compensation scraper, startup sourcing tool, recruiter sourcing scraper, hiring intelligence scraper, wellfound data export, apify wellfound, wellfound csv export, recently funded startup jobs, growing startups jobs scraper, top investor startups, scale stage startups, early stage startups jobs, wellfound market filter, wellfound industry filter, wellfound location filter, datadome bypass wellfound, headless wellfound scraper