# 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:** 34 total users, 8 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.50 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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("💾 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": [
    "test@gmail.com",
    "invalid@nonexistent-domain-xyz123.com"
  ]
}' |
apify call crawlerbros/email-verifier --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/email-verifier",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Email Verifier",
        "description": "Verify email addresses for deliverability. Check syntax, MX records, disposable domains, role-based addresses, and SMTP mailbox existence.",
        "version": "1.0",
        "x-build-id": "nRzvhQCgYTCGmXK5k"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~email-verifier/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-email-verifier",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~email-verifier/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-email-verifier",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~email-verifier/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-email-verifier",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "emails"
                ],
                "properties": {
                    "emails": {
                        "title": "Email Addresses",
                        "type": "array",
                        "description": "List of email addresses to verify",
                        "items": {
                            "type": "string"
                        }
                    },
                    "verificationDepth": {
                        "title": "Verification Depth",
                        "enum": [
                            "basic",
                            "standard",
                            "deep"
                        ],
                        "type": "string",
                        "description": "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.",
                        "default": "standard"
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Number of emails to verify in parallel. Higher values are faster but may trigger rate limits on SMTP servers.",
                        "default": 10
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```