# Bulk Email Verifier — MX, Disposable & Sendability Score (`rp_openpro.ai/bulk-email-verifier`) Actor

syntax validation, MX-record deliverability, disposable-domain detection (60+ providers), role-based and free-provider flags, and a 0–100 sendability score

- **URL**: https://apify.com/rp\_openpro.ai/bulk-email-verifier.md
- **Developed by:** [Rémi Pelloux](https://apify.com/rp_openpro.ai) (community)
- **Categories:** AI, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.30 / 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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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 — Syntax, MX, Disposable Detection & Deliverability Score

**Clean your email lists before you send.** Paste thousands of addresses and get back, for each one: a clear **status** (deliverable / undeliverable / risky / invalid), **MX-record deliverability**, **disposable-domain detection**, **role-based and free-provider flags**, and a **0–100 sendability score** — ready to filter in CSV, Excel, or your CRM.

High bounce rates destroy sender reputation and get your domain blacklisted. Verifying a list before a campaign is the cheapest insurance in email marketing — and this Actor does it in seconds, at a fraction of the price of SaaS verifiers.

---

### What each result contains

| Field | Meaning |
|---|---|
| `email` | Normalized address (lowercased, trimmed) |
| `status` | `deliverable`, `undeliverable-no-mx`, `risky-disposable`, or `invalid-syntax` |
| `deliverable` | `true` when the domain has valid mail servers and no risk flags |
| `score` | 0–100 sendability score — sort by it and cut your list at your risk threshold |
| `mxValid` / `mxHost` | Whether the domain can receive mail, and its primary mail server |
| `disposable` | Temporary-inbox domains (Mailinator, YOPmail, temp-mail, 60+ known providers) |
| `roleBased` | Addresses like `info@`, `support@`, `sales@` — higher complaint rates |
| `freeProvider` | Gmail, Outlook, Yahoo & 40+ other free providers — useful for B2B filtering |

#### Output example

```json
{
    "input": "John.Doe@Company.COM",
    "email": "john.doe@company.com",
    "domain": "company.com",
    "status": "deliverable",
    "deliverable": true,
    "score": 100,
    "syntaxValid": true,
    "mxValid": true,
    "mxHost": "aspmx.l.google.com",
    "disposable": false,
    "roleBased": false,
    "freeProvider": false,
    "verifiedAt": "2026-07-22T10:00:00.000Z"
}
````

***

### How to use

1. Paste your email list into the **Email addresses** field (one per line) — or send it via API.
2. Run. Duplicates are removed automatically and **never billed twice**.
3. Export results as CSV/Excel/JSON, or filter the **Risk Flags** view to drop risky addresses.

#### API (Node.js)

```javascript
const { ApifyClient } = require('apify-client');
const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('rp_openpro.ai/bulk-email-verifier').call({
    emails: ['john@company.com', 'info@business.fr', 'fake@nope-nope.xyz'],
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
const clean = items.filter(r => r.deliverable && r.score >= 80);
```

#### API (Python)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("rp_openpro.ai/bulk-email-verifier").call(run_input={
    "emails": ["john@company.com", "info@business.fr"],
})
clean = [r for r in client.dataset(run["defaultDatasetId"]).iterate_items() if r["deliverable"]]
```

***

### Use cases

- **Pre-campaign hygiene** — cut bounce rates before cold outreach; protect your sender domain.
- **CRM cleaning** — score and re-verify old lead lists on a schedule.
- **Signup validation** — block disposable domains at registration via API.
- **Lead-gen pipelines** — chain after our [Google Maps Scraper](https://console.apify.com/actors/cOE9BjYdgw74bcWyZ) or [Contact Details Scraper](https://console.apify.com/actors/QDKOd64e0w1Mar1UG): scrape leads, then verify every email in one flow.

***

### Pricing

You pay per verified email delivered to the dataset, plus a negligible one-time Actor Start fee. **Duplicates in your input are filtered before billing** — the number of dataset rows always equals the number of charged events.

🆓 Free trial: **25 emails per run**.

> No proxies, no browsers — verification is DNS-based, so runs are fast (thousands of emails per minute) and there are no hidden platform costs.

***

### FAQ

#### Does it guarantee the mailbox exists?

No verifier can fully guarantee that without sending mail. This Actor validates syntax and confirms that the domain has active mail servers (MX records), and flags disposable/role-based/free addresses. Mailbox-level SMTP probing is blocked by all cloud platforms (port 25) and is unreliable by design — services that claim it mostly return "unknown".

#### How fast is it?

DNS lookups run 25-concurrent with per-domain caching — a 10,000-address list with many shared domains typically verifies in under a minute.

#### What about catch-all domains?

Domains with valid MX are marked deliverable. Catch-all detection requires SMTP probing (see above); use the `score` to apply your own risk threshold.

#### Can I schedule it?

Yes — use Apify's scheduler to re-verify your CRM weekly or monthly.

***

*Built by [Leadsit.eu](https://leadsit.eu) — lead generation tools for modern sales teams.*

*SEO: bulk email verifier apify, email list cleaning tool, verify email addresses online bulk, mx record email checker, disposable email detection api, email deliverability checker, reduce email bounce rate, email validation api cheap, clean mailing list before campaign, b2b email list verification*

# Actor input Schema

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

One email address per line. Duplicates are removed automatically and never billed twice. Paste up to tens of thousands of addresses — verification runs concurrently and costs no proxy bandwidth.

## `proxyConfiguration` (type: `object`):

Not required — verification uses DNS lookups only, no web scraping. Leave default.

## Actor input object example

```json
{
  "emails": [
    "john.doe@company.com",
    "info@business.fr"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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": [
        "contact@apify.com",
        "someone@gmail.com",
        "fake@this-domain-does-not-exist-xyz.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rp_openpro.ai/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": [
        "contact@apify.com",
        "someone@gmail.com",
        "fake@this-domain-does-not-exist-xyz.com",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("rp_openpro.ai/bulk-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": [
    "contact@apify.com",
    "someone@gmail.com",
    "fake@this-domain-does-not-exist-xyz.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call rp_openpro.ai/bulk-email-verifier --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bulk Email Verifier — MX, Disposable & Sendability Score",
        "description": "syntax validation, MX-record deliverability, disposable-domain detection (60+ providers), role-based and free-provider flags, and a 0–100 sendability score",
        "version": "1.0",
        "x-build-id": "V452v1EH9GJlRsfOf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/rp_openpro.ai~bulk-email-verifier/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-rp_openpro.ai-bulk-email-verifier",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/rp_openpro.ai~bulk-email-verifier/runs": {
            "post": {
                "operationId": "runs-sync-rp_openpro.ai-bulk-email-verifier",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/rp_openpro.ai~bulk-email-verifier/run-sync": {
            "post": {
                "operationId": "run-sync-rp_openpro.ai-bulk-email-verifier",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "emails"
                ],
                "properties": {
                    "emails": {
                        "title": "Email addresses",
                        "type": "array",
                        "description": "One email address per line. Duplicates are removed automatically and never billed twice. Paste up to tens of thousands of addresses — verification runs concurrently and costs no proxy bandwidth.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Not required — verification uses DNS lookups only, no web scraping. Leave default."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```