# Bulk Email Verifier & Validator: MX, Disposable | $0.40/1k (`mauve_bunch/email-validator-dns`) Actor

Verify emails with DNS only, no SMTP probing. Input: list of emails. Output per address: status (valid/risky/invalid), score 0-100, reasons, MX hosts, disposable, role-account and free-provider flags, typo suggestion. $0.40 per 1,000 emails. No API key.

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

## Pricing

from $0.32 / 1,000 email 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

## Bulk Email Verifier & Validator: Syntax, MX, Disposable, Role & Typo Checks

### Agent quick reference

- **Purpose:** Verify emails with DNS only, no SMTP probing.
- **Price:** $0.40 per 1,000 emails (pay per event; you pay only for items returned). Set `maxTotalChargeUsd` on the run to cap spend.
- **Call:** `POST https://api.apify.com/v2/acts/mauve_bunch~email-validator-dns/run-sync-get-dataset-items?token=<APIFY_TOKEN>` with the JSON input below, or via the Apify MCP server (`call-actor`, Actor `mauve_bunch/email-validator-dns`).
- **Minimal input:** `{"emails": ["jane.doe@gmail.com", "john@gmial.com", "info@stripe.com", "someone@mailinator.com"], "checkDns": true, "concurrency": 50, "dnsTimeoutSecs": 5, "maxEmails": 100000, "dnsResolver": "system"}`
- **Output:** one JSON object per item in the default dataset; a `SUMMARY` record in the key-value store has run counts.

> **Try it in one click:** press Start with the four prefilled addresses and see valid, risky and typo results in about 3 seconds. **$0.40 per 1,000 emails**, DNS only, no SMTP probing.

**Clean an email list in minutes without ever sending a probe to a mail server.** This Actor checks every address for valid syntax, whether the domain exists and accepts mail (MX/DNS), disposable domains, role accounts such as `info@` or `sales@`, free-mail providers, and likely typos like `gmial.com`. Each address gets a clear status (`valid`, `risky`, `invalid`, `unknown`), a 0–100 score and a list of reasons you can filter on.

It is fast and cheap because it uses DNS only. That also makes it safe for your sender reputation and your IP: no connections to recipient mail servers, no greylisting, no blocklisting.

> **Honest scope:** DNS-based validation tells you whether an address *can* receive mail. It cannot confirm that a specific mailbox exists or detect catch-all domains. If you need mailbox-level verification, use an SMTP-based verifier after this cheap first pass.

### What it checks

| Check | What it catches |
|---|---|
| **Syntax** | Missing `@`, illegal characters, double dots, over-long local part or domain, bad TLD, internationalized domains (converted to punycode) |
| **Domain exists** | Typos and dead domains (`NXDOMAIN`) |
| **MX / mail routing** | Domains with no mail server, "null MX" domains that explicitly refuse mail, and domains that fall back to an A record |
| **Disposable domains** | Temporary inbox services such as Mailinator-style domains (maintained community list, subdomains included) |
| **Role accounts** | `admin@`, `info@`, `support@`, `sales@`, `noreply@` and similar shared mailboxes |
| **Free providers** | Gmail, Outlook, Yahoo, iCloud and other consumer domains, so you can separate business from personal addresses |
| **Typo suggestions** | `john@gmial.com` becomes `john@gmail.com`; `.con` becomes `.com` |
| **Gmail username rules** | Gmail usernames must have 6–30 letters, numbers or dots, so `abc@gmail.com` is flagged |
| **Mail provider hint** | Detects Google Workspace, Microsoft 365, Yahoo, iCloud, Proton, Zoho and others from MX hosts |

Duplicates (case-insensitive) are removed automatically and billed once.

### How to use it

1. Paste or upload your addresses into **Emails** (one per line, or send a JSON array via API).
2. Click **Start**.
3. Download the dataset as CSV/Excel/JSON. Filter on `status = valid` for a clean list, or inspect `reasons` to see why an address was flagged.

#### Input example

```json
{
  "emails": ["jane.doe@gmail.com", "john@gmial.com", "info@stripe.com", "someone@mailinator.com"],
  "checkDns": true,
  "concurrency": 50
}
```

#### Output example

