# Email Finder: Work Emails from Name and Company Domain (`alexmorain/email-finder`) Actor

Find verified work emails from a full name and a company domain, website or company name. Catch-all check per domain, confidence level, mail provider, CSV input. Webmails and duplicates filtered for free. Pay only for emails found.

- **URL**: https://apify.com/alexmorain/email-finder.md
- **Developed by:** [Alexis Morain](https://apify.com/alexmorain) (community)
- **Categories:** Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 emails

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/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

## Email Finder: Work Emails from Name and Company Domain

Email Finder takes a list of people, each with a name and a company (domain, website or company name), and returns their work email with a status, a confidence level and the checks behind it. You pay only for the emails found: rows without an email, skipped rows and duplicates cost nothing.

Paste a few people in the input, or point the Actor to a CSV file or a published Google Sheet. Each row comes back with the email, `valid` or `risky`, a confidence level, whether the domain accepts any address (catch-all), whether the email is on the domain you asked for, and the mail provider of the company.

### What does Email Finder do?

- **Finds the work email of a person** from a full name (or first and last name) and a company domain, website or company name.
- **Cleans your list before any lookup, for free.** Rows without a name or a company, webmail and ISP domains (gmail.com, outlook.com, yahoo.com, orange.fr and many more) and duplicates are skipped and never charged.
- **Resolves a company name to its domain** when you only have the name. The domain is kept only when the name matches, legal forms aside (Inc, SAS, GmbH, Ltd...). A wrong guess would produce wrong emails, so an unsure match is skipped.
- **Checks catch-all domains.** Some mail servers accept any address, so a `risky` email there proves little. Each domain that returned a risky email is tested once with an invented name. Emails on such domains get `confidence: low`. This check is free for you.
- **Flags emails on another domain.** A provider can return an email on a sister domain (`@company.fr` when you asked for `company.com`). The `emailDomainMatch` field says so, and the confidence drops to `low`.
- **Names the mail provider** of the company from its MX record: Google, Microsoft, Proofpoint, Mimecast, Cisco IronPort, Barracuda.
- **Optional deep search.** When the standard providers find nothing, `deepSearch` asks four more providers. Emails found this way are charged at a higher price, and only those.
- **Reuses your past results.** A person looked up in the last 30 days is served from a cache stored in your own Apify account.

### Why use Email Finder?

- **You pay for results, not for attempts.** A not-found row is free, a skipped row is free, a duplicate is free.
- **Each email comes with its evidence.** Status, confidence, catch-all flag, domain match and the provider that found it: you decide what to send to and what to verify again.
- **It fits in a workflow.** One call per list from n8n, Make, Zapier, Clay or your own code, a webhook at the end of the run, and the original `customId` and `linkedinUrl` returned as given so you can join the rows back to your CRM.
- **Several providers behind one input.** The standard lookup tries three email finders in turn. The deep search adds four more. You do not need an account with any of them.

### What data can you extract?

| Field | Description |
|---|---|
| `fullName`, `firstName`, `lastName` | The name as you gave it |
| `domain` | The company domain used for the lookup |
| `companyName` | The company name as you gave it |
| `domainSource` | `input` (domain given), `website` (taken from the website) or `company_lookup` (resolved from the company name) |
| `linkedinUrl`, `customId` | Returned as you gave them |
| `email` | The work email, or null |
| `found` | true when an email was found |
| `status` | `valid`, `risky`, `not_found`, `error` or a `skipped_...` reason (see below) |
| `confidence` | `high`, `medium` or `low` (see below), null when no email |
| `emailDomainMatch` | true when the email is on the domain you asked for |
| `provider` | The provider that found the email |
| `catchAllDomain` | true when the domain accepts any address, null when not tested |
| `validSmtp`, `validIdentity` | Mailbox and identity checks, when the provider returns them |
| `mxDomain`, `mailProvider` | The mail server of the domain and its family (google, microsoft...) |
| `cached` | true when the row came from your account's cache |
| `rowNumber` | Position of the row in your input |
| `checkedAt` | When the email was looked up |

#### Status

| Status | Meaning | Charged |
|---|---|---|
| `valid` | The mail server confirmed the mailbox | Yes |
| `risky` | An email was found but the server did not confirm it | Yes |
| `not_found` | No provider found an email | No |
| `error` | A provider failed for this row | No |
| `skipped_invalid_input` | No name, or no company | No |
| `skipped_personal_domain` | Webmail or ISP domain (gmail.com, orange.fr...) | No |
| `skipped_company_not_resolved` | The company name did not match a domain | No |
| `skipped_max_lookups` | Over your **Max lookups** limit | No |
| `skipped_free_plan_limit` | Over the 25 lookups of the Free Apify plan | No |

#### Confidence

- `high`: the email is `valid`.
- `medium`: the email is `risky` on a normal domain.
- `low`: the email is `risky` on a catch-all domain, or it is on another domain than the one you asked for.

### How to find a work email from a name and a domain

1. Open the Actor and fill **People** with one object per person, for example `{"fullName": "Erol Toker", "domain": "trykitt.ai"}`.
2. Or give a **CSV file URL**. For a Google Sheet, use *File > Share > Publish to web > CSV*.
3. Leave **Catch-all check** on. Turn **Deep search** on if you want more emails at a higher price.
4. Click **Start**. The emails appear in the dataset; export them as CSV, Excel or JSON, or read them from the API.

### Input

| Field | Type | Description |
|---|---|---|
| `people` | array | One object per person. Name: `fullName`, or `firstName` + `lastName`. Company: `domain`, `website` or `companyName`. Optional `linkedinUrl` and `customId` |
| `csvUrl` | string | Public URL of a CSV file, read in addition to `people` |
| `catchAllCheck` | boolean | Test each domain that returned a risky email for catch-all. Default true, free |
| `deepSearch` | boolean | Ask four more providers when the standard ones find nothing. Default false |
| `maxLookups` | integer | Stop after this many new lookups. Cached rows do not count |
| `webhookUrl` | string | A POST with the run summary is sent here when the run ends |

The CSV file can be comma or semicolon separated. Recognised headers, case and spaces ignored: `full name`, `name`, `first name`, `last name`, `company`, `company name`, `domain`, `website`, `url`, `linkedin url`, `id`.

Example input:

```json
{
  "people": [
    { "fullName": "Erol Toker", "domain": "trykitt.ai", "customId": "crm-1042" },
    { "firstName": "Jane", "lastName": "Doe", "website": "https://www.example.com" },
    { "fullName": "John Smith", "companyName": "Acme Inc" }
  ],
  "catchAllCheck": true,
  "deepSearch": false
}
```

### Output example

```json
{
  "fullName": "Erol Toker",
  "firstName": null,
  "lastName": null,
  "domain": "trykitt.ai",
  "companyName": null,
  "domainSource": "input",
  "linkedinUrl": null,
  "customId": null,
  "email": "erol@trykitt.ai",
  "found": true,
  "status": "valid",
  "confidence": "high",
  "emailDomainMatch": true,
  "provider": "kitt",
  "catchAllDomain": null,
  "validSmtp": true,
  "validIdentity": true,
  "mxDomain": "aspmx.l.google.com",
  "mailProvider": "google",
  "cached": false,
  "rowNumber": 1,
  "checkedAt": "2026-11-18T13:00:30.614227+00:00"
}
```

Each run also writes a `SUMMARY` record in its key-value store: rows received, duplicates removed, skipped rows by reason, lookups, rows served from cache, emails found (standard and deep), valid, risky, not found, errors, found rate and the reason the run stopped early, if it did.

### Deep search

The standard lookup asks three email finders, one after the other, and stops at the first email. When none of them finds anything, `deepSearch: true` asks four more: Enrow, Tomba, Findymail and Hunter. On a test set of 7 people the standard providers missed, the deep providers found 4 or 5 each.

Only the emails found by the deep search are charged at the deep price. An email found by the standard providers stays at the standard price, even with `deepSearch` on. A person not found by a standard run in the last 7 days is tried again by a deep run, not served from the cache.

### How much does it cost to find work emails?

The Actor uses pay-per-event pricing. You pay for the start of the run and for each email found. Prices fall with your Apify plan.

| Event | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| Actor start (per GB of memory, 256 MB by default) | 0.002 USD | 0.002 USD | 0.002 USD | 0.002 USD |
| Email (standard providers or cache) | 12 USD per 1,000 | 12 USD | 10.50 USD | 10 USD |
| Deep search email | 45 USD per 1,000 | 45 USD | 40 USD | 35 USD |

Rows with no email, skipped rows, duplicates and errors are not charged. The catch-all test is not charged. An email served from your cache is charged at the standard price, without a new lookup.

Examples at the Free plan price: 1,000 people with 600 emails found cost about 7.20 USD. With deep search on, if it finds 150 more, those add 6.75 USD.

You can set a maximum charge per run in the run options. The Actor checks it before each lookup, stops when the next email would not fit, and the summary says `buyer_limit`.

#### Free Apify plan

On the Free Apify plan, 25 new lookups per 30 days are included. Rows over that are marked `skipped_free_plan_limit` and not charged. Any paid Apify plan removes the limit. Rows served from the cache do not count.

### Tips and limits

**Start small.** Run 20 people you know, look at the statuses, then send the full list.

**Give the domain when you have it.** The company name is resolved through a public company lookup, and only an exact name match is kept. A domain or website is faster and never skipped.

**Read `risky` for what it is.** A risky email was found but the mail server would not confirm the mailbox. Many companies set their servers this way. On a catch-all domain (`confidence: low`), the address may be right or wrong: verify it, or send to it at a low volume first.

**A found email does not prove the person still works there.** Providers build emails from public sources. Someone who left a company months ago can still get an email on its domain, sometimes `valid` if the mailbox was kept open.

**Expect around half to three quarters found.** On a test of 150 real people, the first provider alone found 51% of the French profiles and 75% of the international ones. The cascade and the deep search raise that. The rate depends on your list: small companies, recent hires and private domains find less.

**Mail provider fields come from one provider only.** `mxDomain` and `mailProvider` are filled when the first standard provider returns them. They can be null on an email found by another provider.

**Very low found rates stop the run.** After 40 lookups, if fewer than 10% found an email, the Actor stops and says why (`low_found_rate`). A list where few rows find an email is usually wrong in its shape: company names in the domain column, personal names missing, or a list of generic addresses.

**Large lists.** One run takes up to 100,000 rows. A run close to its timeout stops before it is killed, keeps the rows delivered so far, and says `timeout` in the summary. If the platform moves the run to another server, it resumes without charging the same row twice.

**Cache.** Found emails are cached 30 days, not-found rows 7 days, catch-all results 30 days, in a store of your own Apify account. Nobody else reads it.

### Use it from code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("alexmorain/email-finder").call(run_input={
    "people": [
        {"fullName": "Erol Toker", "domain": "trykitt.ai", "customId": "crm-1042"},
        {"firstName": "Jane", "lastName": "Doe", "companyName": "Acme Inc"},
    ],
    "deepSearch": True,
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["customId"], row["email"], row["status"], row["confidence"])
```

JavaScript:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('alexmorain/email-finder').call({
  csvUrl: 'https://docs.google.com/spreadsheets/d/e/<ID>/pub?output=csv',
  maxLookups: 500,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.filter((r) => r.found).length, 'emails found');
```

