# Wellfound Jobs: Startup Salary & Equity (`deepmine/wellfound-jobs`) Actor

Get startup jobs from Wellfound (AngelList Talent) by role and location: title, company, logo, tagline, location, remote policy, posted date, company size, stage, badges and full description, plus salary and equity when the startup lists them. For recruiters, job boards and startup researchers.

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

## Pricing

from $1.00 / 1,000 jobs

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Wellfound Jobs: Startup Salary & Equity

Type a role like Software Engineer (and, if you want, a city or Remote) and get Wellfound's startup jobs as clean rows: title, company, logo and pitch, role, location, remote policy, posted date, company size, funding stage, market, badges such as YC Funded or Top Investors, the full job description, and the salary, equity, years of experience and Glassdoor ratings when the startup lists them (live run 2026-10-06: salary on 90 of 100 jobs, equity on 26, years of experience on 35).

| 💼 Title | 🏢 Company | 📍 Location | 🏠 Workplace | 💰 Salary | 📈 Equity | 🚀 Stage | 📅 Posted |
|---|---|---|---|---|---|---|---|
| Software Engineer | Nyle.ai | San Francisco | Remote or on-site | $100k – $165k | 1.0% – 3.0% | Early Stage | 2026-09-30 |
| Senior Software Engineer | Countly | London | Remote | $66k – $80k | No equity | Early Stage | 2026-09-23 |
| Product Manager, Growth & Lifecycle | Rhythm Energy | Houston | Remote | $140k – $160k | No equity | Growth Stage | 2026-09-29 |

<sub>Collected 2026-10-06.</sub>

**$1.50 per 1,000 jobs** on the Starter plan ($1.80 Free, $1.20 Scale, $1.00 Business). The prefilled run (100 jobs: 50 Software Engineer and 50 Product Manager jobs) costs about $0.15.

It reads Wellfound's public job search pages (formerly AngelList Talent) at run time: no login, no browser, no stored copy of our own. Fast: 40 remote Software Engineer jobs arrived 4.3 seconds after the start request on 2026-10-06, where two of the most-used alternatives took 54 and 83 seconds for the same page.

### What you can do with it

- **Recruit from startups' hiring lists**: every startup hiring for a role, with its size, stage, market, valuation band and a link to its Wellfound page.
- **Benchmark startup pay and equity**: the **💰 With Salary** list holds every job with a published salary (about 9 in 10 jobs), with numbers you can sort and average.
- **Feed a job board or newsletter** with fresh startup jobs, logos and full descriptions, filtered to the last few days, and only the jobs you don't have yet.
- **Find sales leads**: startups hiring for a role you sell to, flagged YC Funded, Top Investors, Growing fast or Valuation $1B+.

### Input

```json
{
  "roles": ["Software Engineer", "Product Manager"],
  "locations": ["San Francisco", "Remote"],
  "maxJobsPerSearch": 100,
  "postedWithinDays": 7,
  "keywords": ["rust", "fintech"],
  "minSalary": 150000
}
```

