Wellfound Jobs Scraper

💼 What is Wellfound Jobs Scraper?

Wellfound Jobs Scraper extracts startup jobs from Wellfound (ex-AngelList Talent): the full job description, the salary AND the equity range split into numbers, the job type, the location, remote setup, the hiring company with its size, stage, markets, amount raised and funding rounds, plus visa sponsorship, relocation and GPS coordinates.

Type a job category (Software Engineer), add a location if you want one, click Start, and download the jobs in JSON, CSV or Excel. No login, nothing to set up. A listing-only run reads about 1,800 jobs a minute; with each job page opened, about 45 jobs a minute.

📋 What data can you extract from Wellfound?

One item per job, 83 fields:

Category	What you get
💼 Job	title, category, link, apply link, job type (full-time, contract, internship, cofounder) — Software Engineer
📝 Full job ad	the whole description, as text and as HTML — 4,800 characters on average
💰 Salary and equity	the salary range and the equity range as numbers, with currency and period — $120k – $200k • 0.01% – 0.15%
📍 Location and remote	city, region, country, GPS, remote or not, the countries a remote job accepts — Austin, Texas
🎓 Requirements and perks	years of experience asked, visa sponsorship, relocation, recruiter recently active
🏢 Company	name, website, logo, tagline, size, employees, stage, B2B or B2C, markets, industries, badges such as "Actively Hiring"
💵 Funding	amount raised, in text and in dollars, and every funding round with its date — Seed, $5.6M, Feb 2022
👥 Founders	name, role, years at the company and Wellfound profile of each founder
🏷️ Company page	the company's own description, perks and benefits, culture photos, LinkedIn / X / Facebook / blog / Product Hunt links, open jobs in all and by role (option)
✉️ E-mails	addresses published on the company's own website (option)
🕒 Dates and freshness	publication date — what the date filters read — and how long the results page had been cached

Every field, with an example, is listed in the Output section below.

The whole description, the compensation text, the equity, the job type, the date, the location and the company card come from the results page: they are filled whether or not Extract job details is on. The fields marked detail in the Output tab (descriptionHtml, exact salary figures, GPS, industries, company website, visa, relocation, recruiter activity, employees, markets, funding, founders, similar jobs) need it. emails and emailSource need Find company e-mails as well. The fields marked company need Company page, with or without Extract job details; in a list-only run it also fills the website, amount raised, markets and locations. A job URL pasted in Start URLs has no results page behind it: its job-page fields, title, salary and equity, date, company name, slug and Wellfound page are filled, as are the remote flag and policy and the "Actively Hiring" badge, read on the job page, while the Markdown description, job type, locations, the other badges and the rest of the company card stay empty (null or []).

✅ Why use Wellfound Jobs Scraper?

• 📄 The whole job ad, every time: the full description (4,800 characters on average) comes with every job, at no extra request — most scrapers of this site return a title and a link.
• 💰 Salary and equity as numbers: $120k – $200k • 0.01% – 0.15% becomes minSalary, maxSalary, salaryCurrency, salaryPeriod, minEquity and maxEquity, ready to sort and filter.
• 🏢 The company with the job: size, stage, B2B/B2C, markets, amount raised, funding rounds, website, founders — and, with Company page, its description, perks, social links and open jobs — without a second product to run.
• ⏱️ Freshness you can check: listPageCacheAgeSeconds says how long the results page had been served from cache when it was read, instead of promising an hourly watch.
• 🧩 Nothing missed, nothing twice: pagination is automatic, every page of a search is read, each job is returned once — no 500-job ceiling.
• 🔔 Monitoring built in: tick Only new jobs, schedule the Actor, and each run returns (and charges) only what it has never delivered before.
• 🔌 API, scheduling, monitoring, integrations (Make, Zapier, n8n, Google Sheets…) and JSON/CSV/Excel export via the Apify platform.

🚀 How to scrape Wellfound

