# Bulk Email Validator: Syntax, MX, Disposable & Role Checks (`capable_cauldron/email-validator`) Actor

Clean an email list before you send. Checks syntax, MX records, disposable and role addresses, free providers and typos like gmial.com, and returns VALID, RISKY, INVALID or UNKNOWN with a score. Paste emails or point it at another run's dataset.

- **URL**: https://apify.com/capable_cauldron/email-validator.md
- **Developed by:** [Capable Cauldron](https://apify.com/capable_cauldron) (community)
- **Categories:** Lead generation, Developer tools, Marketing
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.50 / 1,000 email validateds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

Email Validator is a **bulk email validator** that cleans an **email list** before you send. It checks every address for **valid syntax**, live **MX records**, **disposable** inboxes, **role accounts** like info@ and sales@, **free providers** like Gmail, and common **typos** such as `gmial.com` or `.con`. Each email comes back as VALID, RISKY, INVALID or UNKNOWN with a short reason and a 0 to 100 score, so you can drop bad rows, fix typos and protect your sender reputation.

This Actor flags address and domain risks; it does not confirm whether a specific mailbox exists. When you need verified addresses, use [Verified Work Email Finder](https://apify.com/capable_cauldron/verified-work-email-finder), which returns emails that have already been verified. Like every Apify Actor, it runs on a schedule, through the API, and inside Make, Zapier, n8n and Clay workflows.

Click **Try for free**, paste your emails and press **Start**. The Apify free plan gives you $5 of credit every month, which covers about 10,000 email checks.

See a real run in 47 seconds:

[![Bulk Email Validator demo video, 47 seconds](https://api.apify.com/v2/key-value-stores/9FGooi7IrKs0P8DcV/records/email-validator-demo-poster.jpg)](https://api.apify.com/v2/key-value-stores/9FGooi7IrKs0P8DcV/records/email-validator-demo.mp4)

▶️ [Watch the 47-second demo](https://api.apify.com/v2/key-value-stores/9FGooi7IrKs0P8DcV/records/email-validator-demo.mp4) (MP4, 20 MB, opens in your browser) · [Transcript](https://api.apify.com/v2/key-value-stores/9FGooi7IrKs0P8DcV/records/email-validator-demo-transcript.srt)

### What can Email Validator do?

- ✅ Checks **syntax** the way mail servers do, normalizes case and whitespace, strips `mailto:` links, and converts international domains (bücher.de) to their DNS form
- 📮 Looks up **MX records** for every domain and catches dead domains, domains that publish "no mail accepted" (null MX), and domains with no mail server at all
- 🗑️ Flags **disposable email** domains including subdomains
- 👥 Marks **role accounts** (info, sales, support, admin, noreply and about 80 more) that reach a team instead of a person
- 🆓 Tags **free providers** (Gmail, Outlook, Yahoo, iCloud, Proton, GMX, Yandex, Mail.ru, QQ, 163 and more) so you can separate B2B from personal addresses
- ✏️ Suggests a **fix for typos**: `john@gmial.com` gets `didYouMean: john@gmail.com`
- 🔗 Validates the email column of **another run's dataset**, so it slots in right after any lead scraper
- ⚡ Supports large batches and returns one verdict per input address

| Status | Meaning | What to do |
|---|---|---|
| `VALID` | Good syntax, the domain accepts mail, no red flags | Send |
| `RISKY` | Role account, likely typo, or a domain without an MX record | Review, fix the typo, or send with care |
| `INVALID` | Broken syntax, dead domain, no mail server, or disposable inbox | Remove |
| `UNKNOWN` | DNS did not answer in time | Re-run later |

### How to validate an email list

1. Open the Actor and click **Try for free**. Sign up with Google, GitHub or email; no credit card is needed.
2. Paste your addresses into **Emails**, one per line. Commas and semicolons work too.
3. Or put a **Dataset ID** from an earlier run (for example a lead or contact scraper) and tell it which **Email column** to read.
4. Click **Start**. Results stream into the dataset in the same order as your list.
5. Filter by `status`, then download CSV, Excel or JSON, or send the clean list to Google Sheets, HubSpot or your email tool with an integration.

### How much does it cost to validate emails?

You pay per unique email checked. Duplicates in your list are checked and billed once.

| Event | Price |
|---|---|
| Email validated | $0.0005 |

That is $0.50 per 1,000 emails. Platform compute is included, so the event table is the whole bill.

Worked examples:

- **A 1,000-row lead list** costs **$0.50**.
- **A 20,000-contact CRM export** costs **$10.00**.
- **The free plan.** $5 of monthly credit validates about 10,000 emails.

A useful workflow is to clean the list here first, then use an SMTP verification service when you need mailbox-level checks. To cap spending, set **Maximum cost per run** in the run options; the Actor stops cleanly at the cap and keeps every result so far.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `emails` | array | — | Addresses to check. One per line; commas and semicolons also separate them. |
| `datasetId` | string | — | Optional. Validate the emails in another Apify dataset as well. |
| `emailField` | string | `email` | The dataset field that holds the email. A single address or a list both work. |
| `checkMx` | boolean | true | Look up the mail servers for each domain. Off means syntax and list checks only. |
| `maxConcurrency` | integer | 20 | Domains looked up in parallel (1 to 100). |

```json
{
    "emails": ["info@apify.com", "john.doe@gmial.com", "someone@mailinator.com"],
    "checkMx": true
}
```

#### Validating the output of another Actor

Every Apify run has a default dataset. Copy its ID from the run's **Storage** tab (or `defaultDatasetId` in the API) into `datasetId`, and set `emailField` to the column name, such as `emails` for [Website Contact Scraper](https://apify.com/capable_cauldron/website-contact-scraper). Rows where the field holds a list of addresses are expanded, one result per address.

#### How the score works

| Result | Score |
|---|---|
| VALID, MX checked | 90 |
| VALID, MX not checked | 70 |
| RISKY, role account | 60 |
| RISKY, no MX record but the domain has a web server | 50 |
| UNKNOWN | 40 |
| RISKY, possible typo | 20 |
| INVALID | 0 |

The highest score is 90, because a DNS check cannot prove that a specific mailbox exists.

### Output

One row per unique email, in the order you gave them. Here is the row for the typo in the example input:

```json
{
    "email": "john.doe@gmial.com",
    "normalizedEmail": "john.doe@gmial.com",
    "domain": "gmial.com",
    "status": "INVALID",
    "reason": "possible_typo",
    "score": 0,
    "isValidSyntax": true,
    "hasMx": null,
    "mxRecords": [],
    "isDisposable": true,
    "isRoleAccount": false,
    "isFreeProvider": false,
    "didYouMean": "john.doe@gmail.com",
    "checkedAt": "2026-11-05T10:12:44.120Z"
}
```

`gmial.com` is a typo-squat domain on the disposable blocklist, so mail sent there reaches a stranger instead of John. The row says INVALID and gives the corrected address. Possible values of `reason`: `ok`, `ok_mx_not_checked`, `role_account`, `possible_typo`, `no_mx_records_a_fallback`, `syntax`, `empty`, `disposable_domain`, `domain_not_found`, `null_mx`, `no_mx_records`, `dns_timeout`, `dns_servfail`, `dns_error`.

The dataset has a **Results** view and a **Full detail** view with the MX hosts. Counts of valid, risky, invalid and unknown emails are saved to the `OUTPUT` record in the key-value store.

### Use cases

Start with one of these six prefilled examples:

- [Clean a business email list with DNS checks](https://apify.com/capable_cauldron/email-validator/examples/ev-clean-a-business-email-list)
- [Find common email domain typos](https://apify.com/capable_cauldron/email-validator/examples/ev-find-typos-in-email-domains)
- [Identify disposable email addresses in a list](https://apify.com/capable_cauldron/email-validator/examples/ev-identify-disposable-email-addresses)
- [Separate role inboxes from named email addresses](https://apify.com/capable_cauldron/email-validator/examples/ev-separate-role-inboxes-from-personal-emails)
- [Run a quick email syntax and domain-list check](https://apify.com/capable_cauldron/email-validator/examples/ev-quick-email-syntax-and-list-check)
- [Inspect mail-routing evidence for email domains](https://apify.com/capable_cauldron/email-validator/examples/ev-inspect-email-mail-routing-evidence)

### API and integrations

The Actor ID is `capable_cauldron/email-validator`.

JavaScript:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('capable_cauldron/email-validator').call({
    emails: ['info@apify.com', 'john.doe@gmial.com'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
const sendable = items.filter((r) => r.status === 'VALID');
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("capable_cauldron/email-validator").call(
    run_input={"datasetId": "PREVIOUS_RUN_DATASET_ID", "emailField": "emails"}
)
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["email"], row["status"], row["reason"], row["didYouMean"])
```

CLI:

```bash
apify call capable_cauldron/email-validator --input '{"emails":["info@apify.com"]}'
```

To validate automatically after another Actor finishes, add a webhook or a Make or Zapier step that starts this Actor with the finished run's `defaultDatasetId`.

### FAQ

#### Is it legal to validate email addresses?

Checking the syntax and DNS records of an address is a technical lookup that sends no email and touches no mailbox, and the DNS records it reads are public. What you do with the list afterwards is regulated: under GDPR, CAN-SPAM, CASL and similar laws you need a lawful basis to email people and must honor opt-outs. Ask a lawyer if you are unsure about your use.

#### Does this verify that the mailbox exists?

No. It checks everything that can be checked without connecting to the recipient's mail server. Mailbox-level checks need an SMTP conversation, which is blocked or unreliable from cloud servers and can hurt your sending reputation. For verified addresses, use [Verified Work Email Finder](https://apify.com/capable_cauldron/verified-work-email-finder).

#### Why is an address RISKY instead of VALID?

It is a role account (info@, sales@), the domain looks like a typo of a big provider, or the domain has no MX record and only a web server. The `reason` field says which. These addresses often work, but they deserve a look before a cold campaign.

#### What does UNKNOWN mean?

The DNS resolvers did not answer for that domain after several retries on two providers. It is not a verdict about the address; run those rows again later.

#### Can I validate emails with Python?

Yes. Use the Python example above, or call the Apify API from any language. Results are plain JSON.

#### How is this different from other email validators?

It is cheaper than SMTP verifiers for the checks it does, reads another run's dataset directly, fixes typos with a suggested address, and explains every verdict with a reason and a score instead of a bare yes or no.

### Other Actors by capable_cauldron

| Actor | What it does |
|---|---|
| [App Store Reviews Scraper](https://apify.com/capable_cauldron/app-store-reviews-scraper) | Reviews and ratings for iPhone and iPad apps, grouped by app and country |
| [Company Job Postings Scraper](https://apify.com/capable_cauldron/ats-jobs-scraper) | Open roles and hiring summaries from supported company job boards |
| [Verified Work Email Finder](https://apify.com/capable_cauldron/verified-work-email-finder) | Verified professional emails from LinkedIn URLs or a name and company domain |
| [GTM Account Enrichment](https://apify.com/capable_cauldron/gtm-account-enrichment) | Public company contacts, technologies and hiring signals with an account fit score |
| [Investor Database Search](https://apify.com/capable_cauldron/investor-database-search) | Filter investors by stage, industry and geography and export available partner contacts |
| [LinkedIn Comment Scraper](https://apify.com/capable_cauldron/linkedin-comment-scraper) | LinkedIn comments and replies using your own session cookies |
| [LinkedIn Post Comments Scraper](https://apify.com/capable_cauldron/linkedin-post-comments-scraper) | Comments, replies and reactions on public LinkedIn posts without cookies |
| [LinkedIn Profile Posts & Comments Scraper](https://apify.com/capable_cauldron/linkedin-profile-posts-comments-scraper) | Posts from any LinkedIn profile with up to 50 comments and replies per post, no cookies needed |
| [LinkedIn Profile Posts Scraper](https://apify.com/capable_cauldron/linkedin-profile-posts-scraper) | Public profile posts with 56 enriched fields, including engagement and content metadata |
| [Ad Scraper: Meta, Google, LinkedIn & TikTok](https://apify.com/capable_cauldron/multi-channel-ad-intelligence) | Competitor ads from Meta, Google, LinkedIn and TikTok in one dataset |
| [TikTok Shop USA Scraper](https://apify.com/capable_cauldron/tiktok-shop-usa-scraper) | US product, shop, creator and shoppable-video data from TikTok Shop |
| [Website Contact Scraper](https://apify.com/capable_cauldron/website-contact-scraper) | Public emails, phone numbers and social profile links from company websites |
| [Website Tech Stack Detector](https://apify.com/capable_cauldron/website-tech-stack-detector) | Visible website technologies and the evidence supporting each detection |
| [LinkedIn Post Search Scraper](https://apify.com/capable_cauldron/linkedin-post-search-scraper) | Keyword searches for public LinkedIn posts with text, authors and engagement |

### Support

Found a wrong verdict or a missing provider or role name? Open an issue on the Actor's **Issues** tab with the address (or just its domain). Issues are usually answered within 24 hours. Custom versions, such as your own blocklists or a CRM sync, are available on request.

# Actor input Schema

## `emails` (type: `array`):

Email addresses to check, one per line. Commas and semicolons also separate addresses. Duplicates are checked once.

## `datasetId` (type: `string`):

Optional. Validate the emails in another run's dataset, for example the output of a lead scraper. Combined with the list above.

## `emailField` (type: `string`):

Which field of the dataset rows holds the email. The value can be one address or a list of addresses.

## `checkMx` (type: `boolean`):

Look up each domain's mail servers. Turn off for a syntax and list check only, which is faster but cannot catch dead domains.

## `maxConcurrency` (type: `integer`):

How many domains to look up at once. Each domain is looked up only once per run.

## Actor input object example

```json
{
  "emails": [
    "info@apify.com",
    "john.doe@gmial.com",
    "someone@mailinator.com"
  ],
  "emailField": "email",
  "checkMx": true,
  "maxConcurrency": 20
}
```

# Actor output Schema

## `results` (type: `string`):

One item per unique email: status, reason, score, MX records and disposable, role, free-provider and typo flags.

## `runSummary` (type: `string`):

Status and counts of valid, risky, invalid and unknown emails, plus categorised DNS errors.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "emails": [
        "info@apify.com",
        "john.doe@gmial.com",
        "someone@mailinator.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("capable_cauldron/email-validator").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "emails": [
        "info@apify.com",
        "john.doe@gmial.com",
        "someone@mailinator.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("capable_cauldron/email-validator").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "emails": [
    "info@apify.com",
    "john.doe@gmial.com",
    "someone@mailinator.com"
  ]
}' |
apify call capable_cauldron/email-validator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,capable_cauldron/email-validator"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/SrPFqxadWSZNUhkbz/builds/syK1e2zxShguif1Qv/openapi.json
