# Email Verifier — 6 Checks per Address, MX + SMTP, No API Key (`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, Business, MCP servers
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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)

### Overview

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.

Reliability posture: a charge only ever happens after a verification result has actually been written to the dataset. Failed pushes and empty input are never charged.

✅ No login required | ✅ No API key | ✅ Pay only for verified emails | ✅ MCP-ready for AI agents

### Features

Non-sending SMTP check. Stops at `RCPT TO` and issues `QUIT`. No message body is ever transmitted.
Full status verdicts. `valid`, `invalid`, `risky`, `unknown`, each with a human-readable reason.
Disposable and role detection. Flag throwaway providers and generic mailboxes like info@ or sales@.
Catch-all probing. Detects domains that accept every address so you never rely on false positives.
Pure network. Only DNS and a direct SMTP socket. No proxy, no browser, no external API.

### How it works

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. Your list never leaves the Apify run.

For each address, the actor parses syntax, looks up DNS MX records for the domain, opens a direct SMTP connection to the top MX host, and issues `HELO`, `MAIL FROM`, and `RCPT TO`. It then quits before any `DATA` stage, so nothing is delivered. Catch-all is detected by also probing a random, non-existent mailbox on the same domain.

### 🧾 Input configuration

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

### 📤 Output format

Captured from a live run against `support@apify.com`:

```json
{
  "email": "support@apify.com",
  "domain": "apify.com",
  "isValidSyntax": true,
  "mxFound": true,
  "isDisposable": false,
  "isRoleBased": true,
  "isCatchAll": false,
  "status": "risky",
  "reason": "Role-based address (not a person)",
  "checkedAt": "2026-07-15T04:15:37.745Z"
}
```

Every record contains these 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`. Only present when the check returns a definitive true/false; omitted from the record entirely when SMTP is skipped, blocked, or inconclusive |
| 🗑️ `isDisposable` | Known disposable or 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 read `status`: `valid` means syntax ok, MX found, SMTP accepted a non-catch-all mailbox. `invalid` means bad syntax, no MX, or a definitive server rejection. `risky` means deliverable but low quality (disposable, role-based, or catch-all). `unknown` means MX exists but the mailbox could not be confirmed (SMTP skipped, blocked, or greylisted). Many large providers (Gmail, Outlook) deliberately land here.

### 💼 Common use cases

**Clean an outreach or cold-email list**
Verify before sending to protect sender reputation and cut bounces.
Strip disposables and role-based addresses in one pass.

**Real-time signup validation**
Reject disposable addresses at the form before they land in your CRM.
Feed the API into a signup webhook for zero-friction cleaning.

**CRM hygiene**
Score and dedupe leads. Drop role-based and invalid contacts.
Refresh every quarter to catch mailboxes that went dead.

**Newsletter pre-flight**
Strip dead mailboxes ahead of a broadcast send.
Audit a purchased list to measure how much of it is actually deliverable.

### 🚀 Getting started

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

### 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 actually delivered, at $0.001 per email ($1 per 1,000). There is no free tier.

**Can I use it inside an AI agent?**
Yes. It is exposed as an MCP tool. See below.

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

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

Or call 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})`);
}
```

### 🛠️ Complete your outbound pipeline

This actor is the final hygiene step in a full outbound stack:

- **[Google Maps Leads Scraper](https://apify.com/themineworks/maps-leads)**: pull businesses and 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.

Typical flow: maps-leads finds the businesses, website-contact-finder and b2b-leads-finder add the people, email-verifier-validator confirms deliverability before you send.

Found a bug or have a feature request? Open an issue on the actor's Apify Console page or reach out through the Apify profile.

# 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

Download the OpenAPI definition: https://api.apify.com/v2/acts/NdlbZTaeZs1iQJnUb/builds/lVygpJ1JQ4aR1F9ei/openapi.json