# Wellfound Startup Jobs Scraper (`bareezh_codes/wellfound-startup-jobs-scraper`) Actor

Get startup job listings from Wellfound (formerly AngelList Talent) by role/keyword: salary AND equity ranges, company size, stage, markets, website and full descriptions. No login needed.

- **URL**: https://apify.com/bareezh\_codes/wellfound-startup-jobs-scraper.md
- **Developed by:** [Salman Bareesh](https://apify.com/bareezh_codes) (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 $1.90 / 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.
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

Get startup job listings straight from **[Wellfound](https://wellfound.com)** (formerly AngelList Talent) - the largest job board built specifically for startups. This is a **Wellfound jobs API alternative** for anyone who needs structured startup job data without scraping the site by hand: search by role/keyword and pull job title, salary range, **equity range**, company details and a description snippet for every match, with no Wellfound login or API key required.

### Why use this Actor?

Wellfound is one of the few job boards where companies routinely publish **equity ranges alongside salary** - a real signal for anyone comparing startup offers, building compensation benchmarks, or qualifying leads by company stage. This Actor is built to capture that completely and reliably:

- **Salary AND equity, structured.** Salary comes from Wellfound's own structured job-posting data (min/max/currency); equity comes from the compensation text Wellfound displays next to it (e.g. "0.05% - 0.25%"), parsed into `equityMin`/`equityMax` rather than left as a string.
- **Company context**: size, funding stage (Early/Growth/Scale), public website, and industry/market tags - not just the job title.
- **No login, no API key.** Reads only Wellfound's own public pages.
- Runs on Apify's infrastructure: schedule it, pull results via the API, export to Sheets/JSON/CSV, or wire it into an integration - all without maintaining your own scraper.

Use cases: recruiters and sourcers building a startup-jobs pipeline, jobseekers tracking new startup roles in a niche, market researchers benchmarking startup compensation (including equity) by stage or industry, and lead-generation teams identifying actively-hiring startups.

### What data does this Actor extract?

| Field | Type | Description |
|---|---|---|
| `jobTitle` | string | The job's title |
| `companyName` / `companySlug` | string | The hiring startup |
| `companyWebsite` | string | null | The company's own public website, when Wellfound publishes it |
| `location` | string | Where the role is based (or its base location for remote roles) |
| `remoteFlag` | boolean | Whether the role is remote |
| `salaryMin` / `salaryMax` / `currency` | number / string | Structured annual salary range |
| `salaryText` | string | Wellfound's own compensation text, as displayed (salary + equity together) |
| `equityMin` / `equityMax` | number | Equity range in percent, when Wellfound publishes one (0/0 for an explicit "No equity"; null when not disclosed at all) |
| `jobType` | string | e.g. `full-time`, `contract` |
| `postedAt` | string | ISO-8601 posting date |
| `jobUrl` | string | Direct link to the listing on wellfound.com |
| `companySize` | string | e.g. "11-50 employees" |
| `companyMarkets` | array | Industry/market tags Wellfound assigns the company |
| `companyStage` | string | null | e.g. "Early Stage", "Growth Stage", "Scale Stage" |
| `description` | string | A snippet of the full job description |

### How to scrape Wellfound startup jobs

1. Open this Actor and, in **Input**, type a role or keyword (e.g. "Backend Engineer", "Product Manager") - or leave it as the default to see a sample.
2. Optionally narrow results with a location filter, company stage, or job type.
3. Set **Max jobs** (up to 200) and click **Start**.
4. When the run finishes, open the **Dataset** tab to view, filter, or export the results.

### How much will it cost to scrape Wellfound?

This Actor uses **pay-per-result** pricing: **$0.0025 per job** returned (lower on higher Apify plans: Bronze $0.00225, Silver $0.002, Gold/Platinum/Diamond $0.0019). Apify's free plan includes monthly platform credit, so light/occasional use can run entirely within the free tier. There is no separate compute-unit charge on top of the per-result price.

### Input

See the **Input** tab for the full list of options (role/keyword, location filter, remote-only, company stage, job type, max jobs). Every field is optional - an empty input scrapes a small sample of Software Engineer roles so you can see the output shape immediately.

### Output

You can download the dataset in JSON, CSV, Excel, HTML, or other formats from the **Dataset** tab. Example output (from a real run, trimmed to two items):

```json
[
  {
    "jobTitle": "Senior Software Engineer",
    "companyName": "Confident LIMS",
    "companySlug": "confidentlims",
    "companyWebsite": "https://www.confidentlims.com/",
    "companyLogo": "https://photos.wellfound.com/startups/i/829771-....jpg",
    "location": "San Francisco Bay Area",
    "remoteFlag": true,
    "salaryMin": 100000.0,
    "salaryMax": 180000.0,
    "currency": "USD",
    "salaryText": "$100k – $180k • 0.05% – 0.25%",
    "equityMin": 0.05,
    "equityMax": 0.25,
    "jobType": "full-time",
    "postedAt": "2026-09-10T17:59:14Z",
    "jobUrl": "https://wellfound.com/jobs/4697947-senior-software-engineer",
    "companySize": "11-50 employees",
    "companyMarkets": ["SaaS", "Information Technology", "Analytics", "Software", "Web Development"],
    "companyStage": "Early Stage",
    "description": "Confident powers analytical testing labs — the labs that test samples on behalf of businesses and report product safety to consumers and regulators at high volume..."
  },
  {
    "jobTitle": "Software Engineer",
    "companyName": "Oklo",
    "companySlug": "oklo",
    "companyWebsite": "https://www.oklo.com",
    "location": "Santa Clara, California, United States",
    "remoteFlag": true,
    "salaryMin": 110000.0,
    "salaryMax": 200000.0,
    "currency": "USD",
    "salaryText": "$110k – $200k",
    "equityMin": null,
    "equityMax": null,
    "jobType": "full-time",
    "postedAt": "2026-08-12T16:29:14Z",
    "jobUrl": "https://wellfound.com/jobs/4579450-software-engineer",
    "companySize": "51-200 employees",
    "companyMarkets": ["Clean Energy", "Renewable Energies", "Renewable Tech", "Nuclear Energy"],
    "companyStage": null,
    "description": "..."
  }
]
```

### Tips

- Keep **Max jobs** modest (20-50) for quick exploratory runs; each job costs one extra request (its detail page) at roughly 1 request/second, so 200 items takes a few minutes.
- If `companyWebsite`/`companyMarkets`/structured `salaryMin`/`salaryMax` come back null for some items, that job's detail page could not be fetched or parsed that run (see Limits) - `salaryText` and the search-page fields are still populated.

### Limits

- **Remote roles only, verified.** Wellfound's public, unauthenticated role-search page (`wellfound.com/role/r/{role}`) that this Actor reads only ever returns remote roles, regardless of query-string overrides - there is no equivalent public page found for on-site-only search. The `remoteOnly` input is kept for forward compatibility but currently has no additional effect.
- **Company profile pages are not scraped.** `wellfound.com/company/{slug}` pages return Wellfound's own "Security Check" interstitial to this Actor's requests; this Actor does not attempt to solve or bypass it. `companyWebsite` and `companyMarkets` instead come from the public schema.org job-posting data on each job's own detail page, which is not challenged the same way - when a specific job's detail page can't be fetched, those two fields fall back to null (or, for `companyMarkets`, to the company's public B2B/B2C tag when Wellfound shows one) rather than blocking the run.
- Equity ranges are only as complete as what each company chose to disclose to Wellfound; `null` means "not disclosed", not "zero".
- Respects Wellfound's servers: paced at roughly 1 request/second with bounded retries and Apify Proxy session rotation on a block, rather than hammering a blocked IP.

### Legal

Our Actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the target site has chosen to publish publicly. We therefore believe that our Actors, when used for ethical purposes by Apify users, are safe. However, you should be aware that your results could contain personal data (e.g. a job's contact name, if a company chose to publish one). Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

Found an issue or have a feature request? Use the **Issues** tab. Need programmatic access? See the **API** tab for this Actor's REST/client endpoints.

# Actor input Schema

## `keyword` (type: `string`):

The role or keyword to search for, e.g. "Software Engineer", "Product Manager", "Backend Engineer". This is converted to a URL slug the way Wellfound's own search does (lowercased, spaces to hyphens) - it does not need to exactly match one of Wellfound's predefined role names.

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

Only include jobs whose location or accepted-remote-locations mention this text (e.g. "United States", "San Francisco", "Canada"). Matched case-insensitively as a substring. Leave empty for no location filter. Note: Wellfound's public search used by this actor only reliably surfaces remote roles (see 'Remote only' below and the README 'Limits' section) - this filter narrows which countries/regions those remote roles accept candidates from, it does not unlock on-site-only jobs.

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

Wellfound's public, unauthenticated search page this actor uses only ever lists remote roles - there is no equivalent public page found for on-site-only search (verified live; see README 'Limits'). This flag is kept for forward compatibility; turning it off currently has no additional effect since the underlying data source is remote-only either way.

## `companyStages` (type: `array`):

Only include jobs at companies Wellfound publicly tags with one of these stages. Leave empty for all stages.

## `jobTypes` (type: `array`):

Only include jobs of these employment types, as published by Wellfound. Leave empty for all types.

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

Stop after this many job listings. Wellfound's search page lists roughly 20-40 jobs per page, and this actor fetches one extra request per matching job (its detail page, for structured salary/website/market data) at roughly 1 request/second - so 20 items takes about 25-30 seconds and 200 items takes about 4 minutes.

## Actor input object example

```json
{
  "keyword": "Software Engineer",
  "location": "",
  "remoteOnly": true,
  "companyStages": [],
  "jobTypes": [],
  "maxItems": 20
}
```

# Actor output Schema

## `dataset` (type: `string`):

One item per matching job listing

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("bareezh_codes/wellfound-startup-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("bareezh_codes/wellfound-startup-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 '{}' |
apify call bareezh_codes/wellfound-startup-jobs-scraper --silent --output-dataset

```

## MCP server setup

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