Bulk Email Verifier

Validate the deliverability of email addresses at scale without sending a single message. Paste in your email list and the actor checks each address through multiple verification layers: syntax validation against RFC 5322, DNS MX record lookups, disposable and temporary provider detection (powered by the MailChecker database of 55,000+ disposable domains), role-based address flagging, free provider identification, live SMTP mailbox verification, and catch-all domain detection.

Every email receives a status classification (valid, invalid, risky, disposable, or unknown) along with a confidence score from 0 to 100 and a detailed breakdown of which checks passed or failed. The actor deduplicates inputs, normalizes casing, groups emails by domain for efficient MX record caching, and processes them in parallel with configurable concurrency.

This tool is built for marketers cleaning mailing lists, sales teams validating lead data, developers integrating email verification into automated pipelines, and anyone who needs to reduce bounce rates before sending campaigns. There are no external API costs -- all verification logic runs natively inside the actor using DNS queries and direct SMTP connections.

Why Use This on Apify

Running email verification on Apify gives you serverless infrastructure that handles DNS resolution and SMTP connections from cloud IP addresses, avoiding reputation risks to your own mail server or network. You get automatic scaling, scheduled runs for recurring list cleaning, and direct integration with dozens of downstream tools through the Apify platform.

Unlike SaaS email verification services that charge per-email fees, this actor runs on Apify compute credits only. There are no third-party API keys required and no per-verification pricing. For teams processing thousands of emails regularly, this translates to significant cost savings.

The actor also fits naturally into larger Apify workflows. Pair it with lead generation actors to automatically verify scraped contact data, or schedule weekly runs to keep your CRM lists clean.

Key Features

• Three verification levels -- choose Basic (syntax + MX only), Standard (adds disposable, role-based, and free provider detection), or Deep (adds live SMTP mailbox verification and catch-all detection)
• Confidence scoring -- every email gets a 0-100 confidence score reflecting how certain the verification result is
• Disposable email detection -- identifies 55,000+ temporary and throwaway email domains using the MailChecker library
• Role-based address flagging -- detects 60+ functional prefixes like info@, admin@, support@, noreply@ that indicate non-personal addresses
• Free provider identification -- flags addresses from 60+ free email services (Gmail, Yahoo, Outlook, ProtonMail, etc.)
• SMTP mailbox verification -- connects to the mail server and checks whether the specific mailbox exists, without sending any email
• Catch-all domain detection -- identifies domains that accept all addresses regardless of whether the mailbox exists, reducing false positives
• MX record caching -- groups emails by domain and caches DNS lookups, making large batch verifications faster
• Automatic deduplication -- removes duplicate entries and normalizes email casing before processing
• Configurable concurrency -- process 1 to 10 emails simultaneously with built-in rate limiting for SMTP checks
• No external API costs -- all verification runs natively using DNS and SMTP protocols

How to Use

1. Navigate to the Bulk Email Verifier actor page on Apify Store.
2. Click Try for free to open the actor in Apify Console.
3. In the Email addresses field, enter or paste the email addresses you want to verify (one per line, or use the string list editor).
4. Select a Verification level:
   • Basic -- fastest, checks syntax and DNS MX records only
   • Standard (recommended) -- adds disposable, role-based, and free provider detection
   • Deep -- adds live SMTP mailbox verification and catch-all detection (slowest but most accurate)
5. Optionally adjust the SMTP timeout (default 10 seconds) and Max concurrent checks (default 5).
6. Click Start to run the verification.
7. Once complete, view results in the Dataset tab. Export as JSON, CSV, or Excel.

Input Parameters

Parameter	Type	Required	Default	Description
emails	string[]	Yes	--	List of email addresses to verify. One result per email.
verificationLevel	string	No	standard	Verification depth: basic (syntax + MX), standard (+ disposable/role/free detection), or deep (+ SMTP mailbox check).
smtpTimeout	integer	No	10	Maximum seconds to wait for SMTP server response. Only used in deep verification mode. Range: 3-30.
maxConcurrency	integer	No	5	Number of emails to verify in parallel. Lower values are safer for SMTP checks. Range: 1-10.
proxyConfiguration	object	No	Apify Proxy	Proxy settings for SMTP connections. Recommended for deep verification to avoid IP reputation issues.

