Email Finder Migration

Migrate from Hunter Email Finder to Tomba

This guide will help you seamlessly transition from Hunter's email finder to Tomba, offering better accuracy, free verification, more data points, and 40% cost savings.

---

Why Switch from Hunter to Tomba?

Feature	Hunter	Tomba
Database Size	200M emails	500M+ emails
Accuracy	85-90%	98%+ with built-in verification
Email Verification	$0.01 extra per email	FREE with every search
Data Attributes	5-6 fields	20+ comprehensive fields
Domain Search	Yes	Yes, with advanced filters
Author Finder	No	Extract emails from article URLs
LinkedIn Finder	No	Direct LinkedIn profile to email
Phone Numbers	No	Phone Finder & Phone Validator included
Technology Detection	No	Detect tech stack (6000+ technologies)
Similar Companies	No	Find similar companies to expand reach
Bulk Operations	Yes (limited)	Yes, with webhooks and real-time tracking
Chrome Extension	✅	✅ More features
Google Sheets	✅	✅ Enhanced add-on
Excel Integration	❌	✅ Native add-in
Airtable Extension	❌	✅ Native extension
MCP/AI Integration	❌	✅ Works with Claude, ChatGPT, etc.
API Rate Limits	100 req/min	300 req/min (3x faster)
Pricing (1000 searches)	~$99/month	~$59/month (40% savings)

---

Key Advantages of Tomba

1. Free Email Verification (Save $10-20/month per 1000 emails)

Hunter: Charges separately for verification ($0.01 per email)

• Find email: $0.05
• Verify email: $0.01
• Total: $0.06 per verified email

Tomba: Verification included FREE

• Find email: $0.03 (includes verification)
• Total: $0.03 per verified email

Savings: 50% per email!

Every email found with Tomba is automatically verified:

• SMTP validation
• MX record check
• Deliverability status
• Accept-all detection
• Disposable email detection
• Confidence score (0-100)

2. Larger Database (500M+ vs 200M emails)

Tomba's database is 2.5x larger than Hunter's:

• More companies covered
• Better international coverage
• More recent data
• Higher find rates for niche industries

3. Rich Data Attributes (20+ vs 5-6 fields)

Hunter provides:

• Email, First name, Last name, Position, Domain, Confidence

Tomba provides all of that PLUS:

• Phone numbers
• LinkedIn profile
• Twitter handle
• Department
• Seniority level
• Company size
• Company industry
• Company location
• Founded year
• Company revenue
• Technology stack
• Sources (URLs where found)
• Verification details
• Last verified date
• Email type (generic/personal)

4. Unique Features Not in Hunter

Author Finder

Code
 
// Find email from article URL (Tomba only!)
const author = await tomba.authorFinder({
    url: "https://stripe.com/blog/article-title",
});
// Returns: author email, name, position, social profiles

LinkedIn Finder

Code
 
// Find email from LinkedIn profile (Tomba only!)
const contact = await tomba.linkedinFinder({
    url: "https://linkedin.com/in/john-doe",
});
// Returns: email, phone, full profile data

Technology Detection

Code
 
// Detect tech stack (Tomba only!)
const tech = await tomba.technologyFinder({
    domain: "stripe.com",
});
// Returns: 50+ technologies used by the company

Similar Companies

Code
 
// Find similar companies (Tomba only!)
const similar = await tomba.similarFinder({
    domain: "stripe.com",
});
// Returns: 25 similar companies to expand your target list

Phone Finder

Code
 
// Find phone numbers (Tomba only!)
const phone = await tomba.phoneFinder({
    full_name: "John Doe",
    domain: "stripe.com",
});
// Returns: verified phone numbers

---

Migration Steps

Step 1: Get Your Tomba API Credentials

1. Sign up at app.tomba.io
2. Navigate to API → API Keys
3. Copy your API Key and Secret Key

Step 2: Update API Endpoints

Hunter endpoint:

Code
 
GET https://api.hunter.io/v2/email-finder

Tomba endpoint:

Code
 
GET https://api.tomba.io/v1/email-finder

Step 3: Update Authentication

Hunter authentication (query parameter):

