Free Email Format Checker

What an email format actually is

Most companies use a consistent pattern for employee emails. At Acme Corp, every email might be `first.last@acme.com`. At Startup Inc, it's `first@startup.com`. At a consulting firm, you might see `flast@firm.com`. That pattern is the company's email format — a convention applied (usually) to everyone.

When the format breaks down, you get problems. New hires set up with the wrong format. Contractors with personal-looking addresses. Subsidiaries that picked their own convention before the parent company standardized. This tool audits a list of emails against a pattern you define and tells you who doesn't conform.

Format checker vs syntax checker — different questions

These two tools answer different questions and confusing them sends you down the wrong path.

Take `kevin@acme.com` as an example. The syntax checker says: valid (it's a properly-structured email). The format checker, with pattern `{first}.{last}@{domain}`, says: doesn't conform (no last name). The verifier checks whether the mailbox actually exists.

Most users want all three checks in sequence. Syntax first (cheap, weeds out garbage), format next (catches policy violations), verifier last (the slow, accurate check).

The eight most common business email patterns

Research across 250,000 verified business emails (Hunter.io 2024 + Adapt.io 2023) shows these patterns dominate. The percentages are how often each pattern appears across all companies — not per company. Any one company picks ONE format.

How to audit your company's email convention

Here's the practical workflow we recommend for HR teams or admins running a one-time audit:

1. Pull the email list from your directory (Google Workspace, Microsoft 365, BambooHR — wherever your system of record lives). Export to a CSV, copy the email column.
2. Paste the list into this tool and click Auto-detect dominant pattern. The tool tells you which format the majority of your employees use.
3. Confirm the dominant pattern is your intended one. If your policy says first.last but the auto-detect says flast, you have a bigger problem than non-conformers — your IT setup defaults are wrong.
4. Apply the pattern and click Audit. Review the non-conformers in the table.
5. Export the non-conforming list as CSV. Hand it to IT to fix or send to each employee with a note about the convention.
6. For subsidiaries with their own conventions, use multi-pattern mode — add their pattern alongside the parent company's. An email matches if it conforms to ANY of the configured patterns.

When subsidiaries break the format

Big companies often acquire smaller ones. The acquired company's domain comes with the deal, and so does its existing email convention. You end up with `parent.co` on `first.last@` and `subsidiary.io` on `flast@`. A single-pattern audit flags every subsidiary employee as non-conformant — not what you want.

Use multi-pattern matching. Add your parent-company pattern first. Click Add another pattern. Add the subsidiary's pattern. Audit again. Each email now matches if it conforms to EITHER pattern.

The per-domain breakdown shows you which domains have which conformance rates. If `@subsidiary.io` is at 32% even after adding their pattern, the subsidiary has its own inconsistency problem worth flagging separately.

Using format conformance to clean a marketing list

Cold-outreach lists from data brokers or LinkedIn scrapes are noisy. You get a mix of real business emails (`kevin.smith@company.com`), personal addresses on free providers (`kevin.smith88@gmail.com`), and obvious junk (`info@`, `sales@`, `webmaster@`).

For B2B outreach you typically want only the real business addresses. Set the pattern to `{first}.{last}@{domain}` or `{f}{last}@{domain}` and audit. Non-conformers get a closer look — many will be the personal/junk addresses you wanted to filter out anyway.

This isn't a perfect filter. Some real business emails use shorter formats like `{first}@` at startups. But for a list with thousands of rows where you can only afford to send to the most-likely-deliverable, format conformance is a fast filter that pairs well with a final pass through our email verifier.

Patterns we don't cover (and what to do about them)

Our placeholders handle the common name-based patterns. Some companies use formats we can't express with these tokens:

• Department prefixes — `sales.kevin@company.com`, `marketing.lena@company.com`. You'd need a separate pattern for each department, which gets tedious.
• Office codes — `kevin.smith.nyc@company.com`. Same problem.
• Sequential numbers — `kevin.smith.7@company.com` when there are name collisions. You CAN match this with `{first}.{last}.{number}@{domain}` — number placeholder handles it.
• Quoted local parts — `"Kevin Smith"@company.com`. RFC-valid but almost never used; our pattern syntax doesn't support quotes.
• Internationalized email — `用户@example.com`. Our placeholders only match Latin letters. International support is on the roadmap.

For these edge cases, you have two options: (1) accept that they'll show as non-conformers and manually whitelist them, or (2) request the pattern in our feedback form so we can add support if multiple users hit the same issue.

Format-clean is not deliverable

A reminder that's easy to forget: an email matching your pattern doesn't mean the mailbox exists. `john.smith@acme.com` is format-perfect, but if John Smith left the company three months ago, the address bounces. Acme might catch-all the address, route it to nobody, or generate an NDR.

The last step in any list-cleanup workflow is verification. Run your format-clean list through our email verifier — it opens an SMTP conversation with the recipient mail server to confirm the mailbox actually accepts mail. That's the only check that confirms deliverability.