# Wellfound Scraper (`kawsar/wellfound-scraper`) Actor

Extract startup job listings and company data from Wellfound across any role or city search, giving you salary ranges, remote policies, funding badges, and experience requirements for every listing.

- **URL**: https://apify.com/kawsar/wellfound-scraper.md
- **Developed by:** [Kawsar](https://apify.com/kawsar) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 3 total users, 2 monthly users, 36.4% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Wellfound Job Listings Scraper

Extract startup job listings and company data from Wellfound across any role or city search. Each record includes the job title, salary range, location details, remote policy, experience requirements, company size, funding badges, and posted date. No account or login required.

### What It Returns

**Job fields**

| Field | Description |
|-------|-------------|
| `jobId` | Unique job listing identifier |
| `jobTitle` | Job title |
| `jobType` | Employment type, e.g. `full-time`, `contract` |
| `primaryRole` | Role category |
| `jobUrl` | Direct link to the job listing |
| `jobDescription` | Full job description (markdown) |
| `compensation` | Salary range, e.g. `$150k – $195k` |
| `locationNames` | List of cities where the role is based |
| `remote` | Whether the role accepts remote candidates |
| `acceptedRemoteLocations` | Countries/regions accepted for remote work |
| `yearsExperienceMin` | Minimum years of experience required |
| `yearsExperienceMax` | Maximum years of experience listed |
| `postedAt` | Date the listing went live |
| `autoPosted` | Whether the listing was posted via ATS integration |

**Company fields**

| Field | Description |
|-------|-------------|
| `companyId` | Wellfound company identifier |
| `companyName` | Company name |
| `companySlug` | Company slug used in Wellfound URLs |
| `companySize` | Headcount range, e.g. `SIZE_11_50` |
| `companyLogoUrl` | URL to the company logo image |
| `companyHighConcept` | Company tagline |
| `companyBadges` | Funding and activity badges, e.g. `YC Funded`, `Actively Hiring`, `Top Investors` |

### How to Use

Provide at least one search parameter. You can combine `role` and `location` for narrower results.

#### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `role` | string | | Role slug from the Wellfound URL, e.g. `software-engineer` |
| `location` | string | | City slug, e.g. `new-york`, `san-francisco`, `remote` |
| `companySlug` | string | | Scrape a specific company's listings, e.g. `stripe` |
| `maxItems` | integer | 100 | Cap on total results (max 1000) |
| `maxPages` | integer | 5 | Pages to crawl per run (max 20) |
| `requestTimeoutSecs` | integer | 60 | Per-request timeout in seconds |

#### Example: Software engineers in New York

```json
{
  "role": "software-engineer",
  "location": "new-york",
  "maxItems": 200,
  "maxPages": 10
}
````

#### Example: All jobs at a specific company

```json
{
  "companySlug": "stripe",
  "maxItems": 50
}
```

#### Example: Remote product managers (any location)

```json
{
  "role": "product-manager",
  "location": "remote",
  "maxItems": 100
}
```

### Example Output

```json
{
  "jobId": "4063748",
  "jobTitle": "Software Engineer",
  "jobType": "full-time",
  "primaryRole": "Software Engineer",
  "jobUrl": "https://wellfound.com/company/methodfi/jobs/4063748",
  "compensation": "$150k \u2013 $195k",
  "locationNames": ["Austin", "New York", "Washington"],
  "remote": false,
  "acceptedRemoteLocations": [],
  "yearsExperienceMin": 2,
  "yearsExperienceMax": 5,
  "postedAt": "2024-10-15T00:00:00.000Z",
  "autoPosted": false,
  "companyId": "8530754",
  "companyName": "Method Financial",
  "companySlug": "methodfi",
  "companySize": "SIZE_11_50",
  "companyLogoUrl": "https://photos.wellfound.com/startups/i/8530754-xxx.jpg",
  "companyHighConcept": "The future of financial account connectivity",
  "companyBadges": ["Actively Hiring", "YC Funded", "Top Investors"],
  "scrapedAt": "2025-01-15T09:30:00+00:00"
}
```

### Role Slugs

Use the hyphenated slug that appears in Wellfound role URLs:

`software-engineer`, `product-manager`, `data-scientist`, `designer`, `marketing`, `sales`, `operations`, `devops`, `data-analyst`, `machine-learning`, `frontend-engineer`, `backend-engineer`, `full-stack-engineer`

### Location Slugs

Use the hyphenated slug from Wellfound location URLs:

`new-york`, `san-francisco`, `los-angeles`, `austin`, `seattle`, `boston`, `chicago`, `denver`, `miami`, `remote`

### Capacity

Each page returns roughly 20 to 40 job listings. With the default settings (5 pages, 100 items), a typical run finishes in under two minutes. For larger crawls, increase `maxPages` and `maxItems` proportionally.

### Use Cases

- Job market research and salary benchmarking across startup roles
- Recruiting pipeline automation for sourcing candidates by role and city
- Startup hiring trend analysis for funded companies
- B2B lead generation targeting actively hiring startups
- Competitive intelligence on competitor hiring velocity

# Actor input Schema

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

One or more role slugs to search. Use the hyphenated form from Wellfound URLs, e.g. software-engineer, product-manager, data-scientist. Each role runs as a separate query.

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

One or more city or region slugs, e.g. new-york, san-francisco, austin, remote. Combined with each role to form search queries.

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

Scrape jobs from specific companies by their Wellfound slug, e.g. stripe, openai, notion. Each company runs as a separate query.

## `maxResultsPerQuery` (type: `integer`):

Maximum job listings to collect per search query. If you run 3 roles x 2 locations = 6 queries, total results = 6 x this value.

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

Maximum result pages to crawl per query. Each page returns roughly 20 to 40 listings.

## `requestTimeoutSecs` (type: `integer`):

Per-request timeout in seconds. Increase on slow connections.

## Actor input object example

```json
{
  "roles": [
    "software-engineer",
    "product-manager"
  ],
  "locations": [
    "new-york",
    "san-francisco"
  ],
  "companySlugs": [
    "stripe",
    "openai"
  ],
  "maxResultsPerQuery": 40,
  "maxPages": 3,
  "requestTimeoutSecs": 60
}
```

# 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": [
        "new-york"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kawsar/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"],
    "locations": ["new-york"],
}

# Run the Actor and wait for it to finish
run = client.actor("kawsar/wellfound-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [
    "new-york"
  ]
}' |
apify call kawsar/wellfound-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=kawsar/wellfound-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Wellfound Scraper",
        "description": "Extract startup job listings and company data from Wellfound across any role or city search, giving you salary ranges, remote policies, funding badges, and experience requirements for every listing.",
        "version": "0.0",
        "x-build-id": "dzQpFYUlZggBCzIe1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kawsar~wellfound-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kawsar-wellfound-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/kawsar~wellfound-scraper/runs": {
            "post": {
                "operationId": "runs-sync-kawsar-wellfound-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/kawsar~wellfound-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-kawsar-wellfound-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "roles": {
                        "title": "Job roles",
                        "type": "array",
                        "description": "One or more role slugs to search. Use the hyphenated form from Wellfound URLs, e.g. software-engineer, product-manager, data-scientist. Each role runs as a separate query.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "One or more city or region slugs, e.g. new-york, san-francisco, austin, remote. Combined with each role to form search queries.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "companySlugs": {
                        "title": "Company slugs",
                        "type": "array",
                        "description": "Scrape jobs from specific companies by their Wellfound slug, e.g. stripe, openai, notion. Each company runs as a separate query.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerQuery": {
                        "title": "Max results per query",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum job listings to collect per search query. If you run 3 roles x 2 locations = 6 queries, total results = 6 x this value.",
                        "default": 40
                    },
                    "maxPages": {
                        "title": "Max pages per query",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum result pages to crawl per query. Each page returns roughly 20 to 40 listings.",
                        "default": 3
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout (seconds)",
                        "minimum": 10,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Per-request timeout in seconds. Increase on slow connections.",
                        "default": 60
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
