Email Pattern Finder - Detect Company Email Formats

Email Pattern Finder is a company email format detection tool that identifies the most likely naming convention a company uses — formats like [email protected], [email protected], or [email protected] — and generates candidate email addresses for specific people at that company, with optional MX and SMTP verification. Designed for sales, recruiting, and enrichment workflows that need company email pattern detection and name-to-email generation without per-address lookup pricing.

Unlike Hunter.io, Apollo.io, and Snov.io, which charge per email address from a pre-crawled database, Email Pattern Finder detects the company's naming convention once from live public sources for $0.10 per domain, then generates addresses for every contact at no additional cost.

To find a company's email format, generate work email addresses from names, or guess someone's work email at a company, enter one or more company domains into Email Pattern Finder. It collects real employee emails from 5 independent sources (company website, GitHub commits, WHOIS/RDAP records, Hunter.io API, and your own known emails), scores them against 18 naming convention templates, and returns the best match with a confidence score. Enable built-in email verification to test every generated candidate with MX record checks and SMTP deliverability probing. Catch-all domain detection warns you when a domain accepts any address — important context when interpreting SMTP verification results.

What it does: Detects company email naming patterns from public data, generates candidate email addresses for any person, and optionally verifies each candidate. Best for: SDRs, sales teams, recruiters, marketing agencies, and data enrichment workflows that need email addresses from a company name and person name. Speed: 1 domain in 30-60 seconds without verification. 20 domains in 10-20 minutes. Pricing: $0.10 per domain analyzed. Verification and catch-all detection included. No subscription. Output: JSON/CSV with detected pattern, confidence score, data quality rating, catch-all flag, source breakdown, alternate patterns, and generated/verified email addresses.

Summary

• Input: company domain + optional known emails + optional names to generate addresses for
• Output: detected email pattern, confidence score, data quality rating, alternate patterns, generated candidate emails, optional verification results, catch-all flag
• Data sources: company website, GitHub commits, WHOIS/RDAP, optional Hunter.io API, user-provided known emails
• Accuracy: high with 3-5+ name-email pairs from the domain
• Limitation: verification is unreliable on catch-all domains

Typical results

• Based on internal testing, 70-90% of tech companies typically yield a high-confidence pattern (5+ sample emails, 85%+ match rate)
• GitHub commits are often one of the highest-quality sources: real names paired with real email addresses
• Best domains: tech companies, SaaS vendors, agencies, startups with public engineering teams
• Lower results for: companies with WHOIS privacy, no website emails, and no public GitHub activity

Best fit:

• You know the company domain and the person's name
• You want to detect one company-wide pattern and generate many addresses
• The company has some public employee email footprint (website, GitHub, WHOIS)

Less suitable:

• The company has no public employee emails at all
• The company uses opaque mailbox IDs like [email protected]
• The website is JavaScript-rendered and you are not providing known emails
• The domain is catch-all and mailbox-level certainty is required

Important: Email Pattern Finder detects likely email patterns and generates candidate addresses. It does not guarantee mailbox existence or inbox reachability. Verification results on catch-all domains are unreliable. It does not access private databases or proprietary contact lists.

How to interpret the result

• confidence — how well the detected pattern matches the available name-email evidence (0-1 scale)
• dataQuality — how much evidence the result is based on: high (5+ samples), medium (2-4), low (1), no-data (none found)
• isCatchAll — whether the domain accepts any address, making SMTP verification unreliable for confirming individual mailboxes
• alternatePatterns — fallback candidates when a company may use more than one format

What is an email pattern finder?

An email pattern finder is a tool that determines the email naming convention a company uses by analyzing real employee email addresses collected from public sources. Once the convention is known (e.g., [email protected]), the tool generates candidate email addresses for any person by applying that pattern to their name. Email Pattern Finder goes further than basic pattern detection: it collects sample emails from 5 independent sources, scores against 18 naming templates, detects catch-all domains, and optionally verifies each generated address through MX and SMTP checks — all in one run.

What data can you extract?

Data Point	Source	Example
📧 Primary email pattern	Pattern analysis across 18 templates	{first}.{last}@acmecorp.com
📊 Confidence score	Pattern scoring algorithm (0-1)	0.92 (92% match rate)
📋 Data quality indicator	Email count + confidence threshold	high (5+ emails, 70%+ confidence)
🔍 Catch-all domain detection	Probe email verification	false (domain rejects unknown addresses)
🔢 Emails analyzed	All 5 sources combined, deduplicated	14 unique personal emails
🌐 Source breakdown	Per-source counts	{ website: 7, github: 4, whois: 1, hunter: 2, userProvided: 0 }
🔀 Alternate patterns	Ranked secondary matches with confidence	{f}{last}@acmecorp.com (conf: 0.08)
👤 Generated email addresses	Pattern + input names	[email protected]
✅ Verification status	MX + SMTP deliverability checks	valid / invalid / risky
🎯 Verification confidence	SMTP probe result score	0.95
🕐 Analysis timestamp	Run metadata	2026-03-25T14:30:00.000Z

Why use Email Pattern Finder?

