# 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           | 450M+ 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 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 (450M+ 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**

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

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

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

**Similar Companies**

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

**Phone Finder**

```javascript
// 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](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-finder
```

**Tomba endpoint:**

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

### Step 3: Update Authentication

**Hunter authentication (query parameter):**

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

**Tomba authentication (headers):**

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

### Step 4: Update Response Mapping

**Hunter response:**

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

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

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

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

```javascript {4-5}
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):**

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

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

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

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

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

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

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

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

```javascript
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: $49/month (2,500 searches)
- Email verification: (2,500 searches)
- **Total: $49/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

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

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

```javascript
// Detect tech stack for better targeting
const result = await axios.get("https://api.tomba.io/v1/technology", {
    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

```javascript
// Find similar companies to expand TAM
const result = await axios.get("https://api.tomba.io/v1/similar", {
    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

```javascript
// 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](https://docs.tomba.io)
- [Email Finder API Reference](https://docs.tomba.io/api#tag/Email-Finder)
- [Domain Search API Reference](https://docs.tomba.io/api#tag/Domain-Search)
- [Author Finder Guide](https://docs.tomba.io/bulks/author-finder)
- [LinkedIn Finder Guide](https://docs.tomba.io/bulks/linkedin-finder)
- [SDKs and Libraries](https://docs.tomba.io/libraries)
- [Chrome Extension](https://chrome.google.com/webstore/detail/tomba-email-finder/icmjegjggphchjckknoooajmklibccjb)
- [Support Portal](https://help.tomba.io)

Need help with migration? [Contact our team](https://app.tomba.io/contact) 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.