Email Verifier Migration

Migrate from Hunter to Tomba

This guide will help you seamlessly transition from Hunter to Tomba's email verification service, offering better accuracy, more comprehensive features, and superior value.

---

Why Choose Tomba Over Hunter?

Feature	Hunter	Tomba
Accuracy	90-95%	99%+
Pricing	$0.01 per verification	20-30% more cost-effective
Data Attributes	5-6 fields	15+ comprehensive attributes
Catchall Detection	Basic	Advanced with confidence scoring
Speed	Moderate	Ultra-fast with optimized infrastructure
Bulk Verification	Yes (limited)	Yes, with better batch processing
API Access	REST API	REST API + MCP integration
Smart Caching	No	3-month automatic caching (saves credits)
SMTP Provider Detection	No	Advanced provider identification
Whois Data	No	Comprehensive domain registration details
Source Tracking	Limited	Complete URLs and timestamps for data provenance
Greylisting Detection	No	Yes
MX Records	Basic	Complete array with all mail servers
AI Integration	No	Model Context Protocol (MCP) support

---

Key Advantages of Tomba

1. Superior Accuracy (99%+ vs Hunter's 90-95%)

Tomba achieves industry-leading accuracy through:

• Multi-layered SMTP verification
• Advanced pattern recognition
• Real-time server validation
• Machine learning algorithms
• Greylisting detection
• Provider-specific validation rules

Result: Fewer bounces, better deliverability, cleaner lists.

2. Rich Data Attributes (15+ vs Hunter's 5-6)

Tomba provides comprehensive verification data with 15+ attributes:

• Verification Results: status (valid/invalid/accept_all/etc.), result (deliverable/undeliverable/risky), score (0-100)
• SMTP Intelligence: smtp_provider (e.g., "Google Workspace"), smtp_server, smtp_check
• MX Infrastructure: Complete mx.records array, mx_check validation
• Email Quality Signals: accept_all, greylisted, block, gibberish, regex
• Email Type Detection: disposable, webmail
• Domain Insights: whois data including registrar, creation date, referral URL
• Data Provenance: sources array with URIs, extraction dates, and page status

Example comprehensive response:

Code
 
{
    "data": {
        "email": {
            "email": "dayna.winter@shopify.com",
            "result": "deliverable",
            "status": "valid",
            "score": 99,
            "smtp_provider": "Google Workspace",
            "mx": {
                "records": [
                    "aspmx.l.google.com",
                    "alt1.aspmx.l.google.com",
                    "alt2.aspmx.l.google.com",
                    "alt4.aspmx.l.google.com",
                    "alt3.aspmx.l.google.com"
                ]
            },
            "mx_check": true,
            "smtp_server": true,
            "smtp_check": true,
            "accept_all": true,
            "greylisted": false,
            "block": false,
            "gibberish": false,
            "disposable": false,
            "webmail": false,
            "regex": true,
            "whois": {
                "registrar_name": "markmonitor inc.",
                "referral_url": "http://www.markmonitor.com",
                "created_date": "2005-03-11T06:18:03+01:00"
            }
        },
        "sources": [
            {
                "uri": "https://www.shopify.com/blog/black-friday-cyber-monday-shopify-apps",
                "website_url": "www.shopify.com",
                "extracted_on": "2022-11-07T13:16:42+01:00",
                "last_seen_on": "2022-11-07T13:16:42+01:00",
                "still_on_page": true
            }
        ]
    }
}

3. Game-Changing Smart Caching

Tomba's unique advantage: Automatic 3-month verification caching

• Skip verification if email was checked within the last 3 months
• Free cached results (no credits charged)
• Instant response times for cached emails
• Automatic freshness management

Real-world impact:

• CRM contact updates: 40-60% repeat rate
• Email list maintenance: 30-50% repeat rate
• Lead verification workflows: 35-45% repeat rate

Cost savings example:

• 20,000 monthly verifications
• 45% are repeat checks within 3 months
• Hunter: $200/month (20,000 × $0.01)
• Tomba: $88/month (11,000 × $0.008, 9,000 cached = free)
• Save $112/month = $1,344/year!

4. Complete Email Finding Suite

Unlike Hunter's limited verification, Tomba offers:

• Email Finder: Find emails by name + domain
• Email Verifier: Verify email deliverability (this guide)
• Domain Search: Discover all emails at a company
• Author Finder: Find article author emails
• LinkedIn Finder: Find emails from LinkedIn profiles
• Phone Finder: Find phone numbers
• Email Enrichment: Get complete contact data

Unified platform: One API key, one dashboard, one bill.

5. SMTP Provider Intelligence

Identify actual email service providers (feature Hunter lacks):

• "Google Workspace" → Corporate email, high-value lead
• "Gmail" → Personal email, different approach needed
• "Microsoft 365" → Enterprise contact
• "Zoho Mail" → SMB segment
• And 50+ other providers

Use cases:

• Lead scoring and prioritization
• Email deliverability optimization
• Contact segmentation
• Corporate vs personal identification

6. Advanced Integration Ecosystem

• Official SDKs for 10+ languages (Node.js, Python, PHP, Ruby, Go, C#, etc.)
• Model Context Protocol (MCP) for AI tools (Claude, ChatGPT, etc.)
• Google Sheets add-on
• Microsoft Excel add-in
• Browser extensions (Chrome, Firefox, Edge, Safari)
• Webhook support for async operations
• Zapier and n8n integrations
• Apify actors
• Direct CRM integrations

---

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-verifier?email={email}

Tomba endpoint:

Code
 
GET https://api.tomba.io/v1/email-verifier?email={email}

Step 3: Update Authentication

Hunter authentication:

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

Tomba authentication:

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

Step 4: Update Response Mapping

Hunter response:

Code
 
{
    "data": {
        "status": "valid",
        "result": "deliverable",
        "score": 92,
        "email": "test@example.com",
        "regexp": true,
        "gibberish": false,
        "disposable": false,
        "webmail": false,
        "mx_records": true,
        "smtp_server": true,
        "smtp_check": true,
        "accept_all": false,
        "block": false
    }
}

Tomba response (with 15+ attributes):

Code
 
{
    "data": {
        "email": "test@example.com",
        "status": "valid",
        "result": "deliverable",
        "score": 100,
        "smtp_provider": "Google Workspace",
        "mx": {
            "records": ["mx1.example.com", "mx2.example.com"]
        },
        "mx_check": true,
        "smtp_server": true,
        "smtp_check": true,
        "accept_all": false,
        "greylisted": false,
        "block": false,
        "disposable": false,
        "webmail": false,
        "gibberish": false,
        "regex": true,
        "whois": {
            "registrar_name": "google llc",
            "created_date": "1999-09-15T04:00:00+00:00",
            "referral_url": "http://www.markmonitor.com"
        },
        "sources": [
            {
                "uri": "https://example.com/about",
                "website_url": "example.com",
                "extracted_on": "2024-01-15T10:30:00+00:00",
                "last_seen_on": "2024-11-10T14:20:00+00:00",
                "still_on_page": true
            }
        ]
    }
}

Key differences:

• smtp_provider (new): Email service identification
• greylisted (new): Greylisting detection
• whois (new): Domain registration data
• sources (new): Data provenance tracking
• mx.records (enhanced): Complete array vs boolean

---

Code Migration Examples

Node.js

Before (Hunter):

Code
 
const axios = require("axios");

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;
}

After (Tomba):

Code
 
const axios = require("axios");

async function verifyEmail(email) {
    const response = await axios.get(`https://api.tomba.io/v1/email-verifier`, {
        params: { email: email },
        headers: {
            "X-Tomba-Key": process.env.TOMBA_KEY,
            "X-Tomba-Secret": process.env.TOMBA_SECRET,
        },
    });

    const data = response.data.data;

    // Access rich attributes not available in Hunter
    console.log(`Status: ${data.status}`);
    console.log(`SMTP Provider: ${data.smtp_provider}`);
    console.log(`Score: ${data.score}`);
    console.log(`Domain Age: ${data.whois?.created_date}`);
    console.log(`Greylisted: ${data.greylisted}`);

    if (data.sources && data.sources.length > 0) {
        console.log(`Found on: ${data.sources[0].uri}`);
    }

    return data;
}

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 verifier = new Tomba.Verifier(client);

async function verifyEmail(email) {
    const result = await verifier.emailVerifier({ email: email });
    return result.data;
}

Python

Before (Hunter):

Code
 
import requests

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

After (Tomba):

Code
 
import requests

def verify_email(email):
    response = requests.get(
        'https://api.tomba.io/v1/email-verifier',
        params={'email': email},
        headers={
            'X-Tomba-Key': os.environ['TOMBA_KEY'],
            'X-Tomba-Secret': os.environ['TOMBA_SECRET']
        }
    )
    data = response.json()['data']

    # Access rich attributes
    print(f"Status: {data['status']}")
    print(f"SMTP Provider: {data.get('smtp_provider', 'N/A')}")
    print(f"Score: {data['score']}")
    print(f"Greylisted: {data.get('greylisted', False)}")

    if 'whois' in data:
        print(f"Domain Registrar: {data['whois'].get('registrar_name', 'N/A')}")

    if 'sources' in data and data['sources']:
        print(f"Found on: {data['sources'][0]['uri']}")

    return data

Using Tomba SDK (Recommended):

Code
 
from tomba import Client, Verifier

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

verifier = Verifier(client)

def verify_email(email):
    result = verifier.email_verifier(email=email)
    return result['data']

PHP

Before (Hunter):

Code
 
<?php
function verifyEmail($email) {
    $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;
}

After (Tomba):

Code
 
<?php
function verifyEmail($email) {
    $ch = curl_init('https://api.tomba.io/v1/email-verifier?email=' . urlencode($email));
    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;

    // Access rich attributes
    echo "Status: " . $data->status . "\n";
    echo "SMTP Provider: " . ($data->smtp_provider ?? 'N/A') . "\n";
    echo "Score: " . $data->score . "\n";
    echo "Greylisted: " . ($data->greylisted ? 'Yes' : 'No') . "\n";

    if (isset($data->whois)) {
        echo "Domain Registrar: " . ($data->whois->registrar_name ?? 'N/A') . "\n";
    }

    if (isset($data->sources) && count($data->sources) > 0) {
        echo "Found on: " . $data->sources[0]->uri . "\n";
    }

    return $data;
}

Using Tomba SDK (Recommended):

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

use Tomba\Client;
use Tomba\Services\Verifier;

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

$verifier = new Verifier($client);

function verifyEmail($email) {
    global $verifier;
    $result = $verifier->emailVerifier(['email' => $email]);
    return $result['data'];
}

Ruby

Before (Hunter):

Code
 
require 'httparty'

def verify_email(email)
  response = HTTParty.get(
    'https://api.hunter.io/v2/email-verifier',
    query: { email: email, api_key: ENV['HUNTER_KEY'] }
  )
  response.parsed_response['data']
end

After (Tomba):

Code
 
require 'httparty'

def verify_email(email)
  response = HTTParty.get(
    'https://api.tomba.io/v1/email-verifier',
    query: { email: email },
    headers: {
      'X-Tomba-Key' => ENV['TOMBA_KEY'],
      'X-Tomba-Secret' => ENV['TOMBA_SECRET']
    }
  )

  data = response.parsed_response['data']

  # Access rich attributes
  puts "Status: #{data['status']}"
  puts "SMTP Provider: #{data['smtp_provider']}"
  puts "Score: #{data['score']}"
  puts "Greylisted: #{data['greylisted']}"
  puts "Domain Registrar: #{data.dig('whois', 'registrar_name')}"

  if data['sources']&.any?
    puts "Found on: #{data['sources'].first['uri']}"
  end

  data
end

---

Status Mapping

Hunter Status	Hunter Result	Tomba Status	Tomba Result
valid	deliverable	valid	deliverable
invalid	undeliverable	invalid	undeliverable
accept_all	risky	accept_all	risky
unknown	unknown	unknown	risky
webmail	deliverable	valid	deliverable
disposable	undeliverable	disposable	undeliverable

Field mapping:

Hunter Field	Tomba Field	Notes
status	status	Direct mapping
result	result	Direct mapping
score	score	Direct mapping
email	email	Direct mapping
regexp	regex	Name variation
gibberish	gibberish	Direct mapping
disposable	disposable	Direct mapping
webmail	webmail	Direct mapping
mx_records	mx_check	Enhanced with mx.records array
smtp_server	smtp_server	Direct mapping
smtp_check	smtp_check	Direct mapping
accept_all	accept_all	Direct mapping
block	block	Direct mapping
N/A	smtp_provider	New: Email service provider
N/A	greylisted	New: Greylisting detection
N/A	whois	New: Domain registration data
N/A	sources	New: Data provenance tracking

---

Bulk Verification Migration

Hunter Bulk Process

Hunter's bulk verification is limited and requires CSV uploads.

Tomba Bulk Process (Superior)

Code
 
const axios = require("axios");

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

    // Get task ID for tracking
    const taskId = response.data.task_id;

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

// Example: Verify 1000 emails
const emails = ["test1@example.com", "test2@example.com" /* ... */];
const taskId = await verifyBulk(emails);

// Get results via webhook or polling

Key advantages over Hunter:

• Direct API call (no CSV uploads)
• Real-time progress tracking
• Webhook notifications
• Cached emails are free and instant (huge savings!)
• Better error handling
• Faster processing

---

Advanced Features

1. SMTP Provider Intelligence for Lead Scoring

Code
 
const scoreLeadByProvider = async (email) => {
    const data = await verifyEmail(email);

    let leadScore = data.score;

    // Adjust score based on provider
    switch (data.smtp_provider) {
        case "Google Workspace":
        case "Microsoft 365":
            leadScore += 10; // Corporate email = higher quality
            break;
        case "Gmail":
        case "Yahoo Mail":
            leadScore -= 5; // Personal email = lower priority
            break;
    }

    return {
        email: data.email,
        score: leadScore,
        provider: data.smtp_provider,
        is_corporate: [
            "Google Workspace",
            "Microsoft 365",
            "Zoho Mail",
        ].includes(data.smtp_provider),
    };
};

2. Domain Age Analysis

Code
 
const analyzeDomainAge = async (email) => {
    const data = await verifyEmail(email);

    if (data.whois && data.whois.created_date) {
        const domainAge = new Date() - new Date(data.whois.created_date);
        const years = Math.floor(domainAge / (365 * 24 * 60 * 60 * 1000));

        console.log(`Domain: ${email.split("@")[1]}`);
        console.log(`Registrar: ${data.whois.registrar_name}`);
        console.log(`Age: ${years} years`);
        console.log(`Trust Score: ${years > 2 ? "High" : "Medium"}`);

        return {
            domain_age_years: years,
            is_established: years > 2,
            registrar: data.whois.registrar_name,
        };
    }

    return null;
};

3. Source Tracking for Context

Code
 
const getEmailContext = async (email) => {
    const data = await verifyEmail(email);

    if (data.sources && data.sources.length > 0) {
        console.log(`\nEmail Context for ${email}:`);

        data.sources.forEach((source, index) => {
            console.log(`\nSource ${index + 1}:`);
            console.log(`  Page: ${source.uri}`);
            console.log(`  Website: ${source.website_url}`);
            console.log(`  First found: ${source.extracted_on}`);
            console.log(`  Last seen: ${source.last_seen_on}`);
            console.log(
                `  Still active: ${source.still_on_page ? "Yes" : "No"}`,
            );
        });

        return data.sources;
    }

    console.log("No source data available");
    return [];
};

4. Greylisting Detection

Code
 
const handleGreylisting = async (email) => {
    const data = await verifyEmail(email);

    if (data.greylisted) {
        console.log(`Warning: ${email} is greylisted`);
        console.log("Recommendation: Retry verification in 5 minutes");

        // Wait and retry
        await new Promise((resolve) => setTimeout(resolve, 300000)); // 5 min

        const retryData = await verifyEmail(email);
        console.log(`Retry result: ${retryData.status}`);

        return retryData;
    }

    return data;
};

5. Model Context Protocol (MCP) Integration

Integrate with AI tools for natural language email verification:

Code
 
// .claude/config.json
{
    "mcpServers": {
        "tomba": {
            "command": "npx",
            "args": ["-y", "@tomba-io/mcp"]
        }
    }
}

Now ask Claude:

• "Verify john.doe@example.com and tell me about the company"
• "Check if these 10 emails are valid: [list]"
• "Find the SMTP provider for contacts in my CRM"

---

Cost Comparison Calculator

Code
 
const compareHunterVsTomba = (monthlyVolume, repeatPercentage) => {
    // Hunter costs
    const hunterCostPerEmail = 0.01;
    const hunterMonthlyCost = monthlyVolume * hunterCostPerEmail;

    // Tomba costs (with caching advantage)
    const tombaCostPerEmail = 0.008;
    const newVerifications = monthlyVolume * (1 - repeatPercentage / 100);
    const cachedVerifications = monthlyVolume - newVerifications;
    const tombaMonthlyCost = newVerifications * tombaCostPerEmail;

    // Savings
    const monthlySavings = hunterMonthlyCost - tombaMonthlyCost;
    const savingsPercentage = (monthlySavings / hunterMonthlyCost) * 100;
    const annualSavings = monthlySavings * 12;

    console.log(`\n=== Hunter vs Tomba Cost Comparison ===`);
    console.log(
        `Monthly volume: ${monthlyVolume.toLocaleString()} verifications`,
    );
    console.log(`Repeat rate: ${repeatPercentage}% (cached in Tomba)`);
    console.log(`\n--- Hunter ---`);
    console.log(`Cost per email: $${hunterCostPerEmail}`);
    console.log(`Monthly cost: $${hunterMonthlyCost.toFixed(2)}`);
    console.log(`Annual cost: $${(hunterMonthlyCost * 12).toFixed(2)}`);
    console.log(`\n--- Tomba ---`);
    console.log(`Cost per email: $${tombaCostPerEmail}`);
    console.log(
        `New verifications: ${newVerifications.toLocaleString()} ($${(newVerifications * tombaCostPerEmail).toFixed(2)})`,
    );
    console.log(
        `Cached verifications: ${cachedVerifications.toLocaleString()} (FREE)`,
    );
    console.log(`Monthly cost: $${tombaMonthlyCost.toFixed(2)}`);
    console.log(`Annual cost: $${(tombaMonthlyCost * 12).toFixed(2)}`);
    console.log(`\n--- Savings ---`);
    console.log(
        `Monthly savings: $${monthlySavings.toFixed(2)} (${savingsPercentage.toFixed(1)}%)`,
    );
    console.log(`Annual savings: $${annualSavings.toFixed(2)}`);
    console.log(`\n--- Bonus ---`);
    console.log(`Extra data attributes: 15+ vs 5-6`);
    console.log(`SMTP provider detection: Yes vs No`);
    console.log(`Whois data: Yes vs No`);
    console.log(`Source tracking: Yes vs Limited`);
    console.log(`MCP AI integration: Yes vs No`);
};

// Examples
console.log("Small business:");
compareHunterVsTomba(5000, 35);

console.log("\n\nMedium business:");
compareHunterVsTomba(20000, 40);

console.log("\n\nEnterprise:");
compareHunterVsTomba(100000, 45);

Sample output:

Code
 
Small business:
Monthly volume: 5,000 verifications
Repeat rate: 35% (cached in Tomba)
Monthly savings: $24.00 (48.0%)
Annual savings: $288.00

Medium business:
Monthly volume: 20,000 verifications
Repeat rate: 40% (cached in Tomba)
Monthly savings: $104.00 (52.0%)
Annual savings: $1,248.00

Enterprise:
Monthly volume: 100,000 verifications
Repeat rate: 45% (cached in Tomba)
Monthly savings: $560.00 (56.0%)
Annual savings: $6,720.00

---

Testing Your Migration

Parallel Testing Script

Code
 
const testHunterVsTomba = async (testEmails) => {
    console.log("Email,Hunter Status,Tomba Status,SMTP Provider,Whois,Sources");

    for (const email of testEmails) {
        try {
            const [hunter, tomba] = await Promise.all([
                verifyWithHunter(email),
                verifyWithTomba(email),
            ]);

            console.log(
                `${email},${hunter.status},${tomba.status},` +
                    `"${tomba.smtp_provider || "N/A"}",` +
                    `"${tomba.whois?.registrar_name || "N/A"}",` +
                    `"${tomba.sources?.length || 0} sources"`,
            );
        } catch (error) {
            console.error(`Error testing ${email}:`, error.message);
        }
    }
};

// Test with real emails
testHunterVsTomba([
    "contact@shopify.com",
    "support@microsoft.com",
    "invalid@nonexistent-domain-xyz.com",
    "test@gmail.com",
]);

---

Migration Checklist

• Sign up for Tomba account at app.tomba.io
• Generate API credentials (Key + Secret)
• Install Tomba SDK for your language (optional but recommended)
• Update API endpoints (hunter.io → tomba.io)
• Update authentication (query param → headers)
• Update response parsing to handle new structure
• Leverage new attributes (smtp_provider, whois, sources, greylisted)
• Run parallel tests (Hunter vs Tomba)
• Compare accuracy and data richness
• Calculate actual cost savings with caching
• Update bulk verification code
• Set up webhooks for async operations (optional)
• Update error handling
• Migrate email finding workflows (domain search, etc.)
• Update documentation
• Train team on new features
• Monitor performance and savings
• Decommission Hunter integration

---

Support and Resources

• Tomba API Documentation
• Email Verifier Attributes
• Bulk Verification Guide
• Domain Search Guide
• SDKs and Libraries
• MCP Integration Guide
• Support Portal

Need help with migration? Contact our support team for personalized assistance and custom migration plans.

---

FAQ

Q: Will I lose any features by switching from Hunter? A: No! Tomba provides all Hunter verification features PLUS 15+ data attributes, smart caching, SMTP provider detection, whois data, source tracking, greylisting detection, and MCP integration.

Q: What about Hunter's email finding features? A: Tomba offers superior email finding tools:

• Domain Search (find all emails at a company)
• Email Finder (find email by name + domain)
• Author Finder (find article author emails)
• LinkedIn Finder (find emails from LinkedIn profiles)
• Email Enrichment (complete contact data)

Q: How much can I save with caching? A: With typical 40% repeat rates, you can save 50%+ on verification costs. For 20k monthly verifications, that's $100+/month or $1,200+/year.

Q: What is SMTP provider detection? A: Tomba identifies the actual email service (Google Workspace, Microsoft 365, Gmail, etc.). This helps with lead scoring, segmentation, and identifying corporate vs personal emails.

Q: Can I access domain registration data? A: Yes! Tomba includes whois data (registrar, creation date, URL) for every verified email. Use this to assess domain age, legitimacy, and trust level.

Q: How does source tracking work? A: When available, Tomba provides complete URLs where the email was found, along with extraction dates and current page status. This gives valuable context about your contacts.

Q: Is migration complex? A: No! The APIs are similar, and migration typically takes 1-2 hours. Our SDKs make it even easier with minimal code changes.

Q: Can I test before migrating? A: Yes! Sign up for a free account with 25 verifications to test side-by-side with Hunter.

Q: What if I have a high-volume enterprise account? A: Contact our sales team for custom enterprise pricing, dedicated support, and white-glove migration assistance.

Q: Does Tomba support international emails? A: Yes! Tomba supports international email verification with superior accuracy across all regions.

Q: Can I integrate with AI tools? A: Yes! Tomba supports Model Context Protocol (MCP), allowing AI assistants like Claude to verify emails naturally in conversation.

Q: What about API rate limits? A: Tomba offers generous rate limits. Contact us if you need higher limits for enterprise use cases.