# Email Validator Bulk: MX, Disposable, Typo, No SMTP (`br_data_hub/email-validator-bulk`) Actor

Bulk validate e-mail addresses with DNS only: RFC syntax, domain and MX records, disposable domains, role accounts (admin@, info@), domain typos (gmial.com) and a score. valid, risky or invalid. No SMTP probing.

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

## Pricing

from $1.05 / 1,000 e-mail checkeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Bulk: MX, Disposable, Typo, No SMTP

Validate **thousands of e-mail addresses in one run** and get a clear verdict for each one: `valid`, `risky` or `invalid`, with a 0-100 score and the reasons. Built for cold email, list cleaning before an import, sign-up forms and CRM hygiene.

**It never contacts a mail server.** No SMTP `RCPT TO`, no "ping", no test message. Every check uses public DNS and a bundled list, so your IP is never burned, you never break a mail provider's terms, and results come back in seconds, not minutes. The trade-off is explained in [Data source and limits](#data-source-and-limits).

At **US$ 1.50 per 1,000 addresses** it costs a fraction of the leading validators in the Store (US$ 0.10 per address, i.e. US$ 100 per 1,000).

### What it checks

| Check | What you get |
|---|---|
| **Syntax (RFC 5321/5322)** | One `@`, local part up to 64 characters, no leading/trailing/double dots, allowed characters only, valid domain labels and TLD, total length up to 254. Accented domains (`bücher.de`) are converted to punycode. |
| **Domain exists** | A DNS lookup tells whether the domain is registered (`domainExists`). |
| **MX records** | Mail servers by priority (`mxHosts`). Falls back to the A/AAAA record when there is no MX, as RFC 5321 says (`acceptsMailViaARecord`). A *null MX* (RFC 7505) means the domain declares it receives no mail. |
| **Disposable domain** | Matched against a list of about 10,000 known throwaway domains (Mailinator-style), including subdomains. |
| **Role account** | `admin@`, `info@`, `support@`, `sales@`, `contato@`, `noreply@` and about 70 more, in English and Portuguese. |
| **Typo in the domain** | `gmial.com`, `gmai.com`, `gmail.con`, `hotmial.com`, `outlok.com`... with the corrected address in `suggestedEmail`. |
| **Free mailbox provider** | `freeProvider` is true for Gmail, Outlook, Yahoo, iCloud, UOL and other large public providers. |

### Input

| Field | Description |
|---|---|
| `emails` | Addresses to validate, up to 5,000 per run. `Jane <jane@acme.com>` and `mailto:jane@acme.com` work too. Duplicates (case-insensitive) are dropped. |
| `dnsMode` | `auto` (default): normal DNS, switching to DNS over HTTPS if port 53 is blocked. `udp` or `doh` to force one. |
| `dohProvider` | Cloudflare (default) or Google Public DNS, used for DNS over HTTPS. |

The default input has 6 addresses and finishes in a few seconds.

### Output

One dataset item per address (abridged):

```json
{
  "input": "Maria Souza <maria@gmail.con>",
  "email": "maria@gmail.con",
  "localPart": "maria",
  "domain": "gmail.con",
  "status": "ok",
  "verdict": "invalid",
  "score": 5,
  "syntaxValid": true,
  "domainExists": false,
  "hasMx": false,
  "mxHosts": [],
  "acceptsMailViaARecord": false,
  "disposable": false,
  "roleAccount": false,
  "freeProvider": false,
  "typoSuggestion": "gmail.com",
  "suggestedEmail": "maria@gmail.com",
  "reasons": ["domain_does_not_exist", "possible_typo"],
  "checkedAt": "2026-11-05T12:00:00+00:00"
}
```

**Verdict and score.** The score starts at 100. Subtract: no MX but an A record 30, disposable domain 70, possible typo 45, role account 25. `valid` is 80 or more, `risky` is below 80. These are always `invalid` (score at most 5): bad syntax (score 0), domain does not exist, null MX, or no mail server at all.

