Wellfound Startup Jobs Scraper

Extract public Wellfound startup jobs into structured records for recruiting, job aggregation, market research, and scheduled change monitoring.

The Actor accepts Wellfound role and location filters or public search URLs. It returns the company, role, description, locations, remote policy, compensation, equity, experience range, canonical URL, and posting timestamp available in Wellfound's public result pages.

What does this Wellfound scraper do?

Wellfound organizes startup openings into public role and location pages. This Actor converts those pages into integration-ready JSON without requiring a Wellfound login.

It can:

• scrape a Wellfound role such as software-engineer;
• combine roles with locations such as new-york or berlin;
• select Wellfound's remote role pages;
• process public /jobs and /role search URLs;
• paginate with explicit item and page limits;
• normalize salary and equity ranges while retaining the source text;
• deduplicate jobs by stable Wellfound listing ID;
• label jobs NEW, UPDATED, or UNCHANGED between scheduled runs;
• emit only new or changed jobs to reduce downstream work.

Who is it for?

Recruiters and talent teams

Build focused startup-job lists by role, location, compensation, and remote availability. Schedule the Actor to watch searches your team repeats.

Job boards and data teams

Send consistent Wellfound job records into a spreadsheet, warehouse, database, or internal search index.

Startup and labor-market analysts

Compare hiring activity, compensation ranges, remote policies, and role demand across startup segments and locations.

AI agents and workflow builders

Use the Actor through the Apify API or MCP to retrieve current source records before summarization, matching, or enrichment.

Why use this Actor?

• Structured SSR extraction: parses Wellfound's embedded application state, rather than relying only on fragile visible text selectors.
• Role and location targeting: supports Wellfound's public SEO result routes.
• Rich job rows: result pages can include the full description as well as compensation, experience, startup, and remote fields.
• Change monitoring: persistent hashes identify listing changes between runs.
• Bounded anti-block handling: rotates challenged browser sessions and can fall back from datacenter to sticky US residential proxies.
• Cost control: blocks images, media, fonts, and unrelated third-party requests; duplicate or filtered records are not charged.

What data can you extract?

Field	Meaning
jobId	Stable Wellfound listing ID
title	Job title
companyName	Hiring startup name
companySlug	Wellfound startup slug
companySize	Company-size band, when available
companyDescription	Short startup description
jobType	Employment type
primaryRole	Wellfound role title or slug
description	Public job description, when embedded
locations	Listed job locations
acceptedRemoteLocations	Regions accepted for remote work
remote	Whether the job is remote-capable
remoteType	Remote configuration such as REMOTE
compensation	Original salary and equity text
salaryMin, salaryMax	Parsed salary range
equityMinPercent, equityMaxPercent	Parsed equity range
experienceMinYears, experienceMaxYears	Experience range
postedAt	Wellfound listing start timestamp
url	Canonical Wellfound job URL
sourceUrl	Result page used for extraction
badges	Startup badges from the result
changeType	FOUND, NEW, UPDATED, or UNCHANGED
scrapedAt	Extraction timestamp

Source fields can be absent. Missing values are returned as null or an empty array rather than invented.

How to scrape Wellfound startup jobs

1. Open the Actor input in Apify Console.
2. Add one or more role slugs, such as software-engineer.
3. Optionally add location slugs, such as new-york.
4. Set remoteOnly if you need Wellfound's remote route.
5. Keep proxyTier set to AUTO unless you are testing a specific proxy path.
6. Choose maxItems and maxPages.
7. Start the run and open the Wellfound jobs dataset view.
8. Export the dataset or connect it to your workflow.

A useful first input is:

{
  "roles": ["software-engineer"],
  "locations": ["new-york"],
  "maxItems": 20,
  "maxPages": 1,
  "proxyTier": "AUTO"
}

Input parameters

Input	Type	Default	Description
roles	string array	software-engineer in prefill	Wellfound role slugs
locations	string array	empty	Wellfound location slugs combined with roles
query	string	empty	Post-filter for title, company, role, or description
startUrls	URL array	empty	Public Wellfound /jobs or /role search URLs
remoteOnly	boolean	false	Use remote role routes and keep remote jobs
maxItems	integer	50	Maximum unique jobs saved
maxPages	integer	3	Maximum pages per route
proxyTier	enum	AUTO	Automatic, datacenter-only, or US residential-only
monitorChanges	boolean	false	Compare jobs with a prior snapshot
stateKey	string	empty	Stable label for one monitored search
onlyNewOrChanged	boolean	false	Skip unchanged records in monitoring mode

