# Bulk Email Validator: MX, Disposable & Typo Check (No SMTP) (`steadyline/email-deliverability-checker`) Actor

Bulk email list cleaner without sending or SMTP probing: syntax, MX records, null MX, disposable and free providers, role addresses, typo suggestions (gmial.com → gmail.com), SPF/DMARC, mail provider and a deliverability verdict. $0.50 per 1,000 emails. By Steadyline Data.

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

## Pricing

from $0.50 / 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

## Email Domain & Deliverability Checker (no SMTP)

Clean an email list **without sending anything and without SMTP mailbox probing**. Every address gets:

- **Syntax validation** (RFC 5321/5322 rules that real mailboxes use, plus IDN domains). `Name <a@b.com>` and `mailto:` inputs are accepted.
- **Domain checks**: does the domain exist, MX records, *null MX* (RFC 7505), implicit MX (A record only), and the mail provider (Google Workspace, Microsoft 365, …).
- **Disposable / throwaway detection**, using the public, community-maintained disposable-email-domains list (~10k domains) plus your own additions.
- **Role address** detection (info@, sales@, support@, noreply@ …) and **free provider** detection (Gmail, Outlook, Yahoo …).
- **Typo suggestions**: `jane@gmial.com` → `jane@gmail.com`.
- **SPF / DMARC** on the domain (optional).
- **Verdict** (`deliverable` / `risky` / `undeliverable` / `unknown`), a 0–100 score, and the reasons behind it.

#### What it does *not* do

It does not connect to mail servers, so it can't confirm that a specific mailbox exists or detect catch-all domains. That trade-off is deliberate: SMTP probing gets your IPs blocklisted, is unreliable against Gmail and Microsoft 365, and is unwelcome to mail operators. Use this Actor to remove obviously bad, risky and mistyped addresses before you send.

### Use cases

- **Pre-clean lists before paid SMTP verification:** remove syntax errors, dead domains and disposable addresses for $0.50 per 1,000.
- **Sign-up form hygiene:** flag disposable and typo'd addresses (gmial.com → gmail.com).
- **Lead list QA:** flag role addresses (info@, sales@) and free-mail addresses in B2B lists.
- **Mail-provider segmentation:** Google Workspace vs Microsoft 365 vs others, from MX.
- **CRM data quality** jobs on a schedule.

### Input

```json
{ "emails": ["someone@gmail.com", "info@apify.com", "test@mailinator.com", "jane@gmial.com", "bad@@x"] }
```

### Output sample

```json
{
  "input": "jane@gmial.com", "email": "jane@gmial.com", "domain": "gmial.com",
  "syntaxValid": true, "domainExists": true, "mxRecords": ["..."], "nullMx": false,
  "disposable": false, "role": false, "freeProvider": false,
  "typoSuggestion": "gmail.com", "suggestedEmail": "jane@gmail.com",
  "spf": false, "dmarc": false, "mailProvider": null,
  "verdict": "risky", "score": 50, "reasons": ["possible typo of gmail.com", "domain has no SPF", "domain has no DMARC"],
  "charged": true
}
```

The dataset has two views: **Overview** and **Technical**.

### Pricing (pay per event)

| Event | Price | When |
|---|---|---|
| `email-checked` | **$0.0005** per email | A unique email with valid syntax whose domain DNS lookup completed. A result that says the domain doesn't exist counts as completed. |

Invalid syntax, duplicates and DNS timeouts or failures are **never charged**. Invalid-syntax rows still appear in the dataset so you can see them. DNS answers are cached per domain, so large lists from the same company domains run quickly.

**Cost example:** a 10,000-address list costs about **$5.00** in events, plus a few cents of platform usage.

### Use it from AI agents (MCP), Zapier, Make, n8n or the API

**AI agents (Claude, Cursor, VS Code, ChatGPT and other MCP clients).** Add Apify's hosted MCP server with just this Actor as a tool:

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

Sign in with Apify (OAuth) on first connect, or add an `Authorization: Bearer <APIFY_TOKEN>` header. Then ask your agent, for example:

> Use steadyline/email-deliverability-checker to clean this list of 500 emails: drop undeliverable and disposable addresses and fix obvious typos.

The agent sees this Actor's input schema and output fields, so it can call it without extra prompting. Agents that use the general Apify MCP server can also find it with `search-actors`.

This Actor uses pay-per-event pricing with limited permissions, so it can also be run through Apify's agentic payments (no Apify account needed for the agent). See the [Apify docs](https://docs.apify.com/platform/integrations/mcp#agentic-payments).

