Bulk Email Validator: Syntax, MX, Disposable, Role & Typo Check

Clean an email list without sending a single email. Paste emails, point it at a CSV / Google Sheet, or feed it the dataset of another Actor, and get one row per email with:

• Syntax check (RFC 5321/5322, the parts real mail systems accept) with a plain-English error: Two dots in a row before @, Domain has no extension (e.g. .com), Invalid character "(" before @...
• Cleanup: spaces removed, domain lower-cased, "Name <email>", mailto: links, trailing dots and gmail,com fixed; international domains converted to punycode.
• Typo suggestions for common providers: gmial.com → gmail.com, hotmail.con → hotmail.com, yahoo.com.arg → yahoo.com.ar, gmailcom → gmail.com.
• MX records of the domain (with the RFC 5321 fallback to the A/AAAA record when there is no MX), null MX detection (domains that declare they accept no mail, like example.com) and the mail provider (Google, Microsoft, Yahoo, Zoho, Proofpoint...).
• Disposable / temporary domains (mailinator, yopmail, 10minutemail... about 10,000 domains, subdomains included).
• Role accounts: info@, sales@, support@, noreply@, contacto@, ventas@... (shared mailboxes, not a person).
• Free providers: Gmail, Outlook/Hotmail, Yahoo, iCloud, AOL, Proton, GMX, Yandex, Mail.ru, regional ISPs...
• SPF and DMARC of the domain (policy none / quarantine / reject, with the RFC 7489 fallback to the organizational domain).
• Duplicates (case-insensitive, after cleanup): flagged or removed.
• A final status valid / risky / invalid with the reason in one sentence.

What does Bulk Email Validator do?

Bulk Email Validator cleans email lists without sending a single email: syntax check, typo suggestions (gmial.com to gmail.com), MX records, disposable / temporary email domains, role accounts (info@, sales@), free providers, SPF and DMARC, with a valid / risky / invalid verdict and a reason. It does not do SMTP mailbox probing.

How to use Bulk Email Validator

1. Click Try for free on this page (a free Apify account is enough to start).
2. Fill in the input (see the examples below) or keep the prefilled example.
3. Click Start and wait for the run to finish.
4. Download the results from the Output tab as JSON, CSV, Excel or HTML, or read them with the Apify API.
5. Optional: create a Schedule to run it daily or weekly, and connect a webhook or an integration (Make, Zapier, n8n, Slack).

What it does NOT do (on purpose)

No SMTP check. This Actor never connects to port 25, never opens a session with the recipient's mail server and never sends an email. It only uses public DNS (DNS over HTTPS through Cloudflare and Google).

That means it does not verify that the mailbox exists. valid means "well-formed, not disposable, not a likely typo, and the domain has a working mail server setup". A made-up address at a real company (nobody-here-123@microsoft.com) is valid here. SMTP "mailbox probing" is slow, often blocked from cloud servers, gets your IP blacklisted, and many large providers (Gmail, Outlook, Yahoo) accept every address during the probe anyway (catch-all behaviour), so its answers are unreliable. If you need mailbox-level verification, use this Actor first to remove the obvious junk cheaply, then send only the remaining valid rows to a paid SMTP verifier.

Use cases

• Clean lists before a campaign: remove invalid and disposable addresses and fix typos before you import into Mailchimp, Brevo, HubSpot or Instantly. Fewer hard bounces protect your sender reputation.
• Validate sign-up and lead forms: run your form exports daily, catch @gmial.com typos and throwaway inboxes, and reach the person through another channel with the suggested address.
• CRM hygiene: periodic checks of the contacts table: domains that stopped receiving mail, role accounts mixed with people, duplicates with different casing.
• Lead scraping pipelines: chain it after a contact or Google Maps scraper (dataset input) and keep only the rows worth sending to.
• B2B segmentation: free provider vs company domain, mail provider (Google Workspace vs Microsoft 365) and DMARC policy per domain.

Input

