Wellfound Jobs & Startup Company Profile Scraper

Wellfound Jobs Scraper — Startup Company Profiles & Badges

Scrape live Wellfound (formerly AngelList Talent) job listings and get two linked row types back: one job row per listing, and one startup company-profile row per hiring company — employee-size band, tagline, funding-stage badge, YC-backed and top-investor flags, valuation tier, B2B/B2C market model and responder speed. Every response is structured JSON, ready to load into a spreadsheet, pass to an LLM as grounding context, or feed a hiring-signal monitoring pipeline. Company profiles cost no extra requests — they're built entirely from the same search-listing payload the job rows come from, and they're never billed. Point it at a hiring market, a role keyword, a single startup, or your own Wellfound URLs, and start tracking which companies are actually hiring right now.

🏢 What is the Wellfound Jobs & Startup Company Profile Scraper?

It's an Apify Actor that queries Wellfound's job search — by hiring market, role keyword, company name, or a pasted URL — and returns job listings joined to a startup company-intelligence profile for every hiring company. No Wellfound account or login is required; the Actor reads the same server-rendered search results any visitor sees.

What makes it different from a plain job-listing scraper is the second row type: for every company that appears in the search results, it parses the Badge entities Wellfound attaches to that company's search-listing entry and turns them into typed fields — funding stage, YC backing, top-investor backing, fast-growth flag, valuation tier, B2B/B2C market model, and responder speed. Those signals ship as a dedicated company row (type="company") mirrored into its own dataset, joined back to every job that company is hiring for.

Key capabilities:

• 💼 Job listings — title, salary/compensation band, location, remote flag, job type, posted date, and full description
• 🏢 Startup company profiles — one row per hiring company with size band, tagline, logo, and canonical Wellfound URL
• 🎖️ Badge-derived signals — funding stage, YC backing, top-investor backing, fast-growth flag, valuation tier, B2B/B2C model, responder speed
• 🔎 Query controls — hiring market (location), role/tech keyword, single-startup lookup, employment type, posting recency, or bulk pasted URLs
• 📄 Multi-page crawling — walk up to 100 result pages per starting URL, with an automatic proxy escalation ladder when Wellfound's anti-bot layer intervenes
• 🗂️ A separate company dataset — company rows are pushed to the main dataset and mirrored into their own per-run dataset for easy company-only exports

📊 What data can you get with this Wellfound scraper?

The Actor returns two result types on every run — job listings and, when enabled, the startup company profile behind each one.

Result Type	Extracted Fields	Primary Use Case
Job listing (type="job")	job_title, company_name, location, salary, job_type, date, description, URL, plus every company field below joined onto the row	Job-board aggregation, compensation benchmarking, remote-role filtering
Company profile (type="company", isChild=true)	companyName, companySlug, companySizeLabel, companyTagline, companyStage, isYCBacked, hasTopInvestors, isGrowingFast, valuationTier, isB2B/isB2C, responderSpeed, badgeLabels, openRolesInRun, roleTitlesInRun	Startup hiring-signal tracking, sourcing/lead lists, VC and market research

Startup company badge signals

This is the section competing Wellfound scrapers don't cover the same way. Wellfound attaches a badges array of Badge entities to every StartupResult object in its search-listing payload — the same JSON block the job cards are parsed from. Most scrapers discard that array along with the rest of the raw Apollo cache; this Actor reads it and derives seven typed signals from it:

{
  "companyStage": "growth",
  "companyStageRaw": "growth_stage",
  "isYCBacked": true,
  "hasTopInvestors": true,
  "isGrowingFast": true,
  "isActivelyHiring": true,
  "isB2B": true,
  "isB2C": null,
  "valuationTier": "1B+",
  "responderSpeed": "top",
  "badgeTypes": ["B2B_BADGE", "COMPANY_STAGE_BADGE", "TOP_INVESTORS", "VALUATION1B", "YC_BADGE"],
  "badgeLabels": ["B2B", "Growth Stage", "Top Investors", "$1B+ Valuation", "Y Combinator"],
  "badgesCaptured": 5
}

