Hunter.io Complete Guide: Domain Search, Email Finder, and Verification

What Hunter.io Actually Does

Hunter.io is one of the oldest and most established email finding tools on the market. Founded in 2015, it has built its reputation on a simple value proposition: give it a domain, and it will return the email addresses associated with that company.

Unlike all-in-one sales platforms like Apollo, Hunter stays focused on email. It does three things: find emails, verify emails, and send cold email campaigns. That focus is both its strength and its limitation.

This guide covers every feature in depth, with practical advice on when Hunter is the right tool and when you should look elsewhere. For a head-to-head comparison with other tools, see our 2026 email finder benchmark.

Core Features

1. Domain Search

Domain Search is Hunter’s flagship feature. Enter a company domain, and Hunter returns all the email addresses it has found associated with that domain, along with the sources where each address was discovered.

How it works:

Hunter crawls the public web — websites, social profiles, public documents, press releases — and indexes email addresses linked to specific domains. When you search a domain, you get back a list of addresses with:

The full email address
The person’s name and job title (when available)
The source URLs where the address was found
A confidence score
The email pattern used by that domain (e.g., {first}.{last}@domain.com)

Practical example:

curl "https://api.hunter.io/v2/domain-search?domain=intercom.com&api_key=YOUR_KEY"

Response (simplified):

{
  "data": {
    "domain": "intercom.com",
    "pattern": "{first}",
    "emails": [
      {
        "value": "[email protected]",
        "type": "personal",
        "confidence": 96,
        "first_name": "Eoghan",
        "last_name": "McCabe",
        "position": "CEO",
        "sources": [
          {
            "domain": "techcrunch.com",
            "uri": "https://techcrunch.com/...",
            "extracted_on": "2025-11-14"
          }
        ]
      }
    ]
  }
}

When Domain Search is useful:

Building a prospect list at a specific company
Discovering the email pattern used by a domain before guessing addresses
Finding the right department contacts (filter by department in the UI)
Mapping out a company’s org chart from publicly available email data

Limitations:

Only returns emails that have been publicly indexed. Private or recently created addresses will not appear.
Coverage is weaker for small companies and non-English-speaking regions.
Results include some outdated addresses from people who have left the company.

2. Email Finder

While Domain Search gives you all known emails at a company, Email Finder takes a person’s name and company domain and returns their specific email address.

curl "https://api.hunter.io/v2/email-finder?domain=stripe.com&first_name=Patrick&last_name=Collison&api_key=YOUR_KEY"

Hunter’s Email Finder works by:

Checking its database for a known email for that person at that domain
If not found, identifying the email pattern used by that domain
Generating the most likely email based on the pattern
Running a verification check on the generated address

The confidence score reflects how certain Hunter is about the result. In our benchmark testing, Hunter achieved 84.7% accuracy across 500 contacts, which places it solidly in the middle of the pack — reliable but not best-in-class.

Key detail: Hunter will sometimes return a pattern-guessed email at a catch-all domain with a moderate confidence score. These emails cannot be truly verified. If you see a confidence score below 80 on a catch-all domain, treat that result with caution. For more on how catch-all domains affect verification, see our email verification guide.

3. Email Verifier

Hunter’s verification service checks whether an email address is deliverable. It performs:

Format check: Validates the email format
MX record lookup: Confirms the domain has mail servers
SMTP verification: Connects to the mail server and checks if the mailbox exists
Catch-all detection: Identifies domains that accept all addresses

Verification uses separate credits from email finding. The results are categorized as:

Status	Meaning	Should You Send?
valid	Mailbox exists and accepts mail	Yes
invalid	Mailbox does not exist	No
accept_all	Domain accepts everything (catch-all)	Maybe — risky
webmail	Free email provider (gmail, yahoo)	Yes, but likely personal
disposable	Temporary email service	No
unknown	Could not determine	Verify manually or skip

Bulk verification is available through the UI (upload a CSV) or the API. If you are cleaning an existing list before a campaign, Hunter’s verifier is solid and competitively priced.

import requests