1. Create a free Apify account.
2. Open Wellfound Jobs Scraper and type a Job category (e.g. Software Engineer) — the categories Wellfound itself browses by.
3. Add a Location (San Francisco, London, India), or tick Remote jobs only. You can also paste your own Wellfound URLs into Start URLs: /role/…, /role/l/…, /role/r/…, /location/…, /remote, or single job pages.
4. Set Max jobs (20 in the form to try it out, 100 when an API call leaves it out, 0 = no limit) — and Max jobs per search when you run several searches — then click Start.
5. Download the dataset in JSON, CSV, Excel or via API.

💰 How much does it cost to scrape Wellfound?

This Actor uses pay per event pricing: $0.40 per 1,000 jobs, job pages included — plus $0.0011 per run start at the Actor's default memory (11 cents per 100 runs; the platform counts that event once per gigabyte, so a run you give more memory pays proportionally more). Higher Apify plans pay less per job: $0.38 (Bronze), $0.36 (Silver) and $0.34 (Gold and above) per 1,000. Find company e-mails costs nothing more. Company page costs $1.00 per 1,000 companies ($0.90 Bronze, $0.85 Silver, $0.80 Gold and above), each company charged once per run however many of its jobs you get, plus $0.005 per run that uses it; the run takes 1 GB of memory instead of 256 MB (still one run start). Example: 20,000 jobs ≈ $8; a daily monitor of 200 new jobs ≈ $0.08 a day. The filters are applied by the Actor on every job it reads, kept or not: $0.025 per 1,000 job cards checked by a filter (filter-check; $0.023 Bronze, $0.021 Silver, $0.020 Gold and above) and $0.20 per 1,000 job pages read for Industries or Visa sponsorship only (detail-filter-check; $0.19 Bronze, $0.18 Silver, $0.17 Gold and above) — a search that finds nothing pays for what it read (8,000 jobs checked ≈ $0.20). Platform usage (compute, proxy) is included in the price.

⚙️ Input

{
    "query": "Software Engineer",
    "location": "San Francisco",
    "maxItems": 200,
    "extractDetails": true
}

Several searches, a cap per search, a keyword filter, only recent jobs, only the ones not delivered before:

{
    "searchQueries": ["Software Engineer", "Data Scientist"],
    "locations": ["San Francisco", "New York"],
    "maxItemsPerQuery": 50,
    "includeKeywords": ["python", "rust"],
    "minSalary": 150000,
    "postedAfter": "7 days",
    "onlyNew": true,
    "stateKey": "us-engineers"
}

Or with your own URLs:

{
    "startUrls": [
        { "url": "https://wellfound.com/role/r/designer" },
        { "url": "https://wellfound.com/jobs/4716782-software-engineer" }
    ],
    "maxItems": 500
}

