# 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:**

```json
{
    "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)
- 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](https://app.tomba.io)
2. Navigate to **API** → **API Keys**
3. Copy your **API Key** and **Secret Key**

### Step 2: Update API Endpoints

**Hunter endpoint:**

```
GET https://api.hunter.io/v2/email-verifier?email={email}
```

**Tomba endpoint:**

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

### Step 3: Update Authentication

**Hunter authentication:**

```javascript
{
  "params": {
    "api_key": "your_hunter_key"
  }
}
```

**Tomba authentication:**

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

### Step 4: Update Response Mapping

**Hunter response:**

```json
{
    "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):**

```json
{
    "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):**

```javascript
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):**

```javascript
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):**

```javascript
const Tomba = require("tomba") {4-5};

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):**

```python
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):**

```python
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):**

```python
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):**

```php
<?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):**

```php
<?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):**

```php
<?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):**

```ruby
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):**

```ruby
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)

```javascript
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
- Cached emails are free and instant (huge savings!)
- Better error handling
- Faster processing

---

## Advanced Features

### 1. SMTP Provider Intelligence for Lead Scoring

```javascript
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

```javascript
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

```javascript
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

```javascript
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:

```json
// .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

```javascript
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:**

```
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

```javascript
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
- [ ] 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](https://docs.tomba.io)
- [Email Verifier Attributes](https://docs.tomba.io/attributes/verifier)
- [Bulk Verification Guide](https://docs.tomba.io/bulks/email-verifier)
- [Domain Search Guide](https://docs.tomba.io/bulks/domain-search)
- [SDKs and Libraries](https://docs.tomba.io/libraries)
- [MCP Integration Guide](https://docs.tomba.io/llm)
- [Support Portal](https://help.tomba.io)

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.