**Reasons** (list in `reasons`): `invalid_syntax`, `domain_does_not_exist`, `null_mx`, `no_mail_server`, `no_mx_records_a_record_only`, `disposable_domain`, `possible_typo`, `role_account`.

**`status`**: `ok` (checked, charged), `syntax_error` (malformed address, `syntaxProblem` says why, free), `error` (not an address, or DNS failed, free) and `duplicate` (free).

### How much does it cost?

Pay per event, with no platform usage added to your bill:

| Event | When | Price |
|---|---|---|
| `apify-actor-start` | Once per run, charged by Apify | US$ 0.00005 (Apify default) |
| `email` | Once per address checked against DNS (any verdict) | US$ 0.0015 |

Malformed addresses, inputs that are not addresses, duplicates and DNS failures are free.

How the `email` price (**US$ 1.50 per 1,000 addresses**) was set:

- Apify compute costs US$ 0.20 per compute unit (1 CU = 1 GB for 1 hour). The Actor runs with **256 MB**. An address needs one to three DNS queries and a few milliseconds of CPU, and addresses on the same domain share one lookup, so compute is a small fraction of a cent per 1,000 addresses.
- After Apify's 20% commission, US$ 0.0015 leaves US$ 0.0012 per address, far above the compute cost, so even a one-address run is profitable.
- Store comparison (November 2026): the leading validator charges US$ 0.10 per address and the median of the niche is about US$ 0.001. We sit at the cheap end on purpose: the product is DNS-only, so it does not need a premium, and a low price makes it the default choice for cleaning large lists.

**$0.0015 per e-mail checked** (`email` event, pay per event). Charged once per e-mail address checked against DNS (verdict, score, MX, disposable, role and typo checks). Malformed input, duplicates and DNS errors are free.

| You get | Free tier | Bronze tier (10% off) | Gold tier (30% off) |
|---|---|---|---|
| 100 e-mail checkeds | $0.15 | $0.14 | $0.10 |
| 1,000 e-mail checkeds | $1.50 | $1.35 | $1.05 |
| 10,000 e-mail checkeds | $15.00 | $13.50 | $10.50 |

Discounts follow your Apify subscription tier: Bronze 10%, Silver 20%, Gold and above 30%. No subscription to this Actor and no charge for platform usage: you pay only for results.
The Apify Free plan includes $5 of monthly credit, enough for about **3,333 e-mail checkeds** at the list price.
You can cap the cost of any run with **Maximum cost per run**; the Actor stops when it is reached.

### Data source and limits

**Source.** Public DNS (MX, A and AAAA records) read from Cloudflare 1.1.1.1 and Google Public DNS, over UDP/TCP 53 or DNS over HTTPS, plus a bundled list of disposable domains. Nothing is scraped and no login is needed.

**No SMTP verification.** This Actor does not connect to the recipient's mail server, does not run `RCPT TO` or `VRFY`, and does not send any message. That means it **cannot tell whether a specific mailbox exists**: `jane@acme.com` gets `valid` when the syntax is right and `acme.com` has a mail server, even if there is no user "jane". Catch-all domains and full or disabled mailboxes are invisible to it. Think of `valid` as "deliverable in principle, no red flags", not "confirmed mailbox". It is the safe first filter: it removes malformed, dead-domain, disposable and mistyped addresses, which are most of the bounces in a typical list. Pair it with a sending tool that handles bounces for the rest.

