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
• ✅ Return machine-readable reason codes for filtering and automation

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

Input settings

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.

Example input

{
  "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
}

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

{
  "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",
  "reasonCodes": ["ROLE_ACCOUNT", "MX_FOUND"],
  "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

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

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

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

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

{
  "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. If you see 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.

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.