# Email Validator & Verifier | $0.6/1K | Cleanup + Finder (`apivault_labs/email-validator`) Actor

Bulk email verifier that cleans your list before you send: cut bounce rate & protect sender reputation. Checks syntax, MX & live SMTP mailbox (RCPT TO) with catch-all detection. Flags disposable, role & free emails, fixes typos, scores 0-100. Email Finder built in. $1/1K, no API key.

- **URL**: https://apify.com/apivault\_labs/email-validator.md
- **Developed by:** [Apivault Labs](https://apify.com/apivault_labs) (community)
- **Categories:** Lead generation, Automation, MCP servers
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 email checkeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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?

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 & Finder - Bulk Email Verification

**Clean and verify any email list before you send** - cold outreach, newsletters,
sign-up forms, CRM imports. Paste or upload thousands of addresses and get back a
clean, deliverability-scored list in seconds. Or find a person's email from just
a name and a company domain.

No login and **no API key**. The validator combines syntax checks, live domain
(MX / SPF / DMARC) checks and an optional live SMTP mailbox check that confirms
whether an inbox really exists.

### Drop-in replacement for the most popular Apify verifier

Every record includes the same normalized fields as the market-leading email
verifier (`michael.g/email-verifier-validator`), so you can switch actors
without changing a single line of your workflow, n8n/Make/Zapier scenario or
MCP integration:

| Field | Values |
|-------|--------|
| `status` | `good` / `risky` / `bad` - business verdict, safe to send? |
| `technical_status` | `valid` / `invalid` / `unknown` / `catch_all` / `disposable` / `error` |
| `score` | 0-100 deliverability score |
| `reason` | `ok`, `invalid_syntax`, `no_mail_infrastructure`, `disposable_email`, `catch_all_domain`, `smtp_unreachable`, `request_failed` |
| `verification_details` | nested object with every individual check result |

Our richer legacy fields (`deliverabilityScore`, `verificationStatus`,
`mailboxExists`, `catchAll`, `mxProvider`, `suggestedCorrection`...) are all still
there - this actor is a strict superset of the leader's schema.

### What this email checker does

- **Bulk email verification** - validate thousands of addresses in one run.
- **Real deliverability, not just regex** - domain (MX) checks confirm the
  domain can actually receive mail and reveal the provider (Google Workspace,
  Microsoft 365, Zoho, Yandex...).
- **SPF & DMARC checks** - confirms the domain publishes SPF and DMARC records
  (a strong signal the domain is a well-managed mail sender).
- **Live SMTP mailbox check** - confirm the specific mailbox exists and detect
  catch-all domains. Works on cloud platforms.
- **Email Finder** - guess and verify a person's address from `Name + domain`.
- **Typo rescue** - recover misspelled domains (`gmial.com` -> `gmail.com`).
- **List hygiene** - flag disposable, role-based and free-webmail addresses.
- **Plus-tag detection** - surfaces `user+tag@domain.com` aliases
  (`emailTag` / `isTagged`).
- **Smart de-duplication** - Gmail dots and `+tags` are normalized.
- **Deliverability score** - a transparent 0-100 score with plain-English reasons.

### Pricing

Pay per result - you are billed only for addresses actually returned (via the
`result` charge event). Tiered by your Apify plan, platform usage paid by user:

| Plan | Price per verified email |
|------|--------------------------|
| FREE | $0.10 (anti-abuse) |
| BRONZE | $0.001 |
| SILVER | $0.0008 |
| GOLD and above | $0.0006 |

**From $0.60 per 1,000 verified emails** on paid plans. No monthly
subscription, no seat fees, no API key. The optional live SMTP mailbox check is
opt-in, so you only spend extra time on the lists that need mailbox-level
certainty. Use the filters (only-valid / only-deliverable) to return fewer
records and pay for just the addresses you keep.

### What you get for every email

| Field | Meaning |
|-------|---------|
| `status` | business verdict: `good`, `risky` or `bad` (leader-compatible) |
| `technical_status` | `valid`, `invalid`, `unknown`, `catch_all`, `disposable`, `error` (leader-compatible) |
| `score` | 0-100 deliverability score (same value as `deliverabilityScore`) |
| `reason` | snake\_case primary failure reason, or `ok` (leader-compatible) |
| `verification_details` | nested per-check detail: syntax, MX, A fallback, SMTP, catch-all, disposable, role, free, tag, SPF, DMARC |
| `verificationStatus` | legacy status: `valid`, `risky`, `invalid` or `unknown` |
| `deliverabilityScore` | 0-100 confidence score (legacy name of `score`) |
| `syntaxValid` | passes RFC-aware syntax rules |
| `normalizedEmail` | de-duplication key (Gmail dots / `+tags` ignored) |
| `emailTag` / `isTagged` | the `+tag` part of an aliased address, if present |
| `hasMx` / `mxProvider` | domain can receive mail + detected provider (Google Workspace, Microsoft 365, Zoho...) |
| `hasSpf` / `hasDmarc` | domain publishes SPF / DMARC records (null if DNS lookup failed) |
| `mailboxExists` | the inbox really exists (when the live mailbox check is on) |
| `catchAll` | domain accepts any address, so a single mailbox can't be confirmed |
| `smtpConnected` | whether the live mailbox check reached a mail server |
| `freeProvider` | free webmail (Gmail, Outlook, Yahoo...) |
| `roleBased` | group mailbox (`info@`, `sales@`, `support@`) |
| `disposable` | throwaway / temporary domain (18k+ domains) |
| `suggestedCorrection` | typo fix, e.g. `john@gmial.con` -> `john@gmail.com` |
| `reasons` | plain-English explanation of the score |

### Why use this email verifier

- **Reduce bounce rate and protect sender reputation.** Removing invalid and
  risky addresses before a campaign keeps your bounce rate low and your domain
  out of spam folders.
- **Confirm mailboxes actually exist.** The live mailbox check goes beyond
  syntax and domain checks - it confirms whether the specific inbox is real, and
  flags catch-all domains that accept everything.
- **Typo rescue.** Recovers misspelled domains (`gmial.com`, `yaho.com`,
  `outlook.con`) instead of silently dropping good leads.
- **Broad disposable detection.** Flags 18,000+ throwaway / temporary domains.
- **Smart de-duplication.** Provider-aware normalization catches
  `john.doe+news@gmail.com` and `johndoe@gmail.com` as the same inbox.
- **Drop-in compatible.** The same `status` / `technical_status` / `score` /
  `reason` / `verification_details` schema as the most popular Apify email
  verifier - zero switching cost.
- **No API key, no signup.** Nothing to register for.

### Email Finder - find an email from a name and domain

Don't have the address yet? Give the finder a **name + domain** and it builds the
common corporate patterns (`john.doe@`, `jdoe@`, `john@`, `jsmith@`...) and, when
the SMTP check is on, verifies which one actually exists - skipping catch-all
domains so you don't get false positives.

Input (one person per line):

```
Elon Musk, tesla.com
Bill Gates @ microsoft.com
```

Output per person:

```json
{
  "mode": "finder",
  "name": "Elon Musk",
  "domain": "tesla.com",
  "candidates": ["elon.musk@tesla.com", "elonmusk@tesla.com", "emusk@tesla.com", "elon@tesla.com"],
  "mostLikely": "elon.musk@tesla.com",
  "email": "emusk@tesla.com",
  "found": true,
  "verified": true,
  "catchAll": false,
  "reason": "mailbox verified via live SMTP check"
}
```

When the SMTP check is off or a mail server is unreachable, the finder still
returns the ranked candidates and the `mostLikely` pattern (with `verified: null`)
so the run is always useful.

### Reliability

The live mailbox check works on cloud platforms. Some mail servers greylist or
rate-limit verification, and catch-all domains accept any address - in those
cases the actor returns its best signal from the domain/MX checks rather than a
false "valid", and the run never fails. For the highest certainty on large
lists, enable a proxy (see Input below).

### Input

- **Email addresses** - one per line, paste a whole CSV column into the
  free-text field, or upload a CSV/TXT file directly. `Name <john@acme.com>`
  pastes are handled too.
- **Email Finder** - one `First Last, domain.com` per line to guess + verify a
  person's address (optional; runs alongside the validator).
- **Check domain deliverability** - toggle domain (MX / SPF / DMARC) checks on/off.
- **Live SMTP mailbox check** - confirm the mailbox exists + detect catch-all.
- **Proxy** - optional. For large lists a proxy improves throughput and
  reliability of the mailbox check. Use `auto` for Apify Residential, or paste
  your own proxy URL.
- **Filters** - return only valid / only deliverable, drop disposable, drop
  role-based, de-duplicate.
- **Export format** - full JSON, CSV-friendly columns, or both.

### Output sample

```json
{
  "input": "John.Doe+news@Gmail.com",
  "email": "john.doe+news@gmail.com",
  "status": "good",
  "technical_status": "valid",
  "verificationStatus": "valid",
  "score": 95,
  "deliverabilityScore": 95,
  "reason": "ok",
  "syntaxValid": true,
  "normalizedEmail": "johndoe@gmail.com",
  "emailTag": "news",
  "isTagged": true,
  "domain": "gmail.com",
  "freeProvider": true,
  "roleBased": false,
  "disposable": false,
  "hasMx": true,
  "mxProvider": "Google Workspace",
  "hasSpf": true,
  "hasDmarc": true,
  "mailboxExists": true,
  "catchAll": false,
  "smtpConnected": true,
  "verification_details": {
    "syntax_valid": true,
    "mx_records_valid": true,
    "a_fallback": false,
    "mx_records": ["gmail-smtp-in.l.google.com"],
    "smtp_checked": true,
    "smtp_connected": true,
    "mailbox_exists": true,
    "catch_all": false,
    "disposable": false,
    "role_based": false,
    "free_provider": true,
    "has_tag": true,
    "tag": "news",
    "spf": true,
    "dmarc": true
  },
  "reasons": ["domain has MX records", "SMTP confirmed the mailbox exists"]
}
```

### API, MCP and no-code usage

Run the actor programmatically with any HTTP client - no SDK needed:

```bash
## Start a run (returns a run id; poll it until SUCCEEDED)
curl -X POST "https://api.apify.com/v2/acts/apivault_labs~email-validator/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"emails": ["john.doe@gmail.com", "info@acme.com"], "smtpVerification": true}'

## Read the results (replace RUN_ID with the id from the previous call)
curl "https://api.apify.com/v2/actor-runs/RUN_ID/dataset/items?token=YOUR_APIFY_TOKEN"
```

- **MCP**: add this actor as a tool to any MCP client (Claude, Cursor, ChatGPT,
  ...) via the Apify MCP server and call it directly from your AI agent.
- **n8n / Make / Zapier**: use the official Apify integration nodes - start the
  actor with your email list and map the dataset items (`status`, `score`,
  `reason`, `verification_details`) straight into your workflow.
- **Schedules & webhooks**: run it on a schedule and push clean lists to Google
  Sheets, your CRM or a webhook endpoint automatically.

### Common use cases

- **Clean a lead list before a cold email campaign** - drop invalid and risky
  addresses to keep your bounce rate low.
- **Scrub a purchased or scraped list** before importing to a CRM.
- **Validate sign-up form input** in bulk to stop fake and disposable signups.
- **Find a decision-maker's email** from their name and company domain.
- **Protect sender reputation** by removing spam-trap-prone role and catch-all
  addresses before you send.

### FAQ

**Does this actually check if an email address exists?**
Yes. With the live SMTP mailbox check enabled, the actor confirms whether the
specific inbox exists. Catch-all domains are flagged separately because they
accept any address and can't be confirmed individually.

**Do I need an API key or account?**
No. There's no signup and no API key - only a standard Apify run.

**How accurate is the mailbox check?**
Very accurate for most domains. Some large providers greylist or rate-limit
verification, and catch-all domains accept everything - in those cases the
actor returns its best signal instead of a false "valid", so you never get
misleading results.

**Why do some addresses come back as `risky` or `unknown`?**
Some mail servers greylist verification attempts, and catch-all domains accept
everything. In those cases the actor returns its best signal instead of a false
"good".

**Can it find someone's email from just their name?**
Yes - use the Email Finder. Provide `Name, domain.com` and it generates the
common corporate patterns and verifies which one exists.

**How do I get a clean, deliverable-only list?**
Turn on the *Return only deliverable* filter (and optionally *Drop disposable* /
*Drop role-based*) to export just the addresses safe to send to.

**How much does it cost?**
From $0.60 per 1,000 verified emails on paid plans ($0.10 on the Free plan to
deter abuse). You pay only for addresses returned, with no monthly subscription
and no API key.

**What formats can I export?**
Full JSON, CSV-friendly flat columns, or both. Dataset views include a
ready-made "Deliverable (clean list)" table.

# Actor input Schema

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

Email addresses to validate (one per line), e.g. john.doe@acme.com.

## `emailsText` (type: `string`):

Optional. Paste many addresses at once (one per line, or comma/semicolon separated — e.g. a copied spreadsheet column). They are merged with the list above and de-duplicated.

## `emailsFile` (type: `string`):

Optional. Upload a .csv or .txt file with one email address per line (or comma/semicolon separated). The addresses are merged with the fields above and de-duplicated.

## `findEmails` (type: `array`):

Optional. One person per line as "First Last, domain.com" (comma, @ or space separated). Generates the common corporate patterns (john.doe@, jdoe@, john@…) and, when the live SMTP check is on, verifies which one actually exists. Turn on 'Live SMTP mailbox check' below to confirm the address.

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

Look up each domain's MX records to confirm it can receive mail and detect the mail provider. Turn off for a faster syntax-only pass.

## `smtpVerification` (type: `boolean`):

Confirm whether the specific mailbox exists and detect catch-all domains that accept any address. This is the strongest deliverability signal. Works on cloud platforms; when a mailbox can't be confirmed it falls back to the domain (MX) signals and never fails the run. Slower than the domain-only pass; best for high-value lists. Tip: set a proxy below for larger runs.

## `proxyUrl` (type: `string`):

Optional but recommended for the live mailbox check on bulk lists — a proxy improves throughput and reliability. Use 'auto' for Apify Residential (recommended), or paste your own proxy as http://user:pass@host:port (or host:port:user:pass). Leave empty to run the mailbox check without a proxy (fine for smaller lists).

## `proxySessions` (type: `integer`):

How many proxy attempts to make per address before giving up.

## `smtpTimeout` (type: `integer`):

Per-step timeout for the SMTP mailbox check.

## `freshDisposableList` (type: `boolean`):

Use the full disposable/throwaway domain list (18,000+ domains) instead of the smaller built-in set. Adds a second or two at startup and catches far more temporary mailboxes. Falls back to the built-in set if unavailable.

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

Remove duplicate addresses using provider-aware normalization (Gmail dots and +tags are ignored). Keeps the first occurrence.

## `onlyValid` (type: `boolean`):

If on, drop addresses that fail the syntax check from the output.

## `onlyDeliverable` (type: `boolean`):

If on, keep only addresses whose status is valid or risky (drops invalid/undeliverable). Best run right before sending.

## `dropDisposable` (type: `boolean`):

If on, remove addresses on known temporary-mailbox domains.

## `dropRoleBased` (type: `boolean`):

If on, remove group mailboxes like info@, sales@, support@ (keep only personal addresses).

## `exportFormat` (type: `string`):

default = full JSON. csv = flat CSV-friendly columns. both = JSON + nested \_csv.

## Actor input object example

```json
{
  "emails": [
    "john.doe@gmail.com",
    "info@apify.com",
    "test@gmial.con",
    "user@mailinator.com",
    "bad email@@example"
  ],
  "findEmails": [
    "Elon Musk, tesla.com",
    "Bill Gates @ microsoft.com"
  ],
  "checkMx": true,
  "smtpVerification": false,
  "proxySessions": 8,
  "smtpTimeout": 10,
  "freshDisposableList": true,
  "deduplicate": true,
  "onlyValid": false,
  "onlyDeliverable": false,
  "dropDisposable": false,
  "dropRoleBased": false,
  "exportFormat": "default"
}
```

# 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": [
        "john.doe@gmail.com",
        "info@apify.com",
        "test@gmial.con",
        "user@mailinator.com",
        "bad email@@example"
    ],
    "findEmails": [
        "Elon Musk, tesla.com",
        "Bill Gates @ microsoft.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("apivault_labs/email-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": [
        "john.doe@gmail.com",
        "info@apify.com",
        "test@gmial.con",
        "user@mailinator.com",
        "bad email@@example",
    ],
    "findEmails": [
        "Elon Musk, tesla.com",
        "Bill Gates @ microsoft.com",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("apivault_labs/email-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 '{
  "emails": [
    "john.doe@gmail.com",
    "info@apify.com",
    "test@gmial.con",
    "user@mailinator.com",
    "bad email@@example"
  ],
  "findEmails": [
    "Elon Musk, tesla.com",
    "Bill Gates @ microsoft.com"
  ]
}' |
apify call apivault_labs/email-validator --silent --output-dataset

```

## MCP server setup

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