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

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
reasonCodes	Machine-readable reasons such as MX_FOUND or INVALID_SYNTAX
checkedAt	ISO timestamp for the check

How much does it cost to verify email deliverability?

The actor uses pay-per-event pricing.

You pay a $0.005 run-start fee plus a per-email fee for each checked email saved to the dataset. Current tiered per-email prices are approximately: FREE $0.0000667, BRONZE $0.0000580, SILVER $0.0000452, GOLD $0.0000348, PLATINUM $0.0000232, and DIAMOND $0.0000162.

For planning, this type of utility is designed for bulk checks such as hundreds or thousands of emails. Keep your first run small, confirm the output columns match your workflow, then scale to larger lists.

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"
  ],
  "checkMx": true,
  "checkARecordFallback": true,
  "includeDisposableCheck": true,
  "maxConcurrency": 20,
  "dnsProvider": "google"
}

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 with Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/email-mx-deliverability-verifier').call({
  emails: ['support@example.com', 'bad-email'],
  checkMx: true,
  checkARecordFallback: true,
  includeDisposableCheck: true
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

API usage with 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', 'bad-email'],
    'checkMx': True,
    'checkARecordFallback': True,
    'includeDisposableCheck': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

API usage with 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","bad-email"],"checkMx":true}'

MCP usage

Use the Apify MCP server to run this actor from AI tools that support Model Context Protocol.

MCP URL pattern:

https://mcp.apify.com/?tools=fetch_cat/email-mx-deliverability-verifier

Claude Code setup example:

$claude mcp add apify-email-verifier https://mcp.apify.com/?tools=fetch_cat/email-mx-deliverability-verifier

MCP JSON configuration example:

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

Example prompts:

• "Verify these 50 emails and return only high-risk rows."
• "Check this Apify dataset of leads and summarize how many have MX records."
• "Run the email verifier and prepare a CSV of low-risk contacts."

Working with Apify datasets

If another actor produced a dataset with an email column, copy its dataset ID into datasetId.

If the field has a different name, set datasetEmailField to that column name. For example, use workEmail, contactEmail, or emailAddress depending on your dataset.

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.

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 Apify actors

You can combine this actor with other Apify lead-generation, search, and enrichment actors from the same Apify account to build a complete prospecting workflow.

Changelog

• Initial version: syntax, MX, A-record fallback, disposable-domain, role-account, risk-level, and reason-code output.