Email Checker / Verifier

📧 Email Checker / Verifier – SMTP Validation, MX Lookup & Deliverability Scoring

The Email Checker / Verifier is an email verification actor that runs a full SMTP-level validation on any email address and returns a structured deliverability verdict instead of a simple yes/no guess. It checks syntax against RFC rules, resolves the domain's MX records, opens a real SMTP conversation with the receiving mail server, and reports whether the mailbox is reachable — plus useful signals such as whether the address is disposable, a role account, or a B2C consumer mailbox.

This email verification tool is built for people who care about sender reputation: cold outreach teams cleaning a prospect list, SaaS products validating sign-ups, CRM administrators purging stale contacts, and anyone who has watched a bounce rate creep toward the threshold where an ESP starts throttling delivery. Single addresses and batches are both supported, and every SMTP parameter that matters — HELO name, MAIL FROM identity, port, timeout, retries — is configurable so you can tune the handshake to match how your production mail server actually behaves.

---

📊 What Data Can You Extract with This Email Verification Scraper?

Each verified address produces one dataset item containing the following grouped signals.

Category	Fields	What you get
🔤 Syntax validation	syntax	Object with the parsed address, domain, username and an is_valid_syntax flag
📬 Deliverability verdict	is_reachable	The headline result for the address — the field most integrations key off
🌐 Domain & mail routing	mx	Whether the domain accepts_mail plus the full list of resolved MX records
🔌 SMTP conversation	smtp	The outcome of the live SMTP handshake, including any structured error object returned
🕵️ Risk & profile signals	misc	Disposable-address detection, role-account detection, B2C classification, Gravatar URL and breach-related hints
🧪 Run diagnostics	debug, input, error	Backend name, start/end timestamps, the original input address, and an error message when a check fails

The single most useful field for most workflows is is_reachable, because it collapses the syntax check, the MX lookup and the SMTP probe into one verdict you can branch on. But do not throw away mx and smtp — when is_reachable comes back as unknown, those two objects tell you why, which is the difference between "this mailbox does not exist" and "this provider refused the probe".

---

🌟 Key Features of the Email Checker / Verifier

Feature	Description
🔍 Real SMTP probing	Connects to the recipient's mail server and walks the SMTP conversation rather than guessing from the domain alone
📦 Batch verification	Pass an emails array to validate a whole list in a single run; email handles the one-off case
🧾 RFC syntax parsing	Splits every address into username and domain and flags malformed input before any network call is made
🌐 MX record resolution	Resolves and returns the domain's mail exchangers, so you can see exactly which infrastructure handles the mailbox
🗑️ Disposable detection	The misc object flags throwaway and temporary-mailbox providers commonly used to bypass sign-up gates
👥 Role-account flagging	Identifies shared addresses such as info@, support@ and sales@ that skew engagement metrics in cold outreach
🖼️ Optional Gravatar lookup	Enable check_gravatar to see whether the address has a registered Gravatar image and profile URL
⚙️ Tunable SMTP handshake	from_email, hello_name, smtp_port, smtp_timeout and retries let you mirror your production sender identity
🔄 Automatic proxy rotation	Outbound requests are routed through rotating proxies managed by the actor, with no proxy setup required from you

---

🚀 Why Choose This Email Verification Scraper?

Transparent verdicts, not black-box scores. Many verification services return a single opaque grade. This actor returns the raw evidence alongside the verdict: the MX records it resolved, the SMTP error object it received, the syntax breakdown it parsed. When you need to justify why an address was dropped from a campaign, the evidence is in the dataset.

Built for list hygiene at scale. The emails array accepts an entire batch in one run, and each address becomes its own dataset item with its own input value, so results map cleanly back to source rows in a CRM export or a spreadsheet column.

Honest about uncertainty. A large share of mail providers deliberately accept every recipient during the SMTP handshake, or block probes outright. Instead of pretending otherwise, the actor reports is_reachable as unknown and puts the underlying SMTP error in the smtp object so you can decide how to treat that segment.

Configurable to match your sending identity. Deliverability behaviour changes with the HELO name and MAIL FROM address you present. Because both are inputs, you can run verification using the same domain identity your production mail server uses, which produces results far closer to what a real send would experience.

---

📥 Input

{
  "email": "xyz.mikolabs@gmail.com",
  "from_email": "reacher.email@gmail.com",
  "hello_name": "gmail.com",
  "smtp_timeout": 15,
  "smtp_port": 25,
  "retries": 1,
  "check_gravatar": false
}

🔧 Email Verifier Input Fields