def verify_email(email, api_key):
    url = f"https://api.hunter.io/v2/email-verifier"
    params = {"email": email, "api_key": api_key}
    response = requests.get(url, params=params)
    data = response.json()["data"]
    return {
        "email": email,
        "status": data["status"],       # valid, invalid, accept_all, etc.
        "score": data["score"],          # 0-100
        "mx_records": data["mx_records"],
        "smtp_server": data["smtp_server"],
        "smtp_check": data["smtp_check"],
    }

result = verify_email("[email protected]", "YOUR_API_KEY")
print(f"Status: {result['status']}, Score: {result['score']}")

4. Campaigns (Cold Email)

Hunter added a built-in cold email sending feature called Campaigns. It is a basic but functional cold email tool that connects to your Gmail or Outlook account and lets you:

Write email sequences with follow-ups
Personalize using merge fields
Track opens, clicks, and replies
Set sending schedules and daily limits
A/B test subject lines

Honest assessment: Hunter Campaigns is adequate for low-volume outreach (under 200 emails/day). It lacks the advanced features of dedicated cold email tools like Lemlist, Smartlead, or Instantly — no inbox rotation, no advanced deliverability features, limited analytics. But if you want a simple all-in-one workflow (find -> verify -> send) without juggling multiple tools, it gets the job done.

The Chrome Extension

Hunter’s Chrome extension is one of its best features for day-to-day prospecting. Install it and you can:

On any website: Click the extension to see all email addresses associated with that domain
On LinkedIn: View the email address for the profile you are looking at (LinkedIn URL enrichment)
On company websites: One-click domain search without switching to Hunter’s web app

The extension is free and works with the free Hunter plan (limited to 25 searches/month).

Pro tip: The LinkedIn integration is the most practical use case. When you are scrolling through LinkedIn search results and want to quickly grab someone’s email, the extension saves significant time compared to switching between tabs.

API Deep Dive

Hunter’s API is well-documented and straightforward. Here are the endpoints you will use most:

Rate Limits and Authentication

All requests are authenticated with an API key passed as a query parameter. Rate limits depend on your plan:

Plan	Requests/Second	Monthly Searches	Monthly Verifications
Free	10	25	50
Starter ($49/mo)	20	500	1,000
Growth ($149/mo)	30	5,000	10,000
Business ($499/mo)	40	50,000	100,000

Batch Processing

For high-volume lookups, Hunter supports bulk operations via CSV upload through the dashboard, but the API itself is single-request. If you need to process thousands of lookups, you will need to build your own batching logic:

import time
import csv
from concurrent.futures import ThreadPoolExecutor

def find_email_hunter(first_name, last_name, domain, api_key):
    url = "https://api.hunter.io/v2/email-finder"
    params = {
        "first_name": first_name,
        "last_name": last_name,
        "domain": domain,
        "api_key": api_key,
    }
    response = requests.get(url, params=params)
    if response.status_code == 429:
        time.sleep(1)  # Rate limited -- wait and retry
        return find_email_hunter(first_name, last_name, domain, api_key)
    return response.json()

# Process a CSV of contacts
def process_contacts(input_file, output_file, api_key):
    with open(input_file) as f:
        contacts = list(csv.DictReader(f))

    results = []
    for contact in contacts:
        result = find_email_hunter(
            contact["first_name"],
            contact["last_name"],
            contact["domain"],
            api_key
        )
        email = result.get("data", {}).get("email")
        confidence = result.get("data", {}).get("confidence", 0)
        results.append({
            **contact,
            "found_email": email,
            "confidence": confidence,
        })
        time.sleep(0.1)  # Respect rate limits

    with open(output_file, "w", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=results[0].keys())
        writer.writeheader()
        writer.writerows(results)

process_contacts("prospects.csv", "enriched.csv", "YOUR_API_KEY")

Useful Endpoints Summary

Endpoint	Method	Purpose	Credits Used
`/v2/domain-search`	GET	Find all emails at a domain	1 search per request
`/v2/email-finder`	GET	Find email for a specific person	1 search per result found
`/v2/email-verifier`	GET	Verify a single email	1 verification
`/v2/email-count`	GET	Count emails at a domain (free)	0
`/v2/account`	GET	Check your account/usage	0

The /v2/email-count endpoint is especially useful — it lets you check how many emails Hunter has for a domain before spending search credits. Use it to prioritize which companies are worth a full domain search.