Use Email Pattern Finder when you know a company's domain and a person's name, and want to generate likely work email addresses based on that company's naming convention rather than paying per-lookup from a database. Enable verification to test each candidate against MX records and SMTP probes. Catch-all domain detection tells you when a domain accepts any address, so you know the difference between a truly verified email and a false positive.

• Scheduling — run daily or weekly to detect format changes as companies restructure or rebrand
• API access — trigger runs from Python, JavaScript, or any HTTP client to integrate into existing sales pipelines
• Proxy rotation — scrape company websites at scale without IP blocks using Apify's built-in proxy infrastructure
• Monitoring — get Slack or email alerts when runs fail or produce unexpected low-confidence results
• Integrations — connect to Zapier, Make, Google Sheets, HubSpot, or webhooks to feed verified emails directly into your CRM

Email Pattern Finder as an alternative to Hunter.io, Apollo.io, and Snov.io

Feature	Email Pattern Finder	Hunter.io	Apollo.io	Snov.io
Email pattern detection	18 templates, 5 sources	Database lookup	Database lookup	Database lookup
Email generation from names	Included (unlimited per domain)	Per-lookup fee	Per-credit fee	Per-credit fee
Built-in email verification	MX + SMTP included	Extra charge	Separate tool	Separate tool
Catch-all domain detection	Automatic probe per domain	Not a core feature	Not a core feature	Not a core feature
Pricing model	$0.10/domain, no subscription	$49-399/month	$49-119/month	$39-199/month
Data freshness	Live scrape each run	Pre-crawled database	Pre-crawled database	Pre-crawled database
Alternate pattern ranking	Yes, with confidence scores	No	No	No
Data quality indicator	high/medium/low/no-data	No	No	No
API + scheduling + proxies	Apify platform included	Varies by plan	Varies by plan	Varies by plan

What makes Email Pattern Finder different from database-based tools?

Database tools like Hunter.io and Apollo.io look up email addresses from a pre-crawled index. If the company's email format changed last month, the database still returns the old pattern. If the company is not in the database, you get nothing.

Email Pattern Finder collects sample emails from 5 live sources every time it runs: the company website, GitHub public commits, WHOIS/RDAP registration records, Hunter.io API (optional), and your own known emails. It then scores those samples against 18 naming convention templates and returns a confidence-ranked result with alternates. The data is as fresh as the run itself.

Email Pattern Finder also tests whether a domain is catch-all before you rely on SMTP verification results. It sends a probe to a random nonexistent address — if the domain accepts it, you know that "valid" verification results are unreliable for that domain.

Features

• 18 email format templates — Scores all major corporate email conventions: first.last, firstlast, first, flast, first.l, first_last, f.last, last.first, last, fl, lastf, lastfirst, first-last, last-first, f-last, first_l, lfirst, and firstl. Includes 3 hyphenated formats common in European companies.
• 5-source email collection — Gathers sample emails from: (1) company website via CheerioCrawler, (2) GitHub public commit search, (3) WHOIS/RDAP domain registration records, (4) Hunter.io API integration, and (5) user-provided known emails. Each source is independently configurable.
• Built-in email verification — Enable verifyEmails to verify every generated email candidate using MX record checks and SMTP deliverability testing. Each candidate receives a verification status (valid, invalid, or risky) and a verification confidence score.
• Catch-all domain detection — Probes each domain with a random nonexistent email address. If the domain accepts it, the isCatchAll flag is set to true, warning you that all generated emails will appear "valid" regardless of whether the mailbox exists.
• Data quality indicator — Every result includes a dataQuality rating: high (5+ emails, 70%+ confidence), medium (2+ emails), low (1 email), or no-data.
• Confidence scoring — Each pattern gets a 0-1 confidence score: the proportion of analyzed name-email pairs where the template matched the actual address.
• Alternate pattern ranking — Returns secondary and tertiary pattern candidates with their own confidence scores. Useful for companies where different departments or acquired subsidiaries use different formats.
• Name-to-email generation — Provide a list of full names and domains; Email Pattern Finder applies the detected pattern to generate a ready-to-use email for each person.
• International name support — Handles accented characters (NFD normalization), hyphens, and apostrophes. Correctly processes names like "Jean-Pierre Dubois" and "Sean O'Brien".
• 25+ role-based email filters — Automatically excludes generic addresses (info@, sales@, support@, noreply@, hr@, billing@, and 20+ more) before pattern analysis so they do not skew results.
• 15 junk email pattern filters — Filters out noreply variants, example domains, Sentry error addresses, Wixpress placeholders, hex tokens, numeric-only local parts, and file-extension email artifacts.
• Name inference from email structure — When no name is paired with an email, Email Pattern Finder infers first/last from structured local parts like jane.doe or jane_doe (both parts must be 2+ characters).
• Structural fallback detection — When no name-email pairs can be built, the actor analyzes separator frequency in local parts to make a lower-confidence structural guess rather than returning no result.
• Budget controls — Pay-per-event pricing charges per domain analyzed. Email Pattern Finder stops immediately when your spending limit is reached.