A badge that never appears in the payload resolves to null, not false — Wellfound not displaying a badge for a company is not evidence the underlying fact is false, so the Actor never guesses. companyStage only gets a value when a real COMPANY_STAGE badge is present; there is no default stage. Badge ratings (work-life-balance, leadership) exist in the same payload but were measured at only around 20% coverage during development, so they're logged in the run summary rather than shipped as unreliable dataset columns.

Job listings

Every job row carries the standard listing fields — title, compensation band (normalized to "120K–160K a year" style strings), location, remote flag folded into location, job type, and a relative posted date ("3 days ago", "today"). Descriptions come straight from the listing payload for the vast majority of cards; the Actor only opens the individual job page when a card arrives without one, and stops trying after several consecutive failures rather than burning the run on a dead surface.

Result pages that lazy-load more cards on scroll (rather than paginate via ?page=N) are handled with an auto-scroll pass before extraction: the page is scrolled to the bottom repeatedly, counting distinct job links after each scroll, until two consecutive scrolls add no new jobs or a scroll ceiling is hit. Extraction always prefers the embedded Apollo JSON over reading the rendered DOM — the JSON keys (JobListingSearchResult:*, StartupResult:*) are far more stable than Wellfound's hashed CSS class names, so DOM scraping only runs as a fallback if the JSON shape ever changes underneath the Actor.

Why not build a Wellfound scraper yourself?

Wellfound has no public data API, so the only way to get this data programmatically is to parse what the browser receives — and that surface moves under you in three specific ways this Actor is built to absorb:

• The payload shape isn't stable across page types. Wellfound's listing pages ship a Next.js __NEXT_DATA__ Apollo cache; individual job pages are Rails-rendered and carry no such block, only a schema.org application/ld+json JobPosting object instead. A scraper gated only on the Apollo shape misjudges every successfully loaded job-detail page as blocked.

• DataDome fronts the whole site. Company profile pages (wellfound.com/company/<slug>) and individual job pages are anti-bot walled to logged-out traffic — this Actor verified 4 out of 4 attempts blocked across 3 fresh browser sessions during development. Getting past a JS/CAPTCHA interstitial reliably needs a stealth browser and a proxy escalation strategy, not a plain HTTP client.

• Proxy cost adds up fast. Reaching Wellfound from cloud IP ranges (including Apify's own) reliably trips DataDome on direct and datacenter connections, so a from-scratch scraper either eats a high block rate or needs to build and pay for residential proxy rotation itself.

• The same startup shows up under two different cache keys, and dropping either one loses data. Wellfound's Apollo cache normally carries a company under both a Startup:<id> key (the entity: size band, tagline, logo, badges) and a StartupResult:<id> key (the search wrapper: which jobs it's hiring for). Reading only one of the two silently loses either the badge signals or the job-to-company join. This Actor merges every cache key that resolves to the same company id, filling in whichever fields the first-seen key was missing rather than overwriting real data with a thinner duplicate.

This Actor handles all of the above: it reads either payload shape, runs a real stealth browser (Camoufox) behind a tiered proxy strategy that escalates from datacenter to residential sticky sessions automatically, and rotates to a fresh residential exit IP on every retry — up to three residential retries per seed before it gives up and logs an unbilled error row. Build your own scraper if you need a payload shape or a page type this Actor doesn't cover; use this Actor if you want the anti-bot handling, the cache-merge logic and the proxy escalation already solved.

How to scrape Wellfound jobs and startup company data

