# Free Email Verifier & Bulk Email Checker (`quantifiable_toccata/email-list-verifier`) Actor

Free email verifier and bulk email checker: syntax validation, MX check, disposable email detection, role-account flags, and typo suggestions. No SMTP mailbox check.

- **URL**: https://apify.com/quantifiable_toccata/email-list-verifier.md
- **Developed by:** [n1](https://apify.com/quantifiable_toccata) (community)
- **Categories:** Developer tools, Lead generation, Automation
- **Features:** Limited permissions
- **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/actors/running/actors-in-store.md#pay-per-usage

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Free Email Verifier & Bulk Email Checker (MX + Disposable)

Free **email verifier** and **bulk email checker** for mailing lists and lead exports. Paste addresses or a CSV and get one result row per email: syntax validation, **MX check** (DNS), **disposable email detection**, role-account flags, and common typo suggestions (`gmial.com` → `gmail.com`).

This Actor does **not** perform an SMTP mailbox check. It never talks to the receiving mail server, so it cannot prove that a specific inbox exists. That keeps each run fast, private, and free of mailbox-probe abuse.

**Price:** the Actor itself is free (you only pay your own Apify platform usage). No third-party verification API and no per-email fee from us.

Try it: [apify.com/quantifiable_toccata/email-list-verifier](https://apify.com/quantifiable_toccata/email-list-verifier)

### Why use this email verifier?

- **Free bulk email checker** — validate a list without paying a per-address verification API
- **Email validation (syntax)** — catch missing `@`, illegal characters, and malformed domains
- **MX check** — look up Mail Exchange DNS records, with an A-record fallback
- **Disposable email detection** — flag throwaway domains such as Mailinator, YOPmail, and 10MinuteMail
- **Role-account flags** — mark `info@`, `admin@`, `sales@`, `noreply@`, and similar shared mailboxes
- **Typo suggestions** — frequent mistakes on Gmail, Outlook, Hotmail, Yahoo, iCloud, and Proton Mail
- **CSV-friendly** — paste a CSV with an `email` column, or any cells that contain `@`
- **Privacy-friendly** — no SMTP probing and no forwarding of your list to another vendor

### Use cases

1. **Clean a newsletter list before a send** — drop addresses that cannot receive mail (bad syntax or no MX) and review the risky ones.
2. **Filter disposable sign-ups** — catch throwaway inboxes used on registration forms.
3. **Pre-check exported or scraped leads** — remove obvious invalids and `gmial.com`-style typos before you pay a deeper SMTP verifier.
4. **Separate role accounts** — distinguish personal inboxes from shared `support@` / `info@` mailboxes.
5. **Bulk email validation via API** — run the Actor from a script or automation with the Apify API.

Use this only on lists you have the right to process (consent or another lawful basis). The Actor does not send email and is not a tool for unsolicited outreach.

### How the bulk email checker works

For each address the Actor:

1. **Normalizes** — trim whitespace and lowercase
2. **Checks syntax** — practical RFC-style rules (not a full RFC 5322 parser)
3. **Detects disposable / throwaway domains** — offline match against a bundled public list
4. **Flags role accounts** — `info@`, `admin@`, `noreply@`, `support@`, `sales@`, and others
5. **Runs an MX check** — DNS MX lookup, then A if there is no MX; results are cached per domain. If the local resolver looks intercepted, it retries over DNS-over-HTTPS (Cloudflare / Google)
6. **Suggests typo corrections** for common mistakes on major providers

Input is deduplicated (case-insensitive) when you mix a list and a CSV.

If you start a run with empty input, the Actor verifies a tiny built-in demo sample so the dataset is never empty (useful for the Store “try it” prefill and Apify’s daily quality check).

### Honest limits (please read)

- **No SMTP mailbox check.** We never open an SMTP conversation (`RCPT TO`) with the destination server. A `valid` result does **not** prove that `jane.doe@gmail.com` is a real mailbox, a catch-all, or an inbox that can still receive mail.
- **Disposable email detection** depends on the bundled list. Brand-new throwaway domains can be missed until the list is updated.
- **DNS timeouts** return `status=unknown` instead of guessing `invalid`.
- **Typo suggestions** cover frequent mistakes on major consumer providers only.
- This is a **first-pass email validation** tool. If you need mailbox-level deliverability, use a dedicated SMTP verifier after this filter.

### Status values

| Status | Meaning |
|--------|---------|
| `valid` | Syntax OK, MX/A found, not disposable, not a role account, no typo flag |
| `invalid` | Bad syntax, or the domain has no MX and no A record |
| `risky` | Disposable domain, role account, and/or likely typo |
| `unknown` | DNS timed out or errored; syntax is otherwise OK |

### Example input

```json
{
  "emails": [
    "hello@example.com",
    "info@gmail.com",
    "user@mailinator.com",
    "alice@gmial.com",
    "not-an-email"
  ],
  "csvText": "email,name\nbob@example.org,Bob\n",
  "concurrency": 10,
  "checkMx": true
}
```

- `emails` — list of addresses to verify (one per item)
- `csvText` — optional CSV; if a column is named `email`, `e-mail`, or `mail`, that column is used, otherwise any cell containing `@` is collected
- `concurrency` — parallel DNS lookups, 1–50 (default 10)
- `checkMx` — set to `false` for a syntax-only + disposable + role pass (default `true`)

### Example output

One dataset item per input address:

```json
{
  "email": "alice@gmial.com",
  "normalized": "alice@gmial.com",
  "status": "risky",
  "reasons": ["possible_typo", "no_mx_or_a"],
  "mx_found": false,
  "disposable": false,
  "role": false,
  "suggestion": "alice@gmail.com"
}
```

```json
{
  "email": "user@mailinator.com",
  "normalized": "user@mailinator.com",
  "status": "risky",
  "reasons": ["disposable_domain"],
  "mx_found": true,
  "disposable": true,
  "role": false,
  "suggestion": null
}
```

```json
{
  "email": "hello@example.com",
  "normalized": "hello@example.com",
  "status": "valid",
  "reasons": ["syntax_ok_mx_found"],
  "mx_found": true,
  "disposable": false,
  "role": false,
  "suggestion": null
}
```

Export the dataset as JSON, CSV, or Excel from the run page.

### FAQ

#### Is this email verifier free?

Yes. The Actor charges no per-email fee. On Apify you only pay platform usage for the run; the free Apify plan includes monthly usage credit. No card is required to try it on that free plan.

#### Does it check if the mailbox really exists?

No. There is **no SMTP mailbox check**. `valid` means the address looks well-formed and the domain advertises mail servers at the DNS level (MX or A), not that the inbox exists.

#### What is an MX check?

An MX (Mail Exchange) DNS record tells the internet which server receives mail for a domain. If a domain has no MX and no A record, mail cannot be delivered there. That is what this bulk email checker tests.

#### How does disposable email detection work?

The Actor compares the domain to a bundled list of known throwaway providers (Mailinator, YOPmail, and many others). The list is used offline — your addresses are not sent to a third-party disposable-email API.

#### How many emails can I check in bulk?

There is no extra product cap beyond the run timeout and memory (defaults: 5 minutes, 512 MB). Start with a few hundred addresses and scale up. DNS lookups are cached per domain, so many addresses at the same company stay cheap.

#### Why is `info@gmail.com` marked risky?

`info@` is a role account. Shared or unmonitored role mailboxes are flagged `risky` even when the domain itself is fine.

#### Do you keep my email list?

Addresses are processed only for the duration of the run. Results live in that run’s Apify dataset. The Actor does not send the list to another verification vendor and does not keep its own permanent store.

#### Can I call this as an email validation API?

Yes. Use the Apify API (`run-sync-get-dataset-items`) or the official JavaScript / Python client. See the API section on the Store page.

### Privacy

- Emails are processed only for the duration of the run.
- Results live in the run’s **dataset** (Apify storage for that run).
- The Actor does **not** send addresses to any third-party verification API.
- You remain responsible for having a lawful basis to process the addresses (GDPR and similar rules still apply to you as the operator).

### Pricing

The Actor is free to use during this demand test (listed as pay-per-usage with no extra Actor fee). If real demand appears, a low pay-per-result or rental price may be added later. The Store page always shows the current price before you run it.

# Actor input Schema

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

Bulk email checker input: one address per item. Used for email verification (syntax, MX check, disposable email detection). Leave empty only if you pass CSV text instead.

## `csvText` (type: `string`):

Optional CSV for bulk email validation. If a column is named email / e-mail / mail, that column is used; otherwise any cell containing @ is collected.

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

Max parallel MX / DNS lookups (1–50). Higher values speed up bulk email checking.

## `checkMx` (type: `boolean`):

Look up MX records (fallback A) for each domain. Cached per domain. Disable for a syntax-only + disposable + role pass. This is an MX check only — not an SMTP mailbox check.

## Actor input object example

```json
{
  "emails": [
    "hello@example.com",
    "info@gmail.com",
    "user@mailinator.com",
    "alice@gmial.com",
    "not-an-email"
  ],
  "csvText": "email,name\nhello@example.com,Alice\nbad@gmial.com,Bob\n",
  "concurrency": 10,
  "checkMx": true
}
```

# Actor output Schema

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

Dataset with one row per verified email (bulk email checker output).

# 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": [
        "hello@example.com",
        "info@gmail.com",
        "user@mailinator.com",
        "alice@gmial.com",
        "not-an-email"
    ],
    "csvText": `email,name
hello@example.com,Alice
bad@gmial.com,Bob`
};

// Run the Actor and wait for it to finish
const run = await client.actor("quantifiable_toccata/email-list-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": [
        "hello@example.com",
        "info@gmail.com",
        "user@mailinator.com",
        "alice@gmial.com",
        "not-an-email",
    ],
    "csvText": """email,name
hello@example.com,Alice
bad@gmial.com,Bob
""",
}

# Run the Actor and wait for it to finish
run = client.actor("quantifiable_toccata/email-list-verifier").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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": [
    "hello@example.com",
    "info@gmail.com",
    "user@mailinator.com",
    "alice@gmial.com",
    "not-an-email"
  ],
  "csvText": "email,name\\nhello@example.com,Alice\\nbad@gmial.com,Bob\\n"
}' |
apify call quantifiable_toccata/email-list-verifier --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,quantifiable_toccata/email-list-verifier"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/0mentBbeHiZIw091V/builds/3HcIB6omlDO1xC6za/openapi.json