Use cases for email pattern detection

Best for: Sales prospecting and SDR outreach

Use when you have target accounts and named buyers but no confirmed work emails. Email Pattern Finder detects the company pattern once, generates addresses for the buying committee, and flags catch-all domains where verification is unreliable. Key outputs: pattern, generatedEmails, verified, isCatchAll.

Best for: Marketing agency lead generation

Use when building prospect databases at scale without per-lookup costs. Detect patterns for hundreds of target companies in one batch and route results by dataQuality — high-confidence to automated sequences, low-confidence to manual review. Combine with Waterfall Contact Enrichment for addresses that return low confidence.

Best for: Recruiting and talent sourcing

Use when you know a candidate's employer and name but need their work email for direct outreach. Provide the domain and enable verification — Email Pattern Finder detects the convention, generates the address, and confirms deliverability.

Best for: Account-based marketing campaigns

Use when you need verified contact data for buying committee members across a target account list. Analyze the entire list in one batch and use dataQuality to prioritize outreach.

Best for: CRM data enrichment

Use when CRM records have names and company domains but no email addresses. Detect patterns, generate addresses, verify before import. Feed verified output into HubSpot Lead Pusher to update contacts automatically.

Best for: Competitive intelligence

Use when you need email addresses for key personnel at competitor organizations. Detect the naming convention and generate addresses for any named individual — useful for org chart mapping or acquisition target outreach.

How to find a company's email format from a domain (or guess someone's work email)

1. Enter company domains — Type one or more domains into the "Company Domains" field, for example stripe.com or buffer.com. Email Pattern Finder accepts full URLs too — paste and it normalizes automatically.
2. Add names to generate emails for — In the "Names" field, provide full names paired with their company domain: [{"name": "Sarah Chen", "domain": "stripe.com"}]. Skip this if you only need the pattern itself.
3. Enable verification — Check "Verify generated emails" to run MX and deliverability checks on every generated candidate. This also activates catch-all domain detection.
4. Run and download — Click "Start" and wait approximately 30-60 seconds per domain (longer with verification enabled). Download detected patterns, verified emails, and confidence scores in JSON, CSV, or Excel from the Dataset tab.

Typical performance

Metric	Range	Notes
Pattern confidence (5+ sample emails)	85-95%	Tech companies with GitHub activity
Pattern confidence (2-3 sample emails)	60-80%	Companies with some public email presence
Pattern confidence (1 sample email)	20-40%	Structural guess only — verify before outreach
Processing time per domain (no verification)	15-45 seconds	All 5 sources enabled
Processing time per domain (with verification)	45-90 seconds	Includes catch-all probe + candidate checks
Domains where 5+ sample emails are found	~60%	Higher for tech/SaaS, lower for law/finance
GitHub source hit rate	~40%	Best for companies with open-source teams
Website source hit rate	~55%	Best for companies with team/contact pages

Example campaigns

Campaign	Domains	Total cost	Result
SDR target accounts (March 2026)	50 SaaS companies	$5.00	42 high-confidence patterns, 6 medium, 2 no-data
Recruiting outreach (February 2026)	15 tech companies	$1.50	13 patterns detected, 28 candidates verified
Agency client list (January 2026)	200 mixed industries	$20.00	148 high/medium quality, 31 low, 21 no-data
ABM buying committee (March 2026)	10 enterprise companies	$1.00	8 patterns, 47 generated + verified emails

Input parameters

Parameter	Type	Required	Default	Description
domains	string[]	Yes	["apify.com"]	Company domains to analyze. One result record per domain.
knownEmails	object[]	No	[]	Pre-discovered emails to boost accuracy. Format: [{"email": "[email protected]", "name": "Jane Doe"}]. Name is optional but significantly improves confidence.
names	object[]	No	[]	Names to generate email addresses for. Format: [{"name": "John Smith", "domain": "stripe.com"}]. Each name is matched to its domain.
searchWebsite	boolean	No	true	Scrape the company homepage and up to 2 contact/about/team pages for publicly listed emails.
searchGitHub	boolean	No	true	Search the GitHub public commit API for author emails matching the domain. Returns up to 30 commits.
searchWhois	boolean	No	true	Query RDAP domain registration records for registrant email addresses. Most effective for small companies and startups.
verifyEmails	boolean	No	false	Verify generated email candidates using MX record checks and deliverability testing. Adds verified status and verifyConfidence to each candidate. Also enables catch-all domain detection.
hunterApiKey	string	No	—	Your Hunter.io API key for additional email discovery. Free tier provides 25 searches/month at hunter.io/api-keys.
proxyConfiguration	object	No	Apify Proxy	Proxy settings for website scraping. Recommended for batches over 20 domains.

Input examples

Detect pattern and generate verified emails for a single company:

{
    "domains": ["acmecorp.com"],
    "names": [
        {"name": "Sarah Chen", "domain": "acmecorp.com"},
        {"name": "Marcus Delgado", "domain": "acmecorp.com"}
    ],
    "verifyEmails": true
}

Batch pattern detection with known emails for extra accuracy:

