# Email List Cleaner & Validator: Syntax, MX, Disposable (`adhistory/email-list-cleaner-validator-syntax-mx-disposable`) Actor

Clean email lists for $0.20 per 1,000 on every plan. Catches bad syntax, domains with no mail server, disposable inboxes, role addresses and typos (gmial.com → gmail.com), with a 0-100 score. Does not check individual mailboxes. Never sends email.

- **URL**: https://apify.com/adhistory/email-list-cleaner-validator-syntax-mx-disposable.md
- **Developed by:** [Brandon Ob](https://apify.com/adhistory) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.20 / 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.

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 List Cleaner & Validator: Syntax, MX, Disposable

This email validator and list cleaner checks a list of email addresses and tells you, for each one, whether it is **valid**, **risky**, **undeliverable** or **invalid**, with the reason, a 0–100 score and every individual check. Use it to remove addresses that are sure to bounce or waste a send before a campaign or a CRM import. It costs **$0.20 per 1,000 emails on every Apify plan, including the free plan**. No email is ever sent.

**What it does not do:** it does not ask the recipient's mail server whether a specific mailbox exists (an "SMTP check"). `valid` means the address is well formed and its domain accepts email, not that the person's inbox exists. Use it as a fast, cheap first pass that removes the obvious junk.

### What does Email List Cleaner & Validator do?

- **Syntax check:** one @, allowed characters, a valid domain and top-level domain.
- **Domain and mail server (MX) check:** the domain exists and has a mail server (MX record, or an A record as the fallback). Domains that publish "null MX" (accept no mail) are caught.
- **Disposable inbox detection:** the domain belongs to a throwaway or temporary inbox provider (a list of 10,000+ domains).
- **Role account detection:** addresses like info@, sales@, support@ and noreply@ that reach a team, not a person.
- **Free provider detection:** Gmail, Outlook, Yahoo, iCloud, GMX and other free mailboxes, to separate B2B from B2C contacts.
- **Typo suggestions:** common misspellings like `gmial.com` or `gmail.con` get a "did you mean" fix and are marked risky.
- **Deduplication:** repeated addresses (case and spaces ignored) are removed before checking, and you are not charged for them.
- Reads emails pasted in the input or from a **CSV link**, such as a Google Sheet published as CSV.

### Use cases

- **Cold email and outreach teams:** remove dead domains, typos and throwaway addresses from a lead list before sending, to protect your sender reputation.
- **Marketers:** clean a newsletter or event sign-up list before importing it into an email tool.
- **Sales operations:** flag role accounts and free-mail contacts in a B2B lead list before it reaches reps.
- **Product teams:** find disposable sign-ups and mistyped addresses in your user base.
- **Data teams:** add a cheap validation step to a scraping or enrichment pipeline.

### How to use it

1. Open the Actor in Apify Console and paste your emails, one per line, or put a CSV link in **Or a CSV file URL** (a column named `email`, `e-mail` or `email address` is used automatically).
2. Click **Start**.
3. Open the **Verified emails** view and filter by `result`, or download the dataset.
4. To clean new sign-ups regularly, save the input as a task and schedule it, or call the Actor from the API.

### Input

| Field | What it does |
|---|---|
| `emails` | One email per line. Duplicates are removed and charged once. |
| `csvUrl` | Optional link to a CSV file with an email column. |
| `maxConcurrency` | How many domains are looked up at the same time (default 20). |

Example input:

```json
{
  "emails": ["support@github.com", "jane@gmial.com", "john@@example.com", "x@mailinator.com"],
  "maxConcurrency": 20
}
```

### Output

One row per unique email. Example row:

```json
{
  "email": "support@github.com",
  "result": "valid",
  "reason": "Well formed and the domain accepts email (mailbox not checked) (role account, e.g. info@ or sales@)",
  "score": 60,
  "isValidSyntax": true,
  "domain": "github.com",
  "hasMx": true,
  "mxHost": "github-com.mail.protection.outlook.com",
  "smtpCheck": "skipped",
  "smtpCode": null,
  "isCatchAll": null,
  "isDisposable": false,
  "isRoleAccount": true,
  "isFreeProvider": false,
  "suggestion": null
}
```

What each result means:

| Result | Meaning | Keep? |
|---|---|---|
| `valid` | Well formed, and the domain accepts email. The individual mailbox is not checked. | Yes |
| `risky` | Disposable (throwaway) inbox, or a likely typo in the domain (see `suggestion`). | Usually no |
| `unknown` | The domain's DNS could not be read (timeout). | Run again |
| `undeliverable` | The domain has no mail server or says it accepts no email. | No |
| `invalid` | The address is not well formed. | No |

Examples from a test run: `John@@example` → invalid; `info@example.com` → undeliverable (null MX); `x@mailinator.com` → risky (disposable); `jane@gmial.com` → risky, "did you mean jane@gmail.com?". The key-value store holds a `SUMMARY` record with counts per result. The dataset can be downloaded as JSON, CSV, Excel, XML or HTML, or read through the API.

### Pricing

Pay per event: **$0.20 per 1,000 emails**, the same price on every plan, free plan included. You pay per unique email checked (duplicates are removed first). You can set a maximum cost per run and the Actor stops cleanly when it is reached.

Example: a 25,000-address list costs about **$5.00**.

### Integrations and API

Run it and get the results back in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/adhistory~email-list-cleaner-validator-syntax-mx-disposable/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"emails": ["jane@gmial.com", "support@github.com"]}'
```

Python, with the `apify-client` package:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("adhistory/email-list-cleaner-validator-syntax-mx-disposable").call(run_input={
    "csvUrl": "https://docs.google.com/spreadsheets/d/<id>/export?format=csv",
})
keep = [r["email"] for r in client.dataset(run["defaultDatasetId"]).iterate_items() if r["result"] == "valid"]
```