Field	Notes
query, searchQueries	The Wellfound job CATEGORY, as the site browses by (Software Engineer, Product Manager). Not a free-text search: Wellfound offers none to visitors. Ignored when startUrls is set.
location, locations	City, region or country as Wellfound names it (San Francisco, London, India). Every category is searched in every location (max 500 searches per run).
remoteOnly	Browse the remote pages instead of the on-site ones. Cannot be combined with a location: those pages carry no place.
startUrls	Wellfound results pages (pagination automatic) or single job pages.
extractDetails	Open each job page for the exact salary, GPS, industry, company website, visa, relocation, funding and founders (default on). Off = about 40× faster, same price.
enrichEmails	Read the company's own website (up to 3 pages, once per company) for its e-mail addresses. Wellfound publishes none. Needs extractDetails.
enrichCompany	Read each company's Wellfound page once per run: description, perks, culture photos, social links, open jobs. Works in list-only runs too. Takes 1 GB of memory (set automatically).
maxItems	Stop after this many jobs for the whole run (0 = unlimited).
maxItemsPerQuery	Cap for EACH search (category × location, or search URL). 0 = no per-search cap.
maxPages	Stop each search after this many results pages (about 40 jobs a page). 0 = every page the site serves.
includeKeywords, excludeKeywords	Keep, or drop, the jobs whose title or description holds one of these words (case and accents ignored). This is how you search by keyword here.
jobTypes	full-time, part-time, contract, internship, cofounder.
minSalary, maxSalary, includeNoSalary	Salary range to overlap, and whether the jobs showing no salary are kept (8 % of them).
minEquity, maxYearsExperience	Equity floor in percent; jobs asking for at most this many years (jobs stating none are kept).
companySizes, companyStages, companyTypes, activelyHiringOnly	Employee bucket, stage label (Early Stage), B2B / B2C, and Wellfound's "Actively Hiring" badge.
includeCompanies, excludeCompanies	Company names or Wellfound slugs (Boom, boom-app).
industries, visaSponsorshipOnly	Company industry, and only the jobs whose page states that visa sponsorship is available. Both need extractDetails.
postedAfter, postedBefore	Publication date range: 2026-09-01, or a period before now (7 days, 2 weeks, 1 month, 24 hours).
onlyNew, stateKey, resetState	Monitoring: only the jobs never delivered under this memory key; resetState forgets the memory.
Advanced	proxyConfiguration (Apify proxy by default, included in the price; the residential proxy is not available), maxConcurrency, maxRequestsPerMinute, maxRequestRetries, debugLog.

📦 Output

One item, shortened to its first fields (a real item carries all 83):

{
    "id": "4716782",
    "url": "https://wellfound.com/jobs/4716782-software-engineer",
    "applyUrl": "https://wellfound.com/jobs/4716782-software-engineer",
    "slug": "software-engineer",
    "title": "Software Engineer",
    "primaryRoleTitle": "Software Engineer",
    "description": "# **Software Engineer**\n\nWe hire software engineers across levels under a single posting...",
    "compensation": "$120k – $200k • 0.01% – 0.15%",
    "minSalary": 120000,
    "maxSalary": 200000,
    "salaryCurrency": "USD",
    "salaryPeriod": "YEAR",
    "salarySource": "card",
    "hasEquity": true,
    "minEquity": 0.01,
    "maxEquity": 0.15,
    "jobType": "full-time",
    "publishedAt": "2026-09-15T00:00:52.000Z",
    "liveStartAt": 1789430452,
    "locationNames": ["Austin"],
    "remote": false,
    "acceptedRemoteLocationNames": [],
    "atsProvider": "Ashby",
    "autoPosted": false,
    "visaSponsorship": "Not Available",
    "relocation": "Not Allowed",
    "companyName": "Boom",
    "companySlug": "boom-app",
    "companyWebsite": "https://boompay.app",
    "companySizeLabel": "11-50",
    "companyStage": "Early Stage",
    "companyBusinessType": "B2C",
    "companyActivelyHiring": true,
    "companyGrowingFast": true,
    "companyBadges": [{ "id": "ACTIVELY_HIRING", "label": "Actively Hiring", "tooltip": "Actively processing applications" }],
    "companyLocationNames": ["Austin"],
    "founders": [
        {
            "name": "Rob Whiting",
            "role": "Co-founder",
            "tenure": "6 years",
            "location": "Austin",
            "profileUrl": "https://wellfound.com/p/rob-whiting"
        }
    ],
    "similarJobIds": ["2776321", "2777056"],
    "companyEmployees": "11-50",
    "companyMarkets": ["Real Estate", "Property Management", "Fin Tech"],
    "industries": ["Real Estate", "Property Management", "Fin Tech", "Financial Technology"],
    "companyTotalRaised": "$5.6M",
    "companyTotalRaisedUsd": 5600000,
    "companyFundingRounds": [{ "type": "Seed", "amount": "$5600000", "date": "Feb 2022" }],
    "emails": [],
    "searchQuery": "software-engineer",
    "searchLocation": "austin",
    "listPageCacheAgeSeconds": 8539,
    "source": "wellfound",
    "scrapedAt": "2026-09-20T12:00:00.000Z"
}