{
    "domains": ["acmecorp.com", "betaindustries.com", "pinnacletech.io"],
    "knownEmails": [
        {"email": "[email protected]", "name": "James Porter"},
        {"email": "[email protected]", "name": "Linda Wu"},
        {"email": "[email protected]", "name": "Ravi Kaur"}
    ],
    "names": [
        {"name": "Sarah Chen", "domain": "acmecorp.com"},
        {"name": "Priya Sharma", "domain": "betaindustries.com"},
        {"name": "Jean-Pierre Dubois", "domain": "pinnacletech.io"}
    ],
    "verifyEmails": true,
    "searchWebsite": true,
    "searchGitHub": true,
    "searchWhois": true
}

Fast run using only provided emails (no web scraping, no verification):

{
    "domains": ["acmecorp.com"],
    "knownEmails": [
        {"email": "[email protected]", "name": "James Porter"},
        {"email": "[email protected]", "name": "Linda Wu"},
        {"email": "[email protected]", "name": "Ben Harris"}
    ],
    "searchWebsite": false,
    "searchGitHub": false,
    "searchWhois": false,
    "names": [
        {"name": "Sarah Chen", "domain": "acmecorp.com"}
    ]
}

Input tips

• Start with defaults — the default settings (all sources enabled, verification off) cover 80% of use cases. Enable verification when you plan to send outreach directly from the results.
• Provide 3-5 known emails with full names for the most accurate pattern detection. Name-email pairs are the primary input to the scoring algorithm — even 2 pairs can push confidence above 0.8.
• Batch domains in one run — processing 50 domains in a single run is faster and cheaper than 50 separate single-domain runs due to startup overhead.
• Use WHOIS for small companies and startups — Larger enterprises use WHOIS privacy protection. For businesses with fewer than 50 employees, WHOIS/RDAP often exposes the founder or admin email directly.
• Enable verification for outreach-ready data — When verifyEmails is true, each generated candidate gets an MX + SMTP check and every domain gets catch-all detection. This adds processing time but eliminates the need for a separate verification step.

Output example

{
    "domain": "acmecorp.com",
    "pattern": "{first}.{last}@acmecorp.com",
    "confidence": 0.92,
    "dataQuality": "high",
    "isCatchAll": false,
    "emailsAnalyzed": 12,
    "sources": {
        "userProvided": 2,
        "website": 5,
        "github": 4,
        "whois": 1,
        "hunter": 0
    },
    "alternatePatterns": [
        {
            "pattern": "{first}{last}@acmecorp.com",
            "confidence": 0.08
        },
        {
            "pattern": "{f}{last}@acmecorp.com",
            "confidence": 0.08
        }
    ],
    "generatedEmails": [
        {
            "name": "Sarah Chen",
            "email": "[email protected]",
            "verified": "valid",
            "verifyConfidence": 0.95
        },
        {
            "name": "Marcus Delgado",
            "email": "[email protected]",
            "verified": "valid",
            "verifyConfidence": 0.92
        },
        {
            "name": "Priya Sharma",
            "email": "[email protected]",
            "verified": "risky",
            "verifyConfidence": 0.61
        }
    ],
    "analyzedAt": "2026-03-25T14:32:17.000Z"
}

Output fields

Field	Type	Description
domain	string	The company domain that was analyzed
pattern	string	The most likely email naming pattern (e.g., {first}.{last}@domain.com)
confidence	number	Pattern match rate from 0 to 1. Above 0.8 is reliable; below 0.5 is a structural guess
dataQuality	string	Overall data reliability: high (5+ emails, 70%+ confidence), medium (2+ emails), low (1 email), no-data
isCatchAll	boolean/null	Whether the domain accepts any email address. true means verification results are unreliable. null if detection failed
emailsAnalyzed	integer	Unique personal emails used in pattern scoring (role-based excluded)
sources.userProvided	integer	Emails from the knownEmails input field
sources.website	integer	Emails found on the company website
sources.github	integer	Emails found in public GitHub commits
sources.whois	integer	Emails found in WHOIS/RDAP registration data
sources.hunter	integer	Emails returned by Hunter.io (when API key provided)
alternatePatterns	array	Other matching patterns ranked by confidence. Check these when primary confidence is below 0.7
alternatePatterns[].pattern	string	Alternate pattern template with domain
alternatePatterns[].confidence	number	Match rate for this alternate pattern
generatedEmails	array	Email addresses generated for names provided in the names input
generatedEmails[].name	string	Full name as provided in the input
generatedEmails[].email	string	Generated email address using the detected pattern
generatedEmails[].verified	string	Verification status: valid, invalid, or risky. Present only when verifyEmails is enabled
generatedEmails[].verifyConfidence	number	Verification confidence from 0 to 1. Present only when verifyEmails is enabled
generatedEmails[].verifyReason	string	Reason for the verification result. Present only when verifyEmails is enabled
analyzedAt	string	ISO 8601 timestamp of when the analysis completed

How much does it cost to find company email patterns?

