# ✅ Email Verifier — Bulk MX + SMTP Check · $1/1k (`themineworks/email-verifier-validator`) Actor

Verify emails in bulk: syntax, DNS MX, SMTP mailbox check, disposable & role-based detection, plus a catch-all heuristic. Returns valid / invalid / risky / unknown per address. No API key. Works in Claude, ChatGPT & any MCP agent.

- **URL**: https://apify.com/themineworks/email-verifier-validator.md
- **Developed by:** [The Mine Works](https://apify.com/themineworks) (community)
- **Categories:** Lead generation, MCP servers, Automation
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.00 / 1,000 emails

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Verifier & Validator — Bulk MX + SMTP Check (No API Key)

### What is Email Verifier & Validator?

**Email Verifier & Validator** is clean, fast bulk email verification. Paste a list of addresses and get back a per-email verdict — `valid`, `invalid`, `risky`, or `unknown` — backed by real syntax parsing, DNS MX lookups, a **non-sending SMTP mailbox check**, plus disposable, role-based, and catch-all detection. No API key, no sign-up, no third-party verification service. It is the reusable enrichment primitive for cleaning outreach lists, deduping sign-ups, and scoring leads before you send.

- **Protect sender reputation** — strip dead mailboxes before a cold-email or newsletter send
- **Cut bounce rates** — catch typo domains, dead domains, and disposable addresses
- **Clean CRM lists** — flag role-based and catch-all addresses for filtering
- **Verify at the form** — reject throwaway sign-ups in real time
- **Drop into any pipeline** — run it after a scraper to validate the emails it found

### No API key, no verification-service subscription

Paid verification services (ZeroBounce, NeverBounce, Hunter Verify) charge per credit and route your list through their servers. **Email Verifier & Validator uses only DNS and a direct SMTP socket** — no proxy, no browser, no external API, and your list never leaves the Apify run. The SMTP mailbox check stops at `RCPT TO` and issues `QUIT`: there is no `DATA` stage, so **no message body is ever transmitted and nothing lands in anyone's inbox.** It is a pure-network actor, which keeps it fast and cheap.

### What data does Email Verifier & Validator return?

Every record contains these real fields:

| Field | Description |
| --- | --- |
| 📧 `email` | The address checked (lowercased, trimmed) |
| 🌐 `domain` | Domain portion of the email |
| ✏️ `isValidSyntax` | Passes RFC-style syntax validation |
| 📡 `mxFound` | Domain has at least one DNS MX record |
| 📬 `smtpAccepts` | Mail server accepted `RCPT TO`; `null` if skipped, blocked, or inconclusive |
| 🗑️ `isDisposable` | Known disposable / throwaway mailbox provider |
| 👥 `isRoleBased` | Generic role mailbox (info, sales, admin, support…) |
| 🕳️ `isCatchAll` | Server appears to accept all addresses on the domain |
| ✅ `status` | Overall verdict: `valid` / `invalid` / `risky` / `unknown` |
| 💬 `reason` | Short human-readable explanation of the status |
| 🕒 `checkedAt` | ISO timestamp of the check |

### How to use Email Verifier & Validator (5 steps)

1. Paste your addresses into **Emails to verify** (one per line). Bulk lists are processed in order.
2. Leave **Check MX records** on to confirm each domain can receive mail (disabling it also disables the SMTP check).
3. Leave **Check mailbox via SMTP** on for the non-sending `RCPT TO` mailbox test — or turn it off for a faster MX-only pass.
4. Keep **Detect disposable domains** and **Detect role-based addresses** on to clean outreach lists.
5. Click **Start**, then export the per-address verdicts as JSON, CSV, or Excel — or pull them via API/MCP.

#### Example input

```json
{
  "emails": ["test@stripe.com", "ceo@notion.so", "info@example.com"],
  "checkMx": true,
  "checkSmtp": true,
  "detectDisposable": true,
  "detectRoleBased": true
}
````

#### Example output record

```json
{
  "email": "test@stripe.com",
  "domain": "stripe.com",
  "isValidSyntax": true,
  "mxFound": true,
  "smtpAccepts": null,
  "isDisposable": false,
  "isRoleBased": false,
  "isCatchAll": false,
  "status": "unknown",
  "reason": "MX found; mailbox not confirmed (SMTP inconclusive)",
  "checkedAt": "2026-07-10T09:12:44.018Z"
}
```

**How to read `status`:** `valid` = syntax ok, MX found, SMTP accepted a non-catch-all mailbox. `invalid` = bad syntax, no MX, or a definitive server rejection. `risky` = deliverable but low quality (disposable, role-based, or catch-all). `unknown` = MX exists but the mailbox could not be confirmed (SMTP skipped, blocked, or greylisted) — many large providers (Gmail, Outlook) deliberately land here.

### Use cases

- **Clean an outreach / cold-email list** before sending to protect sender reputation and cut bounces.
- **Validate sign-ups in real time** — reject disposable addresses at the form.
- **Score and dedupe CRM leads** — drop role-based and invalid contacts.
- **Pre-flight a newsletter** — strip dead mailboxes ahead of a send.
- **Enrich any pipeline** — run it right after a scraper to verify the emails it found.
- **Audit a purchased list** — measure how much of a bought list is actually deliverable.

### FAQ

#### Does this send any email?

No. The SMTP check stops at `RCPT TO` and issues `QUIT`. There is no `DATA` stage, so no message body is ever transmitted and nothing is delivered.

#### Why is `smtpAccepts` null for some addresses?

Port 25 is frequently firewalled, and providers such as Gmail and Outlook intentionally cloak mailbox existence or greylist unfamiliar connections. When the handshake is inconclusive we return `null` and a `status` of `unknown` rather than guessing.

#### What does "catch-all" mean?

Some domains accept mail for every possible address. We detect this by also probing a random, nonexistent mailbox; if the server accepts it, we mark `isCatchAll: true` and downgrade the verdict to `risky`, because acceptance no longer proves the real mailbox exists.

#### Do I need a proxy or API key?

No. The actor uses only DNS and a direct SMTP socket — no proxy, no browser, no external API.

#### How is it priced?

Pay-per-event: one `email-verified` event per email processed, at **$0.001 per email ($1 per 1,000)**. The first 25 emails per Apify account are free for life, so you can try it before spending anything.

### Use in Claude, ChatGPT & any MCP agent

This actor is exposed as a Model Context Protocol (MCP) tool, so AI agents can verify emails as a step in any workflow:

```
https://mcp.apify.com/?tools=themineworks/email-verifier-validator
```

Or run it programmatically with the Apify client:

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('themineworks/email-verifier-validator').call({
  emails: ['test@stripe.com', 'ceo@notion.so', 'info@example.com'],
  checkMx: true,
  checkSmtp: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const r of items) {
  if (r._type === 'summary') continue;
  console.log(`${r.email}: ${r.status} (${r.reason})`);
}
```

### Related lead-generation actors (they chain together)

This actor is the final hygiene step in a pipeline:

- **[Google Maps Leads Scraper](https://apify.com/themineworks/maps-leads)** — pull businesses + emails from a Google Maps search.
- **[Website Contact Scraper](https://apify.com/themineworks/website-contact-finder)** — extract emails, phones, and socials from a domain list.
- **[B2B Leads Finder](https://apify.com/themineworks/b2b-leads-finder)** — find named decision-makers (email, LinkedIn, phone) at target companies.
- **email-verifier-validator** (this actor) — MX + SMTP verify every address before you send.

Typical flow: **maps-leads → website-contact-finder → email-verifier-validator**.

# Actor input Schema

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

List of email addresses to validate (one per line). Each address is checked for syntax, then for DNS MX records, then optionally for a live mailbox via SMTP. Bulk lists are processed in order.

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

Resolve the domain's DNS MX records to confirm it can receive mail. Fast and free of side effects. Disabling this also disables the SMTP check.

## `checkSmtp` (type: `boolean`):

Open a connection to the domain's mail server and run a HELO / MAIL FROM / RCPT TO handshake to test whether the specific mailbox exists. NO email is ever sent. Many providers (Gmail, Outlook) block or cloak this, so the result can be null even for valid addresses. Slower than the MX-only check.

## `detectDisposable` (type: `boolean`):

Flag addresses on known throwaway / temporary-mailbox domains (mailinator.com, 10minutemail.com, guerrillamail.com, etc.).

## `detectRoleBased` (type: `boolean`):

Flag generic role mailboxes (info@, sales@, admin@, support@, etc.) that are not tied to a single person. Useful for cleaning outreach lists.

## Actor input object example

```json
{
  "emails": [
    "test@stripe.com",
    "ceo@notion.so"
  ],
  "checkMx": true,
  "checkSmtp": true,
  "detectDisposable": true,
  "detectRoleBased": true
}
```

# Actor output Schema

## `results` (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": [
        "test@stripe.com",
        "ceo@notion.so"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("themineworks/email-verifier-validator").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": [
        "test@stripe.com",
        "ceo@notion.so",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("themineworks/email-verifier-validator").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": [
    "test@stripe.com",
    "ceo@notion.so"
  ]
}' |
apify call themineworks/email-verifier-validator --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "✅ Email Verifier — Bulk MX + SMTP Check · $1/1k",
        "description": "Verify emails in bulk: syntax, DNS MX, SMTP mailbox check, disposable & role-based detection, plus a catch-all heuristic. Returns valid / invalid / risky / unknown per address. No API key. Works in Claude, ChatGPT & any MCP agent.",
        "version": "0.1",
        "x-build-id": "catSJA2f7CIoyrTb6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/themineworks~email-verifier-validator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-themineworks-email-verifier-validator",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/themineworks~email-verifier-validator/runs": {
            "post": {
                "operationId": "runs-sync-themineworks-email-verifier-validator",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/themineworks~email-verifier-validator/run-sync": {
            "post": {
                "operationId": "run-sync-themineworks-email-verifier-validator",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "emails"
                ],
                "properties": {
                    "emails": {
                        "title": "Emails to verify",
                        "type": "array",
                        "description": "List of email addresses to validate (one per line). Each address is checked for syntax, then for DNS MX records, then optionally for a live mailbox via SMTP. Bulk lists are processed in order.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "checkMx": {
                        "title": "Check MX records",
                        "type": "boolean",
                        "description": "Resolve the domain's DNS MX records to confirm it can receive mail. Fast and free of side effects. Disabling this also disables the SMTP check.",
                        "default": true
                    },
                    "checkSmtp": {
                        "title": "Check mailbox via SMTP",
                        "type": "boolean",
                        "description": "Open a connection to the domain's mail server and run a HELO / MAIL FROM / RCPT TO handshake to test whether the specific mailbox exists. NO email is ever sent. Many providers (Gmail, Outlook) block or cloak this, so the result can be null even for valid addresses. Slower than the MX-only check.",
                        "default": true
                    },
                    "detectDisposable": {
                        "title": "Detect disposable domains",
                        "type": "boolean",
                        "description": "Flag addresses on known throwaway / temporary-mailbox domains (mailinator.com, 10minutemail.com, guerrillamail.com, etc.).",
                        "default": true
                    },
                    "detectRoleBased": {
                        "title": "Detect role-based addresses",
                        "type": "boolean",
                        "description": "Flag generic role mailboxes (info@, sales@, admin@, support@, etc.) that are not tied to a single person. Useful for cleaning outreach lists.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```