# Email List Verifier (`conserving_mastodon/email-list-verifier`) Actor

Verify a list of email addresses without sending mail. Combines syntax checks, MX lookup over DNS-over-HTTPS, disposable and role-account detection, and an optional live SMTP mailbox probe into a per-address verdict: valid, invalid, risky, or unknown. Charged only on completion.

- **URL**: https://apify.com/conserving\_mastodon/email-list-verifier.md
- **Developed by:** [Chris Arsenault](https://apify.com/conserving_mastodon) (community)
- **Categories:** Business, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$500.00 / 1,000 completed verifications

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Email List Verifier

**Clean an email list before you send to it, without sending a single message.** Give the Actor up to 100 addresses and it returns a per-address verdict built from four independent signals: syntax, a working MX host, disposable and role-account detection, and an optional live SMTP mailbox probe. No mail is ever sent.

### What it checks

- **Syntax**: each address is validated against a practical RFC-style pattern.
- **MX lookup**: the domain is resolved over DNS-over-HTTPS (Cloudflare, then Google as a fallback). A domain with no MX host cannot receive mail, so the address is marked invalid.
- **Disposable providers**: the domain is matched against an embedded set of temporary-mailbox services (mailinator, guerrillamail, yopmail, sharklasers, temp-mail, and more).
- **Role accounts**: local-parts like `info@`, `admin@`, `support@`, `sales@`, `noreply@`, `billing@`, and `postmaster@` are flagged, since they usually address a function rather than a person.
- **Live SMTP probe** (optional, on by default): the Actor connects to the domain's highest-priority mail server on port 25 and runs `EHLO`, `MAIL FROM`, and `RCPT TO` to read whether the mailbox is accepted. It stops before `DATA`, so no message is delivered. It also probes a random address at the same domain to detect catch-all servers that accept everything.

### Verdicts

Each address gets one of four verdicts:

- **valid** — syntax and MX are good and the mailbox was accepted by the mail server.
- **invalid** — bad syntax, no MX host, or the mailbox was rejected.
- **risky** — deliverable but flagged: a disposable domain, a role account, or a catch-all domain where the specific mailbox cannot be confirmed.
- **unknown** — the mailbox could not be determined, for example because the SMTP probe was off, the server greylisted the request, or outbound port 25 was blocked.

### Output

A summary row followed by one row per address:

```json
{
  "row_type": "summary",
  "total": 3,
  "valid": 1,
  "invalid": 1,
  "risky": 1,
  "unknown": 0,
  "disposable_count": 0,
  "role_count": 1
}
```

```json
{
  "row_type": "email",
  "email": "info@apify.com",
  "verdict": "risky",
  "syntax_ok": true,
  "has_mx": true,
  "smtp_status": "deliverable",
  "is_disposable": false,
  "is_role": true,
  "is_catch_all": false
}
```

### Use cases

- **Sales list cleaning**: strip dead and disposable addresses out of a prospect list before an outreach campaign.
- **Signup validation**: check an address at registration to catch typos and throwaway inboxes.
- **Reducing bounce rate**: remove addresses that will bounce, protecting your sending domain's reputation.

### Honest limits

- **This does not send real email.** The SMTP probe stops before the `DATA` phase, so no message is ever delivered.
- **SMTP status is best-effort.** Many mail hosts and many networks block outbound port 25 or greylist unfamiliar senders. When the Actor cannot complete the conversation, the SMTP status comes back `unknown` rather than a false positive or negative. If you run it from a network where port 25 is blocked, expect `unknown` and rely on the syntax, MX, disposable, and role signals.
- **Catch-all domains cannot be individually confirmed.** Some domains accept mail for every address. When that is detected, the address is marked risky and `is_catch_all` is set, because the specific mailbox cannot be proven to exist.
- **Signals, not guarantees.** A `valid` verdict means the checks passed at probe time; mailboxes can still be disabled later.

Empty runs and failed runs are not charged; billing is per completed batch verification.

Built by 1450 Enterprises. Pure Python standard library, no third-party lookups beyond public DNS-over-HTTPS.

# Actor input Schema

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

The list of email addresses to verify (up to 100 per run). Each address is checked for syntax, a working MX host, disposable and role-account signals, and, when the SMTP probe is on, live mailbox existence.

## `smtpProbe` (type: `boolean`):

When on, the Actor connects to each domain's mail server (port 25) and asks whether the mailbox exists, without ever sending mail. Turn this off to run syntax, MX, and disposable checks only. Many networks block outbound port 25, in which case the SMTP result is reported as unknown.

## Actor input object example

```json
{
  "emails": [
    "test@gmail.com",
    "fake9xzq@gmail.com",
    "info@apify.com"
  ],
  "smtpProbe": true
}
```

# Actor output Schema

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

A summary row with total, valid, invalid, risky, and unknown counts plus disposable and role tallies, followed by one row per address carrying its verdict and the sub-signals: syntax, MX, SMTP status, disposable, role, catch-all.

# 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": [
        "test@gmail.com",
        "fake9xzq@gmail.com",
        "info@apify.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("conserving_mastodon/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": [
        "test@gmail.com",
        "fake9xzq@gmail.com",
        "info@apify.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("conserving_mastodon/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": [
    "test@gmail.com",
    "fake9xzq@gmail.com",
    "info@apify.com"
  ]
}' |
apify call conserving_mastodon/email-list-verifier --silent --output-dataset

```

## MCP server setup

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