# Email MX & Deliverability Verifier (`fetch_cat/email-mx-deliverability-verifier`) Actor

Validate email lists with syntax, MX, disposable-domain, role-account, and deliverability risk checks before outreach.

- **URL**: https://apify.com/fetch\_cat/email-mx-deliverability-verifier.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Developer tools, Lead generation, Automation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Email MX & Deliverability Verifier

Validate email lists before outreach with syntax checks, public domain mail-server checks, disposable-domain flags, role-account detection, and a simple deliverability risk score.

Use this Apify Actor when you have a lead list, recruiting list, newsletter export, CRM upload, or enrichment dataset and want to quickly separate safer emails from risky ones before sending campaigns.

### What does Email MX & Deliverability Verifier do?

Email MX & Deliverability Verifier checks each email address you provide and returns a structured dataset with the most useful deliverability signals.

It can:

- ✅ Normalize and deduplicate email addresses
- ✅ Detect invalid email syntax
- ✅ Parse the mailbox domain
- ✅ Check whether the domain has MX mail records
- ✅ Check an A-record fallback when no MX record is present
- ✅ Flag common disposable or temporary email domains
- ✅ Flag role accounts such as `info@`, `support@`, and `admin@`
- ✅ Assign a practical risk level: `low`, `medium`, `high`, or `unknown`
- ✅ Add a clear verification outcome: `READY`, `RISKY`, `INVALID`, or `UNKNOWN`
- ✅ Return machine-readable reason codes for filtering and automation
- ✅ Save a run summary with completed and pending work when a bounded run ends early

### Who is it for?

This actor is useful for teams that work with email lists regularly.

- 📈 **Sales teams** can clean prospect lists before sending sequences.
- 🧲 **Lead generation agencies** can add validation signals to scraped or purchased leads.
- 👥 **Recruiters** can check candidate contact lists before outreach.
- 🛒 **E-commerce operators** can audit customer or partner exports.
- 🧪 **Data enrichment teams** can add email-quality columns to downstream workflows.
- 🧰 **No-code operators** can validate lists from Apify datasets, CSV exports, or pasted text.

### Why use it?

Bad email lists waste time, damage sender reputation, and create noisy CRM data.

This actor gives you fast, explainable checks that are easy to export and combine with other data. It does not claim that an inbox exists, but it helps identify addresses that are clearly malformed, risky, disposable, role-based, or attached to domains without visible mail routing.

### What checks are included?

The first version focuses on safe public signals.

- Syntax validation
- Domain extraction
- MX record check
- Optional A-record fallback check
- Disposable-domain check
- Role-account check
- Risk-level assignment
- Reason-code output

### What is not included?

This actor does not log into email providers and does not require private credentials.

It also does not perform mandatory SMTP mailbox probing in version 1. SMTP probing can be slow, blocked by mail servers, inaccurate due to catch-all domains, and potentially intrusive at scale. The actor instead focuses on stable public signals that are suitable for batch workflows.

### Data returned

| Field | Description |
| --- | --- |
| `email` | Original email string after trimming |
| `normalizedEmail` | Lowercase normalized email when syntax is valid |
| `validSyntax` | Whether the address has valid email syntax |
| `domain` | Parsed domain from the address |
| `mxFound` | Whether MX mail records were found |
| `mxRecords` | MX records with priority and exchange host |
| `aRecordFallbackFound` | Whether an A record exists when no MX was found |
| `isDisposable` | Whether the domain is a known temporary mailbox provider |
| `isRoleAccount` | Whether the mailbox is a role account |
| `riskLevel` | `low`, `medium`, `high`, or `unknown` |
| `outcome` | Plain outcome: `READY`, `RISKY`, `INVALID`, or `UNKNOWN` |
| `reasonCodes` | Machine-readable reasons such as `MX_FOUND` or `INVALID_SYNTAX` |
| `error` | A safe, actionable message when verification could not finish for that row; otherwise `null` |
| `checkedAt` | ISO timestamp for the check |

### Input settings

