Email Pattern Finder

Email Pattern Finder detects the naming convention any company uses for employee email addresses — formats like [email protected], [email protected], or [email protected] — using publicly available data from up to 5 sources. Provide a list of company domains, get back the detected pattern, a confidence score, and ready-to-use email addresses for any person at that organization.

This actor reverses what tools like Hunter.io charge $0.10-0.50 per lookup for. Detect the pattern once per company for a fraction of a cent, then generate accurate email addresses for every contact on your list. It works by collecting real employee emails from company websites, GitHub public commits, WHOIS/RDAP registration records, and optional Hunter.io integration, scoring 12 pattern templates, and returning the best match with ranked alternates. Batch processing lets you analyze hundreds of domains in a single run.

What data can you extract?

Why use Email Pattern Finder?

Manual email guessing wastes hours per prospect list. Per-lookup services like Hunter.io charge $0.10-0.50 per address — a list of 500 contacts costs $50-250 before you send a single message. And you're paying for addresses one at a time, with no insight into why a format is right or wrong.

This actor detects the company's naming convention once, from public data, for a fraction of a cent per domain. Then you generate addresses for every contact at that company for free. SDRs building a 200-person outreach list across 20 target companies can complete the entire email discovery step for under $1.

• Scheduling — run daily or weekly to detect format changes as companies grow and restructure
• API access — trigger runs from Python, JavaScript, or any HTTP client to integrate into existing prospecting 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 generated emails directly into your CRM

Features

• 5-source email collection — Gathers emails from: (1) user-provided known emails, (2) company website via CheerioCrawler scanning homepage and up to 2 contact/about/team pages, (3) GitHub public commit search returning up to 30 commits per domain, (4) WHOIS/RDAP domain registration records via the free rdap.org protocol, and (5) optional Hunter.io API integration using your own key.
• 12 pattern templates — Scores all major corporate email formats: first.last, firstlast, first, flast, first.l, first_last, f.last, last.first, last, fl, lastf, and lastfirst. Ordered by real-world frequency so the most common formats rank first on ties.
• Confidence scoring — Every detected pattern is assigned a 0-1 confidence score: the proportion of analyzed name-email pairs where the template matched the actual address. A score of 0.8+ means the pattern matched 80%+ of your sample.
• Alternate pattern ranking — Returns secondary and tertiary pattern candidates with their own confidence scores, ranked by match count. Essential for companies where different departments use different formats.
• Bulk email address generation — Provide a list of full names and domains; the actor applies the detected pattern to generate a ready-to-use email for each person, with accent normalization and non-alpha character stripping.
• 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.
• 13 junk email pattern filters — Filters out noreply variants, example domains, Sentry error addresses, Wixpress placeholders, file-extension email addresses, and other artifacts that appear in HTML but are not real contacts.
• Name inference from email structure — When no name is paired with an email, the actor infers first/last from structured local parts like jane.doe or jane_doe (both parts must be 2+ characters to avoid ambiguity).
• Structural fallback detection — When no name-email pairs can be built, the actor analyzes dot-vs-underscore frequency in local parts to make a lower-confidence structural guess, rather than failing silently.
• Domain normalization — Accepts full URLs, bare domains, or messy inputs (https://www.stripe.com/about, stripe.com, STRIPE.COM) — strips protocol, www, paths, ports, query strings, and fragments automatically.
• Batch domain processing — Process any number of domains in a single run. Each domain is analyzed independently and produces its own output record.
• Budget controls — Pay-per-event pricing charges per domain analyzed. The actor stops immediately when your spending limit is reached, so costs never exceed your budget.

Use cases for email pattern finder

Sales prospecting and SDR outreach

Sales development reps building outreach lists for target accounts spend hours guessing email formats or paying per-lookup fees to email discovery tools. With Email Pattern Finder, an SDR targeting 50 accounts detects all email patterns in a single 10-minute run, then generates accurate email addresses for every decision-maker on the buying committee. The confidence score tells you how much to trust each result before sending.

Marketing agency lead generation

Agencies building prospect databases for clients need email addresses at scale without per-lookup costs eating into margins. Email Pattern Finder lets agencies detect patterns for hundreds of target companies in one batch, feed the patterns into a name list, and produce client-ready email lists for pennies per company. Combine with Waterfall Contact Enrichment to enrich addresses that return low confidence scores.

Recruiting and talent sourcing

Recruiters know the name of a candidate but need their work email for outreach outside LinkedIn. Provide the company domain and any known emails (from LinkedIn profiles or the company website), and the actor generates a probable work address for the candidate based on the proven company format. Pair with Bulk Email Verifier to confirm deliverability before reaching out.

Account-based marketing campaigns

ABM campaigns require verified contact data for specific buying committee members across a defined target account list. Email Pattern Finder analyzes the entire target account list in one batch, detects naming conventions, and generates email addresses for each stakeholder identified through research. The alternate pattern rankings help identify companies where multiple formats may be in use.

Lead generation data enrichment

CRM records often have names and company domains but no email addresses. Email Pattern Finder fills that gap by detecting the company pattern from public sources and generating addresses for every incomplete record in your database. Feed output directly into HubSpot Lead Pusher to update contacts automatically.

Competitive intelligence and research

Analysts building contact maps for competitor organizations can construct probable email addresses for identified employees using the detected naming convention. The 5-source collection approach maximizes the chance of finding real sample emails even for companies with minimal public web presence.

How to find company email patterns

1. Enter company domains — Type one or more domains into the "Company Domains" field, for example stripe.com or buffer.com. The actor accepts full URLs too — just paste and it normalizes automatically.
2. Optionally add known emails — If you already have one or two real email addresses from the company (found on LinkedIn, a press release, or the company website), add them to "Known Emails" with the person's full name. Even 2 known emails with names can push confidence above 0.8.
3. Run the actor — Click "Start" and wait approximately 30-60 seconds per domain. A batch of 20 companies takes 10-20 minutes.
4. Download results — Get detected patterns, confidence scores, and generated email addresses in JSON, CSV, or Excel from the Dataset tab.

Input parameters

Input examples

Detect pattern for a single company:

{
    "domains": ["stripe.com"]
}

Detect pattern and generate email addresses in one run:

{
    "domains": ["acmecorp.com"],
    "knownEmails": [
        {"email": "[email protected]", "name": "James Porter"},
        {"email": "[email protected]", "name": "Linda Wu"}
    ],
    "names": [
        {"name": "Sarah Chen", "domain": "acmecorp.com"},
        {"name": "Marcus Delgado", "domain": "acmecorp.com"},
        {"name": "Priya Sharma", "domain": "acmecorp.com"}
    ]
}

Batch analysis of target account list:

{
    "domains": ["stripe.com", "buffer.com", "notion.so", "figma.com", "linear.app"],
    "searchWebsite": true,
    "searchGitHub": true,
    "searchWhois": true
}

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

{
    "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

• 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.
• Disable sources you do not need — If you already have known emails, set searchWebsite, searchGitHub, and searchWhois to false for a faster, lower-cost run.
• 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.
• Add Hunter.io for maximum coverage — A free Hunter.io key adds a fifth data source and is especially useful for companies with no public website emails and no GitHub activity.

Output example

{
    "domain": "acmecorp.com",
    "pattern": "{first}.{last}@acmecorp.com",
    "confidence": 0.92,
    "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]"
        },
        {
            "name": "Marcus Delgado",
            "email": "[email protected]"
        },
        {
            "name": "Priya Sharma",
            "email": "[email protected]"
        }
    ],
    "analyzedAt": "2026-03-15T14:32:17.000Z"
}