1. Open Wellfound Jobs & Startup Company Profile Scraper on the Apify Console.
2. Set a query: enter a hiring market (hiringLocation, e.g. "San Francisco"), a role or tech keyword (roleKeyword, e.g. "golang"), a single startup name (startupName), or paste one or more Wellfound URLs into startUrls — any listing page or individual job page.
3. Set the real query controls that apply: employmentType to keep only one job type, postedWithin to keep only recent postings, listingPages to walk more than one result page per seed.
4. Click Start.
5. Download results as JSON, CSV, Excel or the other formats Apify's dataset export supports, or stream them via the Apify API.

{
  "hiringLocation": "San Francisco",
  "roleKeyword": "machine learning",
  "listingPages": 3,
  "employmentType": "FULLTIME",
  "postedWithin": "week"
}

To run several hiring markets or role searches in one job, paste multiple URLs into startUrls — https://wellfound.com/location/new-york, https://wellfound.com/role/r/data-scientist, and so on. Each URL is walked independently for up to listingPages pages, and every company seen across every seed collapses into a single company profile row, so a startup hiring in two of your queries appears once with an accurate openRolesInRun count.

⬇️ Input

All parameters are optional — leaving everything blank defaults the search to Wellfound's /location/new-york page.

Parameter	Required	Type	Constraints	Description
startUrls	No	array	default []	Paste Wellfound search/listing URLs (e.g. https://wellfound.com/location/new-york, https://wellfound.com/role/r/data-scientist) or individual job pages. Overrides the search builder below. Every listing page yields both job rows and company profiles.
hiringLocation	No	string	default "New York"	City or region whose hiring startups you want profiled — e.g. "New York", "San Francisco", "London". Builds https://wellfound.com/location/<slug>.
roleKeyword	No	string	default ""	Narrow the companies to those hiring for a role or stack — e.g. "machine learning", "golang", "product designer". Combined with the hiring market. Leave blank to profile every startup hiring in that market.
startupName	No	string	default ""	Profile one company only. The scraper searches Wellfound for it and keeps the cards whose company name loosely matches. Example: startupName="Brex".
listingPages	No	integer	default 1, min 1, max 100	How many result pages to walk per starting URL. Page 1 of a location page carries roughly 50 jobs across roughly 20 distinct startups, so 2 pages is roughly 40 company profiles.
maxItems	No	integer	default 0, min 0	Hard cap on JOB rows across the whole run — the billed, top-level items. Company rows are children and are never counted against this cap or charged. 0 = no cap. Example: maxItems=25 returns up to 25 job rows plus however many companies those 25 jobs belong to.
includeCompanyRows	No	boolean	default true	Adds one row per hiring startup (type="company", isChild=true) with its size band, tagline, badge signals and openRolesInRun, and mirrors the same rows into a separate company dataset. Turn off for a jobs-only feed.
employmentType	No	string (enum)	default ""	Keep only jobs of this type when deciding which companies count as hiring. Values: "" (Any type), "FULLTIME" (Full-time), "PARTTIME" (Part-time), "CONTRACTOR" (Contract), "INTERN" (Internship). Leave as Any to profile every hiring startup.
postedWithin	No	string (enum)	default "all"	Keep only jobs posted inside this window. Values: "all" (Any time), "today" (Today), "3days" (Past 3 days), "week" (Past week), "month" (Past month).
fetchJobDescriptions	No	boolean	default true	Wellfound already ships the description inside the listing payload, so this only opens a job page for the rare card that arrives without one.
proxyGeoCountry	No	string (enum)	default "United States"	Country the proxy exit nodes should appear to be in. One of the standard ISO country names (e.g. "United States", "United Kingdom", "Germany", "India" — the full list matches every country in Apify's proxy country selector). This geo-targets the PROXY only — it does not filter which companies or jobs are returned. Use hiringLocation for that.
proxyConfiguration	No	object	default {"useApifyProxy": false}	Apify Proxy configuration. Leaving useApifyProxy false does not mean the run goes proxy-less in practice: because Wellfound's DataDome layer reliably blocks direct and datacenter cloud IPs, the Actor still opens an Apify Residential proxy session automatically whenever you haven't explicitly configured one. Configuring useApifyProxy: true with your own proxy groups takes priority and is used first.
requestDelay	No	integer	default 1, min 0, max 60	Pause before each page load, plus a small random jitter, in seconds. Raising it to 3–5 makes long multi-page runs noticeably less likely to trip rate limiting.
headless	No	boolean	default true	Run the stealth browser without a visible window. Leave on unless you are debugging locally.

Example input:

{
  "hiringLocation": "New York",
  "roleKeyword": "product designer",
  "listingPages": 2,
  "maxItems": 40,
  "includeCompanyRows": true,
  "employmentType": "FULLTIME",
  "postedWithin": "week",
  "fetchJobDescriptions": true,
  "proxyGeoCountry": "United States",
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] },
  "requestDelay": 2,
  "headless": true
}