Role and location values are lowercase URL slugs. The Actor rejects malformed values and non-Wellfound URLs before scraping.

Free-text filtering

Wellfound's public /jobs?q= surface currently exposes a bounded featured set, not a guaranteed exhaustive keyword index. The Actor therefore applies query to the returned title, company, role, and description.

Use a public role route for broad source coverage. Use query to narrow those records or to inspect the current public /jobs set.

Wellfound role and URL examples

Software engineering:

{
  "roles": ["software-engineer"],
  "maxItems": 50
}

Product management in Berlin:

{
  "startUrls": [
    { "url": "https://wellfound.com/role/l/product-manager/berlin" }
  ],
  "maxItems": 20,
  "maxPages": 1
}

Remote data analyst jobs:

{
  "roles": ["data-analyst"],
  "remoteOnly": true,
  "maxItems": 50
}

Output example

A current result has this shape:

{
  "jobId": "3317746",
  "title": "Software Engineer",
  "companyName": "Keeper",
  "companySlug": "keeper-tax",
  "companySize": "11-50",
  "companyDescription": "File your complex taxes confidently",
  "jobType": "full-time",
  "primaryRole": "Software Engineer",
  "description": "Mission and role details...",
  "locations": ["San Francisco"],
  "acceptedRemoteLocations": ["United States"],
  "remote": true,
  "remoteType": "ONSITE_OR_REMOTE",
  "compensation": "$135k – $175k • 0.05% – 0.25%",
  "salaryMin": 135000,
  "salaryMax": 175000,
  "equityMinPercent": 0.05,
  "equityMaxPercent": 0.25,
  "experienceMinYears": 0,
  "experienceMaxYears": null,
  "postedAt": "2026-07-28T20:58:57.000Z",
  "url": "https://wellfound.com/jobs/3317746-software-engineer",
  "sourceUrl": "https://wellfound.com/role/software-engineer?page=1",
  "badges": ["ACTIVELY_HIRING"],
  "changeType": "FOUND",
  "scrapedAt": "2026-08-09T14:20:00.000Z"
}

The source changes continuously, so IDs, listings, and values in future runs will differ.

Monitor new and changed Wellfound jobs

Enable monitorChanges and provide a stable stateKey. The first run labels current jobs NEW. Later runs compare stable content fields:

• NEW: listing ID was not in the prior snapshot;
• UPDATED: tracked listing content changed;
• UNCHANGED: content hash is the same;
• FOUND: ordinary non-monitoring run.

Example:

{
  "roles": ["data-analyst"],
  "remoteOnly": true,
  "maxItems": 100,
  "maxPages": 2,
  "monitorChanges": true,
  "stateKey": "remote-data-analyst-watch",
  "onlyNewOrChanged": true
}

Use the same stateKey only for the same search universe. Changing roles, locations, or limits while reusing a key changes what the snapshot represents.

How much does it cost to scrape Wellfound startup jobs?

The Actor uses pay-per-event pricing:

• one start event per run;
• one item event for each emitted dataset record;
• filtered, duplicate, unchanged-skipped, and failed records are not item events.

The measured configuration charges a $0.005 start fee. At the BRONZE item tier, each emitted job is $0.0013131.

Emitted jobs	Example BRONZE total
20	$0.031262
100	$0.13631
500	$0.66155

Actual item rates depend on the applicable Apify pricing tier. Proxy and compute usage can vary with anti-bot retries, but users are billed through the declared Actor events rather than a separate proxy event.

Scheduling and export workflows

Recruiting monitor

Schedule the monitoring input daily. Send only NEW and UPDATED rows to Slack, a CRM, or an applicant-tracking workflow.

Labor-market dataset

Run a list of role/location URLs on a regular schedule. Export JSON, CSV, Excel, XML, or RSS through Apify dataset endpoints.

Compensation analysis

Store salaryMin, salaryMax, and equity fields in a warehouse. Retain compensation to audit parsing against the source text.

Startup enrichment

Join companyName or companySlug with a separate company-domain or enrichment workflow. This Actor intentionally keeps its primary output job-focused.

Run with the Apify API

Replace APIFY_TOKEN with your token.

