Email Pattern Finder

Discover the email format used by any company. Give it a domain like stripe.com and it figures out that they use first.last@stripe.com — then generates email addresses for any name you provide.

Why this matters: Knowing a company's email pattern turns a list of names into a list of email addresses. Combine this with the Website Contact Scraper to go from a list of company websites to verified email contacts in minutes.

How to find a company's email pattern

1. Go to the Email Pattern Finder on Apify
2. Enter company domains (e.g., stripe.com, buffer.com)
3. Optionally add known emails to improve accuracy (e.g., from the Website Contact Scraper)
4. Optionally add names you want to generate emails for
5. Click Start — get back the email pattern, confidence score, and generated email addresses

What data can you extract?

For each company domain, the Actor:

1. Collects known emails from the company website and optional user input
2. Filters out role-based emails (info@, sales@, support@) that don't reveal the naming pattern
3. Detects the email format by matching known emails against common patterns
4. Scores confidence based on how many emails match the detected pattern
5. Generates email addresses for any names you provide using the detected pattern

Supported email patterns

The Actor detects these common formats (ranked by real-world frequency):

Pattern	Example	Frequency
{first}.{last}	jane.doe@company.com	~45%
{first}{last}	janedoe@company.com	~20%
{first}	jane@company.com	~15%
{f}{last}	jdoe@company.com	~5%
{first}.{l}	jane.d@company.com	~5%
{first}_{last}	jane_doe@company.com	~3%
{f}.{last}	j.doe@company.com	~3%
{last}.{first}	doe.jane@company.com	~2%
{last}	doe@company.com	~2%

Use cases

Build email lists from company names

You have 500 company domains and key decision-maker names. Feed them into the Email Pattern Finder to generate direct email addresses for every person — without paying per-email lookup fees.

Complete the lead generation pipeline

1. Run Google Maps Scraper → get business websites
2. Run Website Contact Scraper → get team names + any public emails
3. Run Email Pattern Finder → detect the pattern and generate emails for every team member

Verify email patterns before outreach

Before sending cold emails, check if a company uses first.last or firstlast format. A wrong pattern means bounced emails and damaged sender reputation.

Input

Field	Type	Description	Default
domains	Array of strings	Company domains to analyze (required)	—
knownEmails	Array of objects	Pre-discovered emails to improve detection (optional)	[]
names	Array of objects	Names to generate emails for (optional)	[]
searchWebsite	Boolean	Scrape company website for public emails	true
searchGitHub	Boolean	Search GitHub commits for employee emails	true
proxyConfiguration	Object	Proxy settings for website scraping	Apify Proxy

Example input

{
    "domains": ["stripe.com"],
    "knownEmails": [
        { "email": "jane.diaz@stripe.com", "name": "Jane Diaz" },
        { "email": "patrick.collison@stripe.com", "name": "Patrick Collison" },
        { "email": "john.collison@stripe.com", "name": "John Collison" }
    ],
    "names": [
        { "name": "Will Gaybrick", "domain": "stripe.com" },
        { "name": "David Singleton", "domain": "stripe.com" }
    ]
}

Output

Each domain produces one record. Here's a real result from the example input above:

{
    "domain": "stripe.com",
    "pattern": "{first}.{last}@stripe.com",
    "confidence": 1,
    "emailsAnalyzed": 3,
    "sources": {
        "userProvided": 3,
        "website": 1,
        "github": 0
    },
    "alternatePatterns": [],
    "generatedEmails": [
        { "name": "Will Gaybrick", "email": "will.gaybrick@stripe.com" },
        { "name": "David Singleton", "email": "david.singleton@stripe.com" }
    ],
    "analyzedAt": "2026-02-07T01:14:12.040Z"
}

Confidence of 1.0 means all 3 known emails matched the {first}.{last} pattern perfectly.

Output fields

Field	Type	Description
domain	String	Company domain analyzed
pattern	String	Detected email pattern (e.g., {first}.{last}@stripe.com)
confidence	Number	Confidence score from 0 to 1 (1 = all emails match)
emailsAnalyzed	Integer	Number of personal (non-role) emails analyzed
sources	Object	Breakdown: how many emails came from each source
alternatePatterns	Array	Other patterns that partially matched
generatedEmails	Array	Email addresses generated for provided names
analyzedAt	String	ISO timestamp

Understanding confidence scores

Confidence	Meaning
0.8 - 1.0	High — the pattern is almost certainly correct
0.5 - 0.8	Medium — likely correct, but the company may use multiple formats
0.2 - 0.5	Low — limited data, pattern is a best guess
0.0	No data — only role-based emails found, defaulting to most common pattern

How to use the API

Python

from apify_client import ApifyClient

client = ApifyClient(token="YOUR_API_TOKEN")

run = client.actor("ryanclinton/email-pattern-finder").call(
    run_input={
        "domains": ["stripe.com"],
        "knownEmails": [
            {"email": "jane.diaz@stripe.com", "name": "Jane Diaz"},
            {"email": "patrick.collison@stripe.com", "name": "Patrick Collison"},
        ],
        "names": [
            {"name": "Will Gaybrick", "domain": "stripe.com"},
        ],
    }
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['domain']}: {item['pattern']} (confidence: {item['confidence']})")
    for email in item["generatedEmails"]:
        print(f"  {email['name']} → {email['email']}")

JavaScript / Node.js

import { ApifyClient } from 'apify-client';

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