**Zapier, Make and n8n.** Use the official Apify app: Zapier "Run Actor" action, Make "Run an Actor" module, or the n8n Apify node. Choose `steadyline/email-deliverability-checker`, paste the input below, then use "Get dataset items" (or the run's dataset) to send results to Google Sheets, Slack, a CRM or a database.

**API (any language).** Run it and get the results in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/steadyline~email-deliverability-checker/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"emails": ["someone@gmail.com", "info@apify.com", "test@mailinator.com", "jane@gmial.com"]}'
```

Or with the Python client (`pip install apify-client`):

```python
from apify_client import ApifyClient
client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("steadyline/email-deliverability-checker").call(run_input={"emails": ["someone@gmail.com", "info@apify.com", "test@mailinator.com", "jane@gmial.com"]})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

### Works well with other Steadyline Data tools

- **Tech-targeted lead list:** [Tech Stack Detector](https://apify.com/steadyline/tech-stack-detector) → [Website Contact Extractor](https://apify.com/steadyline/website-contact-extractor) → this Actor to clean the emails.
- **List hygiene:** this Actor, then [Domain Intel](https://apify.com/steadyline/domain-intel) on the remaining company domains for SPF/DMARC and mail provider.
- Related: [Website Contact Scraper](https://apify.com/steadyline/website-contact-extractor), [Domain Intel (WHOIS/RDAP, DNS, SSL)](https://apify.com/steadyline/domain-intel), [Tech Stack Detector](https://apify.com/steadyline/tech-stack-detector).

### FAQ

**Does it verify that the mailbox exists?**
No. It never connects to mail servers over SMTP or sends mail. It checks everything that can be known from syntax and DNS. Use it to remove obvious bad addresses before you pay for SMTP verification.

**Which addresses are charged?**
Each email checked is $0.0005. Rows that fail syntax, and rows where the DNS lookup itself fails, are returned with `charged: false`.

**What does the verdict mean?**
`deliverable` (score ≥ 70), `risky` (40–69, e.g. typo, disposable, no SPF/DMARC) or `undeliverable` (bad syntax, no such domain, null MX). `reasons` explains each verdict.

**Can I run it on a schedule?** Yes. Create an Apify Schedule (or a saved Task with a schedule) and connect a webhook or integration to receive results.

**Need a feature or found a bug?** Open an issue on the Issues tab of this page or email steadylinedata@proton.me. Built and maintained by **Steadyline Data**.

### Acceptable use

Use this Actor only on lists you are legally allowed to process: for example, your own customers, sign-ups or CRM contacts, under a legitimate interest or consent. It reads public DNS data only and never contacts mailboxes. Don't use it to build or validate lists for unsolicited bulk email. You're responsible for complying with GDPR, CAN-SPAM, CASL and similar laws.

***

Built and maintained by **Steadyline Data**. The disposable list comes from the public disposable-email-domains project (CC0).

# Actor input Schema

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

Email addresses. "Name <a@b.com>" and "mailto:" are accepted. Duplicates are skipped for free.

## `checkEmailAuth` (type: `boolean`):

Also report whether the email domain publishes SPF and DMARC.

## `extraDisposableDomains` (type: `array`):

Your own domains to flag as disposable, in addition to the public list.

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

Emails checked in parallel. DNS results are cached per domain.

## `timeoutSecs` (type: `integer`):

Per DNS query.

## Actor input object example

```json
{
  "emails": [
    "someone@gmail.com",
    "info@apify.com",
    "test@mailinator.com",
    "jane@gmial.com"
  ],
  "checkEmailAuth": true,
  "extraDisposableDomains": [],
  "maxConcurrency": 20,
  "timeoutSecs": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

One row per email.

## `technical` (type: `string`):

DNS details per email.

# 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": [
        "someone@gmail.com",
        "info@apify.com",
        "test@mailinator.com",
        "jane@gmial.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("steadyline/email-deliverability-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": [
        "someone@gmail.com",
        "info@apify.com",
        "test@mailinator.com",
        "jane@gmial.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("steadyline/email-deliverability-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": [
    "someone@gmail.com",
    "info@apify.com",
    "test@mailinator.com",
    "jane@gmial.com"
  ]
}' |
apify call steadyline/email-deliverability-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,steadyline/email-deliverability-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/Rs5TVqPpVgkmH6e6x/builds/sxkfcWmJL801bxtRP/openapi.json