Email Pattern Finder uses pay-per-event pricing — you pay $0.10 per domain analyzed. Platform compute costs are included. Email verification and catch-all detection are included in the per-domain price at no extra charge.

Scenario	Domains	Cost per domain	Total cost
Quick test	1	$0.10	$0.10
Small batch	10	$0.10	$1.00
Medium batch	50	$0.10	$5.00
Large batch	200	$0.10	$20.00
Enterprise	1,000	$0.10	$100.00

You can set a maximum spending limit per run to control costs. Email Pattern Finder stops when your budget is reached, so you never go over.

Compare this to Hunter.io at $49-149/month for 500-2,000 searches, Apollo.io at $49-119/month for limited credits, or Snov.io at $39-199/month. With Email Pattern Finder, most users spend $2-10/month with no subscription commitment — and generated emails, verification, and catch-all detection are all included. Once you know the pattern for a company, you generate addresses for every contact there at no additional cost.

Find company email patterns using the API

Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("ryanclinton/email-pattern-finder").call(run_input={
    "domains": ["acmecorp.com", "betaindustries.com"],
    "names": [
        {"name": "Sarah Chen", "domain": "acmecorp.com"},
        {"name": "Marcus Delgado", "domain": "betaindustries.com"},
    ],
    "verifyEmails": True,
    "searchWebsite": True,
    "searchGitHub": True,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['domain']}: {item['pattern']} (confidence: {item['confidence']}, quality: {item['dataQuality']})")
    print(f"  Catch-all: {item.get('isCatchAll', 'unknown')}")
    for email in item.get("generatedEmails", []):
        status = email.get("verified", "not verified")
        print(f"  {email['name']} -> {email['email']} [{status}]")

JavaScript

import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: "YOUR_API_TOKEN" });

const run = await client.actor("ryanclinton/email-pattern-finder").call({
    domains: ["acmecorp.com", "betaindustries.com"],
    names: [
        { name: "Sarah Chen", domain: "acmecorp.com" },
        { name: "Marcus Delgado", domain: "betaindustries.com" },
    ],
    verifyEmails: true,
    searchWebsite: true,
    searchGitHub: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const item of items) {
    console.log(`${item.domain}: ${item.pattern} (confidence: ${item.confidence}, quality: ${item.dataQuality})`);
    console.log(`  Catch-all: ${item.isCatchAll}`);
    for (const email of item.generatedEmails ?? []) {
        console.log(`  ${email.name} -> ${email.email} [${email.verified ?? "not verified"}]`);
    }
}

cURL

# Start the actor run
curl -X POST "https://api.apify.com/v2/acts/ryanclinton~email-pattern-finder/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "domains": ["acmecorp.com"],
    "names": [{"name": "Sarah Chen", "domain": "acmecorp.com"}],
    "verifyEmails": true,
    "searchWebsite": true,
    "searchGitHub": true
  }'

# Fetch results (replace DATASET_ID from the run response)
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_API_TOKEN&format=json"

Where Email Pattern Finder fits in a lead generation pipeline

Email Pattern Finder sits between contact discovery and outreach. It takes company domains (from any source) and names (from LinkedIn, CRM, or manual lists) and produces verified, pattern-based email addresses ready for outreach tools.

Upstream: Feed domains and names into Email Pattern Finder

• Google Maps Email Extractor — Search Google Maps for local businesses, extract domains, then detect their email patterns for further outreach
• Website Contact Scraper — Extract team names and emails from company websites, then feed them as knownEmails to boost pattern confidence to 0.9+
• B2B Lead Qualifier — Score and prioritize companies by fit before running pattern detection on your target list

Downstream: Use Email Pattern Finder output

• Bulk Email Verifier — For large candidate lists where batch verification at $0.005/email is more efficient than per-domain verification
• HubSpot Lead Pusher — Push the generatedEmails array directly into HubSpot as new contacts with company association

Full pipelines that call Email Pattern Finder internally

• Google Maps Lead Enricher — Maps search to enriched leads with email patterns, verification, and lead scoring in one run
• B2B Lead Gen Suite — Company URLs to qualified, scored, verified leads through a multi-stage pipeline
• Event Lead Extractor — Conference sponsor and speaker contacts with email pattern detection built in

How Email Pattern Finder works

Phase 1: Multi-source email collection

For each domain, Email Pattern Finder aggregates personal emails from up to 5 independent sources, deduplicating by exact email address match throughout.

Website scraping uses CheerioCrawler with 3 concurrent connections and a 30-request-per-minute rate limit. It loads the company homepage, extracts emails from mailto: links and regex matches in body text (/\b[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,12}\b/g), then enqueues up to 2 subpages whose URLs contain keywords like contact, about, team, people, staff, or leadership. When a mailto: link's visible text matches a person name pattern, the name is captured alongside the email for higher-confidence scoring.

GitHub commit search queries https://api.github.com/search/commits?q=author-email:@{domain}&sort=author-date&per_page=30 without authentication (10 requests/minute limit). This surfaces real employee emails with attached author names from public repositories — often the highest-quality source because both name and email are present in structured form.

