# Free Bulk Email Verifier — Clean Your List Before You Send (`geniuslead/bulk-email-verifier`) Actor

Free email verification — only pay Apify platform costs. 7-layer check: Syntax, MX, SMTP, Catch-All, Disposable, DNSBL, Role-Based. Score 0-100, typo correction. Upload CSV, get a clean list. ZeroBounce/NeverBounce alternative. By GeniusLead

- **URL**: https://apify.com/geniuslead/bulk-email-verifier.md
- **Developed by:** [Genius Lead](https://apify.com/geniuslead) (community)
- **Categories:** Lead generation
- **Features:** Limited permissions
- **Stats:** 81 total users, 7 monthly users, 100.0% runs succeeded, 5 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-usage

## 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 — Zero Bounce Rate for 1 Cent, Not $1

> **They charge $0.008 per email. We charge $0.01 for a hundred.**
>
> Same SMTP technology. Same accuracy. Same catch-all detection. **80x less money leaving your wallet.**
>
> The "premium" tools hope you never do this math. Now you have.
>
> **Built by [GeniusLead.de](https://www.geniuslead.de)** — B2B lead generation that actually makes sense.

### The Math They Don't Want You To See

Let's talk about what email verification actually is: Your server sends a TCP packet to port 25. The mail server says "yes" or "no." That's it. That's the whole technology.

Now let's talk about what "premium" tools charge for this TCP packet:

| | **This Tool** | Tool Z\* | Tool N\* | Tool M\* |
|---|:---:|:---:|:---:|:---:|
| **1,000 emails** | **$0.10** | $8 | $8 | $3 |
| **10,000 emails** | **$1.00** | $65 | $50 | $29 |
| **100,000 emails** | **$10.00** | $350 | $300 | $189 |
| **SMTP Verification** | Yes | Yes | Yes | Yes |
| **Disposable Detection** | Yes (500+) | Yes | Yes | Yes |
| **Catch-All Detection** | Yes | Yes | Yes | Yes |
| **Role-Based Detection** | Yes | Yes | No | No |
| **Typo Auto-Correction** | Yes | Yes | No | No |
| **Free Provider Flagging** | Yes | No | No | No |
| **DACH-Optimized** | Yes | No | No | No |
| **API Key Required** | **No** | Yes | Yes | Yes |
| **Credit Card Required** | **No** | Yes | Yes | Yes |

*\*You know exactly which tools these are. They charge 80x more for sending the same TCP packet.*

**$0.01 per email. $1 for 10,000. That's the actual cost of verification.**

The rest? That's their marketing budget. Their office in Vegas. Their Series B investors expecting 40x returns on your email list.

### 7-Layer Deep Verification

Every email goes through **7 checks** — more than most "premium" tools:

```
  YOUR EMAIL                john.doe@gmial.com
      |
      v
  1. RFC 5322 SYNTAX        Valid format? Yes
      |
      v
  2. TYPO DETECTION          "gmial.com" --> Did you mean "gmail.com"?
      |
      v
  3. DISPOSABLE CHECK        tempmail.com? guerrillamail? 500+ domains checked
      |
      v
  4. ROLE-BASED CHECK        info@? sales@? support@? Flagged.
      |
      v
  5. FREE PROVIDER CHECK     Gmail? GMX? web.de? Flagged.
      |
      v
  6. MX RECORD LOOKUP        Does the domain have a mail server?
      |                      (with A-record fallback)
      v
  7. REAL-TIME SMTP CHECK    Connect to mail server. Ask if mailbox exists.
      |                      Detect catch-all servers.
      v
  RESULT                     valid | invalid | catch-all | unknown
                             + score 0-100 + detailed reason
```

### Why Does This Exist?

Because we got tired of paying rent on someone else's TCP connection.

Email verification is a **solved problem.** The code is simple. The infrastructure costs pennies. Yet somehow it became a $100M+ industry charging $0.008 per "yes or no" answer.

We built this for [GeniusLead](https://www.geniuslead.de) — our B2B lead generation platform. We needed to verify millions of emails. We looked at the prices. We laughed. Then we built our own.

Now you can use it too.

**$0.01 per email. Not $0.008. Not $0.003. One cent. For a hundred emails.**

### How to Use

#### Simple — Paste and Go

Paste emails separated by commas, newlines, or semicolons:

```
john@example.com, jane@company.de
max.mueller@firma.de
fake@tempmail.com; info@apple.com
```

#### Bulk — Up to 10,000 Emails

Paste your entire list. The Actor processes them in parallel with real-time SMTP verification.

#### Programmatic — JSON Input

```json
{
  "emails": ["john@example.com", "jane@company.de", "max@firma.de"],
  "concurrency": 15,
  "timeout": 12
}
```

### Input

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `emails` | string | **Yes** | — | Emails to verify (comma/newline/semicolon separated) |
| `concurrency` | number | No | 10 | Parallel checks (1-20). Higher = faster. |
| `timeout` | number | No | 10 | Seconds per SMTP check (1-30). |

### Output — What You Get Back

Every email returns a full verification report:

```json
{
  "email": "john.doe@gmail.com",
  "status": "valid",
  "valid": true,
  "score": 90,
  "reason": "Email address verified via SMTP",
  "isDisposable": false,
  "isRoleBased": false,
  "isFreeProvider": true,
  "isCatchAll": false,
  "hasMxRecords": true,
  "syntaxValid": true
}
```

#### Disposable Caught

```json
{
  "email": "test@guerrillamail.com",
  "status": "invalid",
  "valid": false,
  "score": 5,
  "reason": "Disposable/temporary email domain",
  "isDisposable": true
}
```

#### Typo Detected

```json
{
  "email": "john@gmial.com",
  "status": "invalid",
  "valid": false,
  "score": 5,
  "reason": "No MX or A records",
  "typoSuggestion": "john@gmail.com"
}
```

#### Role-Based Flagged

```json
{
  "email": "info@big-company.de",
  "status": "valid",
  "valid": true,
  "score": 85,
  "reason": "Email address verified via SMTP",
  "isRoleBased": true
}
```

### Score Guide

| Score | Verdict | What To Do |
|-------|---------|-----------|
| **90-100** | Verified | Safe to send |
| **70-89** | Likely valid | Send — minor flags (role-based or free provider) |
| **50-69** | Catch-all | Server accepts everything — can't confirm this specific address |
| **20-49** | Risky | Greylisting or timeout — consider removing |
| **0-19** | Dead | Invalid, disposable, or no mail server. Do not send. |

### Pricing

**$0.01 per email verified.** That's it.

| Emails | Cost Here | Cost at "Premium" Tools |
|--------|-----------|------------------------|
| 1,000 | **$0.10** | $3 - $8 |
| 10,000 | **$1.00** | $29 - $65 |
| 50,000 | **$5.00** | $150 - $300 |
| 100,000 | **$10.00** | $189 - $350 |

You save 80-97% on every single verification. Same SMTP check. Same result. Different price.

### DACH-Optimized

Built in Germany, for German-speaking markets:

- **40+ DACH email providers** recognized (GMX, web.de, t-online, freenet, posteo, bluewin.ch, a1.net...)
- **German typo correction** (gmx.ce -> gmx.de, wbe.de -> web.de, t-onlien.de -> t-online.de)
- **German role-based prefixes** (kontakt@, buchhaltung@, geschaeftsfuehrung@, bewerbung@...)

### Use Cases

#### Clean Your List Before a Campaign

Before you blast 5,000 cold emails, run them through here. Remove invalids. Flag disposables. Fix typos. Your bounce rate drops from 8% to under 2%. **Cost: $0.50 instead of $40.**

#### Validate Sign-Up Forms

User entered "john@gmial.com"? Show them "Did you mean gmail.com?" before they submit.

#### Audit Your CRM

How many of your 50,000 contacts have dead emails? Find out for **$5** instead of paying a "premium" tool $200.

#### Pre-Qualify Purchased Lists

Bought a lead list? Verify before importing. The $0.10 you spend here saves you $500 in sender reputation damage.

#### Stop Verifying. Start Generating.

Why verify emails you bought from shady data brokers? **[GeniusLead](https://www.geniuslead.de) generates fresh leads with pre-verified emails.** Skip the middleman. [Try it ->](https://apify.com/cherry_picker/geniuslead)

### Technical Details

- **Real-time SMTP** — direct connection to mail servers on port 25
- **MX Priority Sorting** — tries highest-priority mail server first
- **A-Record Fallback** — for domains without MX records
- **5-Minute MX Cache** — same domain = one DNS lookup (fast for bulk)
- **Catch-All Probe** — random address test to detect catch-all servers
- **Zero external APIs** — no third-party dependencies

### Limitations

- **Gmail/Google Workspace** — often returns catch-all (Google doesn't reject at SMTP level)
- **Rate limiting** — aggressive mail servers may throttle. Use concurrency 5-10 for sensitive domains.
- **Accuracy** — 85-95% industry standard. Catch-all domains reduce certainty.
- For best results on large lists: concurrency 10, timeout 15s.

### FAQ

**Why only $0.01?**
Because that's what it actually costs. The other tools aren't charging for technology — they're charging because you didn't know any better. Now you do.

**How does this compare to "premium" tools?**
Same core technology (SMTP verification). We add DACH-specific typo detection and free provider flagging they don't have. They add proprietary checks (spam trap scores) that require expensive third-party data. For 95% of use cases, the result is identical. The price is not.

**Can I do 100,000 emails?**
Yes. Split into batches of 10,000. Set memory to 2-4 GB and concurrency 10-15. Total cost: $10.

**Does it work with German business emails?**
Absolutely. Built and tested for DACH markets. Handles Umlauts, German TLDs, and DACH-specific providers.

**Why should I trust a $0.01 tool?**
Because the $0.008 tool uses the same SMTP check. The price difference isn't quality — it's margin. We run this on dedicated infrastructure with zero middlemen. You get the same TCP packet for less.

***

***

### You Just Verified Emails. Now Get The Leads.

This tool **verifies** emails. **[GeniusLead](https://www.geniuslead.de)** **finds** them.

#### What GeniusLead Does

Enter an industry + region. Get back:

- **Companies** — name, address, phone, website (from Google Maps)
- **Up to 5 decision makers per company** — CEO, HR, Sales, CTO, CMO
- **Verified email addresses** — the same SMTP tech that powers this verifier
- **LinkedIn profiles** — for every decision maker found
- **Quality scores** — so you call the best leads first
- **Excel export** — color-coded, ready for your CRM

#### Example

```
Input:  "IT Dienstleister in Munchen, 50 leads"

Output: 50 companies, each with:
        - Geschaftsfuhrer + email + LinkedIn
        - HR Manager + email + LinkedIn
        - Vertriebsleiter + email + LinkedIn
        - Quality score (green/yellow/red)
        - Complete company data
```

#### Pricing

**$0.05 per lead.** No subscription. No minimum. No contract.

50 verified B2B leads = $2.50. That's what other tools charge for a single page view.

**[Try GeniusLead on Apify ->](https://apify.com/cherry_picker/geniuslead)**

**[Visit geniuslead.de ->](https://www.geniuslead.de)**

***

### More Tools by GeniusLead

| Tool | What It Does | Link |
|------|-------------|------|
| **Email Verifier** | You're using it right now | This Actor |
| **GeniusLead** | Complete DACH B2B lead generation | [Try it](https://apify.com/cherry_picker/geniuslead) |

More tools coming soon. Follow [geniuslead.de](https://www.geniuslead.de) for updates.

***

**Built by [geniuslead.de](https://www.geniuslead.de)** — The smartest way to find and verify B2B contacts in DACH.

# Actor input Schema

## `emails` (type: `string`):

Paste emails separated by commas, newlines, or semicolons.

## `contactsCsv` (type: `string`):

Paste CSV text — the email column is auto-detected. Works with any CRM export format (Apollo, HubSpot, Salesforce, LinkedIn).

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

URL to a CSV or Excel (.xlsx) file. Email column is auto-detected. Supports Dropbox, Apify key-value store, or any public URL.

## `googleSheetsUrl` (type: `string`):

Paste a Google Sheets sharing URL. Sheet must be publicly accessible (Anyone with link → Viewer). Email column is auto-detected.

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

Pass a Dataset ID from another Apify actor (e.g., Email Finder, B2B Lead Finder, Apollo Scraper). Emails are auto-extracted from the dataset.

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

How many emails to verify in parallel (1-20). Higher = faster but more aggressive.

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

Max seconds per verification check (1-30). Increase for slow mail servers.

## Actor input object example

```json
{
  "emails": "hello@geniuslead.de, test@gmail.com, john.doe@example.com, fake@tempmail.com",
  "concurrency": 10,
  "timeout": 10
}
```

# 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@geniuslead.de, test@gmail.com, john.doe@example.com, fake@tempmail.com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("geniuslead/bulk-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": "hello@geniuslead.de, test@gmail.com, john.doe@example.com, fake@tempmail.com" }

# Run the Actor and wait for it to finish
run = client.actor("geniuslead/bulk-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": "hello@geniuslead.de, test@gmail.com, john.doe@example.com, fake@tempmail.com"
}' |
apify call geniuslead/bulk-email-verifier --silent --output-dataset

```

## MCP server setup

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