Common pitfall: if you paste your own startUrls and try to filter by location with a query parameter — https://wellfound.com/jobs?location=san-francisco — Wellfound silently ignores that parameter and serves the generic /jobs landing page instead, which is hard-capped at roughly 49 featured cards with no pagination. The genuine, paginated, location-filtered page is https://wellfound.com/location/<slug>, which is what hiringLocation builds automatically. Use hiringLocation rather than hand-building a ?location= URL.

⬆️ Output

Results are typed, normalized JSON with a consistent schema across runs, downloadable as JSON, CSV, Excel, HTML table, or the other formats Apify's dataset export supports. Only job rows are billed — company rows and error/accounting rows are pushed to the dataset unbilled, so filtering on type == "job" isolates exactly what you were charged for.

Company profile rows are written to two places: the main dataset (interleaved with job rows, distinguished by type), and mirrored into a separate dataset named wellfound-companies-<runId> for a clean company-only export. Three dataset views are pre-configured on the Actor: the default Jobs with company profile view (21 columns), a Company profiles view (19 columns, company rows only), and a Base job fields view (9 columns, job fields with no company data). All three are subsets of the full row shape below — every key the Actor actually writes is documented here, not just what a view displays.

Scraped results

A job row (type="job") carries every base job field plus the joined company profile:

{
  "type": "job",
  "isChild": false,
  "jobId": "4361872",
  "job_title": "Senior Machine Learning Engineer",
  "company_name": "Vantage Robotics",
  "location": "New York, NY",
  "posted_via": "Wellfound",
  "salary": "160K–210K a year",
  "job_type": "Full-time",
  "date": "3 days ago",
  "description": "We're building the perception stack for autonomous last-mile delivery...",
  "URL": "https://wellfound.com/jobs/4361872-senior-machine-learning-engineer?utm_campaign=google_jobs_apply&utm_source=google_jobs_apply&utm_medium=organic",
  "companyId": "1092233",
  "companySlug": "vantage-robotics",
  "companyUrl": "https://wellfound.com/company/vantage-robotics",
  "companyLogo": "https://photos.wellfound.com/startups/i/1092233-abc123.png",
  "companySize": "SIZE_51_200",
  "companySizeLabel": "51-200 employees",
  "companyTagline": "Autonomous delivery robots for the last mile",
  "companyStage": "growth",
  "companyStageRaw": "growth_stage",
  "isYCBacked": true,
  "hasTopInvestors": true,
  "isGrowingFast": true,
  "isActivelyHiring": true,
  "isB2B": true,
  "isB2C": null,
  "valuationTier": "500M+",
  "responderSpeed": "top",
  "badgeTypes": ["B2B_BADGE", "COMPANY_STAGE_BADGE", "TOP_INVESTORS", "VALUATION500M", "YC_BADGE"],
  "badgeLabels": ["B2B", "Growth Stage", "Top Investors", "$500M+ Valuation", "Y Combinator"],
  "badgesCaptured": 5,
  "companyProfileFound": true,
  "sourceUrl": "https://wellfound.com/location/new-york",
  "runId": "a1b2c3d4e5f6",
  "scrapedAt": "2026-07-24T18:12:03Z"
}

