# Bulk Email Validator (`properscraper/bulk-email-validator`) Actor

Check a list of email addresses without sending anything: valid format, whether the domain exists and accepts mail (MX records), disposable addresses, free providers, role accounts and likely typos.

- **URL**: https://apify.com/properscraper/bulk-email-validator.md
- **Developed by:** [jake mcclure](https://apify.com/properscraper) (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.20 / 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 Validator

Check a list of email addresses before you use it. For each address the Actor tells you whether the format is valid, whether the domain exists and has a mail server, and whether it is a disposable address, a free provider or a shared mailbox such as `info@`. It also suggests a fix for common typos such as `gmial.com`.

It sends no email and never connects to anyone's mail server. It checks the address's format and looks up the domain's public DNS records.

Use it to:

- clean a mailing list before a campaign, to cut bounces
- catch typos and throwaway addresses in sign-up or lead lists
- sort business addresses from free-provider addresses
- see which mail provider (Google, Microsoft 365 and others) each company uses

### Input

| Field | What it does |
|---|---|
| **Email addresses** | One address per line. Repeated addresses are checked once. |
| **Only return problem addresses** | Return and charge for only the invalid, risky and unknown addresses. |

```json
{
    "emails": ["hello@apify.com", "someone@gmial.com", "x@mailinator.com", "not-an-email"]
}
```

### Output

One record per address:

```json
{
    "input": "hello@apify.com",
    "email": "hello@apify.com",
    "status": "valid",
    "reason": "ok",
    "validSyntax": true,
    "domain": "apify.com",
    "domainExists": true,
    "acceptsMail": true,
    "mxRecords": ["aspmx.l.google.com", "alt1.aspmx.l.google.com"],
    "mailProvider": "Google",
    "isDisposable": false,
    "isFreeProvider": false,
    "isRoleAccount": true,
    "didYouMean": null,
    "scrapedAt": "2026-11-12T09:00:00.000Z"
}
```

`status` is the overall result and `reason` says why:

| Status | Reason | Meaning |
|---|---|---|
| `valid` | `ok` | The format is valid and the domain has a mail server. |
| `risky` | `disposable` | The domain is a known throwaway-address service. |
| `risky` | `no_mx_record` | The domain has no mail server record, only a website address. Mail may not be delivered. |
| `invalid` | `invalid_syntax` | Not a correctly formed email address. |
| `invalid` | `domain_not_found` | The domain does not exist. |
| `invalid` | `no_mail_server` | The domain exists but cannot receive mail. |
| `unknown` | `dns_error` | The domain's DNS is not answering properly, so it could not be checked. |

Other fields:

- `email` is the address tidied up: spaces removed and the domain in lower case. It is empty when the format is invalid.
- `mxRecords` are the domain's mail servers, in the order they are tried.
- `mailProvider` names the company running the domain's mail when it can be recognised.
- `isFreeProvider` is `true` for consumer services such as Gmail, Outlook and Yahoo.
- `isRoleAccount` is `true` for shared mailboxes such as `info@`, `sales@` and `support@`.
- `didYouMean` suggests a corrected address for common typos of well-known domains.

A `SUMMARY` record in the run's key-value store gives the totals for the run.

### Pricing

Pay per result. You are charged once for each address whose result is saved to the dataset, at the per-result price shown on this page.

An address whose lookup failed because of a temporary DNS problem is not saved and not charged; it is listed in the log and the summary so you can run it again. The run stops as soon as it reaches the maximum charge you set for it.

### Limits

- **It cannot tell you whether a specific mailbox exists.** `valid` means the address is well formed and its domain can receive mail. It does not mean `jo@example.com` is a real person's inbox. Confirming that needs a connection to the recipient's mail server, which this Actor deliberately does not make: mail providers treat such probing as abuse, and the answers are unreliable.
- The disposable-domain list covers tens of thousands of services but new ones appear all the time.
- Addresses in unusual but legal formats, such as a quoted name part (`"jo smith"@example.com`), are reported as invalid.
- Typo suggestions cover common slips on the most used providers only.

### Is this allowed?

The Actor reads public DNS records through a public DNS service, which is how every mail server finds out where to deliver mail. It contacts no mail server and sends nothing to the addresses you check. The addresses you supply are processed only within your run and saved only to your own dataset. You are responsible for having the right to hold and process them.

# Actor input Schema

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

One address per line. Repeated addresses are checked once.

## `onlyProblems` (type: `boolean`):

Leave out addresses that passed every check, and return (and charge for) only the invalid, risky and unknown ones.

## Actor input object example

```json
{
  "emails": [
    "hello@apify.com",
    "someone@gmial.com",
    "not-an-email"
  ],
  "onlyProblems": false
}
```

# Actor output Schema

## `emails` (type: `string`):

One record per email address checked.

## `summary` (type: `string`):

Totals for the run and, for each batch of addresses, how many results were saved and any error.

# 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@apify.com",
        "someone@gmial.com",
        "not-an-email"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("properscraper/bulk-email-validator").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@apify.com",
        "someone@gmial.com",
        "not-an-email",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("properscraper/bulk-email-validator").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@apify.com",
    "someone@gmial.com",
    "not-an-email"
  ]
}' |
apify call properscraper/bulk-email-validator --silent --output-dataset

```

## MCP server setup

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

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/Fq3PPSssPXmip4nUm/builds/uO2Vbd4ePRK2FSFos/openapi.json