Code
 
{
    params: {
        api_key: "your_hunter_key";
    }
}

Tomba authentication (headers):

Code
 
{
  headers: {
    'X-Tomba-Key': 'your_api_key',
    'X-Tomba-Secret': 'your_secret_key'
  }
}

Step 4: Update Response Mapping

Hunter response:

Code
 
{
    "data": {
        "first_name": "John",
        "last_name": "Doe",
        "email": "john.doe@stripe.com",
        "score": 92,
        "position": "CTO",
        "twitter": null,
        "linkedin_url": null,
        "phone_number": null,
        "company": "Stripe",
        "sources": []
    }
}

Tomba response (more data!):

Code
 
{
    "data": {
        "email": "john.doe@stripe.com",
        "first_name": "John",
        "last_name": "Doe",
        "full_name": "John Doe",
        "position": "Chief Technology Officer",
        "department": "Engineering",
        "seniority": "executive",
        "phone_number": "+1-415-XXX-XXXX",
        "linkedin": "https://linkedin.com/in/johndoe",
        "twitter": "@johndoe",
        "score": 95,
        "verification": {
            "status": "valid",
            "result": "deliverable",
            "mx_check": true,
            "smtp_check": true,
            "accept_all": false,
            "disposable": false,
            "webmail": false,
            "last_verified": "2024-11-13T10:30:00Z"
        },
        "company": {
            "name": "Stripe",
            "domain": "stripe.com",
            "industry": "Financial Services",
            "size": "5000-10000",
            "location": "San Francisco, CA",
            "founded": 2010
        },
        "sources": [
            {
                "uri": "https://stripe.com/about",
                "extracted_on": "2024-10-15",
                "still_on_page": true
            }
        ]
    }
}

---

Code Migration Examples

Node.js

Before (Hunter):

Code
 
const axios = require("axios");

async function findEmail(domain, firstName, lastName) {
    const response = await axios.get("https://api.hunter.io/v2/email-finder", {
        params: {
            domain: domain,
            first_name: firstName,
            last_name: lastName,
            api_key: process.env.HUNTER_KEY,
        },
    });

    return response.data.data;
}

// Need separate call for verification
async function verifyEmail(email) {
    const response = await axios.get(
        "https://api.hunter.io/v2/email-verifier",
        {
            params: {
                email: email,
                api_key: process.env.HUNTER_KEY,
            },
        },
    );

    return response.data.data;
}

// Usage: 2 API calls = 2x cost
const found = await findEmail("stripe.com", "John", "Doe");
const verified = await verifyEmail(found.email); // Extra cost!

After (Tomba):

Code
 
const axios = require("axios");

async function findEmail(domain, firstName, lastName) {
    const response = await axios.get("https://api.tomba.io/v1/email-finder", {
        params: {
            domain: domain,
            first_name: firstName,
            last_name: lastName,
        },
        headers: {
            "X-Tomba-Key": process.env.TOMBA_KEY,
            "X-Tomba-Secret": process.env.TOMBA_SECRET,
        },
    });

    // Verification included for FREE!
    const data = response.data.data;
    console.log(`Email: ${data.email}`);
    console.log(`Verified: ${data.verification.status}`);
    console.log(`Score: ${data.score}`);

    return data;
}

// Usage: 1 API call with FREE verification!
const result = await findEmail("stripe.com", "John", "Doe");
// result.verification.status = "valid"
// result.verification.mx_check = true
// result.verification.smtp_check = true

Using Tomba SDK (Recommended):

Code
 
const Tomba = require("tomba");

const client = new Tomba.Client()
    .setKey(process.env.TOMBA_KEY)
    .setSecret(process.env.TOMBA_SECRET);

const finder = new Tomba.Finder(client);

async function findEmail(domain, firstName, lastName) {
    const result = await finder.emailFinder({
        domain: domain,
        first_name: firstName,
        last_name: lastName,
    });

    return result.data;
}

// Bonus: Access unique Tomba features
const search = new Tomba.Search(client);
const emails = await search.domainSearch({ domain: "stripe.com" });