| Setting | JSON key | Type / default | Description |
| --- | --- | --- | --- |
| Email addresses | `emails` | array, default `["support@example.com","sales@gmail.com","bad-email","test@mailinator.com"]` | Paste email addresses to validate. Duplicates are normalized and checked once per run. |
| CSV or pasted text | `csvText` | string | Optional pasted CSV, newline, comma, semicolon, or whitespace separated email list. |
| Input dataset ID | `datasetId` | string | Optional Apify dataset ID to read email addresses from. |
| Dataset email field | `datasetEmailField` | string, default `"email"` | Field name containing email addresses when datasetId is used. |
| Check MX records | `checkMx` | boolean, default `true` | Look up public DNS MX records for each valid email domain. |
| Check A-record fallback | `checkARecordFallback` | boolean, default `true` | If no MX record exists, check whether the domain has an A record as a weak fallback signal. |
| Flag disposable email domains | `includeDisposableCheck` | boolean, default `true` | Flag common temporary or disposable mailbox providers. |
| DNS provider | `dnsProvider` | string, default `"google"` | DNS-over-HTTPS provider. Google is currently supported. |
| Maximum concurrency | `maxConcurrency` | integer, default `20` | Number of email addresses to verify in parallel. Keep low for small test runs. |
| Work budget | `maxRuntimeSecs` | integer, default `270`, range `60`–`270` | Time available for DNS work before the Actor saves completed rows and stops starting new checks. |
| Runtime safety margin | `runtimeSafetySecs` | integer, default `30`, range `30`–`120` | Time reserved for saving completed rows and the run summary. Keep this lower than `maxRuntimeSecs`. |

### Output fields

| JSON key | Label | Type | Description |
| --- | --- | --- | --- |
| `email` | Email | string | Output field for email. |
| `normalizedEmail` | NormalizedEmail | string / null | Output field for normalizedemail. |
| `validSyntax` | ValidSyntax | boolean | Output field for validsyntax. |
| `domain` | Domain | string / null | Output field for domain. |
| `mxFound` | MxFound | boolean | Output field for mxfound. |
| `mxRecords` | MxRecords | array | Output field for mxrecords. |
| `aRecordFallbackFound` | ARecordFallbackFound | boolean | Output field for arecordfallbackfound. |
| `isDisposable` | IsDisposable | boolean | Output field for isdisposable. |
| `isRoleAccount` | IsRoleAccount | boolean | Output field for isroleaccount. |
| `riskLevel` | RiskLevel | string | Output field for risklevel. |
| `outcome` | Outcome | string | High-level verification outcome: READY, RISKY, INVALID, or UNKNOWN. |
| `reasonCodes` | ReasonCodes | array | Output field for reasoncodes. |
| `error` | Error | string or null | Safe message for a row that could not be fully verified. |
| `checkedAt` | CheckedAt | string | Output field for checkedat. |

### Pricing

This Actor uses Apify pay-per-event pricing. The prices below come from the current Actor pricing configuration. Apify public plans map to Store discount tiers, so the table shows both the user-facing plan context and the pricing tier name. The final price shown in Apify depends on the user account plan and any custom agreement.

| Event | What is charged | Price |
| --- | --- | ---: |
| `start` | One-time fee per run | $0.005 |

| Event | What is charged | Free / no discount | Starter / Bronze | Scale / Silver | Business / Gold | Custom / Platinum | Custom / Diamond |
| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |
| `item` | Each email result saved to the dataset, including an explicit `UNKNOWN` result when a per-email verification cannot finish | $0.0667 / 1,000 | $0.058 / 1,000 | $0.0452 / 1,000 | $0.0348 / 1,000 | $0.0232 / 1,000 | $0.0162 / 1,000 |

Apify may also charge platform usage for compute, storage, proxies, or data transfer outside this Actor pricing. Check the Actor run and the Apify Pricing tab for the exact cost shown to your account.

### Input options

You can provide email addresses in three ways.

1. `emails` — a direct array of email strings.
2. `csvText` — pasted text containing email addresses separated by commas, semicolons, spaces, tabs, or new lines.
3. `datasetId` — an Apify dataset ID plus the field name that contains emails.

You can combine these options in one run. Duplicates are normalized and checked once.

### Ready-to-run examples