Field	Type	Required	Default	Description
email	string	Yes	xyz.mikolabs@gmail.com	The single email address to verify. Use emails (array) instead to check a batch.
emails	array	No	—	Optional list of email addresses to verify in one run. If provided, email is ignored.
from_email	string	No	reacher.email@gmail.com	Email address used in the SMTP MAIL FROM command during verification.
hello_name	string	No	gmail.com	Domain name announced in the SMTP HELO/EHLO greeting.
smtp_timeout	integer	No	15	How long to wait for each SMTP step before giving up, in seconds.
smtp_port	integer	No	25	TCP port used to connect to the target mail server.
retries	integer	No	1	Number of retry attempts on transient SMTP/network failures.
check_gravatar	boolean	No	false	If true, looks up whether the email has a registered Gravatar image.

💡 Input Examples

Verify a single address with default settings:

{
  "email": "jane.doe@example.com"
}

Verify a batch and enrich each result with a Gravatar lookup:

{
  "emails": [
    "sales@acme.io",
    "jane.doe@example.com",
    "throwaway@mailinator.com"
  ],
  "check_gravatar": true
}

Use a stricter timeout and your own sender identity for a large list:

{
  "emails": ["contact@startup.dev", "hello@agency.co"],
  "from_email": "verify@yourdomain.com",
  "hello_name": "yourdomain.com",
  "smtp_timeout": 8,
  "retries": 2
}

---

📤 Output

{
  "input": "xyz.mikolabs@gmail.com",
  "is_reachable": "unknown",
  "syntax": {
    "address": "xyz.mikolabs@gmail.com",
    "domain": "gmail.com",
    "username": "xyz.mikolabs",
    "is_valid_syntax": true
  },
  "mx": {
    "accepts_mail": true,
    "records": [
      "gmail-smtp-in.l.google.com.",
      "alt1.gmail-smtp-in.l.google.com."
    ]
  },
  "smtp": {
    "error": {
      "type": "SmtpError",
      "message": "Proxy CONNECT to gmail-smtp-in.l.google.com:25 failed"
    }
  },
  "misc": {
    "is_disposable": false,
    "is_role_account": false,
    "is_b2c": true,
    "gravatar_url": null
  },
  "debug": {
    "backend_name": "reacher-cli",
    "start_time": "2026-08-08T15:44:32.259525Z",
    "end_time": "2026-08-08T15:44:47.183000Z"
  }
}

🧾 Email Verification Output Fields

Field	Type	Description
input	string | null	The email address that was submitted for verification.
is_reachable	string | null	The deliverability verdict for the address.
syntax	object | null	Parsed address components and the RFC syntax validity flag.
mx	object | null	Whether the domain accepts mail and the MX records resolved for it.
smtp	object | null	Result of the SMTP handshake, including a structured error object when the probe fails.
misc	object | null	Risk and profile signals such as disposable, role-account, B2C and Gravatar data.
debug	object | null	Backend name and start/end timestamps for the individual check.
error	string | null	Error message, if the item failed to process.

---

💻 How to Use the Email Checker / Verifier (Step by Step)

Step 1: Open the actor and choose single or batch mode

Start on the actor's Input tab. If you only need to check one address — validating a form submission, confirming a contact before a manual send — put it in the email field and leave everything else alone. If you have a list, put it in the emails array instead. When emails is populated it takes priority and email is ignored entirely, so you never need to clear one to use the other.

Step 2: Set the SMTP identity you want to present

The hello_name and from_email values are what the receiving mail server sees during the handshake. Defaults are provided so the actor works out of the box, but results are more representative when these match the domain you actually send from. If your production mail flows from yourdomain.com, set hello_name to yourdomain.com and from_email to a real, monitored address on that domain.

Step 3: Tune timeouts, port and retries for your list size

smtp_timeout controls how long each SMTP step waits before giving up, and smtp_port selects the TCP port used for the connection — port 25 is the standard mail-transfer port and the default here. For a big batch, a shorter timeout keeps the run moving; for a small, high-value list, a longer timeout and retries of 2 or 3 will squeeze out more definitive answers from slow servers.

Step 4: Decide whether to enable the Gravatar lookup

Setting check_gravatar to true adds an extra lookup per address against the Gravatar service and populates the gravatar_url value inside misc. It is genuinely useful for enrichment — a registered Gravatar is weak evidence that the address belongs to an active human — but it does add work per address, so leave it off for pure deliverability runs.

Step 5: Run the actor and watch the log

Click Start. The log narrates each address as it moves through syntax parsing, MX resolution and the SMTP probe. Watch for repeated connection failures against a single provider early on; that usually signals a network-level block rather than genuinely dead mailboxes, and it is cheaper to adjust settings after ten addresses than after ten thousand.

Step 6: Read the results in the dataset

