Email MX & Deliverability Verifier

Check email lists for syntax, public MX records, common disposable domains and role accounts. Email MX & Deliverability Verifier returns structured risk signals for CRM cleanup and outreach preparation—not proof that an inbox exists or will accept mail.

Provide an address array, pasted text or an Apify dataset. No email-provider login or SMTP probing is used.

Quick start

1. Paste a small address list into Email addresses.
2. Keep the default checks enabled and start the Actor.
3. Open the dataset, review riskLevel and reasonCodes, then export JSON, CSV or Excel.

{
  "emails": ["support@example.com", "bad-email"],
  "maxConcurrency": 5
}

Reserved example domains illustrate input format, not working mailboxes. Replace them with addresses you want to check.

Prefer a video guide? This short Apify walkthrough shows you how to set up and run an Actor. It uses a different Actor, but the setup steps are the same.

Ready-to-run examples

Choose a public example to see its settings before starting a run:

• Detect role account emails in a lead list
• Flag disposable email addresses
• Verify a pasted email list for MX records

What you get

One row per processed unique address string, with syntax, enabled public mail-routing checks, local-list flags and explicit classification reasons. Read riskLevel, outcome and reasonCodes together. Results are domain-level signals rather than proof that an inbox exists or will accept mail.

Who is it for?

• CRM operations teams separating formatting and domain-mail issues before importing a list.
• Sales operations analysts reviewing existing business-contact addresses.
• Data-quality teams investigating inconclusive DNS checks and local-list risk flags.
• Automation developers adding bounded address checks to their own reporting workflows.

How you can use the data

• Triage an address column. Submit a small list and keep email, normalizedEmail, riskLevel, outcome and reasonCodes together. Separate invalid, risky and unknown results for review rather than treating every non-ready row as a nonexistent inbox.
• Check pasted addresses without importing other columns. Paste only the email column into the text input. It accepts simple separators rather than a full CSV file, so names and other CRM data belong in your own downstream join.
• Review a known dataset's mail-routing signals. Supply your actual dataset ID and email-field name. Only string values from that field are read, within the first 100,000 source rows. Use returned email values to match results back to your own data.
• Compare uncertain checks later. Keep checkedAt, enabled-check settings and reason codes with each export. A false DNS boolean can mean the check was disabled, an A-record fallback is only a weak domain signal, and a temporary lookup failure is not a permanent mailbox finding.

Input settings

Supply at least one nonempty source: emails, csvText or datasetId. They can be combined. The form's sample addresses are a prefill, not an API default.

Setting	JSON key	Default / purpose
Email addresses	emails	Array of strings. No API default.
CSV or pasted text	csvText	Simple comma, semicolon or whitespace-separated strings. Not a full CSV-file parser. Paste only the address column.
Input dataset	datasetId	Optional existing dataset. Reads up to the first 100,000 rows.
Dataset email field	datasetEmailField	email. Reads string values, not other columns.
Check MX records	checkMx	true.
Check A-record fallback	checkARecordFallback	true. Can run even when MX checking is disabled.
Flag disposable domains	includeDisposableCheck	true. Limited to known local entries.
DNS provider	dnsProvider	google, the only supported value.
Maximum concurrency	maxConcurrency	20, range 1–50.
Work budget	maxRuntimeSecs	270 seconds, range 60–270.
Runtime safety margin	runtimeSafetySecs	30 seconds, range 30–120. Keep below the work budget.

For a pasted list, use {"csvText":"support@example.com; bad-email"}. For dataset input, select your actual dataset and the appropriate field. An illustrative dataset ID will not work.

Example inputs

Use the Quick start input as a small first run. Adjust the fields described above for your own data.

Output data

Each unique address string produces a row when processed. Repeated strings are compared without case. Rows arrive in completion order, not guaranteed input order.

The following shape example illustrates the deterministic invalid-address result. The timestamp is illustrative:

{
  "email": "bad-email",
  "normalizedEmail": null,
  "validSyntax": false,
  "domain": null,
  "mxFound": false,
  "mxRecords": [],
  "aRecordFallbackFound": false,
  "isDisposable": false,
  "isRoleAccount": false,
  "riskLevel": "high",
  "outcome": "INVALID",
  "reasonCodes": ["INVALID_SYNTAX"],
  "error": null,
  "checkedAt": "2026-10-24T00:00:00.000Z"
}

Fields	Meaning
email, normalizedEmail, domain	Trimmed input, lowercase address and domain. Normalized values are null for invalid syntax.
validSyntax	Whether the address passes the supported syntax check.
mxFound, mxRecords	MX lookup signal and priority/exchange records, ordered by priority.
aRecordFallbackFound	An A record was found when no MX was found. This is only a weak domain signal.
isDisposable, isRoleAccount	Matches against fixed lists of common temporary domains and shared mailbox names.
riskLevel, outcome	Risk classification and its high-level outcome.
reasonCodes, error	Classification reasons and a nullable message for a per-address verification error. DNS lookup failures appear in reason codes even when error is null.
checkedAt	ISO check timestamp.

