Email Verifier & Validator - Dataset Input, MX Check

Why use this scraper

Every list of emails you collect, whether from a signup form, a scraped lead list, or a CSV someone handed you, has some percentage of addresses that will bounce, land you on a spam blacklist, or simply belong to nobody. Sending to them wastes money on your email provider and damages your sender reputation for the good addresses on the same list. This Actor checks every address before you send a single email: it confirms the syntax is valid, looks up the domain's real mail servers (MX records) to see if it can actually receive mail, flags disposable and temporary-email domains, flags role-based addresses like info@ or admin@ that rarely belong to a person, and catches common typos like gmial.com before they cost you a bounce. You get a clear status and a 0-100 score per address, so you can filter your list in one pass instead of finding out which addresses were dead after your campaign already went out.

Overview

Input is a list of email addresses, pasted directly or pulled from an existing Apify dataset. Output is one record per address with syntax validity, MX/domain status, disposable and role-based flags, a free-provider flag, typo suggestions, an overall status (valid, risky, invalid) and a numeric score. A batch of a few hundred addresses typically finishes in well under a minute, since checks run concurrently. Cost is a flat $0.001 per email verified, with no subscription.

Supported inputs

• Emails (emails, array): paste addresses directly, one per line or as a comma/space-separated list. This is the simplest way to check a list you already have in hand.
• Dataset ID (datasetId, optional): instead of (or in addition to) pasting addresses, point this Actor at an existing Apify dataset, for example the output of a lead-scraping Actor you already ran, and it will pull the emails straight from there.
• Email field name (emailField, optional): when using datasetId, the column or field name in that dataset that holds the email address (e.g. email).
• Concurrency (concurrency, optional, default 20): how many addresses to check in parallel, from 1 to 50. Raise it for large lists, lower it if you want a gentler, slower pace.

Use cases

• Marketing teams cleaning a list before a campaign: run your whole subscriber list through once, strip out invalid and disposable addresses, and send only to addresses with a real chance of landing in an inbox.
• Sales and growth teams validating scraped leads: feed the dataset straight from a lead-generation Actor into this one via datasetId, no manual export/import step, and only reach out to addresses that pass MX checks.
• SaaS signup forms doing pre-send validation: catch typos like gmial.com or yahooo.com at signup time instead of after your welcome email bounces.
• Deliverability and compliance teams auditing an existing database: periodically re-verify a customer list to catch addresses that have gone disposable or stopped resolving since they were first collected.

How it works

Each address is checked in layers: syntax is parsed first, then the domain's mail-exchange (MX) records are looked up live to confirm the domain can actually receive mail, then the domain is checked against known disposable-email and free-provider patterns, then the local part is checked for role-based prefixes (info, admin, support, noreply and similar), and finally the domain is compared against common typo patterns of popular providers to catch things like gmial.com or yahooo.com. The checks run concurrently across your whole list so a batch of hundreds of addresses doesn't take hundreds of sequential lookups.

Input configuration

Mode: paste a list directly

{
  "emails": ["john.doe@gmail.com", "info@mailinator.com", "test@gmial.com"],
  "concurrency": 20
}

Mode: verify from an existing Apify dataset

{
  "datasetId": "Wil8Th5gbCyXm1yEq",
  "emailField": "email",
  "concurrency": 30
}

Mode: small, careful batch (low concurrency)

{
  "emails": ["ceo@example.com", "sales@example.com"],
  "concurrency": 5
}

All three are valid against the Actor's input schema.

Output sample

Real items from a live run:

[
  {
    "email": "john.doe@gmail.com",
    "isValidSyntax": true,
    "domain": "gmail.com",
    "mxFound": true,
    "mxRecord": "gmail-smtp-in.l.google.com",
    "isDisposable": false,
    "isRoleBased": false,
    "isFreeProvider": true,
    "didYouMean": null,
    "status": "valid",
    "score": 90,
    "reason": "valid"
  },
  {
    "email": "user@yahooo.com",
    "isValidSyntax": true,
    "domain": "yahooo.com",
    "mxFound": false,
    "mxRecord": null,
    "isDisposable": false,
    "isRoleBased": false,
    "isFreeProvider": false,
    "didYouMean": "user@yahoo.com",
    "status": "risky",
    "score": 45,
    "reason": "possible_typo"
  },
  {
    "email": "noreply@apify.com",
    "isValidSyntax": true,
    "domain": "apify.com",
    "mxFound": true,
    "mxRecord": "aspmx.l.google.com",
    "isDisposable": false,
    "isRoleBased": true,
    "isFreeProvider": false,
    "didYouMean": null,
    "status": "risky",
    "score": 60,
    "reason": "role_based_address"
  }
]

