# Email Finder - Name + Domain to Work Email (`logiover/work-email-finder`) Actor

Find the most likely business email from a person's name and company domain. Ranks every common corporate pattern (first.last, flast, first…) by real-world frequency and validates the domain over DNS (MX). Pure DNS — no rate limits, no bans, always returns a result. Bulk in/out via CSV, Excel, JSON.

- **URL**: https://apify.com/logiover/work-email-finder.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Lead generation, Marketing, Automation
- **Stats:** 23 total users, 13 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 results

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

<h1 align="center">📧 Email Finder — Name + Company Domain → Work Email</h1>

<p align="center">
  <b>Find anyone's work email from just their name and company domain.</b><br>
  This email finder <b>learns each company's real email format from its own website</b>, returns published addresses when they exist, and validates every domain over DNS — so you reach real inboxes, not dead guesses.
</p>

<p align="center">
  <img alt="No API key" src="https://img.shields.io/badge/API_Key-Not_Required-2ea44f">
  <img alt="Pricing" src="https://img.shields.io/badge/From-%243.50%20%2F%201%2C000-1f6feb">
  <img alt="Bulk" src="https://img.shields.io/badge/Bulk-Unlimited-e36209">
  <img alt="MX validated" src="https://img.shields.io/badge/Domains-MX_Validated-8250df">
  <img alt="Formats" src="https://img.shields.io/badge/Export-CSV%20%7C%20JSON%20%7C%20Excel-0969da">
  <img alt="No login" src="https://img.shields.io/badge/Login-None-2ea44f">
</p>

***

### 🔍 What is this Email Finder?

**Email Finder** is a bulk **email lookup tool** that turns a list of names and company domains into real, reachable **work email addresses**. Give it `Anna Roth, acme.com` and it returns the most likely **business email** for that person — with a confidence score, ranked alternatives, and proof of how it was found.

Unlike basic tools that slap `first.last@` on every name, this **email address finder** reads each company's website, **discovers the real email pattern the company uses**, and applies it — the same way premium tools like Hunter and Apollo work, but with **no API key, no login, no monthly subscription, and no credit caps.** Pay only per result, **from $3.50 per 1,000 emails.**

> 💡 **Use it for:** cold email, B2B sales prospecting, lead generation, recruiting, and CRM enrichment — anywhere you need to **find a work email by name and company**.

***

### ⚙️ How the Email Finder works — a 4-layer ladder

The Finder works down a ladder of decreasing certainty and **tells you exactly which rung it used** (the `method` field), so you always know how much to trust a result.

<table>
  <thead>
    <tr><th>#</th><th>Method</th><th>What happens</th><th>Confidence</th></tr>
  </thead>
  <tbody>
    <tr>
      <td>1️⃣</td><td><b><code>found_on_site</code></b></td>
      <td>The person's email is <b>published on the company site</b> (contact / about / team). Returned <b>verbatim</b> — a real, verified address.</td>
      <td>~96</td>
    </tr>
    <tr>
      <td>2️⃣</td><td><b><code>discovered_pattern</code></b></td>
      <td>The company publishes <b>other</b> real emails, so the Finder <b>learns its true format</b> (sees <code>mark.davies@acme.com</code> → learns Acme uses <code>first.last</code>) and applies it to your person.</td>
      <td>75–92</td>
    </tr>
    <tr>
      <td>3️⃣</td><td><b><code>frequency_guess</code></b></td>
      <td>The site publishes nothing usable, so it falls back to the <b>most common corporate pattern</b> — and clearly labels it as a guess.</td>
      <td>19–33</td>
    </tr>
    <tr>
      <td>4️⃣</td><td><b>Domain validation</b></td>
      <td><b>Always on.</b> Every candidate domain is checked for <b>MX (mail server) records</b> over DNS, so unreachable domains are flagged before you send.</td>
      <td>—</td>
    </tr>
  </tbody>
</table>

**The result:** real answers where the data exists, honest best-guesses where it doesn't, and an **MX validation** on every single row.

***

### 🎯 Confidence score, explained

The `confidence` field (0–100) combines **how the email was found** with **whether the domain accepts mail**:

- **80+** → send with confidence
- **30–80** → verify, then send
- **under 30** → treat as a lead to confirm, not a confirmed address

***

### 📬 Email patterns it understands

For **John Smith** at `acme.com`, the Finder ranks and applies these corporate **email formats**:

| Pattern | Example | Frequency |
|---|---|---|
| `first.last` | john.smith@acme.com | ~33% |
| `first` | john@acme.com | ~19% |
| `flast` | jsmith@acme.com | ~14% |
| `firstlast` | johnsmith@acme.com | ~9% |
| `first_last` | john\_smith@acme.com | ~5% |
| `f.last` | j.smith@acme.com | ~5% |
| `firstl` · `first.l` · `last.first` · `lastfirst` · `last` · `first-last` | … | ~1–4% each |

When a company's **real email pattern** is discovered on its site, that format jumps to the top with high confidence.

***

### 📤 What you get — output fields

