# Email Verifier & Validator - Bulk Email Verification API (`sian.agency/email-verifier`) Actor

Verify email addresses in bulk: syntax, domain and MX records, disposable and catch-all detection, role-account flags and typo suggestions. Pay per email.

- **URL**: https://apify.com/sian.agency/email-verifier.md
- **Developed by:** [SIÁN OÜ](https://apify.com/sian.agency) (community)
- **Categories:** Marketing, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 email verifications

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?

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 Verifier — Bulk Email Validation & Checker API 🚀

[![SIÁN Agency Store](https://img.shields.io/badge/Store-SI%C3%81N%20Agency-1AE392)](https://apify.com/sian.agency?fpr=sian) [![Store-Email & Contact Lead Scraper-1AE392](https://img.shields.io/badge/Store-Email%20%26%20Contact%20Lead%20Scraper-1AE392)](https://apify.com/sian.agency/email-contact-lead-scraper?fpr=sian) [![Store-Local Business Data Scraper-0077B5](https://img.shields.io/badge/Store-Local%20Business%20Data%20Scraper-0077B5)](https://apify.com/sian.agency/local-business-data-scraper?fpr=sian) [![Store-Property Skip Tracing-1AE392](https://img.shields.io/badge/Store-Property%20Skip%20Tracing-1AE392)](https://apify.com/sian.agency/property-skip-tracing?fpr=sian)

#### ✅ Syntax, domain and mail-server checks on every address — plus a mailbox answer wherever the server gives one — $0.80 per 1,000

##### Built for marketers, sales teams and developers who need to know which addresses will bounce *before* they hit send

### 🔎 What is the Email Verifier — and when should you use it?

The **Email Verifier** turns a list of email addresses you already hold into clean, structured rows you can filter, export and feed straight into a spreadsheet, database or AI agent. No account, no portal API key, no browser automation to maintain.

**Use it when you need:** one row per address with a status: valid, invalid, catch\_all, disposable or unknown. Each row carries a filterable reason code, the mail server that answered and the receiving platform. SPF, DMARC and a role-account flag come with it. A one-character domain typo gets a did-you-mean correction in the same row. Duplicates are removed before anything is charged, and a malformed address is never billed.

**Use something else when:** you do not have the addresses yet and need to find them. Use [Email & Contact Lead Scraper](https://apify.com/sian.agency/email-contact-lead-scraper?fpr=sian) for collecting the addresses from websites in the first place, which this actor then checks. Use [Local Business Data Scraper](https://apify.com/sian.agency/local-business-data-scraper?fpr=sian) for business listings with their contact details attached, for building the list rather than grading it. This actor grades addresses you supply. It does not find new ones, and it does not send anything — a mailbox is confirmed by asking the recipient's mail server, never by delivering mail.

### 🤖 Use with AI agents

Already connected to the [Apify MCP server](https://mcp.apify.com)? Just ask for this Actor by name: sian.agency/email-verifier

**Your agent can pay for its own runs.** This Actor is eligible for [agentic payments](https://docs.apify.com/platform/actors/publishing/monetize), so an agent can discover it, run it and settle the bill over [x402](https://www.x402.org/) (USDC on Base) or [Skyfire](https://www.skyfire.xyz/) — without an Apify account or API token of its own. Billing is the same either way: per successful row, never for errors.

Otherwise copy this prompt into Claude, ChatGPT, Cursor or any MCP-enabled assistant:

```text
I want to know which email addresses on a list are safe to send to using the Apify Actor `sian.agency/email-verifier`.

Use it when I need: one row per address with a status: valid, invalid, catch_all, disposable or unknown. Each row carries a filterable reason code, the mail server that answered and the receiving platform. SPF, DMARC and a role-account flag come with it. A one-character domain typo gets a did-you-mean correction in the same row. Duplicates are removed before anything is charged, and a malformed address is never billed.

Don't use it when: you do not have the addresses yet and need to find them — use email-contact-lead-scraper or local-business-data-scraper instead.

How to call it: pass a single address in `email`, a list in `bulkEmails`, or a public text/CSV URL in `requestsFromUrl`. Everything else is automatic: syntax, domain and MX, disposable, role and catch-all detection, and a typo correction where one is suspected.

Start with this input:
{
  "operation": "verify",
  "bulkEmails": [
    "name@company.com",
    "info@acme.co",
    "test@mailinator.com"
  ]
}

Ask me for the addresses or the file URL they want checked, and whether they care more about strictness (drop everything not confirmed) or reach (keep anything not proven dead), then run the Actor and summarise the results as a table.
```

**Things you can ask your agent for:**

- *Check these 300 newsletter addresses and give me three lists: safe to send, remove, and retry later.*
- *Grade last month's sign-ups and tell me which came from throwaway domains or shared inboxes.*
- *Scan my lead list and flag every domain that publishes no DMARC policy or has no mail server.*

Machine-readable API, MCP config and OpenAPI definition for this Actor are published at [apify.com/sian.agency/email-verifier.md](https://apify.com/sian.agency/email-verifier.md).

### 📋 Overview

Paste a list, get a verdict on every address. The Email Verifier runs each address through five checks and returns one row per address with a status, a plain-English reason and a machine-readable reason code you can filter on.

**What you get:**

- ✅ **Five checks in one pass**: syntax, domain existence, mail server (MX), throwaway detection and catch-all detection. One run answers what would otherwise be five lookups. The first four land on every row; the mailbox questions depend on the receiving server accepting one.
- 💡 **Typo rescue**: a one-character miss in the domain is caught and the corrected address returned, so `gmial.com` never costs you a customer.
- 🧭 **Deliverability signals included**: every row carries the mail server found, the receiving platform (22 recognised, from Google Workspace to Cloudflare), plus SPF and DMARC answers for the domain.
- 💰 **Priced under the category leader**: $0.80 per 1,000 addresses. You are never charged for a malformed address.
- 🔎 **The reason, per row**: 8 reason codes. Filter your list by *why* an address failed instead of guessing at valid and invalid.
- ✨ **No keys, no setup**: no account to connect and no provider to sign up for. Paste and run.

### ✨ Features

- ✅ **Syntax validation** — malformed addresses are flagged with what to fix, and never charged.
- 🌍 **Domain and mail-server lookup** — a live MX query per unique domain, with an A-record fallback for domains that publish no MX.
- 🗑️ **Disposable address detection** — 8,700+ known throwaway domains bundled in the build, so the check never depends on a third-party quota.
- 👥 **Role-account flagging** — `info@`, `sales@`, `admin@` and 550+ other shared inboxes, marked so a campaign can treat them differently.
- 📥 **Catch-all detection** — where a domain accepts every address, the row is reported as `catch_all` rather than falsely marked deliverable. Part of the mailbox answer, so it appears when the mail server takes the question.
- 💡 **Did-you-mean suggestions** — a near-miss domain gets the corrected address in the same row.
- 📦 **Three ways to load a list** — a single address, a pasted bulk list, or a public text/CSV URL for very large files.
- 🚫 **Duplicate removal before charging** — the same address twice is checked and billed once.
- 📄 **A run report you can act on** — safe-to-send and remove lists, each with a one-click copy.

### 🎬 Quick Start

Give it one address and press Start. The default input is pre-filled, so a bare run returns real results.

```bash
curl -X POST 'https://api.apify.com/v2/acts/sian.agency~email-verifier/runs?token=YOUR_TOKEN' \
-H 'Content-Type: application/json' \
-d '{"email": "name@company.com"}'
```

### 🚀 Getting Started (3 Simple Steps)

#### Step 1: Add your addresses

Paste one address into **Email address**, or a list into **Bulk email list**, or point **Load list from URL** at a public text file.

#### Step 2: Run it

Press Start. Checks run 15 addresses at a time and every unique domain is looked up once, so large lists do not slow down.

#### Step 3: Filter your dataset

Download the results and split them on `status`: send to `valid`, drop `invalid` and `disposable`, retry `unknown` later.

**That's it! In under a minute for a hundred addresses, you'll have:**

- A safe-to-send list, ready to copy
- A removal list with the reason for each address
- Per-row mail server, platform, SPF and DMARC answers

### 📥 Input Configuration

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| email | string | No | A single address to verify |
| bulkEmails | array | No | Many addresses at once, one per line |
| requestsFromUrl | string | No | Public URL of a text or CSV file with one address per line |
| operation | string | No | Always `verify` — kept for API compatibility |

**Single address:**

```json
{
  "email": "name@company.com"
}
```

**Bulk:**

```json
{
  "bulkEmails": ["name@company.com", "sales@other.com", "test@mailinator.com"]
}
```

**From a file:**

```json
{
  "requestsFromUrl": "https://example.com/my-list.txt"
}
```

### 📤 Output

One row per address, with **17 fields**:

| Field | Type | Description |
|-------|------|-------------|
| email | string | The address as submitted |
| status | string | `valid` · `invalid` · `catch_all` · `disposable` · `unknown` |
| reasonCode | string | Machine-readable reason — filter on this |
| reasonDetail | string | The same reason in plain English |
| mailboxCheck | string | `confirmed` · `rejected` · `catch_all` · `unavailable` · `not_possible` · `not_needed` |
| smtpCode | number | The mail server's own reply code, where it gave one |
| didYouMean | string | Corrected address when the domain looks like a typo |
| normalizedEmail | string | Dots and plus-suffixes collapsed, for de-duplicating |
| mxPresent | boolean | Whether the domain has a mail server |
| mxHost | string | The mail server that answered |
| mailProvider | string | Receiving platform, e.g. Google Workspace |
| disposable | boolean | Throwaway domain |
| roleAddress | boolean | Shared inbox such as `info@` or `sales@` |
| freeProvider | boolean | Free mailbox provider such as Gmail |
| spfPresent | boolean | Domain publishes SPF |
| dmarcPolicy | string | DMARC policy: `none` · `quarantine` · `reject` |
| checkedAt | string | When this row was checked |

**Example:**

```json
{
  "email": "support@apify.com",
  "status": "valid",
  "reasonCode": "mailbox_confirmed",
  "reasonDetail": "The mail server confirmed this mailbox exists.",
  "mailboxCheck": "confirmed",
  "smtpCode": 250,
  "mxPresent": true,
  "mxHost": "aspmx.l.google.com",
  "mailProvider": "Google Workspace",
  "spfPresent": true,
  "dmarcPolicy": "reject",
  "normalizedEmail": "support@apify.com",
  "disposable": false,
  "roleAddress": true,
  "freeProvider": false,
  "checkedAt": "2026-08-31T02:42:35.757Z"
}
```

### 💼 Use Cases & Examples

#### 1. Clean a mailing list before a campaign

**An email marketer with 50,000 subscribers and a hard-bounce limit to protect.**

**Input:** the exported list, one address per line
**Output:** send / remove / retry lists, each with the reason
**Use:** strip what cannot exist before it damages your sender reputation and your ESP account.

#### 2. Stop trial abuse at sign-up

**A SaaS operator watching disposable addresses burn free trials.**

**Input:** new sign-ups as they arrive
**Output:** `disposable` status with the throwaway domain flagged
**Use:** block or challenge throwaway registrations without touching real customers.

#### 3. Triage a bought lead list

**A sales team that just paid for 10,000 B2B contacts.**

**Input:** the vendor's CSV by URL
**Output:** dead mailboxes and role accounts separated from real people
**Use:** spend sending credits only on addresses that can receive mail.

#### 4. Rescue typos at the point of entry

**A developer building a sign-up form who cannot afford to lose customers to fat fingers.**

**Input:** the address as typed
**Output:** `didYouMean` with the corrected address
**Use:** prompt the user with the fix instead of silently storing a dead address.

#### 5. Audit sender domains in a B2B list

**A deliverability consultant checking which prospects can even receive mail securely.**

**Input:** the prospect list
**Output:** MX, mail platform, SPF and DMARC per domain
**Use:** flag domains with no mail server or no DMARC before outreach.

#### 6. Keep a CRM clean on a schedule

**An operations lead whose CRM decays between one-off cleanups.**

**Input:** a scheduled run pointed at the exported CRM file URL
**Output:** a fresh grade for every address, every week
**Use:** retire dead contacts continuously instead of in a yearly panic.

### 🔗 Integration Examples

#### JavaScript/Node.js

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('sian.agency/email-verifier').call({
  email: 'name@company.com'
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].status);
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')

run = client.actor('sian.agency/email-verifier').call(
    run_input={'email': 'name@company.com'}
)

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item['email'], item['status'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/sian.agency~email-verifier/runs?token=YOUR_TOKEN' \
-H 'Content-Type: application/json' \
-d '{"bulkEmails": ["a@company.com", "b@company.com"]}'
```

#### Automation Workflows (N8N / Zapier / Make)

1. **Trigger**: a new sign-up, a form submission, or a weekly schedule
2. **HTTP Request**: call the actor API with the address or list
3. **Process**: read `status` and `reasonCode` from the JSON result
4. **Action**: block disposable sign-ups, drop dead addresses, or queue `unknown` for a retry

### 📊 Performance & Pricing

#### FREE Tier (Try It Now)

- **5 addresses per run** — every check included, same quality
- No credit card required
- Perfect for trying it on a handful of your own addresses

#### PAID Tier (Production Ready)

- **Unlimited addresses per run**
- 15 checks in parallel; each unique domain is looked up once per run
- Pay per address verified — never for a malformed one

💰 **$0.80 per 1,000 addresses** — under the category leader's $0.89.

🔗 [View current pricing](https://apify.com/sian.agency/email-verifier?fpr=sian)

### ❓ Frequently Asked Questions

**Q: What does each status mean?**
A: `valid` — the mail server confirmed the mailbox. `invalid` — the address cannot receive mail: bad syntax, dead domain, no mail server, or mailbox not found. `catch_all` — the domain accepts every address, so this one cannot be confirmed individually. `disposable` — a throwaway domain. `unknown` — the domain is real and takes mail, but its server would not confirm the individual mailbox. On a cloud platform that is the common outcome for the mailbox question, which is why the row carries everything the domain level did establish.

**Q: Which mail servers will not confirm a mailbox?**
A: Most of them, when the question comes from a cloud platform: many recipient servers refuse the connection outright, and Microsoft-hosted domains in particular answer based on who is asking rather than on the address. Those rows come back `unknown` with `mailboxCheck: unavailable`. The row still tells you the domain is live, has a mail server, and whether it is disposable or a role account. The check is always attempted, so a server that does take the question is answered on the spot.

**Q: Do you send an email to check the address?**
A: No. The check asks the recipient's mail server a question and stops there. No message is delivered to any address at any point.

**Q: Do I get charged for invalid addresses?**
A: Not for malformed ones — an address that fails the syntax check is returned free of charge. Every other answer, including `invalid` and `unknown`, is a real verification result and is charged.

**Q: How many addresses can one run handle?**
A: Thousands. Checks run 15 at a time, and each unique domain is looked up once per run.

**Q: What output formats are available?**
A: JSON, CSV and Excel, straight from the Apify dataset.

**Q: Is this legal?**
A: The actor only checks addresses you already hold. You are responsible for having a lawful basis to process them — see the legal section below.

### 🐞 Troubleshooting

**Everything comes back `unknown`**

- The receiving servers refused the mailbox question. Most do when the question comes from a cloud platform. You still get the domain, mail server, provider, SPF and DMARC answers on every row, plus disposable and role flags. Treat `unknown` as "probably deliverable, unverified" and re-run later — the check is attempted on every run.

**An address I know is real came back `invalid`**

- Check the `reasonCode`. `syntax_invalid` means the address as submitted had a stray character or an incomplete domain; `mailbox_not_found` means the recipient's own server said it does not exist — usually a full or closed mailbox, or an address that was deleted.

**A whole domain comes back the same for every address**

- That is a `catch_all` domain. It accepts everything, so no per-address answer is possible. Filter on `status: catch_all` and treat those as deliverable but unverified.

**My list file was not loaded**

- The URL must be public and point at a plain text or CSV file with one address per line. A link that needs a login will fail.

**`info@` addresses marked valid but I want to exclude them**

- Filter on `roleAddress: true`. Shared inboxes are flagged rather than marked invalid, because many of them do receive mail.

### ⚖️ Is it legal to verify email addresses?

This actor checks addresses you supply. It collects no data of its own and sends no email to anyone. You are responsible for holding a lawful basis to process the addresses you verify: personal data is protected by the **GDPR** in the European Union and by equivalent laws elsewhere, and commercial sending is governed by laws such as CAN-SPAM. If you are unsure whether your use is lawful, consult your lawyers.

You can also read Apify's post on [the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### 🤝 Support

[![Telegram Support](https://img.shields.io/badge/Telegram-Support%20Group-0088cc?logo=telegram)](https://t.me/+vyh1sRE08sAxMGRi)

**Join our active support community**

- For issues or questions, open an issue in the actor's repository
- Check the [SIÁN Agency Store](https://apify.com/sian.agency?fpr=sian) for more automation tools
- 📧 <apify@sian-agency.online>

***

**Built by [SIÁN Agency](https://www.sian-agency.online)** | **[More Tools](https://apify.com/sian.agency?fpr=sian)**

# Actor input Schema

## `operation` (type: `string`):

One check per email address: syntax, domain and MX records, disposable/role detection, typo suggestions and mailbox-level verification where the recipient server allows it.

## `email` (type: `string`):

A single email address to verify, e.g. name@company.com. Use this for one-off checks.

## `bulkEmails` (type: `array`):

Paste or load many addresses at once — one per line. Duplicates are removed automatically before anything is charged.

## `requestsFromUrl` (type: `string`):

Public URL of a text or CSV file containing one email address per line. Handy for very large lists.

## Actor input object example

```json
{
  "operation": "verify",
  "email": "name@company.com",
  "requestsFromUrl": "https://example.com/my-list.txt"
}
```

# Actor output Schema

## `emailVerifications` (type: `string`):

Every verification this run returned.

## `scrapingSummary` (type: `string`):

HTML summary showing successful and failed results with key metrics

# 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 = {
    "operation": "verify",
    "email": "support@apify.com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("sian.agency/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 = {
    "operation": "verify",
    "email": "support@apify.com",
}

# Run the Actor and wait for it to finish
run = client.actor("sian.agency/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 '{
  "operation": "verify",
  "email": "support@apify.com"
}' |
apify call sian.agency/email-verifier --silent --output-dataset

```

## MCP server setup

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