# Wellfound Startups Scraper — Hiring Company List (`thenetaji/wellfound-startups-scraper`) Actor

Build a list of startups that are hiring: name, website, one-line pitch, description, headcount band, industries, offices and how many roles are open. Switch on the profile add-on and every row also carries funding rounds with amounts, the team and the stated perks.

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

## Pricing

from $2.55 / 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.
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 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

## Wellfound Startups Scraper

Build a list of startups that are hiring. Every company in Wellfound's directory becomes one row
with its name, its own website, its one-line pitch, its longer description, its headcount band,
the industries it files itself under, the offices it lists, the badges Wellfound awards it, how
many roles it has open and the breakdown of those roles by function.

That is a prospect list with a buying signal attached: a company appearing here is advertising
that it is hiring, and `open_jobs_count` says how hard.

### What a row looks like

```json
{
  "company_id": "28804",
  "company_name": "HomeLight",
  "company_slug": "homelight",
  "company_url": "https://wellfound.com/company/homelight",
  "company_website": "https://www.homelight.com",
  "company_pitch": "Our vision is a world where every real estate transaction is simple",
  "company_description": "We're the essential technology platform used by hundreds of thousands…",
  "company_size": "SIZE_501_1000",
  "company_markets": ["Real Estate", "Marketplaces"],
  "company_locations": ["San Francisco", "Scottsdale"],
  "company_badges": ["Actively Hiring", "Responds within two weeks"],
  "open_jobs_count": 16,
  "open_roles": [
    { "role": "Marketing", "count": 2 },
    { "role": "Operations", "count": 2 },
    { "role": "Product", "count": 1 }
  ]
}
```

`company_website` is the company's own domain rather than its Wellfound page, which is what makes
these rows usable as a prospect list without a second enrichment step somewhere else.
`company_size` is Wellfound's own coding — `SIZE_1_10` through `SIZE_1001_5000` — and it is
self-reported, so it is a band rather than a headcount.

### Accepted input

```json
{
  "maxItems": 100,
  "remote": false
}
```

`maxItems` is how many companies to save, up to 500. `remote` narrows the directory to companies
hiring remotely; unlike the job search, the directory does publish a remote variant, so it is
always valid here.

#### Funding, team and perks

`enrichCompanyProfile` reads each company's own profile and adds `total_raised`, `funding_rounds`
with the amount raised, the valuation, the close date and the press article behind each one,
`team` with titles, classification and tenure, `perks`, the company's own `open_jobs`, and its
LinkedIn, X and blog links. `sections` chooses which tabs are read — `overview`, `funding`,
`jobs`, `people`, `culture` — and it defaults to `overview` and `funding`.

It is one read per company and it is billed per company enriched, so it is off by default. Runs
that use it take noticeably longer than runs that do not.

### Questions

**Why does a round have no amount on it?**
Because `funding` was not among the requested sections. The overview tab lists a company's rounds
with their type and close date and omits the amount raised and the press link entirely — measured
on HomeLight, whose eleven rounds come back with `raised_amount: null` from overview and with
$60M, $55M, $263M and $100M from the funding tab. Request `["overview", "funding"]`, which is the
default, and the two are merged by round so nothing is lost.

**Why do some enriched companies have an empty `perks` or `team`?**
Either the tab was not requested or the company hid it. `hidden_sections` on each row says which,
and it is the reason an empty section is readable at all: `["SALARIES"]` means the company
withheld its salary tab, not that the read failed. Salaries are not offered as a section here —
Wellfound redirects that page and most companies hide it, so offering it would promise data the
site does not serve.

**`open_jobs` is shorter than `open_jobs_count`. Which is right?**
Both, and they answer different questions. `open_jobs_count` is the number the company's page
states; `open_jobs` is the postings actually listed on the tab that was read, and only the ones
belonging to that company. The overview tab renders a strip of recommended postings from *other*
companies in the same block — OpenAI, which has no open roles at all, comes back with ten
postings on its overview and every one belongs to somebody else — so postings are matched to their
own company and the rest are dropped rather than reported as this company's.

**How many companies can one run collect?**
Up to 500. The directory serves about twenty companies per read, so 500 is roughly twenty-five
reads, and a walk stops early when the directory stops producing new companies. There is no filter
for industry or city on this surface: the directory is one ordered list plus the remote variant,
so narrowing happens after the export, on `company_markets` and `company_locations`.

**Is this the same company record the jobs scraper attaches to a posting?**
The columns are the same names, so the two datasets join on `company_slug`, but the directory row
is fuller: a posting carries the company's name, pitch, size, logo and badges, while the directory
adds the website, the long description, industry tags, offices and open-role counts.

**Are these companies ranked by anything?**
They arrive in the directory's own order, which Wellfound does not explain and which is not a
ranking this Actor can reproduce or sort by. Sorting on `open_jobs_count` or on the badges is the
honest way to prioritise the export.

### Related Actors

[Wellfound Company Scraper](https://apify.com/thenetaji/wellfound-company-scraper) takes a list of
`company_slug` values and returns full profiles, which is the cheaper order when the companies are
already known.

[Wellfound Jobs Scraper](https://apify.com/thenetaji/wellfound-jobs-scraper) approaches the same
market from the roles rather than the companies, and every one of its rows carries the hiring
company.

# Actor input Schema

## `remote` (type: `boolean`):

Restrict the directory to companies hiring remotely. Unlike the job search, the directory does have a remote variant, so this is always valid here.

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

How many companies to save, up to 500. The directory serves about 20 per request, so a larger number is more round trips rather than a longer single one.

## `enrichCompanyProfile` (type: `boolean`):

Read each company's own profile and add its funding rounds with amounts and press links, its lifetime raised total, its team with titles and tenure, its stated perks, its open postings and its social links — whichever of those the selected sections cover.

One request per section per company, billed per company enriched and only when the profile returns something. This is the slowest part of any run that uses it: the profile tier is gated, and the first company of a run can take a minute while that is dealt with.

## `sections` (type: `array`):

Which tabs to read when the company profile is added. Ignored unless that is switched on.

`funding` is the one worth stating: the overview tab lists a company's rounds but not the amounts raised or the press behind them, so a profile fetched without it reports rounds with no money on them. `jobs` adds the company's own open postings, `people` its team with titles and tenure, `culture` its stated perks.

## Actor input object example

```json
{
  "remote": false,
  "maxItems": 40,
  "enrichCompanyProfile": false,
  "sections": [
    "overview",
    "funding"
  ]
}
```

# Actor output Schema

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

All records scraped by this run

# 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 = {
    "maxItems": 40
};

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

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

```

## MCP server setup

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