# Wellfound Scraper — Startup Jobs, Salary, Equity & Funding (`haketa/wellfound-scraper`) Actor

Scrape Wellfound (formerly AngelList Talent) startup jobs by role: title, salary range, equity, remote policy, location, experience and description — plus the hiring company's size, stage, valuation and funding signals (YC, Top Investors). No login or API key. Export JSON, CSV, Excel.

- **URL**: https://apify.com/haketa/wellfound-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (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 $1.50 / 1,000 results

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Wellfound (AngelList) Scraper 🚀

Extract **startup jobs from Wellfound — formerly AngelList Talent** — at scale, without an account or API key. Scrape any role and get clean JSON, CSV or Excel: **job title, salary range, equity, remote policy, location and experience — plus the hiring company's size, stage, valuation and funding signals (YC, Top Investors).**

What makes this different from every other job scraper: **equity + startup funding intelligence** on the same record. Perfect for tech recruiters, job seekers, VC/talent-intelligence teams and anyone building startup lead lists.

***

### 🔑 What this scraper does

- 🔎 **Scrape by role** — `software-engineer`, `data-scientist`, `product-manager`, `product-designer`, anything.
- 💰 **Salary & equity** — the compensation range and equity offered, parsed into numeric fields.
- 🏠 **Remote policy** — remote flag, remote kind, and accepted remote locations.
- 🏢 **Company intelligence** — name, size, "high concept" tagline and logo for the hiring startup.
- 🦄 **Funding signals** — **YC-funded, Top Investors, Valuation ($500M+/$1B+), company stage (Early/Growth/Scale), Growing fast, Actively hiring** — the data VCs and recruiters actually want.
- 📝 **Full details** — job description, job type, years of experience.

No login, no cookies to paste, no API key. Enter a role, press start, export.

***

### 📋 Example output

```json
{
  "id": "4697947",
  "url": "https://wellfound.com/jobs/4697947",
  "title": "Senior Software Engineer",
  "roleTitle": "Software Engineer",
  "compensation": "$100k – $180k • 0.05% – 0.25%",
  "salaryMin": 100000,
  "salaryMax": 180000,
  "equityMin": 0.05,
  "equityMax": 0.25,
  "jobType": "full-time",
  "remote": true,
  "remoteKind": "REMOTE",
  "remoteLocations": ["United States", "Canada", "Latin America"],
  "locations": ["San Francisco Bay Area"],
  "yearsExperienceMin": 5,
  "yearsExperienceMax": null,
  "description": "Confident powers analytical testing labs...",
  "postedAt": "2026-09-09T12:39:14.000Z",
  "atsSource": null,
  "company": {
    "id": "829771",
    "name": "Confident LIMS",
    "slug": "confidentlims",
    "url": "https://wellfound.com/company/confidentlims",
    "size": "11-50",
    "highConcept": "The easiest way to test",
    "logoUrl": "https://photos.wellfound.com/startups/i/829771-...",
    "stage": "Early Stage",
    "valuation": null,
    "ycFunded": true,
    "topInvestors": true,
    "growingFast": false,
    "activelyHiring": true,
    "b2b": true
  },
  "searchRole": "software-engineer",
  "scrapedAt": "2026-09-11T10:00:00.000Z"
}
```

***

### 🗂️ Fields you get

| Field | Description |
|---|---|
| `id`, `url` | Job ID and link |
| `title`, `roleTitle` | Job title and primary role |
| `compensation` | Raw compensation string as shown on Wellfound |
| `salaryMin`, `salaryMax` | Salary range parsed to numbers (where the startup publishes it) |
| `equityMin`, `equityMax` | Equity range parsed to numbers (where equity is offered) |
| `jobType` | full-time, contract, internship… |
| `remote`, `remoteKind`, `remoteLocations` | Remote flag, kind, and accepted remote locations |
| `locations` | Office/location names |
| `yearsExperienceMin`, `yearsExperienceMax` | Required experience |
| `description` | Job description |
| `postedAt` | When the job went live |
| `atsSource` | External ATS source, where the job is cross-posted |
| `company.name`, `company.size`, `company.highConcept`, `company.logoUrl` | Hiring company basics |
| `company.stage` | Early / Growth / Scale stage (where badged) |
| `company.valuation` | Valuation $500M+ / $1B+ (where badged) |
| `company.ycFunded`, `company.topInvestors` | YC-funded / Top-Investors signals |
| `company.growingFast`, `company.activelyHiring`, `company.b2b` | Extra company signals |
| `searchRole`, `scrapedAt` | The role searched and scrape timestamp |

> Salary, equity and funding-signal fields are populated **when the startup publishes/qualifies for them** — Wellfound doesn't show all of them on every listing. Core fields (title, company, remote, location, URL) come on every job.

***

### 🚀 How to use

1. Click **Try for free**.
2. Enter one or more **Roles** (e.g. `software-engineer`, `data-scientist`) — or paste Wellfound role URLs into **Start URLs**.
3. (Optional) Turn on **Remote jobs only**.
4. Set **Max Items** and **Max Pages per Role**, then click **Start**.
5. Export as **JSON, CSV, Excel, HTML, RSS**, or via the **Apify API**.

***

### 📝 Example inputs

#### 1. One role

```json
{ "roles": ["software-engineer"], "maxItems": 200 }
```

#### 2. Several roles, remote only

```json
{
  "roles": ["frontend-engineer", "backend-engineer", "data-scientist"],
  "remoteOnly": true,
  "maxItems": 1000
}
```

#### 3. Product & design roles

