# Email Pattern Finder: Name + Domain to Work Email (`steadyline/email-pattern-finder`) Actor

Turn a name and company domain into ranked work-email guesses (first.last@, flast@, first@ and the rest), with an MX check on the domain. No SMTP, no LinkedIn, no paid APIs. $2 per 1,000 people with a best guess; no-MX and not-found are free. By Steadyline Data.

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

## Pricing

from $2.00 / 1,000 email guess returneds

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/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 Pattern Finder: ranked work-email guesses from a name and company domain

Give it a person's name and a company domain (or a dataset from [Company Team Page Scraper](https://apify.com/steadyline/website-team-extractor)). It generates the usual business email patterns (`first.last@`, `flast@`, `first@`, and the rest), ranks them by how common they are, and MX-checks the domain so you only keep guesses at a domain that actually accepts mail.

This is a **pattern engine plus an MX check**. It does not open an SMTP session, scrape LinkedIn, query a people database or use a paid API. Mailbox-level confirmation is intentionally out of scope: every guess is flagged `notMailboxConfirmed: true` and `catchAllUnknown: true` (catch-all domains cannot be detected without SMTP). Pipe `bestEmail` into [Email Deliverability Checker](https://apify.com/steadyline/email-deliverability-checker) for typo, disposable and SPF/DMARC context.

- **No logins, no search engines, no third-party data brokers.**
- **Not-found is free.** People we cannot parse, domains with no mail (no MX / null MX) and DNS failures are returned but never charged.

### Use cases

- **Team-page follow-up:** take names from [Company Team Page Scraper](https://apify.com/steadyline/website-team-extractor) and produce ranked work-email guesses for each person.
- **CRM enrichment:** you already have a first name, last name and company domain and need a best-guess address to review.
- **List building after a website pass:** pair with [Website Contact Scraper](https://apify.com/steadyline/website-contact-extractor) when the site published a domain but not a named person's mailbox.

### Input

```json
{ "people": ["Jane Smith, python.org", {"firstName": "Guido", "lastName": "van Rossum", "domain": "python.org"}] }
```

Or pass `teamDatasetId` with the dataset id from a Team Page Scraper run, plus an optional `defaultDomain` for names that have no site of their own.

### Output sample

```json
{
  "name": "Jane Smith",
  "domain": "python.org",
  "bestEmail": "jane.smith@python.org",
  "pattern": "first.last",
  "confidence": 33,
  "candidates": [{"email": "jane.smith@python.org", "pattern": "first.last", "rank": 1, "score": 33, "weight": 33}],
  "mxVerified": true,
  "notMailboxConfirmed": true,
  "catchAllUnknown": true,
  "mailProvider": null,
  "status": "ok",
  "charged": true
}
```

`status` is `ok`, `unparsed-name`, `missing-domain`, `no-mx`, `null-mx`, `no-such-domain`, `dns-failed` or `not-found`.

### Pricing (pay per event)

| Event | Price | When |
|---|---|---|
| `email-guessed` | $0.002 | One person who received a ranked best-guess on a domain that accepts mail |

No-MX, not-found, unparsable names and DNS failures are **never charged**.

**Cost example:** 1,000 people with a best guess = **$2.00**.

### Use it from AI agents (MCP), Zapier, Make, n8n or the API

**AI agents (Claude, Cursor, VS Code, ChatGPT and other MCP clients).** Add Apify's hosted MCP server with just this Actor as a tool:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=steadyline/email-pattern-finder"
    }
  }
}
```

Sign in with Apify (OAuth) on first connect, or add an `Authorization: Bearer <APIFY_TOKEN>` header. Then ask your agent, for example:

> Use steadyline/email-pattern-finder to suggest the most likely work emails for Jane Smith at python.org and return the ranked candidates with MX flags.

The agent sees this Actor's input schema and output fields, so it can call it without extra prompting. Agents that use the general Apify MCP server can also find it with `search-actors`.

This Actor uses pay-per-event pricing with limited permissions, so it can also be run through Apify's agentic payments (no Apify account needed for the agent). See the [Apify docs](https://docs.apify.com/platform/integrations/mcp#agentic-payments).

**Zapier, Make and n8n.** Use the official Apify app: Zapier "Run Actor" action, Make "Run an Actor" module, or the n8n Apify node. Choose `steadyline/email-pattern-finder`, paste the input below, then use "Get dataset items" (or the run's dataset) to send results to Google Sheets, Slack, a CRM or a database.

**API (any language).** Run it and get the results in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/steadyline~email-pattern-finder/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"people": ["Jane Smith, python.org", {"firstName": "Guido", "lastName": "van Rossum", "domain": "python.org"}]}'
```

