# Wellfound Jobs Scraper: Startup Salary, Equity and Funding (`themineworks/wellfound-jobs-scraper`) Actor

Scrape Wellfound (AngelList Talent) startup jobs by role, city or remote: salary and equity ranges, experience, remote policy, posted date, full description, skills, visa, and the startup's size, stage, funding and website. No login.

- **URL**: https://apify.com/themineworks/wellfound-jobs-scraper.md
- **Developed by:** [The Mine Works](https://apify.com/themineworks) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.49 / 1,000 jobs

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Wellfound Jobs Scraper: Startup Salary, Equity and Funding

[![200 Wellfound jobs in 21 seconds](https://api.apify.com/v2/key-value-stores/cUXz95yxflDho41nn/records/wellfound-jobs-scraper-hero.png)](https://console.apify.com/actors/aXEEnaJ9aMt1Eo6aA/input)

From **The Mine Works**, makers of [Threads Scraper](https://apify.com/themineworks/threads-scraper) and [B2B Leads Finder](https://apify.com/themineworks/b2b-leads-finder), with over 140,000 runs across 170+ public actors.

### Why choose this actor?

- **Salary, equity and funding in one row, without a login.** Every job comes with its salary range and currency, the equity range when one is offered, experience, remote policy and posted date, plus the startup's size, stage, total raised and latest round. In our proof run, 200 San Francisco software engineer and product manager jobs from 90 startups came back in 21 seconds: 174 with a salary range, 34 with an equity range, 129 with funding figures and all 200 with the company website. No Wellfound account, no cookies from you.
- **Search the way Wellfound lists jobs.** By role (software engineer, product manager, data scientist, python developer and hundreds more), by city, remote only, or any mix, with filters for job type and keywords. Each role and city pair is its own search, up to 5,000 jobs deep. A role or city Wellfound does not know gives a free status row instead of jobs from somewhere else.
- **You pay only for open jobs you receive.** One charge per job row saved to your dataset, plus a flat start fee per run. Jobs filtered out, a job already delivered by another search in the same run (10 in our proof run), and jobs Wellfound has taken down but still lists (6 in our proof run) are never charged.

[![Run it on Apify](https://api.apify.com/v2/key-value-stores/cUXz95yxflDho41nn/records/button-run.png)](https://console.apify.com/actors/aXEEnaJ9aMt1Eo6aA/input)

**Part of The Mine Works Jobs and hiring family:** [Foundit Monster India Jobs](https://apify.com/themineworks/foundit-jobs-scraper), [Hirist Jobs Scraper](https://apify.com/themineworks/hirist-jobs-scraper), [India Jobs MCP](https://apify.com/themineworks/india-jobs-mcp), [Naukri Jobs Scraper](https://apify.com/themineworks/naukri-jobs), [Shine.com Jobs Scraper](https://apify.com/themineworks/shine-jobs-scraper), [Internshala Scraper](https://apify.com/themineworks/internshala-jobs-scraper).

### Try it in one minute

Paste this input and press Start. It returns 20 remote data scientist jobs with salary, company and funding details, in 6 to 15 seconds:

```json
{
  "roles": ["data scientist"],
  "remote": "remote_only",
  "maxJobsPerSearch": 20
}
```

You can give the search in three ways, alone or together:

- **`roles`**: role names as Wellfound uses them (`software engineer`, `product manager`, `data scientist`, `designer`, `sales`, `python developer`, `react developer`) or a role link such as `https://wellfound.com/role/software-engineer`.
- **`locations`**: city names as Wellfound lists them (`san francisco`, `new york`, `london`, `bangalore`, `berlin`, `toronto`). Each role is searched in each city. Common spellings are mapped for you, so `NYC`, `Bengaluru` and `Washington DC` work.
- **`startUrls`**: Wellfound job list links (`/role/r/data-scientist`, `/role/l/product-manager/new-york`, `/location/london`, `/remote`) or single job links (`https://wellfound.com/jobs/4787326-software-engineer`).

Apify's free plan includes $5 of credit every month, which covers about 1,900 results at this actor's price.

#### Copy to your AI assistant

```text
themineworks/wellfound-jobs-scraper on Apify. Scrapes startup jobs from Wellfound (formerly AngelList Talent) without a login, by role, city or remote, and returns one row per job with title, salary range and currency, equity range, experience, job type, locations, remote policy, posted date, full description, and the startup's name, size, stage, badges (Top Investors, YC Funded), website, industries, total raised and latest funding round. Call ApifyClient("TOKEN").actor("themineworks/wellfound-jobs-scraper").call(run_input={"roles": ["software engineer"], "locations": ["san francisco"], "maxJobsPerSearch": 100}), then client.dataset(run["defaultDatasetId"]).list_items().items. Required: at least one of roles (role names or role links), locations (city names), startUrls (Wellfound list or job links), or remote set to remote_only. Optional: remote (any, remote_only, onsite_only; default any), jobTypes (full-time, contract, internship, cofounder), keywords (keep jobs mentioning any of them), maxJobsPerSearch (default 100, 20 to 5000), includeCompanyDetails (default true; reads each job page for skills, visa, funding and company website). Skip rows that have "_type": "status". Full spec: GET https://api.apify.com/v2/acts/themineworks~wellfound-jobs-scraper/builds/default (Bearer TOKEN), which returns inputSchema and readme. Token: https://console.apify.com/account/integrations
```

### Key features

- **Up to 62 fields per job**: id, link, title, Wellfound role, job type, salary text plus parsed minimum, maximum, currency and period, equity minimum and maximum, locations, remote flag and policy, where remote hires may live, years of experience, posted date, the full description, and the applicant tracking system the job came from (Ashby, Greenhouse, Workable).
- **Startup fields on every row**: name, Wellfound page, logo, one line pitch, employee band, stage, and badges such as Top Investors, YC Funded, Actively Hiring and response time.
- **Job page details, on by default**: skills, visa sponsorship, relocation, preferred time zones, collaboration hours, the exact salary currency and period, job addresses with city, region and country, the startup's website, industries, base location, company type, total raised, number of rounds, and the latest round with its date and amount.
- **Role, city and remote searches in one run**: give 3 roles and 4 cities and you get 12 searches, up to 100 searches and 1,000 job links per run. Each search reads about 40 jobs a page and stops at your limit or at the end of Wellfound's list.
- **Filters that cost you nothing**: remote only or on site only, job types, and keywords matched against the title, role, skills and description. Jobs that do not match are skipped before any charge.
- **Clear outcomes**: a search for a role or city Wellfound does not know, a closed job link, or a search where nothing matched your filters returns a free status row that says why, and the run summary (the OUTPUT record) lists every search with pages read, jobs seen, jobs filtered, duplicates and Wellfound's own total.

### How to use it

#### Basic: one role everywhere

```json
{
  "roles": ["software engineer"],
  "maxJobsPerSearch": 100
}
```

#### Several roles in several cities

Each role is searched in each city, so this is 4 searches of up to 200 jobs each:

```json
{
  "roles": ["product manager", "data scientist"],
  "locations": ["new york", "london"],
  "maxJobsPerSearch": 200
}
```

#### Remote jobs only

With no city, `remote_only` reads Wellfound's remote lists for each role. With cities, it keeps the jobs in those cities that allow remote work.

```json
{
  "roles": ["backend engineer", "devops engineer"],
  "remote": "remote_only",
  "maxJobsPerSearch": 300
}
```

#### Salary benchmark for a role

Pull a few hundred jobs for one role and city, then compare `salary_min`, `salary_max`, `equity_min_pct` and `equity_max_pct` by `company_stage` or `company_size`. Run it monthly to see pay move. Our proof run had a salary range on 174 of 200 jobs.

```json
{
  "roles": ["software engineer"],
  "locations": ["san francisco"],
  "jobTypes": ["full-time"],
  "maxJobsPerSearch": 500
}
```

#### Startups that are hiring, for sales and recruiting teams

Every row names the startup, its website, size, stage, badges and funding, so one run of a role list doubles as a list of funded companies that are hiring right now. Filter on `yc_funded`, `top_investors`, `funding_last_round` or `company_size` after the run. Schedule it weekly and keep only companies you have not seen.

```json
{
  "roles": ["account executive", "sales"],
  "remote": "remote_only",
  "maxJobsPerSearch": 300
}
```

#### Niche skills inside a broad role

Keywords keep only jobs whose title, role, skills or description mention one of them. Filtered jobs are not charged, so a narrow keyword on a broad role costs only the jobs that match.

```json
{
  "roles": ["software engineer"],
  "keywords": ["rust", "golang"],
  "maxJobsPerSearch": 100
}
```

#### Daily feed of new jobs

Every row has `posted_at` and a stable `job_id`. Schedule a daily run (Apify Schedules, for example every morning at 07:00) with the same input, and keep rows whose `posted_at` is newer than your last run, or whose `job_id` you have not stored yet.

#### Refresh a list of job links

Give job links in `startUrls` to read each job page directly, for example to check that saved jobs are still open. A job Wellfound has taken down comes back as a free `job_closed` status row.

```json
{
  "startUrls": [
    "https://wellfound.com/jobs/4785402-software-engineer-iii",
    "https://wellfound.com/jobs/4718887-senior-product-manager-foundations"
  ]
}
```

#### Faster runs with the list fields only

Turn off `includeCompanyDetails` to skip the job pages. You still get title, salary and equity text with parsed numbers, locations, remote policy, experience, posted date, the full description and the startup's size, stage and badges, about 40 jobs per request. A check run of 18 role and city lists with the list fields only returned 340 jobs in 10 seconds.

```json
{
  "roles": ["designer"],
  "includeCompanyDetails": false,
  "maxJobsPerSearch": 1000
}
```

### Input parameters

| Parameter | Type | Default | What it does |
|---|---|---|---|
| `roles` | array of strings | none (Console form shows `software engineer`) | Role names as Wellfound uses them, or role links. Each role is searched in each city. |
| `locations` | array of strings | none | City names as Wellfound lists them. Empty means everywhere. |
| `remote` | string | `any` | `any`, `remote_only` or `onsite_only`. |
| `jobTypes` | array of strings | all | Keep only `full-time`, `contract`, `internship` or `cofounder` jobs. |
| `keywords` | array of strings | none | Keep only jobs whose title, role, skills or description mention at least one word. |
| `maxJobsPerSearch` | integer | `100` | Most jobs per role and city pair or per list link, 20 to 5,000. |
| `includeCompanyDetails` | boolean | `true` | Also read each job page for skills, visa, time zones, exact salary terms and the startup's website, industries, location, type and funding. |
| `startUrls` | array of strings | none | Wellfound list links (`/role/...`, `/role/r/...`, `/role/l/.../...`, `/location/...`, `/remote`) or job links (`/jobs/<id>`). |

With nothing filled in at all, the run reads remote software engineer jobs as an example. With only `remote` set to `remote_only`, it reads Wellfound's list of all remote jobs. Up to 100 searches and 1,000 job links per run.

### What data do you get?

One row per job. Fields with no value on Wellfound are left out of the row rather than sent empty.

**The job**: `job_id`, `job_url`, `title`, `primary_role`, `job_type`, `compensation` (as Wellfound writes it), `salary_min`, `salary_max`, `salary_currency`, `salary_period`, `equity_min_pct`, `equity_max_pct`, `offers_equity`, `locations`, `remote`, `remote_policy`, `remote_hiring_locations`, `experience_min_years`, `experience_max_years`, `posted_at`, `description`, `applicant_tracking_system`.

**The startup**: `company_id`, `company_name`, `company_slug`, `company_url`, `company_logo_url`, `company_tagline`, `company_size`, `company_stage`, `company_badges`, `top_investors`, `yc_funded`, `actively_hiring`.

**From the job page** (when `includeCompanyDetails` is on): `skills`, `visa_sponsorship`, `remote_work_policy`, `preferred_timezones`, `collaboration_hours`, `relocation`, `job_addresses`, `applicant_countries`, `recruiter_recently_active`, `company_website`, `company_industry`, `company_industries`, `company_location`, `company_type`, `funding_total`, `funding_rounds`, `funding_last_round`, `funding_last_round_date`, `funding_last_round_amount`, and `details_included` set to true.

**Where it came from**: `search_input`, `search_role`, `search_location`, `search_url`, `search_page`, `position`, `scraped_at`.

**Status rows** (free): `_type` is `status`, with `status` (`unknown_role`, `unknown_location`, `filtered_out`, `no_results`, `no_open_jobs`, `job_closed`, `not_found`, `blocked`, `invalid_input`) and a plain `note`.

How often fields were filled in our proof run of 200 San Francisco jobs: salary range 87%, equity range 17%, funding figures 65%, company stage 68%, years of experience 25%, skills 19%, company website, industries and visa sponsorship 100%.

#### Stable fields for automations

These fields were present in every job row from a search in our test runs, with company details on or off:

| Field | What it holds |
|---|---|
| `record_type` | `job` (status rows say `status`) |
| `job_id` | Wellfound job id, the key for de-duplication across runs |
| `job_url` | Link to the job on Wellfound |
| `title` | Job title |
| `primary_role` | Wellfound's role for the job |
| `job_type` | `full-time`, `contract`, `internship` or `cofounder` |
| `remote` | true when the job can be done remotely |
| `remote_policy` | `remote_only`, `onsite`, `onsite_or_remote` or `hybrid` |
| `posted_at` | When the job went live, UTC ISO 8601 |
| `description` | Full job description |
| `company_id` | Wellfound startup id |
| `company_name` | Startup name |
| `company_url` | Startup page on Wellfound |
| `details_included` | Whether the job page was read |
| `scraped_at` | When the row was read |

These names will not change. New fields may be added; existing ones keep their name and meaning.

#### Output examples

##### A job with equity and funding (software engineer in San Francisco)

```json
{
  "record_type": "job",
  "job_id": "1304789",
  "job_url": "https://wellfound.com/jobs/1304789-senior-software-engineer",
  "title": "Senior Software Engineer",
  "primary_role": "Software Engineer",
  "job_type": "full-time",
  "compensation": "$170k to $200k • 0.088% to 0.2%",
  "salary_min": 170000,
  "salary_max": 200000,
  "salary_currency": "USD",
  "salary_period": "year",
  "equity_min_pct": 0.088,
  "equity_max_pct": 0.2,
  "offers_equity": true,
  "locations": ["San Francisco"],
  "remote": false,
  "remote_policy": "onsite",
  "experience_min_years": 5,
  "posted_at": "2025-10-16T16:35:56.000Z",
  "description": "## Your Role\n\nAscend is seeking a Senior Software Engineer to join our team on-site in San Francisco to help expand our core product...",
  "applicant_tracking_system": "Greenhouse",
  "company_id": "8285365",
  "company_name": "Ascend",
  "company_url": "https://wellfound.com/company/useascend",
  "company_tagline": "Finance Automation Platform for the $7T+ Insurance Industry",
  "company_size": "11-50",
  "company_stage": "Growth Stage",
  "company_badges": ["Responds within three weeks", "B2B", "Growth Stage", "Top Investors"],
  "top_investors": true,
  "yc_funded": false,
  "skills": ["Ruby", "Ruby on Rails", "Engineering", "Next.Js"],
  "visa_sponsorship": "Not Available",
  "remote_work_policy": "In office",
  "relocation": "Allowed",
  "job_addresses": [{ "city": "San Francisco", "region": "California", "country": "United States" }],
  "company_website": "https://useascend.com",
  "company_industries": ["Payments", "Insurance", "Finance Technology", "Fin Tech", "Insurtech"],
  "company_location": "Columbus",
  "company_type": "Enterprise Software Company",
  "funding_total": "$35.5M",
  "funding_rounds": 2,
  "funding_last_round": "Series A",
  "funding_last_round_date": "Jan 2022",
  "funding_last_round_amount": "$30000000",
  "search_input": "software engineer in san francisco",
  "search_url": "https://wellfound.com/role/l/software-engineer/san-francisco",
  "search_page": 2,
  "position": 48,
  "details_included": true,
  "scraped_at": "2026-10-05T21:51:13.481Z"
}
```

##### A YC startup job (product manager in San Francisco)

```json
{
  "record_type": "job",
  "job_id": "4718887",
  "job_url": "https://wellfound.com/jobs/4718887-senior-product-manager-foundations",
  "title": "Senior Product Manager, Foundations",
  "primary_role": "Product Manager",
  "job_type": "full-time",
  "compensation": "$215k to $250k",
  "salary_min": 215000,
  "salary_max": 250000,
  "salary_currency": "USD",
  "salary_period": "year",
  "locations": ["San Francisco"],
  "remote": false,
  "remote_policy": "onsite",
  "posted_at": "2026-09-15T23:00:41.000Z",
  "applicant_tracking_system": "Ashby",
  "company_name": "Vitalize Care (YC W23)",
  "company_size": "51-200",
  "company_stage": "Early Stage",
  "company_badges": ["Actively Hiring", "B2B", "Early Stage", "Top Investors", "YC Funded", "Growing fast"],
  "top_investors": true,
  "yc_funded": true,
  "actively_hiring": true,
  "company_website": "https://vitalize.care",
  "company_industries": ["Healthcare", "Hospitals"],
  "company_location": "San Francisco Bay Area",
  "funding_total": "$7.5M",
  "funding_last_round": "Seed",
  "funding_last_round_date": "Mar 2023",
  "details_included": true
}
```

##### A job read from a job link

```json
{
  "record_type": "job",
  "job_id": "4785402",
  "job_url": "https://wellfound.com/jobs/4785402-software-engineer-iii",
  "title": "Software Engineer III",
  "job_type": "full-time",
  "compensation": "$175k to $195k",
  "salary_min": 175000,
  "salary_max": 195000,
  "salary_currency": "USD",
  "salary_period": "year",
  "remote": true,
  "remote_hiring_locations": ["Everywhere"],
  "posted_at": "2026-09-30T08:15:09.000Z",
  "company_name": "Garner Health",
  "company_size": "501-1000",
  "company_stage": "Growth Stage",
  "company_website": "http://www.getgarner.com",
  "company_type": "Healthcare Technology",
  "funding_total": "$45M",
  "funding_last_round": "Series B",
  "funding_last_round_date": "Dec 2021",
  "search_input": "https://wellfound.com/jobs/4785402-software-engineer-iii",
  "details_included": true
}
```

##### Status rows (free)

```json
{
  "_type": "status",
  "record_type": "status",
  "search_input": "software engineer in atlantis",
  "search_url": "https://wellfound.com/role/l/software-engineer/atlantis",
  "status": "unknown_location",
  "note": "Wellfound has no job list for this city (it answered with a list for everywhere), so nothing was kept. Use a city Wellfound lists, for example \"san francisco\", \"new york\", \"london\" or \"bangalore\". Not charged."
}
```

```json
{
  "_type": "status",
  "record_type": "status",
  "search_input": "https://wellfound.com/jobs/3538641-software-engineer",
  "status": "job_closed",
  "note": "Wellfound says this job was taken down and no longer takes applications. Not charged."
}
```

### Pricing

Pay per event: you pay for each job delivered to your dataset, plus a flat $0.005 per run, whatever memory you choose. Nothing else is billed: no proxy add-on, no charge per page or per request.

| Event | Free plan | Bronze (Starter) | Silver (Scale) | Gold (Business) and above |
|---|---|---|---|---|
| Job delivered, per 1,000 jobs | $2.49 | $2.09 | $1.79 | $1.49 |
| Run start, once per run | $0.005 | $0.005 | $0.005 | $0.005 |

**Never charged:** jobs your filters skip, a job already delivered earlier in the same run (one job can sit in several role or city lists), jobs Wellfound has taken down but still lists, roles or cities Wellfound does not know, closed job links, pages Wellfound refuses, and the status rows that explain a search with no jobs. Company details cost nothing extra. A run that delivers nothing costs only the start fee.

To cap a run's cost, set Maximum cost per run in the run options; the actor stops delivering, and charging, when that budget is used.

### FAQ

#### What is Wellfound?

Wellfound, formerly AngelList Talent, is a job board for startups. Companies list their open roles with salary and equity ranges, and their profile shows size, stage, funding and investors. It is one of the main places to find jobs at venture backed and YC startups.

#### Do I need a Wellfound account or cookies?

No. The actor reads the public job lists and job pages that Wellfound shows to anyone who is not logged in. It never logs in and never asks you for a cookie, a password or an API key.

#### How many jobs can I get?

Up to 5,000 per role and city pair, and up to 100 searches per run. Wellfound's lists hold 20 startups per page with up to three of their open jobs each, about 40 jobs a page, and the run summary reports Wellfound's own total for every search (766 software engineer jobs in San Francisco and 1,891 remote ones when we checked in October 2026). A list may also show a startup's other open roles next to the one you searched; use `keywords` or filter on `primary_role` if you need only exact matches.

#### Which roles and cities can I use?

The ones Wellfound has lists for. Roles include engineering, product, design, data, sales, marketing and operations titles, and many skill roles such as python developer, react developer or devops engineer. Cities include the big hubs in the US, Europe, India and Canada. A name Wellfound does not know gives a free status row that says so (`unknown_role` or `unknown_location`), never jobs from a different list.

#### How fresh is the data?

Every run reads Wellfound live, so you get the jobs listed at that moment. `posted_at` is the time the job went live on Wellfound (a reposted job shows its repost time). Wellfound sometimes keeps a job in its lists after it was taken down; with company details on, the actor reads each job page and drops those jobs without charging.

#### Why do some jobs have no salary, equity or funding?

Wellfound shows what the startup entered. In our proof run 87% of jobs had a salary range and 17% an equity range, and 65% of rows had funding figures. A startup that never shared its funding has no funding block, and some show "Undisclosed amount".

#### Does it return investor names?

No. Wellfound shows investor names on the startup's own page, which this actor does not read. Every row carries the Top Investors and YC Funded badges, the total raised, the number of rounds and the latest round with its date and amount.

#### Does it return hiring manager names or emails?

No. The actor collects job and company data only, not personal contact details.

#### Do I need my own proxy?

No. The actor uses Apify's proxy, included in the price. Wellfound shows a security check to some proxy addresses; the actor moves the request to another address and keeps using the ones that work, so you never solve anything and refused requests are never charged.

#### What happens with jobs that appear in two of my searches?

They are delivered and charged once, under the first search that found them. The run summary counts the repeats per search.

#### Can I schedule it and get only new jobs?

Yes. Save your input as an Apify task and add a schedule (daily or weekly). Each row has a stable `job_id` and `posted_at`, so keep the ids you have stored and add only new ones, or keep rows newer than your last run.

#### Which export formats are there?

JSON, CSV, Excel, XML, RSS and HTML from the dataset page or the API, plus direct sends to Google Sheets and other tools through Apify integrations. Nested fields such as `skills` and `job_addresses` are arrays in JSON and are flattened into columns in CSV and Excel.

#### Can I use it from Claude, ChatGPT or another AI assistant?

Yes, through Apify's MCP server.

- Connector URL: https://mcp.apify.com/?tools=themineworks/wellfound-jobs-scraper
- Claude: Settings > Connectors > Add custom connector, paste the URL, sign in with Apify.
- ChatGPT: turn on developer mode, add an MCP connector with the URL, sign in with Apify.
- Cursor or VS Code: add it as an HTTP MCP server with that URL.
- Claude Code: `claude mcp add -t http wellfound-jobs-scraper "https://mcp.apify.com/?tools=themineworks/wellfound-jobs-scraper"`

#### Is it legal to scrape Wellfound?

The actor collects only public job and company data that Wellfound shows to anyone without logging in, and it does not log in or bypass any login. You are responsible for how you use the data: check Wellfound's terms for your use case and the data protection laws that apply to you, such as GDPR and CCPA.

### Integrations

- **Google Sheets**: send each run's dataset to a sheet with Apify's Google Sheets integration, one row per job.
- **Make, Zapier and n8n**: start a run and read its dataset with the Apify apps and nodes, for example to post new remote jobs to Slack or add hiring startups to a CRM.
- **Webhooks**: have Apify call your URL when a run finishes, then fetch the dataset.
- **API**: start runs and read results from any language with the Apify API or the Python and JavaScript clients (see "Copy to your AI assistant" above).
- **MCP clients**: Claude, ChatGPT, Cursor, VS Code and Claude Code, through the connector URL in the FAQ.

### More from The Mine Works

**Jobs and hiring**

- [Foundit Monster India Jobs](https://apify.com/themineworks/foundit-jobs-scraper)
- [Hirist Jobs Scraper](https://apify.com/themineworks/hirist-jobs-scraper)
- [India Jobs MCP](https://apify.com/themineworks/india-jobs-mcp)
- [Naukri Jobs Scraper](https://apify.com/themineworks/naukri-jobs)
- [Shine.com Jobs Scraper](https://apify.com/themineworks/shine-jobs-scraper)
- [Internshala Scraper](https://apify.com/themineworks/internshala-jobs-scraper)
- [Indeed Jobs Scraper](https://apify.com/themineworks/indeed-scraper)
- [Instahyre Jobs Scraper](https://apify.com/themineworks/instahyre-jobs-scraper)
- [Apna Jobs Scraper](https://apify.com/themineworks/apna-jobs-scraper)
- [CutShort Jobs Scraper](https://apify.com/themineworks/cutshort-jobs-scraper)
- [LinkedIn Jobs Scraper](https://apify.com/themineworks/linkedin-jobs-scraper)
- [Recruiting & Jobs MCP](https://apify.com/themineworks/recruiting-jobs-mcp)

**Social media and video**

- [Threads Scraper](https://apify.com/themineworks/threads-scraper)
- [Reddit Scraper](https://apify.com/themineworks/reddit-scraper)
- [Threads Search Scraper](https://apify.com/themineworks/threads-search-scraper)
- [Instagram Profile Scraper](https://apify.com/themineworks/instagram-profile-scraper)

**Leads and business directories**

- [B2B Leads Finder](https://apify.com/themineworks/b2b-leads-finder)
- [Skip Trace Lookup](https://apify.com/themineworks/skip-trace-lookup)
- [Google Maps Email Scraper](https://apify.com/themineworks/maps-leads)
- [2GIS Places Scraper](https://apify.com/themineworks/2gis-places-search)

**Marketing, SEO and reviews**

- [Facebook Ad Library Scraper](https://apify.com/themineworks/meta-ad-library-scraper)
- [Google Ads Transparency Scraper](https://apify.com/themineworks/google-ads-transparency)
- [Similarweb Scraper](https://apify.com/themineworks/similarweb-scraper)
- [Google News Scraper](https://apify.com/themineworks/google-news)

**LinkedIn**

- [LinkedIn Company Scraper](https://apify.com/themineworks/linkedin-company-details)
- [LinkedIn Post Scraper](https://apify.com/themineworks/linkedin-post-search)
- [LinkedIn Employees Scraper](https://apify.com/themineworks/linkedin-employees)
- [LinkedIn Profile Scraper](https://apify.com/themineworks/linkedin-profile-scraper)

**Real estate**

- [Zillow Rentals Scraper](https://apify.com/themineworks/zillow-rental-listings)
- [Zillow Sold Comps Scraper](https://apify.com/themineworks/zillow-recently-sold)
- [India Real Estate MCP](https://apify.com/themineworks/india-real-estate-mcp)
- [Housing.com Scraper](https://apify.com/themineworks/housing-com-scraper)

**Science, health and government data**

- [Academic Research MCP](https://apify.com/themineworks/academic-research-mcp)
- [CourtListener Scraper](https://apify.com/themineworks/courtlistener-court-records)
- [Socrata Open Data Scraper](https://apify.com/themineworks/socrata-open-data)
- [OpenAlex Scraper](https://apify.com/themineworks/openalex-scholarly-works)

**Company and business data**

- [Company Domain Finder](https://apify.com/themineworks/company-domain-finder)
- [GST Taxpayer Lookup](https://apify.com/themineworks/gst-taxpayer-lookup)
- [Company KYB Resolver](https://apify.com/themineworks/company-identity-resolver)
- [SEC EDGAR Filings Scraper](https://apify.com/themineworks/sec-edgar-filings)

**E-commerce and marketplaces**

- [Ozon.ru Scraper](https://apify.com/themineworks/ozon-product-search)
- [⭐ Amazon Reviews Scraper](https://apify.com/themineworks/amazon-reviews)
- [Amazon Product Scraper](https://apify.com/themineworks/amazon-products)
- [Etsy Listings Scraper](https://apify.com/themineworks/etsy-search-scraper)

**Food and local services**

- [NoBroker Scraper](https://apify.com/themineworks/nobroker-scraper)
- [Swiggy Restaurant Scraper](https://apify.com/themineworks/swiggy-scraper)
- [Zomato Scraper](https://apify.com/themineworks/zomato-scraper)

**Developer and AI tools**

- [Website to Markdown Crawler](https://apify.com/themineworks/rag-crawler)
- [GitHub Skill Finder](https://apify.com/themineworks/github-skill-discovery)
- [GitHub Repo Scraper](https://apify.com/themineworks/github-repo-intelligence)
- [GitHub Trending Scraper](https://apify.com/themineworks/github-trending-scraper)

**More tools**

- [G2 Reviews Scraper](https://apify.com/themineworks/g2-reviews-scraper)
- [Naver Blog Scraper](https://apify.com/themineworks/naver-blog-posts-scraper)
- [WeChat Article Scraper 微信公众号文章](https://apify.com/themineworks/wechat-article-scraper)
- [Taobao Products Scraper 淘宝 天猫](https://apify.com/themineworks/taobao-products-scraper)

### Support

Found a role, city or job that does not come back right, or a field you need? Open an issue in the Issues tab and include the run link. For new sources or a custom build, email dmineworks@gmail.com.

*Wellfound startup jobs by role, city or remote, with salary and equity ranges, experience, skills and the startup's size, stage and funding, read without a login and charged only for open jobs you receive.*

# Actor input Schema

## `roles` (type: `array`):

One per line, as Wellfound names roles: software engineer, product manager, data scientist, designer, sales, marketing manager, or keyword roles such as python developer or react developer. A Wellfound role link (https://wellfound.com/role/software-engineer) works too. Each role is searched in each city below. Leave empty to list every role in the cities.

## `locations` (type: `array`):

One city per line, as Wellfound lists them: san francisco, new york, london, bangalore, berlin, toronto, austin, seattle. Leave empty to search everywhere. A city Wellfound does not list returns a free status row, not jobs from elsewhere.

## `remote` (type: `string`):

Remote only uses Wellfound's remote job lists when no city is given; with a city it keeps the jobs that allow remote work. On site only keeps the jobs that do not.

## `jobTypes` (type: `array`):

Keep only these job types. Leave empty for all.

## `keywords` (type: `array`):

Keep only jobs whose title, role, skills or description mention at least one of these words, for example rust, fintech, series a. Filtered jobs are not charged.

## `maxJobsPerSearch` (type: `integer`):

Most jobs to return for each role and city pair (or each link). Wellfound shows about 40 jobs a page; the run stops at this number or at the end of the list. Minimum 20.

## `includeCompanyDetails` (type: `boolean`):

Also reads each job's own page for skills, visa sponsorship, time zones, relocation, exact salary currency and period, and the startup's website, industries, location, type and funding (total raised, rounds, last round). Turn off for faster runs with the list fields only.

## `startUrls` (type: `array`):

Wellfound job list links (https://wellfound.com/role/r/data-scientist, /role/l/product-manager/new-york, /location/london, /remote) or single job links (https://wellfound.com/jobs/4787326-software-engineer). Read in addition to the roles and cities above.

## Actor input object example

```json
{
  "roles": [
    "software engineer"
  ],
  "locations": [],
  "remote": "any",
  "jobTypes": [],
  "keywords": [],
  "maxJobsPerSearch": 100,
  "includeCompanyDetails": true,
  "startUrls": []
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `summary` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "roles": [
        "software engineer"
    ],
    "locations": [],
    "remote": "any",
    "jobTypes": [],
    "keywords": [],
    "maxJobsPerSearch": 100,
    "includeCompanyDetails": true,
    "startUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("themineworks/wellfound-jobs-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "roles": ["software engineer"],
    "locations": [],
    "remote": "any",
    "jobTypes": [],
    "keywords": [],
    "maxJobsPerSearch": 100,
    "includeCompanyDetails": True,
    "startUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("themineworks/wellfound-jobs-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "roles": [
    "software engineer"
  ],
  "locations": [],
  "remote": "any",
  "jobTypes": [],
  "keywords": [],
  "maxJobsPerSearch": 100,
  "includeCompanyDetails": true,
  "startUrls": []
}' |
apify call themineworks/wellfound-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,themineworks/wellfound-jobs-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/aXEEnaJ9aMt1Eo6aA/builds/1gbpdz3PhQpmaCZ1o/openapi.json