WHOIS/RDAP lookup calls https://rdap.org/domain/{domain} and parses vCard entities from the JSON response, including nested sub-entities. For domains where the registrant's email is not privacy-protected, this often returns a founder or admin email with an associated contact name.

Hunter.io (optional) calls https://api.hunter.io/v2/domain-search with a limit of 20 results per domain, authenticated via the user's own API key. Results include first and last name alongside each email. Rate limit and auth errors are handled gracefully with fallback to other sources.

After collection, 15 junk patterns are filtered out: noreply variants, @example.* domains, @sentry.*, @wixpress.*, @placeholder.*, hex token prefixes, numeric-only local parts, and file-extension suffixes.

Phase 2: Pattern scoring against 18 templates

Before scoring, 25+ role-based local parts (info, sales, support, hello, admin, billing, press, hr, careers, enquiries, and more) are removed because they do not contain person-name structure.

For remaining emails, Email Pattern Finder builds name-email mappings. If a name was provided or discovered (from GitHub author metadata, mailto link text, Hunter.io, or WHOIS vCard), it is parsed: accents stripped via NFD normalization, non-alpha characters removed, first and last tokens extracted. If no name exists, the actor infers first/last from dot-separated, underscore-separated, or hyphen-separated local parts, requiring both parts to be 2+ characters.

Each of the 18 pattern templates then generates what the local part would be for every name-email mapping. Templates that use {first} are skipped when the first name is only 1 character (to avoid false matches between {first} and {f}). Hits are counted; confidence = hits / eligible mappings. Templates are ranked by confidence descending, with match count as tiebreaker. The top template becomes the primary pattern; all others with at least one hit become alternate patterns.

If no name-email pairs could be constructed, Email Pattern Finder falls back to structural analysis: counting the proportion of local parts containing dots, underscores, or hyphens, returning a 0.2-confidence structural guess.

Phase 3: Catch-all detection and email verification

Catch-all detection runs for every domain. Email Pattern Finder generates a probe email with a random, nonexistent local part (e.g., [email protected]) and sends it through Apify's Bulk Email Verifier infrastructure. If this clearly fake address comes back as "valid," the domain is catch-all — it accepts mail for any address.

Email verification (when verifyEmails is true) runs all generated email candidates through MX record checks and SMTP deliverability probing via the same verifier sub-actor. Each candidate receives a verified status (valid, invalid, or risky), a verifyConfidence score from 0 to 1, and a verifyReason string. The verification runs with a 15-minute timeout to handle large candidate lists.

Phase 4: Data quality classification

Each domain result receives a dataQuality rating based on two factors: the number of emails analyzed and the confidence score. The thresholds are: high requires 5+ emails and 70%+ confidence; medium requires 2+ emails; low means only 1 email was found; no-data means zero emails were collected from any source.

Use Email Pattern Finder if

• You have a list of target company domains and need to find or generate email addresses for specific people
• You want pattern detection from live public sources, not a stale pre-crawled database
• You need catch-all domain detection to avoid false positives from SMTP verification
• You want email generation + verification in one run instead of chaining separate tools
• Your budget does not support $49-399/month subscription tools for occasional use
• You are building automated sales or recruiting pipelines via API
• You need confidence scoring and data quality ratings to prioritize outreach

Tips for best results

1. Pair every known email with a full name. The confidence algorithm is name-dependent. An email like [email protected] alone is ambiguous — it could be {f}.{last} or {first}.{l}. Adding name: "James Porter" disambiguates it and can change confidence from 0.3 to 0.9.

2. Use the dataQuality field to decide next steps. high quality: proceed with confidence. medium: check alternate patterns and consider verification. low: the pattern is a best guess — verify before outreach. no-data: supplement with known emails or try a different domain variation.

3. Check isCatchAll before trusting verification results. If isCatchAll is true, the domain accepts mail for any address. Verification will show "valid" for every candidate, but the mailbox may not actually exist. For catch-all domains, rely on the pattern confidence score rather than verification status.

4. Enable verification for outreach-ready data. When building a list you plan to email directly, set verifyEmails: true. The small increase in processing time saves you from bounce rates that damage sender reputation. Verification and catch-all detection cost nothing extra beyond the $0.10/domain.

5. Disable sources when you have enough data. Three known name-email pairs is often sufficient. Set searchWebsite, searchGitHub, and searchWhois to false for a sub-5-second run that costs the same $0.10 per domain.

6. Check alternate patterns for enterprise companies. Large organizations sometimes use different email formats across divisions or acquisitions. A primary confidence of 0.6 alongside an alternate at 0.4 signals that the company may use two formats.

7. Combine with Website Contact Scraper for high-confidence results. Use Website Contact Scraper to pull all publicly listed emails with names from a company's team page, then feed those into Email Pattern Finder's knownEmails field — a two-step pipeline that consistently produces 0.9+ confidence.

8. Schedule periodic re-analysis for key accounts. Companies change email formats after rebranding, mergers, or IT migrations. A scheduled weekly run on your top accounts catches format changes before they cause bounce spikes.

Combine with other Apify actors

