Email Verifier Migration

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:

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. 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
• Webhook notifications
• 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
2. Navigate to API → API Keys
3. Copy your API Key and Secret Key

Step 2: Update API Endpoints

MillionVerifier endpoint:

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

Tomba endpoint:

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

Step 3: Update Authentication

MillionVerifier authentication:

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

Tomba authentication:

Code
 
// 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:

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

Tomba response:

Code
 
{
    "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):

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

Code
 
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
const Tomba = require("@tomba-io/node");
const client = new Tomba.Client(
    process.env.TOMBA_KEY,
    process.env.TOMBA_SECRET,
);

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

Python

Before (MillionVerifier):

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

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']
        }
    )
    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):

Code
 
<?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):

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

    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:

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

Code
 
const Tomba = require("@tomba-io/node");
const client = new Tomba.Client(API_KEY, SECRET_KEY);

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

   Code
    
   {
       "smtp_provider": "Google Workspace"
   }

2. Greylisting Detection

   Code
    
   {
       "greylisted": false
   }

3. Confidence Scoring

   Code
    
   {
       "score": 95
   }

4. MX Record Details

   Code
    
   {
       "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

Code
 
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
• Email Verifier Attributes
• Bulk Verification Guide
• SDK Libraries
• Support Portal

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.