**Disposable list.** [disposable-email-domains](https://github.com/disposable-email-domains/disposable-email-domains) by the `disposable-email-domains` contributors, `disposable_email_blocklist.conf` (commit a72c0ce, 4 November 2026), released under **CC0 1.0 Universal** (public domain dedication, no attribution required; credited here anyway). The copy in this Actor lives in `src/data/disposable_domains.txt`, with its source in `src/data/SOURCE.txt`. New throwaway services appear daily, so the list is a snapshot.

**Other limits.** Up to 5,000 addresses per run. Quoted local parts (`"john doe"@acme.com`), comments, IP-literal domains and non-ASCII local parts are reported as invalid syntax, because most mail servers refuse them. Role-account and typo lists are built in and cover common cases, not every language. Results are a snapshot at `checkedAt`; DNS caching can delay changes by minutes to hours. A DNS timeout or SERVFAIL returns `status: "error"` and is not charged, so you can re-run those addresses.

Privacy: addresses are processed in memory and written only to your own run dataset. Only the domain part is sent to DNS resolvers; the part before the `@` never leaves the Actor.

Not affiliated: this Actor is an independent tool, not affiliated with, endorsed by or sponsored by Google, Microsoft, Cloudflare, Yahoo or any mailbox or DNS provider named on this page; names are used only to describe what is checked.

### Use it via API

Run it from any language and get the results as JSON. Replace `<YOUR_API_TOKEN>` with your [Apify API token](https://console.apify.com/settings/integrations).

```bash
curl -X POST "https://api.apify.com/v2/acts/br_data_hub~email-validator-bulk/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"emails": ["jane.doe@gmail.com", "admin@apify.com", "temp123@mailinator.com", "maria@gmail.con", "nobody@no-such-domain-xyz-12345.com", "john@@example"]}'
```

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("br_data_hub/email-validator-bulk").call(run_input={'emails': ['jane.doe@gmail.com',
                                                 'admin@apify.com',
                                                 'temp123@mailinator.com',
                                                 'maria@gmail.con',
                                                 'nobody@no-such-domain-xyz-12345.com',
                                                 'john@@example']})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

You can also schedule runs, send results to webhooks, or connect the Actor to Make, Zapier, n8n, Google Sheets and other [integrations](https://docs.apify.com/platform/integrations).

### Use it with AI agents (MCP)

This Actor is ready for AI agents: typed input and output schemas, pay-per-event pricing, limited permissions and short runs.

- **Apify MCP server:** add `https://mcp.apify.com/?tools=br_data_hub/email-validator-bulk` to Claude, ChatGPT, Cursor, VS Code or any MCP client, and the agent can call this Actor as a tool.
- **Agent frameworks:** call it from LangChain, LlamaIndex, CrewAI or the OpenAI Agents SDK through the Apify integrations, or with the API call above.
- Results come as structured JSON with stable field names, documented in the **Output** tab.

### FAQ

#### Where does the data come from?

**Source.** Public DNS (MX, A and AAAA records) read from Cloudflare 1.1.1.1 and Google Public DNS, over UDP/TCP 53 or DNS over HTTPS, plus a bundled list of disposable domains. Nothing is scraped and no login is needed.

#### How much does it cost?

$0.0015 per e-mail checked. Discounts follow your Apify subscription tier: Bronze 10%, Silver 20%, Gold and above 30%. See **How much does it cost?** above for examples.

#### Do I pay for errors or empty results?

No. Charged once per e-mail address checked against DNS (verdict, score, MX, disposable, role and typo checks). Malformed input, duplicates and DNS errors are free.

#### Can I run it on a schedule or connect it to other tools?

Yes. Use Apify schedules to run it daily or weekly, webhooks to get notified, and integrations such as Make, Zapier, n8n and Google Sheets. Everything also works through the API.

#### Can AI agents use it?

Yes. It works as a tool in the Apify MCP server and in agent frameworks, and AI agents can pay per event. See **Use it with AI agents (MCP)**.

#### Is it legal to use this data?

The Actor reads only public sources. You are responsible for how you use the data and for complying with the source's terms and with privacy laws such as GDPR.

#### I found a bug or need a feature. What should I do?

Open an issue in the **Issues** tab. We answer within 14 days, usually much sooner.

### More Actors from BR Data Hub

| Actor | What it does |
|---|---|
| [QR Code & Barcode Generator and Reader (EAN, Code128)](https://apify.com/br_data_hub/qr-barcode-toolkit) | Generate QR codes and barcodes (EAN-13, EAN-8, UPC-A, Code 128, Code 39, ITF, Data Matrix) as PNG or SVG with  |
| [Website Tech Stack Detector (CMS, Analytics, CDN)](https://apify.com/br_data_hub/website-tech-stack-detector) | Find out what a website is built with: CMS, JavaScript frameworks, e-commerce platform, analytics, tag manager |
| [Sitemap URL Extractor: Nested, Gzip, robots.txt, Filters](https://apify.com/br_data_hub/sitemap-url-extractor) | Extract every URL from a website's sitemaps: robots.txt discovery, nested indexes, .xml.gz, lastmod, priority, |
| [Brazil CNPJ Lookup API (Consulta CNPJ)](https://apify.com/br_data_hub/br-cnpj-lookup) | Look up Brazilian companies by CNPJ: registration status, partners (masked CPF), activities, tax regime and sc |

See all our Actors at [apify.com/br_data_hub](https://apify.com/br_data_hub).

### Usar em português

Valida **listas de e-mails em lote, só com DNS**: sintaxe RFC, domínio existente, registros MX, domínio descartável (mailinator e similares), endereço de função (`admin@`, `contato@`, `noreply@`), erro de digitação no domínio (`gmial.com` vira `gmail.com`, com o endereço corrigido em `suggestedEmail`) e uma pontuação de 0 a 100 com veredito `valid`, `risky` ou `invalid`.

**Não há verificação SMTP**: o Actor nunca conecta ao servidor de e-mail do destinatário, então não sabe se a caixa `maria@empresa.com.br` existe, só se o domínio recebe e-mail e se o endereço tem sinais de problema. Por isso é seguro para o seu IP e para os termos dos provedores, e roda em segundos.

Preço: **US$ 0,0015 por e-mail validado** (US$ 1,50 por mil). Endereços malformados, duplicados e falhas de DNS não são cobrados. Você pode limitar o gasto com "Maximum cost per run": o Actor para quando o teto é atingido. A lista de domínios descartáveis é de domínio público (CC0).

**Quanto custa:** $0.0015 por resultado (`email`); 1.000 resultados saem por $1.50. Desconto pelo nível da assinatura Apify: Bronze 10%, Silver 20%, Gold ou acima 30%. Erros e consultas sem resultado não são cobrados. Use também pela API ou por agentes de IA no servidor MCP da Apify (`https://mcp.apify.com/?tools=br_data_hub/email-validator-bulk`).

# Actor input Schema

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

Enter e-mail addresses to validate, one per line, up to 5,000 per run, e.g. jane@acme.com. 'Jane <jane@acme.com>' and 'mailto:jane@acme.com' are read as jane@acme.com. Duplicates are dropped and free.

## `dnsMode` (type: `string`):

Keep Auto to use normal DNS (port 53) and switch to DNS over HTTPS if port 53 is blocked. Pick Normal DNS or DNS over HTTPS to force one.

## `dohProvider` (type: `string`):

Pick the public resolver used for DNS over HTTPS.

## Actor input object example

```json
{
  "emails": [
    "jane.doe@gmail.com",
    "admin@apify.com",
    "temp123@mailinator.com",
    "maria@gmail.con",
    "nobody@no-such-domain-xyz-12345.com",
    "john@@example"
  ],
  "dnsMode": "auto",
  "dohProvider": "cloudflare"
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset with all results

# 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": [
        "jane.doe@gmail.com",
        "admin@apify.com",
        "temp123@mailinator.com",
        "maria@gmail.con",
        "nobody@no-such-domain-xyz-12345.com",
        "john@@example"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("br_data_hub/email-validator-bulk").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": [
        "jane.doe@gmail.com",
        "admin@apify.com",
        "temp123@mailinator.com",
        "maria@gmail.con",
        "nobody@no-such-domain-xyz-12345.com",
        "john@@example",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("br_data_hub/email-validator-bulk").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": [
    "jane.doe@gmail.com",
    "admin@apify.com",
    "temp123@mailinator.com",
    "maria@gmail.con",
    "nobody@no-such-domain-xyz-12345.com",
    "john@@example"
  ]
}' |
apify call br_data_hub/email-validator-bulk --silent --output-dataset

```

## MCP server setup

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

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/aEWdhZYncAn9WzahK/builds/U6GHEvJtT2rWa48Aw/openapi.json