# Wellfound Jobs Scraper ($0.5 per 1000 results) (`igolaizola/wellfound-jobs-scraper`) Actor

$0.5/1K 💸 Scrape Wellfound startup jobs from wellfound.com by location with titles, companies, remote options, compensation, equity, posting dates, and job URLs for hiring research and lead generation.

- **URL**: https://apify.com/igolaizola/wellfound-jobs-scraper.md
- **Developed by:** [Iñigo Garcia Olaizola](https://apify.com/igolaizola) (community)
- **Categories:** Jobs, Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 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 Jobs Scraper — Startup Jobs, Salaries & Hiring Leads

### 🤖 What does Wellfound Jobs Scraper do?

Wellfound Jobs Scraper extracts public startup job listings from Wellfound for recruiting, hiring-market research, job-board enrichment, and lead generation. It returns structured job data such as titles, companies, company metadata, locations, remote options, compensation, equity, role category, posting date, job URLs, company URLs, and descriptions.

Use it to monitor startup hiring from Wellfound location pages, compare compensation signals, or build repeatable job-data feeds from Wellfound.

**Great for:** recruiters, sourcing teams, job boards, talent intelligence, market researchers, founders, and sales teams tracking startup hiring activity.

> SEO keywords: **Wellfound scraper**, **Wellfound jobs scraper**, **scrape Wellfound jobs**, **startup jobs scraper**, **startup hiring leads**, **job data API alternative**, **Apify actor**.

### 💡 Why scrape Wellfound jobs?

- 📈 **Track startup hiring trends** — monitor jobs for a Wellfound location URL slug such as `remote`, `san-francisco`, or `new-york`.
- 🎯 **Build hiring lead lists** — find startups actively recruiting in a chosen location.
- 💰 **Compare compensation signals** — collect salary and equity ranges when listings include them.
- 🌍 **Map remote availability** — capture location and remote-location signals for distributed hiring research.
- 🧾 **Power repeatable reports** — schedule runs and download JSON, CSV, Excel, XML, RSS, or Parquet from the Apify Dataset.

### 🚀 Quick Start

1. **Add the actor** – Open **Wellfound Jobs Scraper** in Apify Store.
2. **Set `location`** – Use the location slug from a Wellfound URL, such as `remote`, `san-francisco`, or `new-york`.
3. **Set `maxItems`** – Choose how many job listings to return.
4. **Run the actor** – Click **Run** or trigger it from the Apify API, scheduler, or integrations.
5. **Download results** – Export the Dataset as JSON, CSV, Excel, XML, RSS, or Parquet.

### 💳 Pricing

Apify's **Free plan** includes monthly credits that are useful for small tests and occasional monitoring. For larger startup-job workflows, use a paid Apify plan with higher limits and scheduled runs.

### 📝 Input Parameters

| Parameter | Type | Required | Description |
| --- | --- | --- | --- |
| `location` | String | Yes | Wellfound location URL slug, such as `remote`, `san-francisco`, `new-york`, `los-angeles`, `austin`, `seattle`, `boston`, `chicago`, `denver`, or `district-of-columbia`. Default: `remote`. |
| `maxItems` | Integer | Yes | Maximum number of jobs to return. Minimum `1`, maximum `1000`, default `50`. |

To find the correct `location`, open [https://wellfound.com/jobs](https://wellfound.com/jobs), choose a location, and copy the slug from the resulting URL path. For example, `/location/san-francisco` means `location` should be `san-francisco`, and `/remote` means `location` should be `remote`. The actor lowercases the value and converts spaces to hyphens, so `San Francisco` becomes `san-francisco`.

**Monitor remote startup jobs**

```json
{
  "location": "remote",
  "maxItems": 50
}
````

**Collect startup jobs in San Francisco**

```json
{
  "location": "san-francisco",
  "maxItems": 100
}
```

**Use a copied Wellfound URL slug**

```json
{
  "location": "new-york",
  "maxItems": 75
}
```

### 📊 Output / Results

Each Dataset item is one Wellfound job listing. Fields appear when Wellfound provides them for that listing.

**Field reference:**

- **id** *(string)* — Wellfound job ID.
- **slug** *(string)* — Job slug used in the Wellfound listing URL.
- **title** *(string)* — Job title.
- **companyId** *(string)* — Wellfound company ID.
- **companyName** *(string)* — Hiring company name.
- **companySlug** *(string)* — Company slug used on Wellfound.
- **companyUrl** *(string)* — Wellfound company profile URL.
- **companyLogoUrl** *(string)* — Company logo URL when available.
- **companyDescription** *(string)* — Short company description or high concept when available.
- **companySize** *(string)* — Company size bucket when available.
- **companyBadges** *(array)* — Badge objects with `id`, `name`, `label`, and `tooltip` when available.
- **location** *(string)* — Primary location label.
- **locations** *(array)* — All listed job locations.
- **remoteLocations** *(array)* — Accepted remote locations when available.
- **remote** *(string)* — Remote-work signal when available.
- **remoteKind** *(string)* — Remote configuration kind, such as `remote` or `onsite`, when available.
- **wfhFlexible** *(boolean)* — Whether the listing is marked work-from-home flexible when available.
- **compensation** *(string)* — Salary or compensation range when listed.
- **equity** *(string)* — Equity range when listed.
- **role** *(string)* — Role category or primary role label.
- **roleSlug** *(string)* — Role slug used by Wellfound when available.
- **jobType** *(string)* — Job type, such as full-time or contract, when available.
- **autoPosted** *(boolean)* — Whether the listing is marked as automatically posted when available.
- **atsSource** *(string)* — ATS source signal when available.
- **yearsExperienceMin** *(number)* — Minimum years of experience when available.
- **yearsExperienceMax** *(number)* — Maximum years of experience when available.
- **isBookmarked** *(boolean)* — Bookmark state from the public page payload when available.
- **postedAt** *(string)* — Posting timestamp in ISO format.
- **postedAtIso** *(string)* — Posting timestamp in ISO format.
- **jobUrl** *(string)* — Wellfound job listing URL.
- **descriptionText** *(string)* — Plain-text job description or summary.

**Example output**

```json
{
  "id": "4342678",
  "slug": "software-engineer",
  "title": "Software Engineer",
  "companyId": "9461632",
  "companyName": "Ataraxis AI",
  "companySlug": "ataraxis-ai",
  "companyUrl": "https://wellfound.com/company/ataraxis-ai",
  "companyLogoUrl": "https://photos.wellfound.com/startups/i/123456-medium_jpg.jpg",
  "companyDescription": "AI diagnostics for modern clinical teams",
  "companySize": "SIZE_11_50",
  "companyBadges": [
    {
      "id": "ACTIVELY_HIRING",
      "name": "ACTIVELY_HIRING_BADGE",
      "label": "Actively Hiring",
      "tooltip": "Actively processing applications"
    }
  ],
  "location": "New York City",
  "locations": ["New York City"],
  "remoteLocations": ["United States"],
  "remote": "remote",
  "remoteKind": "remote",
  "wfhFlexible": false,
  "compensation": "$140k – $190k",
  "equity": "0.05% – 0.15%",
  "role": "Software Engineer",
  "roleSlug": "developer",
  "jobType": "Full-time",
  "autoPosted": false,
  "atsSource": "greenhouse",
  "yearsExperienceMin": 3,
  "yearsExperienceMax": 7,
  "isBookmarked": false,
  "postedAt": "2026-05-20T14:24:18Z",
  "postedAtIso": "2026-05-20T14:24:18Z",
  "jobUrl": "https://wellfound.com/company/ataraxis-ai/jobs/software-engineer",
  "descriptionText": "Build production systems for an AI healthcare startup working with clinical data and modern infrastructure."
}
```

### 🧭 Tips / Common Recipes

- **Remote job monitoring:** use `location="remote"`.
- **City-specific hiring:** use URL slugs such as `san-francisco`, `new-york`, `los-angeles`, `austin`, or `seattle`.
- **Recurring market snapshot:** schedule the actor daily or weekly with the same `location` and `maxItems` settings.

### ⚙️ Best Practices

- Start with `maxItems` between `25` and `100` for exploratory runs, then increase once your filters are tuned.
- Use the location slug from the Wellfound URL after choosing a location at https://wellfound.com/jobs.
- Some listings do not include salary, equity, remote rules, or long descriptions. The actor returns those fields when they are available.
- Keep the same input settings across scheduled runs so changes in output reflect hiring movement rather than filter changes.

### ⚖️ Legal & Ethical Considerations

- Respect Wellfound's Terms of Service, robots policies, and applicable usage rules.
- Use scraped job data responsibly and avoid excessive or abusive request patterns.
- Handle personal data and company data in line with privacy laws such as GDPR and CCPA where applicable.
- If you publish analysis or republish job listings, keep attribution and source-linking practices in mind.
- This Actor is an independent tool and is **not** affiliated with, endorsed by, or sponsored by Wellfound. All trademarks are the property of their respective owners.

### ❓ FAQ

**Can I filter by role?**
No. This actor currently uses the location pages that are known to work reliably.

**Can I use plain text instead of slugs?**
The actor lowercases the value and converts spaces to hyphens, but the intended input is the URL slug from Wellfound. For example, `San Francisco` becomes `san-francisco`.

**Do all listings include compensation and equity?**
No. Wellfound listings vary. The actor returns compensation and equity when they are available on the listing.

**Can I export results to CSV or Excel?**
Yes. Open the run Dataset in Apify and choose JSON, CSV, Excel, XML, RSS, or Parquet.

### 🛟 Support

Need a custom field, workflow, or export format?
Open an issue or contact me at https://igolaizola.com/#contact
I can adapt the scraper to your recruiting, job-board, or market-intelligence workflow.

# Actor input Schema

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

Wellfound location URL slug to filter jobs by. Open https://wellfound.com/jobs, choose a location, and use the slug from the resulting URL path, such as remote, san-francisco, new-york, los-angeles, austin, seattle, boston, chicago, denver, or district-of-columbia. Spaces are converted to hyphens and text is lowercased.

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

How many jobs do you want to fetch?

## Actor input object example

```json
{
  "location": "remote",
  "maxItems": 50
}
```

# 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 = {
    "location": "remote"
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Wellfound Jobs Scraper ($0.5 per 1000 results)",
        "description": "$0.5/1K 💸 Scrape Wellfound startup jobs from wellfound.com by location with titles, companies, remote options, compensation, equity, posting dates, and job URLs for hiring research and lead generation.",
        "version": "0.0",
        "x-build-id": "hj0Rcrdz8EdMHmtde"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/igolaizola~wellfound-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-igolaizola-wellfound-jobs-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/igolaizola~wellfound-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-igolaizola-wellfound-jobs-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/igolaizola~wellfound-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-igolaizola-wellfound-jobs-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",
                "required": [
                    "location",
                    "maxItems"
                ],
                "properties": {
                    "location": {
                        "title": "Location slug",
                        "type": "string",
                        "description": "Wellfound location URL slug to filter jobs by. Open https://wellfound.com/jobs, choose a location, and use the slug from the resulting URL path, such as remote, san-francisco, new-york, los-angeles, austin, seattle, boston, chicago, denver, or district-of-columbia. Spaces are converted to hyphens and text is lowercased.",
                        "default": "remote"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "How many jobs do you want to fetch?",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```