You can download the dataset in various formats such as JSON, HTML, CSV or Excel.

All 83 fields

Fields	Example
id, url, applyUrl, slug	4716782, https://wellfound.com/jobs/4716782-software-engineer, same, software-engineer
title, primaryRoleTitle	Software Engineer, Software Engineer
description, descriptionHtml	the whole job ad (Markdown), the same as HTML
compensation, minSalary, maxSalary, salaryCurrency, salaryPeriod, salarySource	$120k – $200k • 0.01% – 0.15%, 120000, 200000, USD, YEAR, card
hasEquity, minEquity, maxEquity	true, 0.01, 0.15 (percent)
jobType, employmentType	full-time, FULL_TIME
publishedAt, liveStartAt	2026-09-15T00:00:52.000Z (what the date filters read), 1789430452
locationNames, remote, remoteConfig, acceptedRemoteLocationNames	["Austin"], false, In office - WFH flexibility, ["United States"]
minYearsExperience, maxYearsExperience	3, 7
atsSource, atsProvider, autoPosted, directApply	AtsIntegration::Ashby::Listing, Ashby, false, true
visaSponsorship, relocation, recruiterRecentlyActive	Not Available, Not Allowed, true
latitude, longitude, addressLocality, addressRegion, addressCountry	30.2672, -97.7431, Austin, Texas, United States
companyId, companyName, companySlug, companyUrl, companyWebsite, companyLogoUrl	7775773, Boom, boom-app, its Wellfound page, https://boompay.app, its logo
companyTagline, companySize, companySizeLabel, companyEmployees	Modern rental financial services, SIZE_11_50, 11-50, 11-50
companyStage, companyBusinessType, companyActivelyHiring, companyGrowingFast, companyBadges	Early Stage, B2C, true, true, every badge with its tooltip
companyLocationNames, companyLatitude, companyLongitude	["Austin"], 30.2672, -97.7431
companyMarkets, industries	["Real Estate", "Fin Tech"], ["Real Estate", "Property Management"]
companyTotalRaised, companyTotalRaisedUsd, companyFundingRounds	$5.6M, 5600000, [{ "type": "Seed", "amount": "$5600000", "date": "Feb 2022" }]
founders, similarJobIds	name, role, years and Wellfound profile of each founder; ids of the jobs shown as similar
companyDescription, companyPerks, companyCulturePhotos	the company's own presentation, [{ "category": "healthcare", "title": "Healthcare Benefits", … }], photo URLs (company)
companyLinkedinUrl, companyTwitterUrl, companyFacebookUrl, companyBlogUrl, companyProductHuntUrl	links of the company page, null when it has none (company)
companyOpenJobsCount, companyOpenJobsByRole, companyPageRead	8, [{ "role": "Engineering", "count": 2 }], true (read) / false (asked, not read) / null (not asked)
emails, emailSource	addresses found on the company's own website, and the page they were read on
searchQuery, searchLocation, searchUrl	software-engineer, austin, the results page it was found on
listPageCacheAgeSeconds, source, scrapedAt	8539 (how long the results page had been cached), wellfound, ISO timestamp

💡 Tips

How to get more results

Set maxItems to 0. Wellfound serves every page of a search — a category like Software Engineer carries about 5,000 jobs over 91 pages, /remote about 12,000 — so a broad category with no cap returns the lot. To cover more ground, list several categories in searchQueries and several places in locations: the Actor runs one search per pair and saves a job found twice only once.

How to reduce costs

The price is per job, so the levers are maxItems, maxItemsPerQuery, maxPages, the filters (a filtered-out job is not saved and does not count in maxItems; each job checked costs its small filter fee, see Pricing) and onlyNew for recurring runs. Turning extractDetails off makes runs about 40× faster (one request per results page of about 40 jobs instead of one per job) but does not change the price. enrichEmails adds nothing to the price; enrichCompany does (per company and per run), and a list-only run with it reads one company page per company. When the run's maximum cost can pay for no more jobs, it stops, and every job it saved is paid for.