Or with the Python client (`pip install apify-client`):

```python
from apify_client import ApifyClient
client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("steadyline/email-pattern-finder").call(run_input={"people": ["Jane Smith, python.org", {"firstName": "Guido", "lastName": "van Rossum", "domain": "python.org"}]})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

### Works well with other Steadyline Data tools

- **Names to ranked emails:** [Company Team Page Scraper](https://apify.com/steadyline/website-team-extractor) -> this Actor -> [Email Deliverability Checker](https://apify.com/steadyline/email-deliverability-checker) for typo, disposable and SPF/DMARC context.
- **Company names first:** [Company Name to Domain](https://apify.com/steadyline/company-name-to-domain) -> this Actor when you have people names but not the domain yet.
- Related: [Company Team Page Scraper](https://apify.com/steadyline/website-team-extractor), [Website Contact Scraper](https://apify.com/steadyline/website-contact-extractor), [Email Deliverability Checker](https://apify.com/steadyline/email-deliverability-checker), [Company Name to Domain](https://apify.com/steadyline/company-name-to-domain).

### FAQ

**Is the best guess a confirmed mailbox?**
No. This Actor only checks that the domain publishes MX (or implicit MX) records. Every row is flagged `notMailboxConfirmed: true` and `catchAllUnknown: true`. Catch-all domains accept every local part, and we do not probe SMTP.

**Does it scrape LinkedIn or a people database?**
No. It is a deterministic pattern engine plus a DNS MX lookup. There is no login, no third-party people API and no paid data.

**What if the domain has no mail?**
The row is returned with `status` = `no-mx`, `null-mx` or `no-such-domain` and is **not charged**.

**Can I pass a Team Page Scraper dataset?**
Yes. Set `teamDatasetId` to that run's dataset id. Each row's `name` plus `site` or `startUrl` is used. You can also paste the dataset items into `people`.

**Can I run it on a schedule?** Yes. Create an Apify Schedule (or a saved Task with a schedule) and connect a webhook or integration to receive results.

**Need a feature or found a bug?** Open an issue on the Issues tab of this page or email steadylinedata@proton.me. Built and maintained by **Steadyline Data**.

### Acceptable use and GDPR

Guessed email addresses can be personal data. You need a lawful basis under GDPR, UK GDPR, CCPA and similar laws to store or use them, and you must follow anti-spam laws (CAN-SPAM, PECR, ePrivacy, CASL). Do not treat a guess as a confirmed mailbox. Do not use the results for harassment or to resell personal data.

Steadyline Data provides this tool as is and does not give legal advice.

# Actor input Schema

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

People to resolve. Each item can be a string ("Jane Smith, acme.com" or "Jane Smith @ acme.com") or an object with name / firstName / lastName and domain or site. Team Page Scraper rows (name + site) work as-is.

## `defaultDomain` (type: `string`):

Used when a person has no domain or site of their own (for example a list of names at one company).

## `teamDatasetId` (type: `string`):

Optional Apify dataset id from a website-team-extractor run. Each row's name plus site/startUrl is added to the people list.

## `maxConcurrency` (type: `integer`):

People processed in parallel. DNS answers are cached per domain.

## Actor input object example

```json
{
  "people": [
    "Jane Smith, python.org",
    {
      "firstName": "Guido",
      "lastName": "van Rossum",
      "domain": "python.org"
    }
  ],
  "defaultDomain": "python.org",
  "maxConcurrency": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

One row per person.

# 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": [
        "Jane Smith, python.org",
        {
            "firstName": "Guido",
            "lastName": "van Rossum",
            "domain": "python.org"
        }
    ],
    "defaultDomain": "python.org"
};

// Run the Actor and wait for it to finish
const run = await client.actor("steadyline/email-pattern-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": [
        "Jane Smith, python.org",
        {
            "firstName": "Guido",
            "lastName": "van Rossum",
            "domain": "python.org",
        },
    ],
    "defaultDomain": "python.org",
}

# Run the Actor and wait for it to finish
run = client.actor("steadyline/email-pattern-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": [
    "Jane Smith, python.org",
    {
      "firstName": "Guido",
      "lastName": "van Rossum",
      "domain": "python.org"
    }
  ],
  "defaultDomain": "python.org"
}' |
apify call steadyline/email-pattern-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,steadyline/email-pattern-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/IzDGj0QQcwrb8hiGz/builds/4syXw6VPIrigveggm/openapi.json
