--- name: bulk-email-finding slug: bulk-email-finding description: This skill should be used when the user asks to "find emails in bulk", "bulk email lookup", "find emails for a list", "email finder for outbound lists", "mass email discovery", "find emails at scale", "bulk contact email lookup", "email finding workflow", "find emails for cold outbound list", or any variation of finding email addresses at scale for B2B cold outbound. category: general --- # Bulk Email Finding Bulk email finding is the process of discovering work email addresses for a list of prospects at scale. You have names, companies, and titles. You need deliverable email addresses. The quality of your email finding determines whether your cold outbound reaches real inboxes or bounces into the void. The principle: no single email finding tool has 100% coverage. The best approach is a multi-provider waterfall: try Provider A, if no result try Provider B, then Provider C. A multi-provider strategy typically achieves 80-95% coverage vs 60-75% from a single provider. ## The Email Finding Workflow ### Standard workflow ``` Input: CSV with first_name, last_name, company, domain, title ↓ Step 1: Primary provider lookup (Apollo, Hunter, Lusha) → Found: 65-75% of contacts → Not found: pass to Step 2 ↓ Step 2: Secondary provider lookup (different provider) → Found: additional 10-15% → Not found: pass to Step 3 ↓ Step 3: Pattern-based guessing + verification → Generate email using company pattern (first.last@domain.com) → Verify with email verification tool → Found and verified: additional 5-10% ↓ Step 4: Email verification (ALL found emails) → Valid: add to outbound list → Invalid: remove → Risky: flag for manual review ↓ Output: Verified email list (80-95% coverage) ``` --- ## Email Finding Providers ### Provider comparison | Provider | Database size | Coverage | Email accuracy | Pricing | |----------|-------------|----------|---------------|---------| | Apollo | 275M+ contacts | Good for US mid-market tech | 85-92% | Credits-based, mid-range | | Hunter.io | 100M+ emails | Good for domain-based search | 90-95% on found emails | Credits-based, affordable | | Lusha | 100M+ contacts | Strong for direct dials + emails | 85-90% | Per-seat + credits | | RocketReach | 700M+ profiles | Wide coverage, varying accuracy | 80-88% | Credits-based | | Snov.io | 200M+ contacts | Good value, decent coverage | 82-88% | Credits-based, affordable | | Cognism | 400M+ profiles | Strong in EMEA | 88-93% | Enterprise pricing | ### Provider selection rules - **Start with Apollo or Hunter as primary.** Both have good coverage for B2B SaaS ICP. Apollo for contact-level search (name + company). Hunter for domain-level search (all emails at a domain) - **Add a second provider for the 25-35% gap.** No single provider covers everyone. A second provider adds 10-15% coverage. The cost is marginal compared to the value of additional contacts - **Match provider to geography.** US contacts: Apollo, Hunter, Lusha. EMEA: Cognism, Lusha. APAC: RocketReach. Coverage varies significantly by region - **Check provider accuracy on YOUR ICP.** Run 100 contacts through each provider. Compare accuracy. The best provider for your ICP may not be the one with the biggest database --- ## Pattern-Based Email Finding ### Common email patterns | Pattern | Format | Prevalence | |---------|--------|-----------| | first.last | john.smith@company.com | 45% of companies | | first | john@company.com | 15% | | firstlast | johnsmith@company.com | 10% | | first_last | john_smith@company.com | 5% | | flast | jsmith@company.com | 10% | | firstl | johns@company.com | 5% | | last.first | smith.john@company.com | 3% | | first.last+initial | john.smith2@company.com | Rare but exists at large companies | ### Pattern discovery process ``` 1. Find one known email at the target company (from Apollo, Hunter, or company website) 2. Determine the pattern from the known email (e.g., john.smith@acme.com = first.last) 3. Apply the pattern to your target contact (e.g., jane.doe@acme.com) 4. Verify the generated email with a verification tool 5. If valid: use it 6. If invalid: try alternative patterns ``` ### Pattern rules - **Always verify pattern-generated emails.** A pattern match is a guess, not a fact. Verification confirms the email exists before you risk a bounce - **Find the pattern from a confirmed email, not a guess.** Hunter.io's domain search often shows the most common pattern for a domain. Use that as your starting point - **Large companies may have multiple patterns.** Acquired companies keep old email domains. Different offices use different patterns. Verify each contact individually at large companies - **Pattern guessing is a last resort.** Use provider lookups first. Pattern guessing + verification is for the contacts that providers couldn't find --- ## The Multi-Provider Waterfall ### Building the waterfall ``` Provider priority (adjust based on your ICP): 1. Apollo (primary - best for US B2B mid-market) 2. Hunter.io (secondary - good for domain-based search) 3. Pattern guess + NeverBounce verification (fallback) For each contact: email = apollo.find(name, company) if not email: email = hunter.find(name, domain) if not email: email = generate_pattern(name, domain) if neverbounce.verify(email) != "valid": email = None if email: verified_email = neverbounce.verify(email) if verified_email == "valid": add_to_list(contact, email) else: skip(contact) ``` ### Waterfall rules - **Don't duplicate API calls.** If Apollo found the email, don't also check Hunter. Move to the next contact. Only cascade when the primary provider returns no result - **Track which provider found each email.** This data tells you which providers are worth renewing. If Provider B only finds 3% incremental contacts, it may not justify the cost - **Deduplicate before the waterfall.** If the same person appears in your list twice (different name spellings), the waterfall runs twice and charges twice. Dedup first - **Set a budget cap per contact.** If the waterfall costs $0.15 per contact (3 provider lookups + verification), your budget for 1,000 contacts is $150. Plan accordingly --- ## Quality Control ### Post-finding verification | Check | How | Target | |-------|-----|--------| | Email verification | NeverBounce, ZeroBounce on all found emails | > 90% valid | | Generic email filter | Remove info@, hello@, support@ | 0 generic emails in final list | | Domain check | Verify domain is active and matches company | 100% domain match | | Duplicate check | Dedup by email address | 0 duplicates | | Role-based filter | Remove role-based emails (sales@, marketing@) | 0 role-based in personal outbound list | --- ## Measurement | Metric | Definition | Target | Frequency | |--------|-----------|--------|-----------| | Coverage rate | % of input contacts with found emails | > 80% (with multi-provider) | Per list build | | Verification pass rate | % of found emails that verify as valid | > 90% | Per list build | | Bounce rate on sends | Actual bounces from found+verified emails | < 2% | Per campaign | | Cost per found email | Total provider costs / found emails | $0.05-0.20 | Per list build | | Provider incremental value | % of contacts found only by Provider B | Track to evaluate provider ROI | Quarterly | | Pattern guess success rate | % of pattern-generated emails that verify | > 50% | Per list build | --- ## Pre-List-Build Checklist - [ ] Input list has first name, last name, company name, and domain for each contact - [ ] Primary email finding provider selected and credits available - [ ] Secondary provider selected for waterfall fallback - [ ] Email verification tool configured (NeverBounce, ZeroBounce) - [ ] Input list deduplicated before running through providers - [ ] Generic and role-based email filter in place - [ ] Budget calculated (expected cost per contact x list size) - [ ] Coverage rate target set (> 80%) - [ ] Bounce rate from previous campaigns reviewed (< 2%) - [ ] Found emails will be verified before any outreach --- ## Anti-Pattern Check - Single provider only. Apollo finds 70% of your list. You accept 30% missing. A second provider would find 10-15% more. That's 100-150 additional contacts per 1,000. Worth the $15-30 in API costs - Sending pattern-guessed emails without verification. You guessed first.last@company.com for 200 contacts. 40 don't exist. 20% bounce rate. Domain reputation damaged. Always verify pattern-generated emails - Not filtering generic emails. info@company.com and hello@company.com are in your outbound list. These aren't people. They're shared inboxes. Filter them out before sending - Using personal emails for cold outbound. Gmail and Yahoo addresses from Apollo or Hunter. These are personal addresses, not work emails. Cold emailing personal addresses is bad practice and may violate regulations. Use work emails only - No deduplication before the waterfall. The same person appears 3 times with slightly different names. You run 3 API calls for 1 person. Wasted credits. Dedup by company + similar name before running providers - Never tracking provider value. You pay for 3 providers but never measure which ones actually find contacts the others miss. Provider B may only add 2% incremental coverage. Not worth the cost. Track and evaluate - Skipping verification because "the provider verified them." Provider verification is a point-in-time check. Emails go stale. Re-verify with a dedicated tool before every cold outbound campaign