# Company Email Format Finder ✅ New · Real Pattern, $0.02/domain (`b2bsearch/company-email-format-finder`) Actor

New: a company's email format (first.last@, flast@, first@) from the work addresses on record for its current employees, not guessed from a name. Per domain: pattern, how many people confirm it, agreement, coverage, masked samples. $0.02 per confirmed domain; weak or empty free. MCP, n8n ready.

- **URL**: https://apify.com/b2bsearch/company-email-format-finder.md
- **Developed by:** [B2B Enrich Search](https://apify.com/b2bsearch) (community)
- **Categories:** Lead generation, Automation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 email format confirmeds

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

### What does Company Email Format Finder do?

**Company Email Format Finder** tells you how a company writes its work email addresses — `first.last@acme.com`, `flast@acme.com`, `first@acme.com` — from the addresses **on record for its current employees**. Paste website domains, get one row per domain with the email pattern, how many people confirm it, how much of the company it covers and masked examples.

It is an email pattern finder, email format lookup and company email convention checker in one Actor — the step before you guess a work email from a name, and the step that tells you whether guessing will work at all.

This is a **database lookup, not a guess and not a scrape**. Other email pattern Actors take a name and a domain and *propose* a format; this one reads a sample of the company's staff, keeps the addresses on the company's domain, and counts which format each person's address follows. The format most people fit is the answer, and the row says how many people that was.

- One row per domain: `pattern`, `patternExample`, `confirmations`, `agreement`, `coverage`, `otherPatterns`, `maskedSamples`.
- **You pay only for a confirmed format**: $0.02 per domain where two or more employees' addresses follow the same format. One person fitting is a free `weak_evidence` row (the format is still shown). No addresses, an unknown domain, a shared hosting platform or an invalid entry: free.
- Up to 5,000 domains per run, five domains in flight at a time; about 1–2 seconds per domain on a list.
- No cookies, no login, no browser. Runs from the Apify Console, the API, a schedule, an n8n / Make / Zapier step or an MCP client (Claude, ChatGPT, Cursor).

**No email address leaves this Actor.** Samples are masked (`j***.d**@acme.com`). To get actual addresses, pair it with one of the email Actors below.

### What data do you get per domain?

| Field | Example | Filled |
|---|---|---|
| `domain` | `acme.com` | always |
| `pattern` | `first.last` | on `found` and `weak_evidence` rows |
| `patternExample` | `jane.doe@acme.com` | with `pattern` — the format written out with a placeholder name |
| `confirmations` | `14` | how many distinct employees' addresses on record follow the format |
| `agreement` | `0.93` | confirmations ÷ employees with an address on the domain |
| `sampledEmployees` | `200` | current employees read for evidence |
| `employeesWithAddress` | `15` | of those, how many have a work address on the domain on record |
| `coverage` | `0.075` | employeesWithAddress ÷ sampledEmployees — how much of the company the data sees |
| `otherPatterns` | `flast (2), first (1)` | other formats at least one person fits — a company with two conventions shows both |
| `maskedSamples` | `j***.d**@acme.com, a**.l**@acme.com` | up to three real addresses, masked |
| `_status`, `_input`, `_note`, `_error` | `found` | every row |

The format names: `first.last`, `firstlast`, `flast`, `first`, `first_last`, `first-last`, `f.last`, `firstl`, `first.l`, `last.first`, `lastfirst`, `last_first`, `lfirst`, `l.first`, `last.f`, `lastf`, `last`, `f_last`, `fl` — where `f` and `l` are initials.

### How to find a company's email format (3 steps)

1. Paste company website domains into **Company website domains**, one per line. Full URLs are reduced to the domain.
2. Press **Start**. The default sample of 200 employees per company is enough for a clear answer on most companies; raise it for very large ones.
3. Export the dataset as CSV, Excel or JSON, or read it through the API. Use `agreement` and `confirmations` as your bar: a pattern 20 people confirm at 0.9 agreement is a convention; one 3 people confirm at 0.5 is a hint.

### How much does it cost to find an email pattern?

**$0.02 per domain with a confirmed format** ($20 per 1,000 domains), plus the small Actor start fee.

| Row | Price |
|---|---|
| Format confirmed by two or more employees (`found`) | $0.02 |
| Format one employee fits (`weak_evidence`) — pattern still shown | $0 |
| Addresses on record, none follows a name-based format — role mailboxes, nicknames (`no_pattern`) | $0 |
| Staff on record, nobody with a work address on this domain (`no_addresses`) | $0 |
| Domain resolved, but no current staff on file (`no_staff`) | $0 |
| No company on record uses the domain (`unresolved_domain`) | $0 |
| Shared hosting or platform domain (`domain_too_broad`) | $0 |
| Entry that is not a domain (`invalid`) | $0 |

The busiest email pattern Actor on this shelf charges $0.10 per domain and guesses the format from the name; here the format is derived from addresses that exist, and a domain the data cannot vouch for costs nothing.

### What a run looks like

Measured on the live database on 2026-10-09:

| Domain | Pattern | Confirmations | Agreement | Employees with an address / read |
|---|---|---|---|---|
| `n26.com` | `first.last` | 66 | 0.92 | 72 / 200 |
| `linear.app` | `first` | 57 | 0.97 | 59 / 183 |
| `stripe.com` | `first` | 50 | 0.60 (`fl` 13, `firstlast` 5, `flast` 5 also in use) | 84 / 200 |

A company whose brand runs on one domain while its company record lists another (`brand.com` vs `brand-group.com`) comes back as `no_staff` — try the other domain.

### Input

```json
{
  "domains": ["stripe.com", "n26.com", "linear.app"],
  "sampleLimit": 200
}
```

- `domains` — required. Company website domains, up to 5,000 per run. Full URLs are reduced to the domain; duplicates are removed.
- `sampleLimit` — how many current employees to read per company, 50–500 (default 200). More employees means more confirmations on large companies. The price per domain does not change.

### Output

A confirmed format:

```json
{
  "_status": "found",
  "_input": { "domain": "n26.com" },
  "domain": "n26.com",
  "pattern": "first.last",
  "patternExample": "jane.doe@n26.com",
  "confirmations": 66,
  "agreement": 0.917,
  "sampledEmployees": 200,
  "employeesWithAddress": 72,
  "coverage": 0.36,
  "otherPatterns": "first (4)",
  "maskedSamples": "m****@n26.com, t***.m****@n26.com, a***.s**********@n26.com"
}
```

A domain with nobody confirming a format (free):

```json
{
  "_status": "no_addresses",
  "_input": { "domain": "example.org" },
  "domain": "example.org",
  "sampledEmployees": 41,
  "employeesWithAddress": 0,
  "coverage": 0,
  "_note": "41 current employees read, none has a work address on this domain on record — nothing to derive a format from, nothing charged"
}
```

### Email format finder API, MCP and integrations

- **API** — start a run and read the dataset with the Apify API or the JavaScript and Python clients; the Actor is a REST endpoint for company email patterns.
- **MCP** — call it as a tool from Claude, ChatGPT, Cursor or any MCP client through the Apify MCP server.
- **n8n, Make, Zapier** — use the Apify node to look up the email format of every new company in a CRM, a spreadsheet or a webhook.

### Use cases

- **Outbound sales** — know a target account's email convention before you write to anyone there, and know how reliable it is.
- **Email finding at scale** — run this first on your account list, then guess or verify addresses only on domains with a confirmed pattern; skip the rest.
- **Data cleaning** — flag CRM contacts whose work email does not follow their company's convention.
- **Deliverability** — `coverage` and `agreement` tell you which companies have many observed mailboxes on record and which are thin.

### FAQ

#### How do I find a company's email format from its domain?

Enter the website domain. The Actor resolves it to the company record that uses it as its site, reads up to `sampleLimit` current employees, keeps the addresses on record that sit on that domain (or a host under it, like `mail.acme.com`), and counts which name-based format each person's address follows. The format most people fit is returned with the count behind it.

#### Is the email pattern guessed?

No. A format is reported only when real addresses on record follow it, and the row says how many. One person fitting a format is reported for free and marked weak, because a single address proves a mailbox exists, not that the company writes them that way.

#### Why do some rows show two formats?

Because the company uses two. Large companies often moved from `flast` to `first.last`, or use `first` for early staff and `first.last` later; `otherPatterns` lists every format at least one employee fits, with its count, so you can see the split.

#### What does "no_staff" mean?

The domain resolved to a company record that has no current employees on file. If the company is well known, its company page may list a different domain than the site you know — try that one.

#### Does it return the actual email addresses?

No. `maskedSamples` shows up to three addresses with the local part masked, as proof. For addresses, pass the people you want to [LinkedIn Email Finder](https://apify.com/b2bsearch/linkedin-email-finder) (by profile URL) or [Work Email Finder](https://apify.com/b2bsearch/work-email-finder) (by name and domain), or take a company's staff with emails from [Company Employees](https://apify.com/b2bsearch/company-employees).

#### Does it need cookies, a login or an API key?

No. The Actor does not sign in to any website and asks for no credentials.

#### How fresh is the data?

Addresses come from a database of professional profile records that is refreshed continuously. A format a company adopted in the last few months may not yet have enough employees on record to confirm it.

### Use Company Email Format Finder with AI agents and MCP

This Actor works as a tool for AI agents. Add it to Claude, ChatGPT, Cursor or any other MCP client through the Apify MCP server:

```
https://mcp.apify.com?tools=b2bsearch/company-email-format-finder
```

- **One question, one row.** "How does acme.com write emails?" is one call with one domain and one answer an agent can act on.
- **The agent pays only for results.** $0.02 per confirmed format, every other outcome free; cap a call with `maxTotalChargeUsd`.
- **Rows explain themselves.** `_status` says what happened; `agreement` and `confirmations` let the agent decide whether to trust the pattern.
- **Fast enough for a tool call.** A handful of domains finishes in seconds.

Input an agent can send as is:

```json
{
  "domains": ["acme.com"],
  "sampleLimit": 200
}
```

The same Actor is available as a tool in LangChain, CrewAI and the OpenAI Agents SDK, and as a step in n8n, Make and Zapier through the Apify integrations.

### Related Actors: which one should you use?

| Need | Actor |
|---|---|
| Company domain → email format | **Company Email Format Finder** (this Actor) |
| Name + company domain → work email | [Work Email Finder](https://apify.com/b2bsearch/work-email-finder) |
| LinkedIn URL → email addresses on record | [LinkedIn Email Finder](https://apify.com/b2bsearch/linkedin-email-finder) |
| Company domain → current employees, with emails | [Company Employees](https://apify.com/b2bsearch/company-employees) |
| Company domain → decision makers | [Decision Maker Finder by Domain](https://apify.com/b2bsearch/domain-to-decision-makers) |
| Company domain → recent hires and where they came from | [New Hires Finder](https://apify.com/b2bsearch/new-hires-finder) |
| Company domain → similar companies | [Lookalike Company Finder](https://apify.com/b2bsearch/lookalike-company-finder) |
| Company domain → company record | [Domain to Company](https://apify.com/b2bsearch/domain-to-company) |
| Email → person and company | [Reverse Email Lookup](https://apify.com/b2bsearch/reverse-email-lookup) |
| Filters → leads with an email | [B2B Leads Finder](https://apify.com/b2bsearch/b2b-leads-finder) |
| CSV of emails, URLs or names → profiles in bulk | [Bulk People Enrichment](https://apify.com/b2bsearch/bulk-people-enrichment) |

### Disclaimer and permitted use

**Independent product.** This Actor is an independent tool. It is not affiliated with, endorsed by, or sponsored by LinkedIn Corporation. LinkedIn® is a trademark of its owner. It is named here only to describe the kind of public profile link related Actors return.

**No platform access.** This Actor does not log in to, crawl or collect pages from LinkedIn or any other service. Every answer comes from our own database of business-contact records. It never returns passwords, messages, or content from non-public accounts.

**Permitted use.** Business-to-business purposes only: sales prospecting, recruiting outreach, CRM enrichment, and confirming that a business contact is who they say they are. You may not use this Actor or its output to:

- stalk, harass, threaten, dox or publicly expose any person;
- decide on anyone's eligibility for credit, employment, housing or insurance. This Actor is not a consumer reporting agency and its output is not a consumer report under the U.S. Fair Credit Reporting Act;
- send unsolicited bulk messages, or place autodialed or prerecorded calls or texts without the consent the law requires;
- profile people by health, religion, political opinion, sexual orientation, ethnicity or union membership;
- build or resell a contact database from the results.

**Your responsibilities.** You decide which companies to look up and what to do with the result. You are responsible for having a lawful basis for that use and for complying with the laws that apply to you, including GDPR and UK GDPR, ePrivacy and PECR, CCPA/CPRA, CAN-SPAM, and the TCPA and Do Not Call rules. Honor every opt-out you receive.

**Removal requests.** To have a person's data removed, open an issue on this Actor with only the profile link. Nothing else is needed, and the record is removed from every listing.

**Accuracy.** Records can be incomplete or out of date. Output is provided as is. Check before you rely on it.

# Actor input Schema

## `domains` (type: `array`):

One company per line, as its website domain (acme.com). Full URLs are reduced to the domain; duplicates are removed. Up to 5,000 domains per run. You pay $0.02 per domain that returns a confirmed format; every other outcome is a free row that says why.

## `sampleLimit` (type: `integer`):

How many current employees are read for evidence (default 200, 50–500). More employees means more confirmations on large companies; the price per domain does not change.

## Actor input object example

```json
{
  "domains": [
    "stripe.com",
    "n26.com",
    "linear.app"
  ],
  "sampleLimit": 200
}
```

# Actor output Schema

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

No description

# 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 = {
    "domains": [
        "stripe.com",
        "n26.com",
        "linear.app"
    ],
    "sampleLimit": 200
};

// Run the Actor and wait for it to finish
const run = await client.actor("b2bsearch/company-email-format-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 = {
    "domains": [
        "stripe.com",
        "n26.com",
        "linear.app",
    ],
    "sampleLimit": 200,
}

# Run the Actor and wait for it to finish
run = client.actor("b2bsearch/company-email-format-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 '{
  "domains": [
    "stripe.com",
    "n26.com",
    "linear.app"
  ],
  "sampleLimit": 200
}' |
apify call b2bsearch/company-email-format-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,b2bsearch/company-email-format-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/RseVONATt3sXimyQP/builds/w56xoYva3udjaSPBn/openapi.json