clean any email list with a 0-100 deliverability score before your campaign burns the domain — and find work emails from just a name + company with AI pattern inference. no email is ever sent to anyone.
Mailbox providers score senders primarily on bounces. Push past roughly 2-3% and Google and Microsoft start routing your mail to spam — for everyone on your list, not just the addresses that bounced. And because people change jobs constantly, even a list that was clean a year ago bounces today.
This Actor runs every address through layered technical checks — syntax, MX records, disposable-domain detection, role-based flags — and confirms Microsoft / Outlook mailboxes directly via provider API, without sending a single email. Every result comes back with a 0-100 deliverability score, a good / risky / bad band, and the reasons behind the number.
The same engine works in reverse: give it a name + company domain and the AI infers the email pattern, constructs the most probable address, verifies it, and tags the contact with role and seniority. List cleaning at $0.003 per email; finding + enrichment at $0.012 per record.
paste a list of emails, or name + domain pairs, or both. comes back scored, banded, and segmentable. runs on Apify, from $0.003 per email.
emails array for list cleaning, and/or a contacts array of {name, domain} records for AI discovery (set enrichment: true). optional: maxConcurrency (1-50 parallel threads) and maxTotalChargeUsd as a hard budget cap that halts the run cleanly.info@, sales@, admin@). nothing is sent to anyone at any point.is_catch_all.deliverability_score, a business_status band (good 85+ · risky 40-84 · bad <40), and the full technical breakdown:enrichment: true, the AI infers the company's email pattern (first.last, flast…), constructs and verifies the most probable address, and tags role_category (sales, engineering, executive…) + seniority (junior → executive) with a confidence score. export JSON, CSV, or Excel, or pipe to your CRM and sequencer via the Apify API, n8n, or Zapier — send only to good, review risky, drop bad.deterministic bands, not vibes. every result includes score_reasons explaining exactly how the number was derived.
0 — invalid syntax · fails RFC 5322. instant bad.
≤20 — no MX records · the domain doesn't run a mail server. nothing deliverable here.
≤20 — mailbox confirmed absent · the provider says this inbox doesn't exist.
≤30 — disposable domain · throwaway provider from the 3,000+ list. bad.
~55 — role-based address · info@, sales@ and friends. deliverable, but team mailboxes convert poorly in outreach — capped at risky.
~78 — deliverable domain, mailbox unconfirmed · everything checks out at domain level but the individual inbox couldn't be verified. honest risky, not fake good.
~88 — Microsoft mailbox confirmed · provider API says the inbox exists. good.
90-100 — SMTP probe confirmed · mailbox individually confirmed via relay. as good as it gets.
an agency loads a 8,000-contact list into its sequencer. 6% bounces in week one and open rates crater — the sending domain is now graylisted at Google and Microsoft. running the verifier first costs $24 and 10 minutes: drop the bad (typically 5-15% of any aged list), gate the risky behind a re-permission sequence, send full volume only to good. domain reputation intact, deliverability stays in the inbox tier.
run frequency: before every campaign · cost: $3 per 1,000 emails
an SDR team has 600 target contacts as name + company pairs (event lists, LinkedIn research) but no emails. enrichment mode infers each company's address pattern, constructs the probable email, verifies it, and tags role + seniority — $7.20 for the whole batch, billed at the enrichment rate only when the result is actually deliverable. the seniority tags then drive the sequencing: executives get the personalized track, practitioners get product-led.
run frequency: per prospect batch · cost: $12 per 1,000 records found + enriched
scraped lead lists always carry a percentage of dead or low-quality emails — sites publish stale addresses. piping the output of the catalog's lead scrapers (Google Maps, TikTok, Instagram, YouTube) through the verifier before CRM import means reps only ever see sendable contacts. an n8n flow chains the two Actors with zero manual steps.
run frequency: continuous via n8n / API · cost: $0.003 per scraped email checked
honest comparison against the dedicated verification SaaS tools and finder subscriptions. pricing checked against their public rate cards, June 2026.
| data-runner.dev | ZeroBounce / NeverBounce | Hunter.io | |
|---|---|---|---|
| Verification price | $0.003 / email, flat | ~$0.0035-0.02 / email by volume | credits on subscription |
| Email finding | ✓ $0.012, verified + role-tagged | ✗ | ✓ from $49/mo |
| Subscription required | none — pay as you go | credit packs (2,000 min purchase) | monthly plans from $49 |
| Microsoft mailbox confirm | ✓ provider API, no email sent | ✓ via SMTP infra | partial |
| AI role / seniority tagging | ✓ 11 categories + 4 levels | ✗ | ✗ |
| Budget cap per run | ✓ maxTotalChargeUsd | n/a | n/a |
| API / automation | Apify API · n8n · Zapier | ✓ API | ✓ API |
no subscription. no minimum purchase. cap any run with a hard budget limit.
full technical verification with deliverability score and status band — ~$3 per 1,000 emails. finding + AI enrichment from name + domain: $0.012 per record (~$12 per 1,000), billed at the enrichment rate only when the result is deliverable.
new to Apify? you get $5 in free credits on signup — that's ~1,600 verifications before you spend a cent.
run on Apify →how verification works, what the scores mean, what it costs, and how it compares.
Four technical layers, none of which puts a message in anyone's inbox: (1) syntax validation against RFC 5322, (2) MX record lookup confirming the domain actually runs a mail server, (3) disposable-domain detection against a list of 3,000+ known throwaway providers, and (4) role-based detection for team mailboxes like info@ or sales@. For Microsoft 365 / Outlook-hosted domains there's a fifth layer: a direct provider API call over HTTPS that confirms the individual mailbox exists — still without sending anything. The recipient never knows a check happened.
Every email gets a 0-100 deliverability score plus a status band: good (85+), risky (40-84), bad (below 40). The bands are deterministic: invalid syntax scores 0, no MX records caps at 20, disposable domains cap at 30, a confirmed-absent mailbox caps at 20, role-based addresses cap around 55, a deliverable domain with unconfirmed mailbox sits around 78, a Microsoft-confirmed mailbox around 88, and an SMTP-probe-confirmed mailbox lands 90-100. Every result includes score_reasons explaining exactly how the number was derived — no black box.
Microsoft 365 hosts a huge share of corporate email, and its provider API allows direct mailbox existence checks over HTTPS — no SMTP handshake, no email sent, no gray-area probing. For any Microsoft-hosted domain the Actor can tell you with high confidence whether [email protected] actually exists, not just whether the domain accepts mail. That's the difference between an 88-scored 'good' and a 78-scored 'risky' result.
It means the domain passed every check — valid syntax, real MX records, not disposable — but the specific mailbox couldn't be individually verified. This is typical for non-Microsoft domains where SMTP-level probing isn't available. These results score around 78 and land in the 'risky' band intentionally: the Actor scores conservatively rather than guessing 'good' and letting you bounce. Many catch-all domains fall here too (flagged via is_catch_all).
Pass contacts as {name, domain} pairs with enrichment: true. The AI infers the company's email naming convention (first.last, flast, first, etc.) from domain patterns, constructs the most probable corporate address, then runs that guess through the full verification pipeline. The output includes the pattern detected, a confidence score, and the complete deliverability result — so a guessed email that verifies as 'good' is genuinely sendable, not a shot in the dark.
Enriched contacts get classified into a role_category (engineering, sales, marketing, executive, operations, finance, hr, support, product, legal, or general) and a seniority level (junior, mid, senior, executive), each with a confidence score. That turns a flat email list into a segmentable one: route executives to the personalized sequence, send practitioners the product-led one, and skip the generic mailboxes entirely. Role-based addresses (info@, sales@) are also flagged separately because they convert poorly in cold outreach.
Two events: $0.003 per email verified (~$3 per 1,000) and $0.012 per record found and AI-enriched (~$12 per 1,000). The enrichment rate only applies to records that reach a deliverable status — an enriched guess that turns out undeliverable is billed at the verification rate only. You can also set maxTotalChargeUsd as a hard budget cap; the run terminates cleanly when it's reached.
Because bounce rate is the loudest signal mailbox providers use to score senders. Push past roughly 2-3% bounces and Google / Microsoft start routing your mail to spam — for every recipient, not just the bounced ones. Email lists decay fast (people change jobs constantly), so even a list that was clean a year ago will bounce today. Cleaning 5,000 emails costs $15 and takes minutes; recovering a burned sending domain takes months, if it recovers at all.
Yes — set maxTotalChargeUsd in the input and the Actor halts cleanly when the cap is reached, keeping everything processed up to that point. Combined with maxConcurrency (1-50 parallel threads, default 10) you control both the budget ceiling and the processing speed. Useful when you're testing list quality before committing to the full file.
$0.003 per email verified. 0-100 deliverability scoring. no email ever sent. pay only for what you check.