# Email Finder — Name + Domain to Work Email + Score (`bovi/email-finder`) Actor

Find a person's likely work email from their name + company domain. Returns an MX-validated best-guess address with a numeric confidence score, role & disposable flags, and ranked alternative candidates — not a single bare guess.

- **URL**: https://apify.com/bovi/email-finder.md
- **Developed by:** [Vitalii Bondarev](https://apify.com/bovi) (community)
- **Categories:** Lead generation, Developer tools, Business
- **Stats:** 4 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.50 / 1,000 email results

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/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 + Domain → Best-Guess Work Email

Give this actor a person's **name** and their **company domain**, and it returns the most
likely **work email** — with a numeric **confidence score**, **MX validation**, and a ranked
list of **alternative candidates**. No API key, no signup, no monthly seat.

> **What you actually get:** a *ranked, MX-gated best guess*, not a hard-confirmed mailbox.
> The actor attempts live SMTP verification, but most cloud networks (including Apify's) block
> outbound port 25, so it degrades to MX + pattern ranking and labels the method `mx_pattern`.
> SMTP confirmation only fires where the run network allows it.

### Why this one

Most email-finder actors hand back a *single guessed address* and, at best, a `catch_all`
flag. That leaves you to guess whether the address is real. This actor instead:

- **Builds frequency-ranked candidate patterns** — `first.last`, `flast`, `first`, `firstlast`,
  and ~9 more — weighted by how common each scheme actually is in corporate email.
- **Validates what it can** — one MX lookup per domain to confirm the mail server exists,
  then (where the network allows) a catch-all probe and RCPT verification of candidates in
  priority order. A confirmed mailbox is marked `verified`; on port-25-blocked networks the
  best guess is marked `unverified_guess` with its MX host and confidence.
- **Tells you the truth** — every record carries `confidence` (0–1), the `verificationMethod`
  (`smtp` / `mx_pattern` / `none`), `isCatchAll`, `isDisposable`, `isRoleAccount`, and the
  ranked `alternativeEmails` so you can fall back if the top pick bounces.

If the run network blocks outbound port 25 (common on cloud), the finder **degrades
gracefully** to MX + pattern ranking and labels the method `mx_pattern` — you still get a
ranked, MX-gated best guess instead of a hard failure.

### Input

```json
{
  "people": [
    { "firstName": "Patrick", "lastName": "Collison", "domain": "stripe.com" },
    { "firstName": "Tobias", "lastName": "Lutke", "domain": "shopify.com" }
  ],
  "verifySmtp": true,
  "maxAlternatives": 5,
  "smtpTimeoutSecs": 8,
  "maxItems": 0
}
````

| Field | Type | Notes |
|---|---|---|
| `people` | array | Each item: `firstName` (required), `lastName` or `surname`, optional `fullName`, and `domain` (required). |
| `verifySmtp` | boolean | Attempt live SMTP RCPT verification. Auto-falls back to MX + pattern if port 25 is blocked. Default `true`. |
| `maxAlternatives` | integer | Ranked alternatives returned per person. Default `5`. |
| `smtpTimeoutSecs` | integer | Per-probe SMTP timeout. Default `8`. |
| `maxItems` | integer | Total output cap, `0` = unlimited. |

### Output (per person)

```json
{
  "firstName": "patrick",
  "lastName": "collison",
  "domain": "stripe.com",
  "email": "patrick.collison@stripe.com",
  "confidence": 0.45,
  "status": "unverified_guess",
  "verificationMethod": "mx_pattern",
  "isCatchAll": null,
  "isDisposable": false,
  "isRoleAccount": false,
  "mxFound": true,
  "mxHost": "aspmx.l.google.com",
  "patternUsed": "first.last",
  "alternativeEmails": [
    { "email": "pcollison@stripe.com", "pattern": "flast", "confidence": 0.319, "smtpStatus": "not_checked", "smtpCode": null }
  ],
  "parse_confidence": 0.9,
  "warnings": ["smtp_unreachable_port25"]
}
```

> The example above is a real Apify-cloud result (port 25 blocked → `mx_pattern`). On a network
> with outbound SMTP open, `status` becomes `verified`/`accept_all`, `verificationMethod` becomes
> `smtp`, and `confidence` rises accordingly.

**`status` values:** `verified` (SMTP confirmed the mailbox) · `accept_all` (domain accepts
all mail — can't single one out) · `unverified_guess` (MX present, SMTP not usable, ranked
best guess) · `no_valid_pattern` (SMTP worked but no candidate accepted) · `no_mx` (domain has
no mail server).

### Pricing

Pay-per-result. You are charged once per person record produced — never for an invalid input.
You run it on your own Apify account, so compute is billed to you at platform cost.

### Use it from your existing tools

#### Use with Claude Desktop / Cursor / Cline (MCP)

This actor is part of the **Apify Lead Generation Suite** — a curated set of 6 actors you can load together as agent tools. Call it directly from your AI assistant via the Apify MCP server — no Store browsing needed. Paste this into your MCP client config (e.g. `claude_desktop_config.json`) and restart the client:

```json
{
  "mcpServers": {
    "apify-lead-gen": {
      "command": "npx",
      "args": [
        "-y",
        "@apify/actors-mcp-server",
        "--tools",
        "bovi/google-maps-scraper,bovi/email-finder,bovi/company-lookup-scraper,bovi/b2b-leads-list-builder,bovi/linkedin-profile-scraper,bovi/google-maps-leads"
      ],
      "env": {
        "APIFY_TOKEN": "YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

Replace `YOUR_APIFY_TOKEN` with your own Apify API token (free at apify.com → Settings → Integrations). Curated to a handful of tools so the agent selects reliably.

#### Works with Clay

Run this actor as an HTTP enrichment step inside a Clay table:

- **Method:** `POST`
- **URL:** `https://api.apify.com/v2/acts/bovi~email-finder/run-sync-get-dataset-items?token={{apify_token}}`
- **Body (JSON):** map your Clay columns to the actor input (see the Input section above), e.g. `{"people": "{{clay_column}}"}`

The run finishes synchronously and returns the dataset rows straight into your Clay table. It runs on Apify's cloud under your own token and usage. Synchronous runs must complete within 300 seconds.

# Actor input Schema

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

List of people to find emails for. Each item is an object with: firstName (required), lastName (or surname), optional fullName, and domain (required, e.g. 'stripe.com'). Example: {"firstName": "Patrick", "lastName": "Collison", "domain": "stripe.com"}.

## `verifySmtp` (type: `boolean`):

Attempt live SMTP RCPT verification so confirmed mailboxes are marked 'verified'. If your run network blocks outbound port 25, the finder automatically falls back to MX + pattern ranking. Default: true.

## `maxAlternatives` (type: `integer`):

How many ranked alternative-email candidates to return per person (each with its own confidence). Default: 5.

## `smtpTimeoutSecs` (type: `integer`):

Timeout for each SMTP connection attempt. Increase on slow mail servers. Default: 8.

## `maxItems` (type: `integer`):

Maximum total records to output. 0 = no limit. Useful for cost control. Default: 0.

## Actor input object example

```json
{
  "people": [
    {
      "firstName": "Patrick",
      "lastName": "Collison",
      "domain": "stripe.com"
    },
    {
      "firstName": "Tobias",
      "lastName": "Lutke",
      "domain": "shopify.com"
    }
  ],
  "verifySmtp": true,
  "maxAlternatives": 5,
  "smtpTimeoutSecs": 8,
  "maxItems": 0
}
```

# Actor output Schema

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

Dataset of email records (firstName, lastName, domain, email, confidence, status, verificationMethod, isCatchAll, isRoleAccount, isDisposable, patternUsed, alternativeEmails).

# 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": [
        {
            "firstName": "Patrick",
            "lastName": "Collison",
            "domain": "stripe.com"
        },
        {
            "firstName": "Tobias",
            "lastName": "Lutke",
            "domain": "shopify.com"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("bovi/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": [
        {
            "firstName": "Patrick",
            "lastName": "Collison",
            "domain": "stripe.com",
        },
        {
            "firstName": "Tobias",
            "lastName": "Lutke",
            "domain": "shopify.com",
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("bovi/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": [
    {
      "firstName": "Patrick",
      "lastName": "Collison",
      "domain": "stripe.com"
    },
    {
      "firstName": "Tobias",
      "lastName": "Lutke",
      "domain": "shopify.com"
    }
  ]
}' |
apify call bovi/email-finder --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Email Finder — Name + Domain to Work Email + Score",
        "description": "Find a person's likely work email from their name + company domain. Returns an MX-validated best-guess address with a numeric confidence score, role & disposable flags, and ranked alternative candidates — not a single bare guess.",
        "version": "0.1",
        "x-build-id": "MPHLnEgMPKeWT2Laa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bovi~email-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bovi-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/bovi~email-finder/runs": {
            "post": {
                "operationId": "runs-sync-bovi-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/bovi~email-finder/run-sync": {
            "post": {
                "operationId": "run-sync-bovi-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",
                "required": [
                    "people"
                ],
                "properties": {
                    "people": {
                        "title": "People (name + company domain)",
                        "type": "array",
                        "description": "List of people to find emails for. Each item is an object with: firstName (required), lastName (or surname), optional fullName, and domain (required, e.g. 'stripe.com'). Example: {\"firstName\": \"Patrick\", \"lastName\": \"Collison\", \"domain\": \"stripe.com\"}."
                    },
                    "verifySmtp": {
                        "title": "Verify via SMTP",
                        "type": "boolean",
                        "description": "Attempt live SMTP RCPT verification so confirmed mailboxes are marked 'verified'. If your run network blocks outbound port 25, the finder automatically falls back to MX + pattern ranking. Default: true.",
                        "default": true
                    },
                    "maxAlternatives": {
                        "title": "Max alternative emails",
                        "minimum": 0,
                        "maximum": 12,
                        "type": "integer",
                        "description": "How many ranked alternative-email candidates to return per person (each with its own confidence). Default: 5.",
                        "default": 5
                    },
                    "smtpTimeoutSecs": {
                        "title": "SMTP timeout (seconds)",
                        "minimum": 2,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Timeout for each SMTP connection attempt. Increase on slow mail servers. Default: 8.",
                        "default": 8
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum total records to output. 0 = no limit. Useful for cost control. Default: 0.",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```