A company profile row (type="company", isChild=true) — one per hiring startup, with the same badge signals plus run-scoped hiring stats:

{
  "type": "company",
  "isChild": true,
  "companyId": "1092233",
  "companyName": "Vantage Robotics",
  "company_name": "Vantage Robotics",
  "companySlug": "vantage-robotics",
  "companyUrl": "https://wellfound.com/company/vantage-robotics",
  "companyLogo": "https://photos.wellfound.com/startups/i/1092233-abc123.png",
  "companySize": "SIZE_51_200",
  "companySizeLabel": "51-200 employees",
  "companyTagline": "Autonomous delivery robots for the last mile",
  "companyStage": "growth",
  "companyStageRaw": "growth_stage",
  "isYCBacked": true,
  "hasTopInvestors": true,
  "isGrowingFast": true,
  "isActivelyHiring": true,
  "isB2B": true,
  "isB2C": null,
  "valuationTier": "500M+",
  "responderSpeed": "top",
  "badgeTypes": ["B2B_BADGE", "COMPANY_STAGE_BADGE", "TOP_INVESTORS", "VALUATION500M", "YC_BADGE"],
  "badgeLabels": ["B2B", "Growth Stage", "Top Investors", "$500M+ Valuation", "Y Combinator"],
  "badgesCaptured": 5,
  "openRolesInRun": 3,
  "roleTitlesInRun": ["Senior Machine Learning Engineer", "Robotics Firmware Engineer", "Product Manager, Perception"],
  "jobIdsInRun": ["4361872", "4361890", "4361911"],
  "runId": "a1b2c3d4e5f6",
  "scrapedAt": "2026-07-24T18:12:05Z"
}

If a target is unreachable after every proxy tier is exhausted, or a job card can't be parsed at all, the run pushes an accounting row instead of failing silently — also unbilled:

{
  "type": "error",
  "isChild": false,
  "job_title": null,
  "company_name": null,
  "URL": "https://wellfound.com/role/r/rust-engineer",
  "errorReason": "proxy_exhausted",
  "errorDetail": "anti-bot blocked every proxy tier",
  "sourceUrl": "https://wellfound.com/role/r/rust-engineer",
  "runId": "a1b2c3d4e5f6",
  "scrapedAt": "2026-07-24T18:14:41Z"
}

What's deliberately not on any row: exact employee headcount, funding rounds, amount raised, founders, founded-year and named investors. Those fields live only on wellfound.com/company/<slug>, which is DataDome-walled to logged-out traffic — the Actor doesn't attempt that page and doesn't emit those fields as empty columns to look complete.

How can I use the data extracted with this scraper?

• 🎯 Recruiters and sourcers — filter badgeLabels and companyStage for startups matching your target profile (growth-stage, YC-backed, actively hiring), then use companySlug and openRolesInRun to build an outbound lead list.
• 🤖 AI engineers and LLM developers — an agent issues a query (a hiring market or role keyword), receives structured job and company JSON back, and passes it to the model as grounding context for a research or sourcing assistant.
• 📊 Market and VC researchers — track which startups in a market carry isGrowingFast, hasTopInvestors or a rising valuationTier, without needing a data feed from the companies themselves.
• 🧭 Product and growth teams — read roleTitlesInRun across a market to spot which roles competitors are hiring for right now, as a proxy for where they're investing.

How do you monitor startup hiring signals over time?

Wellfound's badge signals change as a company's fundraising and hiring activity change — a startup can gain a GROWING_FAST badge, cross a valuationTier threshold, or pick up hasTopInvestors between one run and the next. Repeated, scheduled querying turns this Actor's company rows into a change feed instead of a one-time snapshot.