cURL, synchronous call that returns the rows:

```bash
curl -X POST "https://api.apify.com/v2/acts/alexmorain~email-finder/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"people": [{"fullName": "Erol Toker", "domain": "trykitt.ai"}]}'
```

The synchronous call fits a single lookup in n8n, Make or Zapier. For a list, start the run and read the dataset when the webhook arrives.

### Frequently asked questions

#### How do I find someone's work email from their name and company?

Give the full name and the company domain (or website, or company name) in **People**, or in a CSV file. The Actor returns the email with its status and confidence.

#### What is the difference between valid and risky?

`valid`: the mail server confirmed the mailbox exists. `risky`: an email was found but the server did not confirm it, often because it accepts every address or refuses to answer. Look at `confidence` and `catchAllDomain` before sending.

#### Do I pay for emails that are not found?

No. Only rows with an email are charged. Not-found rows, skipped rows, duplicates and errors are free.

#### Can I use a LinkedIn URL instead of a name?

Not on its own. The Actor needs a name and a company. A `linkedinUrl` you give is returned with the row so you can match it back.

#### Can I upload a CSV or a Google Sheet?

Yes. Give the public URL of the CSV in **CSV file URL**. For a Google Sheet, publish it to the web as CSV and use that link.

#### Does it find personal emails or phone numbers?