Each verified address becomes one dataset item. Open the Dataset tab and use the table view to scan is_reachable across the batch, then drill into individual rows to see the smtp and mx objects behind each verdict. The input field carries the original address, so you can join results back to the row they came from.

Step 7: Export or push the verified list downstream

Export the dataset as JSON, CSV or Excel from the Apify console, or pull it through the API into your own pipeline. A typical pattern is to write is_reachable and the misc.is_role_account flag back onto the contact record in your CRM, then use those two fields as suppression rules for future campaigns.

---

🔌 API Access & Integrations

Run the email verification actor synchronously and get the dataset items back in one call:

curl -X POST "https://api.apify.com/v2/acts/scrapers-hub~email-checker-verifier/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "emails": ["jane.doe@example.com", "sales@acme.io"],
    "check_gravatar": true,
    "smtp_timeout": 15
  }'

The same run from Python using the official client:

from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("scrapers-hub/email-checker-verifier").call(
    run_input={
        "emails": ["jane.doe@example.com", "sales@acme.io"],
        "smtp_timeout": 15,
        "retries": 2,
    }
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["input"], "->", item["is_reachable"])

Because the results land in a standard Apify dataset, you can wire them into Zapier, Make, Google Sheets or Slack, or fire a webhook on run completion to push verified addresses straight into your CRM or ESP.

---

💡 Best Use Cases for Email Verification Data

🧹 Cold outreach list cleaning

Before a sequence goes out, run the whole prospect list through the verifier and drop everything where is_reachable indicates the mailbox will not accept mail. Combining that with misc.is_role_account lets you also strip generic inboxes that inflate your send volume without ever producing a reply.

📝 Sign-up and lead-form validation

Point the actor at addresses captured by a form and use syntax.is_valid_syntax as a fast first filter, then mx.accepts_mail to confirm the domain can receive mail at all. Flagging misc.is_disposable at this stage stops throwaway addresses from claiming free trials and polluting your activation metrics.

🛡️ Sender reputation protection

High bounce rates are the fastest route to throttling and blocklisting. Verifying ahead of each send and suppressing anything where the smtp object shows a hard rejection keeps your bounce ratio low, which protects inbox placement for the addresses that do matter.

🗃️ CRM data hygiene and re-permissioning

Databases decay as people change jobs. Periodically re-verifying stored contacts and writing is_reachable plus the debug.end_time timestamp back onto each record gives you a defensible freshness signal, and makes it easy to route stale contacts into a re-permission campaign rather than a normal send.

🔎 Lead enrichment and scoring

The misc object distinguishes consumer mailboxes from business ones through its is_b2c flag, and the optional gravatar_url adds a small identity signal. For a B2B pipeline, scoring business-domain addresses above free consumer addresses is a cheap improvement to lead quality.

🚨 Fraud and abuse screening

Disposable-address detection is a practical anti-abuse control for anything with a free tier. Rejecting sign-ups where misc.is_disposable is true blocks a meaningful share of throwaway account creation, and the mx.records list lets you spot bulk registrations pointing at a single obscure mail host.

📊 Deliverability diagnostics

When a campaign underperforms, verifying the affected segment and inspecting the smtp.error objects often shows a single provider rejecting your handshake. That is a configuration problem, not a list problem, and the raw SMTP evidence is what you need to fix it.

---

⚙️ Tips for Better Email Verification Results

• Use the batch input for anything over a handful of addresses. One run with a populated emails array is far more efficient than many single-address runs, and it keeps all results in one dataset for export.
• Match hello_name and from_email to a real domain you control. Receiving servers treat mismatched or obviously synthetic HELO identities more suspiciously, which pushes more results into the unknown bucket.
• Raise retries rather than smtp_timeout for flaky domains. Transient failures are common on port 25; a second attempt often succeeds where a longer single wait would not.
• Treat is_reachable values of unknown as a separate segment, not as invalid. Several major providers accept all recipients during the handshake. Sending a small, careful test batch to that segment is usually smarter than deleting it.
• Always keep the mx object. If accepts_mail is false, no amount of SMTP retrying will help, and you can suppress that domain wholesale.
• Re-verify on a schedule. Contact data ages quickly; a quarterly re-run against your active list catches departures and domain changes before they turn into bounces.

---

🛠️ Troubleshooting

Why is is_reachable returning unknown for so many addresses? This is expected behaviour with large consumer providers and with any network path where outbound port 25 is filtered. Check the smtp.error object: an SmtpError describing a failed connection means the probe never completed, whereas a server-level rejection means the mailbox itself responded negatively. Only the second is evidence about the address.

The SMTP step keeps timing out. Increase smtp_timeout and set retries to 2 or 3. Some mail servers deliberately delay responses to slow down automated probing, and a 15-second default is not always enough for them.

