# Bulk Email Validator - MX, Disposable, Role & Typo Check (`transparent_meteorite/bulk-email-verifier`) Actor

Bulk email validator and list cleaner: syntax, MX records, disposable domains, role accounts, typo hints, free-provider flag, SPF and DMARC per address. No API key, no email sent.

- **URL**: https://apify.com/transparent_meteorite/bulk-email-verifier.md
- **Developed by:** [Detroit Web Agent - Open Data](https://apify.com/transparent_meteorite) (community)
- **Categories:** Lead generation, Developer tools
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

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

## Bulk Email Validator: MX, Disposable, Role & Typo Check

Use this to clean an email list before you send to it. Paste addresses, press Start, and get one row per address with a verdict (`valid`, `risky`, `invalid`), a 0-100 score and a plain-English reason. It checks syntax, whether the domain has a mail server (MX record), whether the domain is a disposable or throwaway one, whether the address is a role account (info@, sales@), and whether the domain looks like a typo of a big provider (gmial.com, hotmial.com, .con).

It needs no API key, no login and no proxy, and it never sends an email.

### Run in 30 seconds

1. Open the **Input** tab. The prefilled list (26 addresses: real company mailboxes, disposable domains, typos and malformed lines) is a ready-to-run test.
2. Click **Start**. The default run normally finishes in well under a minute.
3. Open the **Emails** table in the Output tab, or download the dataset as JSON, CSV, Excel or HTML.
4. Replace the list with yours and run again.

### What does this Actor do?

For every address the Actor returns a flat, spreadsheet-ready row:

| Group | Fields |
|---|---|
| Verdict | `status` (`valid`, `risky`, `invalid`), `score` (0-100), `reason` |
| Syntax | `syntaxValid`, `domain` |
| Mail server | `mxFound`, `mxHost` (lowest-priority-number MX, falling back to the A record) |
| Flags | `disposable`, `roleAccount`, `freeProvider`, `didYouMean` (for example gmial.com becomes gmail.com) |
| Domain mail policy | `spf`, `dmarc` |
| Mailbox probe (experimental) | `smtpCheck`, `catchAll` |

A run also saves a summary to the key-value store under `OUTPUT`: unique addresses, duplicates skipped, counts by status, and any warnings.

### Limits: what this can and cannot tell you

- **It does not confirm that a mailbox exists.** Confirming a single mailbox needs an outbound connection on port 25, which Apify and most cloud networks block. A `valid` verdict means: the syntax is right, the domain has a working mail setup, and it is not a disposable domain. It does not mean the person reads that mail.
- **Experimental mailbox probe.** The optional `smtpCheck` input tries the port-25 handshake anyway. On Apify it normally reports `blocked` and the row falls back to the domain-level result. Nothing is guessed.
- **No email is sent.** Ever.
- **Role accounts** such as info@ and sales@ are valid mailboxes but often shared or filtered. They lose 15 points and are flagged, not rejected.
- The disposable-domain list is bundled in the Actor and is a snapshot, so brand-new throwaway domains may be missed.

### Input

| Field | What it does |
|---|---|
| `emails` | One address per line. Blank lines and duplicates are skipped and not charged. |
| `smtpCheck` | Experimental port-25 mailbox probe. Default off, see Limits. |
| `catchAllCheck` | With the probe, also test a random impossible address. Default off. |
| `smtpMailFrom` | Envelope sender for the experimental probe. Nothing is delivered to it. |
| `maxItems` | Stop after this many unique addresses. |

### Example input

```json
{
  "emails": ["support@apify.com", "someone@gmial.com", "test@mailinator.com", "not-an-email"],
  "maxItems": 100
}
```

### Output sample

```json
{
  "email": "dev@hotmail.con",
  "status": "invalid",
  "score": 0,
  "reason": "domain has no mail server (no MX or A record); did you mean hotmail.com",
  "syntaxValid": true,
  "domain": "hotmail.con",
  "mxFound": false,
  "disposable": false,
  "roleAccount": false,
  "didYouMean": "hotmail.com"
}
```

Your own run will show the real values for every field.

### How the score works

Start at 100, capped at 90 because the mailbox itself is not confirmed. Subtract 70 for a disposable domain, 15 for a role account and 10 for a probable typo. Bad syntax or a domain with no mail server is `invalid` (0). 80 and above is `valid`, 1 to 79 is `risky`.

### Use cases

- Clean a newsletter or cold-outreach list before sending, to cut bounces.
- Check sign-up emails in a CRM export and flag disposable addresses.
- Catch typos such as gmial.com, hotmial.com or .con endings.
- Separate role accounts from named people.

### Tips for good results

- Run a small sample first and read the `reason` column.
- Treat `risky` as "send with care", not as bad.
- Sort by `score` and review the lowest rows first.

### Field reference

`status` is the verdict. `score` is the 0-100 number described above. `mxFound` is true when the domain publishes MX records or at least an address record. `spf` and `dmarc` are true when the domain publishes those DNS records. `smtpCheck` and `catchAll` are only filled when you turn on the experimental probe and the server is reachable on port 25 (`accepted`, `rejected`, `unknown`, `blocked`, `provider_hidden`).

### Pricing and cost control

Pay per address: **$0.0008 per email on the free plan, $0.00049 on the Gold plan** (Bronze $0.00075, Silver $0.00064), plus a $0.00005 start fee per run. That is $0.80 per 1,000 emails on the free plan. Duplicates and blank lines are never charged. Use "Maximum cost per run" or `maxItems` to cap spend; the run stops cleanly at the limit.

### API and AI agents

```bash
curl -X POST "https://api.apify.com/v2/acts/transparent_meteorite~bulk-email-verifier/run-sync-get-dataset-items?token=YOUR_TOKEN"   -H "Content-Type: application/json"   -d '{"emails": ["support@apify.com", "someone@gmial.com"], "maxItems": 100}'
```

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")
run = client.actor("transparent_meteorite/bulk-email-verifier").call(run_input={"emails": ["support@apify.com"]})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row)
```

**AI agents (MCP):** add the Apify MCP server (`https://mcp.apify.com`) with this Actor enabled, then ask an assistant such as Claude or ChatGPT to "verify these 500 emails and drop the disposable ones".