The fields worth diffing between runs are companyStage, isYCBacked, hasTopInvestors, isGrowingFast, valuationTier, responderSpeed, and openRolesInRun — keyed on companySlug, which is stable across runs for the same startup. A rising openRolesInRun for a company that previously had none is itself a hiring-intent signal, independent of any badge.

A practical workflow: schedule a run across your target hiring markets or role keywords (Apify Schedules, from the Actor's Schedule tab in the Console), keep the companyProfiles dataset export from each run, and diff consecutive exports on companySlug. Alert on any badge appearing that wasn't present last time, or on openRolesInRun jumping — both are leading indicators that a company changed its hiring or funding posture. The Actor itself has no built-in diffing or alerting; it produces a clean per-run snapshot, and the comparison is a job for your own pipeline or a workflow tool triggered off Apify's scheduled-run webhook.

Integrate the scraper and automate your workflow

Wellfound Jobs & Startup Company Profile Scraper works with any language or tool that can send an HTTP request, through the Apify API.

REST API with Python

from apify_client import ApifyClient

client = ApifyClient("<APIFY_API_TOKEN>")

run = client.actor("<YOUR_USERNAME>/wellfound-jobs-startup-company-profile-scraper").call(
    run_input={
        "hiringLocation": "Austin",
        "roleKeyword": "backend engineer",
        "listingPages": 2,
        "postedWithin": "week",
    }
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item.get("type") == "company":
        print(item["companyName"], item.get("badgeLabels"), item.get("openRolesInRun"))

Query in, structured JSON out — the same call works for a one-off pull or as a step inside a larger agent or pipeline.

Scheduled monitoring and delivery

The Actor has no built-in webhook delivery of its own, but it runs on the standard Apify platform mechanisms: set up a recurring run from the Actor's Schedule tab in the Console, or configure an Apify webhook to fire on ACTOR.RUN.SUCCEEDED and push the resulting dataset ID to your own endpoint. Both are Apify platform features available to every Actor, not something this one adds.

Is it legal to scrape Wellfound job listings?

Scraping publicly accessible Wellfound job listings and company search results is generally lawful — this Actor returns only what any visitor to wellfound.com can see without logging in, and hiQ Labs v. LinkedIn Corp., 9th Cir., 2019, is the commonly cited U.S. precedent establishing that scraping publicly available web data does not by itself violate the Computer Fraud and Abuse Act. Because the data here is business and product information — job postings, company names, funding-stage badges — rather than personal data about private individuals, the relevant framework is Wellfound's own Terms of Service and database-rights law, not GDPR or CCPA. Scraping for one-off research or monitoring carries a different risk profile than scraping to train a model or build a competing product at scale. Consult your legal team for commercial use cases involving bulk data storage or redistribution.

❓ Frequently asked questions

Which hiring markets, roles and companies can I filter for?

Set hiringLocation for a market (city or region, e.g. "London"), roleKeyword for a role or tech stack (e.g. "rust"), startupName to profile a single company, or paste your own listing URLs into startUrls. Location and role keyword combine; a bare location with no keyword profiles every startup hiring there.

What do employmentType and postedWithin actually filter?

employmentType keeps only job cards of that type (FULLTIME, PARTTIME, CONTRACTOR, INTERN) when deciding which companies count as hiring — since a company appears only if at least one of its jobs survives the filters, this doubles as a company filter. postedWithin keeps only jobs posted inside the chosen window (today, 3days, week, month), useful for finding startups hiring right now rather than months ago.

How does the scraper handle Wellfound's anti-bot measures?

It runs a real stealth browser (Camoufox) rather than a plain HTTP client, and starts every session through Apify Residential proxy by default, because Wellfound's DataDome layer reliably blocks direct and datacenter cloud connections. If a page still comes back as an anti-bot stub, the Actor retries on a fresh residential session with a new exit IP, up to three times per target before giving up and logging an unbilled error row.

Does the scraper extract startup company badge signals like YC backing and valuation tier?

Yes. companyStage, isYCBacked, hasTopInvestors, isGrowingFast, valuationTier, isB2B/isB2C, and responderSpeed are all derived from the Badge entities Wellfound attaches to a company in the search-listing payload. A badge Wellfound doesn't display for a given company comes back as null, not false — it's read as "not stated," not "confirmed absent."

Does it return employee headcount, funding rounds or founder names?

No. Those fields live only on wellfound.com/company/<slug>, which is DataDome-walled to logged-out traffic — this Actor verified 4 out of 4 attempts blocked across 3 fresh browser sessions and does not attempt that page. companySizeLabel (a band like "51-200 employees") is the closest available substitute, sourced from the same listing payload as everything else.

Does the scraper always fetch the full job description?

Wellfound ships the description inside the listing payload for most cards, so fetchJobDescriptions (on by default) usually costs nothing extra — it only opens the individual job page for the rare card that arrives without one. If job-detail pages stop returning a parseable description for several cards in a row (a sign that surface is currently anti-bot blocked for this session), the Actor disables the per-job fetch for the rest of the run and logs why, rather than retrying every remaining card against a wall. Listing and company fields are unaffected either way.

What does the headless setting change?

headless (default true) runs the Camoufox stealth browser without a visible window, which is what every Apify Console run uses. Turning it off only makes sense when running the Actor's source locally for debugging, so you can watch the browser navigate Wellfound in real time.

How many job rows does a run return, and what counts toward maxItems?

maxItems caps job rows only — the billed, top-level items — with 0 meaning no cap. Company rows are children of the jobs and are never counted against the cap or charged, so a maxItems=25 run can produce 25 job rows plus however many distinct companies those jobs belong to. Per-seed pagination is bounded by listingPages (1–100), and a location page carries roughly 50 jobs per page.

Why are some companySizeLabel or badge fields empty?

Because Wellfound itself didn't attach that badge or field to the company on the listing page you queried, and the Actor never fabricates or defaults a missing value — an absent field means "Wellfound didn't show this," not "this is false" or "this doesn't exist."

How do I monitor which startups are hiring over time?

Schedule repeated runs across the same hiring market or role keyword (via Apify Schedules), export the companyProfiles view each time, and diff consecutive exports on companySlug — watch openRolesInRun, companyStage, and the badge fields for changes.

Does this scraper work with Claude, ChatGPT and AI agent frameworks?

It's callable as a standard HTTP endpoint via the Apify API from any agent framework — there's no dedicated MCP server for this Actor. An agent can call the Actor with a query, receive the job and company JSON back, and use it as grounding context before answering.

How does this compare to other Wellfound scrapers?

As checked on the Apify Store on 2026-07-25: thirdwatch/wellfound-jobs-scraper returns job fields plus company_size and company_tagline, but no funding-stage, YC-backing or investor badge signals, and no separate company dataset. memo23/wellfound-jobs-scraper offers an opt-in enrichment pass that fetches the DataDome-walled /company/<slug> page directly for funding rounds and founder names, at extra per-company cost and a documented 70–90% success rate (as low as 0% in degraded windows, per its own listing) — this Actor takes the opposite trade-off, deriving badge signals only from the already-downloaded listing payload so every company row is free, fast and doesn't depend on getting past DataDome a second time, at the cost of not offering funding amounts or founder identities at all.

Do I need to manage proxies or a Wellfound account myself?

No account is needed — the Actor reads public search results. Proxy handling is automatic: by default the Actor opens an Apify Residential proxy session for you, and escalates through the tiers itself if a page comes back blocked. Supplying your own proxyConfiguration is optional and only needed if you want a specific proxy group or country.

💬 Your feedback

Found a bug, a Wellfound layout change that broke extraction, or a badge type this Actor doesn't parse yet? Open an issue from the Actor's page on the Apify Console, or reach out via the Console's built-in support chat — reports like this keep the badge parser and page-readiness detection current as Wellfound's site changes.