# ✅ Bulk Email Verifier - MX, Disposable & Role Check (`renzomacar/email-verifier`) Actor

Verify a list of emails without an API key: RFC syntax, live DNS MX record + provider (Google/Microsoft…), disposable-domain and role-based detection, free-provider flag, and a 0-100 deliverability score. Clean your lead list and cut bounces before cold outreach.

- **URL**: https://apify.com/renzomacar/email-verifier.md
- **Developed by:** [Renzo Madueno](https://apify.com/renzomacar) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

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

## ✅ Bulk Email Verifier — MX, Disposable & Role Check

**Paste a list of emails, get back a clean one.** This Actor takes any list of
email addresses and returns, for each one, whether it's well-formed, whether its
domain can actually receive mail (a live DNS MX lookup), who runs that mail
(Google Workspace, Microsoft 365, Zoho…), and whether it's a *disposable*,
*role-based*, or *free consumer* address. Every email gets a `status`
(`valid` / `risky` / `invalid`) and a **0–100 deliverability score** so you can
sort, filter and clean in seconds.

No API key. No signup with a third-party verification service. Keyless DNS +
heuristics that run reliably from the cloud.

---

### The value chain: find → verify → send

A cold list is only as good as its deliverability. Sending to dead, fake, or
throwaway addresses **hurts your sender reputation** — mailbox providers watch
your bounce rate and spam-trap hits, and a dirty list gets your *good* mail sent
to spam. The fix is a two-step pipeline:

1. **Find the emails.** Use our sibling Actors:
   - **Website Contact Finder** — crawl any domain and pull out emails, phones and social links.
   - **Company Enrichment** — turn a domain into tech stack, contacts and MX provider.
2. **Verify before you send** — *this Actor.* Drop the raw list in, keep the
   `valid` rows, review the `risky` ones, and discard the `invalid` ones.
3. **Then email** with your ESP / cold-outreach tool on a clean list.

The result: lower bounce rate, protected sender reputation, higher inbox
placement, and you stop paying your email tool to send to addresses that were
never going to land.

---

### What each check means

| Field | What it tells you |
|---|---|
| `syntaxValid` | Passes pragmatic RFC-ish validation (single `@`, legal local/domain parts, length limits). Catches typos like `john@@stripe`, `.leading`, trailing dots. |
| `hasMx` | The domain has a live **DNS MX record** — i.e. a mail server is configured to receive its mail. Resolved with Node's native `dns` resolver. Falls back to an implicit A-record MX (RFC 5321 §5.1) and flags it as weaker. |
| `mxProvider` | Who runs the mailbox, classified from the MX hostnames: **Google Workspace, Microsoft 365, Zoho, Proofpoint, Mimecast, GoDaddy, Amazon SES, Yahoo, Yandex, Proton**, transactional ESPs, and more. A real, useful deliverability & segmentation signal. |
| `isDisposable` | The domain is a known throwaway / temp-mail service (Mailinator, Guerrilla Mail, 10MinuteMail, YOPmail, and ~100 more). These addresses vanish — never worth emailing. |
| `isRoleBased` | The local part is a role/alias, not a person (`info@`, `support@`, `sales@`, `admin@`, `noreply@`…). Higher bounce and complaint risk on cold outreach; often catch-all. |
| `isFreeProvider` | A free consumer mailbox (`gmail.com`, `yahoo.com`, `outlook.com`, `icloud.com`…). Deliverable, but usually not a business contact — matters when cleaning a B2B list. |
| `status` | Roll-up: **`valid`** (good syntax + real MX + not disposable + not role/free), **`risky`** (deliverable but low-quality: role-based, free, or A-record-only), **`invalid`** (bad syntax, no MX, or disposable). |
| `score` | 0–100 deliverability score combining every signal above. Sort your list by it. |
| `reason` | Short machine-readable reason for the status (e.g. `no-mx-record`, `disposable-domain`, `role-based`, `ok`). |
| `checkedAt` | ISO timestamp of the check. |

---

### Honest note: this is MX + heuristics, **not** live SMTP

Some verifiers claim to "ping the mailbox" over SMTP (connect to the mail server
on port 25 and issue `RCPT TO` to see if the address exists). **We deliberately
don't do that, and neither should you trust services that claim they do from the
cloud:**

- Cloud providers (Apify included) **block or throttle outbound port 25** to stop
  spam, so the check would fail or hang for most addresses.
- Even when it connects, results are **unreliable**: greylisting delays it,
  and **catch-all** domains accept *every* address, so a "yes" means nothing.
- Aggressive SMTP probing can get your IP **blacklisted**.

So we do the checks that are **honest, fast and reliable** from the cloud:
valid syntax + a real MX record + disposable/role/free heuristics. This catches
the overwhelming majority of bad addresses (typos, dead domains, throwaways)
without pretending to a mailbox-level certainty that no cloud tool can truthfully
deliver. `risky` is our honest label for "deliverable domain, but verify the
mailbox yourself before a high-stakes send."

---

### Input

```json
{
  "emails": ["john@stripe.com", "test@mailinator.com", "info@notion.so"],
  "maxConcurrency": 5
}
````

| Field | Type | Default | Description |
|---|---|---|---|
| `emails` | array of strings | — (required) | Emails to verify, one per line. |
| `maxConcurrency` | integer | `5` | How many to verify in parallel (1–25). |

***

### Output

One record per email:

```json
{
  "email": "john@stripe.com",
  "syntaxValid": true,
  "hasMx": true,
  "mxProvider": "Google Workspace",
  "isDisposable": false,
  "isRoleBased": false,
  "isFreeProvider": false,
  "status": "valid",
  "score": 100,
  "reason": "ok",
  "checkedAt": "2026-07-02T00:00:00.000Z"
}
```

```json
{
  "email": "test@mailinator.com",
  "syntaxValid": true,
  "hasMx": false,
  "mxProvider": null,
  "isDisposable": true,
  "isRoleBased": false,
  "isFreeProvider": false,
  "status": "invalid",
  "score": 5,
  "reason": "disposable-domain",
  "checkedAt": "2026-07-02T00:00:00.000Z"
}
```

The dataset ships with a **table view** (email, status, score, MX, disposable,
role-based, provider) and exports to CSV, JSON, Excel, and via API.

***

### Use cases

- **Clean a lead list** before importing it into your CRM or ESP.
- **Cut your bounce rate** — drop `invalid`, review `risky`, keep `valid`.
- **Protect sender reputation** ahead of a cold-outreach campaign.
- **Segment B2B vs consumer** with `isFreeProvider`, and person vs alias with `isRoleBased`.
- **Route by provider** — e.g. tailor sending to Google Workspace vs Microsoft 365 domains.
- **De-risk a purchased or scraped list** by spotting disposable and dead domains.

***

### FAQ

**Does it connect to the mailbox / do a real SMTP check?**
No — see the honest note above. We do syntax + live MX + disposable/role/free
heuristics, which is the reliable approach from the cloud.

**Can it prove an address definitely exists?**
No cloud tool can (catch-all domains accept everything). We prove the domain can
*receive* mail and flag everything that makes an address low-quality or fake.

**What does `risky` mean — should I email those?**
Deliverable domain, but a lower-quality target: a role alias (`info@`), a free
consumer inbox, or a domain with only an A record. Fine for some sends, worth a
second look before high-stakes outreach.

**Do I need an API key or account anywhere?**
No. DNS is queried directly; the disposable/role/free lists are bundled.

**How fast is it?**
Fast — checks run in parallel (default concurrency 5). Thousands of emails run in
minutes.

**Are results deduplicated?**
Yes, the input list is de-duplicated (case-insensitive) before verification.

***

### Automate it

Run this Actor on a schedule or from your own code:

- **Schedule** it in the Apify Console to re-verify a list periodically.
- **API / SDK**: call it from Node or Python and read the dataset back.
- **Integrations**: pipe results to Google Sheets, Slack, Zapier, Make, or a
  webhook.
- **Chain it**: run **Website Contact Finder** → feed its emails straight into
  this verifier → export the `valid` rows to your outreach tool.

Pricing is **pay-per-result**: you're charged per email verified, so a run costs
exactly what you use.

***

*Part of a lead-gen Actor family: **Website Contact Finder** and **Company
Enrichment** to find and enrich; **Bulk Email Verifier** to clean before you
send.*

# Actor input Schema

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

One email address per line. Each is checked for syntax, a live DNS MX record (with provider classification), disposable/throwaway domains, role-based mailboxes (info@, support@…) and free consumer providers (gmail.com…). One clean record is returned per email. No live-SMTP probing (see the README for why).

## `maxConcurrency` (type: `integer`):

How many emails to verify in parallel. Higher = faster on big lists; the default is a friendly value for public DNS resolvers.

## Actor input object example

```json
{
  "emails": [
    "john@stripe.com",
    "test@mailinator.com",
    "info@notion.so"
  ],
  "maxConcurrency": 5
}
```

# 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@stripe.com",
        "test@mailinator.com",
        "info@notion.so"
    ],
    "maxConcurrency": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("renzomacar/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": [
        "john@stripe.com",
        "test@mailinator.com",
        "info@notion.so",
    ],
    "maxConcurrency": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("renzomacar/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": [
    "john@stripe.com",
    "test@mailinator.com",
    "info@notion.so"
  ],
  "maxConcurrency": 5
}' |
apify call renzomacar/email-verifier --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "✅ Bulk Email Verifier - MX, Disposable & Role Check",
        "description": "Verify a list of emails without an API key: RFC syntax, live DNS MX record + provider (Google/Microsoft…), disposable-domain and role-based detection, free-provider flag, and a 0-100 deliverability score. Clean your lead list and cut bounces before cold outreach.",
        "version": "0.1",
        "x-build-id": "I1uFscpzT0t6zebUP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/renzomacar~email-verifier/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-renzomacar-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/renzomacar~email-verifier/runs": {
            "post": {
                "operationId": "runs-sync-renzomacar-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/renzomacar~email-verifier/run-sync": {
            "post": {
                "operationId": "run-sync-renzomacar-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": "Emails to verify",
                        "type": "array",
                        "description": "One email address per line. Each is checked for syntax, a live DNS MX record (with provider classification), disposable/throwaway domains, role-based mailboxes (info@, support@…) and free consumer providers (gmail.com…). One clean record is returned per email. No live-SMTP probing (see the README for why).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 25,
                        "type": "integer",
                        "description": "How many emails to verify in parallel. Higher = faster on big lists; the default is a friendly value for public DNS resolvers.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```