# Migrate from MillionVerifier to Tomba

This guide will help you seamlessly transition from MillionVerifier to Tomba's email verification service, offering superior accuracy, richer data attributes, and better value.

---

## Why Choose Tomba Over MillionVerifier?

| Feature                     | MillionVerifier     | Tomba                                |
| --------------------------- | ------------------- | ------------------------------------ |
| **Accuracy**                | 96-98%              | 99%+                                 |
| **Pricing**                 | $4 per 1,000 emails | More competitive with flexible plans |
| **Catchall Detection**      | Basic               | Advanced with risk scoring           |
| **Speed**                   | Standard            | Ultra-fast with smart caching        |
| **Bulk Verification**       | Yes                 | Yes, with better API integration     |
| **API Access**              | REST API            | REST API + MCP + Multiple SDKs       |
| **Data Attributes**         | 8 attributes        | 15+ comprehensive attributes         |
| **Real-time Caching**       | No                  | Yes, 3-month smart caching           |
| **SMTP Provider Detection** | No                  | Yes, detailed provider info          |
| **Integration Options**     | Limited             | Extensive (50+ integrations)         |

---

## Key Advantages of Tomba

### 1. Higher Accuracy Rate

Tomba achieves 99%+ accuracy through:

- Advanced SMTP validation
- Real-time mailbox verification
- Multi-source cross-referencing
- AI-powered pattern detection

### 2. More Comprehensive Data (15+ Attributes)

Beyond basic verification, Tomba provides rich data attributes:

- **Verification Results**: `status`, `result`, `score` (0-100)
- **SMTP Details**: `smtp_provider` (Google Workspace, Microsoft 365, etc.), `smtp_server`, `smtp_check`
- **MX Records**: Complete `mx.records` array with all mail servers
- **Email Quality**: `mx_check`, `regex`, `accept_all`, `greylisted`, `block`, `gibberish`
- **Email Type Detection**: `disposable`, `webmail`
- **Domain Information**: `whois` data (registrar, creation date, referral URL)
- **Data Sources**: `sources` array showing where email was found with timestamps

**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. Better Developer Experience

- Multiple official SDKs (Node.js, Python, PHP, Ruby, Go, etc.)
- Model Context Protocol (MCP) support for AI integrations
- Comprehensive API documentation
- OpenAPI specification

### 4. Smart Caching System

- 3-month verification caching
- Saves credits on repeat verifications
- Instant results for cached emails
- Automatic freshness management

### 5. Flexible Integration

- Direct API access
- Bulk CSV upload
- Google Sheets add-on
- Excel add-in
- Chrome extension

---

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

**MillionVerifier endpoint:**

```
https://api.millionverifier.com/api/v3/?api={api_key}&email={email}
```

**Tomba endpoint:**

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

### Step 3: Update Authentication

**MillionVerifier authentication:**

```javascript
// API key in URL parameter
const url = `https://api.millionverifier.com/api/v3/?api=${API_KEY}&email=${email}`;
```

**Tomba authentication:**

```javascript
// API key in headers (more secure)
const headers = {
    "X-Tomba-Key": API_KEY,
    "X-Tomba-Secret": SECRET_KEY,
};
```

### Step 4: Update Response Handling

**MillionVerifier response:**

```json
{
    "email": "test@example.com",
    "quality": "good",
    "result": "ok",
    "resultcode": 1,
    "subresult": "none",
    "free": false,
    "role": false,
    "didyoumean": ""
}
```

**Tomba response:**

```json
{
    "data": {
        "email": "test@example.com",
        "status": "valid",
        "result": "deliverable",
        "score": 100,
        "regex": true,
        "mx_records": ["mail.example.com"],
        "mx_check": true,
        "smtp_server": true,
        "smtp_check": true,
        "smtp_provider": "Google Workspace",
        "accept_all": false,
        "block": false,
        "gibberish": false,
        "disposable": false,
        "webmail": false,
        "greylisted": false
    }
}
```

---

## Code Migration Examples

### Node.js

**Before (MillionVerifier):**

```javascript
const axios = require("axios");

async function verifyEmail(email) {
    const response = await axios.get(
        `https://api.millionverifier.com/api/v3/?api=${process.env.MV_API_KEY}&email=${email}`,
    );

    return response.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 },
        headers: {
            "X-Tomba-Key": process.env.TOMBA_KEY,
            "X-Tomba-Secret": process.env.TOMBA_SECRET,
        },
    });

    return response.data.data;
}

// Or use the official SDK
import { TombaClient, Verifier } from "tomba";

// Init Tomba
let client = new TombaClient();

let verifier = new Verifier(client);

client
    .setKey("ta_xxxx") // Your Key
    .setSecret("ts_xxxx"); // Your Secret

async function verifyEmail(email) {
    const verifier = new Tomba.Verifier(client);
    return await verifier.emailVerifier(email);
}
```

### Python

**Before (MillionVerifier):**

```python
import requests

def verify_email(email):
    url = f"https://api.millionverifier.com/api/v3/"
    params = {
        'api': os.environ['MV_API_KEY'],
        'email': email
    }

    response = requests.get(url, params=params)
    return response.json()