<table>
  <thead><tr><th>Field</th><th>Description</th></tr></thead>
  <tbody>
    <tr><td><code>mostLikelyEmail</code></td><td>The single best work email for this person</td></tr>
    <tr><td><code>confidence</code></td><td>0–100 score for the top result</td></tr>
    <tr><td><code>method</code></td><td><code>found_on_site</code> · <code>discovered_pattern</code> · <code>frequency_guess</code></td></tr>
    <tr><td><code>pattern</code></td><td>The email format applied (e.g. <code>first.last</code>)</td></tr>
    <tr><td><code>patternEvidence</code></td><td>The real published email(s) the pattern was learned from</td></tr>
    <tr><td><code>candidates</code></td><td>Every plausible format, ranked, each with <code>email</code> + <code>probability</code></td></tr>
    <tr><td><code>status</code></td><td><code>found</code> · <code>pattern_discovered</code> · <code>guessed</code> · <code>personal_domain</code> · <code>invalid_domain</code></td></tr>
    <tr><td><code>domainHasMx</code> / <code>mxHost</code></td><td>Whether the domain accepts mail, and its mail server</td></tr>
    <tr><td><code>fullName</code> · <code>firstName</code> · <code>lastName</code> · <code>domain</code></td><td>Parsed input</td></tr>
  </tbody>
</table>

#### 🧪 Example — discovered pattern (high confidence)

```json
{
  "fullName": "Anna Roth",
  "domain": "acme.com",
  "mostLikelyEmail": "anna.roth@acme.com",
  "confidence": 86,
  "method": "discovered_pattern",
  "pattern": "first.last",
  "patternEvidence": ["mark.davies@acme.com"],
  "domainHasMx": true,
  "mxHost": "aspmx.l.google.com",
  "candidates": [
    { "pattern": "first.last", "email": "anna.roth@acme.com", "probability": 86 },
    { "pattern": "first", "email": "anna@acme.com", "probability": 19 },
    { "pattern": "flast", "email": "aroth@acme.com", "probability": 14 }
  ]
}
```

***

### 📥 How to use — 3 ways to feed it

1. **A simple list** — one person per line as `Full Name, domain`:
   ```
   Anna Roth, acme.com
   Marques Brownlee, mkbhd.com
   Sarah Johnson, stripe.com
   ```
2. **Pasted text** — drop a whole block into *People (paste)*; commas, semicolons, or pipes all work.
3. **Objects from another Actor** — pipe records with `firstName` / `lastName` / `fullName` + `domain` straight from a **LinkedIn scraper**, **company scraper**, or **Google Maps scraper**.

Then click **Start** — every person comes back with their best email, the method used, confidence, and ranked alternatives. Export to **CSV, Excel, or JSON**, or pull via the API.

***

### 💼 Email finder use cases

- **Cold email & outbound sales** — turn a prospect list into reachable inboxes with a confidence score on each.
- **B2B lead generation** — add validated **work emails** to any list of names and companies.
- **Recruiting & talent sourcing** — reach candidates and hiring managers directly.
- **Agency & partnership outreach** — go from a roster to real contacts.
- **CRM enrichment & hygiene** — re-derive and re-validate emails for stale records.
- **Account-based marketing** — build verified contact lists for target accounts.

***

### 🔗 Integrations & automation

Wire the Email Finder into your stack: **Apify API / SDK** (Python & Node), **Make**, **Zapier**, **n8n**, **webhooks**, and **scheduling**. Chain it in an enrichment pipeline:

> **Company / LinkedIn scraper → 📧 Email Finder → ✅ Bulk Email Verifier → your sequencer**

***

### 🆚 Why this over other email finders

| | **This Finder** | Typical guesser | Hunter / Apollo |
|---|---|---|---|
| Learns the company's **real** format | ✅ live site | ❌ always `first.last` | ✅ database |
| Returns **published** addresses | ✅ | ❌ | ✅ |
| **MX validation** on every row | ✅ | sometimes | ✅ |
| Transparent method + evidence | ✅ | ❌ | partial |
| API key required | ❌ | ❌ | ✅ |
| Monthly fee / credit cap | ❌ | varies | ✅ $49+/mo |
| **Price** | **from $3.50 / 1,000** | varies | subscription |

***

### 💰 Pricing

Pay **per result — from $3.50 per 1,000 emails.** No subscription, no API fees, no monthly credit ceiling. Compared to a **$49–$99/month** email-finder SaaS seat with hard caps, bulk runs here cost a fraction.

***

### ✅ Honest note on accuracy

A live-crawl email finder is **not** a giant historical database. Big SaaS companies that hide every address behind JavaScript will fall back to a **frequency guess** (clearly labeled). Its accuracy sweet spot is exactly what cold email targets: **agencies, service firms, manufacturers, consultancies, local and mid-market companies** that publish real contact emails. Every result — discovered or guessed — is **domain-validated** and carries an **honest confidence score**. For a final deliverability pass, pair it with **Bulk Email Verifier**.

***