Output fields

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.

You can set a maximum spending limit per run to control costs. The actor 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 — with Email Pattern Finder, most users spend $2-10/month with no subscription commitment and no per-address fees for generated emails. Once you know the pattern for a company, you can generate email 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"},
    ],
    "searchWebsite": True,
    "searchGitHub": True,
})

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

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" },
    ],
    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})`);
    for (const email of item.generatedEmails ?? []) {
        console.log(`  ${email.name} -> ${email.email}`);
    }
}

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"}],
    "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"

How Email Pattern Finder works

Phase 1: Multi-source email collection

For each domain, the actor 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 the pattern [A-Z][a-z]+ [A-Z][a-z]+, the name is captured alongside the email for higher-confidence scoring downstream.

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 the vCard entities in the JSON response. 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. Results include first and last name alongside each email, making them ideal for pattern scoring. Rate limit and auth errors are handled gracefully.

After collection, 13 junk patterns are filtered out: noreply variants, @example.* domains, @sentry.*, @wixpress.*, @placeholder.*, file-extension suffixes, and several daemon/postmaster patterns.

Phase 2: Pattern scoring against 12 templates

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

For remaining emails, the actor builds name-email mappings. If a name was provided or discovered (from GitHub author metadata or a mailto: link text), 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 or underscore-separated local parts, requiring both parts to be 2+ characters to prevent ambiguity between {first} and {f}{last} when first names are single characters.

Each of the 12 pattern templates then generates what the local part would be for every name-email mapping. Hits are counted; confidence = hits / eligible mappings. Templates are ranked by confidence descending, with match count as a tiebreaker. The top template becomes the primary pattern; all others with at least one hit become alternate patterns with their own confidence scores.

If no name-email pairs could be constructed from the collected emails, the actor falls back to structural analysis: counting the proportion of local parts containing dots versus underscores, returning a low-confidence (0.2) structural guess rather than failing.

Phase 3: Email address generation

When the names input is populated, the actor applies the winning pattern template to each name. Names are normalized identically to the scoring phase (NFD accent stripping, non-alpha removal, lowercased). The pattern's generator function formats the local part, and the result is returned as {name, email} pairs in the output record alongside the pattern analysis.

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 instantly and can change the confidence from 0.3 to 0.9.

2. Use the confidence score to decide next steps. Above 0.8: proceed with confidence. Between 0.5-0.8: check the alternate patterns and consider verifying generated addresses. Below 0.5: the pattern is a structural guess — verify before outreach.

3. Run verification after generation. Generated emails are predictions based on the detected pattern. Before sending outreach, run them through Bulk Email Verifier to confirm deliverability and avoid bounce rates that damage sender reputation.

4. Disable automatic 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.

5. Check alternate patterns for enterprise companies. Large organizations sometimes use different email formats across divisions or acquisitions. A confidence of 0.6 for two different patterns may indicate both are in active use.

6. Schedule periodic re-analysis for long-term accounts. Companies change email formats after rebranding or major organizational restructuring. A scheduled weekly run on your key accounts catches format changes before they cause bounce spikes.

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

Combine with other Apify actors

Limitations

• No email deliverability verification — The actor detects naming patterns and generates candidate addresses. It does not confirm that generated emails exist or are deliverable. Use Bulk Email Verifier before outreach.
• Requires at least 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 a low-confidence structural guess.
• Name-dependent scoring accuracy — Without person names paired to emails, the actor 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.
• 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.
• GitHub rate limits apply — The unauthenticated GitHub commit search API allows 10 requests per minute. Batches of 100+ domains will experience throttling delays.
• 12 pattern templates only — The actor recognizes the 12 most common corporate email conventions. Unusual formats (employee ID numbers, numeric suffixes like jsmith2@, department codes) will not be detected.
• Sequential domain processing — Domains are analyzed one at a time in a loop. Batches of 500+ may approach the 3600-second default run timeout. For very large batches, split into multiple runs.
• 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.

Integrations

• Zapier — Trigger pattern detection when new companies are added to your CRM and push generated emails back automatically
• Make — Build multi-step workflows connecting domain lists from a spreadsheet to pattern detection and email verification in sequence
• Google Sheets — Export detected patterns and generated emails 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. The actor needs name-email pairings to score pattern templates against each other. 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, so no mapping is built. 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. As a workaround, manually copy one or two emails from the page into the knownEmails field, or run Website Contact Scraper Pro (browser-based) first to harvest the emails.

GitHub source returns 0 emails for a well-known company. The GitHub commit search API returns results only from public repositories. Companies that work exclusively in private repos, or where employees use personal email addresses for open-source commits, will return zero results. Supplement with known emails or a Hunter.io API key.

Run is slow on a large batch. Each domain involves up to 3 HTTP sources plus pattern scoring. Disable sources you do not need (searchWebsite: false, searchGitHub: false, searchWhois: false) when providing known emails directly. This reduces per-domain processing from 30-60 seconds to under 5 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. Treat confidence as meaningful only when emailsAnalyzed is 4 or higher.

Responsible use

• This actor 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.
• 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 the "Company Domains" field and run the actor. It collects real employee emails from the company website, public GitHub commits, and WHOIS records, then scores 12 naming convention templates against those emails to determine which format the company uses.

How accurate is email pattern detection? Accuracy depends on the number of name-email pairs the actor can build. With 5 or more paired samples, the actor typically reaches 85-95% confidence. With 2-3 pairs it is usually reliable (70-85%). Below 2 pairs, treat the result as a best guess and check the alternate patterns list.

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 lets you generate addresses for as many people as you like at no additional cost. For prospecting a 50-person buying committee across 10 companies, Hunter.io might cost $250 or more; this actor costs $1.00.

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, and any generated emails you requested.

What email naming conventions can this actor detect? The actor recognizes 12 patterns: first.last, firstlast, first, flast, first.l, first_last, f.last, last.first, last, fl, lastf, and lastfirst. These cover over 95% of corporate email conventions in practice.

Does Email Pattern Finder verify that generated emails actually exist? No. It detects the naming pattern and generates candidate addresses based on that pattern. To confirm deliverability before sending outreach, pass the generated emails to Bulk Email Verifier, which performs MX record checks and SMTP probing.

What happens if no emails are found for a domain? The actor returns {first}.{last}@domain.com as the pattern with a confidence score of 0, clearly signaling that no real data was found and the result is a default assumption.

Is it legal to scrape email addresses from company websites? The actor 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, how you use that data matters — sending unsolicited commercial email must comply with CAN-SPAM, GDPR, and equivalent regulations. See Apify's web scraping legality guide for full guidance.

How long does a typical run take? A single domain takes 30-60 seconds with all sources enabled. A batch of 20 domains takes 10-20 minutes. Disabling website and GitHub search when providing known emails directly reduces this to under 5 seconds per domain.

Can I schedule this actor 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 or mergers.

What if a company uses different email formats across departments? The actor's alternate patterns list captures this. When multiple templates each match a meaningful share of analyzed emails, they all appear in alternatePatterns with their own confidence scores. A primary confidence of 0.6 alongside an alternate at 0.4 is a signal that the company may use two formats.

Can I use my own Hunter.io API key to improve results? Yes. Add your Hunter.io API key to the hunterApiKey field. The actor calls Hunter.io's Domain Search endpoint (limit: 20 results) and merges the results with its other sources. Hunter.io's free tier gives 25 searches per month — enough for most small-scale use cases.

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.