Email Verifier & Email Finder — Bulk Email Verification + AI Email Enrichment

Verify email deliverability in bulk, and find the corporate email when all you have is a name and a company domain — in one Actor. This is a bulk email verifier and an AI-powered email finder: it cleans your email list (syntax, MX, mailbox confirmation, disposable & role detection), and discovers the most likely corporate address from a name + domain, then scores and classifies it.

Use it to clean your email list, reduce bounce rate, improve email deliverability, and protect your sender reputation — and to turn "name + company" into a verified, role-classified email. One tool, one bill, no stitching a separate finder and verifier together.

Great for bulk email verification, CRM list cleaning, pre-campaign list QA, signup validation, and sales prospecting / lead enrichment.

---

Why this beats a finder + verifier stack

Most teams pay twice: an email finder to discover addresses, then a separate email verifier to confirm deliverability. Stacked together, the cost of one usable, verified corporate email typically lands around $14–$38 per 1,000.

This Actor does both and prices the combined "found and verified and classified" result at ≈ $15 per 1,000 — the low end of that range, with an AI role/seniority classification on top that standalone finders don't include — and plain verification at ≈ $3 per 1,000.

Tier	What you get	Price
Verification	syntax → MX → mailbox confirmation → disposable / role detection → 0–100 deliverability score	$0.003 / email (≈ $3 / 1k)
Find + enrich	AI guesses the corporate address from name + domain, verifies it, and classifies role + seniority	$0.012 / record (≈ $12 / 1k)

Pay-as-you-go, no subscription. You're charged per result, only for the work performed. Set a Max total charge (maxTotalChargeUsd) per run to cap spend — the Actor stops cleanly the moment your budget is reached.

---

Features

Bulk email verification & list cleaning

Verify thousands of addresses in one run and export a clean list — strip dead, risky, and throwaway emails before you send.

Mailbox confirmation (no email sent)

For Microsoft 365 / Outlook-hosted domains (a large share of corporate mail), the Actor confirms whether the individual mailbox exists via Microsoft's provider API over HTTPS — without sending any email. These addresses can reach a confident good verdict.

Domain-level deliverability

Every address is checked for valid syntax, a deliverable domain (MX records), disposable / temporary domains, and role-based mailboxes — so even when a mailbox can't be individually confirmed, you get a sound deliverability signal.

Disposable & temporary email detection

Flags throwaway/temporary-domain addresses so you can remove fake signups and junk leads.

Role-based email detection

Identifies role mailboxes (info@, sales@, admin@, …) that go to a team rather than a person — deliverable but low-signal for outreach.

AI email finder (find work email by name + domain)

Give a name and a company domain; the AI engine infers the address convention (first.last, flast, first, …), builds the most likely corporate email, and runs it through verification.

Transparent 0–100 deliverability score

Every address gets a deterministic score and a good / risky / bad status, with the reasons attached.

Bulk email verification API

Run it on demand or from your own code via the Apify API, and pull results as CSV, JSON, or Excel.

---

How to verify and find emails in bulk

1. Open the Actor on Apify (or call it via the Apify API).
2. Add your data — paste/upload a list into Emails to verify, and/or add Contacts as {name, domain} objects to find missing addresses.
3. Choose options — toggle AI enrichment (find + classify) and the deep mailbox check, and set Max concurrency.
4. Set a budget — enter Max total charge (USD) to cap spend.
5. Run it.
6. Export the results as CSV, JSON, or Excel, or fetch them programmatically via the Apify API.

Two ways to run it

1. Verify emails you already have — list-cleaning / QA:

{
  "emails": ["jane.doe@stripe.com", "info@acme.com", "old.contact@dead-domain.xyz"],
  "smtpCheck": true
}

2. Find + verify from name + domain — the AI engine guesses the address, verifies it, and classifies the role:

{
  "contacts": [
    { "name": "Jane Doe", "domain": "stripe.com" },
    { "name": "John Smith", "domain": "acme.com" }
  ],
  "enrichment": true
}

