# Wellfound Startup Scraper — Founders, Websites & Funding (`scrapersdelight/wellfound-startup-contact-scraper`) Actor

Scrape Wellfound (AngelList) startups by market, city or tech: website, email, phone, one-liner, size, stage, open jobs, founders (name, title, profile), funding raised and HQ. Every search is checked against the filter Wellfound really applied. $1.30 per 1,000 startups, no start fee.

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

## Pricing

$1.30 / 1,000 per startup returneds

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 Startup Scraper — Founders, Websites & Funding

Build a list of startups from **Wellfound** (formerly AngelList Talent) by market, city or tech stack. Every startup comes back as **one row** with its own website, one-liner, description, headcount band, stage, markets, offices, open jobs, its **founders** (name, title, tenure, location, Wellfound profile), **funding raised** and latest round, and HQ address — plus the **email, phone and company LinkedIn / X / Facebook links** published on the startup's own website.

It is built for people who sell to startups: agencies, SaaS sales teams, recruiters, investors and service providers who need the decision-maker and a way to reach them, not just a company name.

### What one row looks like

A real row from a verified run (search: *Fin Tech* in *New York*, run 2026-09-30; long arrays shortened):

```json
{
  "startupId": "177310",
  "name": "Riskified",
  "slug": "riskified",
  "wellfoundUrl": "https://wellfound.com/company/riskified",
  "website": "https://www.riskified.com/",
  "websiteDomain": "riskified.com",
  "oneLiner": "Riskified makes eCommerce safe, accessible, and frictionless",
  "companySize": "501-1000",
  "stage": "public_stage",
  "stageLabel": "Public Stage",
  "businessModel": "B2B",
  "hasTopInvestors": true,
  "glassdoorRating": 4.5,
  "markets": ["E-Commerce", "Payments", "Machine Learning", "Fraud Detection", "Risk Management", "Fin Tech"],
  "locations": ["New York City", "New York", "Tel Aviv-Yafo"],
  "hqCity": "New York",
  "hqRegion": "New York",
  "hqCountry": "United States",
  "founders": [
    {
      "name": "Assaf Feldman",
      "title": "Founder",
      "profileUrl": "https://wellfound.com/p/assaf-feldman",
      "linkedinUrl": "http://www.linkedin.com/pub/assaf-feldman/0/167/991",
      "avatarUrl": "https://photos.wellfound.com/users/285286-medium_jpg?1463375411"
    },
    { "name": "Eido Gal", "title": "Founder", "profileUrl": null, "linkedinUrl": null }
  ],
  "founderNames": "Assaf Feldman; Eido Gal",
  "primaryFounderName": "Assaf Feldman",
  "primaryFounderTitle": "Founder",
  "primaryFounderLinkedinUrl": "http://www.linkedin.com/pub/assaf-feldman/0/167/991",
  "email": "hello@riskified.com",
  "emails": ["hello@riskified.com", "riskified.china@riskified.com", "japan@riskified.com", "press@riskified.com"],
  "companyLinkedinUrl": "https://www.linkedin.com/company/riskified",
  "companyFacebookUrl": "https://www.facebook.com/RiskifiedInc",
  "companyInstagramUrl": "https://www.instagram.com/riskified",
  "contactSourceUrl": "https://www.riskified.com/contact/",
  "totalRaisedText": "$230.3M",
  "totalRaisedUsd": 230300000,
  "fundingRoundsCount": 6,
  "latestRoundDate": "Nov 2019",
  "latestRoundAmountUsd": 165000000,
  "openJobsCount": 29,
  "openJobsByRole": [{ "role": "Engineering", "count": 11 }, { "role": "Sales", "count": 5 }],
  "openJobs": [
    {
      "jobId": "3544615",
      "title": "Senior Global Revenue Enablement Manager",
      "url": "https://wellfound.com/jobs/3544615-senior-global-revenue-enablement-manager",
      "compensation": "$140k – $150k",
      "employmentType": "Full Time",
      "locationAndRoleTags": ["New York", "BD Manager"]
    }
  ],
  "enrichment": "full",
  "foundVia": "Fin Tech in New York",
  "sourceUrl": "https://wellfound.com/startups/l/new-york/fintech-2"
}
```

### How to use it

Pick what to search, set how many startups you want, run.

**All fintech startups in London**

```json
{ "markets": ["Fin Tech"], "locations": ["London"], "maxResults": 200 }
```

**AI and health-care startups in New York and San Francisco, early and growth stage only, with founder LinkedIn links**

