# Wellfound Startup Jobs Scraper (`clearrun/wellfound-jobs`) Actor

Public startup job listings from Wellfound (formerly AngelList Talent) by role and location: title, company (name, tagline, size, stage, badges, logo), locations, remote mode, salary range with currency, equity range, job type, posted date and description. No login, no personal data.

- **URL**: https://apify.com/clearrun/wellfound-jobs.md
- **Developed by:** [Clearrun Data](https://apify.com/clearrun) (community)
- **Categories:** Jobs, Agents, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 job listings

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 Startup Jobs Scraper

Search Wellfound (formerly AngelList Talent) by role and location and get every public job listing with the
**company, locations, remote mode, salary range, equity range, job type, posted date and description**. Reads the
data Wellfound embeds in its listing pages, so no browser is needed and runs are fast and cheap. Public listing
pages only: no login, no candidate or recruiter data.

### What you get

```json
{
  "jobId": "4689464",
  "title": "Software Engineer",
  "url": "https://wellfound.com/jobs/4689464-software-engineer",
  "applyUrl": "https://wellfound.com/jobs/4689464-software-engineer",
  "company": {
    "id": "93099",
    "name": "Canva",
    "slug": "canva",
    "url": "https://wellfound.com/company/canva",
    "tagline": "Empowering the world to design",
    "size": "1001-5000",
    "stage": "Scale Stage",
    "badges": ["Actively Hiring", "Scale Stage", "Top Investors", "Valuation $1B+"],
    "logo": "https://photos.wellfound.com/startups/i/93099-....jpg"
  },
  "locations": ["Sydney"],
  "remote": true,
  "remoteMode": "onsite_or_remote",
  "acceptedRemoteLocations": [],
  "salaryMin": 150000,
  "salaryMax": 185000,
  "salaryCurrency": "USD",
  "salaryText": "$150k – $185k",
  "equityMin": 0.05,
  "equityMax": 0.25,
  "equityText": "0.05% – 0.25%",
  "compensationText": "$150k – $185k • 0.05% – 0.25%",
  "jobType": "full-time",
  "experienceMinYears": null,
  "experienceMaxYears": null,
  "experienceText": null,
  "roleTitle": "Software Engineer",
  "postedAt": "2026-09-08T00:58:15.000Z",
  "autoPosted": false,
  "atsSource": null,
  "description": "**Join the team redefining how the world experiences design.** ...",
  "query": { "role": "software engineer", "location": "remote", "url": "https://wellfound.com/role/r/software-engineer" },
  "page": 1,
  "position": 1,
  "sourceUrl": "https://wellfound.com/role/r/software-engineer",
  "scrapedAt": "2026-09-09T08:31:12.512Z"
}
```

Field notes:

- `salaryMin` / `salaryMax` are numbers in `salaryCurrency` (ISO code; Indian lakh values are expanded, so `₹8L` is `800000`).
  `salaryText`, `equityText` and `compensationText` keep Wellfound's original wording. All are `null` when the listing shows no compensation.
- `equityMin` / `equityMax` are percentages; "No equity" gives `0` / `0`.
- `remoteMode` is `remote`, `onsite` or `onsite_or_remote`; `remote` is Wellfound's boolean flag.
- `company.size` is the headcount band (`1-10`, `11-50`, `51-200`, `201-500`, `501-1000`, `1001-5000`, ...); `company.stage` is the
  funding stage badge (Early Stage, Growth Stage, Scale Stage) when Wellfound shows one.
- `postedAt` is when the listing went live. `description` is Markdown; switch it off with `includeDescription: false`.
- `position` is the job's rank within its search across pages; `page` is the Wellfound results page it came from.

The key-value store record `STATS` holds, per search, the delivered count, how many listings Wellfound reports for the search,
pages fetched and min/median/max salary midpoints per currency.

### Input

| Field | Default | Notes |
|---|---|---|
| `roles` | `["software engineer"]` | Job titles, one per line. Any wording works; it is turned into Wellfound's URL slug (`software engineer` → `software-engineer`) |
| `locations` | `["remote"]` | Cities as they appear in wellfound.com URLs (`london`, `san francisco`, `new york`, `berlin`) or `remote`. Empty = all locations |
| `remoteOnly` | `false` | Use Wellfound's remote listings for every role and skip on-site jobs |
| `startUrls` | — | Paste wellfound.com listing pages: `/role/l/<role>/<city>`, `/role/r/<role>`, `/role/<role>`, `/location/<city>`, `/remote`, `/jobs` |
| `maxResults` | 100 | Cap across the whole run |
| `maxResultsPerQuery` | 100 | Cap for each role and location combination |
| `includeDescription` | `true` | Include the Markdown job description |
| `proxyConfiguration` | Apify residential | Wellfound blocks Apify's datacenter IPs with HTTP 403s |

Every role is combined with every location. A location Wellfound does not recognise is skipped with a warning in the log
(Wellfound would otherwise silently show all locations). Wellfound serves 20 companies per page with up to three
highlighted jobs each, so a search typically yields 30–60 jobs per page; pagination continues until your cap or the last
public page.

### Pricing

Pay per job listing delivered. Duplicate listings within a run are removed before charging. Searches that return
nothing cost nothing.

#### Speed & cost

Runs in roughly 30–60 seconds per 100 results; a 100-job run costs about $0.20 in job events plus roughly $0.02 of
platform usage.

### Use from an AI agent

Available through the Apify MCP server, for example: "Find remote software engineer jobs on Wellfound that pay at
least $150k and list the companies with their stage." Or call the API directly:

```bash
curl -X POST "https://api.apify.com/v2/acts/clearrun~wellfound-jobs/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"roles":["product manager"],"locations":["london","remote"],"maxResults":50}'
```

### Support

Open an issue on the Issues tab with your input and the run ID. Issues are answered within one working day.

# Actor input Schema

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

Job titles to search, one per line, e.g. "software engineer", "product manager", "data scientist". Combined with every location below.

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

Cities or "remote", one per line, e.g. "remote", "london", "san francisco", "new york". Leave empty for all locations.

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

Search Wellfound's remote listings for each role and skip on-site jobs.

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

Optional: paste wellfound.com listing pages instead of, or as well as, roles and locations, e.g. https://wellfound.com/role/l/software-engineer/london, https://wellfound.com/role/r/product-manager, https://wellfound.com/location/berlin, https://wellfound.com/remote.

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

Stop after this many jobs across all searches. Duplicates are removed before counting.

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

Stop after this many jobs for each role and location combination.

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

Add the full job description (Markdown) to each record. Turn off for a smaller dataset.

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

Wellfound blocks Apify's datacenter proxies with HTTP 403s, so this defaults to residential.

## Actor input object example

```json
{
  "roles": [
    "software engineer"
  ],
  "locations": [
    "remote"
  ],
  "remoteOnly": false,
  "startUrls": [
    {
      "url": "https://wellfound.com/role/r/software-engineer"
    }
  ],
  "maxResults": 100,
  "maxResultsPerQuery": 100,
  "includeDescription": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

One record per Wellfound job listing

## `stats` (type: `string`):

Delivered count, listings available on the site and salary midpoint statistics per search

# 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": [
        "remote"
    ],
    "startUrls": [
        {
            "url": "https://wellfound.com/role/r/software-engineer"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("clearrun/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": ["remote"],
    "startUrls": [{ "url": "https://wellfound.com/role/r/software-engineer" }],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("clearrun/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": [
    "remote"
  ],
  "startUrls": [
    {
      "url": "https://wellfound.com/role/r/software-engineer"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call clearrun/wellfound-jobs --silent --output-dataset

```

## MCP server setup

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