Pricing Breakdown (June 2026)

Plan	Monthly Price	Searches	Verifications	Best For
Free	$0	25	50	Testing, occasional lookups
Starter	$49	500	1,000	Individual SDRs, freelancers
Growth	$149	5,000	10,000	Small sales teams
Business	$499	50,000	100,000	High-volume operations

Important pricing notes:

Searches and verifications are separate credit pools. Finding an email uses a search credit. Verifying it uses a verification credit.
Failed searches do not consume credits. If Hunter cannot find an email, you are not charged. This is a significant advantage over tools that charge per lookup regardless of outcome.
Unused credits do not roll over to the next month.
Annual billing saves roughly 30%.

When Hunter Is the Right Choice

Hunter excels when:

You need domain-level research (who works at company X?)
You want transparent sourcing (Hunter shows where each email was found)
You prefer a focused tool over an all-in-one platform
You are doing moderate-volume prospecting (under 5,000 lookups/month)
You want a clean, well-documented API for integrations
You need the Chrome extension for LinkedIn prospecting

Hunter is not the best choice when:

You need the highest possible accuracy (Findymail outperformed Hunter in our benchmark by ~8 percentage points)
You need phone numbers alongside emails (Hunter is email-only)
You need a full sales intelligence platform with intent data, org charts, and sequencing
You are doing very high volume (50,000+ lookups/month) and need the best per-email economics
You need strong coverage for European or APAC contacts

Hunter vs. Alternatives

Feature	Hunter.io	Findymail	Apollo.io
Email accuracy	84.7%	93.2%	81.3%
Coverage	72.6%	78.4%	88.2%
Built-in verification	Separate credits	Included	Partial
Phone numbers	No	No	Yes
CRM features	No	No	Yes
Free tier	25 searches	10 credits	10,000 credits
API quality	Excellent	Good	Good
Chrome extension	Excellent	Good	Good

For the full comparison across eight tools, see the 2026 benchmark results.

If your workflow involves chaining multiple email finders together, Hunter works well as part of a waterfall enrichment strategy. Its transparent confidence scoring makes it easy to set thresholds for when to fall through to a secondary provider.

Practical Setup: Hunter + CRM Integration

Hunter integrates natively with Salesforce, HubSpot, Pipedrive, and Zoho. Here is the typical setup flow:

Connect your CRM in Hunter’s dashboard under Integrations
Set up lead routing: When you find an email through Hunter, you can push the contact directly to your CRM with one click
Map fields: Match Hunter’s data fields (name, email, company, position) to your CRM’s contact properties
Enable auto-verification: Set Hunter to automatically verify emails before pushing to CRM

For teams using Hunter’s Campaigns feature, you can sync campaign activity (opens, clicks, replies) back to your CRM, keeping your sales records up to date.

Tips for Getting the Most Out of Hunter

Always check email count before domain search. Use the free /v2/email-count endpoint to see if Hunter has useful data on a domain before spending credits.
Filter domain search by department. If you are targeting marketing decision-makers, filter by the “marketing” department to avoid burning through results on irrelevant contacts.
Set a confidence threshold. In our testing, Hunter emails with confidence scores above 90 had a 92% accuracy rate. Emails with confidence below 70 dropped to 68% accuracy. Set your threshold accordingly.
Verify before sending. Even though Hunter includes a verification step in email finding, run a separate verification on any address older than 30 days. People change jobs frequently, and a result from last month may already be stale.
Use Hunter as part of a waterfall. Hunter is a strong first-pass tool due to its transparent sourcing and confidence scoring. Use it first, then pass “not found” results to a tool with broader coverage like Apollo. See our waterfall enrichment guide for the full approach.

Bottom Line

Hunter.io is a solid, reliable email finding tool with an excellent API and Chrome extension. It is not the most accurate tool on the market, and it does not try to be an all-in-one sales platform. What it does, it does well: finding and verifying business email addresses with clear sourcing and transparent confidence scores.

For individual SDRs and small teams doing moderate-volume prospecting, Hunter remains one of the best options. For teams that need higher accuracy, consider Findymail. For teams that need a broader platform, look at Apollo.