Email Verifier Batch

TL;DR for cold email senders, SDR teams, and list hygiene operators: Verifies a batch of emails with syntax, MX record, disposable-domain, role-account, and optional SMTP probe in one pass, returning a clean disposition for each address (valid, invalid, risky, disposable, role, catch_all). Compared to NeverBounce, ZeroBounce, or Hunter at $0.005-$0.01 per email, this is a flat low PPE per email with no monthly minimum and bring-your-own-proxy for SMTP probes. Free Apify plan handles small batches on your $5 platform credit. PPE charges scale linearly with email count. Upgrade to Apify Starter ($49/mo) for production volume.

Run it in 30 seconds

# Via the Apify Python SDK
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("seibs.co/email-verifier-batch").call(run_input={
    "emails": [
        "test@example.com",
        "john@stripe.com"
    ],
    "do_smtp_probe": true,
    "concurrency": 10
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

Or via curl:

curl -X POST "https://api.apify.com/v2/acts/seibs.co~email-verifier-batch/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"emails": ["test@example.com", "john@stripe.com"], "do_smtp_probe": true, "concurrency": 10}'

Or click "Try for free" on this page if you prefer the no-code UI.

What you get

Each run produces:

• A clean dataset, filterable in the Apify console and downloadable as CSV or JSON
• An OUTPUT.html dashboard preview of your top records
• A sample-output preview at ./.actor/sample-output.json

Per-archetype custom artifacts shipped with this actor:

• verified-emails.csv (disposition column: valid, invalid, risky, role, disposable, catch_all)
• valid-only.csv (the safe-to-send subset, ready for Mailchimp or Klaviyo import)
• summary.html (rollup of valid pct, role pct, disposable pct, catch-all pct)

---

What does Email Verifier Batch do?

Feed it a list of email addresses. For each one, the actor runs up to five checks and emits a single record with the verdict:

1. Syntax check - RFC 5322 compliant validation via email-validator.
2. MX lookup - asks DNS whether the domain accepts mail. Falls back to the A record (implicit MX per RFC 5321 5.1) when no MX exists.
3. Disposable detection - matches the domain against a bundled blocklist of 5400+ known throwaway-email providers (mailinator, guerrillamail, 10minutemail, tempmail, and ~5400 more).
4. Role-based detection - flags info@, sales@, support@, etc. so SDRs can skip group inboxes.
5. SMTP probe (optional) - connects to the MX host on port 25 and issues HELO + MAIL FROM + RCPT TO. The DATA stage is never reached, so no email is ever sent. Tests an additional random-mailbox RCPT TO to detect catch-all domains. Returns deliverable / undeliverable / catch-all / unknown.

The five signals are combined into a confidence_score from 0.0 to 1.0. Disposable domains are capped at 0.30; SMTP-undeliverable addresses floor at 0.05.

Features

• Five independent checks per address - failures in one check never block the others.
• 5400+ bundled disposable-domain blocklist (sourced from the canonical disposable-email-domains GitHub project).
• ~45 bundled role prefixes (info, sales, support, billing, hr, recruiting, no-reply, postmaster, ...).
• SMTP probe never sends mail - RCPT TO only, then QUIT.
• Catch-all detection - a second RCPT TO to a random local-part flags domains that accept everything.
• Greylisting awareness - 4xx responses set greylisted=true and retry_recommended=true.
• Per-email timeout - one slow MX never holds up the batch.
• Concurrency-controlled (1-50 parallel) via asyncio + semaphore.
• Errors are emitted as records, not run failures - you always get a row per input address.

Use cases

• B2B sales prospecting - clean a list of scraped LinkedIn-derived emails before importing to your sequencer.
• Lead-list cleanup - score a CSV from an outbound vendor; drop disposable + role-based + undeliverable before paying per-contact for upload.
• Email-campaign hygiene - run before every send; bounces above 2% wreck deliverability and sender reputation.
• Anti-bounce filtering - filter signups by confidence_score >= 0.6 to keep your transactional senders out of penalty boxes.
• Form-spam reduction - reject signups where is_disposable=true at submit time.
• CRM enrichment - pass every contact in your CRM through this monthly to flag departed-employee inboxes (catch-all + role + 4xx greylist patterns).

Input

Field	Type	Required	Default	Notes
emails	array of strings	yes	-	List of addresses. Case-insensitive dedupe.
do_smtp_probe	boolean	no	true	When false, only syntax/MX/disposable/role checks run. ~50x faster.
concurrency	integer	no	10	1-50 parallel verifications.
timeout_seconds	integer	no	10	Per-address ceiling for DNS + SMTP.

Output

One record per input email. Key fields:

• email, normalized_email, local_part, domain
• syntax_valid (bool)
• mx_records (array of {host, priority})
• has_mx (bool)
• is_disposable (bool)
• is_role_based (bool), role_type (matched prefix or null)
• smtp_probe_result - deliverable / undeliverable / catch-all / unknown / null
• smtp_response (raw SMTP code + message, for audit)
• smtp_catch_all_tested, greylisted, retry_recommended
• confidence_score (0-1)
• verification_method (array of checks that ran)
• warnings, error, checked_at

Two dataset views are provided: Overview (compact verdict table) and Detailed (every field).

Pricing (pay per event)

• verification_basic - $0.0005 per email (syntax + MX + disposable + role + confidence score). Always charged.
• verification_smtp - $0.001 per email when the SMTP probe actually completes. Skipped automatically when SMTP probing is disabled or the domain has no MX.

A 10K-list scan with SMTP enabled costs ~$15. The same scan against ZoomInfo or Hunter would run $100-300 depending on plan.

How the confidence score is computed

Condition	Effect
Syntax invalid	score = 0.0
No MX (and no fallback A)	score = 0.05
SMTP undeliverable	score = 0.05
Syntax + MX present, no SMTP probe	base = 0.55
SMTP deliverable	base = 0.95
SMTP catch-all	base = 0.55 (mailbox cannot be proven)
SMTP unknown (greylist / temp error)	base = 0.45
Role-based local-part	-0.10
Disposable domain	capped at 0.30

FAQ

Q: Does this send email? A: No. The SMTP probe stops at RCPT TO and immediately sends QUIT. The DATA stage - the only stage that actually transmits a message body - is never reached. This is the same technique every reputable email-verifier (Hunter, ZeroBounce, NeverBounce) uses.

Q: Why are some big-provider results unknown or catch-all? A: Gmail, Outlook, and many large providers refuse RCPT TO probes outright (they return a generic 250 for any address, which we report as catch-all) or rate-limit aggressively from datacenter IPs. For those, the syntax + MX + disposable + role signals are usually all you need; confidence_score accounts for this.

Q: What about greylisting? A: A 4xx response on RCPT TO sets greylisted=true and retry_recommended=true. Re-run the same input 5-15 minutes later and the MX will typically accept on the second attempt.

Q: Can I bring my own disposable-domain list? A: Not via input today - the bundled list is rebuilt at build time from the disposable-email-domains GitHub project. Open an issue or fork the actor if you need to layer in a custom list.

Q: Will this trip rate-limits or get my Apify IP blocked? A: SMTP RCPT TO is the universal verification primitive - it does not download mail, does not authenticate, and does not transmit a body. Keep concurrency at 10 or below for shared MX hosts (Gmail / Outlook / Yahoo) and you will be fine. The actor never reuses an SMTP session across addresses.

Q: How does this compare to ZoomInfo / Hunter / ZeroBounce? A: For the verification step specifically, the methodology is the same (syntax + MX + SMTP + disposable + role). What those vendors add is a contact database. This actor is the verification half - perfect for cleaning a list you already have.

Q: Can I schedule this? A: Yes. Pair with Apify Schedules + a webhook to your CRM and re-verify your active contact list every 30-90 days to catch employee turnover.

Limitations

• SMTP probes against Gmail / Outlook / Yahoo will frequently land as catch-all or unknown - those providers refuse to disclose mailbox existence.
• IPv6-only MX hosts work but the SMTP probe falls back to whichever address family the OS resolver returns first.
• The actor does not perform deep SPF / DKIM / DMARC analysis - it answers "is this mailbox real" not "is this domain configured well to send mail".
• Catch-all domains return confidence_score = 0.55 by design - the mailbox literally cannot be proven without sending an actual message.

Data sources

• Disposable-domain list: disposable-email-domains/disposable-email-domains (GitHub, Creative Commons).
• Role-prefix list: curated from RFC 2142 + common industry conventions.
• DNS: any public resolver via dnspython.
• SMTP: direct port-25 connection to the target's MX host.

Save your input as an Apify Task

Apify Tasks let you save a configured input once and re-run it with a single click - no need to re-type search terms, locations, filters, or tier settings every time. Tasks are the foundation for everything that comes next: schedules, monitor mode, and webhook routing all attach to a saved Task, not to the raw actor.

Steps to save your current input as a Task:

1. On this actor's Apify Store page, click Run with your input fully configured.
2. Click the Save as task button at the top of the run page.
3. Name the task something memorable (e.g. Verify weekly inbound list - weekly).
4. Reload the task page and click Start anytime to re-run with the same inputs.

Tasks unlock the next two features below: scheduling and monitor mode.

Run this weekly with Apify Schedules

Apify Schedules cron-run any saved Task automatically. Pair this with the saved Task above and you get hands-off recurring runs with no manual clicks, no missed weeks, and a steady stream of fresh data into your CRM or warehouse.

Steps to schedule a Task:

1. Save your input as a Task (see above).
2. Go to https://console.apify.com/schedules and click Create new schedule.
3. Pick your Task and set the cron expression. Common patterns:
   • Daily at 9am UTC: 0 9 * * *
   • Weekly on Mondays at 9am: 0 9 * * 1
   • Monthly on the 1st: 0 9 1 * *
4. Save. Apify will run your Task on that schedule automatically, push the dataset to whatever integrations you have wired up, and fire run-completion webhooks for downstream automation.

Run weekly to re-verify your active outbound list and prune bounced or risky addresses before they hurt your sender reputation.

Monitor mode (v2, beta)

Monitor mode is the v2 evolution of this actor and is currently in BETA. It turns a recurring schedule into a true change-feed instead of a firehose of duplicate records.

How it works:

• When this actor runs under an Apify Schedule, monitor mode is enabled automatically.
• Instead of emitting ALL records every run, it emits ONLY records that are NEW or CHANGED since the last scheduled run.
• A digest record summarizes the delta (X new, Y changed, Z removed) at the top of every run.
• Optional: provide a Slack or email webhook URL in the monitor_webhook_url input field and the digest fires there too, so your team gets the delta in their inbox or channel without polling the dataset.
• Cost: a single scheduled_delta_run event ($0.05) per scheduled run, plus standard PPE on emitted delta records only. Predictable monthly cost, no surprise bills from re-charging for unchanged records.

Monitor mode is rolling out to the top 3 actors first (this one included if it's hotel-motel-lead-finder, google-maps-reviews-pro, or mcp-accounting-firm-leads). Full portfolio coverage by end of June.

Found this useful?

If this actor saved you time or money, please consider leaving a quick review on the Apify Store. Reviews help other buyers find work that solves their problem and let me prioritize the features paying customers actually use. Leave a review: https://apify.com/seibs.co/email-verifier-batch#reviews