# Wellfound Remote Jobs Scraper (`schnellscrapers/wellfound-remote-jobs`) Actor

Extract Wellfound startup jobs from remote and city-specific role feeds, including titles, full descriptions, salary bands, remote locations, company size, hiring badges, and apply-ready job URLs. Filter by keyword, salary, freshness, and remote status; pay only for matching rows.

- **URL**: https://apify.com/schnellscrapers/wellfound-remote-jobs.md
- **Developed by:** [Nate Schnell](https://apify.com/schnellscrapers) (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 $0.50 / 1,000 jobs

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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 Remote Jobs Scraper do?

Wellfound Remote Jobs Scraper turns Wellfound role and location feeds into flat job records for recruiters, job boards, hiring dashboards, and startup lead lists. It reads the source page's own structured result payload, paginates it, and writes only unique rows that pass your filters.

### What data can you extract from Wellfound?

- Job details — title, primary role, employment type, full public description, ATS source, posted timestamp
- Compensation — raw salary/equity text, parsed salary minimum and maximum, parsed equity percentage range
- Remote targeting — remote flag, listed locations, accepted remote locations, keyword and freshness filters
- Startup context — company name, slug, profile URL, logo, company-size band, short pitch, hiring badges
- Provenance — stable job ID, canonical job URL, source search URL, scrape timestamp

### How to use Wellfound Remote Jobs Scraper

1. Open the actor and keep the prefilled `software-engineer` role, or add your own Wellfound role slugs.
2. Add location slugs such as `new-york` or `berlin`, or paste full role/location URLs under Custom Wellfound URLs.
3. Choose Remote jobs only, add optional keyword or salary filters, then set the page and item caps.
4. Click Start and watch the run log for fetched pages and parsed jobs.
5. Download the matching dataset as JSON, CSV, or Excel, or read it through the Apify dataset API.

### How much does it cost?

The actor uses pay-per-event pricing: one billable event is one matching job row written to the default dataset. Jobs filtered out before writing are not charged. Use `maxItems`, `maxPages`, and narrow role/location filters to keep a run bounded; the current price is shown in the Pricing tab.

### Input

The simplest input is a role slug. Set `remoteOnly` to `false` when a city feed should include on-site roles. Custom Wellfound search URLs override the role and location fields.

```json
{
  "roleSlugs": ["software-engineer", "data-scientist"],
  "locations": ["new-york"],
  "remoteOnly": true,
  "keyword": "python, machine learning",
  "maxPages": 2,
  "maxItems": 50
}
```

### Output

Each dataset item contains the job, compensation, remote eligibility, startup context, and source URLs. Missing source values are returned as `null`; array fields are returned as empty arrays when Wellfound has no values.

```json
{
  "jobId": "4579450",
  "jobSlug": "software-engineer",
  "title": "Software Engineer",
  "primaryRole": "software-engineer",
  "description": "Public Wellfound job description text.",
  "jobType": "full-time",
  "locations": ["Santa Clara"],
  "acceptedRemoteLocations": ["United States"],
  "remote": true,
  "compensation": "$110k – $200k",
  "salaryMin": 110000,
  "salaryMax": 200000,
  "equityMinPercent": null,
  "equityMaxPercent": null,
  "experienceMinYears": null,
  "experienceMaxYears": null,
  "atsSource": "AtsIntegration::Greenhouse::Listing",
  "postedAt": "2026-08-12T00:00:00.000Z",
  "jobUrl": "https://wellfound.com/jobs/4579450-software-engineer",
  "companyName": "Oklo",
  "companySlug": "oklo",
  "companyUrl": "https://wellfound.com/company/oklo",
  "companyLogoUrl": "https://photos.wellfound.com/startups/i/5268250-medium.jpg",
  "companySize": "SIZE_201_500",
  "companyHighConcept": "Making reactors people want",
  "badges": ["Actively Hiring", "YC"],
  "sourceUrl": "https://wellfound.com/role/r/software-engineer",
  "scrapedAt": "2026-08-24T01:35:06.543Z"
}
```

### Source and coverage notes

The actor uses public Wellfound role and location pages. Those pages currently embed the job search result data in the server-rendered `__NEXT_DATA__` payload, with source pagination metadata and full descriptions on role feeds. Individual job detail-page enrichment is intentionally not used, keeping page count and cost predictable.

### FAQ

#### Is it legal to scrape Wellfound?

This actor reads public job-listing pages and does not access private candidate, recruiter, applicant, or message data. You are responsible for using the output lawfully and respecting the requirements that apply to your workflow.

#### Why is a description sometimes null?

Wellfound does not expose every field on every result. Role feeds usually include descriptions, while a listing can omit compensation, experience, or company metadata. The actor preserves those gaps as `null` rather than inventing values.

#### Does this open each job detail page?

No. The actor uses the structured data already embedded in the role or location result page. This keeps runs faster and makes pay-per-row costs predictable.

# Actor input Schema

## `roleSlugs` (type: `array`):

Wellfound role slugs to search, such as `software-engineer`, `product-manager`, `data-scientist`, or `growth-marketer`. One source is created per role and location combination.

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

Optional Wellfound location slugs such as `new-york`, `san-francisco`, `berlin`, or `united-states`. Leave empty for a role-wide remote feed.

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

Optional full Wellfound role or location search URLs. When supplied, these replace roleSlugs and locations. Examples include `/role/r/software-engineer` and `/role/l/product-manager/berlin`.

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

Keep only records whose native Wellfound remote flag is true. It defaults on because this actor is optimized for remote startup-job feeds; turn it off for city feeds that should include on-site roles.

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

Optional comma-separated OR terms matched against title, role, company, company pitch, locations, badges, and full description. Filtering happens before records are written.

## `excludeKeywords` (type: `array`):

Optional terms that drop a job when found in its title, role, company, company pitch, locations, badges, or description. Exclusions run before billing.

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

Keep jobs whose published salary band reaches this amount. Jobs without salary are dropped when a minimum is set.

## `maxSalary` (type: `integer`):

Keep jobs whose published salary band starts at or below this amount. Jobs without salary are dropped when a maximum is set.

## `includeNoSalary` (type: `boolean`):

Keep jobs that do not publish a compensation band. Turn off to return only salary-bearing listings.

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

Optional freshness filter based on Wellfound's liveStartAt timestamp. Set to 7 for jobs posted in the last week; 0 means no date filter.

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

Hard cap on unique matching job records written across all roles, locations, and custom URLs.

## `maxPages` (type: `integer`):

Maximum result pages to fetch for each source URL. Wellfound pages expose their own pageCount; this is an additional cost and runtime guard.

## Actor input object example

```json
{
  "roleSlugs": [
    "software-engineer"
  ],
  "locations": [],
  "startUrls": [],
  "remoteOnly": true,
  "excludeKeywords": [],
  "minSalary": 0,
  "maxSalary": 0,
  "includeNoSalary": true,
  "postedWithinDays": 0,
  "maxItems": 50,
  "maxPages": 3
}
```

# Actor output Schema

## `jobs` (type: `string`):

Default dataset of filtered Wellfound jobs. Key fields include title, companyName, locations, remote, compensation, salaryMin, salaryMax, description, and jobUrl.

# 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 = {
    "roleSlugs": [
        "software-engineer"
    ],
    "locations": [],
    "startUrls": [],
    "keyword": "",
    "excludeKeywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("schnellscrapers/wellfound-remote-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 = {
    "roleSlugs": ["software-engineer"],
    "locations": [],
    "startUrls": [],
    "keyword": "",
    "excludeKeywords": [],
}

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

```

## MCP server setup

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