# 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:** 4 total users, 1 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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):
```bash
npm install apify-client
```
In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):
```bash
pip install apify-client
```
In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):
````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash
In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).
If your project is in a different language, use 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
π§ Email Finder β Name + Company Domain β Work Email
Find anyone's work email from just their name and company domain.
This email finder learns each company's real email format from its own website, returns published addresses when they exist, and validates every domain over DNS β so you reach real inboxes, not dead guesses.
---
### π 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.
| # | Method | What happens | Confidence |
|---|
| 1οΈβ£ | found_on_site |
The person's email is published on the company site (contact / about / team). Returned verbatim β a real, verified address. |
~96 |
| 2οΈβ£ | discovered_pattern |
The company publishes other real emails, so the Finder learns its true format (sees mark.davies@acme.com β learns Acme uses first.last) and applies it to your person. |
75β92 |
| 3οΈβ£ | frequency_guess |
The site publishes nothing usable, so it falls back to the most common corporate pattern β and clearly labels it as a guess. |
19β33 |
| 4οΈβ£ | Domain validation |
Always on. Every candidate domain is checked for MX (mail server) records over DNS, so unreachable domains are flagged before you send. |
β |
**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
| Field | Description |
|---|
mostLikelyEmail | The single best work email for this person |
confidence | 0β100 score for the top result |
method | found_on_site Β· discovered_pattern Β· frequency_guess |
pattern | The email format applied (e.g. first.last) |
patternEvidence | The real published email(s) the pattern was learned from |
candidates | Every plausible format, ranked, each with email + probability |
status | found Β· pattern_discovered Β· guessed Β· personal_domain Β· invalid_domain |
domainHasMx / mxHost | Whether the domain accepts mail, and its mail server |
fullName Β· firstName Β· lastName Β· domain | Parsed input |
#### π§ͺ 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
How do I find someone's work email from their name and company?
Enter Full Name, company-domain.com. 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.
Is this better than guessing first.last@company.com?
Yes. When a company publishes any real emails, the Finder learns their actual format instead of assuming. When nothing is published, it falls back to the most common pattern and says so β and still validates the domain.
Do I need an API key or subscription?
No. No API key, no login, no monthly fee, no credit cap. You pay per result, from $3.50 per 1,000.
Can it process large lists in bulk?
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.
Why are some results empty?
Two clean cases, both flagged in status: 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.
Are the emails guaranteed correct?
found_on_site results are real published addresses. discovered_pattern applies the company's own verified format. frequency_guess is a statistical best guess (labeled). Pair with an email verifier before large sends.
Does it work for non-English names?
Yes. Names are normalized (accents stripped, lowercased), so JosΓ© NΓΊΓ±ez becomes jose.nunez@β¦.
What's the difference between an email finder and an email verifier?
A finder derives the likely address from a name + domain. A verifier checks whether a given address is deliverable. Use them together: find here, then verify with Bulk Email Verifier.
***
### π§ 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.
Find the email β verify it β reach the right inbox β without a single API key.
# 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.
## `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 '' with your token
const client = new ApifyClient({
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 '' with your token.
client = ApifyClient("")
# 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 "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Email Finder - Name + Domain to Work Email",
"description": "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.",
"version": "1.2",
"x-build-id": "dNUHv5b4FKkCdxCIJ"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/logiover~work-email-finder/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-logiover-work-email-finder",
"x-openai-isConsequential": false,
"summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK"
}
}
}
},
"/acts/logiover~work-email-finder/runs": {
"post": {
"operationId": "runs-sync-logiover-work-email-finder",
"x-openai-isConsequential": false,
"summary": "Executes an Actor and returns information about the initiated run in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/runsResponseSchema"
}
}
}
}
}
}
},
"/acts/logiover~work-email-finder/run-sync": {
"post": {
"operationId": "run-sync-logiover-work-email-finder",
"x-openai-isConsequential": false,
"summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK"
}
}
}
}
},
"components": {
"schemas": {
"inputSchema": {
"type": "object",
"properties": {
"people": {
"title": "People (Name, domain)",
"type": "array",
"description": "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.",
"default": [],
"items": {
"type": "string"
}
},
"peopleText": {
"title": "People (paste)",
"type": "string",
"description": "Optionally paste one person per line as \"Full Name, domain.com\". Combined with the list above."
},
"discoverPattern": {
"title": "Discover the company's real email pattern",
"type": "boolean",
"description": "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.",
"default": true
},
"concurrency": {
"title": "Concurrency",
"minimum": 1,
"maximum": 15,
"type": "integer",
"description": "How many domains to process in parallel (1β15).",
"default": 5
},
"proxyConfiguration": {
"title": "Proxy configuration",
"type": "object",
"description": "Apify Proxy for the website-discovery fetches. Datacenter is fine and cheap; not used for DNS lookups.",
"default": {
"useApifyProxy": true,
"apifyProxyGroups": [
"RESIDENTIAL"
]
}
}
}
},
"runsResponseSchema": {
"type": "object",
"properties": {
"data": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"actId": {
"type": "string"
},
"userId": {
"type": "string"
},
"startedAt": {
"type": "string",
"format": "date-time",
"example": "2025-01-08T00:00:00.000Z"
},
"finishedAt": {
"type": "string",
"format": "date-time",
"example": "2025-01-08T00:00:00.000Z"
},
"status": {
"type": "string",
"example": "READY"
},
"meta": {
"type": "object",
"properties": {
"origin": {
"type": "string",
"example": "API"
},
"userAgent": {
"type": "string"
}
}
},
"stats": {
"type": "object",
"properties": {
"inputBodyLen": {
"type": "integer",
"example": 2000
},
"rebootCount": {
"type": "integer",
"example": 0
},
"restartCount": {
"type": "integer",
"example": 0
},
"resurrectCount": {
"type": "integer",
"example": 0
},
"computeUnits": {
"type": "integer",
"example": 0
}
}
},
"options": {
"type": "object",
"properties": {
"build": {
"type": "string",
"example": "latest"
},
"timeoutSecs": {
"type": "integer",
"example": 300
},
"memoryMbytes": {
"type": "integer",
"example": 1024
},
"diskMbytes": {
"type": "integer",
"example": 2048
}
}
},
"buildId": {
"type": "string"
},
"defaultKeyValueStoreId": {
"type": "string"
},
"defaultDatasetId": {
"type": "string"
},
"defaultRequestQueueId": {
"type": "string"
},
"buildNumber": {
"type": "string",
"example": "1.0.0"
},
"containerUrl": {
"type": "string"
},
"usage": {
"type": "object",
"properties": {
"ACTOR_COMPUTE_UNITS": {
"type": "integer",
"example": 0
},
"DATASET_READS": {
"type": "integer",
"example": 0
},
"DATASET_WRITES": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_READS": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_WRITES": {
"type": "integer",
"example": 1
},
"KEY_VALUE_STORE_LISTS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_READS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_WRITES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_INTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_EXTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_SERPS": {
"type": "integer",
"example": 0
}
}
},
"usageTotalUsd": {
"type": "number",
"example": 0.00005
},
"usageUsd": {
"type": "object",
"properties": {
"ACTOR_COMPUTE_UNITS": {
"type": "integer",
"example": 0
},
"DATASET_READS": {
"type": "integer",
"example": 0
},
"DATASET_WRITES": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_READS": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_WRITES": {
"type": "number",
"example": 0.00005
},
"KEY_VALUE_STORE_LISTS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_READS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_WRITES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_INTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_EXTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_SERPS": {
"type": "integer",
"example": 0
}
}
}
}
}
}
}
}
}
}
```