### ⚖️ Compliance

This Actor reads only publicly available data and **does not send email**. You are responsible for lawful outreach under **GDPR / ePrivacy**, **CAN-SPAM**, **CASL** and similar — including lawful basis, clear identification, and a working opt-out.

***

### ❓ FAQ

<details>
<summary><b>How do I find someone's work email from their name and company?</b></summary>
<br>Enter <code>Full Name, company-domain.com</code>. The Finder checks the company's website for the real address or its email format, applies it, validates the domain over DNS, and returns the most likely email with a confidence score.
</details>

<details>
<summary><b>Is this better than guessing first.last@company.com?</b></summary>
<br>Yes. When a company publishes any real emails, the Finder learns their <i>actual</i> format instead of assuming. When nothing is published, it falls back to the most common pattern and says so — and still validates the domain.
</details>

<details>
<summary><b>Do I need an API key or subscription?</b></summary>
<br>No. No API key, no login, no monthly fee, no credit cap. You pay per result, from $3.50 per 1,000.
</details>

<details>
<summary><b>Can it process large lists in bulk?</b></summary>
<br>Yes — it's bulk by design. Domains run in parallel and each company site is read once. There are no rate limits on the DNS side.
</details>

<details>
<summary><b>Why are some results empty?</b></summary>
<br>Two clean cases, both flagged in <code>status</code>: free providers (gmail, outlook — personal emails don't follow name patterns) and non-existent / no-mail-server domains. They're returned so you can filter them, not dropped silently.
</details>

<details>
<summary><b>Are the emails guaranteed correct?</b></summary>
<br><code>found_on_site</code> results are real published addresses. <code>discovered_pattern</code> applies the company's own verified format. <code>frequency_guess</code> is a statistical best guess (labeled). Pair with an email verifier before large sends.
</details>

<details>
<summary><b>Does it work for non-English names?</b></summary>
<br>Yes. Names are normalized (accents stripped, lowercased), so <code>José Núñez</code> becomes <code>jose.nunez@…</code>.
</details>

<details>
<summary><b>What's the difference between an email finder and an email verifier?</b></summary>
<br>A <b>finder</b> derives the likely address from a name + domain. A <b>verifier</b> checks whether a given address is deliverable. Use them together: find here, then verify with <b>Bulk Email Verifier</b>.
</details>

***

### 🔧 Related Actors

- **Bulk Email Verifier** — validate and clean found emails (MX, disposable, role, syntax) before outreach.
- **Company / LinkedIn / Google Maps scrapers** — feed names + domains straight into this Finder.

<p align="center"><b>Find the email → verify it → reach the right inbox — without a single API key.</b></p>

### 📝 Changelog

#### 2026-08-01

- Completed the August 2026 full health check: verified empty/programmatic default, Console UI default, and two source-informed alternative inputs on Apify.
- Confirmed successful live execution, non-empty structured output, dataset-field/type integrity, and logical sample quality within the 5-minute quality window.
- Declared 15 dataset fields from typed live cloud samples so the output contract is no longer an empty placeholder.
- Declared 15 nullable dataset fields from typed live cloud samples so the output contract is no longer an empty placeholder or brittle to sparse modes.

# Actor input Schema

## `people` (type: `array`):

One entry per person as "Full Name, company-domain.com" (comma, semicolon or pipe separated). Example: "John Smith, acme.com". You can also pipe in objects with firstName/lastName/fullName + domain fields from another Actor. Optional — leave empty to run against a small default set of well-known companies so you can see sample output.

## `peopleText` (type: `string`):

Optionally paste one person per line as "Full Name, domain.com". Combined with the list above.

## `discoverPattern` (type: `boolean`):

Fetch each company's website (home + contact/about/team) to find real published emails and learn its actual format (e.g. first.last vs flast) — instead of only guessing. Falls back to the most common pattern when a site publishes nothing. Turn off for pure-DNS speed.

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

How many domains to process in parallel (1–15).

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

Apify Proxy for the website-discovery fetches. Datacenter is fine and cheap; not used for DNS lookups.

## Actor input object example

```json
{
  "people": [
    "Marques Brownlee, mkbhd.com",
    "Tim Cook, apple.com",
    "John Collison, stripe.com"
  ],
  "discoverPattern": true,
  "concurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

All records extracted by this run. Open the Dataset tab to browse, filter, and export as CSV, JSON, or Excel.

# 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 = {
    "people": [
        "Marques Brownlee, mkbhd.com",
        "Tim Cook, apple.com",
        "John Collison, stripe.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/work-email-finder").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 = {
    "people": [
        "Marques Brownlee, mkbhd.com",
        "Tim Cook, apple.com",
        "John Collison, stripe.com",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/work-email-finder").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "people": [
    "Marques Brownlee, mkbhd.com",
    "Tim Cook, apple.com",
    "John Collison, stripe.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call logiover/work-email-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=logiover/work-email-finder",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/3pcY6gLjn4A5zGUTe/builds/ghwq6ag8Pu6lnRE0z/openapi.json