cURL

curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~wellfound-startup-jobs-scraper/runs?token=APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"roles":["software-engineer"],"locations":["new-york"],"maxItems":20}'

To wait and retrieve dataset items:

curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~wellfound-startup-jobs-scraper/run-sync-get-dataset-items?token=APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"roles":["product-manager"],"maxItems":10}'

JavaScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/wellfound-startup-jobs-scraper').call({
  roles: ['software-engineer'],
  locations: ['new-york'],
  maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python

from apify_client import ApifyClient

client = ApifyClient('APIFY_TOKEN')
run = client.actor('automation-lab/wellfound-startup-jobs-scraper').call(
    run_input={
        'roles': ['data-analyst'],
        'remoteOnly': True,
        'maxItems': 20,
    }
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

Use through MCP

Add the Actor to Claude Code:

claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/wellfound-startup-jobs-scraper"

Claude Desktop, Cursor, and VS Code setup

Use the same remote MCP server JSON in Claude Desktop, Cursor, or VS Code:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/wellfound-startup-jobs-scraper"
    }
  }
}

Example prompts:

• "Find current Wellfound software engineer jobs in New York and compare salary ranges."
• "Run my remote data analyst monitor and summarize only new or updated roles."
• "Export the current Berlin product manager listings as a concise table."

Performance and proxy behavior

The target uses Cloudflare and DataDome. A direct request may return a challenge instead of job data.

AUTO uses this bounded strategy:

1. open a sticky datacenter browser session;
2. reuse a healthy identity for pages in the run;
3. retire an identity after a challenge or missing structured state;
4. retry with another datacenter identity;
5. fall back to sticky US residential identities when necessary.

Images, fonts, media, analytics, and unrelated third-party requests are blocked. A run fails clearly after bounded retries instead of silently returning a false empty dataset.

Limits and expected behavior

• Wellfound can change its routes, embedded state, fields, and anti-bot rules.
• Public role pages expose a subset of all jobs per startup and page.
• Free-text filtering is bounded by the records Wellfound exposes publicly.
• Some listings omit compensation, equity, experience, or remote details.
• Salary parsing preserves source text but does not convert currencies.
• A source page with no matching jobs produces an empty dataset successfully.
• A challenge after all configured retries fails the run with a non-zero status.
• Monitoring tracks listings observed within your chosen page and item limits.

Troubleshooting

The run failed with a Wellfound challenge

Use AUTO first. If your workflow deliberately forced DATACENTER, retry with RESIDENTIAL. Do not repeatedly rerun an unchanged failed task without checking the run log and source availability.

My location returned no jobs

Use the lowercase Wellfound URL slug, such as new-york, and verify that the corresponding public role/location page exists. Naturally sparse searches can return zero records.

Why are compensation fields null?

Wellfound does not publish compensation for every job. The Actor does not infer or estimate missing salary or equity.

Why did a second monitoring run emit nothing?

With onlyNewOrChanged: true, that is the expected result when all observed jobs match the previous snapshot.

Responsible use and legality

This Actor accesses public, anonymous Wellfound pages. Web-scraping rules vary by jurisdiction and use case. Review Wellfound's terms, robots guidance, applicable privacy law, employment-data rules, and your contractual obligations.

Do not use job data for unlawful discrimination, harassment, spam, or attempts to identify private individuals. Minimize retained data, respect deletion and access rights where applicable, and use conservative schedules.

FAQ

Does this require a Wellfound account?

No. The supported routes are public and anonymous.

Can it scrape any job title as a role?

Role inputs follow Wellfound's URL taxonomy. Common values include software-engineer, product-manager, data-analyst, growth-marketer, sales-manager, and operations-manager.

Does it include full job descriptions?

Role and location result state commonly includes descriptions. The field is nullable because Wellfound can omit or change it.

Can I export to Excel or Google Sheets?

Yes. Use Apify's dataset export or integrations after the run.

Can I run it on a schedule?

Yes. Apify schedules are especially useful with monitorChanges and onlyNewOrChanged.

Are unchanged jobs charged in monitoring mode?

They are not item events when onlyNewOrChanged is enabled.

Related automation-lab Actors

• Cutshort Jobs Scraper for another technology hiring source.
• Company Domain Finder to enrich hiring-company names with domains in a separate workflow.

These Actors are optional. Wellfound extraction works independently.