# Wellfound Jobs Scraper (`lergassy/wellfound-jobs-scraper`) Actor

Scrape Wellfound (AngelList Talent) startup jobs by role and city or remote: title, salary range, equity note, job type, locations, full description, posting date, plus the startup's name, size, stage, badges and tagline. Export to JSON or CSV, run on a schedule, no login.

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

## Pricing

from $1.20 / 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

Scrape startup jobs from **Wellfound** (formerly AngelList Talent). Give it roles and cities (or *remote*), get one flat row per job with salary, job type, locations, the full description **and the startup behind it**: size, stage, badges like *YC Funded* or *Top Investors*, tagline and logo. Plain HTTP, no login, no browser.

### What data can it extract

| Field | Example |
|---|---|
| `title`, `roleTitle`, `jobType` | Software Engineer · Software Engineer · full-time |
| `compensation`, `salaryMin`, `salaryMax`, `salaryCurrency` | $150k – $176k · 150000 · 176000 · USD |
| `remote`, `remoteConfig`, `acceptedRemoteLocations`, `locations` | true · \[] · \["Denver", "San Francisco"] |
| `postedAt`, `atsSource`, `yearsExperienceMin` | 2026-08-27 · Greenhouse · 3 |
| `description` | full job text (Markdown-ish, as Wellfound shows it) |
| `companyName`, `companySize`, `companyStage`, `companyBadges` | Checkr · 501-1000 · Scale Stage · \["Actively Hiring", "YC Funded", "Valuation $1B+"] |
| `companyTagline`, `companyUrl`, `companyLogo` | "The only background check company using AI…" |

Measured on 25 Sep 2026: *software engineer / San Francisco* lists 785 jobs at 286 startups; *remote software engineer* 1,856 jobs at 897 startups; *remote product manager* 1,636. One listing page ≈ 45 jobs in one request.

### How much does it cost

**$1.50 per 1,000 jobs** (FREE plan; $1.00 on Diamond). Nothing per run, per search or per page; rows that fail are free. The free Apify plan ($5 credit) covers about 3,300 jobs.

#### Bulk export: what 50,000 jobs actually cost (25 Sep 2026)

| Actor | Per job | Per run | 50,000 jobs, 100 runs |
|---|---|---|---|
| **Wellfound Jobs Scraper (this one)** | $0.0015 | $0 | **$75** |
| blackfalcondata/wellfound-scraper (most used) | $0.003 | $0.005 | $150.50 |
| orgupdate/wellfound-jobs-scraper | $0.005 | $0.002 | $250.20 |
| memo23/wellfound-jobs-scraper | $0.00099 | $0.01 | $50.50 |

Prices are the FREE-plan prices on each Actor's page on the date above. memo23 is cheaper per row on big runs; the two most-used Actors are twice the price.

### How to scrape Wellfound jobs

1. Type roles (`software engineer`, `product manager`) and locations (`san francisco`, `remote`).
2. Set **Max jobs per search**. Run.
3. Download the dataset as JSON, CSV or Excel, or read it through the API.

#### Input

```json
{ "roles": ["software engineer", "product manager"], "locations": ["san francisco", "remote"], "maxJobsPerSearch": 200 }
```

Or paste listing URLs: `https://wellfound.com/role/l/data-scientist/berlin`, `https://wellfound.com/location/austin`.

#### Output

```json
{ "type": "job", "id": "4639821", "title": "Software Engineer", "url": "https://wellfound.com/jobs/4639821-software-engineer",
  "jobType": "full-time", "compensation": "$150k – $176k", "salaryMin": 150000, "salaryMax": 176000, "salaryCurrency": "USD",
  "remote": false, "locations": ["Denver", "San Francisco"], "postedAt": "2026-08-27T20:06:24.000Z", "atsSource": "Greenhouse",
  "description": "As a Software Engineer at Checkr, you will work on…",
  "companyName": "Checkr", "companySize": "501-1000", "companyStage": "Scale Stage",
  "companyBadges": ["Actively Hiring", "B2B", "Top Investors", "YC Funded", "Valuation $1B+"], "companyUrl": "https://wellfound.com/company/checkr" }
```

### Use cases

#### Recruiters and sourcing agencies

Daily feed of new startup roles in your niche; filter by `companyStage`, `compensation`, `remote`.

