# Bulk Email Verifier - $0.50/1K - Validate & Score Email Lists (`mamies/bulk-email-verifier`) Actor

Verify email lists in bulk: syntax, MX/DNS, disposable, role-based, free-provider and typo detection with a 0-100 quality score per address. Clean statuses (valid / risky / invalid / unknown), did-you-mean fixes, malformed rows checked free.

- **URL**: https://apify.com/mamies/bulk-email-verifier.md
- **Developed by:** [Mamies Tech](https://apify.com/mamies) (community)
- **Categories:** Lead generation, Automation, MCP servers
- **Stats:** 4 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 email verifieds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Bulk Email Verifier — $0.50 / 1,000 emails

Clean your email lists before you send. Paste up to 100,000 addresses (or point the actor at any other actor's results) and get one clean record per email: a **valid / risky / invalid / unknown** status, a **0–100 quality score**, the reason behind the verdict, and a **did-you-mean fix** for typo'd addresses — at **$0.50 per 1,000 emails**, with **malformed rows checked free**.

Lower bounce rates protect your sender reputation, keep you out of spam folders, and stop you paying your email platform for dead contacts.

### What we check — and what we don't

**We check:** syntax and normalization · typo detection with did-you-mean fixes · disposable/temp-mail domains · role-based and no-reply inboxes · free-provider detection · **live DNS**: MX mail-server records, null-MX (domains that refuse all mail), A-record fallback, SPF and DMARC authentication health · a 0–100 score built from all of it.

**We don't (currently):** a live SMTP mailbox probe — the "does john@ exist on this server" handshake. The `smtp` field in every record honestly reports `unknown`. Cloud platforms block the network port that check requires, which affects **every** verification actor on Apify, regardless of what their listings claim — most quietly return "unknown" or "catch\_all" dressed up in a score. We say it plainly instead, and we cap DNS-evidence scores at 85: scores of 86–100 are reserved for SMTP-confirmed mailboxes, so a score from this actor is never overstated.

### What you get

One record per unique email address (duplicates are removed and never double-charged):

```json
{
  "email": "jane@gmial.com",
  "normalizedEmail": "jane@gmial.com",
  "domain": "gmial.com",
  "status": "invalid",
  "subStatus": "typo_domain",
  "score": 0,
  "didYouMean": "jane@gmail.com",
  "syntaxValid": true,
  "mxFound": false,
  "smtp": "unknown",
  "catchAll": null,
  "disposable": false,
  "roleBased": false,
  "freeProvider": false,
  "hasTag": false,
  "mxRecords": [],
  "spf": null,
  "dmarc": null
}
```

| Field | Meaning |
|---|---|
| `status` | `valid` — safe to send · `risky` — deliverable but risky (shared inbox, catch-all, throwaway) · `invalid` — do not send · `unknown` — could not be determined |
| `subStatus` | The specific reason: `mx_verified`, `no_mx_record`, `typo_domain`, `disposable`, `domain_rejects_mail`, `bad_syntax`, … |
| `score` | 0–100 deliverability quality score — sort by it, pick your own cut-off |
| `didYouMean` | Suggested fix for mistyped providers (`gmial.com` → `gmail.com`) |
| `mxFound` / `mxRecords` | Whether the domain runs mail servers, and which ones |
| `disposable` | Throwaway/temp-mail domain (10-minute inboxes, mailinator, …) |
| `roleBased` | Shared inbox (`info@`, `support@`, `noreply@`, …) — risky for outreach |
| `freeProvider` | Consumer provider (Gmail, Yahoo, Outlook, …) rather than a company mailbox |
| `hasTag` | Address contains a `+tag` (often signup filters) |
| `spf` / `dmarc` | Domain email-authentication health — a spam-filter signal |
| `smtp` / `catchAll` | Mailbox-level SMTP probe result — currently always `unknown`/`null`, see "What we check" above |

Export as CSV/Excel with one click, or append `?format=csv` / `?format=xlsx` to the dataset URL.

### Statuses you can act on

- **valid** → keep. The domain provably receives mail and the address shape is good.
- **risky** → send with care: shared `info@` inboxes, catch-all domains, disposable services.
- **invalid** → delete. Bad syntax, mistyped provider, no mail server, or a domain that refuses all mail (null MX).
- **unknown** → the evidence was inconclusive (DNS timeout, bare-A-record domain). Not charged less — but honestly labeled instead of guessed.

### Verify results from other actors — zero copy-paste

Under **Advanced**, paste the dataset ID of any finished run and the verifier pulls addresses automatically:

- [Website Contact Scraper](https://apify.com/mamiestech/website-contact-scraper) → set **Email field name** to `emails`
- Google Maps scraper runs with email enrichment → leave it as `email`

Scrape → find contacts → verify, all inside Apify.

### Pricing — no surprises

- **$0.50 per 1,000 verified emails** ($0.0005 each), pay-per-event. No subscription tiers, no platform-usage add-ons.
- **Free:** malformed rows (`not-an-email`), duplicate rows, and every re-run of the same unique address in one run.
- Set a **maximum cost** on any run (`maxTotalChargeUsd`) — the run stops cleanly at your cap and you keep everything delivered up to it.

### How it works

Each address goes through: syntax & normalization → typo detection → disposable & role checks → live DNS (MX records, RFC 7505 null-MX, A-record fallback, SPF/DMARC) → scoring. The `smtp` and `catchAll` fields are reserved for our upcoming SMTP relay tier and report `unknown`/`null` until then — see "What we check — and what we don't" above.

### FAQ

**Is this GDPR-safe?** The actor never sends email and never stores your list beyond the run's dataset, which you control and can delete.

**What's a catch-all domain?** One that accepts mail for *any* address — a "yes" there can't prove your specific contact exists, so it's `risky`.

**Why is `info@` risky and not invalid?** It usually delivers — but shared inboxes convert poorly and complain often, so outreach tools treat them as risky.

**How many emails per run?** Up to 100,000. Need more? Split the list or run several inputs in parallel.

***

*Keywords: email verification, email validator, bulk email checker, email list cleaning, verify email addresses, MX record check, disposable email detection, catch-all detection, email deliverability, reduce bounce rate, ZeroBounce alternative, NeverBounce alternative.*

# Actor input Schema

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

One email address per line. Duplicates are removed automatically — you're charged once per unique address, and malformed rows are checked for free.

## `datasetId` (type: `string`):

Dataset ID (or username/dataset-name) of any actor run whose results contain email addresses. Verified emails are ADDED to any pasted list above.

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

Name of the dataset field holding the email address. The field may contain a single address or a list — use "emails" for Website Contact Scraper output.

## Actor input object example

```json
{
  "emails": [
    "john.doe@gmail.com",
    "support@apify.com",
    "email@example.com"
  ],
  "emailField": "email"
}
```

# Actor output Schema

## `verifiedEmails` (type: `string`):

One record per unique email — status (valid / risky / invalid / unknown), sub-status reason, 0-100 quality score, did-you-mean typo fix, and per-check flags (syntax, MX, SMTP, catch-all, disposable, role-based, free provider, +tag, SPF, DMARC). Append ?format=csv or ?format=xlsx to the URL for spreadsheet exports.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "emails": [
        "john.doe@gmail.com",
        "support@apify.com",
        "email@example.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("mamies/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": [
        "john.doe@gmail.com",
        "support@apify.com",
        "email@example.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("mamies/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": [
    "john.doe@gmail.com",
    "support@apify.com",
    "email@example.com"
  ]
}' |
apify call mamies/bulk-email-verifier --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/e6OhHXchPriHzFzat/builds/Mt45wz0KJqFtOsmRe/openapi.json