# Bulk Email Verifier - Deliverability Score, No API Key (`flash_scraper/email-verifier`) Actor

Bulk email verifier with no API key that never sends email. Checks syntax, MX records (DNS-over-HTTPS), disposable & role accounts, plus free webmail, then scores deliverability 0-100 (deliverable/risky/undeliverable) to clean lists & cut bounces. Read-only. Export CSV/JSON/Excel.

- **URL**: https://apify.com/flash\_scraper/email-verifier.md
- **Developed by:** [Flash Scrape](https://apify.com/flash_scraper) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 4 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.70 / 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 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 — verify email addresses in bulk with syntax, MX, disposable & role checks

Verify email addresses in bulk before your next cold-email campaign — **no API key, no subscription, and it never sends a single email**. Paste a list, get back a clear `deliverable` / `risky` / `undeliverable` status, a reason code, and a 0–100 deliverability score for every address, at **$1 per 1,000 verified emails**. Built for list hygiene: cut bounces, protect your sender reputation, and stop paying to email dead inboxes.

### What does it do?

For every email address in your list, the actor runs a fast, read-only verification pipeline:

- **Syntax validation** — RFC-style format check (length limits, local part, domain shape)
- **MX record lookup** — resolves the domain's mail servers over DNS-over-HTTPS (Google and Cloudflare resolvers), so it works from any network without port-25 access
- **Disposable domain detection** — flags temporary inboxes (mailinator, yopmail, guerrillamail, temp-mail and ~70 other domains)
- **Role account detection** — flags generic mailboxes like `info@`, `sales@`, `support@`, `noreply@`, `admin@` that convert poorly and bounce often
- **Free webmail detection** — labels gmail, outlook, yahoo, icloud, proton and other consumer providers so you can separate B2B from personal addresses
- **Normalization + deduping** — trims, lowercases, and (optionally) drops case-insensitive duplicates before verifying

Input is flexible: an array of strings, one address per line, or a single comma/space/newline-separated blob. Verification runs in parallel (configurable concurrency) with per-domain MX caching, so large lists finish quickly.

### Use cases

- **Cold outreach list cleaning** — run every scraped or purchased list through the verifier and keep only `deliverable` rows; bounces above ~2–3% get your domain flagged by Google and Microsoft.
- **Sales prospecting pipelines** — chain it after a lead scraper so every contact you hand to sales already has a verified, scored email.
- **Lead-gen agencies** — deliver client lists with a `status` and `score` column attached; verified lists command higher prices than raw scrapes.
- **CRM hygiene** — export your CRM's email column quarterly, verify it, and archive contacts whose domains no longer accept mail.
- **Form-signup filtering** — batch-check new signups and quarantine disposable domains before they hit your product analytics or drip campaigns.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `emails` | array | *(required)* | List of email addresses to verify. You can paste them one per line, or pass an array. Also accepts a single comma/space/newline-separated string. |
| `concurrency` | integer | `20` | How many emails to verify in parallel (1–100). |
| `dedupe` | boolean | `true` | Drop duplicate addresses (case-insensitive) before verifying. |
| `includeInvalid` | boolean | `true` | Keep malformed addresses in the results (flagged undeliverable) instead of dropping them. |

Example input:

```json
{
  "emails": ["john@apify.com", "info@stripe.com", "noreply@gmail.com", "test@mailinator.com"],
  "concurrency": 20,
  "dedupe": true,
  "includeInvalid": true
}
```

Only `emails` is required.

### Output

One dataset row per verified address. Export to CSV, JSON, or Excel, or pull results via the Apify API.

```json
{
  "email": "John@Apify.com",
  "normalized": "john@apify.com",
  "status": "deliverable",
  "score": 75,
  "reason": "ok",
  "syntax_valid": true,
  "domain": "apify.com",
  "is_free": false,
  "is_role": false,
  "is_disposable": false,
  "mx_found": true,
  "mx_host": "aspmx.l.google.com"
}
```

Status and score map to a fixed, transparent rubric:

| status | reason | score | meaning |
|---|---|---|---|
| `deliverable` | `ok` | 85 (95 on Google Workspace / Microsoft 365) | Valid syntax, domain has working mail servers, no risk flags |
| `risky` | `role_address` | 60 | Generic mailbox (`info@`, `sales@`, ...) — deliverable but low-value for outreach |
| `risky` | `mx_lookup_failed` | 20 | The DNS lookup itself did not complete — **unknown**, not a confirmed failure. Re-run these rather than discarding them. |
| `undeliverable` | `no_mx_record` | 15 | Domain has no mail servers — mail cannot be delivered |
| `undeliverable` | `disposable_domain` | 5 | Temporary/throwaway domain |
| `undeliverable` | `invalid_syntax` | 0 | Malformed address |

#### Example output

A real sample from a live run:

| email | status | score | reason | is\_disposable | mx\_found |
|---|---|---|---|---|---|
| invalid@@bademail | undeliverable | 0 | invalid\_syntax | false | false |
| test@mailinator.com | risky | 15 | disposable | true | true |
| hello@shopify.com | risky | 55 | role\_address | false | true |
| info@stripe.com | risky | 55 | role\_address | false | true |

### Pricing

This actor uses **Apify pay-per-event pricing**: a `result` event is charged for each verified email in the dataset — **$1 per 1,000 verified emails** at the base tier. No subscription, no minimums, and no charge for runs that produce nothing. A **free Apify plan is enough to try it** — the platform's free monthly credit covers thousands of verifications, so you can clean a real list before paying anything.

### Tips & FAQ

#### Does it do a full SMTP handshake with the mail server?

No — and the README won't pretend otherwise. This verifier checks **syntax and MX/DNS only** (plus disposable/role/free classification). It confirms the *domain* accepts mail, not that the specific *mailbox* exists. That's why a clean pass caps at a score of 75, not 100. The upside: it's read-only, sends nothing, needs no proxies or port 25, and never risks your IP reputation. For high-stakes sends, treat `deliverable` as "safe to include", and let your email tool's soft-bounce handling catch the remaining mailbox-level misses.

#### Can a `deliverable` email still bounce?

Yes, occasionally. A domain can have valid MX records while the individual mailbox is full, disabled, or never existed (catch-all domains are the usual culprit). MX-level verification typically removes the large majority of bounces from a scraped list, but it can't guarantee zero.

#### Why are role accounts marked `risky` rather than `undeliverable`?

`info@` and `sales@` mailboxes usually work — they're flagged because they're shared inboxes with low reply rates, and some ESPs penalize campaigns heavy on role addresses. Filter them out with the `is_role` column if your tooling dislikes them, or keep them for local-business outreach where they're often the only address available.

#### How big a list can I verify in one run?

There's no hard input cap. Verification is parallel (up to `concurrency: 100`) and MX lookups are cached per domain, so lists that share domains verify especially fast. For very large jobs, splitting into runs of a few tens of thousands keeps datasets easy to export.

#### What happens to malformed addresses?

With `includeInvalid: true` (the default) they stay in the output flagged `undeliverable / invalid_syntax` with a score of 0 — useful for auditing what was wrong with a source list. Set it to `false` to drop them silently. Note that every row pushed to the dataset is a charged result.

#### Does it need proxies or an API key?

No. MX resolution goes over DNS-over-HTTPS to Google and Cloudflare, which works from any IP, including datacenter IPs, with nothing to configure.

### Related actors

- [Email Pattern Finder](https://apify.com/flash_scraper/email-pattern-finder) — discover a company's email format when you have names but no addresses, then verify the guesses here
- [Hotel & Host Leads Scraper](https://apify.com/flash_scraper/hotel-host-leads-scraper) — accommodation owner leads with emails worth verifying before outreach
- [Restaurant Leads Scraper](https://apify.com/flash_scraper/restaurant-leads-scraper) — restaurant leads by city and tech stack, a natural upstream source for this verifier

Found a bug or need a feature? Open an issue on the actor's **Issues tab** — typical response within 1 business day.

# Actor input Schema

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

List of email addresses to verify. You can paste them one per line, or pass an array. Also accepts a single comma/space/newline-separated string.

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

How many emails to verify in parallel.

## `dedupe` (type: `boolean`):

Drop duplicate addresses (case-insensitive) before verifying.

## `includeInvalid` (type: `boolean`):

Keep malformed addresses in the results (flagged undeliverable) instead of dropping them.

## Actor input object example

```json
{
  "emails": [
    "john@apify.com",
    "info@stripe.com",
    "noreply@gmail.com",
    "test@mailinator.com"
  ],
  "concurrency": 20,
  "dedupe": true,
  "includeInvalid": true
}
```

# Actor output Schema

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

No description

# 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@apify.com",
        "info@stripe.com",
        "noreply@gmail.com",
        "test@mailinator.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("flash_scraper/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@apify.com",
        "info@stripe.com",
        "noreply@gmail.com",
        "test@mailinator.com",
    ] }

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

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/l7pi8rVmQ4bvyY9Jl/builds/GbZLgIGWTVbYuuJb4/openapi.json