# Email Address Validator (2026) Letest (`datascoutapi/email-address-validator`) Actor

Email validator - verify 10000 emails/run. Bulk email validation checks MX records, disposable/role-based detection. Improve deliverability & reduce bounces. 5-layer validation, detailed reports & smart DNS caching. Fast, accurate, cost-effective email list cleaning. Start free!

- **URL**: https://apify.com/datascoutapi/email-address-validator.md
- **Developed by:** [halam](https://apify.com/datascoutapi) (community)
- **Categories:** Lead generation, Automation, MCP servers
- **Features:** Limited permissions
- **Stats:** 80 total users, 7 monthly users, 100.0% runs succeeded, 4 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.49 / 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.

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 Address Validator - Enterprise-Grade Email Verification

**Clean your email lists with lightning-fast validation. Verify up to 10,000 emails per run with comprehensive checks including syntax validation, DNS/MX verification, disposable email detection, and role-based identification.**

🎯 **Process up to 10,000 emails per run** | ⚡ **30-95% faster with smart optimizations** | 💰 **Cost-effective validation** | 🛡️ **500+ disposable services detected**

### Why Choose Email Address Validator?

✅ **Improve Deliverability** - Remove invalid emails before sending campaigns\
✅ **Reduce Costs** - Stop paying to send emails that bounce\
✅ **Protect Reputation** - Prevent sender score damage from invalid addresses\
✅ **Save Time** - Automated validation with intelligent DNS caching\
✅ **Get Insights** - Detailed analytics and comprehensive validation reports

### 🚀 Quick Start - Ready in 30 Seconds

#### Basic Input

```json
{
  "emails": [
    "user@gmail.com",
    "support@business.com", 
    "temp@10minutemail.com"
  ]
}
```

#### Advanced Configuration

```json
{
  "emails": ["user@gmail.com", "contact@company.com"],
  "checkMX": true,
  "checkDisposable": true,
  "checkRoleBased": true,
  "failFast": true,
  "timeout": 5000,
  "concurrency": 20,
  "outputFilter": "accept"
}
```

### 📊 What You Get - Comprehensive Validation

#### 🎯 Multi-Layer Validation System

| Feature | What It Does | Why It Matters |
|---------|--------------|----------------|
| **Syntax Validation** | RFC 5321-compliant format checking | Catch typos and formatting errors |
| **DNS/MX Verification** | Real mail server lookup | Verify domain can receive email |
| **Disposable Detection** | Identifies 500+ temporary email services | Block throwaway addresses |
| **Role-Based Detection** | Flags generic addresses (info@, support@) | Identify low-engagement contacts |
| **Reserved Domain Check** | Catches test domains (example.com, localhost) | Prevent test data in production |

#### ⚡ Performance That Scales

- **10,000 emails per run** - Process large lists in one go
- **Fail-Fast Mode** - 30-50% faster validation for invalid emails
- **Smart DNS Caching** - Up to 95% faster on repeated domains
- **Concurrent Processing** - Adjustable concurrency (1-50 simultaneous checks)
- **Optimized Memory** - Runs efficiently on minimal resources

### 📈 Sample Output

#### Individual Email Results

```json
{
  "email": "user@gmail.com",
  "valid": true,
  "score": 1.0,
  "risk": "LOW",
  "recommendation": "ACCEPT",
  "processingTimeMs": 4,
  "validation": {
    "syntax": true,
    "domain": true,
    "mailServer": true,
    "disposable": true,
    "roleBased": true
  },
  "fullDetails": {
    "syntax": {
      "valid": true,
      "message": "Valid email syntax"
    },
    "mxRecords": {
      "valid": true,
      "message": "5 MX records found",
      "records": ["gmail-smtp-in.l.google.com", "alt1.gmail-smtp-in.l.google.com"]
    },
    "disposable": {
      "valid": true,
      "message": "Not a disposable email"
    }
  }
}
```

#### Summary Statistics

```json
{
  "type": "SUMMARY",
  "total": 1000,
  "valid": 850,
  "invalid": 150,
  "risky": 75,
  "processingTimeMs": 12450,
  "averageTimePerEmail": 12.45,
  "performance": "EXCELLENT"
}
```

### 🎯 Understanding Results

#### Confidence Score (0.0 - 1.0)

Each email gets a weighted confidence score:

| Check | Weight | Purpose |
|-------|--------|---------|
| Syntax | 25% | Fundamental format validation |
| MX Records | 30% | Deliverability verification |
| Disposable | 25% | Quality assurance |
| Role-Based | 20% | Engagement potential |

#### Risk Levels & Recommendations

| Risk | Score Range | Action |
|------|-------------|--------|
| **LOW** | 0.8 - 1.0 | ✅ Safe to send |
| **MEDIUM** | 0.5 - 0.79 | ⚠️ Manual review suggested |
| **HIGH** | 0.0 - 0.49 | ❌ Do not send |

### 🔧 Configuration Options

#### Validation Settings

| Option | Type | Default | Description |
|--------|------|---------|-------------|
| `emails` | array | required | Email addresses to validate (1-10,000) |
| `checkMX` | boolean | true | Verify DNS MX records |
| `checkDisposable` | boolean | true | Detect disposable email services |
| `checkRoleBased` | boolean | true | Identify role-based addresses |

#### Performance Settings

| Option | Type | Default | Description |
|--------|------|---------|-------------|
| `failFast` | boolean | false | Exit early on failures (30-50% faster) |
| `timeout` | integer | 5000 | DNS timeout in ms (1000-30000) |
| `concurrency` | integer | 10 | Concurrent validations (1-50) |

#### Output Settings

| Option | Type | Default | Description |
|--------|------|---------|-------------|
| `outputFilter` | string | 'all' | Save only: 'all', 'accept', 'review', or 'reject' |

### 💼 Use Cases

#### 📧 Email Marketing

**Challenge:** High bounce rates hurt sender reputation\
**Solution:** Clean lists before campaigns, remove disposables

```json
{
  "emails": ["..."],
  "outputFilter": "accept",
  "failFast": true
}
```

#### 👤 User Registration

**Challenge:** Fake signups with throwaway emails\
**Solution:** Block temporary addresses, verify domains exist

```json
{
  "emails": ["..."],
  "checkDisposable": true,
  "checkMX": true
}
```

#### 📊 Data Quality

**Challenge:** Outdated customer databases\
**Solution:** Validate existing contacts, flag risky addresses

```json
{
  "emails": ["..."],
  "outputFilter": "review"
}
```

#### 🎯 Lead Generation

**Challenge:** Wasting time on invalid leads\
**Solution:** Filter disposables/role-based, prioritize quality

```json
{
  "emails": ["..."],
  "checkRoleBased": true,
  "checkDisposable": true
}
```

### 🚀 Performance Features

#### ⚡ Fail-Fast Mode

- **What:** Exits validation immediately when critical failure detected
- **Benefit:** 30-50% faster validation for invalid emails
- **Best For:** Large list cleanup, high-volume processing

#### 🛡️ Reserved Domain Detection

- **What:** Catches test/documentation domains (example.com, localhost)
- **Benefit:** Prevents test data from polluting production databases
- **Always Active:** Cannot be disabled (critical safety feature)

#### 🚀 Smart DNS Caching

- **What:** Automatically caches DNS lookups for 5 minutes
- **Benefits:** 30-40% faster when domains repeat, 95%+ faster for second batch
- **Example:** 1,000 emails with 100 duplicate domains = ~70% faster validation

### 🏆 Why Choose Our Validator?

#### **Performance Advantages:**

- ✅ **Better Accuracy:** 1.0 score vs 0.85 for valid emails
- ✅ **6x Faster:** 4ms vs 24ms processing time
- ✅ **Detailed Reports:** Full validation breakdown vs basic status
- ✅ **Smarter Logic:** Nuanced scoring vs binary Send/Don't Send
- ✅ **Better Analysis:** Detects reserved domains + role-based patterns
- ✅ **Consistent Speed:** 2-8ms vs unpredictable timeouts
- ✅ **More Comprehensive:** 5-layer validation vs basic checks
- ✅ **Professional Output:** Clean table format + detailed insights
- ✅ **Enterprise Ready:** Handles 10,000 emails vs limited batches

#### **Why Choose Our Actor:**

✅ **Most Accurate** - 100% correct identification\
✅ **Most Detailed** - Complete validation breakdown\
✅ **Most Reliable** - Consistent performance\
✅ **Most Professional** - Enterprise-ready output\
✅ **Best Value** - Superior features at competitive cost

### 🔒 Technical Specifications

| Metric | Value |
|--------|-------|
| **Speed** | ~100-200 emails/second |
| **Capacity** | Up to 10,000 emails per run |
| **Memory** | Optimized for minimal resource usage |
| **Concurrency** | 1-50 simultaneous validations |
| **DNS Timeout** | 1-30 seconds (configurable) |
| **Reliability** | Built with Apify SDK for enterprise stability |

#### **📊 10,000 Email Performance**

**Processing Time:**

- **Best Case:** 20-40 seconds (cached domains, valid emails)
- **Average Case:** 2-5 minutes (mixed validation)
- **Worst Case:** 8-15 minutes (many timeouts, invalid emails)

**Optimal Configuration for 10K emails:**

```json
{
  "concurrency": 30,
  "failFast": true,
  "timeout": 3000
}
```

#### **⚠️ Potential Bottlenecks**

1. **DNS rate limiting** - Some providers limit queries
2. **Network latency** - Affects MX record lookups
3. **Memory growth** - Large result objects for detailed validation

### 🎯 Perfect For

- **Email Marketing Teams** - Clean lists, improve deliverability
- **CRM Managers** - Maintain data quality, reduce bounces
- **Lead Generation** - Validate prospects, score quality
- **Developers** - Integrate validation into apps/workflows
- **Small Businesses** - Cost-effective email verification
- **Enterprise** - Scale validation for large datasets

### 🚀 Get Started Now

1. **Add emails** to the input field
2. **Configure options** (or use defaults)
3. **Click Start** and get results in seconds
4. **Download clean data** ready for your campaigns

**Ready to clean your email lists?** Start validating now and see the difference professional email validation makes!

### 🔗 Other Actors

**DomainDaddy – Domain Intelligence & WHOIS Lookup**\
Provides domain availability and expiry dates, WHOIS & RDAP data, DNS records (A, MX, NS, TXT), IP geolocation, and ASN details. Calculates domain age, supports batch processing, and works with 70+ TLDs. Handles errors gracefully and delivers clean, structured JSON output.\
Check it out: https://apify.com/datascoutapi/domaindaddy

**DNS Lookup & Security Intelligence**\
Scrapes 22 data points, including 10 DNS records (A, AAAA, MX, TXT, NS, CNAME, SOA, SRV, PTR, CAA), plus email security analysis (SPF, DKIM, DMARC), SSL certificate checks, and domain monitoring. Processes up to 100 domains per batch with security scoring.\
Learn more: https://apify.com/datascoutapi/dns-lookup

### 📬 Contact & Support

Have questions, need help, or interested in a private or custom instance?\
Reach our team anytime at datascoutapi@gmail.com

***

*Built with enterprise-grade reliability. Trusted by marketers, developers, and businesses worldwide.*

### Keywords

email address validation, email address verifier, email address checker, email validation, email verifier, email checker, bulk email validation, email list cleaning, disposable email detection, mx record check, email deliverability, zeroBounce alternative, neverbounce alternative, hunter.io alternative, email hygiene, lead validation, crm data cleaning, email bounce prevention

### Local testing

This actor delegates validation to a remote verify server. It reads the
connection from (in priority order): the input field → an environment variable
→ a localhost default.

| Setting     | Input field   | Environment variable |
|-------------|---------------|----------------------|
| Server URL  | `verifyUrl`   | `VERIFY_URL`         |
| Auth token  | `verifyToken` | `VERIFY_TOKEN`       |

#### Run it locally

1. Copy the env template and fill in your real values:
   ```bash
   cp .env.example .env
   # edit .env and set VERIFY_URL and VERIFY_TOKEN
   ```
   `.env` is git-ignored — never commit it.

2. Install dependencies and run with Node's built-in env-file loader (Node 20+):
   ```bash
   npm install
   node --env-file=.env src/main.js
   ```
   No extra dependency (e.g. `dotenv`) is required.

#### On Apify

Do not use `.env` on Apify. Set `VERIFY_URL` and `VERIFY_TOKEN` as Actor
environment variables in the Console, and mark `VERIFY_TOKEN` as **Secret**.
Then each run only needs the `emails` input.

#### Notes

- Keep `requestBatchSize` at ~20–30 when `checkSMTP` is `true` — the verify
  server sits behind Cloudflare's ~100s request cap. Use 100 only for
  syntax/MX-only runs.
- Keep `concurrency` low (≈5) for a single-IP SMTP setup, and never run two
  actor runs at once against the same verify server.

# Actor input Schema

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

List of email addresses to validate (up to 10,000)

## `verifyUrl` (type: `string`):

URL of the verify server endpoint. Falls back to the VERIFY_URL env var, then to the localhost default.

## `verifyToken` (type: `string`):

Bearer token that must match the server's VERIFY_TOKEN. Prefer setting this as a secret env var (VERIFY_TOKEN) on the Actor instead of per run.

## `checkMX` (type: `boolean`):

Verify DNS MX records for deliverability

## `checkSMTP` (type: `boolean`):

Perform a live SMTP RCPT TO probe. Slower and rate-limited — keep concurrency low (5) for a single-IP setup.

## `checkDisposable` (type: `boolean`):

Detect temporary/disposable email services

## `checkRoleBased` (type: `boolean`):

Identify generic addresses (info@, support@, etc.)

## `requestBatchSize` (type: `integer`):

Emails per request to the verify server. Up to ~100 is fine for SMTP runs (Nginx allows 600s; Cloudflare proxy is off). Go higher for syntax/MX-only runs.

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

Number of simultaneous requests to the verify server. Keep low (5) for a single-IP SMTP setup — one IP/HELO = one rate budget.

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

Per-request timeout in milliseconds. Nginx allows up to 600s; set high enough to cover a full SMTP batch.

## `outputFilter` (type: `string`):

Filter results by recommendation

## Actor input object example

```json
{
  "emails": [
    "hello@company.com",
    "test@gmail.com"
  ],
  "verifyUrl": "https://mail.toolka.com/verify",
  "checkMX": true,
  "checkSMTP": true,
  "checkDisposable": true,
  "checkRoleBased": true,
  "requestBatchSize": 100,
  "concurrency": 5,
  "timeout": 300000,
  "outputFilter": "all"
}
```

# Actor output Schema

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

Complete validation results for all processed emails

# 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": [
        "hello@company.com",
        "test@gmail.com"
    ],
    "verifyUrl": "https://mail.toolka.com/verify"
};

// Run the Actor and wait for it to finish
const run = await client.actor("datascoutapi/email-address-validator").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": [
        "hello@company.com",
        "test@gmail.com",
    ],
    "verifyUrl": "https://mail.toolka.com/verify",
}

# Run the Actor and wait for it to finish
run = client.actor("datascoutapi/email-address-validator").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": [
    "hello@company.com",
    "test@gmail.com"
  ],
  "verifyUrl": "https://mail.toolka.com/verify"
}' |
apify call datascoutapi/email-address-validator --silent --output-dataset

```

## MCP server setup

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

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/sR02Tc3f3Fr0nqLt3/builds/W5AfNqOe1fFSXkEV6/openapi.json