Hunter.io Best Practices

Hunter.io is an email finding and verification tool. Its core value is domain-based email discovery: give it a company domain, and it returns known email addresses and the email pattern used at that company. Hunter works best as a secondary provider in a multi-tool enrichment stack, specializing in email pattern detection and verification.

The principle: Hunter.io's strength is pattern detection, not database size. It identifies the email format a company uses (first.last@, flast@, etc.) and lets you generate accurate emails for any contact at that company. Use it for pattern discovery and verification, not as your sole contact database.

Core Features

How to use each feature

Domain Search Strategy

When to use Domain Search

1. You're researching a target account
2. You need to identify the email pattern
3. You want to see who at the company has public emails

Domain search for "acme.com":
  Returns:
  - Pattern: {first}.{last}@acme.com (confidence: 92%)
  - Known emails:
    john.smith@acme.com (VP Sales, confidence: 95%)
    jane.doe@acme.com (Head of Marketing, confidence: 90%)
    bob.jones@acme.com (CEO, confidence: 88%)

  Now you know: any contact at Acme uses first.last@acme.com
  → Generate emails for your target contacts at Acme
  → Verify before sending

Domain Search rules

• Use Domain Search to discover patterns, not to build lists. The contacts returned are people with publicly available emails. Your target contact may not be listed. But the pattern lets you generate their email
• Check the confidence score. Hunter provides a confidence score for patterns and individual emails. Below 70% confidence, verify before using. Above 90%, high reliability
• Small companies may have no results. Companies with < 20 employees often have too few public emails for Hunter to detect a pattern. Use direct email finding instead

Email Finding Workflow

Using Hunter in a multi-provider waterfall

For each contact (name + company domain):

1. Check Apollo first (larger database, likely to find)
   → Found: use Apollo email, verify with Hunter or NeverBounce
   → Not found: proceed to Hunter

2. Hunter Email Finder (name + domain)
   → Found with high confidence (> 80%): use it, verify
   → Not found: proceed to pattern-based generation

3. Hunter Domain Search (get the pattern)
   → Pattern found: generate email using pattern
   → Verify the generated email with Hunter Verifier
   → Verified: use it
   → Not verified: mark contact as "no email found"

Finding rules

• Hunter as secondary provider. Apollo or Clearbit as primary (larger databases). Hunter as secondary for contacts the primary misses. Hunter's pattern detection fills gaps that database lookups miss
• Always verify Hunter-found emails. Hunter's Email Finder confidence score is helpful but not a substitute for verification. Run all found emails through the Verifier before sending
• Batch finding saves credits. Use Bulk Finder for lists of 50+. Upload a CSV with name + domain columns. More efficient than individual API calls

Verification Best Practices

Verification results

Verification rules

• Verify every email before cold outbound. Hunter Verifier costs $0.01-0.03 per check. A bounce costs days of domain reputation recovery. Always verify
• Catch-all domains need special handling. Catch-all verification returns "accept-all" which means the domain accepts any email. The specific address may or may not exist. Send to catch-all addresses but monitor bounce rates separately
• Re-verify emails older than 90 days. People change jobs. Domains change. Re-verify before re-using any list older than 3 months
• Bulk verify entire lists before campaigns. Upload the complete CSV to Bulk Verifier. Download results. Remove invalid and disposable. Proceed with valid and accept-all only

API Integration

Common API patterns

# Pattern discovery + email generation + verification
import requests

def find_email(first_name, last_name, domain, api_key):
    # Step 1: Try direct email find
    resp = requests.get(
        "https://api.hunter.io/v2/email-finder",
        params={
            "domain": domain,
            "first_name": first_name,
            "last_name": last_name,
            "api_key": api_key
        }
    )
    data = resp.json().get("data", {})
    
    if data.get("email") and data.get("score", 0) > 70:
        # Step 2: Verify the found email
        return verify_email(data["email"], api_key)
    
    return None

def verify_email(email, api_key):
    resp = requests.get(
        "https://api.hunter.io/v2/email-verifier",
        params={"email": email, "api_key": api_key}
    )
    result = resp.json().get("data", {})
    if result.get("result") == "deliverable":
        return email
    return None

API rules

• Handle rate limits gracefully. Hunter API has rate limits per plan. Build in retry logic with exponential backoff
• Cache results. If you looked up john@acme.com yesterday, don't look it up again today. Cache results for 30 days minimum
• Log every API call. Track credits used, results returned, and success rates. This data helps you optimize credit usage

Credit Optimization

How to get the most from your credits

Measurement

Pre-Use Checklist

• [ ] Hunter.io account created with appropriate plan for volume
• [ ] API key configured in enrichment workflow
• [ ] Hunter positioned as secondary provider (after Apollo/Clearbit)
• [ ] Domain Search used for pattern discovery before individual lookups
• [ ] All found emails verified through Hunter Verifier or alternative
• [ ] Catch-all results handled separately (send with monitoring)
• [ ] Invalid and disposable results removed from list
• [ ] Credit usage tracked and optimized (caching, dedup, batching)
• [ ] Results logged with source and confidence score
• [ ] Re-verification scheduled for lists older than 90 days

Anti-Pattern Check

• Using Hunter as the only email provider. Hunter's database is smaller than Apollo's. As a sole provider, coverage is 50-65%. As a secondary provider after Apollo, it adds 10-15% incremental coverage. Use it in a multi-provider waterfall
• Running Email Finder for every contact at the same company. One Domain Search reveals the pattern for all contacts. Then generate emails using the pattern and verify. Don't waste credits on individual lookups when the pattern works
• Trusting confidence scores as verification. Hunter's confidence score of 85% means "we're 85% sure this email format is correct." It doesn't mean the email is deliverable. Always verify separately
• Sending to "accept-all" without monitoring. Accept-all domains accept every email, even fake ones. Your email won't bounce but may not reach a real person. Monitor engagement (opens, replies) separately for accept-all addresses
• Never caching results. You looked up acme.com's pattern last week. This week you look it up again. Wasted credit. Cache Domain Search results for at least 30 days
• Using Hunter for phone numbers. Hunter is an email tool. It doesn't provide phone numbers. Use Lusha, Cognism, or Apollo for direct dials