const run = await client.actor('ryanclinton/email-pattern-finder').call({
    domains: ['stripe.com'],
    knownEmails: [
        { email: 'jane.diaz@stripe.com', name: 'Jane Diaz' },
        { email: 'patrick.collison@stripe.com', name: 'Patrick Collison' },
    ],
    names: [
        { name: 'Will Gaybrick', domain: 'stripe.com' },
    ],
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(item => {
    console.log(`${item.domain}: ${item.pattern} (${item.confidence})`);
    item.generatedEmails.forEach(e => console.log(`  ${e.name} → ${e.email}`));
});

Combine with Website Contact Scraper

The most powerful workflow: use Website Contact Scraper to find team member names, then Email Pattern Finder to generate their email addresses.

Website Contact Scraper         Email Pattern Finder
┌────────────────────┐          ┌──────────────────────┐
│ buffer.com         │          │ Known emails +        │
│                    │ emails + │ team member names     │
│ 48 team members    │ ──────>  │                       │ ──> Email list
│ names + titles     │ names    │ Detect: first.last@   │
│ 4 social links     │          │ Generate 48 emails    │
└────────────────────┘          └──────────────────────┘

Python — full pipeline example:

from apify_client import ApifyClient

client = ApifyClient(token="YOUR_API_TOKEN")

# Step 1: Scrape team names and any public emails
scraper_run = client.actor("ryanclinton/website-contact-scraper").call(
    run_input={"urls": ["https://buffer.com"], "maxPagesPerDomain": 5}
)

# Step 2: Collect emails and names from the results
known_emails = []
names_to_generate = []

for item in client.dataset(scraper_run["defaultDatasetId"]).iterate_items():
    domain = item["domain"]

    for email in item["emails"]:
        known_emails.append({"email": email})

    for contact in item["contacts"]:
        names_to_generate.append({"name": contact["name"], "domain": domain})

print(f"Found {len(known_emails)} emails, {len(names_to_generate)} names")

# Step 3: Detect pattern and generate emails
pattern_run = client.actor("ryanclinton/email-pattern-finder").call(
    run_input={
        "domains": [domain],
        "knownEmails": known_emails,
        "names": names_to_generate,
    }
)

# Step 4: Get the results
for item in client.dataset(pattern_run["defaultDatasetId"]).iterate_items():
    print(f"\n{item['domain']}: {item['pattern']} (confidence: {item['confidence']})")
    for e in item["generatedEmails"]:
        print(f"  {e['name']} → {e['email']}")

Qualify leads with B2B Lead Qualifier

After generating email addresses, score and rank your leads with B2B Lead Qualifier. It analyzes each company's website for 30+ business quality signals and returns a score (0-100) so you can focus outreach on the highest-quality leads first.

All-in-one pipeline

Want the full pipeline in a single run? Use B2B Lead Generation Suite — it chains Website Contact Scraper, Email Pattern Finder, and B2B Lead Qualifier automatically. One input, one output, no manual data piping.

Performance and cost

This Actor is lightweight — no heavy crawling required:

Domains	Estimated time	Estimated platform cost
10	~20 seconds	< $0.01
100	~3 minutes	~$0.05
1,000	~30 minutes	~$1.00

Estimates include website scraping (3 pages per domain). Providing known emails directly is even faster.

Tips for best results

• Provide known emails — The more real emails you feed in, the higher the confidence. Even 2-3 emails is often enough to detect the pattern.
• Use with Website Contact Scraper — It finds emails on company websites that you can feed directly into this Actor.
• Provide names with emails — Mapping "jane.diaz@stripe.com" to "Jane Diaz" helps the algorithm. Without names, it infers them from the email structure (less reliable).
• Check the confidence score — A score below 0.5 means limited data. Consider finding more emails before relying on the pattern.
• Multiple patterns are possible — Some companies use different formats for different departments. Check alternatePatterns in the output.

FAQ

How accurate are the generated emails?

Accuracy depends on the confidence score. At confidence 0.8+, generated emails are highly likely to be correct. At lower confidence, the pattern is a best guess. Always verify important emails before sending outreach.

What if the company uses multiple email formats?

Some companies use first.last@ for employees and first@ for executives. The Actor reports the most common pattern as primary and lists alternatives in alternatePatterns. Check both if your confidence is below 0.8.

Does this verify that emails actually exist?

No — this Actor detects the format and generates candidates. It does not verify deliverability. For verification, use a dedicated email verification service after generating candidates.

How is this different from Hunter.io or similar services?

Hunter.io charges per lookup and maintains a proprietary database. This Actor analyzes publicly available emails to detect patterns — no per-lookup fees, no database dependency. You own the data and the process.

Is this legal?

This Actor only analyzes publicly available information — emails published on company websites and public GitHub commits. It does not access private databases or bypass any access controls. Always comply with applicable laws (GDPR, CAN-SPAM) when using generated email addresses for outreach.

Responsible use

This Actor generates email address candidates based on publicly observed patterns. By using it, you agree to:

• Comply with all applicable laws, including GDPR, CAN-SPAM, and CCPA
• Use generated emails only for legitimate business purposes
• Not use this tool for unsolicited bulk email or spam
• Verify email deliverability before sending outreach

Limitations

• Requires known emails — The Actor needs at least 1-2 real emails from a domain to detect the pattern reliably. Domains with zero public emails will return a default guess.
• Name parsing — Works best with Western-style "First Last" names. Complex name structures (multiple middle names, prefixes, suffixes) may not parse correctly.
• No email verification — Generated emails are candidates, not verified addresses. Some may bounce.
• Single pattern assumption — Most companies use one email format, but some use multiple. The Actor reports the dominant pattern.

Pricing

• $10 per 1,000 domains analyzed
• First 50 domains free — try it risk-free
• Only pay for successful results

Domains	Price
50	Free
1,000	$10
5,000	$50
10,000	$100

Changelog

v1.0 (2026-02-07)

• Initial release
• Pattern detection from known emails with confidence scoring
• Email generation from detected patterns
• Website scraping for email discovery
• GitHub commit search for employee emails
• Pipeline integration with Website Contact Scraper