Actor	How to combine
Website Contact Scraper	Extract emails and team names from company websites, then feed them as knownEmails to boost pattern confidence to 0.9+
Bulk Email Verifier	For large candidate lists where built-in verification is not needed per-run, batch verify separately at $0.005/email
Waterfall Contact Enrichment	For low-confidence domains, cascade through 10 enrichment providers to find better sample emails
B2B Lead Gen Suite	Full pipeline: company URLs to email pattern detection to qualified leads in one run
HubSpot Lead Pusher	Push the generatedEmails array directly into HubSpot as new contacts with company association
Google Maps Email Extractor	Extract local business contacts from Google Maps, then detect their email format for further outreach
B2B Lead Qualifier	Score and prioritize companies by fit before running pattern detection on your full target list

Limitations

• No JavaScript rendering for website scraping — CheerioCrawler uses static HTML parsing. Emails loaded via JavaScript, React, or single-page application frameworks are not found. If a target company's contact page is JS-rendered, use Website Contact Scraper Pro as a pre-processing step, or manually add known emails.
• Requires some public email presence — Pattern detection needs real sample emails from the domain. If a company has no public website emails, no GitHub activity, and privacy-protected WHOIS, results will be no-data or low quality.
• Catch-all domains limit verification value — When isCatchAll is true, verification reports "valid" for candidates that may not have real mailboxes. Email Pattern Finder flags this, but it is a fundamental limitation of SMTP-based verification.
• Name-dependent scoring accuracy — Without person names paired to emails, Email Pattern Finder can only infer names from structured local parts (e.g., jane.doe). Opaque formats like jd1234@ or emp0087@ cannot be mapped and are excluded from scoring.
• GitHub rate limits — The unauthenticated GitHub commit search API allows 10 requests per minute. Batches of 100+ domains may experience throttling delays on the GitHub source.
• Sequential domain processing — Domains are analyzed one at a time. Batches of 500+ may approach the 3600-second default run timeout. For very large batches, split into multiple runs or increase the timeout.
• WHOIS privacy protection — Most large enterprises use WHOIS privacy services that redact registrant emails. WHOIS/RDAP is most useful for companies with fewer than 200 employees.
• Verification adds processing time — Each verified domain requires a sub-actor call for catch-all detection and another for candidate verification. Expect 15-30 additional seconds per domain when verification is enabled.

Integrations

• Zapier — Trigger pattern detection when new companies are added to your CRM and push verified emails back automatically
• Make — Build multi-step workflows connecting domain lists from a spreadsheet to pattern detection, verification, and CRM import in sequence
• Google Sheets — Export detected patterns, verified emails, and catch-all flags to a shared spreadsheet for SDR team review
• Apify API — Integrate pattern detection into your sales tooling via REST API, pulling results in JSON or CSV
• Webhooks — Receive results immediately when a run finishes for event-driven prospecting pipelines
• LangChain / LlamaIndex — Feed company email patterns into AI prospecting agents that construct and verify outreach messages autonomously

Troubleshooting

• Confidence score is below 0.5 even though I provided known emails. Email Pattern Finder needs name-email pairings to score templates. If you provide emails without names (e.g., {"email": "[email protected]"}), the actor cannot infer a first and last name from an opaque local part. Add the name field to every known email for the best results.

• No emails found on the company website despite the team page being visible. The website scraper uses CheerioCrawler, which parses static HTML only. If the team page is rendered by JavaScript, the emails are invisible to the scraper. Manually copy one or two emails from the page into the knownEmails field, or run Website Contact Scraper Pro (browser-based) first.

• Verification shows "valid" for all candidates but I suspect some are wrong. Check the isCatchAll field. If it is true, the domain accepts any email address — verification results are unreliable. Rely on the pattern confidence score instead, and consider manual verification through a test email.

• Run is slow on a large batch. Each domain involves up to 3 HTTP sources, pattern scoring, catch-all detection, and optional verification. Disable sources you do not need and set verifyEmails: false when you only need the pattern. This reduces per-domain processing from 60+ seconds to under 10 seconds.

• Generated email format looks wrong despite a high confidence score. Check the emailsAnalyzed field. A confidence of 1.0 from only 1 analyzed email means the pattern matched a single data point — not a reliable sample. Check dataQuality as well: treat confidence as meaningful only when dataQuality is medium or high.

Recent updates

• March 2026 — Added catch-all domain detection via probe email verification. Every domain now receives an isCatchAll flag regardless of whether verifyEmails is enabled.
• March 2026 — Added dataQuality field with four-tier rating (high/medium/low/no-data) for faster result triage.
• March 2026 — Added verifyReason field to generated email candidates when verification is enabled.
• March 2026 — Integrated failure webhook for monitoring and alerting on failed runs.

Responsible use

• Email Pattern Finder only accesses publicly available data: company websites, public GitHub commits, and public WHOIS/RDAP registration records.
• Respect website terms of service and robots.txt directives.
• Generated email addresses are predictions — verify them before use, or enable the built-in verification feature.
• Comply with GDPR, CAN-SPAM, and other applicable data protection laws when using generated emails for outreach.
• Do not use generated addresses for spam, harassment, or unauthorized contact.
• For guidance on web scraping legality, see Apify's guide.

