# Wellfound Scraper \[$0.75💰] Jobs, Salary & Equity Data 💼 (`ahmed_jasarevic/wellfound-scraper`) Actor

Extract startup job listings from Wellfound for $0.75/1,000 results. Titles, salary & equity ranges, remote status, company funding, size & investors — parsed straight from Wellfound's embedded data, no brittle DOM selectors. Fast and reliable.

- **URL**: https://apify.com/ahmed\_jasarevic/wellfound-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Categories:** Jobs, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 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/platform/actors/running/actors-in-store#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 Scraper — Startup Jobs, Salary & Equity Data 💼

💰 **From $0.75 per 1,000 results** — job titles, salary and equity ranges, remote status, company funding data, team size, and investors, parsed straight from Wellfound's embedded data.

**Scrape [Wellfound](https://wellfound.com)** (formerly AngelList Talent), the leading platform for startup hiring. This actor parses the embedded Apollo GraphQL state (`__NEXT_DATA__`) from Wellfound's Next.js frontend, so you get clean, reliable JSON output — no brittle DOM selectors that break on every layout change.

***

### Why use this actor?

- 💸 **Cheap & fast** — from $0.75 per 1,000 results, targeting Wellfound's public SEO landing pages over HTTP with residential proxies.
- 🧩 **Structured, not scraped** — parses Wellfound's own embedded GraphQL state instead of fragile HTML selectors, so results stay accurate even when the page design changes.
- 💰 **Full compensation data** — parsed salary and equity ranges (`salaryMin/Max`, `equityMin/Max`), not just a raw text string.
- 🏢 **Company context included** — funding stage, total raised, team size, and remote policy come bundled with every job listing.
- 🛡️ **Built for reliability** — Wellfound uses DataDome anti-bot protection; residential proxies are enabled by default.

***

### Use cases

#### Technical recruiting

**Recruiters sourcing startup talent by compensation and funding stage.**
Input: role + location search terms · Output: salary/equity ranges, company funding stage · Use: filter and prioritize outreach by comp band and company maturity.

#### Job board aggregation

**Job boards pulling in structured startup roles.**
Input: scheduled runs across role/location combinations · Output: full job + company dataset · Use: power a startup-jobs aggregator with compensation and remote-policy data.

#### Career coaching & market research

**Coaches and analysts benchmarking market rates and equity norms.**
Input: role-specific searches · Output: salary and equity ranges by role/location · Use: build compensation benchmarks for candidate advising.

#### Sales & investor prospecting

**Sales teams and investors identifying actively hiring startups.**
Input: broad role/location search · Output: company funding, size, and hiring activity · Use: prioritize outreach to startups showing hiring and funding momentum.

***

### How to use

1. **Enter search terms** — role slugs like `software-engineer`, `product-manager`, `data-engineer`.
2. **Select locations** — `remote`, `san-francisco`, `new-york`, `london`, etc.
3. **Set max items** — free users get 10 items; paid users up to 1,000.
4. **Configure proxy** — residential proxy group recommended (enabled by default).
5. **Run the actor** — results appear in the Output tab.

***

### Input

| Parameter | Type | Default | Description |
|---|---|---|---|
| `searchTerms` | `string[]` | `["software-engineer"]` | Role slugs to search (each triggers a separate search) |
| `locations` | `string[]` | `["remote"]` | Location slugs to combine with each search term |
| `roles` | `string[]` | `[]` | Additional role slugs to append |
| `maxItems` | `integer` | `50` | Maximum job listings to scrape (1–1000) |
| `maxPages` | `integer` | `5` | Max search result pages per search term/location |
| `includeCompanyDetails` | `boolean` | `false` | Fetch detailed company profiles (adds requests) |

**Example input:**

```json
{
  "searchTerms": ["software-engineer", "product-manager"],
  "locations": ["remote", "san-francisco"],
  "maxItems": 200,
  "maxPages": 5,
  "includeCompanyDetails": true
}
```

***

### Output

Each item in the dataset contains:

```json
{
    "jobId": "1234567",
    "title": "Senior Backend Engineer",
    "slug": "senior-backend-engineer-1234567",
    "url": "https://wellfound.com/jobs/senior-backend-engineer-1234567",
    "compensation": "$150k - $200k • 0.1% - 0.5%",
    "salaryMin": 150000,
    "salaryMax": 200000,
    "equityMin": 0.1,
    "equityMax": 0.5,
    "locationNames": ["San Francisco", "Remote"],
    "remote": true,
    "jobType": "full_time",
    "descriptionSnippet": "We're looking for a senior backend engineer...",
    "liveStartAt": 1719000000,
    "companyName": "Stripe",
    "companySlug": "stripe",
    "companyUrl": "https://wellfound.com/company/stripe",
    "companyHighConcept": "Online payments platform",
    "companySize": "1001-5000",
    "companyStage": "Series I",
    "totalRaisedAmount": "$8.7B",
    "scrapedAt": "2026-08-21T12:00:00.000Z"
}
```

You can download the dataset in JSON, CSV, Excel, or XML formats.

#### Data fields

| Field | Description |
|---|---|
| `jobId` | Unique Wellfound job identifier |
| `title` | Job title |
| `url` | Canonical Wellfound job URL |
| `compensation` | Raw compensation string (e.g., "$150k - $200k • 0.1% - 0.5%") |
| `salaryMin` / `salaryMax` | Parsed salary range in USD |
| `equityMin` / `equityMax` | Parsed equity range as percentage |
| `locationNames` | Array of location names |
| `remote` | Whether the role is remote-friendly |
| `jobType` | Employment type (full\_time, part\_time, contract, internship) |
| `companyName` | Company name |
| `companySize` | Employee count range |
| `companyStage` | Funding stage (Seed, Series A–E, etc.) |
| `totalRaisedAmount` | Total funding raised |

***

### Integration examples

#### JavaScript / Node.js

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

const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('ahmed_jasarevic/wellfound-scraper').call({
  searchTerms: ['software-engineer'],
  locations: ['remote'],
  maxItems: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_TOKEN')

run = client.actor('ahmed_jasarevic/wellfound-scraper').call(run_input={
    'searchTerms': ['product-manager'],
    'locations': ['san-francisco', 'remote'],
    'maxItems': 100,
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/ahmed_jasarevic~wellfound-scraper/runs?token=YOUR_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"searchTerms":["software-engineer"],"locations":["remote"],"maxItems":100}'
```

#### Automation workflows (n8n / Zapier / Make)

1. **Trigger**: schedule or webhook
2. **HTTP Request**: call the actor API
3. **Process**: parse the JSON results
4. **Action**: save to a sheet/DB, alert on new roles matching criteria, or feed into a CRM

***

### Pricing

At **$0.75 per 1,000 results**, each run uses Apify proxy (residential group), which is included in your Apify plan. Expect ~0.5–1 Compute Unit per 100 items.

- **Free tier**: 10 items per run
- **Paid tier**: up to 1,000 items per run

***

### Tips

- Use specific role slugs (`software-engineer`, not `engineer`) for better results.
- Combine multiple locations to cast a wider net.
- The `compensation` field often contains both salary and equity — use the parsed `salaryMin/salaryMax` and `equityMin/equityMax` fields for filtering rather than parsing the raw string yourself.
- Wellfound uses DataDome anti-bot protection — residential proxies are enabled by default and recommended.

***

### FAQ

**How much does it cost?**
$0.75 per 1,000 results. Free tier gives 10 items per run to test before scaling up.

**Do I need a proxy?**
Yes — Wellfound uses DataDome anti-bot protection. Residential proxies are enabled by default.

**Can I search multiple roles and locations at once?**
Yes — `searchTerms` and `locations` both accept arrays; every combination is searched.

**What's included in `includeCompanyDetails`?**
Full company profile data beyond what's shown on the job listing — enabling it adds extra requests per company.

**Why don't some listings have salary/equity data?**
Not every company discloses compensation on Wellfound; those fields will be `null` for that listing.

**What output formats are supported?**
JSON, CSV, Excel, and XML — all exportable directly from the Apify dataset.

**Is scraping Wellfound legal?**
This actor scrapes publicly available data from Wellfound's SEO pages. Users are responsible for complying with Wellfound's Terms of Service and applicable laws.

***

### Known limitations

- SEO landing pages don't expose the full filter surface (company size, funding stage, and skills filters require authenticated sessions).
- Some job listings may not have salary/equity data.
- Pagination is capped at 50 pages per search term/location combination.
- Company detail pages require additional requests — enable `includeCompanyDetails` if needed.

***

### Legal disclaimer

This actor scrapes publicly available data from Wellfound's SEO pages. Users are responsible for complying with Wellfound's Terms of Service and applicable laws. This actor is not affiliated with Wellfound.

***

### Support

For issues or feature requests, open an issue on the Apify platform.

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords to search for on Wellfound. Human-readable terms like 'Software Engineer' are automatically converted to URL slugs ('software-engineer'). Full Wellfound URLs are also accepted.

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

Location slugs to search. Examples: 'remote', 'san-francisco', 'new-york', 'london', 'berlin'. Each location is combined with each search term.

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

Additional role slugs to search (beyond searchTerms). These are appended to the search.

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

Maximum number of job listings to scrape. Free users are capped at 10 items.

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

Maximum number of search result pages to scrape per search term/location combination. Raise this (e.g. 25) if you want high maxItems values like 1000.

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

Whether to fetch detailed company profiles for each job. Adds additional requests but provides richer company data.

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

Proxy settings. Residential proxy group is recommended for Wellfound due to DataDome anti-bot protection.

## Actor input object example

```json
{
  "searchTerms": [
    "software-engineer"
  ],
  "locations": [
    "remote"
  ],
  "roles": [],
  "maxItems": 50,
  "maxPages": 50,
  "includeCompanyDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "BUYPROXIES94952"
    ]
  }
}
```

# 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 = {
    "searchTerms": [
        "software-engineer"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/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 = { "searchTerms": ["software-engineer"] }

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/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 '{
  "searchTerms": [
    "software-engineer"
  ]
}' |
apify call ahmed_jasarevic/wellfound-scraper --silent --output-dataset

```

## MCP server setup

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