# Company Email Format Finder: Email Pattern from Any Domain (`sandy_yclept/email-pattern-finder`) Actor

Email pattern finder by domain: give company domains and get each company's email format ({first}.{last}@acme.com), read from the addresses its own website prints or confirmed by its mail server, with the addresses that prove it. Never a guess. Pay only per company email format found.

- **URL**: https://apify.com/sandy_yclept/email-pattern-finder.md
- **Developed by:** [Rafal Sav](https://apify.com/sandy_yclept) (community)
- **Categories:** Lead generation, Automation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 company email patterns

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

### What does Company Email Format Finder do?

**Company Email Format Finder** is an **email pattern finder**: give it a list of **company domains** and it returns each company's **email format** — `{first}.{last}@acme.com`, `{f}{last}@acme.com`, `{last}@acme.com` — **with the addresses that prove it**. The pattern is read from the addresses the company **prints on its own website** for the people it names; when the website prints none, the company's **mail server** is asked which mailbox of a named person exists, and the one it confirms shows how the company spells them.

A pattern is **never guessed**. A company whose pattern could not be shown or confirmed comes back free, with the reason: a catch-all mail server, nobody named on the website, none of the usual mailboxes in use. The commonest pattern is never passed off as the company's own.

You **pay only per company email format found**. It runs on the [Apify platform](https://apify.com): API access, scheduling, integrations (Make, Zapier, n8n, Google Sheets) and run monitoring included.

### Why use it?

- **Proof in every row.** `pattern_examples` lists the addresses the pattern was read from, `pattern_status` says whether they were printed on the website (`published`) or confirmed by its mail server (`confirmed`). A pattern finder that returns a format for every domain is guessing for most of them.
- **The company's own addresses, not the four American patterns.** German companies spell their mailboxes `nachname@` and `v.nachname@`; Irish and Australian firms often `first@`. The pattern is whatever this company's addresses show.
- **A catch-all server fools nobody.** One company in six accepts every address. Each domain is first asked about a mailbox that cannot exist, and only a server that refuses it is believed about anything else.
- **German names the German way.** `Müller` is `mueller@` in a German mailbox, not `muller@`. On October 4, 2026 we asked German mail servers about 18 people with an umlaut in their name, in both spellings: 6 had a mailbox only as `ae`/`oe`/`ue`, none only with the mark dropped. On `.de`, `.at` and `.ch` domains that is the spelling asked for.
- **The company's inbox and phones come free** with every row, and the company's name as its legal notice prints it where the site has one.
- **Cheap to run.** A company whose website prints its people's addresses costs no mail-server check at all; the rest take about two checks at $0.00089 each.

### Use cases

- **Build addresses for the people you already know.** With the format of `acme.com` you can write to anyone at Acme whose name you have — from a conference list, a LinkedIn export, a press article.
- **Enrich a company list** with the email format, the company inbox and phone before an outreach campaign.
- **Check a guessed format** before sending: a `catch_all` or `not_found` row tells you a list built on guesses will bounce.
- **Feed it to our [Email Finder by Name & Domain](https://apify.com/sandy_yclept/work-email-finder)** for the people themselves: name and domain in, a published or confirmed address out.

### How to use it

1. Paste your **Company domains**, one per line — `acme.com` or `https://www.acme.com/`. A domain listed twice is read once.
2. Leave **Confirm the pattern with the company's mail server** on to have the mail servers asked where the websites print no address, or turn it off to get only the patterns printed on the websites.
3. Click **Start**. Download the results as JSON, CSV, Excel or HTML.

### Input

| Field | What it does |
|---|---|
| Company domains | Company domains or websites, one per line. Each comes back as one row with its email pattern and the addresses that show it. |
| Confirm the pattern with the company's mail server | Where the website prints no person's address, ask the company's mail server which mailbox of the first two people it names exists (default on). Runs [bounceverify's email verifier](https://apify.com/bounceverify/bounceverify-email-verifier) in a separate run on your account, which bills $0.00089 per address checked. |
| Max contact and about subpages | How many contact-like pages to read per website (default 5), looking for the people the company names and the addresses it prints. Up to 4 team pages and 8 pages of single people are read on top. |
| Proxy configuration, Retry refused sites | As in our other Actors: websites that refuse a cloud address are retried through Apify Proxy. |

### Output

One row per company. The values below are invented:

```json
{
  "domain": "acme.com",
  "company_pattern": "f.last",
  "email_format": "{f}.{last}@acme.com",
  "pattern_status": "published",
  "pattern_examples": ["j.doe@acme.com", "r.roe@acme.com"],
  "pattern_evidence": 2,
  "pattern_source": "j.doe@acme.com",
  "checks": 0,
  "website": "https://www.acme.com/",
  "website_status": "ok",
  "company": "Acme GmbH",
  "company_email": "info@acme.com",
  "company_phones": ["+493012345678"],
  "note": "The company's own website prints addresses that follow this pattern.",
  "billed": true
}
```

`{first}`, `{last}`, `{f}` and `{l}` in `email_format` stand for the first name, the last name and their first letters, as this company's own addresses show them. A pattern comes from one of two places, and the row says which:

- `published` — the company's own website prints addresses of people it names, and they follow this pattern. `pattern_examples` lists up to five of them, `pattern_evidence` counts them all. No mail server is asked.
- `confirmed` — the website prints no person's address, so the company's mail server was asked about the first two people the website names (the people who run the company come first), likeliest mailbox first. The mailboxes it confirmed are in `pattern_examples`; when two of them are spelt differently, the pattern is the one more of them follow.

Everything else is returned free, with the reason in `pattern_status`: `catch_all` (the server accepts every address, so nothing can be confirmed), `not_found` (none of the usual mailboxes of the people named exists), `no_people` (the website names nobody the server could be asked about, or could not be read), `unanswered` (the server did not answer, twice), `no_mail` (the domain has no mail server), `not_checked` (confirmation is off), `invalid` (not a company domain).

You can download the dataset in JSON, CSV, Excel or HTML, or read it over the API.

### Accuracy

On **October 4, 2026** we asked for the pattern of **60 company websites** picked for another test — 20 local businesses in Ireland, the UK and Australia, 20 US startups, 20 German firms. A pattern came back for **12**: 2 printed on the website, 10 confirmed by the mail server. Of the rest, 11 sit on catch-all domains, 7 have none of the usual mailboxes for the people named, 28 name nobody on their website (or did not answer), 2 accept no mail. The mail servers were asked about **124 addresses, $0.11 in all**. One company in five, each with its proof — a pattern finder that returns a format for every domain is guessing for the other four.

How good is a pattern as a predictor? In our email-finder test of **64 people at 35 companies**, the company's own pattern made the first mailbox asked the right one in **30 of 32** cases. Of 229 readable company websites in our benchmark sets, 20 print at least one person's address — the published patterns; the rest need the mail server.

### How much does it cost?

- **Company email pattern — $0.01** ($10 per 1,000), charged for each company whose pattern its website **shows** or its mail server **confirmed**. Once per company in a run.
- **Free:** every company whose pattern could not be shown or confirmed — catch-all, not found, nobody named, no mail, invalid — with the reason, the company's inbox and phones in every row.
- **Confirming patterns** is done by [bounceverify's email verifier](https://apify.com/bounceverify/bounceverify-email-verifier) in a separate run on your account: **$0.00089 per address checked**, about two checks per company whose website prints no address. In the test above, 124 checks for 60 companies cost $0.11.

The one other email pattern finder on Apify Store charges $0.10 a domain whatever it returns. 1,000 domains here cost at most **$10 for the patterns found plus about $2 of checks plus the platform usage** of reading 1,000 websites (about 0.3 compute units).

### Tips

- **Give the domain the company uses for mail.** It is usually its website's; a company that moved to another domain is followed there when the website is read.
- **A `catch_all` row** means the company's server will accept any address whether or not the mailbox exists. A list built on a guessed format for that company will not bounce, and will not be read either.
- **A `no_people` row** is a website that names nobody — a shop, a one-page site, a site that refused the run. There is nothing to ask a mail server about; `company_email` still holds the company's inbox where there is one.
- **Mail servers are asked in batches** of up to 40 companies, after their websites are read: rows appear batch by batch.

### FAQ

#### How is a company's email pattern found without any names?

The names come from the company's own website: team pages, the legal notice, the pages of single people, "founded by" sentences. Where it prints its people's addresses, they are the pattern and nothing is asked. Where it only names its people, the mail server is asked which of the usual mailboxes of the first two exists; the one it confirms shows how the company spells them. A company that names nobody, or whose server accepts every address, has no pattern anyone could prove — its row is free and says why.

#### Why not return the commonest pattern as a fallback?

Because `first.last@` is wrong for most German, Irish and small-business domains, and a wrong format bounces a whole list. A row that says `not_found` is worth more than a guess that looks like a result.

#### Why `confirmed` and not just "valid"?

Because a mail server that accepts every address — one in six — would call any address valid. Each domain is first asked about a mailbox that cannot exist. A server that accepts it is not believed about anything else, and the company comes back as `catch_all`, free.

#### Can I get the people's own emails too?

Yes, with [Email Finder by Name & Domain](https://apify.com/sandy_yclept/work-email-finder): name and company domain in, a published or confirmed address out. [Decision Maker Email Finder](https://apify.com/sandy_yclept/decision-maker-email-finder) finds the owners and executives on a company's website with their emails.

#### Is this legal?

The Actor reads public company websites, respecting `robots.txt`, and asks mail servers the question every mail client asks before delivery. The addresses in `pattern_examples` are work addresses the company itself publishes or its mail server confirms; a person's name and work email are personal data under the GDPR, so you need a legal basis to process them and must inform the people concerned. You are responsible for how you use the data.

### Related Actors

- [Email Finder by Name & Domain](https://apify.com/sandy_yclept/work-email-finder) — a person's verified work email from their name and company domain, published on the website or confirmed by its mail server.
- [Decision Maker Email Finder](https://apify.com/sandy_yclept/decision-maker-email-finder) — the people who own or run each company on a list of websites, with their emails.
- [Website Contact & Email Scraper](https://apify.com/sandy_yclept/website-contact-email-scraper) — emails, phone numbers and social profiles from any list of websites, priced per contact.
- [Google Maps Email Extractor](https://apify.com/sandy_yclept/google-maps-email-extractor) — local businesses from a Google Maps search, each with the email from its own website.
- [Impressum & Legal Notice Scraper](https://apify.com/sandy_yclept/impressum-email-scraper) — German company websites: the company, its representatives and contacts from the Impressum.

### Disclaimer

This Actor is a **tool**. You are responsible for complying with the GDPR and local marketing law, the target sites' Terms of Service, and `robots.txt`. It does not build or sell contact databases.

### Support

Got a pattern that bounces, or a `not_found` for a company whose format you know? Open an issue on the **Issues** tab with the domain — accuracy reports shape the roadmap directly.

# Actor input Schema

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

Company domains or websites: acme.com, https://www.acme.com/. One row per company with its email pattern (email format: {first}.{last}@acme.com, {f}{last}@acme.com) and the addresses that prove it, read from the addresses the company's website prints for the people it names or confirmed by its mail server for the first two people named. Billed only for a pattern shown or confirmed. A domain listed twice is read once; a mailbox provider's domain (gmail.com) is invalid and free.

## `confirmEmails` (type: `boolean`):

When the website prints no person's address, the usual mailboxes of the first two people it names are asked of the company's mail server; the pattern of the first mailbox that exists is returned as `confirmed`. A server that accepts every address proves nothing: the row says `catch_all` and is free. The checks run through bounceverify/bounceverify-email-verifier on your account, $0.00089 an address (our test: 60 companies, 124 checks, $0.11). Off: only patterns printed on websites are returned.

## `maxContactPages` (type: `integer`):

How many contact-like subpages (/about, /contact, /team, /impressum) to read on each company website, on top of its homepage, looking for the people it names and the addresses it prints for them. Up to 4 more team pages and 8 pages of single people are read on top of these, where the site has them.

## `proxyConfiguration` (type: `object`):

Optional proxy for fetching pages. Apify Proxy's datacenter IPs are included in every Apify plan, the Free plan too; residential proxies are billed separately. Left disabled, the Actor connects directly, and retries sites that refuse it through Apify Proxy (see below).

## `proxyFallback` (type: `boolean`):

Every cloud run has a datacenter IP address, and some sites turn those away. A site that refuses or drops the direct connection is retried once through Apify Proxy's datacenter IPs (included in every Apify plan, the Free plan too), then once more directly. Sites that answer directly never go through the proxy, and robots.txt is respected either way. Has no effect when a proxy is configured above.

## Actor input object example

```json
{
  "domains": [
    "acme.com",
    "https://www.example.co.uk/"
  ],
  "confirmEmails": true,
  "maxContactPages": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "proxyFallback": true
}
```

# 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": [
        "secotek.de",
        "partner-ag.de",
        "kahanelaw.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sandy_yclept/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 = { "domains": [
        "secotek.de",
        "partner-ag.de",
        "kahanelaw.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("sandy_yclept/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 '{
  "domains": [
    "secotek.de",
    "partner-ag.de",
    "kahanelaw.com"
  ]
}' |
apify call sandy_yclept/email-pattern-finder --silent --output-dataset

```

## MCP server setup

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