# Wellfound Companies Scraper — Startup Directory & Funding (`yugenox/wellfound-companies-scraper`) Actor

Scrape Wellfound's (AngelList Talent) startup directory by city, industry or both: company name, tagline, description, website, size, stage, markets, office locations, open jobs per role, YC / top-investor / $1B+ valuation badges and Glassdoor ratings. Filters for size, stage and hiring. No login.

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

## Pricing

from $1.50 / 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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Wellfound Companies Scraper: startup directory, stage and funding signals

Scrape the **Wellfound (formerly AngelList Talent) startup directory** by city, by industry, or both. Every company comes with its **name, one-line pitch, full description, website, logo, company size, stage, industries, office locations, number of open jobs (per role)** and Wellfound's signals: **YC funded, top investors, $1B+ valuation, recently funded, growing fast, B2B/B2C and Glassdoor ratings**. Filter by size, stage, hiring and badges. No login, no cookies, no Wellfound account.

### What you get

| | |
|---|---|
| **Company** | Name, Wellfound profile and jobs links, website, logo, one-line pitch, full description |
| **Size and stage** | Employees (e.g. `51-200`) and stage: early, growth, scale, public or acquired |
| **Industries** | Wellfound markets, e.g. SaaS, Fin Tech, Artificial Intelligence (names and slugs) |
| **Locations** | Office locations (names and slugs) |
| **Hiring** | Open jobs on Wellfound, open jobs per role (Engineering, Sales …), "Actively hiring", how fast the company answers applicants |
| **Signals** | YC funded, top investors, valuation ($1B+ / $500M+), recently funded, growing fast, B2B / B2C |
| **Ratings** | Glassdoor rating, work/life balance and leadership ratings when Wellfound shows them |
| **List context** | Which list the company came from, its position in that list and how many companies the list has |

### How to use it

1. Enter one or more **locations**, e.g. `London`, `San Francisco`, `New York`, `Berlin`, `Toronto`, `Bengaluru`, `Canada`, `Europe`.
2. And/or enter **industries**, e.g. `SaaS`, `Fintech`, `Artificial Intelligence`, `Healthcare`, `Developer Tools`. Every location × industry pair is its own list ("SaaS startups in London").
3. Set **Max companies** and any filters, then run.

Leave both empty to read Wellfound's whole startup directory (about 10,000 companies). Tick **Startups hiring remotely** for Wellfound's remote list (about 4,000 companies). **Max companies** is the total for the run, shared fairly between your lists. A company that appears in several lists is saved once.

#### Input examples

Startups in London:

```json
{
  "locations": ["London"],
  "maxItems": 200
}
```

Fintech and AI startups in New York and Toronto, growth or scale stage, hiring right now:

```json
{
  "locations": ["New York", "Toronto"],
  "industries": ["Fintech", "Artificial Intelligence"],
  "stages": ["growth_stage", "scale_stage"],
  "onlyHiring": true,
  "maxItems": 500
}
```

YC-funded SaaS companies that hire remotely:

```json
{
  "remoteFriendly": true,
  "industries": ["SaaS"],
  "mustHave": ["ycFunded"],
  "maxItems": 100
}
```

Every company in a Wellfound list, by URL:

```json
{
  "startUrls": [{ "url": "https://wellfound.com/startups/l/london/saas" }],
  "maxItems": 0
}
```

Names are matched to Wellfound's own list names (`Fintech` → `fintech-2`, `New York` → `new-york-city-ny`, `Canada` → `canada-startups`). You can also paste the slug or the directory URL from wellfound.com/startups.

### Output example

