# Email Address Validator & Disposable Email Checker (`mechniverse/email-address-validator`) Actor

Email address validator and disposable email checker: verify syntax, fix typos, confirm MX records and flag disposable, role-based and free-provider addresses. Bulk up to 100 emails per run. Pay only per completed check; invalid addresses cost almost nothing.

- **URL**: https://apify.com/mechniverse/email-address-validator.md
- **Developed by:** [Ganesh Chandak](https://apify.com/mechniverse) (community)
- **Categories:** Lead generation, 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 domain & signals checks

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 Address Validator & Disposable Email Checker

**Check any email address in one call: is it valid, can its domain receive mail, is it a throwaway, and is there a typo to fix. You pay only for completed checks.**

### What does Email Address Validator do?

Email Address Validator takes one address or a list of up to 100 and returns a clear verdict for each, plus the evidence behind it. It validates the **syntax**, suggests a **typo fix** (`gmial.com` becomes `gmail.com`), builds a **canonical form** so `j.o.hne+promo@gmail.com` and `johne@gmail.com` are recognised as the same Gmail inbox, looks up the domain's **MX records**, and flags **disposable** domains, **role accounts** (`info@`, `support@`) and **free providers** (Gmail, Outlook, Yahoo). It can also check for a **Gravatar**, a soft sign that a real person owns the address.

It does not open a connection to the recipient's mail server, so it never sends mail and never alerts the owner. That keeps it fast, cheap and safe to run on large lists. See the FAQ for what that means for accuracy.

### Why use Email Address Validator?

- **Cleaner sign-ups.** Reject malformed, typo and throwaway addresses before they enter your CRM or newsletter list.
- **Stop duplicate accounts.** The canonical form collapses Gmail dots and `+tags`, so one person cannot create a hundred accounts.
- **Modular, honest pricing.** Choose the depth of check; pay only for a completed verdict. Invalid addresses cost almost nothing.
- **Built for pipelines.** Same fields on every row, bulk input, and an explanation in plain English for every verdict.
- **Agent-ready.** Deterministic JSON that an AI agent can call as a tool.

### How to use Email Address Validator

1. Open the Actor in **Apify Console** and click **Try for free** (or call it through the [API](https://docs.apify.com/api/v2)).
2. Enter one address in **Email**, or add up to 100 addresses to **Emails**, one per line.
3. Choose the checks: **syntax** (cheapest) or **syntax + domain** (adds MX records and flags).
4. Click **Start**, then open the **Results** tab or download **JSON, CSV or Excel**. To automate it, use the API, schedules, webhooks, or Zapier, Make and n8n.

### Input

| Field | Type | Description |
|---|---|---|
| `email` | string | One address to verify. |
| `emails` | list of strings | Up to 100 addresses; each is verified and priced separately. |
| `checks` | list | `syntax` (RFC validity, typo suggestion, canonical form) and `domain` (adds MX records and flags). Higher checks include the lower ones. Default: `syntax` and `domain`. |

Example input:

```json
{ "emails": ["john.doe@gmail.com", "someone@mailinator.com"], "checks": ["syntax", "domain"] }
```

### Output

Each address produces one dataset item.

| Field | Description |
|---|---|
| `input` | The address exactly as submitted. |
| `reachable` | The verdict: `safe`, `risky`, `invalid` or `unknown`. |
| `module` | The deepest check that ran: `syntax` or `domain`. |
| `mailbox_verified` | Always `false`: the individual mailbox is not probed (see FAQ). |
| `explanation` | Plain-English statement of exactly what was and was not checked. |
| `syntax` | Validity, domain, username, typo suggestion and `canonical_email`. |
| `domain` | `has_mx`, `mx_records`, `is_disposable`, `is_role_account`, `is_free_provider`, Gravatar details. |
| `charge_event`, `charged` | What was billed for this row. |

Verdicts: **safe** (valid, and the domain accepts mail), **risky** (disposable or otherwise a sign-up trap), **invalid** (malformed, typo domain or dead domain) and **unknown** (inconclusive, never charged).

```json
{
  "input": "someone@mailinator.com",
  "module": "domain",
  "reachable": "risky",
  "mailbox_verified": false,
  "explanation": "Disposable/throwaway provider — deliverable now, but a sign-up trap.",
  "syntax": { "is_valid": true, "domain": "mailinator.com", "canonical_email": "someone@mailinator.com" },
  "domain": { "has_mx": true, "is_disposable": true, "is_role_account": false, "is_free_provider": false }
}
```

### Pricing

This Actor uses pay-per-event pricing, so you only pay for what you use.

| Event | Price | When it is charged |
|---|---|---|
| Syntax check | **$0.0001** | A valid address checked at syntax level |
| Invalid address | **$0.0001** | A malformed address that was rejected |
| Domain check | **$0.0005** | A completed syntax + MX + flags verdict |

- **Pay only for completed verdicts.** An inconclusive result is never charged.
- **A small fixed start fee** of $0.00005 applies per run.
- **No subscription.** Apify free-plan credit applies, so your first thousands of checks are effectively free. Set a maximum cost per run to cap spend.

### Integrations and API

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("mechniverse/email-address-validator").call(
    run_input={"emails": ["a@gmail.com", "b@mailinator.com"], "checks": ["syntax", "domain"]}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["input"], "->", item["reachable"])
```

You can also connect the dataset to Make, Zapier, n8n, Google Sheets, Slack or webhooks.

#### Use with AI agents and MCP

The Actor is available as a tool through [Apify's MCP server](https://docs.apify.com/integrations/mcp). An agent can validate an address before sending, read the structured verdict and its explanation, and stay inside a budget with Apify's maximum-charge cap.

### FAQ

**Does it verify that the mailbox exists?** No. Syntax and domain checks tell you whether the address is well formed and whether its domain can receive mail. They cannot prove that one specific inbox exists. Apify's network does not allow the direct mail-server connections that mailbox probing needs, so we do not claim it. If you request the `smtp` check you receive the domain-level verdict and the SMTP event is never charged.

**What are the limits of a domain-level check?** A `safe` verdict means the address is valid and its domain accepts mail. The specific user may still not exist. Treat `safe` as "worth sending", not "guaranteed delivered".

**Will it email the address or alert its owner?** No. Nothing is sent, and no mail server is contacted.

**How are Gmail addresses canonicalised?** For Gmail, dots are removed, `+tags` are stripped and `googlemail.com` becomes `gmail.com`. For other providers `+tags` are stripped. Variants of one inbox share a `canonical_email`.

**How many addresses per run?** Up to 100. For more, start several runs or loop through the API.

**Is it legal?** The Actor only processes the addresses you provide and public DNS data. You are responsible for lawful use of the results, including data-protection rules in your region.

Questions or feature requests? Open an issue on the **Issues** tab; we read every one.

# Actor input Schema

## `email` (type: `string`):

One email address to verify. Example: john.doe@gmail.com

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

Verify several emails in ONE run — one per line, max 100. Each email is verified and priced separately. Leave empty for a single check.

## `checks` (type: `array`):

Pick how deep to verify. syntax = RFC validity, typo suggestion and canonical form (cheapest). domain = also MX records, disposable / role / free-provider flags and Gravatar. Higher checks include the lower ones. smtp (mailbox handshake) is not available on Apify's network: requesting it returns the domain-level verdict and the smtp event is never charged.

## Actor input object example

```json
{
  "email": "john.doe@gmail.com",
  "checks": [
    "syntax",
    "domain"
  ]
}
```

# Actor output Schema

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

One record per input email: layered verdict (reachable + module completed) with syntax, domain and SMTP evidence, plus what was charged

# 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 = {
    "email": "john.doe@gmail.com",
    "checks": [
        "syntax",
        "domain"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("mechniverse/email-address-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 = {
    "email": "john.doe@gmail.com",
    "checks": [
        "syntax",
        "domain",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("mechniverse/email-address-validator").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 '{
  "email": "john.doe@gmail.com",
  "checks": [
    "syntax",
    "domain"
  ]
}' |
apify call mechniverse/email-address-validator --silent --output-dataset

```

## MCP server setup

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

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/v5CGEovAeg0Eo2qlh/builds/i0dcraIge4ODYDnXQ/openapi.json