You can mix both, and toggle the deep mailbox check and AI enrichment independently.

---

Input

Field	Type	Description
emails	array of strings	Addresses to verify. Use for list-cleaning / QA.
contacts	array of {name, domain}	The AI engine guesses the most likely corporate email, then verifies it. Requires enrichment: true.
enrichment	boolean	Adds AI role/seniority classification and corporate-pattern guessing. Billed at the enrichment rate. Default false.
smtpCheck	boolean	Deep mailbox check. Confirms the individual mailbox where possible (Microsoft-hosted domains, via HTTPS — no email sent). Default true.
maxConcurrency	integer	Records processed in parallel (1–50). Default 10.

Provide at least one of emails or contacts.

---

Output

One dataset item per record (export as CSV, JSON, or Excel):

{
  "input": "john.doe@example.com",        // or the {name, domain} that was resolved
  "email": "john.doe@example.com",         // resolved / guessed address
  "deliverability_score": 88,              // 0–100
  "business_status": "good",               // good | risky | bad
  "technical": {
    "syntax_valid": true,
    "domain_has_mx": true,
    "mailbox_exists": true,                // true | false | null (not individually confirmed)
    "verification_method": "microsoft",    // how the mailbox was checked: microsoft | smtp | none
    "is_catch_all": null,
    "is_disposable": false,
    "is_role_based": false                 // info@, sales@, admin@ …
  },
  "ai_enrichment": {                       // present only when enrichment = true
    "guessed_from": "name+domain",         // null when the email was supplied
    "pattern": "first.last",
    "role_category": "engineering",
    "seniority": "senior",
    "confidence": 0.82
  },
  "verification_details": { /* raw signals for debugging */ },
  "source": "email-verifier-enricher-pro"
}

---

The deliverability score (0–100)

Deterministic and transparent — the same signals always produce the same score, and every item carries the reasons behind it (verification_details.score_reasons). The bands:

Signal	Score	Status
Invalid syntax	0	bad
Domain has no mail server (no MX)	≤ 20	bad
Disposable / temporary domain	≤ 30	bad
Mailbox confirmed not to exist	≤ 20	bad
Role-based address (info@, sales@ …)	capped ~55	risky
Deliverable domain, mailbox not individually confirmed	~78	risky
Mailbox confirmed to exist (Microsoft provider API)	~88	good
Mailbox confirmed by a live SMTP probe (external backend)	90–100	good

good = score ≥ 85, risky = 40–84, bad = below 40. The verification_method field tells you how each mailbox verdict was reached.

---

How mailbox verification works

The Actor never sends an email to verify one. It layers signals that don't require sending:

• Syntax + MX — is the address well-formed and does the domain accept mail? (always run)
• Disposable / role detection — throwaway domains and team mailboxes. (always run)
• Microsoft mailbox check — for Microsoft 365 / Outlook-hosted domains, Microsoft's provider API confirms whether the specific mailbox exists, over HTTPS. (the deep check)

Confirming an individual mailbox on any domain via a raw SMTP probe requires outbound port 25, which shared cloud platforms block as standard anti-spam policy. For domains we can't probe directly, the Actor scores the domain-level deliverability honestly (risky = "deliverable domain, mailbox not individually confirmed") rather than guessing.

Operators can enable full mailbox confirmation on every domain (plus catch-all detection) by connecting an external SMTP backend — then non-Microsoft domains also reach a confident good / bad verdict. See the configuration note below.

---

How the AI enrichment works

When enrichment is on, an AI-powered enrichment engine does two things, batched for speed:

1. Corporate pattern guessing — given a name and a company domain, it infers the most likely address convention (first.last, flast, first, …) and the address itself. The Actor then verifies that guessed address.
2. Role & seniority classification — it categorizes the contact (engineering, sales, marketing, executive, operations, finance, hr, support, product, legal, general) and seniority (junior, mid, senior, executive), with a confidence score.

A contacts record that gets both found and verified is billed for both events (verification + enrichment). Enrichment only applies to addresses that are at least deliverable — a bad address (invalid, no mail server, disposable, or confirmed nonexistent) is billed verification only, so you never pay the enrichment rate for a dead address.