FAQ

How do I find the email format a company uses? Enter the company domain into Email Pattern Finder's "Company Domains" field and run the actor. Email Pattern Finder collects real employee emails from 5 sources (company website, GitHub commits, WHOIS records, Hunter.io, and your own known emails), then scores 18 naming convention templates against those emails. Results include a confidence score and data quality rating.

How accurate is email pattern detection with Email Pattern Finder? Accuracy depends on the number of name-email pairs Email Pattern Finder can build. With 5+ paired samples (dataQuality: high), the actor typically reaches 85-95% confidence. With 2-3 pairs (medium quality), results are usually reliable at 70-85%. With 1 pair (low), treat the result as a best guess. Enable verification to confirm individual addresses before outreach.

How is Email Pattern Finder different from Hunter.io? Hunter.io charges per email address lookup ($0.10-0.50 each) and requires a subscription starting at $49/month. Email Pattern Finder detects the company's naming convention for $0.10 per domain, then generates addresses for as many people as you like at no additional cost. Email Pattern Finder also includes built-in email verification and catch-all domain detection — features Hunter.io charges extra for. For prospecting a 50-person buying committee across 10 companies, Hunter.io costs $250+; Email Pattern Finder costs $1.00 with verification included.

Does Email Pattern Finder verify that generated emails actually exist? Yes, when you enable the verifyEmails option. Each generated candidate is tested using MX record checks and SMTP deliverability probing via the Bulk Email Verifier. Results include a verification status (valid, invalid, risky) and a confidence score. Email Pattern Finder also detects catch-all domains that accept any address, so you know when verification results may be misleading.

What is catch-all domain detection and why does it matter for email pattern finding? A catch-all domain is configured to accept email sent to any address, even ones with no real mailbox. Email Pattern Finder detects this by probing the domain with a random, nonexistent email. If the probe comes back "valid," the domain is catch-all. On catch-all domains, standard email verification cannot confirm whether a specific mailbox exists — every address appears valid. The isCatchAll flag lets you adjust your outreach strategy accordingly.

Can I find company email formats in bulk for a whole target account list? Yes. Add all your target company domains to the "Company Domains" field and run once. Each domain produces its own result record with the detected pattern, confidence score, data quality rating, catch-all status, and any generated or verified emails you requested. A batch of 200 domains costs $20.

What email naming conventions can Email Pattern Finder detect? Email Pattern Finder recognizes 18 patterns: first.last, firstlast, first, flast, first.l, first_last, f.last, last.first, last, fl, lastf, lastfirst, first-last, last-first, f-last, first_l, lfirst, and firstl. This includes 3 hyphenated formats common in European companies. These templates are intended to cover the most common corporate email conventions.

Is it legal to use Email Pattern Finder to generate email addresses? Email Pattern Finder only accesses publicly available data: web pages without authentication, public GitHub commits, and public WHOIS records. Extracting publicly listed contact information is generally legal in most jurisdictions. However, legality depends on jurisdiction, intended use, and applicable regulations. Sending unsolicited commercial email must comply with CAN-SPAM, GDPR, and equivalent local regulations. Consult legal counsel for your specific use case and region. See Apify's web scraping legality guide.

How long does a typical Email Pattern Finder run take? A single domain takes 30-60 seconds with all sources enabled and verification off. With verifyEmails enabled, add 15-30 seconds per domain for catch-all detection and candidate verification. A batch of 20 domains takes 10-20 minutes without verification. Disabling web sources when providing known emails reduces processing to under 5 seconds per domain.

Can I schedule Email Pattern Finder to run automatically? Yes. Apify's scheduling feature lets you run Email Pattern Finder daily, weekly, or on any cron schedule. Use it to re-check your key target accounts periodically and detect format changes after company rebrands, mergers, or IT system migrations.

What does the dataQuality field in Email Pattern Finder output mean? The dataQuality field rates the reliability of the detected pattern: high means 5+ emails were analyzed and confidence is 70%+; medium means 2+ emails were found; low means only 1 email was available; no-data means no emails were collected from any source. Use this field to decide whether to trust the pattern or supplement with additional known emails.

Can I use my own Hunter.io API key with Email Pattern Finder to improve results? Yes. Add your Hunter.io API key to the hunterApiKey field. Email Pattern Finder calls Hunter.io's Domain Search endpoint (limit: 20 results per domain) and merges the results with its other 4 sources. Hunter.io's free tier gives 25 searches per month. Email Pattern Finder handles rate limit and authentication errors gracefully so other sources still run.

Help us improve

If you encounter issues, you can help us debug faster by enabling run sharing in your Apify account:

1. Go to Account Settings > Privacy
2. Enable Share runs with public Actor creators

This lets us see your run details when something goes wrong, so we can fix issues faster. Your data is only visible to the actor developer, not publicly.

Support

Found a bug or have a feature request? Open an issue in the Issues tab on this actor's page. For custom solutions or enterprise integrations, reach out through the Apify platform.