Bulk Email Verifier

Verify email deliverability at scale. No external API costs — all verification is done natively using DNS, SMTP, and a 55,000+ domain disposable email database.

What it does

Give it a list of emails and it checks:

• Syntax — valid email format (RFC 5322)
• MX records — domain can receive email (DNS lookup)
• SMTP verification — mailbox exists on the server (deep mode)
• Disposable detection — temporary/throwaway providers (55K+ domains)
• Role-based detection — info@, admin@, support@, noreply@, etc.
• Free provider detection — gmail, yahoo, outlook, etc.
• Catch-all detection — flags domains that accept any address

Each email gets a confidence score (0-100) and a status: valid, risky, invalid, unknown, or disposable.

Key features

• No external API costs — uses native DNS and SMTP, no ZeroBounce/NeverBounce subscription needed
• Three verification levels — basic (fast), standard (recommended), deep (SMTP)
• Confidence scoring — 0-100 score with detailed check breakdown
• Disposable email database — 55,000+ known temporary providers
• Per-domain MX caching — efficient for bulk lists with many emails at the same domain
• Catch-all detection — identifies domains that accept all addresses
• Concurrent processing — configurable parallelism for speed

Verification levels

Level	Checks	Speed	Accuracy
Basic	Syntax + MX records	~50ms/email	~75%
Standard	+ Disposable + Role + Free	~50ms/email	~80%
Deep	+ SMTP + Catch-all	~2-10s/email	~95%

Example output

{
    "email": "test@apify.com",
    "status": "valid",
    "confidence": 70,
    "checks": {
        "syntax": true,
        "disposable": false,
        "roleAddress": false,
        "freeProvider": false,
        "mxRecords": true,
        "smtpCheck": null,
        "catchAll": null
    },
    "mxHost": "aspmx.l.google.com",
    "reason": null,
    "verifiedAt": "2026-02-07T12:00:00.000Z"
}

Input

Field	Type	Default	Description
emails	string[]	required	Email addresses to verify
verificationLevel	enum	"standard"	basic, standard, or deep
smtpTimeout	integer (3-30)	10	SMTP timeout in seconds (deep mode)
maxConcurrency	integer (1-10)	5	Parallel verification threads
proxyConfiguration	object	Apify Proxy	Proxy for SMTP connections

Status values

Status	Meaning	Confidence
valid	High confidence deliverable	70-95
risky	Might deliver, uncertain	30-69
invalid	Will not deliver	0-29
unknown	Catch-all or SMTP timeout	40-60
disposable	Temporary/throwaway email	20

Use cases

• Lead list cleaning — remove invalid emails before outreach campaigns
• CRM hygiene — verify contacts in your HubSpot, Salesforce, or email lists
• Form validation — verify emails submitted through web forms
• Marketing campaigns — reduce bounce rates by pre-verifying recipients
• Data quality — score email reliability in datasets

Pipeline integration

Chain with our B2B lead generation actors:

1. B2B Lead Gen Suite — Find leads with emails
2. Bulk Email Verifier — Verify which emails are deliverable
3. HubSpot Lead Pusher — Push verified leads to CRM

API usage

Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("ryanclinton/bulk-email-verifier").call(
    run_input={
        "emails": ["ceo@stripe.com", "test@mailinator.com", "nobody@nonexistent.xyz"],
        "verificationLevel": "standard",
    }
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['email']}: {item['status']} ({item['confidence']}%)")

JavaScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('ryanclinton/bulk-email-verifier').call({
    emails: ['ceo@stripe.com', 'test@mailinator.com', 'nobody@nonexistent.xyz'],
    verificationLevel: 'standard',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(item => {
    console.log(`${item.email}: ${item.status} (${item.confidence}%)`);
});

How it works

1. Syntax check — validates email format against RFC 5322
2. MX lookup — queries DNS for mail exchange records (cached per domain)
3. Disposable check — matches against 55,000+ known temporary email providers
4. Role-based check — identifies functional addresses (info@, admin@, etc.)
5. SMTP check (deep mode) — connects to mail server, sends EHLO/MAIL FROM/RCPT TO without actually sending email
6. Catch-all check (deep mode) — tests a random address to detect servers that accept everything

Limitations

• SMTP verification (deep mode) may be blocked by some mail servers
• Catch-all domains cannot be reliably verified — results are flagged as "unknown"
• Some corporate mail servers silently accept all emails (greylisting)
• Deep mode is significantly slower due to SMTP connection overhead
• Standard mode does not verify individual mailbox existence