# Bulk Email Verifier & Validator - Email Checker, MX, Disposable (`santhej/email-verifier`) Actor

Bulk-verify email addresses: syntax, domain/MX deliverability, disposable, role-account, free-provider and typo detection. Fast, no API key, pay per email.

- **URL**: https://apify.com/santhej/email-verifier.md
- **Developed by:** [Santhej Kallada](https://apify.com/santhej) (community)
- **Categories:** Other
- **Features:** Limited permissions
- **Stats:** 40 total users, 6 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.80 / 1,000 email verifieds

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/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 Verifier & Validator — Bulk, SMTP, Catch-all & Disposable

**Clean and validate email lists in bulk with deep, real-time verification. Every address gets a clear status (`valid` / `invalid` / `risky` / `unknown`), a 0–100 score and the full signal set: live SMTP check, catch-all detection, deliverability, MX, disposable, role account, free provider, spam-trap and a "did you mean?" typo fix. No API key, no setup.**

### What does Email Verifier & Validator do?

It checks each email address you give it and tells you whether it is safe to send to. In **Power** mode it talks to the recipient's mail server (a live SMTP handshake) and detects catch-all domains; in **Quick** mode it runs the instant checks only. Duplicates are removed before anything is verified, so you never pay twice for the same address.

- **Two modes:**
  - **Power** (default): deep verification with a live SMTP handshake plus catch-all and deliverability detection. Most accurate.
  - **Quick**: instant check of syntax, MX records, disposable domains, role accounts and free providers, with no SMTP. Faster, same price per email.
- **Rich signals per email**: `is_safe_to_send`, `is_deliverable`, `is_catch_all`, `can_connect_smtp`, `is_disposable`, `is_role_account`, `is_free_email`, `is_spamtrap`, `has_inbox_full`, `is_disabled`, `mx_record`.
- **"Did you mean?"**: suggests a fix for mistyped free-mail domains, e.g. `gmial.com` to `gmail.com`, `yahooo.com` to `yahoo.com`.
- **Confidence score**: one 0–100 number for quick filtering (Power mode).
- **Bulk**: up to 50,000 emails per run.

### Use cases

- **Cold email and outbound**: verify a prospect list before a campaign to keep bounce rates low and protect your sending domain.
- **CRM and list hygiene**: find dead, disabled and disposable addresses in an existing database.
- **Signup and lead-magnet forms**: catch typos and throwaway addresses before they reach your email tool.
- **Lead enrichment pipelines**: add a verification step after scraping or buying leads, via the API, n8n, Make or Zapier.

### How to use Email Verifier & Validator

1. Paste your addresses into **Emails to verify**, one per line (or send an `emails` array through the API).
2. Choose **Verification mode**: *Power* for the deep SMTP check, *Quick* for instant results.
3. Leave **Remove duplicates** on, so repeated addresses are verified and charged once.
4. Click **Start**.
5. Filter the results by `status` or `is_safe_to_send` (the **Quick-mode results** view shows the columns Quick mode fills), and export as CSV, Excel or JSON, or read them through the Apify API.

#### Example input

```json
{
  "emails": ["hello@buffer.com", "info@stripe.com", "test@mailinator.com", "contact@gmial.com", "bad@@format"],
  "mode": "power",
  "deduplicate": true
}
```

#### Input configuration

| Field | Type | Default | Description |
|---|---|---|---|
| `emails` | array of strings | required | Email addresses to verify, one per line. Up to 50,000 per run. |
| `mode` | string | `power` | `power` (live SMTP, catch-all, deliverability, spam-trap; most accurate) or `quick` (syntax, MX, disposable, role and free-provider checks; no SMTP). |
| `deduplicate` | boolean | `true` | Lower-case and de-duplicate the list before verifying, so each address is checked and charged once. |

#### Example output

One record per email (Power mode):

```json
{
  "email": "info@stripe.com",
  "status": "risky",
  "raw_status": "catch_all",
  "score": 71,
  "is_safe_to_send": false,
  "is_deliverable": true,
  "is_valid_syntax": true,
  "domain": "stripe.com",
  "mx_accepts_mail": true,
  "mx_record": "aspmx2.googlemail.com",
  "can_connect_smtp": true,
  "is_catch_all": true,
  "is_disposable": false,
  "is_role_account": true,
  "is_free_email": false,
  "is_spamtrap": false,
  "has_inbox_full": false,
  "is_disabled": false,
  "did_you_mean": null,
  "verification_mode": "power",
  "error": null,
  "checked_at": "2026-09-23T03:31:01.191Z"
}
```

`raw_status` is the detailed verdict behind `status` (`valid`, `invalid`, `disabled`, `catch_all`, `role_account`, `disposable`, `inbox_full`, `spamtrap` or `unknown`). In **Quick** mode `score`, `is_safe_to_send`, `is_deliverable`, `can_connect_smtp`, `is_catch_all`, `has_inbox_full` and `is_disabled` are `null`, because they need the SMTP check. Malformed addresses come back as `invalid` with `error: "invalid_syntax"`.

#### Status meanings

| Status | Meaning |
|---|---|
| `valid` | Safe to send: syntax and MX check out, and in Power mode the mailbox was confirmed over SMTP. |
| `invalid` | Will bounce: bad syntax, dead domain, no mail server, disabled mailbox or spam-trap. |
| `risky` | May deliver but is lower quality: catch-all domain, role account (info@, sales@), disposable address, full inbox, or a likely typo. |
| `unknown` | The mail server could not be probed conclusively (some providers block checks). Try again later or treat with caution. |

A run summary (total and count per status) is saved to the run's key-value store as `OUTPUT`.

### How much does email verification cost?

Pay per event. You are charged per email that gets a conclusive result.

| Event | Apify Free plan | Paid plans (Bronze, Silver, Gold and above) |
|---|---|---|
| Email verified | $0.10 | $0.0018 ($1.80 per 1,000) |
| Actor start (once per run) | $0.0005 | $0.0005 |

- **Not charged:** duplicates removed by `deduplicate`, and emails whose result is `unknown`.
- **Charged:** `valid`, `invalid` (including malformed addresses) and `risky` results. Power and Quick mode cost the same.
- **Apify Free plan users** pay $0.10 per email, so the actor is best suited to paid Apify plans for anything beyond a quick test.

Worked examples:

| Run | Paid plan | Free plan |
|---|---|---|
| 8 emails, all conclusive | 8 × $0.0018 + $0.0005 = **$0.0149** | 8 × $0.10 + $0.0005 = **$0.8005** |
| 1,000 emails, 20 come back `unknown` | 980 × $0.0018 + $0.0005 = **$1.7645** | 980 × $0.10 + $0.0005 = **$98.0005** |
| 10,000 emails with 500 duplicates, all conclusive | 9,500 × $0.0018 + $0.0005 = **$17.1005** | — |

### FAQ

**What is the difference between Power and Quick mode?**
Power mode opens a live SMTP conversation with the recipient's mail server to confirm the mailbox where possible and detects catch-all domains, which accept any address. Quick mode skips SMTP for instant syntax, MX, disposable, role and free-provider filtering. Both cost the same per email.

**Why do some addresses come back `unknown`?**
Some mail providers deliberately block verification probes. Those return `unknown` rather than a false verdict, and you are not charged for them.

**Why is a deliverable address marked `risky`?**
Catch-all domains accept every address, so a mailbox cannot be confirmed; role accounts (info@, sales@, press@) are shared inboxes that hurt cold-email performance. Use `is_safe_to_send` and `score` for finer filtering.

**Are duplicates charged?**
No. With `deduplicate` on (the default), the list is lower-cased and de-duplicated before verification.

**How fast is it?**
Six emails are verified in parallel. Quick mode is near-instant per email; Power mode takes longer because it talks to each recipient's mail server.

**Can I use it from n8n, Make, Zapier or my own code?**
Yes. Call the actor through the Apify API or an integration and read the dataset when the run finishes.

# Actor input Schema

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

Email addresses to verify, one per line.

## `mode` (type: `string`):

Power = full deep check (live SMTP, catch-all, deliverability, spam-trap) — most accurate. Quick = instant check (syntax, MX, disposable, role) — faster, no SMTP, same price per email.

## `deduplicate` (type: `boolean`):

Lower-case and de-duplicate the input list before verifying (you are not charged for duplicates).

## Actor input object example

```json
{
  "emails": [
    "jeff@amazon.com",
    "info@stripe.com",
    "test@mailinator.com",
    "bad@@format"
  ],
  "mode": "power",
  "deduplicate": true
}
```

# Actor output Schema

## `dataset` (type: `string`):

One record per email with status, score and signals.

## `summary` (type: `string`):

Counts of valid / invalid / risky / unknown emails.

# 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": [
        "jeff@amazon.com",
        "info@stripe.com",
        "test@mailinator.com",
        "bad@@format"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("santhej/email-verifier").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": [
        "jeff@amazon.com",
        "info@stripe.com",
        "test@mailinator.com",
        "bad@@format",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("santhej/email-verifier").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": [
    "jeff@amazon.com",
    "info@stripe.com",
    "test@mailinator.com",
    "bad@@format"
  ]
}' |
apify call santhej/email-verifier --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,santhej/email-verifier"
        }
    }
}
```

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/LFgD4hKgZC43fabgU/builds/Lee8y6KPXxJ4j1a8a/openapi.json