Field	What it does
Email addresses	One per line. Messy values are fine. A line with several emails separated by ; or , gives one row per email.
Dataset	The output of another Actor run. Use Email field (email, contact.email, emails.0...) to say where the email is. Lists in that field give one row per email.
CSV file URL	Public CSV with a header row (, ; tab or `
Fields to keep from the source	Copy columns like name, company, id into the output (source) to join the results back.
Check MX / Check SPF and DMARC	Turn off for a syntax-only run (no network at all) or to skip the SPF/DMARC lookups.
Duplicates	Flag (isDuplicate, duplicateOf) or remove (not charged).
Include invalid / risky emails	Turn off to get only the rows you can send to (filtered rows are not charged).
Domains in parallel, DNS timeout, Max emails	Tuning. Defaults work for most lists.

Example input

{
  "csvUrl": "https://docs.google.com/spreadsheets/d/your-sheet-id/edit#gid=0",
  "emailField": "Email",
  "keepFields": ["Name", "Company"],
  "duplicates": "skip",
  "includeInvalid": false
}

Output (one row per email)

{
  "position": 2,
  "input": " Someone@GMIAL.com ",
  "email": "Someone@gmial.com",
  "status": "risky",
  "reason": "Possible typo in the domain, did you mean gmail.com?",
  "reasons": ["Possible typo in the domain, did you mean gmail.com?", "No MX record: mail would go to the A record (fallback), often not set up for email"],
  "isValidSyntax": true,
  "syntaxError": null,
  "localPart": "Someone",
  "domain": "gmial.com",
  "domainUnicode": null,
  "suggestion": "Someone@gmail.com",
  "isDisposable": false,
  "isRoleAccount": false,
  "isFreeProvider": false,
  "domainExists": true,
  "hasMx": false,
  "mailServerSource": "a-fallback",
  "mxRecords": [],
  "mailProvider": null,
  "hasSpf": false,
  "spfRecord": null,
  "hasDmarc": false,
  "dmarcPolicy": null,
  "dmarcRecord": null,
  "dmarcFoundAt": null,
  "isDuplicate": false,
  "duplicateOf": null,
  "dnsError": null,
  "source": null
}

Every row has exactly the same keys, so CSV and Excel exports have stable columns. The dataset has three views: Validated emails, Domain and email security and Problems. The RUN_SUMMARY record in the key-value store has the totals (valid, risky, invalid, disposable, role, free provider, typos, duplicates), the top domains and reasons, DNS statistics and speed.

status	Meaning
valid	Good syntax, the domain exists and has MX records, not disposable, not a role account, no likely typo. The mailbox itself is not verified (see above)
risky	Deliverable in principle but worth a second look: likely typo, disposable domain, role account, no MX record (mail would go to the A record), quoted or non-ASCII part before the @
invalid	Bad syntax, the domain does not exist, the domain publishes a null MX (accepts no mail), the MX points to localhost/an IP, or there is no mail server at all
unknown	The DNS lookup failed after retries (timeouts). Not charged; run those again later

reason is the most important finding; reasons lists all of them.

Pricing

Pay per event: USD 1 per 1,000 emails (USD 0.001 per email in the results). Not charged: duplicates with "Remove duplicates", rows you filter out with the include options, and unknown rows (DNS failure). The run respects your max charge per run. Platform usage is included.

Speed and limits

• DNS results are cached per domain during the run: 50,000 emails at gmail.com cost one lookup. Lists with many different domains are limited by DNS (tens to a couple of hundred new domains per second, 20 in parallel by default); emails on domains already seen in the run are near-instant.
• Default memory 256 MB is enough for large lists. Up to 1,000,000 emails per run (maxEmails).
• The disposable domain list is the open-source disposable-email-domains list (CC0), bundled with the Actor and refreshed with new builds. No list can catch every new throwaway domain.
• If no row is produced (empty input, wrong field name, wrong dataset ID, CSV not reachable), the run is marked as failed with a clear message, never a silent empty success.

Privacy

The Actor only reads the domain part of each email from DNS. The emails are never sent to any third-party verification API and never contacted. Nothing is stored outside your run's own dataset and key-value store.

Why use Bulk Email Validator

• No emails sent, no SMTP connections. It never talks to the recipients' mail servers, so it is fast and cannot get your IP flagged.
• Catches the common problems in a list: bad syntax, typos with a suggested fix (gmial.com to gmail.com), domains without MX, about 10,000 disposable domains, role accounts (info@, sales@), free providers, and SPF / DMARC of the domain.
• Clear result per row: valid, risky, invalid or unknown, with a main reason and all reasons.
• Cheap first pass: unknown rows (DNS failure), removed duplicates and rows you filter out are not charged.

Cost examples

Prices at the current pay-per-event rates (see Pricing). You can set a maximum charge per run in the run options.

Job	Approximate cost
1,000 emails	about $1
10,000 emails	about $10
100,000 emails	about $100

Use it from your code, an integration or an AI agent

Python (pip install apify-client):

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("latamdatatools/email-validator-bulk").call(run_input={
    "emails": [
        "support@apify.com",
        "someone@gmial.com",
        "test@mailinator.com",
        "info@example.com"
    ]
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

JavaScript / Node.js (npm install apify-client):

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('latamdatatools/email-validator-bulk').call({
  "emails": [
    "support@apify.com",
    "someone@gmial.com",
    "test@mailinator.com",
    "info@example.com"
  ]
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

No code:

• Schedules: run it daily or weekly from Apify Console (Schedules), with the same input saved as a Task.
• Integrations: send results to Google Sheets, Slack, email, Make, Zapier, n8n or Airbyte from the Integrations tab, or call your own webhook when a run finishes.
• AI agents: add it as a tool in Claude, Cursor, VS Code and other MCP clients through the Apify MCP server (https://mcp.apify.com), so the agent can run Bulk Email Validator and read the results.

FAQ

Why is an email I know is fake marked valid? Because the Actor does not ask the mail server whether the mailbox exists (no SMTP probe). It checks everything that can be known from the address and public DNS.

Why is info@company.com risky? Role accounts usually go to several people or a ticket system; many email platforms restrict sending marketing email to them. If they are fine for your use case (B2B outreach to generic inboxes), filter on isRoleAccount yourself.

Why is a company domain with no MX risky and not invalid? RFC 5321 says mail can fall back to the domain's A record, so delivery is technically possible, but in practice most such domains do not run a mail server.

Does it detect catch-all domains? Not reliably: that needs an SMTP probe. mailProvider tells you who hosts the mail (Google and Microsoft do not accept everything; some corporate gateways do).

Should I use this or an SMTP email verifier? Use this first to remove the obvious bad rows cheaply and safely. If you also need to know whether each mailbox exists, send only the valid rows to an SMTP verifier afterwards, so you pay for fewer checks.

Questions or a missing check? Open an issue in the Issues tab.