```json
{
  "markets": ["artificial intelligence", "health care"],
  "locations": ["New York", "San Francisco"],
  "stages": ["early_stage", "growth_stage"],
  "includeFounderProfiles": true,
  "maxResults": 500
}
```

**Every startup that uses Python, B2B only**

```json
{ "technologies": ["python"], "businessModel": "B2B", "maxResults": 0 }
```

**Specific startups you already know** (slugs or URLs), or a Wellfound directory page as it is:

```json
{ "startups": ["gustohq", "https://wellfound.com/company/moderntreasury", "https://wellfound.com/startups/l/london/fintech-2"] }
```

With no input at all the actor lists the first 50 startups of Wellfound's whole directory.

#### Markets and locations are typed the way you would say them

"Fin Tech", "fintech", "AI", "health care", "New York City", "NYC", "remote" all work. Behind them are Wellfound's own slugs (`fintech-2`, `artificial-intelligence`, `new-york`, `remote-friendly`), resolved from Wellfound's list of 802 markets and 305 locations.

Wellfound does not reject a filter it does not know. It silently drops it and serves its **whole directory of ~10,000 startups** with a normal-looking page — ask for `/startups/industry/fintech` (the real slug is `fintech-2`) and every startup on the site comes back labelled as fintech. Every search here is checked against the filter Wellfound says it actually applied before a single row is kept. A search it did not apply is skipped, costs nothing, and the run summary lists close matches (e.g. *fintech (fintech-2)*).

Each market × location pair is one search when both are given (turn off **Combine each market with each location** to search them separately). A technology is always its own search — Wellfound cannot combine it with a market or a city.

### Input

| Field | What it does | Default |
|---|---|---|
| `markets` | Markets / industries, as text or Wellfound slugs | — |
| `locations` | Cities, regions, countries, or `remote` | — |
| `technologies` | Tech-stack slugs (`python`, `react`, `aws`) | — |
| `combineMarketAndLocation` | Each market × each location is one search | `true` |
| `startups` | Company slugs / URLs to look up, and/or Wellfound directory URLs (a `?page=N` URL starts at that page) | — |
| `maxResults` | Startups for the whole run; 0 = no limit | `50` |
| `maxPagesPerSearch` | Directory pages per search (10 startups a page); 0 = all | `0` |
| `stages` | Keep only `early_stage`, `growth_stage`, `scale_stage`, `public_stage` | all |
| `companySizes` | Keep only these bands: `1-10` … `5000+` | all |
| `businessModel` | `any`, `B2B` or `B2C` | `any` |
| `onlyYcBacked` | Only startups with Wellfound's Y Combinator badge | `false` |
| `onlyTopInvestors` | Only startups with the Top Investors badge | `false` |
| `requireWebsite` | Skip startups without a website of their own | `false` |
| `requireFounders` | Skip (and do not charge) startups with no listed founder | `false` |
| `includeFounders` | Founders, funding, HQ, team background (one job page per startup) | `true` |
| `includeOpenJobs` | Attach the open jobs list | `true` |
| `maxOpenJobsPerStartup` | Cap on the `openJobs` array (`openJobsListed` is always the full count) | `25` |
| `includeWebsiteContacts` | Email, phone and company socials from the startup's own website | `true` |
| `includeFounderProfiles` | LinkedIn / X / GitHub / site links from each founder's public Wellfound profile | `false` |
| `concurrency` | Startups enriched in parallel | `4` |
| `proxyConfiguration` | Leave empty for the automatic route (see *How it gets the data*) | automatic |

The stage / size / model / YC / investor / website filters are applied to the directory card **before** any extra page is opened, so a filtered-out startup costs nothing.

### Output fields

**Company**

| Field | Description |
|---|---|
| `startupId` | Wellfound's numeric startup id — the dedupe key |
| `name`, `slug`, `wellfoundUrl` | Name, Wellfound slug and profile URL |
| `website`, `websiteDomain` | The startup's own site (never a Wellfound URL) |
| `oneLiner`, `description` | Wellfound pitch line and long description |
| `logoUrl` | Logo image |
| `companySize`, `companySizeRaw`, `employeesText` | Employee band (`51-200`), Wellfound's code (`SIZE_51_200`), the band as the job page prints it |
| `stage`, `stageLabel`, `companyTypes` | `early_stage` / `growth_stage` / `scale_stage` / `public_stage` and its label |
| `businessModel` | `B2B`, `B2C` or `B2B/B2C` |
| `isYcBacked`, `hasTopInvestors`, `valuationTier`, `isGrowingFast`, `isRecentlyFunded`, `isActivelyHiring` | Wellfound's badges as columns (`valuationTier` = `1B+` / `500M+`) |
| `glassdoorRating`, `glassdoorLeadershipRating`, `glassdoorWorkLifeBalanceRating` | The ratings Wellfound shows beside its "Highly rated" badges — they are Glassdoor's, which only Wellfound's tooltip says. Empty = no badge, not a low score |
| `responseSpeed`, `isTopResponder` | How fast the startup answers applicants |
| `badges` | Every badge with its label and tooltip |
| `markets`, `marketSlugs`, `locations`, `locationSlugs` | Market and office tags |
| `hqCity`, `hqRegion`, `hqCountry`, `hqLatitude`, `hqLongitude` | Headquarters from the job posting's structured data |