```json
{
  "companyId": "1222430",
  "name": "Deepgram",
  "slug": "deepgram",
  "url": "https://wellfound.com/company/deepgram",
  "jobsUrl": "https://wellfound.com/company/deepgram/jobs",
  "website": "https://www.deepgram.com/",
  "logoUrl": "https://photos.wellfound.com/startups/i/1222430-25607b0f6637beda561fdf459238422a-medium_jpg.jpg?buster=1687560231",
  "tagline": "AI speech API for transcription with human-level understanding",
  "description": "Hey, we’re Deepgram! We’re an AI speech platform whose mission is to make every voice heard and understood. …",
  "companySize": "51-200",
  "companySizeCode": "SIZE_51_200",
  "stage": "Growth Stage",
  "stageCode": "growth_stage",
  "markets": ["Machine Learning", "Audio", "Artificial Intelligence", "Natural Language Processing"],
  "marketSlugs": ["machine-learning", "audio", "artificial-intelligence", "natural-language-processing"],
  "locations": ["San Francisco", "Ann Arbor", "Remote"],
  "locationSlugs": ["san-francisco", "ann-arbor", "remote-friendly"],
  "openJobs": 93,
  "jobsByRole": [{ "role": "Designer", "count": 1 }, { "role": "Engineering", "count": 33 }, { "role": "Management", "count": 2 }, { "role": "Marketing", "count": 2 }, { "role": "Operations", "count": 14 }, { "role": "Other", "count": 7 }, { "role": "Other Engineering", "count": 5 }, { "role": "Product", "count": 4 }, { "role": "Sales", "count": 25 }],
  "activelyHiring": true,
  "ycFunded": true,
  "topInvestors": true,
  "valuation": null,
  "valuation1b": false,
  "recentlyFunded": false,
  "growingFast": true,
  "b2b": true,
  "b2c": false,
  "glassdoorRating": null,
  "workLifeBalanceRating": null,
  "leadershipRating": null,
  "respondsWithin": "within a day",
  "topResponder": "Top 5% of responders",
  "badges": ["Actively Hiring", "Top 5% of responders", "Responds within a day", "B2B", "Growth Stage", "Top Investors", "YC Funded", "Growing fast"],
  "searchLocation": "london",
  "searchIndustry": null,
  "search": "startups in London",
  "listUrl": "https://wellfound.com/startups/location/london",
  "listTotal": 399,
  "position": 1,
  "scrapedAt": "2026-10-02T00:07:38.964Z"
}
```

Every row has the same columns; a value Wellfound doesn't show for a company is `null` (or an empty list).

### Use cases

- **B2B lead lists**: startups in a city or industry, with website, size, stage and hiring activity, ready for your CRM.
- **Recruiting and job search**: which startups are hiring, how many roles they have open, and how fast they answer applicants.
- **Investor and market research**: map an industry or city by stage, size, YC backing and valuation signals.
- **Sales territory planning**: growth- and scale-stage companies hiring in your region.
- **Monitoring**: schedule a weekly run to see new companies and hiring changes in your market.

### FAQ

**Do I need a Wellfound account, cookies or a login?** No. The scraper reads the same public directory pages any visitor sees at wellfound.com/startups. It never logs in and needs nothing from you except a location, an industry or a URL.

**How many companies can I get?** Each Wellfound list shows its companies 10 per page; London has about 400, SaaS about 1,300, the remote list about 4,000 and the whole directory about 10,000. Set **Max companies** to 0 to get every company in your lists.

**How fast is it?** A page of 10 companies takes about a second, and 4 pages are read at a time: 1,000 companies take about a minute.

**What if a location or industry isn't found?** Wellfound only has lists for the places and industries it knows. If it doesn't recognise one, that list is skipped, not charged, and the run's status message says which word wasn't recognised and suggests close matches (for example `Londn` → `London`).

**How do the filters work?** Wellfound's lists can only be narrowed by location and industry; size, stage, hiring and badges are checked company by company. Companies that don't match are never charged. With a very narrow filter the scraper may read many pages to find a few matches, so it stops early once further pages would cost more than the matches they bring, and the status message says so. Narrowing by location or industry is always the fastest way to a precise list.

**Does it give me founders, employees or contact people?** No. It collects company-level data only. It never opens company profile pages (where Wellfound lists founders and team members) and never outputs people's names, profiles, e-mails or phone numbers as fields. A company's own description can mention its founders by name, as written by the company; personal e-mail addresses and phone numbers in descriptions are removed (company addresses such as `info@` stay).

