# Fast Email Validator & Verifier | $1/1K | Bulk List Cleanup (`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
- **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/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 & Finder — Bulk Email Verification

**Clean and verify any email list before you send** — cold outreach, newsletters,
sign-up forms, CRM imports. Paste 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) checks and an optional live SMTP mailbox check that confirms whether an
inbox really exists.

### 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…).
- ✅ **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.
- ✅ **Smart de-duplication** — Gmail dots and `+tags` are normalized.
- ✅ **Deliverability score** — a transparent 0–100 score with plain-English reasons.

### What you get for every email

| Field | Meaning |
|-------|---------|
| `status` | `valid`, `risky`, `invalid` or `unknown` |
| `deliverabilityScore` | 0–100 confidence score |
| `syntaxValid` | passes RFC-aware syntax rules |
| `normalizedEmail` | de-duplication key (Gmail dots / `+tags` ignored) |
| `hasMx` / `mxProvider` | domain can receive mail + detected provider (Google Workspace, Microsoft 365, Zoho…) |
| `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.
- **No API key, no signup.** Nothing to register for.

### Pricing

**$1 per 1,000 results** — you pay only for addresses the actor returns, with no
monthly subscription, no seat fees and no API key. A syntax + domain pass is fast
and cheap at any list size; the optional live SMTP mailbox check is opt-in, so you
only spend extra time on the lists that need mailbox-level certainty.

### 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, or paste a whole CSV column into the
  free-text field. `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) 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": "valid",
  "deliverabilityScore": 95,
  "syntaxValid": true,
  "normalizedEmail": "johndoe@gmail.com",
  "domain": "gmail.com",
  "freeProvider": true,
  "roleBased": false,
  "disposable": false,
  "hasMx": true,
  "mxProvider": "Google Workspace",
  "mailboxExists": true,
  "catchAll": false,
  "smtpConnected": true,
  "reasons": ["domain can receive mail", "mailbox confirmed to exist"]
}
```

### 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.

**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 `unknown` or `risky`?**
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
"valid".

**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?**
$1 per 1,000 results — you pay only for the addresses returned, with no monthly
subscription and no API key. Use the filters (only-valid / only-deliverable) to
return fewer records and pay for just the addresses you keep.

**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.

## `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("💾 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": [
    "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": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=apivault_labs/email-validator",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/dyhXl9P3lmQfVN1VA/builds/oahKVJXN6OECHbyxL/openapi.json