**People and contact**

| Field | Description |
|---|---|
| `founders[]` | `name`, `title`, `tenure` ("8 years"), `location`, `profileUrl`, `avatarUrl`, and with founder profiles on: `linkedinUrl`, `twitterUrl`, `githubUrl`, `personalWebsite` |
| `foundersCount`, `foundersListMayBeTruncated` | How many are listed; `true` when 3 are shown (Wellfound's card shows at most 3) |
| `founderNames` | All listed founders, `;`-separated (CSV-friendly) |
| `primaryFounderName`, `primaryFounderTitle`, `primaryFounderProfileUrl`, `primaryFounderLinkedinUrl` | The CEO if one is listed, else the first founder |
| `email`, `emails` | Best address from the startup's website (sales/contact/hello first), and all of them — only addresses on the startup's own domain or a freemail box |
| `phone`, `phones` | Phone numbers the website publishes as `tel:` links or structured data |
| `companyLinkedinUrl`, `companyTwitterUrl`, `companyFacebookUrl`, `companyInstagramUrl`, `companyYoutubeUrl` | The company's social profiles as linked from its website |
| `contactSourceUrl`, `websiteReachable` | The page the email/phone came from; whether the site answered |

**Funding and hiring**

| Field | Description |
|---|---|
| `totalRaisedText`, `totalRaisedUsd` | Amount raised as Wellfound prints it, and in dollars ("Undisclosed" stays `null`) |
| `fundingRoundsCount`, `latestRoundName`, `latestRoundDate`, `latestRoundAmountUsd` | Round count and the latest round |
| `openJobsCount`, `openJobsListed`, `openJobsByRole` | Open roles (Wellfound's count, the listed count, per department) |
| `openJobs[]` | `jobId`, `title`, `url`, `compensation` (salary and/or equity), `employmentType`, `locationAndRoleTags` (Wellfound's own tags in its order — a multi-city job lists every city, so they are not split into guessed columns) |
| `teamPreviousEmployers[]` | "Employees joined from": companies the team was hired from, with their websites |

**Provenance**: `enrichment` (`full`, `jobs-only`, `job-page-unreachable`, `off`), `jobPageUrl`, `foundVia`, `sourceUrl`, `sourcePage`, `scrapedAt`.

### Measured coverage

From real runs on the Apify platform (2026-09-29/30). How full a column is depends on **which startups you search** — the well-known names at the top of a market are complete, the small ones deep in a tech list are thin — so each field is given as the range across four different searches.

| Field | Fin Tech top 50 | Health care top 50 | AI in San Francisco (60) | Python, pages 40–44 (50) |
|---|---|---|---|---|
| website | 100% | 100% | 100% | 100% |
| one-liner / size / markets / locations / open jobs | 100% | 100% | 98–100% | 98–100% |
| stage | 100% | 100% | 78% | 98% |
| founders (≥1 named) | 90% | 86% | 77% | 40% |
| funding raised | 90% | 82% | 60% | 86% |
| HQ city | 56% | 44% | 78% | 16% |
| email (from website) | — | 62% | — | — |
| company LinkedIn (from website) | — | 72% | — | — |

With every option on (*Fin Tech in New York*, 20 startups): founders 95%, email 35%, company LinkedIn 90%, company X 85%, funding 80%, HQ 90%, **founder LinkedIn 30%** (only founders who keep a public Wellfound profile list one — between 9% and 35% of founders do, depending on the search; of those, 27 of 28 in the Fin Tech run listed a LinkedIn).

Every founder shown is a real current founder: checked against Wellfound's full team page on 16 startups, the names matched on all 15 with three or fewer founders.

### Pricing

**$1.30 per 1,000 startups** ($0.0013 each), pay per result. No start fee, no monthly fee.

- One charge per **distinct startup** per run, keyed on Wellfound's startup id. A startup found by three of your searches is delivered and charged once.
- Founders, funding, HQ, open jobs and website contacts are included in that price.
- **Never charged:** startups removed by your filters, searches Wellfound does not recognise, look-ups that do not exist or have no open job, and anything that could not be read.
- Examples: 100 startups = $0.13 · 1,000 = $1.30 · all ~380 fintech startups = about $0.50.

### Data limits

- **Founders come from the "Founders" card Wellfound prints on each job page, which shows at most three.** A startup with more founders gets its first three (`foundersListMayBeTruncated: true` flags a full card). Non-founder team members, board members and investor names are only on Wellfound's company pages, which sit behind a Cloudflare challenge — they are not included.
- **Founders and funding need one open job.** Wellfound publishes a startup's founders and funding on its job pages; the directory lists hiring startups, so almost every directory row has one. A looked-up startup with no open job is listed in the run summary and not delivered.
- **Round-by-round funding history** (every round, its investors, valuations) is not included: only the total, the round count and the latest round, as the job page shows them.
- **Founder LinkedIn** exists only for founders who keep a public Wellfound profile (9–35% of founders, by search).
- **HQ** comes from the job posting's structured data; many startups do not fill it — the `locations` tags are always there.
- **Email / phone** come from the startup's own website, not from Wellfound (Wellfound publishes none). Sites that show only a contact form give no email.
- **Headcount is Wellfound's self-reported band**, not an exact number.
- **Stage, badges and ratings** are on directory results. A startup fetched by slug in `startups` has no directory card, so those columns are empty for it (stage is taken from the job page when it prints one).
- Wellfound's directory holds about **10,250 startups** in total.

### How it gets the data

1. **Directory** — Wellfound's public startup directory pages (`/startups/industry/…`, `/startups/location/…`, `/startups/l/<city>/<market>`, `/startups/tech/…`), 10 startups a page, until your cap or the last page.
2. **Open jobs** — the startup's public jobs widget, which lists every open role.
3. **Founders, funding, HQ** — the startup's newest job page.
4. **Website contacts** — the startup's homepage, plus up to two contact/about pages when the homepage shows no email.
5. **Founder profiles** (optional) — each founder's public Wellfound profile.

No login and no browser. Requests go out directly first; if Wellfound starts answering one kind of page with a "Security Check", that kind of page moves to Apify datacenter and then residential proxies for the rest of the run, automatically. Set a proxy in **Proxy** to use only that one.

### Run summary

Every run writes `RUN_SUMMARY` to its key-value store:

- per search: the URL used, the filter Wellfound applied, its total startup count, pages read, startups delivered and why the search stopped;
- searches Wellfound did not recognise, with close matches;
- look-ups not found / without an open job / unreachable;
- how many startups your filters removed, duplicates skipped, founders and emails found;
- a per-page-type request log (direct / datacenter / residential, answered / blocked).

Runs save their progress after every page, so a run the platform moves to another server picks up where it stopped without delivering or charging anything twice.

### FAQ

**Why did my search return startups from other markets?**
It cannot: a search whose filter Wellfound did not apply is dropped before any row is kept. Check `RUN_SUMMARY.unresolved` for the slug it suggests.

**How do I get every startup in a market?**
Set `maxResults` to 0. Fintech is ~380 startups (38 pages), health care ~780, the whole directory ~10,250.

**Why is `founders` empty for some startups?**
Their Wellfound page lists no founder. Turn on `requireFounders` to skip them without paying.

**Why is the email a `support@` or `press@` address?**
It is the best one the website publishes; `emails` has the full list, sales/contact/hello-style inboxes first.

**Can I search by a keyword that is not a market?**
Use the closest Wellfound market (the summary suggests them) or a technology.

**Can I combine a technology with a city?**
Not in one search — Wellfound's directory does not. Run the technology, then filter on `locations`.

**Does it find startups that are not hiring?**
Wellfound's directory lists hiring startups. A non-hiring startup can be looked up by slug, but without an open job its founders and funding are not published.

**Why do two runs of the same search differ slightly?**
Wellfound reorders its directory and startups open and close jobs daily; the totals move by a few.

**How fast is it?**
About 50 startups a minute with the default options at 512 MB.

**Is the same startup charged twice across runs?**
Within a run, never. Across separate runs, each run charges for what it delivers.

# Actor input Schema

## `markets` (type: `array`):

Wellfound markets to list startups from, as you would type them: "Fin Tech", "artificial intelligence", "health care", "SaaS" - or the exact Wellfound slug (fintech-2). Each is checked against the filter Wellfound actually applies; one it does not recognise is skipped, never charged, and the run summary suggests close matches.

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

Cities, regions or countries: "San Francisco", "New York", "London", "India", or "remote" for remote-friendly startups. Combined with markets (see below) or searched on their own.

## `technologies` (type: `array`):

Tech-stack slugs Wellfound tags startups with, e.g. python, react, aws. Each technology is its own search (Wellfound cannot combine a technology with a market or a location).

## `combineMarketAndLocation` (type: `boolean`):

On: every market x location pair is one search (fintech startups IN London). Off: markets and locations are searched separately and the results merged.

## `startups` (type: `array`):

Wellfound company slugs or URLs ("stripe", "https://wellfound.com/company/gustohq") to look up directly, and/or Wellfound directory URLs ("https://wellfound.com/startups/l/london/fintech-2") to crawl as they are. A looked-up startup is delivered only when it has at least one open job - that is where its founders and funding are published.

## `maxResults` (type: `integer`):

Stop after this many startups for the whole run (each startup is delivered and charged once, however many searches find it). 0 = no limit.

## `maxPagesPerSearch` (type: `integer`):

Wellfound's directory shows 10 startups a page. 0 = read every page of each search.

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

Keep only these Wellfound stages. Empty = all.

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

Keep only these employee bands (Wellfound's self-reported band). Empty = all.

## `businessModel` (type: `string`):

B2B, B2C or any (startups tagged both pass either filter).

## `onlyYcBacked` (type: `boolean`):

Keep only startups carrying Wellfound's Y Combinator badge.

## `onlyTopInvestors` (type: `boolean`):

Keep only startups carrying Wellfound's Top Investors badge.

## `requireWebsite` (type: `boolean`):

Skip startups whose Wellfound card has no website of their own.

## `requireFounders` (type: `boolean`):

Skip (and do not charge for) startups whose Wellfound page lists no founder.

## `includeFounders` (type: `boolean`):

Read one of the startup's job pages for its founders (name, title, tenure, location, Wellfound profile), funding raised and latest round, HQ address and where its team was hired from. Included in the per-startup price.

## `includeOpenJobs` (type: `boolean`):

Attach the startup's open jobs: title, link, compensation (salary and/or equity), employment type, and Wellfound's own location + role tags in its order (a multi-city job lists every city).

## `maxOpenJobsPerStartup` (type: `integer`):

Cap on the openJobs array per row (the openJobsListed count is always the full number).

## `includeFounderProfiles` (type: `boolean`):

For each founder with a public Wellfound profile, read it for the LinkedIn, X/Twitter, GitHub and personal-site links they list. One extra request per such founder, so runs take longer.

## `includeWebsiteContacts` (type: `boolean`):

Read the startup's own website (homepage, plus up to 2 contact/about pages when the homepage shows no email) for its email, phone and company LinkedIn / X / Facebook / Instagram / YouTube links. Only emails on the startup's own domain (or a freemail box) are kept. Included in the per-startup price.

## `concurrency` (type: `integer`):

Startups enriched at the same time.

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

Leave empty for the automatic route: direct first, then Apify datacenter, then Apify residential, each step taken only when the cheaper one is blocked. Set a proxy here to use only that one.

## Actor input object example

```json
{
  "markets": [
    "Fin Tech"
  ],
  "combineMarketAndLocation": true,
  "maxResults": 10,
  "maxPagesPerSearch": 0,
  "businessModel": "any",
  "onlyYcBacked": false,
  "onlyTopInvestors": false,
  "requireWebsite": false,
  "requireFounders": false,
  "includeFounders": true,
  "includeOpenJobs": true,
  "maxOpenJobsPerStartup": 25,
  "includeFounderProfiles": false,
  "includeWebsiteContacts": true,
  "concurrency": 4
}
```

# Actor output Schema

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

The dataset of scraped Wellfound startups (one item per startup).

## `runSummary` (type: `string`):

Per-search totals, filters Wellfound did not recognise, not-found / no-open-job lookups and the transport log.

# 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 = {
    "markets": [
        "Fin Tech"
    ],
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapersdelight/wellfound-startup-contact-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 = {
    "markets": ["Fin Tech"],
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapersdelight/wellfound-startup-contact-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 '{
  "markets": [
    "Fin Tech"
  ],
  "maxResults": 10
}' |
apify call scrapersdelight/wellfound-startup-contact-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapersdelight/wellfound-startup-contact-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/Ef2PHdIqVgtaUdmwy/builds/JJZeGabphA3UZMCM4/openapi.json