Key output fields

Field	Type	Description
email	string	The address checked, exactly as submitted
isValidSyntax	boolean	Whether the address is correctly formatted
domain	string	Domain part of the address
mxFound	boolean	Whether the domain has usable mail-exchange (MX) records
mxRecord	string or null	The MX hostname found, when any
isDisposable	boolean	Whether the domain matches a known disposable/temporary email provider
isRoleBased	boolean	Whether the local part looks role-based (info, admin, support, etc.) rather than personal
isFreeProvider	boolean	Whether the domain is a free consumer provider (Gmail, Yahoo, etc.)
didYouMean	string or null	A suggested correction when the domain looks like a common typo of a popular provider
status	string	Overall verdict: valid, risky or invalid
score	number	0-100 confidence score, higher is safer to send to
reason	string	Short code explaining the status (valid, disposable_domain, role_based_address, possible_typo, no_mx_record, etc.)

Pricing

Pay-per-event, no subscription:

Event	Price
Email verified	$0.001

Verifying 1,000 addresses costs $1.00.

What makes this richer than the competition

Two other email verifiers on the Apify Store get meaningful traffic for the same job:

• bounceverify/bounceverify-email-verifier (1,449 users in the last 30 days) runs a deeper "6-layer" check and prices from $0.00065 to $0.00089 per email depending on your Apify plan tier, undercutting this Actor on raw per-email price at scale.
• michael.g/email-verifier-validator (496 users in the last 30 days) covers similar ground at a comparable tiered price.

This Actor's edge over both is the Dataset ID input: point it directly at the dataset ID from any other Apify Actor's run, such as a lead scraper, and it verifies those emails without you ever exporting a CSV or writing glue code. If your workflow already lives on Apify, that one input field saves a manual export/import step every single run.

Notes & limitations

• An MX lookup confirms the domain can receive mail; it cannot confirm a specific mailbox exists or is actively monitored (that requires an SMTP handshake, which this Actor does not perform, by design, to avoid tripping provider rate limits and spam defenses).
• Typo detection (didYouMean) catches common misspellings of major providers (for example yahooo.com to yahoo.com). It is pattern-based, not exhaustive: some unusual-domain typos may instead be classified as disposable_domain if the misspelled domain has no valid MX record, since both conditions produce the same "can't receive mail reliably" signal.
• Role-based detection is based on common prefixes and can occasionally flag a legitimate personal mailbox that happens to start with a role-like word.

FAQ

Does this send any test emails? No. All checks are DNS/MX lookups and pattern matching; no email is ever sent to the address being checked.

Can I verify emails straight from another Actor's output? Yes, that's the datasetId input: point it at any dataset ID (yours or from another Actor's run) and the field name holding the email, and it verifies them without manual export.

What does a risky status mean versus invalid? invalid means the address almost certainly cannot receive mail (bad syntax or no MX record at all). risky means it can technically receive mail but carries a real risk, like being role-based, a likely typo, or a disposable/temporary domain.

Does it work for non-English domains and addresses? Yes, MX lookups and syntax validation work the same for any domain; disposable and typo pattern lists are weighted toward globally common providers.

How fast is a large batch? Checks run concurrently (set by the concurrency input, up to 50 at once), so a list of a few hundred addresses typically finishes in well under a minute.

For AI Agents & LLM Apps

This Actor is callable over MCP (mcp.apify.com) and via the Apify API for use inside agent workflows. Example direct API call:

curl "https://api.apify.com/v2/acts/gio21~email-verifier/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"emails": ["john.doe@gmail.com", "test@gmial.com"]}'

run-sync-get-dataset-items runs the Actor and returns the dataset items directly in the response, which makes it easy for an agent to clean a lead list in a single tool call before passing it on to an email-sending step.

Disclaimer

This Actor performs independent DNS and pattern-based checks and is not affiliated with, endorsed by, or sponsored by Gmail, Yahoo, or any email provider named in this README as an example. Provider and domain names are used only to describe real, observable output of the verification checks.

SEO Keywords

Email verifier, bulk email validation, MX record checker, disposable email detector, email list cleaning