---

Use cases

• CRM cleanup & email list cleaning — purge dead and risky addresses; reduce bounce rate and protect your sender reputation.
• Pre-campaign list QA — verify a list before a send to cut bounces and improve email deliverability.
• Signup / lead-form validation — score addresses at capture time and block disposable signups.
• Sales prospecting & lead enrichment — turn "name + company" into a verified, role-classified corporate email.

---

FAQ

How do I verify an email address without sending an email?

The Actor never sends a message. It validates syntax, looks up the domain's MX records, and — for Microsoft-hosted domains — asks Microsoft's provider API (over HTTPS) whether the specific mailbox exists. You get a 0–100 score and a good/risky/bad status per address, with the method used recorded in verification_method.

How do I verify emails in bulk?

Paste or upload your list into the Emails to verify field (or pull it via the Apify API), set Max concurrency and a Max total charge, and run. Each address returns a deliverability score and technical signals (MX, mailbox check, disposable, role-based). Export the cleaned results as CSV, JSON, or Excel.

How do I find someone's work email from just a name and company?

Add {name, domain} contacts and enable AI enrichment. The AI-powered engine infers the company's address convention (first.last, flast, first, …), constructs the most likely corporate email, then verifies it and classifies the contact's role and seniority with a confidence score.

What does "mailbox not individually confirmed" mean?

For domains where the individual mailbox can't be probed (non-Microsoft domains, without an external SMTP backend), the Actor verifies everything it can at the domain level — valid syntax, a deliverable domain, not disposable, not role-based — and scores the address ~78 risky. The domain accepts mail; we just haven't confirmed that exact mailbox, and we won't pretend we have.

What is a role-based email and why does it matter?

Role-based addresses like info@, sales@, or admin@ go to a team or function rather than a person. They bounce less but convert poorly and can hurt sender reputation in cold outreach, so the Actor detects them and caps their score at ~55 with a risky status.

How accurate is the verification?

Accuracy comes from layering syntax, MX, disposable/role detection, and — for Microsoft-hosted domains — a direct mailbox-existence check, rolled into a deterministic 0–100 score with the reasons attached to every result. Where a mailbox can't be individually confirmed, the score is conservative (risky) rather than a false good.

How much does it cost to verify or find emails?

Pricing is pay-as-you-go with no subscription: verification is $0.003 per email (~$3 per 1,000) and find + AI enrichment is $0.012 per record (~$12 per 1,000). Set a Max total charge to cap spend — the Actor stops cleanly the moment your budget is reached.

Can I detect disposable or temporary email addresses?

Yes. The Actor flags disposable and temporary-domain addresses and caps their score at ~30 with a bad status, so you can strip throwaway signups out of your list before sending.

---

Tips

• Leave smtpCheck: true so Microsoft-hosted mailboxes get the deep check.
• Most lists cluster on a handful of domains — the Actor caches MX status per domain, so large clustered lists stay fast and cheap.
• Set maxTotalChargeUsd to budget each run. The Actor halts cleanly at the cap.

---

Configuration (operators)

The AI enrichment engine is provider-agnostic and configured entirely via environment variables / Apify secrets — set these on the Actor before enabling enrichment:

• LLM_API_KEY — API key for the enrichment engine (store as an Apify secret).
• LLM_BASE_URL — engine endpoint base URL.
• LLM_MODEL — model identifier.

If the engine is not configured, enrichment gracefully falls back to a built-in heuristic so runs still complete.

Optional — full SMTP mailbox verification (all domains): to confirm mailboxes on non-Microsoft domains too (and detect catch-all), point the Actor at an external SMTP relay reachable over HTTPS:

• SMTP_RELAY_URL — base URL of a Reacher-compatible relay (POST /v0/check_email).
• SMTP_RELAY_TOKEN — bearer token the relay requires (store as an Apify secret).

When unset, non-Microsoft domains are scored at the domain level (risky, "mailbox not individually confirmed").