• low / READY: Valid syntax, MX found and no detected disposable or role-account flag. Not an inbox guarantee.
• medium / RISKY: A role mailbox or A-record fallback without MX.
• high: Invalid syntax (INVALID), a detected disposable domain or no positive enabled mail-routing signal (RISKY).
• unknown / UNKNOWN: An inconclusive verification, such as a DNS failure. Earlier invalid/disposable classifications can take precedence over a lookup failure.

False DNS booleans can mean the relevant check was disabled. Read reasonCodes and the input together. Don't interpret every false value as a missing record.

Download your results

Open your run's dataset, choose Export and select JSON, CSV or Excel. JSON keeps nested fields together. CSV and Excel are useful when you want to review the records in a spreadsheet.

See Apify's download and export guide for the available formats and field options.

Pricing

Pay-per-event pricing uses a start event once after nonempty input is collected and an item event for each saved result, including INVALID, RISKY and UNKNOWN rows. Case-insensitive duplicate strings are checked once per run.

Start with a small list. See the Pricing tab for current rates and discounts.

Tips for best results

• Keep MX checks enabled for domain-mail classification. Turning checks off does not establish deliverability.
• Read reasons alongside DNS booleans. A false value can reflect a disabled check, and earlier invalid or disposable classifications can take precedence over a lookup failure.
• Paste only an address column. Keep names and other input data in your own system for later matching.
• Review inconclusive rows before retrying a small list later. A successful run can include UNKNOWN results.
• Inspect progress at the work limit. Compare completed and pending counts and review any saved resumeInput before submitting more work.

Limits and caveats

Checks cover supported syntax, public MX records, optional A-record fallback and fixed lists of common disposable domains and role accounts. Lists are not exhaustive, and internationalized or unusual address formats may not pass the syntax check. An A-record fallback is only a weak domain signal.

READY is not an inbox guarantee. False DNS flags can mean that a check was disabled. DNS failures can be reflected in reason codes even when error is null, and earlier invalid or disposable classifications can take precedence over lookup uncertainty. Review row outcomes alongside the input and run status.

Completed rows are saved progressively. At the work limit, the Actor stops starting new addresses and attempts to save RUN_SUMMARY with completed and pending counts and a resumeInput for remaining work. A successful run can contain inconclusive rows. Retry uncertain addresses later rather than treating an incomplete export as every input checked.

Dataset input reads string values from the selected email field within the first 100,000 rows, without preserving other columns. Duplicate strings are compared without case, and results arrive in completion order rather than guaranteed input order.

No email-provider login, SMTP probing, catch-all testing or automatic change tracking is included. Public domain signals do not confirm mailbox existence or acceptance.

Automation and integrations

Save your settings for next time

Once you have an input that works for you, save it as an Apify task. This keeps your settings together so you can use them again without filling in the form from scratch.

Run on a schedule

Need fresh results regularly? You can schedule the Actor or a saved task to run at a time that suits you.

Each scheduled run collects the data again. If you want to compare results or highlight changes, add that step in your own workflow.

Send results to your other tools

Use n8n, Make or Zapier to connect this scraper to the rest of your workflow. For example, you could pass its results to an AI assistant or add records to a spreadsheet. Follow the Apify integration guides for your chosen tool.

For a custom connection, an Apify webhook can notify your app when a run finishes or fails. Your app can then fetch the results or handle the failure.

API usage

Want to collect this data from your own app or automation? The examples below send input to the scraper and show how to collect its results.

The Node.js and Python examples wait for the run to finish before reading its results. The cURL example starts the run and returns its details. Wait for that run to finish, then use its defaultDatasetId to fetch the results.

For setup instructions, see Apify's JavaScript client guide, Python client guide and Actor runs API reference.

cURL

curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~email-mx-deliverability-verifier/runs' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  --data @- <<'JSON'
{
  "emails": [
    "support@example.com",
    "bad-email"
  ],
  "maxConcurrency": 5
}
JSON

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"
  ],
  "maxConcurrency": 5
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/email-mx-deliverability-verifier').call(run_input={'emails': ['support@example.com', 'bad-email'], 'maxConcurrency': 5})
print(client.dataset(run['defaultDatasetId']).list_items().items)

MCP and AI agents

You can ask your AI assistant to collect data with Email MX & Deliverability Verifier and help you work with the results. The scraper returns the data, and your assistant can then summarize it, compare records or prepare notes.

Connect your assistant through the Apify MCP server. MCP gives your assistant a way to find this scraper, run it and read the results. Follow the official setup and sign-in guide for your app.