Input Examples

Standard verification for a marketing list:

{
    "emails": [
        "john.smith@example.com",
        "jane@acme-corp.com",
        "test@mailinator.com",
        "info@bigcompany.org"
    ],
    "verificationLevel": "standard"
}

Deep verification with conservative settings:

{
    "emails": ["contact@prospect.com", "ceo@target-company.io"],
    "verificationLevel": "deep",
    "smtpTimeout": 15,
    "maxConcurrency": 2
}

Quick syntax + MX check for a large list:

{
    "emails": ["addr1@a.com", "addr2@b.com", "...thousands more..."],
    "verificationLevel": "basic",
    "maxConcurrency": 10
}

Input Tips

• Use basic for lists over 10,000 emails where speed matters most. It catches typos and dead domains without the SMTP overhead.
• Set maxConcurrency to 2-3 for deep verification to avoid triggering mail server rate limits.
• Increase smtpTimeout to 15-20 seconds when verifying addresses on slower mail servers or in regions with high latency.
• Duplicates and whitespace are automatically cleaned -- no need to deduplicate your input list first.

Output Example

Each verified email produces one result object in the dataset:

{
  "email": "john.smith@example.com",
  "status": "valid",
  "confidence": 95,
  "checks": {
    "syntax": true,
    "disposable": false,
    "roleAddress": false,
    "freeProvider": false,
    "mxRecords": true,
    "smtpCheck": true,
    "catchAll": false
  },
  "mxHost": "mx1.example.com",
  "reason": null,
  "verifiedAt": "2025-01-15T10:30:45.123Z"
}

{
  "email": "test@mailinator.com",
  "status": "disposable",
  "confidence": 20,
  "checks": {
    "syntax": true,
    "disposable": true,
    "roleAddress": false,
    "freeProvider": false,
    "mxRecords": true,
    "smtpCheck": null,
    "catchAll": null
  },
  "mxHost": "mail.mailinator.com",
  "reason": "Disposable/temporary email provider",
  "verifiedAt": "2025-01-15T10:30:46.456Z"
}

{
  "email": "nobody@nonexistent-domain-xyz.com",
  "status": "invalid",
  "confidence": 5,
  "checks": {
    "syntax": true,
    "disposable": false,
    "roleAddress": false,
    "freeProvider": false,
    "mxRecords": false,
    "smtpCheck": null,
    "catchAll": null
  },
  "mxHost": null,
  "reason": "Domain has no MX records (cannot receive email)",
  "verifiedAt": "2025-01-15T10:30:47.789Z"
}

Output Fields

Field	Type	Description
email	string	The normalized (lowercase, trimmed) email address
status	string	Overall verdict: valid, invalid, risky, disposable, or unknown
confidence	number	Confidence score from 0 (certainly invalid) to 95 (SMTP-confirmed, not catch-all)
checks.syntax	boolean	Whether the email passes RFC 5322 syntax validation
checks.disposable	boolean/null	Whether the domain is a known disposable email provider (null if not checked)
checks.roleAddress	boolean/null	Whether the local part is a role-based prefix like info@, admin@, support@
checks.freeProvider	boolean/null	Whether the domain is a free email provider like Gmail, Yahoo, Outlook
checks.mxRecords	boolean	Whether the domain has valid MX (mail exchange) DNS records
checks.smtpCheck	boolean/null	Whether the SMTP server accepted the address (null if not checked or failed)
checks.catchAll	boolean/null	Whether the domain accepts all addresses regardless of mailbox existence
mxHost	string/null	The primary MX server hostname for the domain
reason	string/null	Human-readable explanation for non-valid results
verifiedAt	string	ISO 8601 timestamp of when the verification was performed

Use via API