#### Sales and investors

Startups with the *Actively Hiring* badge and many open engineering roles are growing — a lead list with size, stage and tagline included.

#### Job boards and aggregators

Bulk export by role × city on a schedule; `id` is stable, so re-runs only add what is new.

#### AI agents

Call it from an agent (Apify MCP server, x402) with a plain question — "remote data scientist jobs at seed-stage startups" — and get structured rows back.

### Integrations

Works with the Apify API and clients (Python, JavaScript), n8n, Make, Zapier, Google Sheets, webhooks and the Apify MCP server. Schedule it in the Apify Console to keep a live feed.

```bash
curl -X POST "https://api.apify.com/v2/acts/lergassy~wellfound-jobs-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" -d '{"roles":["designer"],"locations":["remote"],"maxJobsPerSearch":100}'
```

### Limits and troubleshooting

- Data comes from Wellfound's public listing pages (role, role + city, remote role, city). Company pages and individual job pages sit behind a bot check, so fields that exist only there (founder names, funding rounds) are not included.
- A role or city Wellfound does not know returns one free error row saying so — check the spelling against the URL on wellfound.com.
- Salary is shown only where the startup published it (about 85% of rows in our tests).

### ❓ FAQ

#### Is it legal to scrape Wellfound?

The Actor reads public listing pages that Wellfound shows to any visitor and collects no personal data of candidates. Job adverts are published to be read. Use the data in line with Wellfound's terms and your local law.

#### How fresh is the data?

Live at run time. Schedule the Actor hourly or daily to track new postings.

#### Can I search by keyword inside the description?

Not on Wellfound's side. Export a role and filter the `description` column afterwards.

### Your feedback

If a field is missing or a page stops working, open an issue on the Actor page — fixes usually ship the same day. A ⭐ review helps other people find the Actor.

### You might also like

| Actor | What it does |
|---|---|
| [Jobs API](https://apify.com/lergassy/jobs-api) | Indeed, LinkedIn and ATS boards in one run |
| [LinkedIn Jobs Scraper](https://apify.com/lergassy/linkedin-jobs-scraper) | LinkedIn job search without a login |
| [Indeed Jobs Scraper](https://apify.com/lergassy/indeed-jobs-scraper) | Indeed by keyword and location |
| [Workday Jobs Scraper](https://apify.com/lergassy/workday-jobs-scraper) | Any company career site on Workday |

# Actor input Schema

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

Job roles as Wellfound names them: <b>software engineer</b>, <b>product manager</b>, <b>data scientist</b>, <b>designer</b>, <b>sales</b>, <b>marketing</b>… One search per role.

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

Cities as on Wellfound (<b>san francisco</b>, <b>new york</b>, <b>london</b>, <b>berlin</b>, <b>bangalore</b>) or <b>remote</b>. Leave empty for all locations of each role.

## `remoteOnly` (type: `boolean`):

Search the remote listing of each role and ignore Locations.

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

Stop each role/location search after this many jobs. A search page holds about 40–50 jobs.

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

Any Wellfound listing page: https://wellfound.com/role/l/software-engineer/berlin, https://wellfound.com/role/r/designer, https://wellfound.com/location/austin.

## `includeDescription` (type: `boolean`):

The full description text of each job is on the listing page already — turning this off only makes rows smaller.

## `maxItems` (type: `integer`):

Hard stop for the whole run.

## `proxyConfiguration` (type: `object`):

Apify datacenter proxy is on by default so a schedule does not hammer the site from one address. Residential is not needed.

## Actor input object example

```json
{
  "roles": [
    "software engineer"
  ],
  "locations": [
    "remote"
  ],
  "remoteOnly": false,
  "maxJobsPerSearch": 40,
  "includeDescription": true,
  "maxItems": 100000,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `rows` (type: `string`):

One row per job with salary, locations, description and the startup's size, stage and badges.

# 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"
    ],
    "maxJobsPerSearch": 40,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("lergassy/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"],
    "maxJobsPerSearch": 40,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("lergassy/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"
  ],
  "maxJobsPerSearch": 40,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call lergassy/wellfound-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lergassy/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/seAOoebZJ5N5kcY1Y/builds/aah5X9AmPsA1fOk7c/openapi.json