Searching by keyword on a site that has no search

Wellfound gives visitors no keyword search — its own search sits behind a login. The Actor therefore browses the site's categories (query) and places (location), then filters on words with includeKeywords / excludeKeywords, which read the title AND the full description. Every scraper of this site works that way; this one says so instead of pretending to search.

How fresh is a row, really

Wellfound serves its results pages from a cache. listPageCacheAgeSeconds is the age of the page the job was read on, in seconds: 0 means it was read at the source, and ages of up to 21 hours have been measured on the most popular pages. Deeper pages are almost always read at the source. Use the field to know what a row is worth instead of trusting a promise of hourly freshness — and note that the site does not sort by date, so a run looking for recent jobs reads every page of its searches.

Several searches in one run

Fill searchQueries and / or locations: the Actor runs one search per category × place (3 categories × 4 cities = 12 searches, up to 500 per run). The single query and location fields still work and are added to the lists. A job found by several searches is saved — and charged — once. Set maxItemsPerQuery to give every search its own cap: without it the first searches can use up the whole maxItems budget. You can also paste several search URLs into startUrls: each one is a search of its own, with the same cap.

Monitoring: only the new jobs

Tick Only new jobs (onlyNew) and schedule the Actor. The first run returns everything; each later run skips the jobs already delivered: they are not saved, not charged, and their page is not even opened. A job re-posted under the same Wellfound id is not delivered twice either. The memory lives in a named key-value store of your account (wellfound-jobs-scraper-seen, up to 150,000 jobs per key) and is only updated with jobs that really reached the dataset, so a failed run never hides anything. Give each schedule its own stateKey (two schedules sharing a key would hide each other's jobs), and tick resetState once to start over. Because Wellfound does not sort by date, a monitoring run still reads every page of its searches — it just stops paying for what it already had. For the same reason, a capped run (maxItems) followed by another one returns the next jobs never delivered, old or new: add postedAfter (for example 2 days) to keep only the recent ones.

Filter by publication date

postedAfter and postedBefore take a date (2026-09-01, the whole day is included, UTC) or a period before now (7 days, 2 weeks, 1 month; via the API also 24 hours or a full ISO date-time). The filter reads publishedAt, which every Wellfound job carries; a job without a publication date is dropped as soon as a date bound is set. A filtered-out job is not saved and does not count in maxItems: it costs only its filter fee (see Pricing); the run summary tells how many were filtered.

🔌 Integrations and API

Call the Actor via the Apify API, the JavaScript or Python clients, or connect it with integrations and webhooks (Make, Zapier, n8n, Google Sheets, Slack, Airtable…). The dataset can be fetched as JSON or CSV from any tool.

🤖 Use with AI agents (MCP)

AI agents (Claude, ChatGPT, Cursor…) can find and run this Actor through the Apify MCP server, billed to their Apify account like any run. It returns one item per Wellfound job. Actor id: nice_dev/wellfound-jobs-scraper; MCP server with this Actor only: https://mcp.apify.com/?tools=fetch-actor-details,nice_dev/wellfound-jobs-scraper.

Smallest input, for a cheap first call:

{
    "query": "Software Engineer",
    "maxItems": 10
}

Key output fields: url, title, companyName, minSalary, maxSalary, salaryCurrency, locationNames and description (with extractDetails).

Cost: $0.40 per 1,000 jobs plus $0.0011 per run start ($0.34 per 1,000 on the Gold plan). The company page option and the filters cost extra, see the pricing section above. Cap each call with maxItems and, through the API, with the run option maxTotalChargeUsd.

❓ FAQ

Is it legal to scrape Wellfound?

The Actor only reads what Wellfound shows publicly to any anonymous visitor. It logs in to nothing. Job ads and company profiles are professional information; the founders Wellfound publishes on a job page are named people, and personal data is protected by GDPR: do not store it without a legitimate reason. You are responsible for using the data in compliance with Wellfound's Terms of Use and applicable law. This Actor is not affiliated with Wellfound or AngelList.

Does it need a login or a proxy?

No login. The proxy is included in the price: leave the default setting (the residential proxy is not available). A request the site turns away is retried at once on a new proxy session, up to 10 times on top of the retries (without a proxy, after a pause of 5 seconds, doubled at each retry up to 150 seconds).

Now and then Wellfound's Cloudflare check turns the platform's IPs away. A run with 1 GB of memory or more (a Company page run has it) then passes the check on the page that was refused and goes on from its own connection. At the default 256 MB the run keeps retrying on new proxy sessions, and if it still fails, its last message says so: run it again, or give it 1 GB (Run options → Memory; the run start is charged per GB). A run that is never turned away costs nothing more.

Is the data safe to open in Excel or to show on a web page?

Titles and descriptions are the companies' own words, copied as they are. A text can begin with -, +, = or @ (a title such as -20% equity): Excel and Google Sheets may read such a cell of a CSV file as a formula or as a number. The Actor leaves the text as it is, so that the JSON and the API give the real value: when you open a CSV, import these columns as text. Every URL field (url, applyUrl, companyUrl, companyWebsite, companyLogoUrl, the founders' profiles) holds an http(s) URL or null, never a javascript: or data: value. descriptionHtml is the company's own HTML and is not sanitized: escape it like any text written by a stranger before putting it on a page.

