# Email Verifier & Validator | 0.85$/1k - Bulk Email No API (`blessiticus/email-verifier-pro`) Actor

Bulk email verifier & validator with live SMTP checks. Clean scraped lists from Google Maps, Apollo, or LinkedIn. Catch-all, disposable & syntax detection ($0.85/1k). No API key required.

- **URL**: https://apify.com/blessiticus/email-verifier-pro.md
- **Developed by:** [Mohammad Palekar](https://apify.com/blessiticus) (community)
- **Categories:** Lead generation, Automation, MCP servers
- **Features:** Limited permissions
- **Stats:** 532 total users, 225 monthly users, 100.0% runs succeeded, 7 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.60 / 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/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 | Bulk Email Verification ($0.85/1k)

Verify email addresses at scale with **real SMTP checks** — not just syntax validation. Email Verifier Pro connects directly to mail servers to confirm whether a mailbox actually exists, giving you the most accurate results possible.

**Stop wasting money on bounced emails.** Whether you're doing cold outreach, cleaning your CRM, or validating lead lists, this actor tells you exactly which emails are safe to send to and which ones will bounce.

> \[!TIP]
> **Need to scrape or find targeted B2B leads before verifying?**\
> Check out our specialized companion lead generation tools:
>
> - 📍 [**Google Maps Leads Scraper + Verified Emails**](https://apify.com/blessiticus/google-maps-leads-scraper-with-emails) — Extract local businesses, phone numbers, websites, owner names, and verified emails from Google Maps ($3/1k).
> - 🎯 [**Lead Scraper: Apollo Alternative**](https://apify.com/blessiticus/lead-scraper) — Extract decision-makers, verified work emails, phones & firmographics with zero export limits ($1.5/1k).
> - 🔍 [**B2B Work Email Finder**](https://apify.com/blessiticus/b2b-work-email-finder-5-1k-find-emails-linkedin-or-domain) — Find verified work emails from prospect Names & Company Domains or LinkedIn URLs ($5/1k).

### Core Features (What We Check)

To ensure maximum deliverability and reduce bounce rates, our verifier performs the following checks on every email:

- **Syntax Check**: Validates the email format (`user@domain.com`).
- **Domain & MX Record Check**: Confirms the domain has a configured mail server.
- **Disposable Email Detection**: Flags temporary and burner emails.
- **Catch-All Domain Detection**: Identifies domains that accept all mail, helping you filter out risky leads.
- **Role-Based Email Detection**: Flags shared inboxes like `info@` or `admin@`.
- **Deep SMTP Handshake**: Connects to the mail server to confirm the specific mailbox exists without sending an actual email.

### Why Email Verifier Pro?

| Feature | Email Verifier Pro | Other Actors |
|:---|:---:|:---:|
| **Price per 1,000 emails** | **$0.85** | $1.00 – $9.00 |
| Real SMTP verification | ✅ | Some ❌ |
| Disposable email detection | ✅ | Some ❌ |
| Catch-all domain detection | ✅ | Some ❌ |
| Role-based email detection | ✅ | Rare |
| Free provider detection | ✅ | Rare |
| CSV URL upload | ✅ | ❌ Most are JSON-only |
| Live progress tracking | ✅ | ❌ |
| Smart retry on failures | ✅ | ❌ |
| No external API key needed | ✅ | ❌ Many require 3rd-party accounts |

### Use Cases

- **Cold email outreach** — Verify your prospect list before sending to protect your sender reputation and avoid getting flagged as spam
- **Marketing campaigns** — Clean your email list to reduce bounce rates and improve deliverability metrics
- **CRM maintenance** — Remove invalid, disposable, and role-based emails from your database on a regular schedule
- **Lead generation** — Validate scraped email lists to ensure you're only reaching out to real people
- **E-commerce** — Verify customer email addresses at checkout to reduce failed order confirmations
- **Data enrichment pipelines** — Chain with other Apify actors: scrape emails → verify → export clean list

#### Why Choose Email Verifier Pro?

- ⚡ **Lightning Fast:** Defaults to 10 simultaneous connections. Verify massive lists in minutes, not hours.
- 🎯 **Deep SMTP Validation:** We don't just check syntax. We talk directly to the target mail server.
- 💰 **Cheapest Full-SMTP Validation:** Compute-based pricing allows for ultra-cheap verification compared to per-result services.
- 🎁 **100 Email Free Tier:** Users on the free Apify plan can verify up to 100 leads per run to test the accuracy before scaling!
- 🛡️ **Role-Based & Disposable Detection:** Automatically flags `info@`, `admin@`, and temporary inboxes.
- 🔗 **Keeps Your Original Data:** Upload a CSV with names, companies, and custom IDs. We'll append the verification results without throwing away your original columns!
- 📈 **Live Progress Tracking:** See valid/invalid ratios in real-time as your list processes.

### How It Works

Email Verifier Pro performs **7 checks** on every email address:

1. **Syntax validation** — Is the email format correct? (`user@domain.com`)
2. **MX record lookup** — Does the domain have a mail server configured?
3. **SMTP handshake** — Can we connect to the mail server and confirm the mailbox exists?
4. **Disposable detection** — Is it a temporary/throwaway email? (Mailinator, Guerrilla Mail, etc.)
5. **Role-based detection** — Is it a generic address? (`info@`, `support@`, `admin@`)
6. **Catch-all detection** — Does the domain accept emails to any address? (makes verification unreliable)
7. **Free provider detection** — Is it Gmail, Yahoo, Outlook, or another free email service?

### Input

You can provide emails in **three ways** (use any one or combine them):

#### Option 1: Paste emails directly

Use the **Email Addresses** field to paste a list of emails, one per line.

#### Option 2: CSV file URL

Paste a URL to a CSV file in the **CSV File URL** field. We automatically detect the email column — or you can specify it manually. Supports:

- Direct download links
- Google Sheets (published as CSV)
- Dropbox shared links

#### Option 3: Apify Dataset ID

If you've already scraped emails with another actor, paste the **Dataset ID** in the corresponding field. We'll read the emails directly — no need to export and re-upload.

#### Advanced Settings

| Setting | Default | Description |
|:---|:---|:---|
| Concurrency | 10 | Emails verified simultaneously (1–30) |
| Max Retries | 1 | Smart retry for temporary server errors |
| Timeout | 8s | Fast 8-second timeout per email (optimizes speed & cost) |
| Max Emails | No limit | Cap the number of emails per run (up to 100,000) |

### Output

Each email produces a result row containing all of your original input columns (if you used a CSV or Dataset), plus our appended verification fields:

```json
{
    "email": "john@company.com",
    "status": "valid",
    "confidence": "high",
    "is_reachable": "safe",
    "is_disposable": false,
    "is_role_based": false,
    "is_catch_all": false,
    "is_free_provider": false,
    "syntax_valid": true,
    "mx_exists": true,
    "smtp_reachable": true,
    "mx_host": "alt1.aspmx.l.google.com",
    "smtp_response": "250 OK — Mailbox exists",
    "error_message": "",
    "verified_at": "2026-06-14T12:00:00Z"
}
```

#### Business Status (`status`)

| Status | Meaning | Action |
|:---|:---|:---|
| `valid` | ✅ Mailbox exists and accepts email | **Safe to send** |
| `invalid` | ❌ Mailbox doesn't exist or domain has no mail server | **Remove from list** |
| `risky` | ⚠️ Disposable, role-based, or catch-all | **Review manually** (See filtering guide below) |
| `unknown` | ❓ Could not determine — server timeout or temporary error | **Retry later** |

***

#### 🎯 How to Filter Your Results

The best way to filter your data depends on your email sending strategy. Don't rely solely on `is_reachable` — use `status` and `confidence` to build the perfect list:

##### Strategy 1: Absolute Safety (Lowest Bounce Rate)

If you want to absolutely protect your domain reputation, only send to emails that are explicitly confirmed as valid:

- Filter: `status == "valid"`

##### Strategy 2: Maximum Reach (More Emails, Slightly Higher Risk)

Many B2B emails (like `info@company.com` or domains that are catch-all) get marked as `risky`. However, our verifier flags these with `confidence: "medium"` if it successfully connected to their SMTP server and confirmed they accept mail.
If you want to reach as many real people as possible:

- Filter 1: `status == "valid"`
- Filter 2: `status == "risky"` AND `confidence == "medium"`

> **Tip:** If an email is `status: "risky"` but `confidence: "low"`, it is highly recommended to **not** send to it.

#### Technical Details

We expose the raw technical signals so you can build your own custom logic:

- `is_reachable`: Raw Reacher API status (`safe`, `invalid`, `risky`, `unknown`)
- `smtp_reachable`: Boolean indicating if the SMTP server responded to our handshake
- `smtp_response`: The exact response message from the mail server (e.g., "550 User unknown")
- `mx_exists`: Boolean indicating if the domain has valid mail servers configured

Results are available as **JSON**, **CSV**, **Excel**, or **HTML** — download from the Dataset tab after the run completes.

### How to Reduce Email Bounce Rates

High bounce rates damage your sender reputation and can get your domain blacklisted. Here's how to use Email Verifier Pro to keep your lists clean:

1. **Before every campaign**: Run your list through Email Verifier Pro. Remove all `invalid` emails and review `risky` ones.
2. **Monthly CRM cleaning**: Schedule recurring runs to catch emails that have become invalid over time (employees leave, domains expire).
3. **At the point of collection**: Verify emails in real-time using the [Apify API](https://docs.apify.com/api/v2) to reject invalid addresses before they enter your database.

### Pricing

**$0.85 per 1,000 emails verified** — the most affordable full-SMTP verification on the Apify Store.

- No external API keys required
- No hidden fees or dual billing
- Pay only for what you use (charged per verified result)
- **Automatic discounts for Apify Subscribers:**
  - **Free & Starter ($49/mo):** $0.85 / 1k ($0.00085/email)
  - **Scale ($499/mo):** $0.80 / 1k ($0.00080/email)
  - **Business & Enterprise ($999+/mo):** $0.60 / 1k ($0.00060/email)

#### Cost Examples

| List Size | Standard Cost (Free/Starter) | Scale Plan Cost | Enterprise Cost |
|:---|:---|:---|:---|
| 1,000 emails | $0.85 | $0.80 | $0.60 |
| 10,000 emails | $8.50 | $8.00 | $6.00 |
| 50,000 emails | $42.50 | $40.00 | $30.00 |
| 100,000 emails | $85.00 | $80.00 | $60.00 |

### Frequently Asked Questions

#### How accurate is the verification?

We perform a **real SMTP handshake** with the recipient's mail server — the same process an actual email uses. This gives 95%+ accuracy for most providers. Catch-all domains are the exception: these accept all emails regardless, so we flag them as `risky` rather than giving a false `valid`.

#### How fast is the verification?

With the default concurrency of 10, you can verify approximately **1,000 emails every 2 to 3 minutes** depending on how quickly the recipient mail servers respond. Gmail and Outlook are typically fast; smaller providers may be slower.

#### Can I verify Gmail, Outlook, and Yahoo addresses?

Yes! We verify emails across all providers including Gmail, Outlook/Hotmail, Yahoo, custom domains, and more.

#### What happens if my run is interrupted?

Results are pushed to the dataset **in real-time** — if your run stops partway through, all emails verified up to that point are saved. Simply run the remaining emails in a new run.

#### Can I chain this with other Apify actors?

Absolutely! Scrape emails with any actor, then pass the Dataset ID directly to Email Verifier Pro. No export/import needed.

#### Is there a rate limit?

Yes — we cap at **100,000 emails per run** to ensure maximum throughput, stability, and zero socket timeouts. For larger pipelines (250k–500k+), simply run in parallel batches or stream leads via the Apify API.

### 🔌 Integrations & Workflow Automation (Clay, Make, Zapier)

Email Verifier Pro is built from the ground up to integrate seamlessly into modern cold outreach pipelines. At **$0.85 per 1,000 emails**, agencies save **85% to 90%** compared to traditional SaaS verifiers.

#### Cost Comparison (Save Up to 89%)

| Verification Provider | Price per 1,000 Emails | Real SMTP Check | Catch-All & Disposable |
| :--- | :---: | :---: | :---: |
| **NeverBounce** | $8.00 | ✅ | ✅ |
| **ZeroBounce** | $6.00 | ✅ | ✅ |
| **MillionVerifier** | $3.50 | ✅ | ✅ |
| **Email Verifier Pro** | **$0.85** | **✅** | **✅ (Save 85%+)** |

***

#### 1. How to Connect with Clay.com

You can verify prospect tables directly inside Clay without leaving your spreadsheet:

1. In your Clay table, add an **HTTP API** enrichment column.
2. Set the **Method** to `POST`.
3. Set the **Endpoint URL** to:
   ```text
   https://api.apify.com/v2/acts/blessiticus~email-verifier-pro/run-sync-get-dataset-items?token=YOUR_APIFY_API_TOKEN
   ```
4. Set the **Body (JSON)**:
   ```json
   {
     "emails": ["{{email}}"]
   }
   ```
5. Map the response fields: `status`, `is_deliverable`, and `confidence` right into your Clay columns!

***

#### 2. How to Connect with Make.com & Zapier

Automate list cleaning whenever new leads arrive from scrapers, webhooks, or CRM forms:

1. Add the official **Apify** module in Make or Zapier.
2. Select the **"Run Actor"** or **"Run Actor and Wait for Finish"** action.
3. Choose Actor: `blessiticus/email-verifier-pro`.
4. Pass your input:
   - For bulk lists: pass your public **Google Sheets CSV export URL** (`csvUrl`).
   - For single leads: map the lead's email into the `emails` array.
5. Filter your next step (e.g. Smartlead, Instantly, HubSpot) to only send to leads where `status == "valid"`.

***

#### 3. Self-Hosted n8n Workflows

Use the Apify node in n8n or send an HTTP POST request to trigger scheduled nightly CRM cleaning runs.

### API Usage & Code Examples

You can run this Actor programmatically using the [Apify API](https://docs.apify.com/api/v2) and official clients.

#### JavaScript/Node.js

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor("YOUR_USERNAME/email-verifier-pro").call({
    emails: ["test@gmail.com", "contact@company.com"],
    concurrency: 10
});

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

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("YOUR_USERNAME/email-verifier-pro").call(run_input={
    "emails": ["test@gmail.com", "contact@company.com"],
    "concurrency": 10
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

#### Apify CLI

```bash
echo '{
  "emails": [
    "test@gmail.com",
    "contact@company.com"
  ]
}' | apify call YOUR_USERNAME/email-verifier-pro --output-dataset
```

### Changelog

We actively maintain Email Verifier Pro to ensure maximum reliability and accuracy.

- **v1.1.0** — Added support for preserving all original input columns (like Names, Company, IDs) through the verification pipeline!
- **v1.0.6** — Improved automated daily health checks to guarantee 99.9% uptime.
- **v1.0.5** — Enhanced Apify dataset streaming for zero data loss during massive runs.

### 🔗 The Complete B2B Outbound Stack

Combine our specialized companion Actors to build an end-to-end automated lead generation and cold outreach pipeline:

| Tool | What It Does | Pricing |
| :--- | :--- | :--- |
| 🛡️ [**Email Verifier & Validator Pro**](https://apify.com/blessiticus/email-verifier-pro) | Verify & clean any email list with live SMTP 250 OK checks. Reduce bounce rates below 2%. | **$0.85 / 1,000** |
| 📍 [**Google Maps Leads Scraper + Emails**](https://apify.com/blessiticus/google-maps-leads-scraper-with-emails) | Extract local businesses, websites, phones, owner names & verified emails from Google Maps. | **$3.00 / 1,000** |
| 🎯 [**Lead Scraper: Apollo Alternative**](https://apify.com/blessiticus/lead-scraper) | Extract B2B decision-makers, verified emails, phone numbers & firmographics with zero limits. | **$1.50 / 1,000** |
| 🔍 [**B2B Work Email Finder**](https://apify.com/blessiticus/b2b-work-email-finder-5-1k-find-emails-linkedin-or-domain) | Find verified corporate emails using First Name, Last Name & Domain or LinkedIn profile URLs. | **$5.00 / 1,000** |

***

### ⭐ Love This Actor? Leave a Review!

If Email Verifier Pro helped clean your lists, cut bounce rates, or save you money compared to expensive SaaS alternatives, **please consider leaving a 5-star review on the Apify Store**!

Your reviews directly help support ongoing server maintenance, blacklist monitoring, and feature updates.

### Support & Reliability

This Actor is actively maintained. We strive for 100% reliability and are highly responsive to our users.

Found a bug, need a feature, or have a suggestion? Open an issue in our [GitHub Issues tab](https://github.com/zaleelbukhari/email-verifier-actor/issues) — we prioritize user feedback and respond within 24 hours.

# Actor input Schema

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

Paste email addresses to verify. One per line.

## `csvUrl` (type: `string`):

URL to a CSV file containing email addresses. Supports direct links, Google Sheets (published as CSV), and Dropbox links. The email column is auto-detected, or you can specify it below.

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

ID of an existing Apify dataset containing emails. Useful for chaining with other actors (e.g., scrape emails → verify them).

## `apifyToken` (type: `string`):

If your Dataset ID gives an 'Insufficient Permissions' error, paste your Personal Apify API Token here to give the Actor access to read it.

## `emailColumn` (type: `string`):

Name of the column containing email addresses in your CSV or dataset. Leave empty for auto-detection (looks for columns named 'email', 'e-mail', 'Email Address', etc.).

## `concurrency` (type: `integer`):

Number of emails to verify simultaneously. Higher = faster but may trigger rate limits on some mail servers.

## `maxRetries` (type: `integer`):

How many times to retry a verification if the mail server times out or returns a temporary error. Set to 0 to disable retries.

## `timeout` (type: `integer`):

Maximum time to wait for each email verification. Capped at 8 seconds to maximize verification speed and compute efficiency.

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

Maximum number of emails to verify in this run. Leave empty for no limit.

## `freeTierNotice` (type: `string`):

Try up to 100 emails for free using the Apify Free Trial (configure in your Apify settings).

## Actor input object example

```json
{
  "emails": [
    "test@gmail.com",
    "nonexistent12345@gmail.com"
  ],
  "csvUrl": "https://docs.google.com/spreadsheets/d/.../export?format=csv",
  "datasetId": "abc123def456",
  "emailColumn": "",
  "concurrency": 10,
  "maxRetries": 1,
  "timeout": 8,
  "freeTierNotice": " "
}
```

# Actor output Schema

## `defaultDatasetUrl` (type: `string`):

URL to the dataset containing the verification results

# 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",
        "nonexistent12345@gmail.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("blessiticus/email-verifier-pro").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",
        "nonexistent12345@gmail.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("blessiticus/email-verifier-pro").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",
    "nonexistent12345@gmail.com"
  ]
}' |
apify call blessiticus/email-verifier-pro --silent --output-dataset

```

## MCP server setup

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

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/rzWN5rWOZelwVxehV/builds/QzaNnslb0RsHgZYDY/openapi.json