# Wellfound Scraper — Startup Jobs, Salary, Equity & Funding (`haketa/wellfound-scraper`) Actor

Scrape Wellfound (formerly AngelList Talent) startup jobs by role: title, salary range, equity, remote policy, location, experience and description — plus the hiring company's size, stage, valuation and funding signals (YC, Top Investors). No login or API key. Export JSON, CSV, Excel.

- **URL**: https://apify.com/haketa/wellfound-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Jobs, Lead generation
- **Features:** Limited permissions
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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.
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 (AngelList) Scraper — Startup Jobs, Salary, Equity & Funding Signals

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-orange?logo=apify)](https://apify.com/haketa/wellfound-scraper)
[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://apify.com/haketa/wellfound-scraper)
[![Data Format](https://img.shields.io/badge/Data-JSON%20%7C%20CSV%20%7C%20Excel-blue)](https://apify.com/haketa/wellfound-scraper)

**Scrape startup job listings from [Wellfound](https://wellfound.com) — formerly AngelList Talent — at scale, with no login and no coding required.** This **Wellfound scraper** extracts complete, structured career opportunities from any role category: **job title, parsed salary min/max, equity percentage min/max, remote policy, accepted locations, and experience requirements — joined directly to the hiring startup's employee headcount, stage, valuation, and investor funding signals (YC Funded, Top Investors, Growing Fast, Actively Hiring, B2B).**

Export everything to **JSON, CSV, Excel, XML, or API**.

> Built for **tech recruiters, talent sourcers, VC intelligence analysts, startup job seekers, and B2B SDR teams** targeting high-growth venture-backed companies.

***

### ⚡ At a glance

| Feature | Description |
|---|---|
| **Data Source** | [Wellfound](https://wellfound.com) (formerly AngelList Talent) — the world's premier startup hiring marketplace |
| **Search Modes** | Role slugs (`roles`), direct role URLs (`startUrls`), and remote-only filtering (`remoteOnly`) |
| **Output Formats** | JSON, CSV, Excel (XLSX), XML, HTML table |
| **Key Job Fields** | Job title, role category, compensation string, `salaryMin`, `salaryMax`, `equityMin`, `equityMax`, remote configuration, locations, description, ATS source |
| **Startup Intelligence** | Company name, employee size, tagline, stage (Early/Growth/Scale), valuation tier, YC Funded badge, Top Investors badge |
| **Speed & Scale** | Pure HTTP Next.js Apollo cache parsing with rotating datacenter proxy sessions; collects 35–40 jobs per page, scaling to 1,000+ records |

***

### 🔎 Why scrape Wellfound?

**Wellfound** is the primary hiring network for early-stage and venture-backed tech startups worldwide. Unlike legacy job boards such as LinkedIn, Indeed, or Monster, Wellfound listings feature structured equity compensation, explicit remote geographic policies, and verified company funding tiers.

However, Wellfound restricts bulk data exports and paginates listings behind dynamic client-side rendering. Manually copying salary ranges, equity splits, and funding badges across hundreds of engineering, product, or sales openings is time-consuming and difficult to automate. This **Wellfound scraper** bypasses UI friction by parsing the underlying Apollo state, returning structured rows ready for immediate analysis.

**Common use cases for Wellfound scraping:**

- 💰 **Compensation Benchmarking:** Analyze tech salary bands and equity stakes across funding stages (Seed, Series A, Growth) and job roles.
- 🦄 **VC & Talent Intelligence:** Track hiring velocity and talent migration across Y Combinator cohorts and top-tier venture portfolio companies.
- 🧑‍💻 **Technical Recruiting & Sourcing:** Generate targeted candidate pipelines matching specific role titles, experience requirements, and remote policies.
- 🎯 **B2B Lead Generation:** Identify high-growth startups that are actively hiring and recently funded for SaaS and developer tooling sales.
- 📊 **Hiring Market Trends:** Monitor demand surges in artificial intelligence, machine learning, data engineering, and product design.

***

### ✨ Key scraper capabilities

- 🔎 **Flexible Role Targeting:** Input standard role handles (`software-engineer`, `data-scientist`, `product-manager`, `product-designer`, `marketing`, `devops`, `sales-development-representative`).
- 🔗 **Direct URL Ingestion:** Paste specific Wellfound search URLs directly into `startUrls` to capture custom role combinations.
- 🔁 **Unlocked Deep Pagination (1,000+ items):** Automatically cycles through sequential page indexes (`?page=1`, `?page=2`, …). Setting `maxPagesPerSearch: 0` allows extraction up to your target `maxItems`.
- 💵 **Parsed Numeric Compensation:** Automatically converts raw compensation strings (e.g. `$120k – $160k • 0.1% – 0.5%`) into clean numeric fields (`salaryMin`, `salaryMax`, `equityMin`, `equityMax`).
- 🏠 **Remote Policy Identification:** Flags whether roles are fully remote, hybrid, or on-site, capturing accepted remote countries and cities.
- 🏢 **Integrated Company Funding Signals:** Joins each job to its hiring startup, attaching metadata including company stage, valuation, and investor pedigree.
- ⚡ **Pure HTTP Execution:** Lightweight and resource-efficient, operating reliably over standard Apify Datacenter proxies.

***

### 📥 Input parameters

| Field | Type | Default | Description |
|---|---|---|---|
| `roles` | Array | `["software-engineer"]` | Role slugs to scrape (e.g. `["software-engineer", "data-scientist", "product-manager"]`). |
| `startUrls` | Array | `[]` | Optional direct Wellfound role URLs (e.g. `https://wellfound.com/role/r/data-scientist`). |
| `remoteOnly` | Boolean | `false` | When true, only positions verified as remote are returned. |
| `maxItems` | Integer | `0` | Overall maximum number of jobs to collect across all roles. `0` = unlimited. |
| `maxPagesPerSearch` | Integer | `0` | Number of result pages per role (~38 jobs/page). `0` = auto/unlimited (governed by `maxItems`). |
| `proxyConfiguration` | Object | Datacenter | Apify Proxy Datacenter is enabled by default for fast, cost-effective runs. |

#### Example input — engineering and data roles

```json
{
  "roles": ["software-engineer", "data-scientist"],
  "remoteOnly": true,
  "maxItems": 250,
  "maxPagesPerSearch": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

#### Example input — product & design roles

```json
{
  "roles": ["product-manager", "product-designer"],
  "remoteOnly": false,
  "maxItems": 150,
  "maxPagesPerSearch": 0
}
```

***

### 📊 Extracted fields

Every scraped job listing produces structured fields across 4 main domains:

#### 💼 Job specifications & compensation

| Field | Type | Coverage | Description |
|---|---|---|---|
| `id` | String | 🟢 High | Unique Wellfound listing identifier (de-duplication key) |
| `url` | String | 🟢 High | Canonical job listing URL |
| `title` | String | 🟢 High | Full job title (e.g. *Senior Full-Stack Engineer*) |
| `roleTitle` | String | 🟢 High | Normalized primary role category |
| `compensation` | String | 🟡 Conditional | Raw compensation summary string as displayed on the site |
| `salaryMin` | Number | 🟡 Conditional | Minimum annual salary in USD |
| `salaryMax` | Number | 🟡 Conditional | Maximum annual salary in USD |
| `equityMin` | Number | 🟡 Conditional | Minimum equity grant percentage (e.g. `0.1` for 0.1%) |
| `equityMax` | Number | 🟡 Conditional | Maximum equity grant percentage (e.g. `0.5` for 0.5%) |
| `jobType` | String | 🟢 High | Employment type (e.g. *Full Time*, *Contract*, *Internship*) |

#### 🌍 Remote configuration & requirements

| Field | Type | Coverage | Description |
|---|---|---|---|
| `remote` | Boolean | 🟢 High | Whether the position supports remote work |
| `remoteKind` | String | 🟡 Conditional | Specific policy (*REMOTE*, *ONSITE*, *ONSITE_OR_REMOTE*) |
| `remoteLocations` | Array | 🟡 Conditional | List of accepted geographic locations for remote staff |
| `locations` | Array | 🟢 High | Physical company office locations or regional hubs |
| `yearsExperienceMin` | Number | 🟡 Conditional | Minimum required professional experience in years |
| `yearsExperienceMax` | Number | 🟡 Conditional | Maximum required professional experience in years |
| `atsSource` | String | 🟡 Conditional | External applicant tracking system (*Ashby*, *Greenhouse*, *Lever*) |
| `postedAt` | String | 🟢 High | ISO 8601 publication timestamp |
| `description` | String | 🟢 High | Full job description text converted from HTML |

#### 🏢 Hiring company intelligence

| Field | Type | Coverage | Description |
|---|---|---|---|
| `company.id` | String | 🟢 High | Unique Wellfound startup identifier |
| `company.name` | String | 🟢 High | Official startup or company name |
| `company.slug` | String | 🟢 High | URL handle for company profile |
| `company.url` | String | 🟢 High | Direct link to company profile page on Wellfound |
| `company.size` | String | 🟢 High | Headcount band (e.g. *11-50*, *51-200*, *500+*) |
| `company.highConcept`| String | 🟢 High | Company elevator pitch / tagline |
| `company.logoUrl` | String | 🟢 High | Direct URL to company logo graphic |

#### 🦄 Startup funding & investor badges

| Field | Type | Coverage | Description |
|---|---|---|---|
| `company.stage` | String | 🟡 Conditional | Funding maturity stage (*Early*, *Growth*, *Scale*, *Public*) |
| `company.valuation` | String | 🟡 Conditional | Company valuation tier (*$500M+*, *$1B+*) |
| `company.ycFunded` | Boolean | 🟢 High | Whether the company graduated from Y Combinator |
| `company.topInvestors` | Boolean | 🟢 High | Backed by tier-one venture capital firms |
| `company.growingFast` | Boolean | 🟢 High | Flagged by Wellfound as rapidly growing headcount |
| `company.activelyHiring` | Boolean | 🟢 High | Flagged as actively hiring across multiple departments |
| `company.b2b` | Boolean | 🟢 High | Verified B2B business model |

***

### 💻 Sample output record

```json
{
  "id": "2918234",
  "url": "https://wellfound.com/jobs/2918234",
  "title": "Senior Backend Engineer (Distributed Systems)",
  "roleTitle": "Software Engineer",
  "compensation": "$150k – $190k • 0.1% – 0.25%",
  "salaryMin": 150000,
  "salaryMax": 190000,
  "equityMin": 0.1,
  "equityMax": 0.25,
  "jobType": "Full Time",
  "remote": true,
  "remoteKind": "REMOTE",
  "remoteLocations": ["United States", "Canada"],
  "locations": ["San Francisco", "New York City"],
  "yearsExperienceMin": 4,
  "yearsExperienceMax": 8,
  "description": "We are looking for a Senior Backend Engineer to scale our core distributed event processing engine...",
  "postedAt": "2026-11-08T14:22:00.000Z",
  "atsSource": "Ashby",
  "company": {
    "id": "847291",
    "name": "HyperScale AI",
    "slug": "hyperscale-ai",
    "url": "https://wellfound.com/company/hyperscale-ai",
    "size": "11-50",
    "highConcept": "Real-time vector inference infrastructure for generative models",
    "logoUrl": "https://photos.wellfound.com/startups/i/847291-abc123_logo.png",
    "stage": "Growth",
    "valuation": "$500M+",
    "ycFunded": true,
    "topInvestors": true,
    "growingFast": true,
    "activelyHiring": true,
    "b2b": true
  },
  "searchRole": "software-engineer",
  "scrapedAt": "2026-11-10T13:00:00.000Z"
}
```

***

### 🔁 Deep pagination & scale

Wellfound lists between **35 and 40 jobs per page**.

- **1,000+ Items Pagination:** Setting `maxPagesPerSearch: 0` removes per-role page caps. The scraper paginates continuously until your `maxItems` target is reached or all available jobs for the role are harvested.
- **Deduplication:** Jobs are tracked in memory by unique `id`, guaranteeing zero duplicate records across overlapping role searches.
- **Polite Network Handling:** Employs subtle request jitter and rotating proxy sessions to respect target platform infrastructure.

***

### ⚙️ How to integrate via API

Trigger runs and consume startup job feeds directly in Python or Node.js:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run_input = {
    "roles": ["software-engineer"],
    "remoteOnly": True,
    "maxItems": 100,
    "maxPagesPerSearch": 0
}
run = client.actor("haketa/wellfound-scraper").call(run_input=run_input)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    company = item.get("company", {})
    print(f"{item['title']} @ {company.get('name')} | Salary: ${item.get('salaryMin')}-${item.get('salaryMax')} | YC: {company.get('ycFunded')}")
```

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('haketa/wellfound-scraper').call({
    roles: ['product-manager', 'data-scientist'],
    maxItems: 150,
    maxPagesPerSearch: 0,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Successfully scraped ${items.length} startup jobs.`);
```

***

### 🏢 VC talent mapping & portfolio monitoring

Venture capital talent partners and investment teams use this scraper to track hiring velocity and organizational growth across their own portfolio companies and rival syndicates:

- **Growth Velocity Scoring:** Track monthly job posting volume by startup slug (`company.slug`). A sudden 3× spike in engineering and go-to-market roles typically indicates a fresh funding round or product breakout.
- **Stage Progression Audits:** Compare employee size bands (`company.size`) against active hiring targets to detect inflection points where startups transition from Seed to Growth stage.
- **Competitor Syndicate Monitoring:** Filter on `company.topInvestors: true` and `company.ycFunded: true` to identify competitive investments made by peer venture firms before PR announcements.

***

### 🧭 Popular role slugs directory

Wellfound organizes job listings into standard URL slugs. You can supply any of these directly to the `roles` input:

| Functional Area | Role Slug | Common Sub-Disciplines Included |
|---|---|---|
| **Software Engineering** | `software-engineer` | Full-stack, backend, frontend, systems, distributed systems |
| **Frontend Development** | `frontend-engineer` | React, Vue, Next.js, TypeScript, UI architecture |
| **Backend Development** | `backend-engineer` | Python, Go, Node.js, Java, microservices, cloud |
| **Data & AI / ML** | `data-scientist` | Machine learning, LLM fine-tuning, computer vision, NLP |
| **Data Engineering** | `data-engineer` | ETL pipelines, Snowflake, dbt, Spark, vector stores |
| **DevOps & Infrastructure**| `devops` | Kubernetes, AWS, Terraform, CI/CD, site reliability |
| **Product Management** | `product-manager` | Technical PM, growth PM, enterprise B2B PM |
| **Product Design** | `product-designer` | UI/UX design, design systems, user research |
| **Sales & Growth** | `sales-development-representative` | SDR, outbound sales, account executive |
| **Marketing** | `marketing` | Growth marketing, product marketing, content, SEO |
| **Operations & Finance** | `operations` | BizOps, Chief of Staff, strategy, financial analysis |

***

### 📈 Equity valuation modeling & analysis

One of the unique strengths of Wellfound data is pairing **equity percentages** with **startup valuation badges**:

- **Early-Stage Valuation Estimate:** A 0.25% equity grant at an Early stage startup ($10M-$20M post-money) represents an unvested paper value of approximately $25,000–$50,000.
- **Growth-Stage Valuation Estimate:** A 0.05% equity grant at a $500M+ valuation startup represents $250,000+ in potential asset value.

You can calculate estimated equity grant value directly in Python:

```python
def estimate_equity_value(equity_pct, valuation_str):
    if not equity_pct or not valuation_str:
        return None
    val_map = {
        "$500M+": 500_000_000,
        "$1B+": 1_000_000_000,
        "$2B+": 2_000_000_000,
        "$5B+": 5_000_000_000
    }
    val = val_map.get(valuation_str)
    if val:
        return (equity_pct / 100.0) * val
    return None
```

***

### 💡 Practical sourcing & recruiting tips

- **YC & Tier-One Backing:** Filter dataset exports on `company.ycFunded: true` or `company.topInvestors: true` to identify candidates at pedigree venture-backed firms.
- **Compensation Analysis:** Group by `company.size` or `company.stage` to benchmark how cash and equity compensation scale from Seed to Series C.
- **ATS Identification:** Leverage `atsSource` to direct candidate referrals through appropriate applicant tracking systems (e.g. Greenhouse, Ashby, Lever).

***

### ❓ Frequently Asked Questions

**Do I need a Wellfound account or recruiter subscription?**
No. The scraper gathers publicly viewable startup jobs without requiring personal credentials or paid recruiter accounts.

**Why do some listings lack salary or equity figures?**
In certain jurisdictions, publishing exact salary ranges is not legally mandatory, and some startups omit compensation figures from initial listings. All available figures are parsed into numeric fields.

**Can I filter only for remote positions?**
Yes. Enabling `remoteOnly: true` automatically filters out on-site-only positions, delivering exclusively remote-friendly opportunities.

**What proxy settings are recommended?**
Standard Apify Datacenter proxies are enabled by default and perform reliably. Switch to Residential (US) only if specific IP-level blocks are encountered.

**What is the value of the `atsSource` field?**
Many venture-backed startups host their official job postings on dedicated Applicant Tracking Systems (e.g. Ashby, Greenhouse, Lever). When `atsSource` is populated, candidates and recruiting agencies can locate the direct ATS application link, bypassing marketplace application queues.

**Can I filter listings by years of experience?**
Yes. You can filter the returned dataset using `yearsExperienceMin` and `yearsExperienceMax` to isolate entry-level, mid-level, or staff/lead engineering roles.

**How do I export Wellfound jobs to Google Sheets or Notion?**
From the Apify platform Dataset tab, select Export and choose Google Sheets or JSON. You can also configure automated synchronization via Apify's native Google Sheets integration.

**How often should I run the scraper to capture new startup jobs?**
Startups typically post new openings throughout the business week. We recommend scheduling a daily run in the morning to capture newly created roles and funding badge updates.

**Can I run this actor from within my own Python or Node.js microservice?**
Yes. You can use the official `apify-client` package in Python or JavaScript to trigger jobs asynchronously or synchronously, streaming the results directly into memory or your internal data pipelines.

**Does this scraper support webhook notifications?**
Yes. You can attach Apify Webhooks to trigger on `SUCCEEDED` events, notifying your Slack channel, Discord, or downstream server endpoint immediately when new jobs are harvested.

***

### 🔗 Related hiring scrapers

- [Seek Scraper](https://apify.com/haketa/seek-scraper) — Australian & Asia-Pacific job market listings.
- [H1B Visa Database Scraper](https://apify.com/haketa/h1b-visa-database-scraper) — US visa sponsorship and salary records.
- [ZipRecruiter Scraper](https://apify.com/haketa/ziprecruiter-scraper) — US job postings and salary ranges.
- [Workana Scraper](https://apify.com/haketa/workana-scraper) — Freelance projects and tech talent directory.

***

### 📋 Changelog

#### v1.2 — 2026-11

- **Unlocked 1,000+ Deep Pagination:** Updated `maxPagesPerSearch` default to `0` (auto/unlimited), enabling deep pagination runs up to 1,000+ jobs governed by `maxItems`.
- **Enhanced Compensation Normalizer:** Improved regex parsing for varied international compensation formats and equity splits.
- **Optimized Prefill Execution:** Fine-tuned initial role extraction for fast prefill runs (<45s).
- **Apollo Cache Join Refinement:** Strengthened mapping between JobListingSearchResult and StartupResult objects.

#### v1.1 — 2026-09

- Initial public release featuring pure-HTTP Apollo cache extraction.
- Automatic extraction of company funding signals (YC Funded, Top Investors, Stage, Valuation).
- Support for role slugs and Start URLs with deduplication.

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/wellfound-scraper/changelog.md

# Actor input Schema

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

Job roles to scrape, e.g. 'software-engineer', 'data-scientist', 'product-manager', 'product-designer', 'marketing'. Each role is scraped separately. Leave empty if you use Start URLs.

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

Optional. Paste full Wellfound role URLs (e.g. https://wellfound.com/role/r/data-scientist) to scrape them directly. When provided, Roles are ignored for these URLs.

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

Keep only remote positions.

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

Maximum number of jobs to collect across all roles. 0 = unlimited.

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

How many result pages to scrape per role / URL. Each page has about 38 jobs. 0 = auto/unlimited (governed by Max Items).

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

The default (Apify Proxy, datacenter) works out of the box. Switch to Residential (US) if you ever hit Cloudflare challenges.

## Actor input object example

```json
{
  "roles": [
    "software-engineer"
  ],
  "startUrls": [],
  "remoteOnly": false,
  "maxItems": 50,
  "maxPagesPerSearch": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Open to view and export all scraped listings (JSON, CSV, Excel).

# 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"
    ],
    "startUrls": [],
    "maxItems": 50,
    "maxPagesPerSearch": 0,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/wellfound-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"],
    "startUrls": [],
    "maxItems": 50,
    "maxPagesPerSearch": 0,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/wellfound-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"
  ],
  "startUrls": [],
  "maxItems": 50,
  "maxPagesPerSearch": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/wellfound-scraper --silent --output-dataset

```

## MCP server setup

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