# Email Verifier & Validator $0.09/1K: Bulk SMTP, Catch-All (`zaiq/email-verifier`) Actor

Verify email addresses in bulk with each mail server, without sending anything. Get deliverable, undeliverable, risky or unknown, plus catch-all, disposable and role flags, typo fixes and a clean list. Unknown answers are free. $0.09 per 1,000 emails.

- **URL**: https://apify.com/zaiq/email-verifier.md
- **Developed by:** [Zaiq](https://apify.com/zaiq) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.07 / 1,000 verified emails

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?

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

## Email Verifier & Validator API: bulk SMTP, catch-all and bounce check, no mail sent

![Email Verifier & Validator: Bulk SMTP, Catch-All & Bounce Check](https://api.apify.com/v2/key-value-stores/4VJNANhwKgqPpXtAi/records/hero-email-verifier.jpg)

**Verify email addresses in bulk** by asking each address's own mail server whether it would accept mail, then hanging up **before anything is sent**. Every address comes back **deliverable**, **undeliverable**, **risky** or **unknown**, with a plain reason, the provider, and flags for **catch-all** domains, **disposable** addresses, **role addresses** such as info@, **free providers** and **typos** such as gmial.com.

**You only pay for real answers.** Unknown and malformed addresses are free, and addresses we cannot confirm cost half. Pay per check instead of buying a NeverBounce or ZeroBounce credit pack. Built for **cold email and outreach teams**, **lead scrapers**, **CRM clean-ups** and **AI agents** that want to clean a list before it costs them their sender reputation.

### What you get

| Field | What it holds |
|---|---|
| The answer | `email`, `status` (deliverable, undeliverable, risky, unknown), `safeToSend`, `reason`, `reasonCode` |
| The flags | `isCatchAll`, `isDisposable`, `isRoleAddress`, `isFreeProvider`, `didYouMean` |
| The evidence | `provider`, `mailServer`, `mailServerReply`, `domain`, `checkedAt`, `position` |
| Your own columns | `source`: the original row from your file or dataset, so nothing gets lost |
| A clean list | `CLEAN_LIST.csv` in the run's key-value store: only the addresses that are safe to send to |

### What people use it for

- **Cold email:** clean a list before a campaign, and keep your bounce rate low
- **Lead scraping:** pass a scraper's dataset straight in and keep only addresses that work
- **CRM clean-ups:** find the dead contacts in an old list, with your columns kept
- **Signup forms:** catch typos and throwaway addresses as they arrive, through the API
- **Sender reputation:** take out catch-alls and role addresses before a warm-up
- **AI agents:** check an address inside any workflow, per address

### How to use it

1. Paste your **addresses**, or give it a **CSV or text file**, or the **dataset** from another Actor.
2. Press **Start**. Duplicates are removed and bad syntax is caught for free.
3. Each mail server is asked about each address. **No email is sent**: the conversation ends before any message.
4. Download the rows, or just `CLEAN_LIST.csv` with the addresses that are safe to send to.

### Input

| Field | Example | Notes |
|---|---|---|
| Email addresses | info@wikipedia.org | One a line, or paste a whole block of text and every address in it is found. |
| Or a file of addresses | https://example.com/list.csv | CSV or plain text, up to 100 MB. The email column is found by name and your other columns come back with each row. |
| Or the results of another Actor | a dataset ID | Clean a list right after you scrape it. |
| Email column | work_email | Only if the column isn't called email. |
| Most addresses to check | 5000 | Stops after this many different addresses. Empty checks them all. |
| Ask again when a server says try later | on | Some servers answer only on a second attempt. On longer lists the run waits 5 minutes and asks again, at no charge. |

### Output

Each result is one row in the run's dataset (download it as JSON, CSV, Excel, XML or HTML, or read it through the API). An example row (values shortened):

```json
{
  "email": "jane@example.org",
  "status": "deliverable",
  "safeToSend": true,
  "reason": "The mail server accepts this address.",
  "reasonCode": "mailbox_accepted",
  "domain": "example.org",
  "provider": "Google",
  "mailServer": "aspmx.l.google.com",
  "isCatchAll": false,
  "isDisposable": false,
  "isRoleAddress": false,
  "isFreeProvider": false,
  "didYouMean": null,
  "mailServerReply": "250 2.1.5 OK",
  "position": 1,
  "checkedAt": "2026-11-01T15:20:00Z"
}
```

A record named `SUMMARY` in the run's key-value store says what each input returned, with any notes (for example an account that does not exist), what was charged and how much traffic the run used.

### Pricing

- **$0.09 per 1,000 definite answers** on Free and Bronze, $0.081 on Silver, $0.072 on Gold and above. That covers deliverable and undeliverable.
- **$0.045 per 1,000 risky addresses**: a mail server that accepts every address, or a disposable address.
- **Unknown and malformed addresses are free**, and you never pay for waiting.
- The Free plan checks up to 100 addresses a run.
- Launch price. It may rise later; Apify emails every user 14 days before any price increase takes effect, and a rise can happen at most once a month.

What typical jobs cost at the list price:

| Job | Cost |
|---|---|
| 1,000 addresses | at most $0.09 |
| 10,000 addresses | at most $0.90 |
| 100,000 addresses | at most $9.00 |

On Apify's Scale and Business plans the per-event prices are lower (Store discounts). Set **Maximum cost per run** and the Actor stops cleanly when it is reached: you never pay more than that.

### Tips

- Send only to `safeToSend: true`. Treat `risky` as a separate, smaller send if you use them at all.
- Run `unknown` addresses again later: many are mail servers that were busy or asked us to wait, and a second run costs nothing unless it gets an answer.
- Check `didYouMean` before you throw an address away: gmial.com is usually a real person.
- Pass `datasetId` from a lead scraper to chain the two runs in one workflow.
- Use `isRoleAddress` to drop info@ and sales@ if your campaign is for named people.

### Use it through the API

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("zaiq/email-verifier").call(run_input={"emails": ["info@wikipedia.org", "no-such-person-7291@wikipedia.org"]})
for row in client.dataset(run.default_dataset_id).iterate_items():
    print(row)
```

**JavaScript**

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('zaiq/email-verifier').call({"emails": ["info@wikipedia.org", "no-such-person-7291@wikipedia.org"]});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**HTTP (one call, results back)**

```bash
curl -X POST 'https://api.apify.com/v2/acts/zaiq~email-verifier/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>' \
  -H 'Content-Type: application/json' \
  -d '{"emails": ["info@wikipedia.org", "no-such-person-7291@wikipedia.org"]}'
```

### Integrations and schedules

- **Schedules:** run it every hour, day or week from the Apify Console (Schedules) and keep a history of results.
- **Make, Zapier, n8n, Google Sheets, Slack, Airtable:** connect it through Apify's integrations, or send each finished run to a **webhook**.
- **Datasets:** results stay in the run's dataset; export them or read them by API whenever you need them.

### Use it with AI agents (MCP)

Add Apify's MCP server with this Actor already pinned (`https://mcp.apify.com?tools=zaiq/email-verifier`) to Claude, ChatGPT, Cursor, VS Code or any MCP client. The agent can find this Actor and run it for you: ask it for Check these email addresses and tell me which are safe to send to. AI agents can also pay for runs directly through Apify's agentic payments.

### Limits

- **Nothing is ever sent.** The check stops before any message, so nobody receives anything.
- **Deliverable means the mail server says it would accept mail for that address.** It cannot tell you that a person reads it.
- **Some mail servers accept every address**, so no check can confirm one address there. Yahoo and AOL work this way, as do many company domains. These come back `risky` at half price.
- **Some mail servers refuse every address, are unreachable or keep asking us to wait.** Those come back `unknown` and are free. In our test of 900 addresses across 300 company domains, 76% got an answer and 24% came back unknown.
- **Your addresses pass through our checking server to reach each mail server.** They are not written to disk or to any log, and only domain-level answers are kept, briefly, in memory.
- You are responsible for having a lawful reason to hold and contact the addresses you check.

### FAQ

**Does this send an email to anyone?**

No. It opens a conversation with the mail server, asks whether it would accept the address, and ends the conversation before any message. Nobody receives anything.

**What is a catch-all domain?**

A mail server set to accept every address, real or not. It says yes to everything, so no check can tell you whether one address exists. We test this with a made-up address and mark those rows `risky`.

**How fast is it, and how many get an answer?**

In our test, 900 addresses across 300 company domains took about 2.5 minutes, then a 5-minute wait to ask again where servers said to try later. 76% got an answer, and every one of the 300 made-up addresses we slipped in was caught: none came back deliverable.

**Why is Yahoo always risky?**

Yahoo and AOL accept every address at this stage of the conversation and only bounce later, so a check cannot separate real addresses from fake ones. Any tool that says otherwise is guessing.

**What do I pay for unknown?**

Nothing. If a mail server refuses to answer, times out or asks us to try later and never answers, that row is free.

**How is this different from a NeverBounce or ZeroBounce subscription?**

No credit packs and no account with another vendor. You pay per answer from your Apify balance, and you can chain it directly after any scraper on Apify.

**Can I keep my other columns?**

Yes. With a file or a dataset, each row keeps its original columns under `source`.

**Do you store my list?**

No. Addresses pass through our checking server to reach each mail server and are not written to disk or to any log. Your results stay in your own Apify storage.

**Can I check one address from my signup form?**

Yes. Call the Actor through the Apify API with one address and read the row.

### Related Actors from Zaiq

- [contact-details-extractor](https://apify.com/zaiq/contact-details-extractor): find the addresses on a list of websites, then check them here
- [google-maps-leads-scraper](https://apify.com/zaiq/google-maps-leads-scraper): local business leads to clean with this
- [company-data-api](https://apify.com/zaiq/company-data-api): company details beside your contacts

### Support

Questions, a site that changed, or a field you need? Open an issue on this Actor's **Issues** tab: we answer there, usually within a day.

***

Also found as: email verifier, email validator, bulk email verification, email checker, SMTP email check, catch-all email detection, disposable email checker, email bounce check, email list cleaning, NeverBounce alternative, ZeroBounce alternative.

# Actor input Schema

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

The addresses to check, one a line. You can also paste a whole block of text: every address in it is found.

## `fileUrl` (type: `string`):

The address of a CSV or text file. The email column is found by its name, and your other columns come back with each row. Up to 100 MB.

## `datasetId` (type: `string`):

The ID of a dataset, such as a lead scraper's results. Its rows come back with each address, so you can clean a list right after you scrape it.

## `emailField` (type: `string`):

The name of the column holding the address, if the file or dataset doesn't call it email.

## `maxEmails` (type: `integer`):

Stop after this many different addresses. Leave empty to check them all.

## `retryGreylisted` (type: `boolean`):

Some mail servers answer only on a second attempt. On longer lists the run waits 5 minutes and asks again, which turns many unknowns into real answers. You pay nothing for the wait.

## Actor input object example

```json
{
  "emails": [
    "info@wikipedia.org",
    "no-such-person-7291@wikipedia.org",
    "someone@example.com"
  ],
  "retryGreylisted": true
}
```

# Actor output Schema

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

Dataset: the results.

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

What each input returned, and notes.

# 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": [
        "info@wikipedia.org",
        "no-such-person-7291@wikipedia.org",
        "someone@example.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("zaiq/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": [
        "info@wikipedia.org",
        "no-such-person-7291@wikipedia.org",
        "someone@example.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("zaiq/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 '{
  "emails": [
    "info@wikipedia.org",
    "no-such-person-7291@wikipedia.org",
    "someone@example.com"
  ]
}' |
apify call zaiq/email-verifier --silent --output-dataset

```

## MCP server setup

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