Known limitations

• Wellfound has no keyword search for visitors and no sort at all: includeKeywords and the date filters are applied to the jobs the categories and places return, so a run looking for a rare word reads whole searches.
• Company page reads each company's Wellfound page once per run, from the run's own connection whatever the proxy setting. A company page shows at most its first jobs: to get all of a company's jobs, search its categories and filter with includeCompanies. A job URL pasted in Start URLs gets its company page too: the company is read from the job page. When the page cannot be opened, the jobs are still delivered, with companyPageRead: false and the company fields empty, and that company is not charged.
• remoteOnly and location cannot be combined: the site's remote pages carry no place.
• onlyNew remembers job ids, not their content: a job whose description changed is not returned again.
• Two runs sharing the same stateKey at the same time may both return the same new job.

A run the platform stops without warning (out of memory, run timeout)

• Resurrect it: it goes on from where it stood at most a minute before the stop. What it had read since is read again, and the jobs already saved are skipped: none is delivered or charged twice, and maxItems still counts them.
• With onlyNew, the memory is saved once a minute: resurrect the stopped run and the jobs it had saved meanwhile join the memory; leave it stopped for good, and the next run may return up to a minute of them once more.

Something doesn't work?

The last line of the log counts the jobs saved, filtered out and no longer on Wellfound (taken down while the run was reading them), and the requests that failed after every retry. Those requests and the removed jobs are listed, with the reason, in the FAILED_REQUESTS record of the run's key-value store. A run that saved nothing and had failed requests fails, and its last message gives the cause (a search URL that does not exist says so, instead of "run it again"). A run that saved some jobs fails too when at least as many requests failed for good as were read (page 1 read, the next pages, the job pages or the company pages blocked): a green run with a short dataset would hide the outage. One failed request among many is only a warning.

If Wellfound changes its pages, you are told instead of paying for blank rows. A results page that counts jobs but gives none the Actor can read is an error (listed in FAILED_REQUESTS), never a quiet "No jobs found". So is a results page whose jobs all lack the salary line, the remote flag, the locations or the required experience (Wellfound sends them on every job, empty when a job has none): nothing is saved or charged. If the first 20 jobs read all lack their title, publication date, description, job type or company name, the run saves nothing more, stops and fails, and its last message names the missing field: at most those first jobs are charged. A job that postedAfter / postedBefore drops because it has no date at all counts among those 20.

🛟 Support

Open an issue in the Issues tab with a link to your run: the run log and the FAILED_REQUESTS record of the key-value store show exactly which URLs failed and why.