Nothing happens when I fill in both email and emails. That is by design — when emails contains any values, the single email field is ignored. Clear the emails array if you want to verify just one address.

The misc object shows no Gravatar data. The Gravatar lookup only runs when check_gravatar is set to true. If it is enabled and gravatar_url is still null, the address simply has no registered Gravatar image.

An item came back with only an error value. The error field carries the message for addresses that failed to process at all — typically malformed input or a domain that would not resolve. Check the syntax object first; if is_valid_syntax is false, the address never reached the network stage.

---

❓ Frequently Asked Questions About Email Verification

How does this email verification actor check if an email address is real? It runs three layers: an RFC syntax parse, a DNS lookup of the domain's MX records, and a live SMTP conversation with the receiving mail server. The combined result is reported in is_reachable, with the underlying evidence in syntax, mx and smtp.

Can I verify a list of email addresses in bulk? Yes. Put the whole list in the emails array and each address becomes its own dataset item. The single email field is ignored whenever emails is populated.

Does the email checker send an actual email to the address? No. The SMTP conversation stops before any message body is transmitted, so the mailbox owner receives nothing.

What does an is_reachable value of unknown actually mean? It means the SMTP probe could not produce a definitive answer — usually because the provider accepts all recipients, blocks probing, or the connection failed. The smtp object explains which case applies.

Can this email verifier detect disposable or temporary email addresses? Yes. The misc object includes an is_disposable flag that identifies throwaway mailbox providers.

How do I identify role accounts like info@ or support@? The is_role_account flag inside the misc object marks shared and departmental addresses, which are usually worth suppressing in one-to-one outreach.

Which SMTP port does the email verification tool use? Port 25 by default, configurable through smtp_port. Port 25 is the standard server-to-server mail transfer port and the one that produces the most representative results.

Why do I need to set a HELO name and MAIL FROM address? Receiving servers evaluate the identity you present during the handshake. Setting hello_name and from_email to values on a domain you actually control makes the verification closer to a real delivery attempt.

Does the actor tell me which mail provider a domain uses? Indirectly, yes — the mx.records array lists the resolved mail exchangers, which reveals whether a domain is on Google Workspace, Microsoft 365, or self-hosted infrastructure.

Can I use this email checker for GDPR-relevant contact data? You can, provided you have a lawful basis for processing those addresses. Email addresses tied to identifiable individuals are personal data, and verification does not change your obligations under GDPR or comparable regimes.

What does the Gravatar check add to the results? When check_gravatar is enabled, the misc object carries a gravatar_url value if the address has a registered Gravatar image — a small but useful signal that the address belongs to an active person.

How do I export verified emails to a CSV file? Open the run's Dataset tab and export as CSV, Excel or JSON, or pull the items through the Apify API with run-sync-get-dataset-items and write them wherever you need.

Does this email verification scraper need proxy configuration? No. Proxy rotation is handled automatically by the actor; there is no proxy setting for you to configure.

How often should I re-verify my email list? For active outreach lists, a re-verification each quarter is a sensible baseline, since contact data decays steadily as people change roles and domains are retired.

Can I integrate the email verifier with my CRM or marketing platform? Yes. Results sit in a standard Apify dataset, so you can reach them via the API, forward them with a webhook, or connect them through Zapier, Make, Google Sheets or Slack.

---

🆘 Support & Feedback

Found a bug or hit an edge case the email verification actor handles badly? Open a ticket on the Issues tab of this actor — it is the fastest way to get a fix, and it keeps the report attached to the run so the behaviour can be reproduced.

Need a custom build — a different verification workflow, extra enrichment fields, or an integration into an existing pipeline? Get in touch at scraperhubapi@gmail.com and describe what you need.

If this email checker saves you a painful bounce report, please leave a review on the actor page. Ratings genuinely help other people find tools that work.

---

⚖️ Disclaimer

This email verification actor performs standard DNS and SMTP protocol checks against publicly reachable mail infrastructure. It does not access mailboxes, read messages, or bypass any authentication.

You are responsible for how you use the results. Email addresses that identify individuals are personal data under GDPR, the UK GDPR, CCPA and similar frameworks; you must have a lawful basis for processing them, honour opt-outs and deletion requests, and comply with anti-spam legislation such as CAN-SPAM and PECR when contacting anyone on a verified list. Verification is not consent.

Use of this actor must also respect the terms of service of the mail providers and networks involved, as well as Apify's platform terms. Verification results are best-effort signals, not guarantees of delivery.

If you believe data processed by this actor should be removed, contact scraperhubapi@gmail.com with the details and it will be addressed.