| Field | What it does |
|---|---|
| `roles` | Roles as Wellfound names them: Software Engineer, Product Manager, Data Scientist, Designer, Machine Learning Engineer, Sales, Marketing... You can also paste a Wellfound search URL: `https://wellfound.com/role/l/designer/new-york`, `/role/r/<role>` (remote), `/location/<city>` (every role in a city). |
| `locations` | Optional. Cities or countries as Wellfound names them (San Francisco, New York, London, Berlin, Bangalore, United States), or `Remote` for remote jobs only. Each role is searched in each location. Empty = every location. |
| `maxJobsPerSearch` | Jobs per role and location, in Wellfound's order (default 100; the form starts at 50). 0 = every job Wellfound lists. You pay per job, so this caps the cost per search. |
| `postedWithinDays` | Keep only jobs posted in the last N days (0 = any date). Older jobs are skipped and cost nothing. Wellfound's pages are not sorted by date, so on a big role a short window can match only a few jobs per page: the run then stops reading when the pages no longer pay for themselves, and says so in the run summary. |
| `keywords` | 🎛️ Filters: keep only jobs whose title or description mentions one of these words (whole words, any case). |
| `companies` | 🎛️ Filters: keep only jobs at startups whose name contains one of these. |
| `excludeCompanies` | 🎛️ Filters: leave out jobs at startups whose name contains one of these. |
| `minSalary` | 🎛️ Filters: keep only jobs whose salary range reaches at least this (per year, in the job's currency); jobs without a salary are left out. |
| `excludeJobIds` | 🔁 Job IDs or Wellfound job links you already have, so a scheduled run brings only new jobs. |
| `includeDescription` | 🧾 Full description as plain text, plus the links written in it (on by default, same price). |
| `maxResults` | ⚙️ Stop after this many jobs in total (default 1,000). |
| `proxyConfiguration` | ⚙️ Apify residential proxies (US) by default. Wellfound's Cloudflare check refuses most datacenter IPs, so keep the default. |

Jobs a filter or `excludeJobIds` leaves out are never charged.

### Output

One row per job. Searches come in the order of your roles and locations; within a search, jobs come in Wellfound's own order (the order its search page shows). A job that several searches find comes once, from the first search.

Two datasets, both with the same rows:

- **💼 All Jobs** (default dataset). Views: **📊 Overview** (🖼️ Logo, 💼 Title, 🏢 Company, 💡 Tagline, 📍 Location, 🏠 Workplace, 💰 Salary, 📈 Equity, 🚀 Stage, 📅 Posted, 🔗 Wellfound), **📈 Stats** (salary and equity ranges, size, years of experience, the Glassdoor ratings) and **🏢 Companies** (🖼️ Logo, 🏢 Company, 💡 Tagline, 👥 Size, 🚀 Stage, 🏅 Badges, 🏢 Company Page, 🎯 Market, 💎 Valuation, 🟧 YC Funded, 💼 Top Investors, 🚀 Growing Fast, 💼 Title, 🔗 Wellfound).
- **💰 With Salary**: the delivered jobs that publish a salary, in the same order, at no extra charge. View **💰 Salaries**: 🖼️ Logo, 💼 Title, 🏢 Company, 📍 Location, 💰 Salary, 💰 Salary Min, 💰 Salary Max, 💱 Currency, 📈 Equity, 📅 Posted, 🔗 Wellfound.

#### Output fields

In row order:

- `companyLogo`: the startup's logo from Wellfound.
- `title`: job title.
- `company`: startup name.
- `companyTagline`: what the startup does, its one-line pitch on Wellfound.
- `role`: Wellfound's role for the job, e.g. `Software Engineer`, `Product Manager`.
- `location`: the job's places, comma-separated. A remote job that names no place says `Remote`.
- `workplaceType`: `Remote`, `Remote or on-site`, `Hybrid` (on-site with work-from-home flexibility) or `On-site`.
- `remoteLocations`: where a remote hire may live, when the company says (e.g. `["United States", "Canada"]`). Empty otherwise.
- `employmentType`: `Full-time`, `Part-time`, `Contract`, `Internship` or `Cofounder`.
- `experienceMinYears`: years of experience the job asks for, when the startup says (about 1 in 3 jobs).
- `salary`: the salary range as Wellfound shows it, e.g. `$120k – $200k`, `$90k – $120k CAD` or `₹10L – ₹20L`. Usually per year, as the company entered it. Empty when the company publishes none.
- `salaryMin`: the lowest salary in the range, as a number (`₹10L` = 1000000).
- `salaryMax`: the highest salary in the range, as a number.
- `salaryCurrency`: ISO currency code, e.g. `USD`, `EUR`, `INR`.
- `equity`: the equity range as Wellfound shows it, e.g. `0.05% – 0.25%`, or `No equity`. Empty when the company says nothing about equity (about 3 in 4 jobs).
- `equityMin`: the lowest equity in percent (`0.05` = 0.05%); `0` when the company offers no equity.
- `equityMax`: the highest equity in percent; `0` when the company offers no equity.
- `postedAt`: when the job went live on Wellfound, in UTC (`2026-09-10T17:59:14Z`).
- `jobUrl`: the job's page on Wellfound.
- `companySize`: employees, `1-10` to `5000+`.
- `companyStage`: `Early Stage`, `Growth Stage`, `Scale Stage` or `Public Stage`, when Wellfound shows it.
- `companyMarket`: `B2B`, `B2C` or both, when Wellfound tags the startup.
- `companyValuation`: `$500M+` or `$1B+` when Wellfound shows a valuation badge.
- `companyBadges`: all of Wellfound's badges for the startup, e.g. `YC Funded`, `Top Investors`, `Valuation $1B+`, `Growing fast`, `B2B`, `Responds within a day`.
- `isActivelyHiring`: `true` when Wellfound marks the startup as actively processing applications.
- `isGrowingFast`: `true` when Wellfound marks strong hiring growth in the past month.
- `isYcFunded`: `true` when the startup is funded by Y Combinator.
- `hasTopInvestors`: `true` when Wellfound marks the startup as backed by top investors.
- `companyResponseRate`: e.g. `Top 10% of responders`, when Wellfound shows it.
- `companyResponseTime`: e.g. `Responds within two weeks`, when Wellfound shows it.
- `companyGlassdoorRating`: the startup's Glassdoor rating (1-5), when Wellfound shows its Highly rated badge.
- `companyWorkLifeBalanceRating`: employees' work/life balance rating on Glassdoor (1-5), when Wellfound shows it.
- `companyLeadershipRating`: employees' rating of leadership on Glassdoor (1-5), when Wellfound shows it.
- `companyUrl`: the startup's page on Wellfound.
- `atsSource`: the applicant tracking system the job comes from, e.g. `Greenhouse`, `Ashby`, `Lever` (about 7 in 10 jobs).
- `isAutoPosted`: `true` when Wellfound imported the job automatically.
- `description`: the full job description as plain text, `•` for list items. Only with `includeDescription` (on by default).
- `descriptionLinks`: the web links written in the description (apply pages, company sites). Only with `includeDescription`.
- `jobId`: the job's id on Wellfound.
- `companyId`: the startup's id on Wellfound.
- `searchUrl`: the Wellfound search (role, location) that found the job first.
- `scrapedAt`: when this run read the job (UTC).

Example row (description shortened):

```json
{
  "companyLogo": "https://photos.wellfound.com/startups/i/395014-2a2164ef6a8cd5954eb970228e62ce15-medium_jpg.jpg?buster=1692326450",
  "title": "Software Engineer",
  "company": "Checkr",
  "companyTagline": "The only background check company using artificial intelligence and machine learning",
  "role": "Software Engineer",
  "location": "Denver, San Francisco",
  "workplaceType": "On-site",
  "remoteLocations": null,
  "employmentType": "Full-time",
  "experienceMinYears": null,
  "salary": "$150k – $176k",
  "salaryMin": 150000,
  "salaryMax": 176000,
  "salaryCurrency": "USD",
  "equity": null,
  "equityMin": null,
  "equityMax": null,
  "postedAt": "2026-08-27T20:06:24Z",
  "jobUrl": "https://wellfound.com/jobs/4639821-software-engineer",
  "companySize": "501-1000",
  "companyStage": "Scale Stage",
  "companyMarket": "B2B",
  "companyValuation": "$1B+",
  "companyBadges": ["Actively Hiring", "Responds within three weeks", "B2B", "Top Investors", "YC Funded", "Valuation $1B+", "Highly rated", "Work / Life Balance", "Strong Leadership"],
  "isActivelyHiring": true,
  "isGrowingFast": false,
  "isYcFunded": true,
  "hasTopInvestors": true,
  "companyResponseRate": null,
  "companyResponseTime": "Responds within three weeks",
  "companyGlassdoorRating": 4.1,
  "companyWorkLifeBalanceRating": 4.3,
  "companyLeadershipRating": 4.1,
  "companyUrl": "https://wellfound.com/company/checkr",
  "atsSource": "Greenhouse",
  "isAutoPosted": false,
  "description": "As a Software Engineer at Checkr, you will work on high-impact engineering projects that help build a fairer future for ...",
  "descriptionLinks": null,
  "jobId": "4639821",
  "companyId": "395014",
  "searchUrl": "https://wellfound.com/role/software-engineer",
  "scrapedAt": "2026-10-06T22:00:37Z"
}
```

The run's **🧾 Run summary** (the OUTPUT record in the key-value store) shows, per search, how many jobs Wellfound counts, how many pages were read, how many jobs were found, delivered, left out by your filters, skipped as older or already delivered, plus any error.

### When something goes wrong

- A role or location Wellfound has no page for (a typo, a very niche title, a small town) is listed in the run summary and the status message. The run still delivers everything else. Try the broader role (Engineer, Designer) or a nearby city or the country.
- If a page can't be read after several retries on fresh IPs, the run ends as **failed** with the reason, so you notice. The jobs read before that are in the dataset and charged; nothing else is.
- When `maxResults` or your spending limit is reached, the searches after that point get nothing; the run summary marks them as skipped.
- If Apify restarts or resurrects a run, it reads its dataset back first: no job is delivered or charged twice (live check 2026-10-06: a resurrected 100-job run stayed at 100 rows and 100 charges).

### Pricing

You pay per job delivered: $1.80 per 1,000 jobs on the Free plan, $1.50 on Starter, $1.20 on Scale and $1.00 on Business. Descriptions, salary and equity are included at the same price. No start fee. Pages, retries, jobs skipped by the date filter or your filters, and the 💰 With Salary list cost nothing. Each job is charged once, even when Apify restarts the run.

Examples on Starter: the prefilled run (100 jobs) about $0.15; the default `maxResults` of 1,000 jobs $1.50; 5,000 jobs $7.50. `maxJobsPerSearch` and `maxResults` cap what a run can cost.

### FAQ

**How many jobs does a search reach?** Wellfound's search pages show up to 3 jobs per startup, so a full walk reaches most, not all, of the jobs Wellfound counts: 352 of 415 for Data Scientist on 2026-09-27. The run summary shows both numbers for every search.

**Which roles and locations exist?** The ones Wellfound has pages for: open `https://wellfound.com/role/<role>` or `https://wellfound.com/role/l/<role>/<city>` in a browser to check. Big roles (Software Engineer, Product Manager, Sales, Marketing, Designer) have thousands of jobs. For a narrower topic, search the broad role and add `keywords` (e.g. role Software Engineer, keyword Rust).

**How fresh is the data?** Each run reads Wellfound's search results live, at run time; we keep no database of our own. Only the run's very first page can be a copy Wellfound cached up to about a day ago, so a job posted in the last few hours may be missing from that page and show up in the next day's run.

**Can I get new jobs every day?** Yes: save your input as a task, schedule it daily in Apify, and set `postedWithinDays` to 2 so each run brings the latest postings (best on a role or city with a few hundred jobs; see the next answer for big roles). Put the `jobId`s you already have in `excludeJobIds` (they are skipped and not charged), or dedupe on `jobId`.

**Why did my run stop before the last page?** Wellfound lists jobs in its own order, not by date, so with `postedWithinDays`, `keywords`, `companies` or `minSalary` a run on a big role reads many pages for few matches. When the pages read so far hold too few matches to be worth the bandwidth they use, the run stops and its status message says how many searches stopped early (the search's `stop` is `lowYield` in the run summary). Jobs on later pages may then be missing. Narrow the search (a smaller role, or a city) to read it whole.

**Does it collect personal data?** No. Rows hold jobs and companies only, no recruiter or founder profiles.

### Feedback

Missing a field, a role or a location it can't find? Open an issue on the Issues tab and we'll look at it. If the data helped you, a short review on this page helps other people find it.

# Actor input Schema

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

Roles as Wellfound names them, e.g. Software Engineer, Product Manager, Data Scientist. Or paste a Wellfound search URL (/role/..., /role/l/<role>/<city>, /role/r/<role>, /location/<city>).

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

Cities or countries as Wellfound names them, e.g. San Francisco, London, United States, or Remote for remote jobs only. Each role is searched in each location. Empty = every location.

## `maxJobsPerSearch` (type: `integer`):

Jobs per role (per role and location), in Wellfound's order. You pay per job, so this caps the cost per search. 0 = every job Wellfound lists.

## `postedWithinDays` (type: `integer`):

Keep only jobs posted in the last N days, e.g. 2 for daily runs; older ones cost nothing. 0 = any date. Big roles may stop early when pages hold few matches.

## `keywords` (type: `array`):

Keep only jobs whose title or description mentions one of these words, e.g. Rust or fintech. Not case-sensitive. Empty = keep all.

## `companies` (type: `array`):

Keep only jobs at startups whose name contains one of these, e.g. Checkr. Empty = every startup.

## `excludeCompanies` (type: `array`):

Leave out jobs at startups whose name contains one of these. Empty = keep all.

## `minSalary` (type: `integer`):

Keep only jobs whose salary range reaches at least this, in the job's currency, e.g. 150000. Jobs without a salary are left out. Empty = no minimum.

## `excludeJobIds` (type: `array`):

Job IDs or Wellfound job links you already have (the jobId column of an earlier run), so a scheduled run brings only new jobs. Skipped jobs are not charged.

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

The full job description as plain text, plus the links written in it. Same price either way; turn it off for smaller rows.

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

Stop after this many jobs in total. You pay per job, so this caps the run's cost. Searches are delivered in the order of your roles and locations.

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

Leave as is: Apify residential proxies (US) are the default, because Wellfound's Cloudflare check refuses most datacenter IPs.

## Actor input object example

```json
{
  "roles": [
    "Software Engineer",
    "Product Manager"
  ],
  "maxJobsPerSearch": 50,
  "postedWithinDays": 0,
  "includeDescription": true,
  "maxResults": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

No description

## `withSalaryUrl` (type: `string`):

No description

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

No description

# 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",
        "Product Manager"
    ],
    "maxJobsPerSearch": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("deepmine/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",
        "Product Manager",
    ],
    "maxJobsPerSearch": 50,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("deepmine/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",
    "Product Manager"
  ],
  "maxJobsPerSearch": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call deepmine/wellfound-jobs --silent --output-dataset

```

## MCP server setup

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