**Which proxy should I use?** Keep the default (Apify Proxy, datacenter). It comes with every Apify plan, including the free one. If Wellfound refuses datacenter IPs, the run switches to residential proxies when your account has them, and stops with a clear message when it doesn't.

**What does a run cost?** You pay per company saved plus a small fee per run. See the Pricing tab. Companies that are filtered out, duplicated across lists or not delivered are never charged.

**Is it legal to scrape Wellfound?** This Actor only collects publicly available data: company listings that anyone can see in Wellfound's startup directory without an account, such as the company name, description, website, size, stage, industries, locations and open-job counts. Collecting publicly available data is generally legal, but you're responsible for how you use it. The data describes companies, not people, but a company's description can mention its founders by name; the scraper removes personal e-mail addresses and phone numbers from descriptions. You must follow privacy laws such as GDPR, PIPEDA and CCPA, as well as Wellfound's terms. If you're unsure, check with a lawyer. More on this: [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/)

**Does it access any private data?** No. Everything comes from directory pages Wellfound shows to any visitor without logging in. It never uses a login and never touches candidate profiles, applications, messages or private accounts. It only reads pages that Wellfound's robots.txt allows.

This Actor is not affiliated with, endorsed by, or sponsored by Wellfound or AngelList. Wellfound is a trademark of its owner, used here only to describe the data the Actor works with.

# Actor input Schema

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

Cities, regions or countries, e.g. "London", "San Francisco", "New York", "Toronto", "Bengaluru", "Canada", "Europe". Each one is a separate list on Wellfound. Combined with industries, every location × industry pair is searched ("SaaS startups in London"). Leave both empty to read Wellfound's whole startup directory (about 10,000 companies).

## `industries` (type: `array`):

Wellfound markets, e.g. "SaaS", "Fintech", "Artificial Intelligence", "Healthcare", "E-Commerce", "Cyber Security", "Developer Tools". Names or Wellfound slugs both work.

## `remoteFriendly` (type: `boolean`):

Also read Wellfound's list of companies that hire remote workers (about 4,000), on its own or combined with your industries.

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

Maximum number of companies for the whole run, shared fairly between your lists (a list with fewer companies leaves its share to the others). 0 = everything.

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

Optional: Wellfound startup directory pages, e.g. https://wellfound.com/startups/location/berlin, https://wellfound.com/startups/industry/fintech-2 or https://wellfound.com/startups/l/london/saas (?page=N starts later in the list). Company profile pages are not supported.

## `companySizes` (type: `array`):

Only companies of these sizes (employees). Empty = all.

## `stages` (type: `array`):

Only companies at these stages. Empty = all. Companies without a stage badge are skipped when this is set.

## `onlyHiring` (type: `boolean`):

Skip companies with no open jobs on Wellfound.

## `mustHave` (type: `array`):

Only companies with all of these Wellfound badges. Empty = no badge filter.

## `freshResults` (type: `boolean`):

Read every list page fresh from Wellfound instead of from its CDN cache (which can be up to a day old and differ between pages). Keeps the order consistent across pages. Leave on.

## `maxConcurrency` (type: `integer`):

How many list pages to read at the same time.

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

Apify Proxy (datacenter) is the default and comes with every Apify plan. If Wellfound refuses datacenter IPs, the run switches to residential proxies when your account has them.

## Actor input object example

```json
{
  "locations": [
    "London"
  ],
  "remoteFriendly": false,
  "maxItems": 20,
  "onlyHiring": false,
  "freshResults": true,
  "maxConcurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped companies.

## `run` (type: `string`):

Status and statistics for this run.

## `report` (type: `string`):

RUN_REPORT: how the run ended, counts per list, requests, proxy use and the cost estimate.

# 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 = {
    "locations": [
        "London"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("yugenox/wellfound-companies-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 = {
    "locations": ["London"],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("yugenox/wellfound-companies-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 '{
  "locations": [
    "London"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call yugenox/wellfound-companies-scraper --silent --output-dataset

```

## MCP server setup

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