# Email Verifier: Bulk Email Validator & MX Checker (`interconnected_seaport/bulk-email-verifier-mx`) Actor

Fast bulk email validation without sending mail: RFC syntax, DNS MX lookup, 9,800+ disposable domains, role accounts (info@, kontakt@), free providers and typo suggestions (gmial.com). Verdict + score per address. DNS only, no SMTP probing.

- **URL**: https://apify.com/interconnected_seaport/bulk-email-verifier-mx.md
- **Developed by:** [Zenith Ops](https://apify.com/interconnected_seaport) (community)
- **Categories:** Lead generation, Developer tools
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 email checkeds

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/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 Verifier & Email List Cleaner

Clean email lists with syntax checks, DNS MX/A checks, disposable-domain detection, role-account flags and typo hints. This email validation API sends no email and never uses SMTP.

### Use cases

- Clean CRM/newsletter imports before sending.
- Block disposable sign-ups and flag generic role mailboxes.
- Verify email addresses in n8n, Make, or a custom API workflow.
- Catch provider typos such as `bob@gmial.com`.

### Input

```json
{"emails":["anna.svensson@telia.com","info@scb.se","x@mailinator.com","bob@gmial.com","ceo@startup.io","john.doe@outlook.com"],"checkMx":true}
```

### Real output sample

| input | verdict | score | reasons | mxStatus | disposable | roleAccount |
|---|---:|---:|---|---|---:|---:|
| test@mailinator.com | risky | 30 | disposable_domain | mx | true | false |
| john.doe@gmail.com | valid | 100 | — | mx | false | false |
| bad@@x | invalid | 0 | invalid_syntax | — | false | false |
| support@hm.com | valid | 90 | role_account | mx | false | true |
| anna@gmial.com | risky | 1\* | no_mx_a_record_fallback, disposable_domain, possible_domain_typo | a_record_only | true | false |

Sample from a real platform run (input order differs). Current versions floor risky scores at 20. Every row includes `inputIndex`, `normalizedInput`, `input`, `email`, `reasons`, and DNS/classification fields; `input_normalized` explains a normalization.

### Verdicts and limits

`valid` means syntax passed and the domain advertises MX; it does **not** prove that an inbox exists. `risky` means disposable, probable typo, role mailbox, or A-record fallback. `invalid` means bad syntax, reserved domain, or no receiving DNS. `unknown` means DNS was inconclusive and is not charged.

There is no SMTP probing: it is slower, unreliable, and can resemble unsolicited mailbox testing. Catch-all domains cannot be identified with DNS alone. Gmail/Outlook results are domain-level checks. The free plan caps 100 checked addresses per run; capped inputs remain visible as deferred rows.

### Pricing

| List | Usage charge |
|---|---:|
| 1,000 addresses | $1 + start fee |
| 100,000 addresses | $100 + start fee |

Only successful checks are charged; duplicates, blanks, and `unknown` DNS results are not. The free-plan cap is 100 addresses.

### API and clients

```bash
curl -X POST 'https://api.apify.com/v2/acts/interconnected_seaport~bulk-email-verifier-mx/run-sync-get-dataset-items?token=YOUR_TOKEN' -H 'content-type: application/json' -d '{"emails":["a@example.com"],"checkMx":true}'
```

```js
const { ApifyClient } = require('apify-client');
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('interconnected_seaport/bulk-email-verifier-mx').call({ emails: ['a@example.com'] });
console.log(await client.dataset(run.defaultDatasetId).listItems());
```

```python
from apify_client import ApifyClient
client = ApifyClient()
run = client.actor('interconnected_seaport/bulk-email-verifier-mx').call(run_input={'emails': ['a@example.com']})
print(client.dataset(run['defaultDatasetId']).list_items().items)
```

n8n and Make can call the same Apify actor endpoint and iterate over dataset items.

### FAQ

**Does valid mean the inbox exists?** No; it means syntax is acceptable and the domain can receive mail.

**Why no SMTP?** SMTP probing is slow, often blocked, and can resemble abuse; this actor performs DNS-only checks.

**What about catch-all domains?** DNS cannot distinguish a catch-all from a real mailbox.

**Is unknown free?** Yes. DNS-inconclusive results are written but not charged.

**Can I process large lists?** Yes, subject to your plan and the free-plan cap of 100.

### GDPR and lawful use

Email addresses are personal data in many jurisdictions. Use a lawful basis, limit retention, secure exports, and honor deletion/access requests. The actor sends no mail and queries only DNS, but you remain responsible for lawful processing, consent, and provider terms. No evasion or SMTP probing is performed.

# Actor input Schema

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

Addresses to verify, one per line. 'Name <a@b.com>' and 'mailto:a@b.com' are understood. Duplicates and blank lines are skipped and not charged.

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

Look up the domain's MX (or A/AAAA fallback) records to see whether it can receive mail. Turn off for syntax/disposable/role checks only (faster, but results then carry a lower score).

## `suggestTypos` (type: `boolean`):

Flag domains that look like a misspelling of a popular provider (gmial.com -> gmail.com) and return the suggested corrected address.

## `includeMxHosts` (type: `boolean`):

Include up to three MX hostnames (lowest priority value first) per address.

## Actor input object example

```json
{
  "emails": [
    "anna.svensson@telia.com",
    "info@scb.se",
    "x@mailinator.com",
    "bob@gmial.com",
    "ceo@startup.io",
    "john.doe@outlook.com"
  ],
  "checkMx": true,
  "suggestTypos": true,
  "includeMxHosts": true
}
```

# Actor output Schema

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

One item per email: verdict (valid, risky, invalid, unknown), score 0-100, reasons, MX status and flags.

# 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": [
        "anna.svensson@telia.com",
        "info@scb.se",
        "x@mailinator.com",
        "bob@gmial.com",
        "ceo@startup.io",
        "john.doe@outlook.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("interconnected_seaport/bulk-email-verifier-mx").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": [
        "anna.svensson@telia.com",
        "info@scb.se",
        "x@mailinator.com",
        "bob@gmial.com",
        "ceo@startup.io",
        "john.doe@outlook.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("interconnected_seaport/bulk-email-verifier-mx").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": [
    "anna.svensson@telia.com",
    "info@scb.se",
    "x@mailinator.com",
    "bob@gmial.com",
    "ceo@startup.io",
    "john.doe@outlook.com"
  ]
}' |
apify call interconnected_seaport/bulk-email-verifier-mx --silent --output-dataset

```

## MCP server setup

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

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/azq0iBTAsxmWSWBwE/builds/DAe4wruEYQAJ3wQd3/openapi.json