# Wellfound Email Scraper - Domain Filter & Deduplication (`insightflow/wellfound-email-scraper-powerful-and-intelligent`) Actor

🚀 Wellfound Email Scraper — turn Wellfound searches into a clean startup founder email list. Filter by keyword, location and domain, merge aliases and decode hidden addresses. 💼 For tech recruiting & SaaS sales outreach.

- **URL**: https://apify.com/insightflow/wellfound-email-scraper-powerful-and-intelligent.md
- **Developed by:** [InsightFlow](https://apify.com/insightflow) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### Wellfound Email Scraper

**Wellfound Email Scraper** is a practical Apify actor for extracting public email addresses from Wellfound based on your chosen keywords. It helps marketers, recruiters, and data teams turn manual prospect discovery into fast, structured lead generation. If you need candidate email extraction, talent sourcing, or recruiting automation at scale, this Wellfound scraper is built to save time and improve ROI. 🚀

### What is Wellfound Email Scraper? 🔍

Wellfound Email Scraper is an automated web scraping tool that collects publicly available contact details from Wellfound profiles. It uses your keywords, optional location filtering, and email-domain filters to find relevant contacts, making it useful for startup hiring, founder outreach, ATS enrichment, and recruitment data scraping.

Instead of manually browsing profiles one by one, this actor helps you gather job candidate data in a structured way. It is designed for marketers, recruiters, sales teams, analysts, and researchers who want a reliable email finder for Wellfound. With repeatable runs and dataset output, it can support prospect discovery at much greater scale. 📈

### What Data Does Wellfound Email Scraper Collect? 📊

This Wellfound email scraper returns a clean dataset with the most useful fields for lead generation and contact extraction. Each record includes the keyword that surfaced the result, the profile title, descriptive text, the profile URL, and the extracted email address.

| Data Category | Fields Extracted | Description |
|---|---|---|
| Discovery | `keyword` | The keyword that brought in the result |
| Identity | `title` | The profile title or name shown in the result |
| Context | `description` | Profile summary or descriptive text |
| Navigation | `url` | Direct link to the Wellfound profile |
| Contact | `email` | Public email address found in the result |

### What Do Results from Wellfound Email Scraper Look Like? 👀

Each result is saved as a structured JSON record in your Apify dataset. Here is a realistic example of what a scraped lead can look like:

```json
{
  "keyword": "founder",
  "title": "Maya Chen",
  "description": "Co-founder at Northstar Labs | Open to early-stage collaborations",
  "url": "https://wellfound.com/u/maya-chen",
  "email": "maya.chen@northstarlabs.com"
}
```

Export formats: JSON by default, and CSV through the Apify Console. ✅

#### Core Features: Wellfound Email Scraper ⚡

| Feature | Benefit |
|---|---|
| ✅ **Keyword-Driven Targeting** | Find Wellfound profiles that match your outreach goals |
| ✅ **Location Filter** | Narrow results by location when you need more relevant contacts |
| ✅ **Custom Domain Filter** | Focus on specific email domains such as `@gmail.com` or `@yahoo.com` |
| ✅ **Configurable Result Cap** | Use `maxEmails` to control run size and keep costs predictable |
| ✅ **Built-In Proxy Support** | Supports reliable scraping for larger public-web data collection runs |
| ✅ **Real-Time Data Saving** | Results are stored as they are found, helping prevent data loss |
| ✅ **Structured Dataset Output** | Clean records ready for CRM import, spreadsheets, or lead generation workflows |
| ✅ **Resume-Friendly Runs** | Helps continue from prior progress during longer scraping sessions |

### Getting Started with Wellfound Email Scraper 🚀

1. **Open the actor on Apify** — Search for **Wellfound Email Scraper** in the Apify Store.
2. **Configure your keywords** — Add one or more keywords that describe your target audience.
3. **Set optional filters** — Add a location if you want to narrow the search.
4. **Choose email domains** — Enter the email domains you want to match.
5. **Set your result limit** — Adjust `maxEmails` to control the number of emails collected.
6. **Run the actor** — Start the task and monitor progress in the logs.
7. **Review the dataset** — Open the output dataset to preview or export your results. 📥

No coding required — it’s a straightforward way to scale contact extraction from Wellfound.

### Ways to Use Wellfound Email Scraper 💡

- 🎯 **B2B Lead Generation** — Build targeted outreach lists from Wellfound profiles
- 🤝 **Startup Hiring** — Support recruiting automation for early-stage teams
- 🔬 **Market Research** — Analyze job candidate data and public professional profiles
- 📊 **CRM Enrichment** — Add contact details to your existing records
- ✉️ **Founder Outreach** — Find public emails for direct, relevant communication
- ⚙️ **Prospect Discovery** — Speed up research across startup and talent sourcing workflows

#### Input Parameters — Wellfound Email Scraper

```json
{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20
}
```

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `keywords` | Array | Yes | `["manager","founder"]` | A list of keywords or queries to search for. |
| `location` | String | No | `""` | Location to filter search results. Leave it empty if you do not want to narrow by location. |
| `customDomains` | Array | No | `["@gmail.com","@yahoo.com"]` | A list of email domains to match, such as personal or company domains. |
| `maxEmails` | Integer | No | `20` | Maximum number of emails to collect. The run stops when this limit is reached. |

#### Output Parameters — Wellfound Email Scraper

| Field | Label | Format | Description |
|---|---|---|---|
| `keyword` | Keyword | text | The keyword that produced the result. |
| `title` | Title | text | The title or name shown for the result. |
| `description` | Description | text | The descriptive text associated with the profile result. |
| `url` | Url | link | Direct link to the Wellfound profile. |
| `email` | Email | text | The public email address extracted from the profile result. |

### Why Choose Wellfound Email Scraper? 🏆

This Wellfound scraper is a strong choice if you need structured lead generation without the headache of manual prospecting. It combines keyword targeting, a configurable email-domain filter, and dataset-ready output so you can move from research to outreach quickly. The actor also supports reliable public-web scraping with built-in resilience features, making it a practical tool for recruiters and data teams. If you need help or have a request, contact <insightflowofficial@gmail.com>. ✅

### How Many Results Can You Scrape? 📈

You can control collection size with `maxEmails`, which accepts values from 1 to 10,000. Actual volume depends on how many Wellfound profiles match your keywords and have public emails available. For bigger runs, it can take longer, so increasing your run timeout may help. Your dataset can store the collected results, and you can export them whenever you need. 📦

### Legal Guidelines for Scraping Wellfound ⚖️

This actor collects only publicly available data from Wellfound. It does not access private accounts or authenticated content. You are responsible for following Wellfound’s terms, applicable privacy rules, and any local regulations that apply to outreach or data handling. Use extracted contacts for legitimate business purposes only. For data removal requests, contact <insightflowofficial@gmail.com>. 🙏

### FAQ — Wellfound Email Scraper ❓

#### How does Wellfound Email Scraper identify data?

The actor uses your keywords and email-domain filters to find relevant public profiles on Wellfound, then extracts publicly available contact details and profile text into a structured dataset.

#### What Wellfound profile types can I scrape?

You can scrape public Wellfound profiles that expose an email address in the available profile content. If no public email is present, there may be no matching result.

#### Why scrape Wellfound for contacts?

Wellfound is valuable for talent sourcing, startup hiring, founder outreach, and prospect discovery because many profiles are closely tied to professional roles and public contact details.

#### How does Wellfound Email Scraper help my business?

It turns manual research into recruiting automation and lead generation, helping you build cleaner contact lists faster and with less effort.

#### What challenges should I expect when using Wellfound Email Scraper?

Result volume depends on your keyword choices, location filter, and whether public emails are available. Broader keywords and more domain options can improve coverage.

#### How do I choose a high-performing Wellfound Email Scraper?

Look for structured output, configurable limits, useful filters, and reliable scraping of publicly available sources. This actor includes those core capabilities.

### Conclusion 🏁

**Wellfound Email Scraper** is a fast, practical way to extract public emails from Wellfound for recruiting automation, candidate email extraction, and lead generation. If you want a scalable workflow for contact extraction and prospect discovery, this actor makes it easy to get started. 🚀

### 🆘 Support & Feedback

Have a question or feature request for Wellfound Email Scraper?

For bug reports, custom solutions, or general feedback, email <insightflowofficial@gmail.com>.

### MX Lookup

Every address is checked at the DNS level: the actor resolves the mail domain's
MX records and reports what it found.

| Field | Meaning |
| --- | --- |
| `mxFound` | `true` when the domain publishes at least one mail server |
| `mxHost` | The lowest-preference (primary) mail server |
| `mxRecords` | Every MX record found, in preference order |
| `mxProvider` | Who runs the mail: Google Workspace, Microsoft 365, Zoho, Proton, ... |
| `mxStatus` | `found`, `no_records`, `no_such_domain`, `timeout`, `error`, or `skipped` |

**Inputs**

- **MX Lookup** - turn the check on or off (default: on).
- **Only keep contacts whose domain has an MX record** - drop unreachable domains.
  Only a definite negative (`no_records` / `no_such_domain`) drops a contact; a
  timeout or resolver error is treated as unknown and the lead is kept.
- **MX lookup timeout (seconds)** - per-domain DNS budget, 1-15s.

This is a domain-level check. It confirms the domain can receive mail; it does
not verify that an individual mailbox exists.

# Actor input Schema

## `keywords` (type: `array`):

A list of keywords or queries to search for.

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

Location to filter search results.

## `customDomains` (type: `array`):

List of custom email domains

## `maxEmails` (type: `integer`):

Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.

## `minLeadScore` (type: `integer`):

Drop any contact whose Lead Score (0-100) falls below this. Leave at 0 for no filter.

## `mxLookup` (type: `boolean`):

Resolve each address's domain to its mail servers. Adds the resolved MX hosts and the mail provider (Google Workspace, Microsoft 365, ...) to every result, and feeds the Lead Score. DNS-level only - it confirms the domain can receive mail, not that the individual mailbox exists.

## `requireMxRecord` (type: `boolean`):

Drop any contact whose domain provably accepts no mail. A lookup that times out or errors is treated as unknown and kept, so a DNS hiccup never silently deletes good leads.

## `mxTimeoutSecs` (type: `integer`):

How long to wait for each DNS answer. Clamped to 1-15 seconds.

## Actor input object example

```json
{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20,
  "minLeadScore": 0,
  "mxLookup": true,
  "requireMxRecord": false,
  "mxTimeoutSecs": 3
}
```

# Actor output Schema

## `dataset` (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 = {
    "keywords": [
        "manager",
        "founder"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("insightflow/wellfound-email-scraper-powerful-and-intelligent").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 = {
    "keywords": [
        "manager",
        "founder",
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("insightflow/wellfound-email-scraper-powerful-and-intelligent").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 '{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ]
}' |
apify call insightflow/wellfound-email-scraper-powerful-and-intelligent --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,insightflow/wellfound-email-scraper-powerful-and-intelligent"
        }
    }
}

```

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/tqfKo64ild8Rstrei/builds/AkuoCAbzBFwHthFx3/openapi.json