const author = new Tomba.Finder(client);
const authorEmail = await author.authorFinder({
    url: "https://stripe.com/blog/article",
});

Python

Before (Hunter):

Code
 
import requests

def find_email(domain, first_name, last_name):
    response = requests.get(
        'https://api.hunter.io/v2/email-finder',
        params={
            'domain': domain,
            'first_name': first_name,
            'last_name': last_name,
            'api_key': os.environ['HUNTER_KEY']
        }
    )
    return response.json()['data']

def verify_email(email):
    # Extra API call = extra cost
    response = requests.get(
        'https://api.hunter.io/v2/email-verifier',
        params={
            'email': email,
            'api_key': os.environ['HUNTER_KEY']
        }
    )
    return response.json()['data']

# Usage: 2 calls, double cost
found = find_email('stripe.com', 'John', 'Doe')
verified = verify_email(found['email'])

After (Tomba):

Code
 
import requests

def find_email(domain, first_name, last_name):
    response = requests.get(
        'https://api.tomba.io/v1/email-finder',
        params={
            'domain': domain,
            'first_name': first_name,
            'last_name': last_name
        },
        headers={
            'X-Tomba-Key': os.environ['TOMBA_KEY'],
            'X-Tomba-Secret': os.environ['TOMBA_SECRET']
        }
    )

    data = response.json()['data']

    # Verification included FREE!
    print(f"Email: {data['email']}")
    print(f"Verified: {data['verification']['status']}")
    print(f"Score: {data['score']}")
    print(f"Phone: {data.get('phone_number', 'N/A')}")

    return data

# Usage: 1 call with FREE verification
result = find_email('stripe.com', 'John', 'Doe')

Using Tomba SDK (Recommended):

Code
 
from tomba import Client, Finder, Search

client = Client()
client.set_key(os.environ['TOMBA_KEY'])
client.set_secret(os.environ['TOMBA_SECRET'])

finder = Finder(client)

def find_email(domain, first_name, last_name):
    result = finder.email_finder(
        domain=domain,
        first_name=first_name,
        last_name=last_name
    )
    return result['data']

# Bonus: Unique Tomba features
search = Search(client)
all_emails = search.domain_search(domain='stripe.com')

author_email = finder.author_finder(
    url='https://stripe.com/blog/article'
)

linkedin_email = finder.linkedin_finder(
    url='https://linkedin.com/in/johndoe'
)

PHP

Before (Hunter):

Code
 
<?php
function findEmail($domain, $firstName, $lastName) {
    $url = 'https://api.hunter.io/v2/email-finder?' . http_build_query([
        'domain' => $domain,
        'first_name' => $firstName,
        'last_name' => $lastName,
        'api_key' => $_ENV['HUNTER_KEY']
    ]);

    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    $response = curl_exec($ch);
    curl_close($ch);

    return json_decode($response)->data;
}

function verifyEmail($email) {
    // Extra cost for verification
    $url = 'https://api.hunter.io/v2/email-verifier?' . http_build_query([
        'email' => $email,
        'api_key' => $_ENV['HUNTER_KEY']
    ]);

    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    $response = curl_exec($ch);
    curl_close($ch);

    return json_decode($response)->data;
}

// 2 API calls needed
$found = findEmail('stripe.com', 'John', 'Doe');
$verified = verifyEmail($found->email);

After (Tomba):

Code
 
<?php
function findEmail($domain, $firstName, $lastName) {
    $url = 'https://api.tomba.io/v1/email-finder?' . http_build_query([
        'domain' => $domain,
        'first_name' => $firstName,
        'last_name' => $lastName
    ]);

    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        'X-Tomba-Key: ' . $_ENV['TOMBA_KEY'],
        'X-Tomba-Secret: ' . $_ENV['TOMBA_SECRET']
    ]);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

    $response = curl_exec($ch);
    curl_close($ch);

    $data = json_decode($response)->data;

    // Verification included FREE!
    echo "Email: " . $data->email . "\n";
    echo "Verified: " . $data->verification->status . "\n";
    echo "Score: " . $data->score . "\n";
    echo "Phone: " . ($data->phone_number ?? 'N/A') . "\n";

    return $data;
}

