# Wellfound Startups | Hiring Company Research (`keystonelabs/wellfound-startups-scraper`) Actor

Find unique Wellfound companies from public job feeds by role, location and remote filter. Export company profiles for startup research. This is a hiring-company sample, not a complete directory of startups.

- **URL**: https://apify.com/keystonelabs/wellfound-startups-scraper.md
- **Developed by:** [Nick McNemar](https://apify.com/keystonelabs) (community)
- **Categories:** Lead generation, Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 companies

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/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

### Find startups hiring for a selected role

Wellfound Startups: Find unique Wellfound companies from public job feeds by role, location and remote filter. Export company profiles for startup research. This is a hiring-company sample, not a complete directory of startups.

### Start with a small example

1. Open Input, switch to JSON and paste the example below. Replace the example roles with your own research targets when ready.
2. Check the live Pricing tab and set a run spending limit.
3. Run the Actor, then open the **Workflow** output view. Inspect `name`, `slug`, `url`.
4. Export JSON for nested data or CSV for a spreadsheet. Review a small sample before increasing the scope.

```json
{
  "roles": [
    "software-engineer"
  ],
  "maxItems": 20,
  "remoteOnly": true
}
```

At the rate checked September 9, 2026, 20 saved rows cost $0.060 in Actor event fees ($3.00 per 1,000 rows). Actual returned rows determine the event fee. Taxes and other account services may be separate.

### What can I use it for?

- **Startup lead generation.** Companies actively hiring are companies spending money — on tools, recruiting, payroll, benefits, offices. Filter by size and stage to match your ideal customer.
- **Investor and market research.** See which sectors and stages are growing headcount, and which startups are hiring for what.
- **Recruiting and talent marketplaces.** Find the startups hiring for the roles you place, with the roles themselves attached.
- **Competitive intelligence.** Track which competitors are hiring, for which functions, and how fast their open-role count moves.
- **Job seekers and career sites.** Build curated lists of companies hiring remotely for a given role, updated on a schedule.

### What data does it return?

One record per startup, aggregated across every listing page the actor reads, so a company hiring for five roles appears once with all five attached:

| Field | Meaning |
|---|---|
| `name`, `slug`, `url` | Company name and its Wellfound company page |
| `logoUrl` | Company logo |
| `pitch` | The company's one-line description |
| `size` | Headcount band, e.g. `11-50`, `51-200` |
| `stage` | Funding stage badge, e.g. `Seed`, `Series A`, `Public` |
| `activelyHiring` | Whether Wellfound shows the actively-hiring badge |
| `ycFunded` | Whether the company shows the Y Combinator badge |
| `businessModel` | `B2B`, `B2C` or both |
| `badges` | Every badge label Wellfound shows for the company |
| `openJobsFound`, `openJobs` | How many open roles were found for the company in this run, and each role's id, title, URL, compensation text, remote flag and location |
| `searchRole`, `searchLocation`, `searchRemote` | Which feed the company was found in |
| `sourceUrl`, `scrapedAt` | The listing page it came from and when |

#### Illustrative output

Values explain the output shape; they are not a live result or guaranteed field coverage.

```json
{
  "name": "Constructor.io",
  "slug": "constructor-io",
  "url": "https://wellfound.com/company/constructor-io",
  "logoUrl": "https://photos.wellfound.com/startups/i/...-medium_jpg.jpg",
  "pitch": "AI-first product discovery for ecommerce",
  "size": "201-500",
  "stage": "Series A",
  "activelyHiring": true,
  "ycFunded": false,
  "businessModel": "B2B",
  "badges": ["Actively Hiring", "B2B", "Series A", "Growth Stage"],
  "openJobsFound": 2,
  "openJobs": [
    { "id": "4263159", "title": "Software Engineer: Core", "url": "https://wellfound.com/jobs/4263159-software-engineer-core", "compensation": "$150k – $230k • 0.05% – 0.2%", "remote": true, "location": "Remote" }
  ],
  "searchRole": "software-engineer",
  "searchLocation": null,
  "searchRemote": true,
  "scrapedAt": "2026-09-05T06:40:12.104Z"
}
```

### How to use it

1. Enter one or more **Job roles** — Wellfound slugs like `software-engineer`, `product-manager`, `data-scientist`, or plain names, which are converted for you.
2. Optionally add **Locations** (`new-york`, `london`, `san-francisco`) and choose whether you want **Remote roles only**.
3. Set **Max companies** and click **Start**. Download from the **Output** tab as JSON, CSV or Excel, or read the dataset via the API.

#### Input example

```json
{
  "roles": ["software-engineer", "product-manager"],
  "locations": [],
  "remoteOnly": true,
  "maxItems": 200
}
```

### How it works

Wellfound's role and location pages are server-rendered with the full search payload embedded in the page, including every company shown and the roles it is hiring for. The actor requests each page of a feed once, parses that payload, and merges companies across pages so each one is returned once with all its open roles. Nothing is executed, no session is created and no company profile pages are fetched — those sit behind a security check and stay out of scope, so the fields returned are exactly the ones Wellfound shows in its listings.

Wellfound serves at most 47 pages per feed. For broader coverage, run several roles or locations in one input; results are still deduplicated across feeds.

### Pricing

You pay per company saved. There are no subscriptions or minimums, and you can cap the maximum spend of any run before it starts. Because companies are deduplicated across pages and feeds, you do not pay twice for the same startup within that run in one run.

### Scope and responsible use

The actor reads only the public listing pages Wellfound serves to any visitor. It does not log in, does not use cookies or credentials, does not fetch company profile or job detail pages, and does not attempt to bypass any security check. You are responsible for using the results in accordance with the laws that apply to you and the terms of the websites involved.

### Limitations

- Fields are limited to what the listing payload contains: there is no founder list, funding total, website URL or headquarters — those live on company profile pages, which are out of scope.
- A feed returns at most 47 pages; use several roles or locations to widen coverage.
- `openJobsFound` counts the roles seen in the feeds you searched, not every role the company has open.
- An unknown role or location slug is reported as a warning and skipped; check the slug against the URL of the matching Wellfound page.

### Something missing?

Open an issue on this actor's **Issues** tab with the role or company and the field you expected. Include a small public input and expected behavior so the issue can be investigated.

### Interpret empty results and errors

Check the run status and log if no records are returned. Restrictive filters, inaccessible content or a changed source page can produce an empty result; empty output does not prove there are no matching records on the source.

Billing follows saved job or company rows. Disclosed salary and optional fields may be missing. Proxy selection and run duration can affect operating costs. Do not increase concurrency or enable a more expensive proxy merely to work around an unclear result.

For a reproducible problem, open this Actor’s Issues tab with a small public input, expected behavior and relevant error text. Remove tokens and confidential information. No response-time or uptime guarantee is offered.

### Use the result in an automation

In Make or n8n, use the Apify integration to run this Actor with the same JSON input, wait for completion, then retrieve its default dataset. Route failed runs and error rows to a review step before sending valid results to your spreadsheet or CRM. Scheduling does not make these Actors emit only new records: deduplicate downstream using the source URL or record ID.

For Node.js, install the official `apify-client` package and set your own `APIFY_TOKEN` environment variable. The following example starts a paid run with a small spending limit.

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const input = {
  "roles": [
    "software-engineer"
  ],
  "maxItems": 20,
  "remoteOnly": true
};
const run = await client.actor('keystonelabs/wellfound-startups-scraper').call(input, {
  memory: 512, timeout: 180, maxTotalChargeUsd: 0.10
});
if (run.status !== 'SUCCEEDED') throw new Error('Run did not succeed: ' + run.id);
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 100 });
console.log(items);
```

The first 100 rows are retrieved in this example. Use the dataset API pagination for a larger result. Keep credentials out of shared inputs and source files.

### A useful next step

- [Wellfound Jobs Scraper | Remote Roles & Salaries](https://apify.com/keystonelabs/wellfound-jobs-scraper): build a remote startup-job shortlist. This is a separate Actor with its own input and price.

# Actor input Schema

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

Wellfound role slugs to find companies hiring for, e.g. software-engineer, product-manager, data-scientist. Plain names like "Software Engineer" are converted automatically.

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

Optional Wellfound location slugs, e.g. new-york, london, san-francisco. Combined with roles when both are given.

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

Find companies hiring remotely for the given roles.

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

Stop after this many unique companies.

## `maxPagesPerFeed` (type: `integer`):

Wellfound serves at most 47 pages per role/location feed.

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

Optional. Wellfound listing pages are served without a proxy in normal conditions; enable Apify Proxy only if runs are blocked by a security check.

## Actor input object example

```json
{
  "roles": [
    "software-engineer"
  ],
  "locations": [],
  "remoteOnly": true,
  "maxItems": 20,
  "maxPagesPerFeed": 47,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `startups` (type: `string`):

Dataset of startup company records.

## `workflowJson` (type: `string`):

Selected columns for this workflow. Inspect errors and missing values before using the data.

## `workflowCsv` (type: `string`):

Download the workflow columns as CSV. Use JSON for full nested arrays.

# 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"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("keystonelabs/wellfound-startups-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"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("keystonelabs/wellfound-startups-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"
  ],
  "maxItems": 20
}' |
apify call keystonelabs/wellfound-startups-scraper --silent --output-dataset

```

## MCP server setup

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