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

Scrapes Wellfound job listings from company profiles, role searches, and location feeds. Returns each posting as a flat row with title, description, salary, equity, remote policy, skills, and company details.

- **URL**: https://apify.com/parseforge/wellfound-jobs-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Jobs, Automation
- **Stats:** 8 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $13.50 / 1,000 items

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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### Wellfound Jobs Scraper

**Scrape Wellfound jobs from any company profile, role, or location, up to a million per run.** Every listing returns its title, salary range, equity, remote policy, required skills, and founding team details. No login or API key. Export to CSV, JSON, Excel, or XML.

Wellfound's job board is where startups post their most critical hires, but browsing manually or building an internal API integration takes engineering time you do not have. This scraper reads the public job listing pages directly, collecting every visible field from title and compensation to tech stack and founding team bios, and delivers them in one flat, analysis-ready schema.

| Who uses it | What they scrape Wellfound for |
|---|---|
| Talent intelligence analysts | Map which startups are hiring for specific roles and what compensation they offer. |
| Recruiters and staffing agencies | Build a live pipeline of startup job openings filtered by role, location, and salary band. |
| Job board aggregators | Pull fresh Wellfound listings into a multi-source job search platform. |
| Venture capital analysts | Track hiring velocity and role seniority across portfolio companies and competitors. |

### What it does

This Actor collects Wellfound job listings from company profile pages, role searches, or location feeds, and returns each posting as a flat row with its full description, salary band, equity range, remote policy, required skills, and company details.

- 💼 **Full job details:** title, description, salary range, equity, remote policy, and required skills.
- 🏢 **Company context:** founding team bios, company size, funding stage, and tech stack.
- 📍 **Location filters:** remote, hybrid, and on-site roles across any city or country.
- 🔗 **URL-driven input:** drop in any Wellfound company page or job search URL to start scraping.
- 📊 **Flat row output:** every job is one row, ready for CSV, JSON, Excel, or XML export.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with Wellfound data

**💰 Benchmark startup compensation.**

A talent intelligence analyst scrapes Wellfound jobs for senior engineering roles and compares salary bands and equity ranges across Series A and Series B companies.

**📋 Build a recruiter pipeline.**

A staffing agency pulls remote marketing roles daily, filters by salary and required skills, and loads the results into their outreach CRM.

**🏢 Monitor hiring velocity.**

A VC analyst scrapes job listings from portfolio companies each week to track headcount growth and role seniority as a signal of scaling.

**🌐 Aggregate startup jobs.**

A job board operator includes Wellfound listings alongside other sources, refreshing the feed every few hours to keep postings current.

### Why choose this scraper

| | What you get |
|---|---|
| **No API key needed** | Reads the public job pages directly, so you skip OAuth, rate limits, and app registration. |
| **Compensation data** | Salary bands and equity ranges are included when the employer lists them. |
| **Startup-specific fields** | Founding team bios, funding stage, and tech stack come through in the same row. |
| **Flexible input** | Start from a company page, a role search, or the main jobs feed. |

### How it compares

This Actor and the other Wellfound Jobs Scraper both extract job listings from Wellfound. Here is how they compare on the capabilities each listing describes.

| Feature | ParseForge | Wellfound Jobs Scraper |
|---|---|---|
| Salary range extraction | Yes, when present on the listing | Not listed |
| Equity range extraction | Yes, when present on the listing | Not listed |
| Founding team details | Yes, when present on the listing | Not listed |
| Remote policy field | Yes | Not listed |
| Required skills extraction | Yes, when present on the listing | Not listed |
| Company tech stack | Yes, when present on the listing | Not listed |

### Configure the run

Drive the Actor from any Wellfound company profile URL, role search page, or location feed, and set a maximum item count so only the most recent listings reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
 "startUrls": [
 {
 "url": "https://wellfound.com/jobs"
 }
 ],
 "maxItems": 10
}
```

A larger pull:

```json
{
 "startUrls": [
 {
 "url": "https://wellfound.com/jobs"
 }
 ],
 "maxItems": 200
}
```

### Pricing

Pay-per-result: **$0.018 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $1.80 |
| 1,000 results | $18.00 |
| 10,000 results | $180.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [Wellfound Jobs Scraper](https://apify.com/parseforge/wellfound-jobs-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to Wellfound through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=parseforge/wellfound-jobs-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check that the Start URL points to a valid Wellfound jobs page with active listings. If the page has no job postings, the Actor will return an empty dataset. Try the default URL (https://wellfound.com/jobs) to confirm the scraper is working.

**The scraper stopped before reaching my Max Items limit.**

The Actor stops when it has exhausted all available listings on the provided URLs. If the search or company page has fewer jobs than your Max Items value, the run ends early with whatever it found.

**Some fields are empty in my results.**

Wellfound listings vary in completeness. Salary, equity, and founding team details are only present when the employer chooses to include them. Empty fields mean the data was not on the page.

**I am getting a timeout or error on a large run.**

Large runs may need more memory. Increase the Actor's memory allocation in the run settings, or split the job across multiple runs using narrower search URLs.

**Can I scrape Wellfound jobs from multiple companies in one run?**

Yes. Add multiple company profile URLs to the Start URLs array, and the Actor will process each one sequentially, collecting all active listings from every company.

### FAQ

| Question | Answer |
|---|---|
| Do I need a Wellfound account or API key to scrape jobs? | No. The Actor reads the public job listing pages, so no login, API key, or app registration is required. |
| What Wellfound data does each job row include? | Each row returns the job title, full description, salary range, equity range, remote policy, required skills, company name, founding team bios, funding stage, and tech stack when those fields are present on the listing. |
| Can I scrape jobs from a specific company on Wellfound? | Yes. Paste the company's Wellfound profile URL into the Start URLs field, and the Actor will collect every active job listing from that company. |
| How do I filter by location or role? | Use a Wellfound search URL with your desired location or role filters applied, and pass that URL as the start URL. The Actor scrapes whatever listings that search returns. |
| Is there a limit on how many jobs I can scrape? | Free Apify users are limited to 10 items as a preview. Paid users can set the Max Items field up to 1,000,000 per run. |
| What export formats are supported? | You can export your dataset to CSV, JSON, Excel, or XML from the Apify platform. |
| Does this scraper handle pagination on Wellfound? | Yes. The Actor follows pagination links on search results and company profile pages to collect all available listings up to your Max Items limit. |
| Can I run this on a schedule? | Yes. Apify supports scheduled runs, so you can set the Actor to scrape Wellfound jobs hourly, daily, or weekly. |
| Does the scraper get salary and equity information? | It collects salary ranges and equity ranges whenever the employer includes them on the job listing. Not all listings provide this data. |
| What is the difference between this and the Wellfound API? | Wellfound does not offer a public jobs API. This scraper reads the same pages you see in a browser and structures the data for programmatic use. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Wellfound (formerly AngelList Talent). It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

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

List of Wellfound job listing page URLs to begin scraping. Defaults to the main jobs page.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://wellfound.com/jobs"
    }
  ],
  "maxItems": 10
}
```

# Actor output Schema

## `results` (type: `string`):

Complete dataset of all scraped records.

# 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 = {
    "startUrls": [
        {
            "url": "https://wellfound.com/jobs"
        }
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/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 = {
    "startUrls": [{ "url": "https://wellfound.com/jobs" }],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/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 '{
  "startUrls": [
    {
      "url": "https://wellfound.com/jobs"
    }
  ],
  "maxItems": 10
}' |
apify call parseforge/wellfound-jobs-scraper --silent --output-dataset

```

## MCP server setup

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