Like every Apify Actor, it also works with Make, Zapier and n8n, with webhooks and schedules, and as a tool for AI agents through the Apify MCP server.

### FAQ

**Does it send emails?** No. It only reads public DNS records and its built-in lists. Nothing reaches anyone's inbox.

**Will `valid` addresses never bounce?** Not guaranteed. A `valid` address has a correct format and a domain that accepts email, but the specific mailbox may not exist. This tool removes the addresses that are certain to fail; it does not confirm individual inboxes.

**Why no mailbox (SMTP) check?** Mailbox checks need an outbound connection on port 25, which the Apify cloud does not allow. The Actor is priced for what it can do: syntax, domain, disposable, role and typo checks.

**How fast is it?** Thousands of emails in seconds to a few minutes, depending on how many different domains are in the list.

**Am I charged for duplicates?** No. Duplicates are removed (ignoring case and spaces) before checking.

**What CSV format does it read?** Any CSV reachable by link. The column named `email`, `e-mail` or `email address` is used; otherwise the first column that holds email addresses.

**Is this a bulk email validator or verifier?** It is a bulk email validator: paste thousands of addresses or a CSV link and get one row per address with a verdict. It does not do mailbox (SMTP) verification, so use it as the cheap first pass before a full email verifier.

**Can I validate emails for free?** Every Apify account includes free monthly credit, and this Actor costs $0.20 per 1,000 emails on every plan, so a few thousand addresses fit inside the free credit.

**How do I clean a Mailchimp, HubSpot or CSV export?** Export the list as CSV, host it at a link or paste the addresses, run the Actor, then filter the dataset on `status` and re-import only the `valid` rows.

### Related tools

- [Greenhouse, Lever & Ashby Jobs Scraper](https://apify.com/adhistory/ats-jobs-export): find companies that are hiring, for outreach lists.
- [Google Ads Transparency Center Scraper](https://apify.com/adhistory/google-ads-history-actor): check which prospects already spend on Google Ads.
- [Broken Link Checker](https://apify.com/adhistory/broken-link-checker): find dead links on a prospect's or your own website.
- [Google Sheets Export & Import](https://apify.com/adhistory/google-sheets-export-actor): send the cleaned list back into a Google Sheet.

Found a bug or need a feature? Open an issue on the Issues tab — I usually reply within a day.

# Actor input Schema

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

One email per line. Duplicates are removed (case-insensitive) and you are charged once per unique email.

## `csvUrl` (type: `string`):

Link to a CSV file (e.g. a Google Sheets 'publish to web' CSV link). The column named email, e-mail or email address is used; otherwise the first column that holds email addresses.

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

How many domains are looked up in DNS at the same time. Raise it for very large lists.

## Actor input object example

```json
{
  "emails": [
    "support@github.com",
    "jane@gmial.com",
    "john@@example.com"
  ],
  "maxConcurrency": 20
}
```

# Actor output Schema

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

No description

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

No description

# 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": [
        "support@github.com",
        "jane@gmial.com",
        "john@@example.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("adhistory/email-list-cleaner-validator-syntax-mx-disposable").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": [
        "support@github.com",
        "jane@gmial.com",
        "john@@example.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("adhistory/email-list-cleaner-validator-syntax-mx-disposable").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": [
    "support@github.com",
    "jane@gmial.com",
    "john@@example.com"
  ]
}' |
apify call adhistory/email-list-cleaner-validator-syntax-mx-disposable --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,adhistory/email-list-cleaner-validator-syntax-mx-disposable"
        }
    }
}
```

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/cvoEW3ZIfTRSFCVR1/builds/QFEzlZNqusHVnC4OF/openapi.json