Clean Email Verifier

Clean Email Verifier is a real-time email verification API that checks whether an email address is valid and safe to send to. Paste a list of addresses and get back a clear, per-email result — deliverable, risky, or invalid — plus disposable, role, free-provider and catch-all signals and a typo suggestion, all in seconds.

Use it to clean email lists, protect your sender reputation, cut bounce rates, and block fake sign-ups before they ever reach your database.

What does Clean Email Verifier do?

For every email address you provide, the Actor performs a live check — syntax, domain, MX records and mailbox — and returns a structured result:

• ✅ Deliverable — the mailbox exists and can receive email (result: ok).
• ⚠️ Risky — the address may accept mail but carries risk, e.g. catch-all domains, disposable addresses, or an unknown mailbox state.
• ❌ Invalid — the address is malformed, the domain has no mail server, or the mailbox does not exist.

It also tells you whether an address is a free provider (Gmail, Yahoo…), a role address (info@, sales@, admin@), and offers a "did you mean" correction for common typos such as gmal.com → gmail.com.

Why use Clean Email Verifier?

• Reduce bounces & protect deliverability — remove invalid addresses before you send, keeping your bounce rate low and your domain reputation healthy.
• Stop fake sign-ups — reject disposable and invalid emails at registration.
• Real-time results — each address is verified live in about a second, not queued for hours.
• Rich signals, not just yes/no — catch-all, disposable, role, free and typo detection let you make smarter decisions.
• Bulk-friendly — verify one address or thousands of them in a single run.
• Runs anywhere on Apify — schedule it, call it from the API, chain it into workflows, or trigger it from Make, Zapier and n8n.

What data do you get for each email?

Every verified address is stored as one row in the dataset:

Field	Type	Description
email	string	The email address that was checked.
result	string	Verification outcome: ok, catch_all, unknown, disposable, invalid, or error.
resultcode	integer	Numeric form of result: 1 ok, 2 catch_all, 3 unknown, 4 error, 5 disposable, 6 invalid.
quality	string	Simple quality grade: good, risky, or bad.
subresult	string	Technical detail behind the result, e.g. ok, no_mailbox, dns_no_mx, mailbox_full, greylisted.
free	boolean	true if the domain is a free email provider (Gmail, Yahoo, Outlook…).
role	boolean	true if the address is a role/team inbox (info@, support@, admin@).
didyoumean	string	Suggested correction for a likely typo, or empty if none.
error	string	Error message when result is error, otherwise empty.

How to verify emails

1. Open the Actor and go to the Input tab.
2. Add the email addresses you want to check into the Email addresses field — one per line.
3. (Optional) Open Advanced settings to change the per-address timeout.
4. Click Start.
5. Watch the live log as each address is verified, then open the Output tab (or Storage → Dataset) to see the results.
6. Export the results as JSON, CSV, Excel or HTML, or fetch them from the Apify API.

How much does it cost?

Cost scales with how many addresses you verify. A single address is verified in roughly a second, so runs are fast and compute usage is minimal — the main cost driver is the number of emails on your list, not the run time. Verify a handful of addresses for a fraction of a cent, or clean lists of thousands in a single run. See the Pricing section on the Actor's Store page for the exact model.

Input

Configure everything on the Input tab. See the input schema for all options.

Field	Type	Default	Description
emails	array of strings	3 sample addresses	The addresses to verify, one per line. Duplicates and blank lines are ignored. Required.
timeout	integer	60	Seconds to wait for the recipient mail server per address (2–60).

Example input

{
    "emails": ["karbontechstore@gmail.com", "test@gmail.com", "salim@karbon-tech.store"],
    "timeout": 20
}

Output

Results are saved to the run's dataset, one item per email, and you can download them as JSON, CSV, Excel or HTML. Each item holds the verification result for one address.

[
    {
        "email": "karbontechstore@gmail.com",
        "quality": "good",
        "result": "ok",
        "resultcode": 1,
        "subresult": "ok",
        "free": true,
        "role": false,
        "didyoumean": "",
        "error": ""
    },
    {
        "email": "someone@gmal.com",
        "quality": "bad",
        "result": "invalid",
        "resultcode": 6,
        "subresult": "bad_domain",
        "free": false,
        "role": false,
        "didyoumean": "someone@gmail.com",
        "error": ""
    }
]

A run SUMMARY is also written to the default key-value store, with totals broken down by result and quality and the remaining credit balance.

Result reference

Result codes

Code	Result	Meaning
1	ok	Valid, existing mailbox — safe to send.
2	catch_all	Domain accepts all addresses; individual mailbox can't be confirmed.
3	unknown	The mail server did not give a definitive answer (greylisting, timeout…).
4	error	The address could not be checked — see the error field.
5	disposable	Temporary/throwaway address.
6	invalid	Malformed address, dead domain, or non-existent mailbox.

Quality grades

• good — safe to send.
• risky — send with caution (catch-all, unknown, disposable).
• bad — do not send.

Integrate with the Apify API

Run the Actor from your own code and read back the results.

JavaScript / Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('YOUR_USERNAME/clean-email-verifier').call({
    emails: ['john@example.com', 'sales@company.com', 'typo@gmal.com'],
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const item of items) {
    console.log(`${item.email}: ${item.result} (${item.quality})`);
}

// Keep only the addresses that are safe to send to.
const deliverable = items.filter((i) => i.result === 'ok').map((i) => i.email);
console.log('Deliverable:', deliverable);

cURL

curl -X POST "https://api.apify.com/v2/acts/YOUR_USERNAME~clean-email-verifier/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "emails": ["john@example.com", "sales@company.com"] }'

Tips

• Slow domains — increase the timeout (up to 60s) so slow mail servers are given more time before being marked unknown.
• Act on the signals — treat ok as safe, drop invalid and disposable, and decide per campaign how to handle catch_all and unknown.
• Fix typos automatically — when didyoumean is set, offer the correction back to the user at sign-up.

FAQ

Do I need an API key or any external account to run this? No. Just add your email addresses and click Start — everything is handled for you.

Can it verify a single email? Yes — add a single address. The Actor works for one email or thousands.

Why did an address come back as catch_all or unknown? Some mail servers accept every address (catch_all) or refuse to confirm a mailbox (unknown, e.g. greylisting). These are graded risky — verify importance before sending.

In what formats can I download the results? JSON, CSV, Excel and HTML from the Output tab, or via the Apify dataset API.

Disclaimers & support

Only verify email addresses you have a legitimate reason to process. Email addresses are personal data protected by the GDPR in the European Union and by other regulations worldwide — make sure your use complies with applicable law. This Actor performs deliverability checks only and does not send email to the addresses it verifies.

Found a bug or have a feature request? Open a ticket on the Issues tab, and see the API tab for programmatic access.