# Wellfound (AngelList) Startup Jobs & Company Scraper (`ahmed_jasarevic/wellfound-startup-jobs-scraper`) Actor

Extract startup job listings (role, location, remote, salary range, equity) and company profiles (funding stage, size, market, social links) from Wellfound (formerly AngelList Talent). For recruiters, talent agencies, job-board aggregators and market researchers.

- **URL**: https://apify.com/ahmed\_jasarevic/wellfound-startup-jobs-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Categories:** Jobs, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 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.

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

### What does Wellfound (AngelList) Startup Jobs & Company Scraper do?

This Actor extracts **startup job listings and company profiles from [Wellfound](https://wellfound.com)** (formerly AngelList Talent). For every job it returns the title, role, location, remote policy, job type, **salary range and equity range**, description, and the hiring company's profile. For company pages it returns the **funding stage, team size, market, total raised, and social/website links**.

It is built for **recruiters, startup talent agencies, job-board aggregators, and market researchers** who track which startups are hiring, what they pay, and at what stage. It runs on the Apify platform, so you get an API, scheduling, automatic proxy rotation and monitoring out of the box.

### Why use this Actor?

- **Startup-specific data that job boards don't have** — Wellfound listings include equity ranges and funding-stage context that are unavailable on LinkedIn, Indeed or Glassdoor.
- **Hiring-velocity signal** — a seed-stage startup suddenly posting 10+ roles is often closing a round; this data surfaces that movement.
- **Compensation benchmarking** — numeric salary min/max and equity min/max are parsed from the raw strings so you can compare across roles, stages and markets.
- **Lead generation** — company pages expose the website, LinkedIn, Twitter and other public contact channels for outreach.

### How to use this Actor

1. Open the Actor in [Apify Console](https://console.apify.com).
2. In the **Input** tab, choose one or more search dimensions:
   - **Role slugs** (e.g. `software-engineer`, `product-manager`, `data-scientist`)
   - **Location slugs** (e.g. `remote`, `san-francisco`, `london`)
   - **Company slugs** (e.g. `moxion-power-co`) for full profiles
   - **Direct URLs** for anything else
3. Click **Start** — or run it via the Apify API, schedule it daily, or wire it into Make/Zapier/n8n.

> **Tip:** You need at least one of the four input groups. Role + location are combined into search URLs like `https://wellfound.com/role/l/software-engineer/remote`.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `roles` | string\[] | `[]` | Role slugs to search, e.g. `software-engineer` |
| `locations` | string\[] | `[]` | Location slugs, e.g. `remote`, `san-francisco` |
| `companySlugs` | string\[] | `[]` | Company slugs for full profiles |
| `startUrls` | array | `[]` | Direct Wellfound URLs (search / company / job pages) |
| `maxItems` | integer | `100` | Hard cap on dataset records |
| `maxPagesPerSearch` | integer | `5` | Max result pages crawled per search URL |
| `maxConcurrency` | integer | `3` | Parallel browser pages (keep 2–4 to avoid rate limits) |
| `proxyConfiguration` | proxy | Residential | Apify proxy; **Residential** is recommended |

Example JSON input:

```json
{
  "roles": ["software-engineer"],
  "locations": ["remote", "san-francisco"],
  "maxItems": 200,
  "maxPagesPerSearch": 5
}
```

### Output

Each record is a `type: "job"` or `type: "company"` object. You can download the dataset in various formats such as **JSON, HTML, CSV, or Excel**.

```json
{
  "type": "job",
  "id": "2275832",
  "title": "Senior UI/UX Designer",
  "slug": "senior-ui-ux-designer",
  "url": "https://wellfound.com/jobs/moxion-power-co-senior-ui-ux-designer",
  "role": "Designer",
  "jobType": "full_time",
  "remote": true,
  "locations": ["San Francisco"],
  "postedAt": "2022-05-28T07:48:45.000Z",
  "compensation": "$150K – $200K · 0.1% – 0.5%",
  "currency": "USD",
  "salaryMin": 150000,
  "salaryMax": 200000,
  "equityMin": 0.1,
  "equityMax": 0.5,
  "company": {
    "id": "8281817",
    "name": "Moxion Power",
    "slug": "moxion-power-co",
    "url": "https://wellfound.com/company/moxion-power-co",
    "companySize": "SIZE_11_50"
  }
}
```

### Data table

| Field | Description |
|---|---|
| `title`, `role`, `jobType` | Job title, primary role, and type (`full_time`, etc.) |
| `remote`, `locations` | Remote flag and location names |
| `salaryMin`, `salaryMax`, `currency` | Parsed annual salary range |
| `equityMin`, `equityMax` | Parsed equity range in percent |
| `compensation` | Raw compensation string as shown on Wellfound |
| `postedAt`, `description` | Publish date and full description |
| `company` | Nested company summary (name, slug, size, high concept, URL) |
| `stage`, `totalRaisedAmount` | Company funding stage and total raised (company records) |
| `markets`, `hiring`, `badges` | Company market tags, hiring flag, badges (company records) |

### Pricing / Cost estimation

**How much does it cost to scrape Wellfound?**

This Actor uses a Playwright browser to handle Wellfound's anti-bot protection (Cloudflare/DataDome), which costs more compute than a plain-HTTP scraper. Expect roughly **1–3 Apify compute units per ~100 job records**, depending on concurrency and pages crawled. Free Apify users get a capped preview run (10 records). **Residential proxy** traffic is recommended and billed separately per Apify's proxy pricing. Keep `maxConcurrency` low (2–4) to avoid rate limiting and control cost.

### Tips / Advanced options

- **Watch specific startups** with `companySlugs` to get full profiles including stage, size, markets and up to 20 open jobs each.
- **Reduce cost**: use fewer search URLs, a lower `maxPagesPerSearch`, or scrape only company pages.
- **Avoid blocking**: keep `maxConcurrency` at 2–3 and use the default residential proxy prefill.
- **Guest-access limits**: Wellfound hides salary/equity behind login for some filter combinations and paginates only the first page of the `/jobs` app; the SEO landing pages (`/role/*`, `/location/*`, `/company/*`) used by this Actor are fully readable without login.

### FAQ, disclaimers, and support

**Is scraping Wellfound legal?** Wellfound's job listings and company profiles are public pages — the same data Google indexes. This Actor reads only public content and does not bypass logins or access controls. As with any dataset, respect Wellfound's Terms of Service and local privacy laws (e.g. GDPR for EU personal data) when redistributing data.

**Why does Wellfound need a browser?** Wellfound is protected by Cloudflare and DataDome anti-bot systems and is a JavaScript SPA. A stealth Playwright browser routed through Apify's residential proxy is required to read the pages reliably. If a run hits an unresolved challenge, retry with residential proxy enabled.

**Limitations**: founder/recruiter emails are not publicly exposed on Wellfound, so contact info is limited to the company's public website and social links. Pagination within a single company's job list is capped at the first 20 listings.

Found a bug or want a custom field/extractor? Open an issue on the [Issues tab](https://console.apify.com/actors) of this Actor — or [contact us](https://apify.com/contact) for a custom scraping solution.

# Actor input Schema

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

Wellfound role slugs to search, e.g. software-engineer, product-manager, data-scientist, designer. Combined with locations to build search URLs.

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

Wellfound location slugs, e.g. remote, san-francisco, new-york, london. Combined with roles to build search URLs.

## `companySlugs` (type: `array`):

Wellfound company slugs to scrape full profiles from, e.g. moxion-power-co. Found in the URL of any company page.

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

Any Wellfound URLs to scrape directly: search pages (/role/*, /location/*), company pages (/company/*) or job pages (/jobs/*).

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

Hard cap on the number of records pushed to the dataset.

## `maxPagesPerSearch` (type: `integer`):

Maximum number of result pages to crawl per search URL.

## `maxConcurrency` (type: `integer`):

Number of parallel browser pages. Keep low (2-4) to avoid rate limiting.

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

Apify Proxy with Residential IPs is recommended to avoid blocking.

## Actor input object example

```json
{
  "roles": [
    "software-engineer"
  ],
  "locations": [
    "remote"
  ],
  "maxItems": 100,
  "maxPagesPerSearch": 5,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (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"
    ],
    "locations": [
        "remote"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/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 = {
    "roles": ["software-engineer"],
    "locations": ["remote"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

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

```

## MCP server setup

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