# Email Verifier (`crawlerbros/email-verifier`) Actor

Verify email addresses for deliverability. Check syntax, MX records, disposable domains, role-based addresses, and SMTP mailbox existence.

- **URL**: https://apify.com/crawlerbros/email-verifier.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Other, Developer tools, Lead generation
- **Stats:** 77 total users, 13 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

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

Verify email addresses for deliverability — check syntax, MX records, disposable domains, role-based addresses, free providers, and SMTP mailbox existence.

### What is Email Verifier?

A fast, free email verification tool that checks whether email addresses are valid and deliverable. No external paid APIs are used — all verification is performed locally using DNS lookups, SMTP handshakes, and built-in databases of 55,000+ disposable domains.

Perfect for cleaning email lists, validating sign-up forms, and reducing bounce rates before sending campaigns.

### What data can you extract?

**Verification results per email:**

- Verdict: valid, invalid, risky, disposable, or unknown
- Confidence score (0-100)
- Detailed checks: syntax, MX record, SMTP, disposable, role-based, free provider, catch-all
- Primary MX server hostname
- Human-readable reason for non-valid results

### Input

#### Email Addresses

Provide a list of email addresses to verify.

```json
{
    "emails": ["user@example.com", "test@gmail.com", "info@company.org"]
}
```

#### Verification Depth

Choose how thoroughly each email is checked:

| Depth | Checks Performed | Speed | Use Case |
|-------|-----------------|-------|----------|
| **Basic** | Syntax + MX records | Fastest | Quick format validation |
| **Standard** (default) | + Disposable, role-based, free provider detection | Fast | Email list cleaning |
| **Deep** | + SMTP mailbox verification, catch-all detection | Slower | Maximum accuracy |

#### Options

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| emails | string\[] | — | Email addresses to verify (required) |
| verificationDepth | string | `"standard"` | Verification depth: basic, standard, or deep |
| concurrency | integer | `10` | Parallel verifications (1-50) |

### Output

Each item in the dataset represents one verified email:

```json
{
    "email": "test@gmail.com",
    "verdict": "valid",
    "confidence": 85,
    "checks": {
        "syntax": true,
        "mxRecord": true,
        "smtp": null,
        "disposable": false,
        "roleBased": false,
        "freeProvider": true,
        "catchAll": null
    },
    "mxHost": "gmail-smtp-in.l.google.com",
    "reason": null,
    "verifiedAt": "2025-03-16T12:00:00.000000+00:00"
}
```

#### Output Fields

| Field | Type | Description |
|-------|------|-------------|
| email | string | Normalized email address |
| verdict | string | Verification result: valid, invalid, risky, disposable, or unknown |
| confidence | integer | Confidence score from 0 to 100 |
| checks | object | Detailed check results (see below) |
| mxHost | string/null | Primary MX server hostname |
| reason | string/null | Human-readable explanation for non-valid verdicts |
| verifiedAt | string | ISO 8601 timestamp of verification |

#### Check Details

| Check | Type | Description |
|-------|------|-------------|
| syntax | boolean | Email follows RFC 5322 format |
| mxRecord | boolean | Domain has valid MX records |
| smtp | boolean/null | SMTP server accepts the address (deep mode only) |
| disposable | boolean/null | Domain is a known disposable email provider (standard/deep) |
| roleBased | boolean/null | Address is role-based like admin@, info@, support@ (standard/deep) |
| freeProvider | boolean/null | Domain is a free email provider like Gmail, Yahoo (standard/deep) |
| catchAll | boolean/null | Domain accepts all addresses (deep mode only) |

#### Verdict Meanings

| Verdict | Meaning |
|---------|---------|
| **valid** | Email passed all checks and appears deliverable |
| **invalid** | Email failed syntax, MX, or SMTP verification |
| **risky** | Email exists but domain is catch-all (accepts any address) |
| **disposable** | Email uses a known disposable/temporary domain |
| **unknown** | Could not determine deliverability (SMTP blocked or timeout) |

### How to use

#### Quick validation

1. Enter email addresses in the **Email Addresses** field
2. Leave depth as **Standard**
3. Click **Save & Start**

#### Maximum accuracy

1. Enter email addresses
2. Set **Verification Depth** to **Deep**
3. Click **Save & Start**

Deep mode performs SMTP mailbox verification and catch-all detection for the most accurate results.

#### Large batches

For 100+ emails, increase the **Concurrency** setting (up to 50) for faster processing. Domain-level caching ensures MX lookups and catch-all checks are only performed once per domain.

### Frequently Asked Questions

#### How accurate is the verification?

Standard depth provides reliable syntax, MX, disposable, and role-based detection. Deep mode adds SMTP verification for the highest accuracy, but some mail servers may block or rate-limit verification attempts from cloud IPs.

#### Why is Gmail showing as "risky" in deep mode?

Gmail and some other major providers accept all addresses at the SMTP level (catch-all behavior). This means SMTP verification cannot distinguish between real and fake Gmail addresses, so they are marked as "risky" rather than "valid".

#### What does "unknown" verdict mean?

Unknown means the verifier could not definitively determine if the email is valid or invalid. This typically happens when SMTP servers block the connection, timeout, or return temporary errors.

#### Does this use any external paid APIs?

No. All verification is performed locally using DNS lookups, SMTP handshakes, and a built-in database of 55,000+ disposable email domains. No proxy or authentication is required.

#### Can I verify emails in bulk?

Yes. You can verify hundreds of emails in a single run. Use the concurrency setting to control parallel processing speed. Results are pushed in batches for efficient data handling.

#### What are role-based emails?

Role-based emails are addresses like admin@, info@, support@ that are typically shared by teams rather than belonging to individuals. These are flagged because they often have higher bounce rates and lower engagement.

#### Is the data accurate for all email providers?

Syntax and MX checks work universally. Disposable detection covers 55,000+ known domains. SMTP verification accuracy varies by provider — some servers always accept (catch-all) or block verification attempts. The confidence score reflects this uncertainty.

# Actor input Schema

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

List of email addresses to verify

## `verificationDepth` (type: `string`):

How thoroughly to verify each email. Basic: syntax + MX only. Standard: adds disposable, role-based, and free provider checks. Deep: adds SMTP mailbox verification and catch-all detection.

## `concurrency` (type: `integer`):

Number of emails to verify in parallel. Higher values are faster but may trigger rate limits on SMTP servers.

## Actor input object example

```json
{
  "emails": [
    "test@gmail.com",
    "invalid@nonexistent-domain-xyz123.com"
  ],
  "verificationDepth": "standard",
  "concurrency": 10
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset containing verification results for each email address

# 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@gmail.com",
        "invalid@nonexistent-domain-xyz123.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/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": [
        "test@gmail.com",
        "invalid@nonexistent-domain-xyz123.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/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": [
    "test@gmail.com",
    "invalid@nonexistent-domain-xyz123.com"
  ]
}' |
apify call crawlerbros/email-verifier --silent --output-dataset

```

## MCP server setup

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