Easier setup with an Apify plugin

If you use a supported coding assistant, the official Apify plugin can set up the connection for you. It connects your assistant to Apify and includes instructions for common tasks. Follow the guide for your particular app.

Use Apify AI in Console

Prefer to keep everything in Apify? Open Apify AI in Console and ask it to find Fetch Cat's Email MX & Deliverability Verifier. You can describe the data you want and ask questions about the results.

Apify AI is currently in beta. It asks for confirmation before starting an Actor, and normal run charges apply.

Choose your assistant

• Claude and Claude Code (Anthropic): Apify setup guide.
• ChatGPT and Codex (OpenAI): Apify setup guides.
• Grok Bot (xAI): Apify plugin guide.
• Gemini CLI (Google): MCP server setup guide. Use the server URL below with the HTTP configuration supported by Gemini CLI.

Connect just this scraper

To keep your setup focused on this scraper, add this server configuration to a compatible MCP client:

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

Sign in to Apify when your client asks. If your client uses a Bearer token instead, follow its setup guide and keep the token in its secure configuration. Configuration formats vary by app, so use the linked guide if your client needs a different format.

Use Apify's general server

Already connected to the general Apify MCP server at https://mcp.apify.com? You can use it to find this scraper without adding another server. Ask your assistant to use Email MX & Deliverability Verifier by Fetch Cat, or give it the identifier fetch_cat/email-mx-deliverability-verifier.

Your assistant can check the available settings and retrieve the results from the returned run. If the run is still working, it should follow that run rather than start it again. Both connection options use Apify's hosted service.

Example requests

• “Use Fetch Cat’s Email MX & Deliverability Verifier to retrieve syntax and mail-routing signals for the 5 addresses I supply. Show outcomes, risk levels and reason codes without claiming inbox acceptance.”
• “Collect verification outcomes for this pasted column of 3 email addresses. Keep INVALID, RISKY and UNKNOWN results separate and show check times, rather than interpreting every negative signal as a missing mailbox.”
• “Retrieve mail-routing results from the actual dataset ID I provide, reading its email field. Keep normalized addresses and reason codes so I can join them to my own CRM data, and explain any pending or inconclusive work.”

Normal Apify charges apply. Check the live Pricing tab before asking your assistant to run a larger batch.

Pay with x402

If your AI agent has a funded wallet, it can pay for Apify usage through x402. This experimental option lets an agent use Apify without a conventional account.

Apify AGI provides a prepaid API token with a spending cap after payment. Your agent can use that token to run this scraper through the Apify API or an authenticated MCP connection.

Some MCP setups also support paying for each request directly. That is a different payment option, so check the official guide for its availability.

Follow the official guide for wallet setup, supported payment options and current terms. Apify handles the payments. Keep wallet keys and payment tokens in your agent's secure configuration.

Other ways for agents to pay

Apify also supports MPP for prepaid access through AGI and Skyfire for eligible Actors. If your agent already uses one of these, see the agentic payment guide to choose the right setup.

FAQ

Does email verification guarantee delivery?

No. These are syntax and public domain-level signals, not mailbox acceptance, ownership, spam-folder placement or catch-all detection.

Why is a role account marked risky?

Names such as support and admin represent shared or generic mailboxes. They can be valid addresses but merit a separate outreach decision.

Why is a valid-looking address high risk or unknown?

It may match a disposable domain, lack positive enabled DNS signals or have an inconclusive lookup. Check the reason codes and enabled checks before acting. A false flag alone doesn't prove the mailbox is missing.

Can I use this as an email validation API and export results?

Yes. Use the API examples above or Apify integrations to read the result dataset. Download CSV, Excel or JSON from the dataset, or pass results to another workflow. Input dataset columns are not preserved in output.

Related Actors

• Website Contact Finder — Collect public contact details before checking addresses.
• Google Maps Email Extractor & Lead Finder — Find business contacts for qualification.
• GitHub Contributor Email Scraper — Collect public commit-author contact evidence.
• Website Content Crawler Lite — Add website context to your workflow.
• Website Social Profile Finder — Enrich domain lists with public social links.

Support and feedback

For custom additions or integrations, email hello@fetchcat.dev.

Found an error or have a feature request? Open an issue with the run URL, a non-sensitive input example and what you expected.

Need help sharing it? See Apify’s guide to sharing a run when reporting an issue. Sharing a run can give the developer access to its input, logs and results, so use a run that contains no sensitive data. Please leave out API tokens, passwords, cookies, private documents and personal data. Use a public sample URL or a redacted example instead.

Tried this scraper? We'd love to hear how it worked for you. Leave a review to help others choose the right tool and help us improve it. Your feedback means a lot to us.

Made with care for curious people, AI agents and the possibilities in data. ♥