# Bulk email verifier for lead lists and sign-ups > Bulk email verifier that checks syntax, MX records, disposable and role addresses and typos. Get a status and reasons for each email. No API key. URL: https://cliqtomedia.com/actors/email-verifier/ Category: Leads, companies & validation · Status: live on Apify Store · Apify page: https://apify.com/cliqtomedia/email-verifier?fpr=cliqto Paste email addresses. Each one gets one of 4 statuses: deliverable, risky, undeliverable or unknown, with the reasons. No emails are sent. ## How to use it: 3 steps 1. **Make a free Apify account.** Apify is the cloud platform where our tools run. The free plan gives you $5 of usage every month, no credit card needed. You pay Apify, not us. 2. **Paste your input and press Start.** No code needed: you fill in a form (the input). It already has a working example. For example: `support@apify.com` in Email addresses. Each start is one run. 3. **Download the results.** When the run ends, the results are in a table (the dataset). Open Output, press Export and pick Excel or CSV. JSON and the API are there too. ## What it does Bulk Email Verifier checks a list of email addresses and gives every address a status: **deliverable**, **risky**, **undeliverable** or **unknown**, with the reasons. It checks syntax, DNS MX records, disposable and role addresses, free providers and domain typos. It does not open an SMTP connection, so it cannot confirm that a mailbox exists. No API key from an email provider. Your list is not sent to any third-party verification service. - Checks the syntax by the email standards (RFC 5321 / 5322). For example, `john..doe@example.com` is invalid because of the two dots. - Looks up the domain in DNS: MX records, a "null MX" record (RFC 7505) that says "this domain takes no mail", and the A/AAAA fallback when there is no MX. - Flags disposable domains (temporary inboxes like mailinator.com), role addresses (info@, support@, sales@…) and free providers (gmail.com, outlook.com…). - Suggests a fix for a likely typo: `name@gmial.com` → `name@gmail.com`. - Names the mail provider from the MX hosts, for example Google or Microsoft. - Gives one status and a list of reason codes. ### Good for - Remove bad and risky addresses before an email campaign, so fewer emails bounce. - Check emails found by a lead scraper before you add them to a CRM. - Find typos and disposable addresses in sign-up lists. - Check lists that you do not want to share with another verification company. ### Not a good fit - It does not connect to the mail server (SMTP). It cannot say if one mailbox exists, and it cannot detect catch-all domains. See Limitations. - It does not send emails. - It does not promise 100% accuracy. DNS and mail servers change all the time. ## Price Pay per event. Apify bills you, not us. | What you pay for | Price | When | |---|---|---| | Start fee | $0.005 | Charged once per run. This tool uses 1 GB of memory or less by default; more memory costs more. | | Email checked | $0.0004 (from $0.00034 on paid Apify plans) | One address checked with a deliverable, risky or undeliverable result. Unknown results are not charged. | - One email: about $0.0054. - 1,000 emails: about $0.41. - Every day 100 emails, for 30 days: about $1.35 a month. Free to try: the Apify free plan gives you $5 of usage every month, no credit card needed. Prices checked on 24 October 2026. Current price: https://apify.com/cliqtomedia/email-verifier?fpr=cliqto ## Your data - No emails are sent. The tool checks the address format and the domain's DNS records. - Your list and the results stay in your own Apify account (the run and its dataset). Apify keeps them as its [data retention rules](https://docs.apify.com/platform/storage/usage?fpr=cliqto#data-retention) say, and you can delete them. - Only the domain names (like gmail.com) leave Apify, for public DNS lookups. - Roles under GDPR: you are the controller of your list. Apify processes it for you under its [Data Processing Addendum](https://docs.apify.com/legal/data-processing-addendum). We see anonymous usage statistics (like the number of runs), and your run data only if you turn on "Share run data with developers" in Apify. It is off by default. - Checking a list does not make it legal to email it. You need your own legal basis to send, and in many EU countries marketing emails to people need their consent first. See our [terms](/legal/terms/#your-responsibility-for-data-use) and the [Apify terms](https://docs.apify.com/legal). ## Questions ### How many emails can I check? Up to 10,000 addresses per run. Split bigger lists. ### Do I pay for unknown results? No. Unknown rows and removed duplicates are free. ### Does it show the mail provider? Yes. It names the provider from MX records, for example Google or Microsoft. ### Is my email list stored or shared? Your list goes only into your own Apify account: the input and the results are in your run and its dataset. Apify keeps them for the time its data retention rules say, and you can delete them at any time. We see your run data only if you turn on "Share run data with developers" in Apify; it is off by default. Only the domain names, like gmail.com, leave Apify, for public DNS lookups. No email is sent to anyone. ### Why is a fake gmail.com address "deliverable"? The tool does not ask the mail server if one mailbox exists. It checks the domain: gmail.com accepts mail. So the reason list shows mailbox_not_verified. Use an SMTP check after this tool if you need it. ### Do I need an account or API key from an email verification service? No. Everything runs inside the Actor. You only need an Apify account. ### Should I delete every `risky` address? Not always. Role addresses like `sales@` are often real. Disposable addresses and typos are usually worth removing or fixing. ## Data fields - `email` (string): The address as given (trimmed). - `normalized` (string): Lower-cased local part + ASCII (punycode) domain; null when the syntax is invalid. - `status` (string): deliverable: valid syntax and a working mail domain, no risk flags. risky: mail domain works but there is a risk flag (disposable, role, typo, no MX…). undeliverable: invalid syntax or the domain cannot receive mail. unknown: DNS lookup failed; not charged. The mailbox itself is never probed (see reasons: mailbox_not_verified). - `reasons` (array): Machine-readable reason codes, e.g. invalid_syntax, domain_not_found, null_mx_domain_accepts_no_mail, no_mx_a_record_fallback, disposable_domain, role_account, possible_domain_typo, mailbox_not_verified. - `syntaxValid` (boolean): RFC 5321/5322 syntax check result. - `domain` (string): Domain part in ASCII (punycode). - `hasMx` (boolean): true when the domain publishes MX records with a mail host that resolves to a public address; false for no MX, null MX or unresolvable MX hosts; null when DNS failed or syntax is invalid. - `mxRecords` (array): MX records sorted by priority: {exchange, priority}. - `mxProvider` (string): Mail provider detected from MX hosts, e.g. Google, Microsoft, Zoho, Proton; null when not recognised. - `isDisposable` (boolean): Domain is on the bundled disposable / temporary email list. - `isRoleAccount` (boolean): Local part is a role mailbox (info, support, sales…). - `isFreeProvider` (boolean): Domain is a free webmail provider (gmail.com, outlook.com…). - `isCatchAll` (null): Always null: catch-all needs an SMTP probe, which this Actor does not perform. - `smtpCode` (null): Always null: no SMTP connection is made. - `smtpChecked` (boolean): Always false: mailbox existence is not probed. - `didYouMean` (string): Suggested correction for a likely domain typo, e.g. name@gmail.com for name@gmial.com. - `checkedAt` (string): ISO timestamp of the check. ## Input settings - `emails` (array): Up to 10,000 addresses per run. One per line; a pasted line with several addresses separated by commas, semicolons or spaces is split automatically. Duplicates (case-insensitive) are checked once. - `inputDatasetId` (string): Pick an existing Apify dataset to read addresses from, e.g. the output of a lead scraper, or pass its ID in the API. Combined with the list above; 10,000 addresses at most in total. Up to 20,000 dataset items are read; use a smaller dataset if most items have no address. - `emailField` (string): Name of the field that holds the address in the input dataset. Rows without it are counted in the run summary. - `concurrency` (integer): How many addresses are checked at the same time (5–50). DNS results are shared per domain, so lists with many addresses on one domain are fast at any value. - `deduplicate` (boolean): Check each address once (case-insensitive). Turn off to keep one output row per input line. ## Step by step on Apify 1. Open the Input tab. 2. Paste your addresses into Email addresses (`emails`), one per line. The form already has 5 example addresses. 3. Keep the other settings at their defaults. 4. Click Start. 5. Open the Output tab and check the Status and Reasons columns. ## Use cases | Task | Input | You get | Key fields | Next step | |---|---|---|---|---| | Clean a list before a campaign | `emails` | One row per address | `status`, `reasons` | Keep `deliverable`, review `risky`, remove `undeliverable` | | Check scraped leads | `inputDatasetId` + `emailField` | One row per address | `status`, `isRoleAccount`, `mxProvider` | Import good rows into a CRM | | Fix sign-up typos | `emails` | One row per address | `didYouMean`, `reasons` | Ask the user to correct the address | | Block temporary inboxes | `emails` | One row per address | `isDisposable` | Reject or flag the sign-up | ## Tips - Use the input dataset option to check another Actor's output directly. - Fix typos with the suggested address, like gmial.com to gmail.com. - Set a maximum cost per run. The tool stops before it goes over. ## Limits - No SMTP check. Apify does not allow outgoing connections on port 25, so the Actor does not talk to mail servers. A wrong mailbox on a real domain (for example a made-up name at gmail.com) is shown as `deliverable` with `mailbox_not_verified`. Use this Actor as a fast, private first filter. If you need mailbox-level checks, use an SMTP verification service after it. - No catch-all detection. `isCatchAll` is always null. - Lists change. The disposable and free-provider lists come from open-source projects (disposable-email-domains, MIT; freemail, ISC). New temporary services may be missing. - DNS can fail. If DNS does not answer for a domain, the row is `unknown` and free. If DNS fails for more than half of the domains checked (after 10 domains, or after 30 seconds) or for more than half of the first 100 addresses, the run stops with an error so you do not wait for a list of dead domains. ## Sample result Here sales@stripe.com is risky because it is a role address (role_account): it goes to a team, not one person. mailbox_not_verified is on every address, because the tool never asks the mail server. ```json { "email": "sales@stripe.com", "normalized": "sales@stripe.com", "status": "risky", "reasons": ["role_account", "mailbox_not_verified"], "syntaxValid": true, "domain": "stripe.com", "hasMx": true, "mxRecords": [{ "exchange": "aspmx.l.google.com", "priority": 10 }], "mxProvider": "Google", "isDisposable": false, "isRoleAccount": true, "isFreeProvider": false, "isCatchAll": null, "smtpCode": null, "smtpChecked": false, "didYouMean": null, "checkedAt": "2026-10-13T01:57:42.504Z" } ``` ## Use it from code Actor ID: `cliqtomedia/email-verifier` ```python from apify_client import ApifyClient client = ApifyClient("YOUR_APIFY_TOKEN") run = client.actor("cliqtomedia/email-verifier").call(run_input={ "emails": [ "support@apify.com", "someone@nonexistentdomain-7c1e5b42.com", "test@mailinator.com" ], "emailField": "email" }) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item) ``` ```bash curl -X POST "https://api.apify.com/v2/acts/cliqtomedia~email-verifier/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \ -H "Content-Type: application/json" \ -d '{"emails": ["support@apify.com", "someone@nonexistentdomain-7c1e5b42.com", "test@mailinator.com"], "emailField": "email"}' ``` ```python # pip install langchain-apify # set APIFY_TOKEN in your environment from langchain_apify import ApifyActorsTool tool = ApifyActorsTool("cliqtomedia/email-verifier") result = tool.invoke({"run_input": {"emails": ["support@apify.com", "someone@nonexistentdomain-7c1e5b42.com", "test@mailinator.com"], "emailField": "email"}}) print(result) ``` run-sync waits up to 300 seconds; for longer runs start a run and use a webhook. LlamaIndex and MCP: https://cliqtomedia.com/actors/ai-agents/ ## Use cases with this tool - [Lead lists from public data](https://cliqtomedia.com/actors/use-cases/lead-generation/): Build lists of companies and contacts from public sites. Check emails and phones before you send. - [Find the right creators, fast](https://cliqtomedia.com/actors/use-cases/creator-outreach/): Find podcasts, YouTube channels and newsletters in your niche, with public contact details. ## Similar tools - [Website Contact Scraper](https://cliqtomedia.com/actors/website-contacts-scraper/) - [Domain WHOIS (RDAP) & DNS Lookup, No Login](https://cliqtomedia.com/actors/domain-whois-dns-lookup/) - [EU VAT Number Validator (VIES) - Bulk Check, No Login](https://cliqtomedia.com/actors/vat-number-validator/) - [Europages Scraper: B2B Suppliers & Certificates (No Login)](https://cliqtomedia.com/actors/europages-companies-scraper/) - [France Company & SIRET Search](https://cliqtomedia.com/actors/france-sirene-company-search/) - [Norway Company Register (Brreg) & Updates](https://cliqtomedia.com/actors/norway-brreg-company-register/)