You can run Bulk Email Verifier programmatically using the Apify API. This is useful for integrating email verification into automated workflows where upstream actors scrape contacts and this actor validates them.

Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("ryanclinton/bulk-email-verifier").call(run_input={
    "emails": [
        "john@example.com",
        "test@mailinator.com",
        "nobody@fake-domain-xyz.com",
    ],
    "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_APIFY_TOKEN' });

const run = await client.actor('ryanclinton/bulk-email-verifier').call({
    emails: [
        'john@example.com',
        'test@mailinator.com',
        'nobody@fake-domain-xyz.com',
    ],
    verificationLevel: 'standard',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(item => {
    console.log(`${item.email}: ${item.status} (${item.confidence}%)`);
});

cURL

curl "https://api.apify.com/v2/acts/ryanclinton~bulk-email-verifier/runs?token=YOUR_APIFY_TOKEN" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "emails": ["john@example.com", "test@mailinator.com"],
    "verificationLevel": "standard"
  }'

How It Works

The actor runs a multi-stage verification pipeline. Each stage adds more checks, and you choose how deep to go with the verificationLevel parameter.

┌─────────────────────────────────────────────┐
│  INPUT: Deduplicate + normalize emails      │
│  Group by domain for MX cache efficiency    │
└────────────────────┬────────────────────────┘
                     │
          ┌──────────▼──────────┐
          │  1. Syntax Check    │  RFC 5322 regex (all levels)
          │  ✗ → invalid (0%)   │
          └──────────┬──────────┘
          ┌──────────▼──────────┐
          │  2. Standard Checks │  standard + deep levels only
          │  • Disposable       │  MailChecker (55,000+ domains)
          │  • Role-based       │  60+ prefixes (info@, admin@...)
          │  • Free provider    │  60+ domains (gmail, yahoo...)
          └──────────┬──────────┘
          ┌──────────▼──────────┐
          │  3. DNS MX Lookup   │  dns.resolveMx (all levels)
          │  Cached per domain  │
          │  ✗ → invalid (5%)   │
          └──────────┬──────────┘
          ┌──────────▼──────────┐
          │  4. SMTP Verify     │  deep level only
          │  EHLO → MAIL FROM   │  Port 25 connection
          │  → RCPT TO → QUIT   │
          └──────────┬──────────┘
          ┌──────────▼──────────┐
          │  5. Catch-All Test  │  deep level only (if SMTP passed)
          │  Random address     │  500ms delay, then re-test
          └──────────┬──────────┘
          ┌──────────▼──────────┐
          │  SCORE + CLASSIFY   │  confidence score + status
          └─────────────────────┘

Verification Level Comparison

Feature	Basic	Standard	Deep
Syntax validation	Yes	Yes	Yes
DNS MX records	Yes	Yes	Yes
Disposable detection	--	Yes	Yes
Role-based flagging	--	Yes	Yes
Free provider detection	--	Yes	Yes
SMTP mailbox check	--	--	Yes
Catch-all detection	--	--	Yes
Speed (1,000 emails)	~30 sec	~30 sec	5-15 min
Max confidence	70	70	95

SMTP Conversation Flow

In deep verification mode, the actor opens a TCP connection to the mail server's port 25 and speaks enough SMTP protocol to determine if the mailbox exists:

Actor                         Mail Server (MX host)
  │                                │
  ├──── TCP connect :25 ──────────►│
  │◄──── 220 greeting ────────────┤
  ├──── EHLO verify.apify.com ───►│
  │◄──── 250 OK ──────────────────┤
  ├──── MAIL FROM:<verify@...> ──►│
  │◄──── 250 OK ──────────────────┤
  ├──── RCPT TO:<target@...> ────►│
  │◄──── 250 = valid ─────────────┤  ← Mailbox exists
  │◄──── 550 = invalid ───────────┤  ← Mailbox does not exist
  │◄──── other = unknown ─────────┤  ← Cannot determine
  ├──── QUIT ─────────────────────►│
  │◄──── 221 Bye ─────────────────┤

No email content is ever sent. The conversation stops at RCPT TO and disconnects immediately.

Confidence Scoring Algorithm

The confidence score is deterministic, based purely on which checks passed or failed:

Condition	Confidence	Status
Invalid syntax	0	invalid
No MX records	5	invalid
Disposable domain	20	disposable
SMTP rejected (550)	10	invalid
SMTP valid + catch-all domain	50	unknown
SMTP valid + catch-all unknown	80	valid
SMTP valid + not catch-all	95	valid
MX exists, no SMTP check	70	valid
MX exists + role-based	65	valid
MX exists + free provider	65	valid
MX exists + role + free	60	risky

Status thresholds: valid at confidence >= 70, risky at >= 30, invalid below 30.

Domain-Level Caching

The actor groups emails by domain and caches two types of lookups:

• MX record cache -- DNS MX records are resolved once per domain and reused for all emails on that domain. This means verifying 100 emails at @company.com only does one DNS lookup.
• Catch-all cache -- The catch-all test (sending a random address) is performed once per domain and cached. If randomstring@company.com is accepted, all addresses at that domain are marked as catch-all.

This caching strategy makes the actor significantly faster for lists with many emails on the same domain.

Cost

The actor runs on Apify platform compute credits only. There are no external API fees.

Mode	100 Emails	1,000 Emails	10,000 Emails
Basic	~5 sec, <$0.01	~30 sec, ~$0.01	~5 min, ~$0.05
Standard	~5 sec, <$0.01	~30 sec, ~$0.01	~5 min, ~$0.05
Deep	~1 min, ~$0.01	~10 min, ~$0.10	~90 min, ~$0.75

One compute unit (CU) equals 1 GB-hour. The actor uses 256 MB of memory. Actual deep verification times depend on SMTP server response times, timeout settings, and concurrency.

Tips

1. Start with Standard mode for the best balance of speed and accuracy. Only use Deep mode when you need SMTP-level mailbox confirmation.

2. Lower concurrency for Deep mode -- set maxConcurrency to 2-3 when using deep verification to avoid triggering rate limits on mail servers.

3. Use proxies for Deep verification -- enable Apify Proxy to distribute SMTP connections across different IP addresses and avoid reputation blocks.

4. Check the confidence score, not just the status -- a "valid" email with confidence 60 is less reliable than one with confidence 95. Use confidence thresholds that match your risk tolerance.

5. Watch for catch-all domains -- these domains accept all addresses, so even invalid mailboxes appear valid at the SMTP level. The actor flags these as unknown status to prevent false positives.

6. Process large lists in batches -- for lists over 10,000 emails, consider splitting into multiple runs to stay within timeout limits and manage memory.

7. Filter disposable emails first -- if you are cleaning a signup list, disposable detection alone (Standard mode) catches most throwaway addresses without the overhead of SMTP checks.

8. Verify before pushing to CRM -- chain this actor with HubSpot Lead Pusher to ensure only verified emails enter your CRM. This reduces bounce rates and protects your sender reputation.

Limitations

• SMTP verification is not 100% reliable. Some mail servers use greylisting (temporarily rejecting new senders) which can cause valid emails to show as unknown. Large providers like Gmail and Microsoft often return ambiguous responses.
• Catch-all domains limit accuracy. When a domain accepts all addresses (catch-all), the actor cannot confirm whether a specific mailbox exists. These emails get confidence 50 and status unknown.
• No email sending. The actor verifies deliverability at the protocol level but does not confirm the recipient actually reads email or that the address is actively used.
• IP reputation affects SMTP checks. Apify cloud IPs may be blocked by some mail servers. Using Apify Proxy (residential or datacenter) improves SMTP success rates for deep verification.
• Free provider SMTP limitations. Gmail, Yahoo, Outlook, and other large providers actively block or mislead SMTP verification attempts. Standard mode is often just as useful as Deep mode for these domains.
• No bulk import from files. The actor accepts email arrays via JSON input only. To verify from a CSV file, convert it to a JSON array or use the Apify API to pass the data programmatically.
• Role prefixes are English-only. The 60+ role-based prefixes (info@, admin@, support@) are English language patterns. Non-English role addresses may not be flagged.

Responsible Use

• Respect privacy regulations. Email verification does not grant permission to send emails. Always obtain proper consent (opt-in) before sending messages to verified addresses. Comply with GDPR, CAN-SPAM, CASL, and other applicable regulations.
• Do not use for spam validation. This tool is designed for legitimate list cleaning, not for validating scraped or purchased email lists for unsolicited outreach.
• Rate limit SMTP checks. Excessive SMTP connections to a single mail server may be seen as abuse. The actor includes built-in delays (200ms between emails in deep mode), but avoid running many parallel instances against the same domains.
• Keep results private. Verification results contain personal email addresses. Store and handle this data according to your privacy policy and applicable data protection laws.

FAQ

Does this actor send any emails? No. The actor never sends actual email messages. In Deep verification mode, it connects to the mail server's SMTP port and initiates a conversation up to the RCPT TO command to check if the mailbox exists, then immediately disconnects with QUIT. No email content is ever transmitted.

What is the difference between "risky" and "unknown" status? A risky status means the email passed basic checks but has flags that reduce confidence, such as being a role-based address at a free provider. An unknown status means the actor could not determine deliverability with certainty -- typically because the SMTP check timed out or the domain is catch-all (accepts all addresses). Unknown emails should be treated with caution but are not necessarily invalid.

How accurate is the verification without Deep mode? Standard mode confirms that the email has valid syntax, the domain exists, and it has working mail servers (MX records). It also checks against 55,000+ known disposable domains. This catches the most obvious invalid and disposable addresses. However, it cannot confirm whether a specific mailbox exists on the server -- only Deep mode with SMTP verification can do that.

Can I verify emails from Gmail, Yahoo, and other large providers? Yes, but with caveats. Large providers like Gmail often use catch-all or greylisting techniques that make SMTP verification unreliable. The actor will still perform all other checks (syntax, MX, disposable, role-based) and flag the provider type. For these domains, Standard mode is often just as useful as Deep mode.

How does the confidence scoring work? The confidence score is deterministic (not ML-based). A score of 95 means the SMTP server confirmed the mailbox exists and the domain is not catch-all. A score of 70 means MX records exist but no SMTP confirmation was attempted. A score of 50 indicates a catch-all domain where individual mailbox existence cannot be confirmed. Scores below 30 indicate problems such as no MX records, SMTP rejection, or disposable domain detection. See the Confidence Scoring Algorithm table above for the full breakdown.

What role-based prefixes are detected? The actor flags 60+ common role-based prefixes including: info, admin, support, help, contact, sales, marketing, billing, hr, jobs, careers, press, abuse, postmaster, webmaster, noreply, office, team, hello, feedback, newsletter, security, legal, compliance, ops, dev, engineering, service, bookings, orders, returns, shipping, partners, and more.

Integrations

The Bulk Email Verifier integrates with the broader Apify ecosystem and external tools:

• Apify API -- start runs and retrieve results programmatically via REST API or official client libraries for JavaScript, Python, and other languages.
• Webhooks -- configure Apify webhooks to trigger actions when a verification run completes (e.g., notify a Slack channel or call your backend API).
• Scheduled runs -- set up recurring verification jobs to keep your email lists clean on a daily, weekly, or monthly basis.
• Google Sheets -- export results directly to Google Sheets for manual review or team collaboration.
• Zapier / Make / n8n -- connect verification results to thousands of apps through integration platforms. Automatically update CRM records, trigger email sequences, or flag invalid addresses.
• Lead generation pipeline -- chain with Apify lead generation actors (Website Contact Scraper, B2B Lead Gen Suite) to automatically verify scraped email addresses before adding them to your outreach list.
• CRM systems -- push verified results to HubSpot, Salesforce, or other CRMs via API integrations or the HubSpot Lead Pusher actor.
• CSV/Excel/JSON export -- download results in multiple formats directly from the Apify Console dataset view.

Related Actors

These actors from ryanclinton on the Apify Store work well with Bulk Email Verifier:

Actor	What It Does	How It Connects
Website Contact Scraper	Extract emails, phones, and team members from websites	Verify scraped emails before outreach
Email Pattern Finder	Discover email patterns and predict addresses	Verify predicted emails to confirm deliverability
B2B Lead Gen Suite	Full lead generation pipeline with scoring	Verify all emails from the pipeline output
HubSpot Lead Pusher	Push leads to HubSpot CRM	Verify emails first, then push only valid contacts
Google Maps Lead Enricher	Enrich Maps listings with contact details	Verify enriched emails before adding to CRM
Waterfall Contact Enrichment	Multi-source contact enrichment	Add email verification as a final enrichment step