### Integrations and scheduling

Send results to Google Sheets, Slack, email, Make, Zapier or n8n with the Apify integrations, or call the Actor from your code through the REST API and the Python and JavaScript clients. Open the API tab for ready-to-copy snippets.

### Fair use and legal

The Actor only analyses addresses you provide, using public DNS records and the standard mail-server handshake. It does not scrape any website, and it sends no message. You are responsible for complying with email and privacy laws (such as GDPR and CAN-SPAM) when you contact the people on your list.

### FAQ

**Does it send an email to the address?** No.

**Does it confirm the mailbox exists?** No, see Limits. It tells you whether the address is well-formed, the domain can receive mail, and the address is not a known throwaway or an obvious typo.

**Why is a good-looking address `risky`?** Usually a disposable domain or a role account. The `reason` column lists each cause.

**Are duplicates charged?** No.

**What if my list has 100,000 addresses?** Set `maxItems` high enough. If the run reaches its time limit, the Actor stops cleanly and the summary lists how many were not checked, and those are not charged.

**Do I need an API key?** No.

### Support

Found a bug or need a field? Open an issue on the Issues tab with the run URL and you will get a reply there.

### Related actors

- [libphonenumber Bulk Phone Parser](https://apify.com/transparent_meteorite/phone-number-validator-formatter) to validate the phone numbers in the same list.
- [Company Enrichment by Domain](https://apify.com/transparent_meteorite/company-enrichment-by-domain) to add firmographics to a lead list.
- [Decision Maker Finder](https://apify.com/transparent_meteorite/decision-maker-finder) to find the right contact at a company.

### Changelog

- **0.1**: First private build. Syntax, MX, disposable, role, typo, SPF and DMARC checks, plus an experimental port-25 probe.

# Actor input Schema

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

One email address per line. Duplicates and blank lines are skipped and not charged. The prefilled list mixes real company mailboxes, disposable domains, typos and malformed addresses as a ready-to-run test.

## `smtpCheck` (type: `boolean`):

Tries to connect to the recipient mail server on port 25 and ask whether it would accept the address. Most cloud networks, including Apify, block outbound port 25, so this usually reports "blocked" and falls back to the domain-level check. Leave off unless you know port 25 is open for you.

## `catchAllCheck` (type: `boolean`):

Only used with the experimental mailbox probe. Also asks about a random impossible address to detect catch-all domains.

## `smtpMailFrom` (type: `string`):

Envelope sender (MAIL FROM) for the SMTP handshake. Nothing is delivered to it. Some servers prefer a sender on a domain that exists; change it only if you see many unknown results.

## `maxItems` (type: `integer`):

Stop after this many unique emails. You are charged per email checked.

## Actor input object example

```json
{
  "emails": [
    "support@apify.com",
    "info@github.com",
    "sales@stripe.com",
    "press@mozilla.org",
    "hello@notion.so",
    "team@slack.com",
    "security@cloudflare.com",
    "contact@wikipedia.org",
    "feedback@python.org",
    "help@dropbox.com",
    "abuse@gmail.com",
    "someone@gmial.com",
    "test@mailinator.com",
    "jane.doe@10minutemail.com",
    "ceo@yopmail.com",
    "user@nonexistent-domain-xyz123.com",
    "no-reply@microsoft.com",
    "admin@example.com",
    "john.smith@outlook.com",
    "maria@yahoo.com",
    "dev@hotmail.con",
    "not-an-email",
    "two@@signs.com",
    "spaces in@name.com",
    "billing@shopify.com",
    "office@oracle.com"
  ],
  "smtpCheck": false,
  "catchAllCheck": false,
  "smtpMailFrom": "verify@example.com",
  "maxItems": 100
}
```

# Actor output Schema

## `emails` (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": [
        "support@apify.com",
        "info@github.com",
        "sales@stripe.com",
        "press@mozilla.org",
        "hello@notion.so",
        "team@slack.com",
        "security@cloudflare.com",
        "contact@wikipedia.org",
        "feedback@python.org",
        "help@dropbox.com",
        "abuse@gmail.com",
        "someone@gmial.com",
        "test@mailinator.com",
        "jane.doe@10minutemail.com",
        "ceo@yopmail.com",
        "user@nonexistent-domain-xyz123.com",
        "no-reply@microsoft.com",
        "admin@example.com",
        "john.smith@outlook.com",
        "maria@yahoo.com",
        "dev@hotmail.con",
        "not-an-email",
        "two@@signs.com",
        "spaces in@name.com",
        "billing@shopify.com",
        "office@oracle.com"
    ],
    "smtpCheck": false,
    "catchAllCheck": false,
    "smtpMailFrom": "verify@example.com",
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/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": [
        "support@apify.com",
        "info@github.com",
        "sales@stripe.com",
        "press@mozilla.org",
        "hello@notion.so",
        "team@slack.com",
        "security@cloudflare.com",
        "contact@wikipedia.org",
        "feedback@python.org",
        "help@dropbox.com",
        "abuse@gmail.com",
        "someone@gmial.com",
        "test@mailinator.com",
        "jane.doe@10minutemail.com",
        "ceo@yopmail.com",
        "user@nonexistent-domain-xyz123.com",
        "no-reply@microsoft.com",
        "admin@example.com",
        "john.smith@outlook.com",
        "maria@yahoo.com",
        "dev@hotmail.con",
        "not-an-email",
        "two@@signs.com",
        "spaces in@name.com",
        "billing@shopify.com",
        "office@oracle.com",
    ],
    "smtpCheck": False,
    "catchAllCheck": False,
    "smtpMailFrom": "verify@example.com",
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/bulk-email-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": [
    "support@apify.com",
    "info@github.com",
    "sales@stripe.com",
    "press@mozilla.org",
    "hello@notion.so",
    "team@slack.com",
    "security@cloudflare.com",
    "contact@wikipedia.org",
    "feedback@python.org",
    "help@dropbox.com",
    "abuse@gmail.com",
    "someone@gmial.com",
    "test@mailinator.com",
    "jane.doe@10minutemail.com",
    "ceo@yopmail.com",
    "user@nonexistent-domain-xyz123.com",
    "no-reply@microsoft.com",
    "admin@example.com",
    "john.smith@outlook.com",
    "maria@yahoo.com",
    "dev@hotmail.con",
    "not-an-email",
    "two@@signs.com",
    "spaces in@name.com",
    "billing@shopify.com",
    "office@oracle.com"
  ],
  "smtpCheck": false,
  "catchAllCheck": false,
  "smtpMailFrom": "verify@example.com",
  "maxItems": 100
}' |
apify call transparent_meteorite/bulk-email-verifier --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,transparent_meteorite/bulk-email-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/GsQidz1YAmYt7QIOy/builds/0LgQ4sLYnXBdcLHVQ/openapi.json