```

**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']
        }
    )
    return response.json()['data']

# Or use the official SDK
from tomba import Client, Verifier

client = Client(os.environ['TOMBA_KEY'], os.environ['TOMBA_SECRET'])
verifier = Verifier(client)

def verify_email(email):
    return verifier.email_verifier(email)
```

### PHP

**Before (MillionVerifier):**

```php
<?php
function verifyEmail($email) {
    $api_key = $_ENV['MV_API_KEY'];
    $url = "https://api.millionverifier.com/api/v3/?api={$api_key}&email=" . urlencode($email);

    $response = file_get_contents($url);
    return json_decode($response);
}
```

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

    return json_decode($response)->data;
}

// Or use the official SDK
require 'vendor/autoload.php';
use Tomba\Client;
use Tomba\Services\Verifier;

$client = new Client($_ENV['TOMBA_KEY'], $_ENV['TOMBA_SECRET']);
$verifier = new Verifier($client);

function verifyEmail($email) {
    return $verifier->emailVerifier($email);
}
```

---

## Result Code Mapping

| MillionVerifier Result | MillionVerifier Code | Tomba Status | Tomba Result    |
| ---------------------- | -------------------- | ------------ | --------------- |
| `ok`                   | 1                    | `valid`      | `deliverable`   |
| `catch_all`            | 2                    | `accept_all` | `risky`         |
| `unknown`              | 3                    | `unknown`    | `risky`         |
| `invalid`              | 4                    | `invalid`    | `undeliverable` |
| `disposable`           | 5                    | `disposable` | `undeliverable` |

---

## Bulk Verification Migration

**MillionVerifier bulk process:**

```bash
# Upload file
curl -X POST https://bulkapi.millionverifier.com/api/v2/upload \
  -F "file=@emails.csv" \
  -F "api=YOUR_API_KEY"

# Check status and download
```

**Tomba bulk process:**

```javascript
import { TombaClient, Verifier } from "tomba";

// Init Tomba
let client = new TombaClient();

let verifier = new Verifier(client);

client
    .setKey("ta_xxxx") // Your Key
    .setSecret("ts_xxxx"); // Your Secret

// Bulk verification with array
const bulkVerify = async (emails) => {
    const response = await axios.post(
        "https://api.tomba.io/v1/bulk/email-verifier",
        { emails },
        {
            headers: {
                "X-Tomba-Key": API_KEY,
                "X-Tomba-Secret": SECRET_KEY,
            },
        },
    );

    return response.data;
};

// Or upload CSV directly through dashboard
```

---

## Advanced Features Comparison

### Tomba Exclusive Features

1. **SMTP Provider Detection**

    ```json
    {
        "smtp_provider": "Google Workspace"
    }
    ```

2. **Greylisting Detection**

    ```json
    {
        "greylisted": false
    }
    ```

3. **Confidence Scoring**

    ```json
    {
        "score": 95
    }
    ```

4. **MX Record Details**

    ```json
    {
        "mx_records": ["aspmx.l.google.com", "alt1.aspmx.l.google.com"]
    }
    ```

5. **Smart Caching**
    - Automatic 3-month caching
    - No extra charges for cached results
    - Always up-to-date verification dates

---

## Testing Your Migration

### Comparison Test Script

```javascript
const testEmails = [
    "valid@example.com",
    "invalid@example.com",
    "catchall@example.com",
];

async function compareServices(email) {
    // Test with MillionVerifier
    const mvResult = await millionVerifierCheck(email);

    // Test with Tomba
    const tombaResult = await tombaCheck(email);

    console.log({
        email,
        millionverifier: mvResult.result,
        tomba: tombaResult.result,
        tomba_extras: {
            score: tombaResult.score,
            smtp_provider: tombaResult.smtp_provider,
            accept_all: tombaResult.accept_all,
        },
    });
}

// Run comparison
for (const email of testEmails) {
    await compareServices(email);
}
```

---

## Pricing Comparison

| Volume     | MillionVerifier | Tomba   | Savings           |
| ---------- | --------------- | ------- | ----------------- |
| 1,000      | $4.00           | $3.50   | 12.5%             |
| 10,000     | $30.00          | $25.00  | 16.7%             |
| 100,000    | $200.00         | $150.00 | 25%               |
| Enterprise | Custom          | Custom  | Contact for quote |

_Prices are approximate and subject to change. Check current pricing on respective websites._

---

## 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)
- [SDK Libraries](https://docs.tomba.io/libraries)
- [Support Portal](https://help.tomba.io)

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

---

## FAQ

**Q: Is the accuracy really better?**
A: Yes, Tomba consistently achieves 99%+ accuracy with advanced SMTP validation and multi-source verification.

**Q: Will I get more data per verification?**
A: Absolutely! Tomba returns 15+ attributes compared to MillionVerifier's 8, including SMTP provider, MX records, and more.

**Q: How does the smart caching work?**
A: Verifications are cached for 3 months. Re-verifying the same email within this period returns instant results at no charge.

**Q: Can I import my email list from MillionVerifier?**
A: Yes, simply export your list from MillionVerifier and upload to Tomba's bulk verification interface.

**Q: Do you offer a trial?**
A: Yes! Start with our free plan that includes 25 verifications to test the service.