```json
{
  "email": "john@gmial.com",
  "normalizedEmail": "john@gmial.com",
  "status": "risky",
  "score": 20,
  "reasons": ["dns_lookup_failed:ESERVFAIL", "possible_typo"],
  "syntaxValid": true,
  "domain": "gmial.com",
  "domainExists": null,
  "hasMx": null,
  "mxHosts": [],
  "mxProvider": null,
  "isDisposable": false,
  "isRoleAccount": false,
  "isFreeProvider": false,
  "suggestion": "john@gmail.com",
  "smtpChecked": false,
  "checkedAt": "2026-11-19T01:09:00.954Z"
}
```

#### Status meanings

- **valid**: syntax is fine, the domain exists and has mail routing, and nothing suspicious was found.
- **risky**: deliverable in principle but worth reviewing: disposable domain, role account, likely typo, or only an A record instead of MX.
- **invalid**: will bounce: bad syntax, non-existent domain, no mail server, or a null-MX domain.
- **unknown**: DNS did not answer in time. Re-run those addresses.

### Pricing

Pay per event, no subscription:

| Event | Price |
|---|---|
| Actor start | $0.0001 |
| Each unique email checked | $0.0004 (about **$0.40 per 1,000 emails**, with discounts on paid Apify plans) |

Validating 50,000 addresses costs roughly $20. Set a maximum charge per run in Apify to stay in control.

### Use it from code or automation

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("YOUR_USERNAME/email-validator-dns").call(run_input={"emails": ["a@example.com", "b@gmial.com"]})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["email"], row["status"], row["reasons"])
```

Works with Zapier, Make, n8n and Google Sheets integrations, and as an MCP tool for AI agents that need to sanity-check addresses before writing to a CRM.

### Privacy and compliance

Only the addresses you submit are processed, and only DNS queries about their *domains* are made; no data is sent to the recipient's mail server. The Actor does not store your list outside your own Apify run storage. The disposable-domain list comes from the community project `disposable-email-domains` (CC0).

### Limits

- No mailbox-level or catch-all detection (by design, to avoid SMTP probing).
- DNS answers can vary between resolvers; a temporary DNS failure returns `unknown`, not `invalid`.
- Role-account and free-provider lists cover the most common names and providers, not every possible one.
- Maximum 100,000 emails per run by default (raise *Max emails* if needed).

### FAQ

**Why not check the mailbox over SMTP?** Many providers block or tarpit probes, probing can hurt your IP reputation, and results are often unreliable (catch-all servers accept everything). DNS validation removes the large share of obviously bad addresses at a fraction of the price.

**Does it work for international addresses?** Yes, internationalized domain names are converted to punycode before lookup.

**Can I keep the original order?** Rows are produced in input order after duplicate removal.

**How do I report a wrong result?** Open an issue with the address and what you expected.

### Feedback

Found this useful? A quick review on the Store helps others find it. Issues or feature requests? Open an issue and I'll reply fast.

# Actor input Schema

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

Email addresses to validate (duplicates are removed and billed once).

## `checkDns` (type: `boolean`):

Turn off for a fast syntax, disposable, role and typo check only.

## `concurrency` (type: `integer`):

Parallel DNS lookups.

## `dnsTimeoutSecs` (type: `integer`):

Per lookup. Slow domains that time out are marked unknown.

## `maxEmails` (type: `integer`):

Safety cap on how many unique addresses are processed in one run.

## `dnsResolver` (type: `string`):

System resolver (default, fastest) or Cloudflare DNS-over-HTTPS (use if the system resolver is unreliable).

## Actor input object example

```json
{
  "emails": [
    "jane.doe@gmail.com",
    "john@gmial.com",
    "info@stripe.com",
    "someone@mailinator.com"
  ],
  "checkDns": true,
  "concurrency": 50,
  "dnsTimeoutSecs": 5,
  "maxEmails": 100000,
  "dnsResolver": "system"
}
```

# Actor output Schema

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

Dataset items: the validated email addresses returned by the run (JSON, CSV, Excel, XML via the dataset API).

## `summary` (type: `string`):

Key-value store record SUMMARY with counts and per-input status for this run.

# 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",
        "john@gmial.com",
        "info@stripe.com",
        "someone@mailinator.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("mauve_bunch/email-validator-dns").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",
        "john@gmial.com",
        "info@stripe.com",
        "someone@mailinator.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("mauve_bunch/email-validator-dns").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",
    "john@gmial.com",
    "info@stripe.com",
    "someone@mailinator.com"
  ]
}' |
apify call mauve_bunch/email-validator-dns --silent --output-dataset

```

## MCP server setup

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

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/iX3zVEgvdmm81qCDP/builds/GMothW6se4qj6w169/openapi.json