// 1 API call with FREE verification
$result = findEmail('stripe.com', 'John', 'Doe');

Using Tomba SDK (Recommended):

Code
 
<?php
require 'vendor/autoload.php';

use Tomba\Client;
use Tomba\Services\Finder;
use Tomba\Services\Search;

$client = new Client();
$client->setKey($_ENV['TOMBA_KEY'])
       ->setSecret($_ENV['TOMBA_SECRET']);

$finder = new Finder($client);

function findEmail($domain, $firstName, $lastName) {
    global $finder;
    $result = $finder->emailFinder([
        'domain' => $domain,
        'first_name' => $firstName,
        'last_name' => $lastName
    ]);
    return $result['data'];
}

// Bonus features
$search = new Search($client);
$allEmails = $search->domainSearch(['domain' => 'stripe.com']);

$authorEmail = $finder->authorFinder([
    'url' => 'https://stripe.com/blog/article'
]);

$linkedinEmail = $finder->linkedinFinder([
    'url' => 'https://linkedin.com/in/johndoe'
]);

---

Domain Search Migration

Hunter Domain Search

Before (Hunter):

Code
 
const response = await axios.get("https://api.hunter.io/v2/domain-search", {
    params: {
        domain: "stripe.com",
        limit: 50,
        api_key: process.env.HUNTER_KEY,
    },
});

const emails = response.data.data.emails;
// Returns basic email list

After (Tomba with more filters):

Code
 
const response = await axios.get("https://api.tomba.io/v1/domain-search", {
    params: {
        domain: "stripe.com",
        limit: 50,
        // Additional filters not in Hunter:
        department: "engineering",
        seniority: "executive",
        position: "CTO",
    },
    headers: {
        "X-Tomba-Key": process.env.TOMBA_KEY,
        "X-Tomba-Secret": process.env.TOMBA_SECRET,
    },
});

const data = response.data.data;
// Returns MORE data per email:
// - Verification status (FREE!)
// - Phone numbers
// - LinkedIn profiles
// - Department
// - Seniority
// - Sources

---

Bulk Operations Migration

Hunter Bulk Finder

Hunter: Limited bulk API, often requires CSV upload

Tomba: Direct API with real-time tracking

Code
 
const axios = require("axios");

async function bulkFind(contacts) {
    // contacts = [{domain: 'stripe.com', first_name: 'John', last_name: 'Doe'}, ...]

    const response = await axios.post(
        "https://api.tomba.io/v1/bulk/email-finder",
        { contacts: contacts },
        {
            headers: {
                "X-Tomba-Key": process.env.TOMBA_KEY,
                "X-Tomba-Secret": process.env.TOMBA_SECRET,
            },
        },
    );

    const taskId = response.data.task_id;

    // Set up webhook or poll for results
    return taskId;
}

// Process 1000s of contacts
const contacts = [
    { domain: "stripe.com", first_name: "John", last_name: "Doe" },
    { domain: "shopify.com", first_name: "Jane", last_name: "Smith" },
    // ... thousands more
];

const taskId = await bulkFind(contacts);

---

Cost Comparison

Scenario: Finding 1000 emails/month

Hunter:

• Base plan: $49/month (1,000 searches)
• Email verification: $10/month (1,000 verifications @ $0.01)
• Total: $59/month

Tomba:

• Base plan: $29/month (1,000 searches)
• Email verification: FREE
• Total: $29/month

💰 Savings: $30/month = $360/year (51% cheaper!)

Scenario: Finding 5000 emails/month

Hunter:

• Business plan: $199/month (5,000 searches)
• Email verification: $50/month (5,000 verifications @ $0.01)
• Total: $249/month

Tomba:

• Growth plan: $149/month (5,000 searches)
• Email verification: FREE
• Total: $149/month

💰 Savings: $100/month = $1,200/year (40% cheaper!)

---

Advanced Features Only in Tomba

1. Author Finder

Code
 
// Find email from blog post or article URL
const result = await axios.get("https://api.tomba.io/v1/author-finder", {
    params: { url: "https://stripe.com/blog/engineering-culture" },
    headers: { "X-Tomba-Key": KEY, "X-Tomba-Secret": SECRET },
});