```json
{
  "roles": ["product-manager", "product-designer"],
  "maxItems": 500,
  "maxPagesPerSearch": 10
}
```

#### 4. Paste a role URL directly

```json
{ "startUrls": ["https://wellfound.com/role/r/machine-learning-engineer"], "maxItems": 300 }
```

***

### 💡 Popular use cases

#### 🧑‍💻 Tech recruiting & sourcing

Build live lists of startup openings by role, with salary, equity and remote policy — plus which companies are **actively hiring** and **growing fast**. Prioritise YC-funded and top-investor-backed startups.

#### 💼 Job seekers

Compare startup compensation (salary **and** equity), filter to remote roles, and target companies at the stage and funding level you want.

#### 📊 VC / talent-market intelligence

Track hiring across the startup ecosystem: which stages and funding tiers are hiring for which roles, salary benchmarks, remote trends. Company stage, valuation and investor signals come attached to every job.

#### 🎯 Startup lead generation

Build lists of funded, actively-hiring startups (name, size, stage, funding signals) for B2B outreach to companies that are scaling.

#### 🤖 AI, LLM & data products

Feed clean, structured startup-jobs data into your own models, dashboards or products.

***

### 👥 Who uses this

- **Recruiters & sourcers** targeting startup talent and roles.
- **Job seekers** comparing salary, equity and remote across startups.
- **VC & talent-intelligence teams** tracking ecosystem hiring.
- **Sales teams** prospecting funded, scaling startups.
- **Developers & AI builders** who need startup-jobs data via API.

***

### 🎛️ Filters & options

- **Roles** — job roles, scraped separately. Combined and de-duplicated.
- **Start URLs** — paste Wellfound role URLs to scrape directly.
- **Remote jobs only** — keep only remote positions.
- **Max Items** — cap total jobs (`0` = unlimited).
- **Max Pages per Role** — pages per role/URL. Each page holds about 38 jobs.

***

### ❓ FAQ

**Do I need a Wellfound/AngelList account or API key?**
No. Just enter a role and run — no login, no cookies, no key.

**Do I get salary and equity?**
Yes, when the startup publishes them. Both are parsed into numeric fields (`salaryMin/Max`, `equityMin/Max`); the raw `compensation` string is also included. Not every listing shows compensation — that's a Wellfound platform choice, not a scraper limit.

**What are the funding signals?**
Each job carries the hiring company's badges where they qualify: **YC-funded, Top Investors, Valuation $500M+/$1B+, company stage (Early/Growth/Scale), Growing fast, Actively hiring, B2B.**

**Can I get remote jobs only?**
Yes — turn on **Remote jobs only**, or filter the `remote` field afterwards.

**How many jobs can I get?**
As many as the role returns, up to your `maxItems` and `maxPagesPerSearch` limits. Set `maxItems: 0` for unlimited.

**What export formats are supported?**
JSON, CSV, Excel, HTML table, RSS, and the Apify API. Connect to Make, Zapier, Google Sheets, Slack, webhooks or an MCP server.

**Is the data structured and clean?**
Yes. Each job is a flat, typed JSON object with a nested `company` object, de-duplicated by job ID.

***

### 🔌 Integrations

- Export to **JSON, CSV, Excel, HTML, RSS**.
- Pull via the **Apify API** or client libraries (JavaScript, Python).
- Connect to **Make, Zapier, Google Sheets, Slack, webhooks** and more.
- Use from an **MCP server** in your AI agent / LLM workflow.
- Schedule recurring runs with the **Apify Scheduler**.

***

### ⚖️ Legal & responsible use

This scraper collects **publicly available** job-listing information only — the same data any visitor can see on Wellfound without logging in. It does not access private messages, candidate data, or anything behind authentication.

You are responsible for how you use the collected data. Please:

- Respect Wellfound's Terms of Service and all applicable laws (including the GDPR).
- Use any personal or company data lawfully and only for legitimate purposes.
- Avoid excessive request rates and scrape responsibly.

This tool is provided for lawful purposes such as recruiting, market research and business intelligence. It is not affiliated with, endorsed by, or connected to Wellfound or AngelList.

# Actor input Schema

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

Job roles to scrape, e.g. 'software-engineer', 'data-scientist', 'product-manager', 'product-designer', 'marketing'. Each role is scraped separately. Leave empty if you use Start URLs.

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

Optional. Paste full Wellfound role URLs (e.g. https://wellfound.com/role/r/data-scientist) to scrape them directly. When provided, Roles are ignored for these URLs.

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

Keep only remote positions.

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

Maximum number of jobs to collect across all roles. 0 = unlimited.

## `maxPagesPerSearch` (type: `integer`):

How many result pages to scrape per role / URL. Each page has about 38 jobs.

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

The default (Apify Proxy, datacenter) works out of the box. Switch to Residential (US) if you ever hit Cloudflare challenges.

## Actor input object example

```json
{
  "roles": [
    "software-engineer"
  ],
  "startUrls": [],
  "remoteOnly": false,
  "maxItems": 100,
  "maxPagesPerSearch": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Open to view and export all scraped listings (JSON, CSV, Excel).

# 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"
    ],
    "startUrls": [],
    "maxItems": 100,
    "maxPagesPerSearch": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/wellfound-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"],
    "startUrls": [],
    "maxItems": 100,
    "maxPagesPerSearch": 5,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/wellfound-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"
  ],
  "startUrls": [],
  "maxItems": 100,
  "maxPagesPerSearch": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/wellfound-scraper --silent --output-dataset

```

## MCP server setup

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