- [Role Account Email Verifier](https://apify.com/fetch_cat/email-mx-deliverability-verifier/examples/role-account-email-verifier)
- [Disposable Email Domain Check](https://apify.com/fetch_cat/email-mx-deliverability-verifier/examples/disposable-email-domain-check)
- [Crm Email Deliverability Check](https://apify.com/fetch_cat/email-mx-deliverability-verifier/examples/crm-email-deliverability-check)
- [Verify Pasted Email List Mx](https://apify.com/fetch_cat/email-mx-deliverability-verifier/examples/verify-pasted-email-list-mx)

[View all ready-to-run examples](https://apify.com/fetch_cat/email-mx-deliverability-verifier/examples)

### Example input

```json
{
  "emails": [
    "support@example.com",
    "sales@gmail.com",
    "bad-email",
    "test@mailinator.com"
  ],
  "csvText": "example",
  "datasetId": "example",
  "datasetEmailField": "email",
  "checkMx": true,
  "checkARecordFallback": true,
  "includeDisposableCheck": true,
  "dnsProvider": "google",
  "maxConcurrency": 20,
  "maxRuntimeSecs": 270,
  "runtimeSafetySecs": 30
}
```

### How to run it

1. Open the actor on Apify.
2. Paste a few email addresses into the input.
3. Keep the default checks enabled.
4. Start the run.
5. Open the dataset when the run finishes.
6. Filter by `riskLevel`, `validSyntax`, `mxFound`, or `reasonCodes`.
7. Export the results to CSV, JSON, Excel, or API.

### Output example

```json
{
  "email": "support@example.com",
  "normalizedEmail": "support@example.com",
  "validSyntax": true,
  "domain": "example.com",
  "mxFound": true,
  "mxRecords": [
    { "priority": 0, "exchange": "." }
  ],
  "aRecordFallbackFound": false,
  "isDisposable": false,
  "isRoleAccount": true,
  "riskLevel": "medium",
  "outcome": "RISKY",
  "reasonCodes": ["ROLE_ACCOUNT", "MX_FOUND"],
  "error": null,
  "checkedAt": "2026-07-03T00:00:00.000Z"
}
```

### Understanding risk levels

`low` means the address syntax is valid, the domain has mail routing, and no major risk flags were detected.

`medium` means the address may still be usable, but it has a caution flag such as a role mailbox or weak fallback domain evidence.

`high` means the address is clearly invalid, disposable, or attached to a domain without useful mail-routing signals.

`unknown` means a DNS check failed, so the actor could not confidently classify deliverability.

### Tips for better results

- Start with 10–20 emails to confirm your workflow.
- Use `datasetId` when validating output from another Apify actor.
- Keep `checkMx` enabled for most production runs.
- Keep `includeDisposableCheck` enabled for lead-gen lists.
- Treat `riskLevel` as a filtering signal, not a legal or compliance decision.
- Review `reasonCodes` when building automated rules.

### Integrations

You can use the results in common automation workflows.

- Export to Google Sheets or Excel for manual review.
- Feed low-risk emails into CRM import workflows.
- Send high-risk rows to a cleanup queue.
- Combine with lead scrapers to validate contacts before sales outreach.
- Use Apify webhooks to trigger the next step after a run succeeds.
- Read the dataset from the Apify API in your backend.

### API usage

Run Email MX & Deliverability Verifier from your own code with the Apify API.

**Node.js**

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const input = {
  "emails": [
    "support@example.com",
    "sales@gmail.com",
    "bad-email",
    "test@mailinator.com"
  ],
  "csvText": "example",
  "datasetId": "example",
  "datasetEmailField": "email",
  "checkMx": true
};

const run = await client.actor('fetch_cat/email-mx-deliverability-verifier').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python**

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("fetch_cat/email-mx-deliverability-verifier").call(run_input={
  "emails": [
    "support@example.com",
    "sales@gmail.com",
    "bad-email",
    "test@mailinator.com"
  ],
  "csvText": "example",
  "datasetId": "example",
  "datasetEmailField": "email",
  "checkMx": true
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~email-mx-deliverability-verifier/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"emails":["support@example.com","sales@gmail.com","bad-email","test@mailinator.com"],"csvText":"example","datasetId":"example","datasetEmailField":"email","checkMx":true}'
```

### Use with AI agents via MCP

Email MX & Deliverability Verifier can be used by AI assistants through the hosted Apify MCP server.

**Claude Code setup**

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=fetch_cat/email-mx-deliverability-verifier"
```

**Claude Desktop, Cursor, or VS Code JSON config**

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=fetch_cat/email-mx-deliverability-verifier"
    }
  }
}
```

**Example prompts**

- "Run Email MX & Deliverability Verifier with this input JSON and summarize the dataset."
- "Export the latest Email MX & Deliverability Verifier results to a table I can review."
- "Schedule this Actor for monitoring and tell me what changed between runs."

### Limits and reliability

The actor checks public signals and is suitable for batch workflows.

Very large runs depend on the number of email addresses and current DNS response times. The Actor saves completed rows progressively. If the work budget is reached, `RUN_SUMMARY` records the number of pending addresses and a `resumeInput` payload you can use for the remaining work. If you see `UNKNOWN` outcomes or `unknown` risk levels, retry those rows later or lower concurrency.

### Legality and responsible use

Only validate email addresses you are allowed to process. Follow applicable privacy, anti-spam, and data-protection laws, including rules for consent, retention, and outreach.

This actor provides technical validation signals. You remain responsible for how you use the data.

### FAQ

#### Does this guarantee an inbox exists?

No. The actor checks syntax and public domain-level signals. It does not guarantee that a specific mailbox accepts mail.

#### Why is a role account marked medium risk?

Role accounts such as `info@` and `support@` can be valid, but they often represent teams, aliases, or generic inboxes rather than an individual lead.

#### Why did a valid-looking email return high risk?

The domain may have no MX record and no A-record fallback, or it may be a disposable-domain provider.

#### Why did some rows return unknown?

A DNS lookup failed or timed out. Retry those rows later or reduce concurrency.

### Related actors

- [Agoda Reviews Scraper](https://apify.com/fetch_cat/agoda-reviews-scraper)
- [AliExpress Products Scraper](https://apify.com/fetch_cat/aliexpress-products-scraper)
- [Apple App Store Apps Scraper](https://apify.com/fetch_cat/apple-app-store-apps-scraper)
- [Apple App Store Reviews Scraper](https://apify.com/fetch_cat/apple-app-store-reviews-scraper)
- [arXiv Paper Search Scraper](https://apify.com/fetch_cat/arxiv-paper-search-scraper)

### Support

Report bugs, wrong output, blocked runs, or missing fields from the Actor page. Include the Apify run ID or run URL, your input JSON, what you expected, what the Actor returned, and one reproducible public URL so the issue can be tested quickly.

### Privacy and data handling

This Actor only requests the permissions needed to run the input you provide. It uses your input (such as URLs, search terms, identifiers, filters, and limits) only to fetch the requested public data from the relevant source site or API for this Actor, then writes results to your Apify dataset/key-value store.

Data may pass through Apify platform services and Apify Proxy during the run, and requests are sent only to the target site or public data provider required for this Actor's results. FetchCat does not send your inputs or outputs to advertising networks, data brokers, or model-training services, and does not retain run data outside Apify storage after the run except when you explicitly share run details for transient support debugging.

You are responsible for using this Actor lawfully, respecting the target site's terms, and avoiding unnecessary personal or sensitive data in inputs. Review the output before storing, sharing, or combining it with other data.

# Actor input Schema

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

Paste email addresses to validate. Duplicates are normalized and checked once per run.

## `csvText` (type: `string`):

Optional pasted CSV, newline, comma, semicolon, or whitespace separated email list.

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

Optional Apify dataset to read email addresses from. The Actor requests read-only access to the selected dataset.

## `datasetEmailField` (type: `string`):

Field name containing email addresses when datasetId is used.

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

Look up public DNS MX records for each valid email domain.

## `checkARecordFallback` (type: `boolean`):

If no MX record exists, check whether the domain has an A record as a weak fallback signal.

## `includeDisposableCheck` (type: `boolean`):

Flag common temporary or disposable mailbox providers.

## `dnsProvider` (type: `string`):

DNS-over-HTTPS provider. Google is currently supported.

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

Number of email addresses to verify in parallel. Keep low for small test runs.

## `maxRuntimeSecs` (type: `integer`):

Stops admitting new DNS checks before the platform timeout so completed rows and a resume input can be saved.

## `runtimeSafetySecs` (type: `integer`):

Time reserved for saving completed rows and RUN\_SUMMARY after DNS work stops.

## Actor input object example

```json
{
  "emails": [
    "support@example.com",
    "sales@gmail.com",
    "bad-email",
    "test@mailinator.com"
  ],
  "datasetEmailField": "email",
  "checkMx": true,
  "checkARecordFallback": true,
  "includeDisposableCheck": true,
  "dnsProvider": "google",
  "maxConcurrency": 20,
  "maxRuntimeSecs": 270,
  "runtimeSafetySecs": 30
}
```

# Actor output Schema

## `overview` (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@example.com",
        "sales@gmail.com",
        "bad-email",
        "test@mailinator.com"
    ],
    "datasetEmailField": "email"
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/email-mx-deliverability-verifier").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@example.com",
        "sales@gmail.com",
        "bad-email",
        "test@mailinator.com",
    ],
    "datasetEmailField": "email",
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/email-mx-deliverability-verifier").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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@example.com",
    "sales@gmail.com",
    "bad-email",
    "test@mailinator.com"
  ],
  "datasetEmailField": "email"
}' |
apify call fetch_cat/email-mx-deliverability-verifier --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fetch_cat/email-mx-deliverability-verifier",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/IxViwsdCwv7jaXmtu/builds/2IGrWoxGPmgBMxGzy/openapi.json