# Email Validator & MX Record Checker – Bulk, Disposable, Role (`forevertools/email-syntax-mx-checker`) Actor

Email validation, verification & email checker for list cleaning: RFC syntax check, MX record/DNS deliverability, disposable email detection, role-address (info@, admin@) and free-provider flags, typo suggestions (gmial.com → gmail.com). No SMTP probing, no mailbox pinging.

- **URL**: https://apify.com/forevertools/email-syntax-mx-checker.md
- **Developed by:** [Forever Tools](https://apify.com/forevertools) (community)
- **Categories:** Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.00 / 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

## Bulk Email Validator & MX Record Checker: Syntax, Disposable, Role

Clean a list of email addresses cheaply and safely. You paste a list of emails and get one row per address with syntax validity, whether the domain can receive mail (MX lookup), disposable-provider detection, role-address and free-provider flags, and typo suggestions such as `gmial.com` to `gmail.com`.

### Bulk email verification without SMTP

This actor checks addresses at the DNS level. It does **not** connect to mail servers or ping mailboxes, so it cannot confirm that a specific mailbox exists. That is a deliberate trade-off: it is fast, cheap and has no risk of getting your IP blocklisted by mail servers. For each address you get:

- **Syntax** validity (local part and domain rules)
- **MX / DNS** check of the domain, with fallback to implicit MX (A/AAAA records) and detection of null MX ("domain accepts no mail")
- **Disposable** provider detection (Mailinator, Guerrilla Mail, YOPmail and others from a built-in list)
- **Role address** flag (info@, admin@, support@, sales@, noreply@ and similar)
- **Free provider** flag (Gmail, Outlook, Yahoo and similar)
- **Typo suggestion** for common misspelled domains (`gmial.com`, `hotmial.com`, `outlok.com`)

#### Input example

```json
{
  "emails": ["jane@gmial.com", "info@example.org", "x@mailinator.com", "not-an-email"],
  "maxConcurrency": 20
}
```

`emails` is required; duplicates are removed. `maxConcurrency` (1 to 50, default 20) is how many domains are resolved in parallel, and lookups are cached per domain.

### How to check if an email address is valid: output

One realistic row:

```json
{
  "email": "x@mailinator.com",
  "valid": true,
  "status": "risky",
  "domain": "mailinator.com",
  "hasMx": true,
  "mxHosts": ["mail.mailinator.com"],
  "isDisposable": true,
  "isRole": false,
  "isFree": false,
  "suggestion": null,
  "reason": "disposable provider"
}
```

`status` is one of `invalid`, `risky`, `deliverable-domain` or `unknown`. `deliverable-domain` means the syntax and domain are OK. `risky` means it passes DNS but is a disposable or role address, or its domain is a likely typo of a common provider (e.g. `gmial.com`; see `suggestion`). `unknown` means a DNS error prevented a verdict. `mxHosts` lists up to five mail servers.

### How it works

1. Each address is trimmed and checked for valid syntax; malformed input returns `status: "invalid"` with `reason: "bad format"`. Pasted and scraped forms such as `Jane Doe <jane@example.com>`, `mailto:jane@example.com?subject=Hi`, `(jane@example.com)` or `jane@example.com.` at the end of a sentence are accepted (the `email` field keeps your original input), and internationalized domains such as `münchen.de` are checked in their punycode form.
2. The domain is compared against the built-in disposable, free-provider and typo lists, and the local part against the role-address list (a `+tag` suffix is ignored, so `info+news@` counts as a role address).
3. The domain's MX records are resolved once and cached. If none exist, the actor falls back to A/AAAA records (implicit MX). A null MX record or a domain with no mail server gives `valid: false`.
4. Results are pushed to the dataset one row per address, and you can export them as JSON, CSV or Excel from the Apify console or API.

### Use cases

- **Clean a signup or newsletter export** before importing it into your email service, to reduce hard bounces.
- **Filter disposable and role addresses** out of lead lists.
- **Catch typos in form submissions** and offer the corrected address from `suggestion`.
- **Pre-screen a list cheaply** before deciding whether a full SMTP verifier is worth paying for.

### Pricing: how much does email validation cost?

**$0.001 per email checked**, flat, no subscription. Addresses that end as `unknown` (a DNS error prevented a verdict) are **not charged**.

- 1,000 emails = $1.00
- 10,000 emails = $10.00
- 100,000 emails = $100.00

Apify platform compute usage is separate from the per-email price.

### Limitations

- **No mailbox-level verification.** No SMTP probing, so a `deliverable-domain` address may still bounce if the mailbox does not exist.
- **Catch-all domains are not detected**, since that requires talking to the mail server.
- **Lists are finite.** Disposable, free-provider, role and typo detection use built-in lists, so a new or obscure disposable domain may not be flagged, and only common typos get a suggestion.
- **Temporary DNS failures** produce `unknown` rows; re-run those later.

### FAQ

**How do I validate an email list without sending emails?** Paste the list into `emails`. The actor checks syntax and DNS records only, and never contacts the recipient.

**Can it tell me whether a mailbox really exists?** No. It confirms the address can plausibly receive mail at domain level, not that the mailbox exists.

**How do I detect disposable or temporary email addresses?** Check `isDisposable`; those rows also get `status: "risky"`.

**How do I find role addresses like info@ or support@?** Check `isRole`.

**How fast is bulk email checking?** Domains are resolved concurrently and cached, so a list with many addresses on the same domain needs only one lookup per domain.

**Is my list stored anywhere?** Addresses are processed in the run and stored only in your run's dataset.

Built by Forever Tools (AI-assisted development).

### Related tools

Other actors by the same developer (same flat pay-per-result pricing, no subscription):

- [App Store Reviews Scraper – Apple iOS, Multi-Country](https://apify.com/forevertools/apple-app-store-reviews)
- [Article Scraper & Text Extractor – Clean Markdown for LLM/RAG](https://apify.com/forevertools/article-extractor)
- [Job Postings & Career Page Scraper – Workday, Greenhouse, Lever](https://apify.com/forevertools/ats-company-jobs)
- [Bluesky Posts Scraper – Profiles & Threads, No Login](https://apify.com/forevertools/bluesky-posts)
- [Company Enrichment from Domain (Logo, Socials, Tech)](https://apify.com/forevertools/company-website-enrichment)
- [DNS Lookup & WHOIS Domain Checker — SPF/DMARC, SSL Expiry](https://apify.com/forevertools/domain-whois-dns-ssl)
- [Bulk PageSpeed Insights, Lighthouse & Core Web Vitals](https://apify.com/forevertools/pagespeed-core-web-vitals)
- [PDF Extractor & Parser – Bulk PDF to Text with Metadata](https://apify.com/forevertools/pdf-to-text-extractor)
- [SEO Audit Crawler & Broken Link Checker – Website Health](https://apify.com/forevertools/website-seo-audit)
- [Sitemap Extractor & Bulk URL Status Checker](https://apify.com/forevertools/sitemap-url-status-checker)
- [Steam Reviews Scraper – Game Reviews & App Details](https://apify.com/forevertools/steam-reviews)
- [Website Technology Detector – Tech Stack, CMS & Analytics](https://apify.com/forevertools/website-tech-stack-detector)
- [Website Screenshot API – Bulk Full Page PNG, JPEG & PDF](https://apify.com/forevertools/website-screenshot)

### Integrations

Run it from the Apify API, a schedule, or no-code tools: the Apify apps for **Zapier**, **Make** and **n8n** can start any public actor ("Run Actor") and read its dataset. AI agents can call it through the **Apify MCP server**.

### Ready-made examples

One-click tasks you can run or copy and adapt:

- [Clean an email list: syntax, typos and MX records](https://apify.com/forevertools/email-syntax-mx-checker/examples/email-list-cleaning-check)
- [Detect disposable & role-based email addresses in a list](https://apify.com/forevertools/email-syntax-mx-checker/examples/disposable-email-detection)

# Actor input Schema

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

Email addresses to check (one per item). Duplicates are removed. One row per email with `status`: invalid (bad syntax or no mail server), risky (disposable, role address or likely domain typo), deliverable-domain (syntax and MX OK), or unknown (DNS error; not charged). No SMTP connection is made, so mailbox existence is not tested. Common domain typos get a `suggestion`.

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

Domains resolved in parallel.

## Actor input object example

```json
{
  "emails": [
    "hello@apify.com",
    "someone@gmial.com"
  ],
  "maxConcurrency": 20
}
```

# Actor output Schema

## `results` (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": [
        "hello@apify.com",
        "someone@gmial.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("forevertools/email-syntax-mx-checker").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": [
        "hello@apify.com",
        "someone@gmial.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("forevertools/email-syntax-mx-checker").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": [
    "hello@apify.com",
    "someone@gmial.com"
  ]
}' |
apify call forevertools/email-syntax-mx-checker --silent --output-dataset

```

## MCP server setup

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

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/WwFq7Iz4iCbvTRwVP/builds/2KNwhqQuTeekhjSwY/openapi.json