No. It looks for work emails on the company domain only. Rows with a personal domain (gmail.com and the like) are skipped for free.

#### Something is wrong or missing

Open an issue on the Actor page with the run ID and one example row. I read them and answer.

### Legal note

This Actor returns professional contact data about identified people. In the EU and the UK, that is personal data. You are responsible for having a lawful basis to process it (GDPR article 6, usually legitimate interest for B2B prospecting), for informing the people you contact where the data came from (article 14), and for honouring opt-out requests. Local rules on cold email apply too: check them before you send. Do not use it to contact people who asked not to be contacted.

### Guide and use cases

Use cases for outbound and automation, the output fields, pricing and common questions are on the [Email Finder page](https://alexis.morain.fr/en/scrapers/email-finder/) of my site. The [Lead generation family page](https://alexis.morain.fr/en/scrapers/families/lead-generation/) puts it side by side with the other scrapers of the same family.

# Actor input Schema

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

One object per person. Name: <code>fullName</code>, or <code>firstName</code> + <code>lastName</code>. Company: <code>domain</code>, <code>website</code> or <code>companyName</code> (resolved to its domain). Optional <code>linkedinUrl</code> and <code>customId</code> are returned as given.<br>Rows without a name or company, webmail domains (gmail.com, outlook.com, orange.fr...) and duplicates are skipped and never charged.

## `csvUrl` (type: `string`):

Public URL of a CSV file, comma or semicolon separated, read in addition to <b>People</b>. Recognised headers (case and spaces ignored): <code>full name</code>, <code>name</code>, <code>first name</code>, <code>last name</code>, <code>company</code>, <code>company name</code>, <code>domain</code>, <code>website</code>, <code>url</code>, <code>linkedin url</code>, <code>id</code>. For a Google Sheet, use its <i>File > Share > Publish to web > CSV</i> link.

## `catchAllCheck` (type: `boolean`):

Some company mail servers accept any address, so a 'risky' email there proves nothing. When on, each domain that returned a risky email is tested once with an invented name: emails on such domains get <code>confidence: low</code>. Free for you.

## `deepSearch` (type: `boolean`):

When the standard providers find no email, try four more providers (Enrow, Tomba, Findymail, Hunter). Emails found this way are charged as <b>Deep search email</b>, at a higher price. Off by default.

## `maxLookups` (type: `integer`):

Stop after this many new lookups (emails served from your account's cache do not count). Leave empty for no limit.

## `webhookUrl` (type: `string`):

Optional. A POST with the run summary is sent here when the run ends (Slack, Discord, n8n, Make, Zapier). The URL never appears in logs.

## Actor input object example

```json
{
  "people": [
    {
      "fullName": "Erol Toker",
      "domain": "trykitt.ai"
    }
  ],
  "catchAllCheck": true,
  "deepSearch": false
}
```

# Actor output Schema

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

All rows in the default dataset.

## `summary` (type: `string`):

Rows received, duplicates, skipped rows by reason, lookups, cache hits, emails found, catch-all domains, stop reason.

# 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": [
        {
            "fullName": "Erol Toker",
            "domain": "trykitt.ai"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("alexmorain/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": [{
            "fullName": "Erol Toker",
            "domain": "trykitt.ai",
        }] }

# Run the Actor and wait for it to finish
run = client.actor("alexmorain/email-finder").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 '{
  "people": [
    {
      "fullName": "Erol Toker",
      "domain": "trykitt.ai"
    }
  ]
}' |
apify call alexmorain/email-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,alexmorain/email-finder"
        }
    }
}
```

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/S2e0ZMgxKEYRsePfw/builds/ILMuQ3Gkfm2kgVpc8/openapi.json