// Returns: author email, name, position, social profiles

2. LinkedIn Finder

Code
 
// Find email from LinkedIn profile
const result = await axios.get("https://api.tomba.io/v1/linkedin", {
    params: { url: "https://linkedin.com/in/john-doe-stripe" },
    headers: { "X-Tomba-Key": KEY, "X-Tomba-Secret": SECRET },
});

// Returns: email, phone, full profile enrichment

3. Technology Detection

Code
 
// Detect tech stack for better targeting
const result = await axios.get("https://api.tomba.io/v1/technology-finder", {
    params: { domain: "stripe.com" },
    headers: { "X-Tomba-Key": KEY, "X-Tomba-Secret": SECRET },
});

// Returns: React, Node.js, AWS, Kubernetes, etc. (1000+ techs)
// Use for: tech-specific outreach, competitive intelligence

4. Similar Companies

Code
 
// Find similar companies to expand TAM
const result = await axios.get("https://api.tomba.io/v1/similar-finder", {
    params: { domain: "stripe.com" },
    headers: { "X-Tomba-Key": KEY, "X-Tomba-Secret": SECRET },
});

// Returns: 25 similar companies
// Use for: lookalike targeting, market expansion

5. Phone Finder

Code
 
// Find phone numbers (not available in Hunter)
const result = await axios.get("https://api.tomba.io/v1/phone-finder", {
    params: {
        full_name: "John Doe",
        domain: "stripe.com",
    },
    headers: { "X-Tomba-Key": KEY, "X-Tomba-Secret": SECRET },
});

// Returns: verified phone numbers

---

Migration Checklist

• Sign up for Tomba account at app.tomba.io
• Generate API credentials (Key + Secret)
• Install Tomba SDK for your language (optional)
• Update API endpoints (hunter.io → tomba.io)
• Update authentication (query param → headers)
• Update response parsing for new data structure
• Remove separate verification calls (now FREE!)
• Test email finder with sample data
• Test domain search with filters
• Migrate bulk operations
• Set up webhooks (optional)
• Explore unique features (Author, LinkedIn, Tech, etc.)
• Update Chrome extension/integrations
• Train team on new features
• Calculate actual cost savings
• Monitor performance and accuracy
• Cancel Hunter subscription

---

Support and Resources

• Tomba API Documentation
• Email Finder API Reference
• Domain Search API Reference
• Author Finder Guide
• LinkedIn Finder Guide
• SDKs and Libraries
• Chrome Extension
• Support Portal

Need help with migration? Contact our team for dedicated support and migration assistance.

---

FAQ

Q: Will I lose any features switching from Hunter? A: No! Tomba has all Hunter features PLUS verification (free), phone finder, author finder, LinkedIn finder, technology detection, and more.

Q: Is verification really free? A: Yes! Every email found is automatically verified at no extra cost. This alone saves $10-50/month depending on volume.

Q: How much can I save? A: Most customers save 40-50% by switching to Tomba. For 5,000 monthly searches, that's $1,200/year in savings.

Q: How accurate is Tomba compared to Hunter? A: Tomba achieves 98%+ accuracy vs Hunter's 85-90%, thanks to our larger database and built-in verification.

Q: Can I migrate my saved searches? A: Yes! Export from Hunter and import to Tomba via CSV or API. We provide migration assistance for large datasets.

Q: What about API rate limits? A: Tomba allows 300 requests/minute vs Hunter's 100 req/min - 3x faster!

Q: Do you have a Chrome extension? A: Yes! Our Chrome extension works on LinkedIn, company websites, and has more features than Hunter's.

Q: Can I try before migrating? A: Absolutely! Sign up for a free account with 25 searches to test accuracy and features side-by-side with Hunter.

Q: How long does migration take? A: Most teams complete migration in 1-2 days. API changes are minimal, and we provide code examples for all major languages.

Q: Do you offer enterprise support? A: Yes! Enterprise customers get dedicated support, custom integrations, higher rate limits, and white-glove migration assistance.