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

Collect Wellfound (AngelList) startup jobs - salary, equity, remote.

- **URL**: https://apify.com/usestring/wellfound-jobs.md
- **Developed by:** [String](https://apify.com/usestring) (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 $3.25 / 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 Jobs Scraper — startup salary and equity

The Wellfound Jobs Scraper collects startup job listings from Wellfound (formerly AngelList Talent).
It returns the salary range and the **equity range** as numbers, plus the company, its headcount
bucket, the location, a remote flag and a direct link to the posting.

To scrape Wellfound startup jobs, put one or more role keywords in `queries` and set `location` to a
city or to `"Remote"`. Few job boards publish equity at all, which is why `equityMin` and
`equityMax` are the fields this Actor exists for. No Wellfound account, login or cookies are used;
this Actor reads what a logged-out visitor sees. Around **37 jobs per role**, at a measured median
of 0.7 seconds per request.

### What it returns

| Field | Type | Notes |
| --- | --- | --- |
| `jobId` | string | Wellfound's own listing ID — stable, use it to de-duplicate |
| `title` | string | |
| `company` | string | The startup's name |
| `companySlug` | string | Its Wellfound handle, e.g. `"stepsecurity"` |
| `salaryMin`, `salaryMax` | number | Numbers, e.g. `135000` and `175000` — not the `"$135k – $175k"` string |
| `currency` | string | ISO code read from the posting's own figure, e.g. `"USD"`, `"GBP"`, `"INR"` |
| `equityMin`, `equityMax` | number | Equity percentages, e.g. `0.05` and `0.25`. `0` and `0` when the listing states "No equity"; `null` when it says nothing about equity |
| `location` | string | The listing's stated location, or its accepted remote locations when there is no office location |
| `isRemote` | boolean | Whether Wellfound marks the role remote |
| `companySize` | string | Headcount bucket, e.g. `"11-50"`, `"1001-5000"` |
| `jobUrl` | string | Direct link to the Wellfound posting |
| `query`, `sourceUrl`, `collectedAt` | string | Provenance for every row |

### Input

```json
{ "queries": ["software engineer", "product designer"], "location": "Remote" }
```

| Field | Description |
| --- | --- |
| `queries` | Role keywords. Required, 1–50. Duplicates collapse to one fetch. |
| `location` | A city, or `"Remote"` (default). One location per run. |
| `maxItems` | Cap on dataset items. Default 1000. Free plans stop at 250 requests and 250 results — see below. |
| `concurrency` | Roles fetched in parallel. Default 2, maximum 5. |

Each role and location pair addresses one Wellfound role landing page —
`wellfound.com/role/r/software-engineer` for remote, `wellfound.com/role/l/software-engineer/san-francisco`
for a city — so `queries` should read as role names rather than free-text boolean searches.

### Use cases

- Startup compensation benchmarking on salary **and** equity together
- Sourcing remote startup roles by function
- Tracking which startups of a given headcount bucket are hiring, joined on `companySlug`
- Building a startup-hiring lead list from `company`, `companySize` and `location`
- Monitoring a role market over time by re-running on a schedule, joined on `jobId`

### Reliability

The Wellfound Jobs Scraper reads the landing page's own Apollo cache rather than the rendered
markup, and it verifies the arguments the page was actually served with before emitting a single
row. This matters because Wellfound does not 404 an unknown role or location — it quietly serves its
generic job board instead, which would otherwise look like a successful run full of off-topic jobs.
A role or location with no Wellfound landing page is reported as a failure in the run's `SUMMARY`
rather than filled with the wrong listings.

Wellfound publishes pay as one display string, so this Actor parses both halves of it: the salary
range and the equity range. `"Up to $215k"` sets `salaryMax` and leaves `salaryMin` `null` rather
than repeating one bound as both. `"No equity"` is recorded as `0`–`0`, which is a different fact
from equity that the listing never mentions and is left `null`. Indian salaries written in lakh and
crore are converted to plain numbers.

A run where every role failed exits with an error rather than finishing empty.

### Frequently asked questions

**Do I need a Wellfound or AngelList account?** No. The Wellfound Jobs Scraper uses no account,
login, cookies or API key — only public Wellfound role landing pages are read.

**Does the Wellfound Jobs Scraper return equity?** Yes. `equityMin` and `equityMax` are the equity
percentages the listing publishes, e.g. `0.05` and `0.25`. A listing that states "No equity" returns
`0` and `0`; a listing that says nothing about equity returns `null`, so the two cases stay
distinguishable.

**How many Wellfound jobs does one role return?** Around 37 per role landing page. Ten role keywords
therefore return roughly 370 jobs.

**Why did my search return nothing?** Wellfound serves results only for roles and locations that
have a landing page. `"software engineer"` and `"product designer"` work; an invented or very narrow
role has no page, and the run records it under `failures` instead of returning Wellfound's generic
board.

**Does it include the posted date or the full job description?** No. Wellfound's role landing pages
publish neither a posting date nor the description, so this Actor does not emit them. Follow `jobUrl`
for the full posting.

**Can I search several locations in one run?** No — one run searches one `location` across all of
its `queries`. Start one run per city, or use `"Remote"`.

**What happens on a free Apify plan?** The run stops at 250 requests and 250 results and reports
that it hit the limit. Any paid plan runs the full input.

### Limitations

The Wellfound Jobs Scraper reads one role landing page per query, so coverage is what Wellfound puts
on that page rather than a full crawl of its board; run several role keywords to widen coverage.
Posting dates, full descriptions, founder and investor details, company funding stage and applicant
counts are out of scope, as is searching more than one location per run.

### Free plan limit

Runs started from an Apify **free plan** stop at **250 requests and 250 results**, and the run
reports that it reached the limit. Any paid plan runs the full input and `maxItems` you set.

The limit exists because this Actor fetches through our own infrastructure, which Apify does not
cover for free-plan runs. It binds on requests as well as results so that a large input list cannot
spend those fetches for rows the run will not return.

# Actor input Schema

## `queries` (type: `array`):

Role keywords to search for.

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

City or 'Remote'.

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

Global cap on dataset items. Runs started from an Apify free plan stop at 250 requests and 250 results; any paid plan runs the full amount.

## `concurrency` (type: `integer`):

Targets fetched in parallel.

## Actor input object example

```json
{
  "queries": [
    "software engineer"
  ],
  "location": "Remote",
  "maxItems": 1000,
  "concurrency": 2
}
```

# Actor output Schema

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

Collect Wellfound (AngelList) startup jobs - salary, equity, remote.

## `summary` (type: `string`):

Item count, failure count and every target that failed, with its error.

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

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

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

```

## MCP server setup

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