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/r/software-engineer reaches 1,800+ jobs across ~47 pages, 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 — Apify's automatic proxy by default (every plan can use it); paying runs go out through a dedicated residential pool. Wellfound is US-centric, so a US exit returns canonical English pages
• 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: for each unique startup in the dataset, it fires 30 parallel undici fetches at /company/{slug}, 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 is harvested for free and populated on the matching job rows — no extra fetches, no extra charges, no DataDome wall to cross:

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)
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), so a 1,000-row run costs about $1.09 in row charges plus the run's start fee. 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 — and job-detail enrichment in particular is DataDome-walled today, so it usually returns (and bills) nothing at all.

Enrichment reliability

• enrichCompanyProfile is currently blocked. Measured 2026-08-15: Wellfound returns 403 on /company/{slug} for HTTP clients, and a 47-company run produced 0 successful enrichments. The actor now gives up after 5 consecutive failures instead of burning ~30 requests per company. Nothing is charged for a failed enrichment, and enrichmentStatus on every row tells you exactly what got through. Leave it off unless you are testing whether the wall has lifted.
• enrichJobDetail is largely obsolete. Jobs from a /role/ search already include the full description at no extra cost, and the actor skips the enrichment entirely for those rows. It only does anything for /jobs landing-page URLs, where success has been measured near 0%. 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 an hourly schedule (maxAgeMinutes: 70) for a tight fresh-jobs feed
• 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/r/{role} 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 a role URL from your keyword + location. /jobs/{id} and /company/{slug} are rejected — Wellfound blocks those for HTTP-only clients.
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	Per-URL retry budget. Each retry rotates the proxy session with mild exponential backoff and re-races the three HTTP stacks. Default 10.
proxy	object	no	Apify Residential US is the default. Direct connections from non-US IPs sometimes get rerouted to localized variants; US residential always returns canonical English pages.
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 & dedupe the startUrls — accept /jobs[?…] listing URLs; reject detail URLs up-front with a clear reason
2. Race three HTTP stacks (impit Firefox / gotScraping / impers Chrome 142) against the first page; first 200 OK with a real body (~250 KB) wins
3. Parse __NEXT_DATA__ — one JSON.parse resolves the full Apollo normalized graph (JobListing, Startup, Badge, NewTag, JobListingRemoteConfig)
4. Walk JobListing entries in document order, resolve refs in-memory, emit one flat row per job with denormalized company data
5. Paginate to ?page=N+1 until either the parser returns 0 rows or per-URL maxItems is hit
6. Push each row through Dataset.pushData + Actor.chargeOutputRecord('additional-data')

FAQ

Why are the company-size / market-tag / badge fields empty on most rows? Wellfound only attaches the full Apollo Startup payload to featured (paid-promoted) listings — roughly 4 of every 50 jobs per page. Non-featured rows get the lean shape (id, name, slug, logoUrl). We surface the truth of what Wellfound serves; we don't fabricate data. To get only the rich rows, filter your dataset post-run for companyStage != null.

Can you scrape the full job description / company profile / investor list? No — those live behind DataDome-protected detail pages (/jobs/{id}, /company/{slug}) that don't serve to non-browser clients. Adding a JS-runtime stack would bypass this but would also dramatically raise per-row cost and break the listings-only price point. We chose to ship narrow + honest.

Is the actor US-only? The default is Apify's automatic proxy, which every plan can use. Wellfound is US-centric, so a US exit returns canonical English pages most reliably — if your plan includes Residential, selecting it with country US is a small win. (Residential is no longer the default: accounts without access to that group could not start a run at all.)

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

/role/ search — thousands. /role/r/software-engineer reports 1,855 matching jobs across 47 pages; /role/r/ai-engineer reports 1,974 across 52. 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.

/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, and/or minSalary / maxSalary to keep jobs in a pay band. Wellfound's DataDome blocks the equivalent ?remote= / salary query params, so these 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).

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 text. Narrower than keyword (which also searches company, tags and description). Comma-separated → OR
jobType	full-time / part-time / contract / internship. Wellfound's listings carry no structured type field, so this matches the title/role text (and the structured field when job-detail enrichment fills it)
experience	junior / mid / senior / executive, matched on title keywords (senior, lead, principal, head of, VP, chief…)
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

Because jobType and experience match on text rather than a structured field, treat them as a strong narrowing heuristic, not an exact taxonomy.

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) /jobs listing pages — one flat row per job with compensation, remote flags, and denormalized company identity; ~8% featured rows also carry funding-stage and badge signals.

Minimal input:

{ "startUrls": ["https://wellfound.com/jobs?market=ai"], "maxItems": 50 }

Filter mode (build the URL for you when startUrls is empty): { "market": "ai", "location": "san-francisco" } — market/industry/location are Wellfound slugs.

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/r/{role}, /role/l/{role}/{location} and /jobs[?market=…&industry=…&location=…&page=N] URLs are accepted. /jobs/{id} and /company/{slug} are rejected — Wellfound blocks those for HTTP-only clients.
• keyword (comma = OR), jobTitle, jobType, experience, remoteOnly, minSalary, maxSalary, includeNoSalary, companyCategories, includeCompanies, excludeCompanies filter rows after fetching but before charging — you never pay for filtered-out 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: additional-data $0.0015 per job row (primary); company-enrichment $0.0015 per successful unique company; job-detail-enrichment per successful job detail. No actor-start fee.

⚠️ Disclaimer

This actor scrapes only publicly accessible Wellfound pages — the /role/ job search and the /jobs listing. It does not bypass authentication, solve CAPTCHAs, or access private data. Individual job pages (/jobs/{id}) and company profiles (/company/{slug}) are explicitly rejected — we don't try to fetch DataDome-protected surfaces. 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