# Wellfound Jobs Scraper: Startup Jobs, Salary & Equity (`cprussin/wellfound-jobs`) Actor

Startup jobs from Wellfound (formerly AngelList Talent) by role and location, including remote: title, salary range, equity, job type and posted date, plus company size, stage and one-liner. No login needed.

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

## Pricing

from $2.00 / 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.

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 Jobs, Salary & Equity

**Wellfound Jobs Scraper** exports startup job listings from Wellfound (formerly AngelList Talent) as clean JSON, CSV or Excel. Wellfound has no public jobs API, so this actor reads the same public listing pages the wellfound.com website shows, no login needed:

- ✅ **Jobs by role and location**: any role (`software-engineer`, `product-manager`, `data-analyst`, ...) in any city, or **remote**.
- ✅ **Salary and equity**: parsed min/max salary with currency (USD, CAD, EUR, GBP, INR, ...), and equity range in percent, plus the raw text.
- ✅ **Job details**: title, role, job type, posted date, locations, remote flag and accepted remote regions, years of experience, full description.
- ✅ **Company data**: name, Wellfound page, logo, company size, funding stage, one-liner and badges (YC, Top Investors, Growing Fast, ...).
- ✅ **Start URLs**: paste any Wellfound role or location listing page.
- ✅ Deduplicated across searches, so a job that matches two searches is returned (and billed) once.
- ✅ Handles rate limits: new proxy IP on every blocked or failed request, direct fallback when the proxy is down.
- ✅ Fast and light: plain HTTP requests, no browser. Pay only for jobs written to your dataset.

### Who uses Wellfound job data?

- **Recruiters and staffing agencies**: find startups that are hiring for a role right now, with company size and stage.
- **Sales and lead generation**: startups hiring engineers, designers or sales reps are buying tools; reach them while they grow.
- **Job seekers and job boards**: aggregate startup jobs with salary and equity into your own feed or alerts.
- **Investors and analysts**: track hiring activity and pay ranges by role, city and funding stage.
- **AI agents**: give an LLM live startup job listings through the Apify API or MCP server.

### How does the Wellfound jobs scraper work?

1. Add roles and locations (or Wellfound listing URLs).
2. The actor loads each listing page, e.g. `wellfound.com/role/l/software-engineer/san-francisco`, and reads the job data embedded in it (the same data the page renders).
3. It follows `?page=2`, `?page=3`, ... up to `maxPages` per search, or until `maxJobs` jobs in total.
4. You get one dataset item per job, in Wellfound's order (grouped by company).

### How do I choose which Wellfound jobs to scrape?

| Field                | Description                                                              | Example                                         |
| -------------------- | ------------------------------------------------------------------------ | ----------------------------------------------- |
| `roles`              | Role slugs or names. Each role is searched in every location             | `["software-engineer", "Product Manager"]`      |
| `locations`          | Location slugs or names, or `remote`                                     | `["san-francisco", "new-york", "remote"]`       |
| `startUrls`          | Wellfound listing pages (optional)                                       | `["https://wellfound.com/role/r/data-analyst"]` |
| `maxJobs`            | Max jobs in total, across all searches                                   | `500`                                           |
| `maxPages`           | Max listing pages per search (20 companies, usually 30–50 jobs per page) | `10`                                            |
| `includeDescription` | Add the full job description (Markdown)                                  | `false`                                         |
| `proxyConfiguration` | Apify Proxy (on by default; datacenter is enough)                        | `{ "useApifyProxy": true }`                     |

- **Roles only**: all locations (`/role/software-engineer`). **Locations only**: all roles (`/location/new-york`). Remote needs a role.
- Slugs are what you see in Wellfound URLs. Plain names work too: `"Data Analyst"` becomes `data-analyst`, `"New York"` becomes `new-york`.
- Supported start URLs: `/role/l/{role}/{location}`, `/role/r/{role}` (remote), `/role/{role}` and `/location/{location}`. `?page=N` sets the first page.

Example: remote and New York product manager jobs, up to 200.

```json
{
  "roles": ["product-manager"],
  "locations": ["remote", "new-york"],
  "maxJobs": 200,
  "maxPages": 5
}
```

### What data do you get for each Wellfound job?

```json
{
  "jobId": "4639821",
  "title": "Software Engineer",
  "role": "Software Engineer",
  "jobUrl": "https://wellfound.com/jobs/4639821-software-engineer",
  "jobType": "full-time",
  "postedAt": "2026-08-27T20:06:24.000Z",
  "locations": ["Denver", "San Francisco"],
  "remote": false,
  "workplace": "onsite",
  "remoteLocations": [],
  "compensation": "$150k – $176k",
  "salaryMin": 150000,
  "salaryMax": 176000,
  "salaryCurrency": "USD",
  "equityMin": null,
  "equityMax": null,
  "hasEquity": null,
  "yearsExperienceMin": null,
  "yearsExperienceMax": null,
  "description": "As a Software Engineer at Checkr, you will work on high-impact engineering projects ...",
  "companyId": "395014",
  "companyName": "Checkr",
  "companySlug": "checkr",
  "companyUrl": "https://wellfound.com/company/checkr",
  "companyLogoUrl": "https://photos.wellfound.com/startups/i/395014-2a2164ef6a8cd5954eb970228e62ce15-medium_jpg.jpg?buster=1692326450",
  "companySize": "501-1000",
  "companyStage": "Scale Stage",
  "companyOneLiner": "The only background check company using artificial intelligence and machine learning",
  "companyBadges": [
    "Actively Hiring",
    "B2B",
    "Top Investors",
    "YC Funded",
    "Valuation $1B+"
  ],
  "searchRole": "software-engineer",
  "searchLocation": "san-francisco",
  "searchUrl": "https://wellfound.com/role/l/software-engineer/san-francisco",
  "scrapedAt": "2026-10-01T00:00:00.000Z"
}
```

