# Wellfound Jobs Scraper: Startup, Tech & Equity (`santamaria-automations/wellfound-jobs-scraper`) Actor

Extract US startup job listings from Wellfound.com (formerly AngelList Talent). Returns 25+ fields: title, company, salary + equity range, location, remote, tech stack, company stage, funding, founders, industry, description. Rich company page enrichment.

- **URL**: https://apify.com/santamaria-automations/wellfound-jobs-scraper.md
- **Developed by:** [NanoScrape](https://apify.com/santamaria-automations) (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 $6.00 / 1,000 job serp results

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?

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 Jobs Scraper: Startup, Tech & Equity

Extract US startup and tech job listings from [Wellfound.com](https://wellfound.com) (formerly AngelList Talent). Wellfound is the largest startup-native job board, with 100,000+ startups from pre-seed to late-stage listing 300,000+ live roles. Get title, company, salary, equity range, funding stage, tech stack, founders, and description in one call. No login required.

> **v2.0 (2026-08):** Wellfound is behind Cloudflare's Managed Challenge on every plain-HTTP fetch. This rebuild uses a stealth-browser architecture (Camoufox + residential proxy) that reliably passes the challenge. If you used v1.x, the input schema is compatible: existing runs continue to work.

### What data can you extract?

Every job listing includes 25+ fields.

**Job details**

- Job title, employment type, workplace mode (remote / hybrid / onsite / remote-anywhere)
- Location (city + state + country when detailed enrichment is on)
- Full description (plain text + HTML) when includeJobDetails is on
- Posted date (ISO 8601 UTC)

**Salary and equity**

- Structured salary min / max / currency (USD / EUR / GBP / CAD ...)
- Equity range: min / max as percentages
- No-equity flag when explicitly stated
- Original compensation string as shown on Wellfound

**Company signal (from the SERP cache, no extra fetch)**

- Company name, slug, Wellfound URL, logo
- One-line high concept / tagline
- Company size band (11-50, 51-200, 201-500 ...)
- Live jobs count at this employer
- Actively Hiring and other Wellfound badges
- Market taxonomy tags (Artificial Intelligence, Fintech, Healthcare ...)

**Company page enrichment (opt in with includeCompanyDetails)**

- Full About text, external website, founded year, industry
- Funding stage (seed, series-a, series-b, series-c, late-stage, public)
- Total funding raised
- Headquarters + all office locations
- Tech stack (Ruby, Python, Go, React, Postgres, AWS ...)
- Benefits list
- Founders with role and LinkedIn URL
- Other active roles at the company (dedup by slug, one fetch per company)
- Notable investors
- Visa sponsorship signal

### Pricing

Pay per result, no monthly fees.

**SERP mode (default), $6 per 1,000 jobs**

Returns 25+ fields per job from the search results page. Salary + equity + company signal (name, size, logo, badges, market tags) all come from the SERP without a per-job fetch.

**Full mode (includeJobDetails=true), $16 per 1,000 jobs**

Adds a per-job detail-page fetch: full description text + HTML, industry, structured address, refined employment type. Roughly doubles runtime.

**Deep mode (includeCompanyDetails=true), $16 + $5 per unique company**

Also fetches each unique company page once for the enriched about text, funding stage, tech stack, benefits, founders list, and active jobs list. Dedup by company slug within a run: if 30 rows share the same employer, we fetch the company page once.

| Volume | SERP mode | Full mode | Deep mode (approx) |
|--------|-----------|-----------|--------------------|
| 100 jobs | $0.60 | $1.60 | $2.00 |
| 1,000 jobs | $6.00 | $16.00 | $19.00 |
| 10,000 jobs | $60.00 | $160.00 | $190.00 |

Deep mode cost depends on how many unique companies appear in your result set. Typical ratio: 3-5 rows per unique company on a broad search, ~1.5-2 rows per unique company on a narrow one.

The actor uses a full stealth browser through a residential proxy: the only reliable architecture against Wellfound's current Cloudflare Managed Challenge. Free Apify accounts include $5 in monthly credit, enough for ~800 SERP-mode jobs.

### Use with AI Agents (MCP)

Connect this actor to any MCP-compatible AI client: Claude Desktop, Claude.ai, Cursor, VS Code, LangChain, LlamaIndex, or custom agents.

**Apify MCP server URL:**

```
https://mcp.apify.com?tools=santamaria-automations/wellfound-jobs-scraper
```

**Example prompts once connected:**

> "Use `wellfound-jobs-scraper` to find backend engineer jobs in San Francisco. Return the top 10 as a table with title, company, salary range and equity range."

> "Use `wellfound-jobs-scraper` with includeCompanyDetails=true to find remote Rust roles and list the companies with their funding stage and founders."

### How to use

#### Option 1: Search keywords (most common)

```json
{
  "searchQueries": ["software engineer", "product manager"],
  "location": "San Francisco",
  "maxResultsPerQuery": 50
}
```

#### Add company enrichment

Set `includeCompanyDetails: true` to pull each unique company's about text, funding, tech stack, founders, and active jobs list. `includeJobDetails` is auto-enabled so full descriptions come along.

```json
{
  "searchQueries": ["backend engineer"],
  "location": "New York",
  "remote": true,
  "maxResults": 50,
  "includeJobDetails": true,
  "includeCompanyDetails": true
}
```

#### Option 2: Direct Wellfound search URLs

Set up filters on Wellfound.com (funding stage, team size, equity, remote-only), then paste the URL. All filters are preserved.

```json
{
  "startUrls": [
    "https://wellfound.com/jobs?q[role_names][]=Backend+Engineer&q[remote]=true",
    "https://wellfound.com/jobs?q[role_names][]=Data+Scientist&q[location]=San+Francisco"
  ],
  "maxResultsPerQuery": 100
}
```

You can mix `searchQueries` and `startUrls` in the same run.

### Input reference

| Field | Type | Description |
|-------|------|-------------|
| `searchQueries` | string\[] | One or more job role keywords. |
| `startUrls` | string\[] | Pre-filtered Wellfound search URLs. |
| `location` | string | City or region (e.g. "San Francisco", "Remote"). |
| `remote` | boolean | If true, restricts results to remote-friendly roles. |
| `includeJobDetails` | boolean | Fetch each job's PDP for full description, industry, address. Adds cost. |
| `includeCompanyDetails` | boolean | Also resolve each unique company page for about, funding, founders, tech stack. Auto-enables includeJobDetails. |
| `maxResults` | integer | Total cap across all queries (default 25). |
| `maxResultsPerQuery` | integer | Per-query cap (default 100). |
| `startPage` | integer | Skip N pages before returning results (1-indexed). |

### Output example

```json
{
  "_type": "job",
  "id": "4612613",
  "title": "Senior Backend Engineer",
  "company_name": "Stripe",
  "company_slug": "stripe",
  "company_url": "https://wellfound.com/company/stripe",
  "company_logo_url": "https://photos.wellfound.com/startups/i/12345-abc-medium_jpg.jpg",
  "company_high_concept": "Economic infrastructure for the internet",
  "company_size_range": "SIZE_5000_PLUS",
  "company_active_jobs_count": 87,
  "company_badges": ["Actively Hiring"],
  "location": "San Francisco",
  "location_city": "San Francisco",
  "location_state": "California",
  "location_country": "United States",
  "workplace_type": "hybrid",
  "remote_option": true,
  "salary_min": 180000,
  "salary_max": 250000,
  "salary_currency": "USD",
  "salary_text": "$180k – $250k • 0.5% – 1.5%",
  "equity_min": 0.5,
  "equity_max": 1.5,
  "equity_text": "0.5% – 1.5%",
  "no_equity": false,
  "employment_type": "full-time",
  "industry": "Fintech",
  "market_tags": ["Payments", "SaaS", "Fintech"],
  "description_snippet": "We are looking for a Senior Backend Engineer to lead payments infrastructure...",
  "description_full": "Full text of the job description...",
  "posted_at": "2026-08-15T12:00:00Z",
  "source_url": "https://wellfound.com/jobs/4612613-senior-backend-engineer",
  "source_platform": "wellfound.com",
  "apply_url": "https://wellfound.com/jobs/4612613-senior-backend-engineer",
  "company_about": "Stripe builds economic infrastructure for the internet...",
  "company_website": "https://stripe.com",
  "company_founded": 2010,
  "company_stage": "late-stage",
  "company_funding_total": "$8.7B",
  "company_industry": "Fintech",
  "company_headquarters": "San Francisco, CA",
  "company_offices": ["San Francisco, CA", "New York, NY", "Dublin, Ireland"],
  "company_tech_stack": ["Ruby", "Go", "React", "Postgres"],
  "company_benefits": ["Health insurance", "401(k)", "Parental leave"],
  "company_founders": [
    {"name": "Patrick Collison", "role": "Co-founder & CEO", "linkedin_url": "https://linkedin.com/in/patrick", "bio": null}
  ],
  "company_investors": ["Sequoia Capital", "Andreessen Horowitz", "General Catalyst"],
  "sponsors_visa": true,
  "extraction_mode": "serp+detail+company",
  "search_query": "software engineer in San Francisco",
  "serp_page": 1,
  "scraped_at": "2026-08-20T21:30:00Z"
}
```

### Why this scraper

- **Startup-native fields** other Indeed / LinkedIn scrapers do not capture: equity ranges, funding stage, founder LinkedIn URLs, tech stack, investor list.
- **One fetch per unique company**, not per row. A 100-job pull with 30 unique companies fetches 30 company pages, not 100.
- **All filters preserved via startUrls**: paste any Wellfound search URL and every filter set on the site (funding stage, team size, equity range, remote-only) is carried through.
- **Battle-tested stealth**: same Camoufox + residential architecture that unblocks indeed.com, is24, and other Cloudflare-Managed-Challenge sites.

### Use cases

#### Startup market intelligence

Track which stage-A / stage-B companies are actively hiring in your vertical. Combine with funding data to spot the next wave of open positions before they hit Indeed.

#### Founder outreach

Extract founder LinkedIn URLs from company pages for direct sales / partnership outreach.

#### Tech stack targeting

Filter companies by tech stack (Rust, Go, Python) for vendor sales or recruiter sourcing.

#### Compensation benchmarking

Wellfound is one of the few boards that publishes equity ranges alongside salary. Aggregate by role and stage to build compensation intel.

#### Recruiter sourcing

Feed job listings and company\_active\_jobs into your ATS. Auto-alert on new roles at target companies.

### Notes and limits

- **US-focused**: Wellfound serves global startups but the platform is US-headquartered. Non-US roles work, but posting density is highest for San Francisco, New York, Austin, Boston, Los Angeles, and remote-anywhere.
- **Rate**: about 20 jobs per SERP page. A 1,000-job run walks ~50 pages.
- **Company page dedup**: within a single run only. Two separate runs against the same company will re-fetch the company page (fresh charge).
- **Founder LinkedIn URLs**: extracted when Wellfound exposes them on the company page. About 60-80% of pre-seed to series-B companies expose founder profiles; larger public companies often do not.

### Integrations

This actor works with all Apify integrations: API, webhooks, Zapier, Make, Google Sheets, Slack, Email.

### Related Actors

- [Indeed Scraper](https://apify.com/santamaria-automations/indeed-scraper) — Indeed jobs across 60+ countries
- [LinkedIn Jobs Scraper](https://apify.com/santamaria-automations/linkedin-scraper) — LinkedIn job listings globally
- [Google Jobs Scraper](https://apify.com/santamaria-automations/google-jobs-scraper) — Aggregated jobs from Google's for-jobs surface
- [Career Site Scraper](https://apify.com/santamaria-automations/career-site-scraper) — Greenhouse, Lever, Workday career pages
- [Google Maps Scraper](https://apify.com/santamaria-automations/google-maps-scraper) — Business data from Google Maps

### Support

Open an issue on the [Issues tab](https://console.apify.com/actors/santamaria-automations~wellfound-jobs-scraper/issues) or email contact@nanoscrape.com. We usually reply within 6 hours.

# Actor input Schema

## `searchQueries` (type: `array`):

One or more job role keywords to search on Wellfound (e.g. 'software engineer', 'product manager'). Each keyword runs as a separate search. Results are deduplicated by job ID. Leave blank if you supply startUrls instead.

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

Direct Wellfound search URLs to crawl instead of building searches from keywords. Preserves all filters set on the site (funding stage, team size, equity, remote-only). Example: https://wellfound.com/jobs?q\[role\_names]\[]=Backend+Engineer\&q\[remote]=true. Mutually exclusive with searchQueries.

## `location` (type: `string`):

City or region filter (e.g. 'San Francisco', 'New York', 'Remote'). Applied to all search keywords. Ignored when you use startUrls.

## `remote` (type: `boolean`):

If true, restricts results to jobs marked remote-friendly. Ignored when you use startUrls.

## `includeJobDetails` (type: `boolean`):

Fetch each job's detail page for full description, refined employment type, industry, company logo, and structured address. Charged as a separate job-detail-result event.

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

Also resolve each unique company to its Wellfound /company/{slug} page for the enriched about text, size range, funding stage, tech stack, benefits, founders, and active jobs list. Deduplicated by company slug within the run. Charges a separate company-detail-result event per unique company. Requires includeJobDetails=true (auto-enabled if you toggle this on).

## `maxResults` (type: `integer`):

Total cap on jobs pushed to the dataset across all keywords / URLs.

## `maxResultsPerQuery` (type: `integer`):

Maximum results per individual search keyword / URL.

## `startPage` (type: `integer`):

Skip pages before returning results (e.g. 3 = start from page 3). Useful for resuming interrupted runs. Wellfound serves ~20 jobs per page.

## Actor input object example

```json
{
  "searchQueries": [
    "software engineer"
  ],
  "location": "San Francisco",
  "remote": false,
  "includeJobDetails": false,
  "includeCompanyDetails": false,
  "maxResults": 25,
  "maxResultsPerQuery": 100,
  "startPage": 1
}
```

# Actor output Schema

## `jobListings` (type: `string`):

Dataset containing all scraped Wellfound job listings. Each row is one job with 25+ base fields plus optional job-detail and company-detail enrichment. Deduplicated across queries by Wellfound's numeric job ID.

# 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 = {
    "searchQueries": [
        "software engineer"
    ],
    "includeJobDetails": false,
    "includeCompanyDetails": false,
    "maxResults": 25,
    "maxResultsPerQuery": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("santamaria-automations/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 = {
    "searchQueries": ["software engineer"],
    "includeJobDetails": False,
    "includeCompanyDetails": False,
    "maxResults": 25,
    "maxResultsPerQuery": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("santamaria-automations/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 '{
  "searchQueries": [
    "software engineer"
  ],
  "includeJobDetails": false,
  "includeCompanyDetails": false,
  "maxResults": 25,
  "maxResultsPerQuery": 100
}' |
apify call santamaria-automations/wellfound-jobs-scraper --silent --output-dataset

```

## MCP server setup

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