# Bulk Email Verifier & Validator – Clean Your List (`logiover/bulk-email-verifier`) Actor

Verify and validate emails in bulk before outreach. Checks syntax, MX/DNS records, disposable & temporary domains, role accounts, free providers and typos. Cuts bounce rate and protects sender reputation. CSV/Excel/JSON in & out.

- **URL**: https://apify.com/logiover/bulk-email-verifier.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Lead generation, Marketing, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.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

## ✅ Bulk Email Verifier & Validator – Clean Your Email List

**Verify and validate thousands of email addresses in bulk — before you hit send.**
Cut your bounce rate, protect your sender reputation, and stop wasting outreach on dead inboxes.

This Actor is a fast **email verifier** and **email validator** that runs a full signal stack on every address — **syntax**, **MX/DNS** records, **disposable** domains, **role accounts**, **free providers**, and **typo detection** — and returns a clear `valid` / `risky` / `invalid` status plus a 0–100 deliverability score. It's the perfect cleanup step after any scrape or list purchase.

> Need to **verify email addresses in bulk**, **validate an email list**, **check MX records**, **detect disposable emails**, or **reduce your bounce rate** before a campaign? Drop your list in and export a clean one.

---

### ✅ What it checks

For every email, per row:

- **Syntax validation** — RFC-style format check that catches malformed addresses
- **MX / DNS lookup** — does the domain actually run a mail server? (uses clean public resolvers so results don't depend on a flaky host DNS)
- **Disposable / temporary** domain detection (Mailinator, 10MinuteMail, Guerrilla Mail, YOPmail, and 50+ more)
- **Role-account** detection (`info@`, `sales@`, `support@`, `noreply@`, `admin@`, …)
- **Free-provider** flag (Gmail, Outlook, Yahoo, iCloud, GMX, Proton, …)
- **Typo "did you mean"** suggestions (`gmial.com → gmail.com`, `hotnail.com → hotmail.com`)
- **Deliverability score** (0–100) and a single, clear **status**: `valid` · `risky` · `invalid`

---

### 🎯 Best for

- **Cold email & outreach** — remove bounces before they hurt your domain reputation
- **Lead-list cleaning** — validate scraped, exported, or purchased lists
- **CRM hygiene** — periodically re-verify your contact database to keep it deliverable
- **Signup / form validation** — batch-check captured addresses for typos and junk
- **Deliverability protection** — keep bounce rates under provider limits (Gmail, Outlook, Mailchimp, etc.)
- **Agencies & SaaS** — clean client lists at scale before every send

---

### ⚡ Why this validator

- **No SMTP spam, no blacklisting** — it does not hammer mailboxes on port 25 (which is blocked on most clouds and gets sending IPs blacklisted). It removes the bulk of undeliverable, junk, and disposable addresses with safe, fast signals.
- **Clean public DNS** — queries are resolved against public resolvers, so a dead domain reads as dead instead of being hijacked into a "parked" answer by a local resolver.
- **Pipe-friendly** — pass a plain list, a pasted blob, or objects piped from another Actor (just set the email field name).
- **Fast & parallel** — bounded-concurrency DNS lookups with per-domain caching, so large lists with repeated domains fly through.
- **Transparent** — every signal is exposed as its own field, so you decide how strict to be.

---

### 🛠 How to use

1. Add addresses to **Emails** (list) and/or paste them into **Emails (paste)** (separated by spaces, commas, semicolons, or new lines).
2. If you're piping objects from another Actor, set **Email field name** (default `email`).
3. Run the Actor, then export the **valid** rows (`status = valid`) to CSV / Excel / JSON, or pull them via the **Apify API**.

#### Example input
```json
{
  "emails": ["business@mkbhd.com", "test@gmial.com", "hello@mailinator.com", "info@google.com"]
}
````

***

### 📤 Output

```json
{
  "email": "test@gmial.com",
  "status": "invalid",
  "score": 10,
  "reason": "no_mail_server",
  "syntaxValid": true,
  "domain": "gmial.com",
  "hasMxRecord": false,
  "isDisposable": false,
  "isRoleAccount": false,
  "isFreeProvider": false,
  "didYouMean": "test@gmail.com"
}
```

A run summary (`valid` / `risky` / `invalid` counts) is also saved to the key-value store as `SUMMARY`.

#### Status meaning

| Status | Meaning | What to do |
|---|---|---|
| `valid` | Good syntax, domain has a mail server, not disposable/role | ✅ Safe to send |
| `risky` | Deliverable but lower quality: role account or MX-via-A-fallback | ⚠️ Send with care / segment |
| `invalid` | Bad syntax, disposable, or no mail server | ❌ Drop it |

***

### 🆚 How this compares to other email verifiers

**vs. SMTP "ping" verifiers** — Tools that connect to the mailbox over port 25 are slow, frequently blocked by cloud providers, and risk getting your sending IPs blacklisted. This Actor filters out the vast majority of bad addresses (bad syntax, dead domains, disposable, role, typos) safely — no risky probing.

**vs. paid SaaS verifiers** — Same core checks (syntax, MX, disposable, role, free, typo) but on **pay-per-result Apify pricing** with CSV/Excel/JSON export and full API access — no monthly subscription or per-seat fees.

**vs. doing nothing** — Sending to an unverified list spikes your bounce rate, which damages your domain reputation and lands future emails in spam. A quick verification pass keeps your deliverability healthy.

***

### ❓ FAQ

**Does it confirm the exact mailbox exists?**
It confirms the domain can receive mail (MX/A) and filters syntax, disposable, role, and typo issues — the checks that remove the overwhelming majority of bounces — without the risky SMTP probing that gets sender IPs blacklisted. For most outreach, that's the right tradeoff between accuracy and safety.

**Why is a valid-looking Gmail address marked "risky"?**
Role accounts (`info@`, `sales@`, etc.) and addresses that only resolve via an A-record fallback are flagged `risky` because they have lower deliverability/response quality — not because they're necessarily bad. You decide whether to include them.

**Can I feed it the output of a scraper?**
Yes. Pass the dataset items as `emails` and set `emailField`. It pairs perfectly with the **YouTube Creator Email Finder** and **Website Contact Scraper**.

**How fast is it?**
DNS lookups run in parallel with per-domain caching, so large lists with many repeated domains are processed quickly.

**How many emails can I verify?**
As many as you like — paste or pipe a large list and the Actor streams results as it goes.

***

### 🔁 Pairs well with

- **YouTube Creator Email Finder** → get creator emails, then verify them here
- **Website Contact Scraper** → scrape emails, then clean them before outreach
- Any lead-scraping Actor → verification is the natural last step before you send

***

#### Keywords

email verifier, email validator, bulk email verification, verify email address, validate email list, email list cleaning, mx record checker, dns email check, disposable email detector, temporary email checker, role account detector, reduce bounce rate, email deliverability tool, clean email list, check email valid, bulk email checker, email validation api, verify emails bulk, email scrubbing tool.

***

### Changelog

- **2026-06-01** — Maintenance & reliability pass: pulled the latest source and rebuilt the Actor on the current base image; build verified.

*Last reviewed: 2026-06-01.*

# Actor input Schema

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

List of email addresses to verify. You can also pass objects (e.g. piped from another Actor) and set the field name below.

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

Optionally paste emails separated by spaces, commas, semicolons or new lines. Combined with the list above.

## `emailField` (type: `string`):

If you pass objects in 'Emails', the property holding the address (default: email).

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

Parallel DNS lookups (1-50).

## Actor input object example

```json
{
  "emails": [
    "business@mkbhd.com",
    "info@gmail.com",
    "test@gmial.com",
    "hello@mailinator.com",
    "noreply@thisdomaindoesnotexist1234.com"
  ],
  "emailField": "email",
  "concurrency": 20
}
```

# Actor output Schema

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

Dataset with per-email status, score and signals (syntax, MX, disposable, role, typo).

# 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": [
        "business@mkbhd.com",
        "info@gmail.com",
        "test@gmial.com",
        "hello@mailinator.com",
        "noreply@thisdomaindoesnotexist1234.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/bulk-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": [
        "business@mkbhd.com",
        "info@gmail.com",
        "test@gmial.com",
        "hello@mailinator.com",
        "noreply@thisdomaindoesnotexist1234.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("logiover/bulk-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": [
    "business@mkbhd.com",
    "info@gmail.com",
    "test@gmial.com",
    "hello@mailinator.com",
    "noreply@thisdomaindoesnotexist1234.com"
  ]
}' |
apify call logiover/bulk-email-verifier --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bulk Email Verifier & Validator – Clean Your List",
        "description": "Verify and validate emails in bulk before outreach. Checks syntax, MX/DNS records, disposable & temporary domains, role accounts, free providers and typos. Cuts bounce rate and protects sender reputation. CSV/Excel/JSON in & out.",
        "version": "1.0",
        "x-build-id": "iqRWLQ528gFRU2gbe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~bulk-email-verifier/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-bulk-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/logiover~bulk-email-verifier/runs": {
            "post": {
                "operationId": "runs-sync-logiover-bulk-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/logiover~bulk-email-verifier/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-bulk-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",
                "properties": {
                    "emails": {
                        "title": "Emails",
                        "type": "array",
                        "description": "List of email addresses to verify. You can also pass objects (e.g. piped from another Actor) and set the field name below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "emailsText": {
                        "title": "Emails (paste)",
                        "type": "string",
                        "description": "Optionally paste emails separated by spaces, commas, semicolons or new lines. Combined with the list above."
                    },
                    "emailField": {
                        "title": "Email field name",
                        "type": "string",
                        "description": "If you pass objects in 'Emails', the property holding the address (default: email).",
                        "default": "email"
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Parallel DNS lookups (1-50).",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```