- `salaryMin`/`salaryMax` are yearly amounts in `salaryCurrency` as posted ("$150k" = 150000, "₹5L" = 500000). "Up to $150k" gives only `salaryMax`. `null` when the job shows no salary.
- `equityMin`/`equityMax` are percentages (`0.5` = 0.5%). `hasEquity` is `false` for "No equity" and `null` when not stated.
- `workplace` is `onsite`, `remote` or `onsiteOrRemote`. `remoteLocations` lists the regions a remote job accepts.
- `companyStage` is Wellfound's stage badge (Early, Growth, Scale or Public Stage); `null` when Wellfound shows none.

### How much does it cost to scrape Wellfound jobs?

Pay-per-event, only for jobs written to your dataset:

| Event | Price      |
| ----- | ---------- |
| Job   | **$0.002** |

That's **$2 per 1,000 jobs**. The default input (20 software engineer jobs in San Francisco) costs $0.04. All ~775 software engineer jobs in San Francisco cost about $1.55. If you set a **maximum cost per run**, the actor stops cleanly when it reaches it.

### Tips for scraping Wellfound startup jobs

- **Daily new jobs:** schedule the actor and filter on `postedAt`, or dedupe on `jobId` downstream. Send new jobs to Google Sheets, Slack or a webhook with Apify integrations.
- **Hiring leads:** run a role across several cities with `includeDescription: false`, then group by `companySlug` to get a list of hiring startups with size and stage.
- **Salary benchmarks:** filter `salaryCurrency` and aggregate `salaryMin`/`salaryMax` by role, city or `companyStage`.
- **Find the right slug:** open the role or city on wellfound.com and copy it from the URL, or paste the URL into `startUrls`.

### Wellfound jobs scraper FAQ

**Is this an official Wellfound API?** No. It reads the public job listing pages wellfound.com shows to logged-out visitors.

**Why are some jobs outside my role or city?** Wellfound's listing pages group jobs by company and include related roles and multi-location jobs. Filter on `role` or `locations` if you need exact matches.

**Why does a search fail with "no listing page"?** Wellfound redirects unknown role or location slugs to another page. The actor detects this instead of returning unrelated jobs. Check the slug on wellfound.com.

**Do I need a proxy?** Usually not, but Apify Proxy (datacenter) is enabled by default and the actor switches IP automatically when a request is blocked.

**Can I use it through the API or with AI agents?** Yes. Call it through the Apify API, the Apify MCP server or any Apify integration.

**Disclaimer:** This actor is not affiliated with, endorsed by or sponsored by Wellfound. Wellfound is a trademark of its owner. You are responsible for complying with Wellfound's terms and applicable laws when using the data.

### Related actors

- [product-hunt-launches](https://apify.com/cprussin/product-hunt-launches): Product Hunt launches, leaderboards, upvotes and makers.
- [new-business-registrations](https://apify.com/cprussin/new-business-registrations): New LLC and corporation filings from state open-data portals.
- [trustpilot-reviews](https://apify.com/cprussin/trustpilot-reviews): Trustpilot reviews, ratings and TrustScore for any company.

# Actor input Schema

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

Job roles as Wellfound slugs or plain names, e.g. <code>software-engineer</code>, <code>product-manager</code>, <code>Data Analyst</code>. Each role is searched in every location below. Leave empty to list all jobs in the locations.

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

Locations as Wellfound slugs or plain names, e.g. <code>san-francisco</code>, <code>new-york</code>, <code>london</code>, or <code>remote</code> for remote jobs. Leave empty to search a role in all locations.

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

Optional Wellfound listing pages, e.g. <code>https://wellfound.com/role/l/software-engineer/san-francisco</code>, <code>https://wellfound.com/role/r/data-analyst</code> (remote), <code>https://wellfound.com/role/product-manager</code> or <code>https://wellfound.com/location/new-york</code>. A <code>?page=N</code> parameter sets the first page.

## `maxJobs` (type: `integer`):

Stop after this many jobs in total, across all searches. Each job is billed as one event.

## `maxPages` (type: `integer`):

Listing pages to read per role/location (20 companies, usually 30-50 jobs per page).

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

Add the full job description (Markdown) to each job. Turn off for smaller datasets.

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

Apify Proxy (datacenter is enough). The actor switches to a new IP whenever Wellfound blocks or rate-limits a request, and falls back to direct requests if the proxy keeps failing.

## Actor input object example

```json
{
  "roles": [
    "software-engineer"
  ],
  "locations": [
    "san-francisco"
  ],
  "maxJobs": 20,
  "maxPages": 5,
  "includeDescription": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (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": [
        "san-francisco"
    ],
    "maxJobs": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("cprussin/wellfound-jobs").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": ["san-francisco"],
    "maxJobs": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("cprussin/wellfound-jobs").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": [
    "san-francisco"
  ],
  "maxJobs": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call cprussin/wellfound-jobs --silent --output-dataset

```

## MCP server setup

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

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/6WKaz1UlBQl3NMwv9/builds/ezYtnKgWWtu3ufmEA/openapi.json