# Email Verifier Deliverability Scraper (`gocreative.ai/email-verifier-deliverability`) Actor

Verify bulk email lists across 8 layers: syntax, MX, SMTP, catch-all, disposable, role-based, free provider, and tag detection. Returns a 0-100 deliverability score, risk tier (safe/risky/bad), and per-check flags. Pay-per-result $0.50/1k emails. No external API — 100% self-contained.

- **URL**: https://apify.com/gocreative.ai/email-verifier-deliverability.md
- **Developed by:** [GoCreative AI](https://apify.com/gocreative.ai) (community)
- **Categories:** Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 leads

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/platform/actors/running/actors-in-store#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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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 — 8-Layer Deliverability Check, $0.50/1k

### 📊 Example output (real run)

![Sample output](https://api.apify.com/v2/key-value-stores/1ztQFHwG8acESTazI/records/email-verifier-deliverability-sample)

A real record from a live run — clean structured data, exported as CSV / JSON / Excel or via API.


**The only Apify email verifier that runs 8 independent checks, scores every address 0–100, classifies catch-all domains without ambiguity, and costs 50% less than the category leader — all with zero external API dependency.**

---

### What can the Email Verifier check?

Before every send, your list needs more than a syntax check. This actor runs **8 independent verification layers** on every address:

| # | Check | What it catches |
|---|---|---|
| 1 | **Syntax** | Malformed addresses (missing @, invalid chars, bad TLD) |
| 2 | **MX Records** | Domains that cannot receive email (no mail server) |
| 3 | **SMTP Reachability** | Mailboxes that are confirmed deliverable or rejected |
| 4 | **Catch-All Detection** | Domains that accept any address — high bounce risk |
| 5 | **Disposable Providers** | Temp-mail, mailinator, guerrilla, 200+ known providers |
| 6 | **Role-Based Addresses** | info@, support@, admin@, noreply@ — shared inboxes |
| 7 | **Free Provider** | Gmail, Yahoo, Outlook, Hotmail, iCloud |
| 8 | **Tag / Alias** | +suffix addresses that may route to filters |
| ✦ | **SPF Record** | Domain authentication bonus signal |

**Output per email:**
- `deliverability_score` — 0–100 composite score
- `risk_tier` — `safe` / `risky` / `bad`
- `status` — `valid` / `risky` / `invalid` / `disposable` / `role` / `catch_all`
- `reason` — human-readable explanation (great for audit trails)
- `name_hint` — best-effort name parsed from the address handle (e.g. `john.smith@` → `John Smith`)
- Per-layer boolean flags for every check

---

### How to verify emails in bulk — step by step

**Option A: Paste an email array (fastest)**

1. Open the actor and go to **Input**
2. Paste your list in the `emails` field as a JSON array:
   ```json
   ["john@acme.com", "info@company.org", "throwaway@mailinator.com"]
````

3. Click **Run** — results appear in the **Dataset** tab in seconds

**Option B: Upload a CSV file**

1. Host your CSV publicly (Google Drive, S3, Dropbox) — one email per row, first column
2. Paste the URL into the `csvUrl` field
3. Run — the actor fetches, deduplicates, and verifies the full list

**Reading the output table:**

- `safe` (green) — high confidence deliverable, proceed to send
- `risky` (yellow) — catch-all domains or inconclusive SMTP — decide manually
- `bad` / `disposable` / `invalid` (red) — remove from list immediately

***

### How much does email verification cost?

**This actor charges $0.50 per 1,000 emails verified.** You pay only for results — not for Apify platform usage.

| Service | Price per 1,000 | External API dep? | Catch-all score? | Enrichment? |
|---|---|---|---|---|
| **This actor** | **$0.50** | **None** | **✅ scored** | **✅ name hint** |
| account56 / Million Verifier (Apify) | $1.00 | ✅ MV API | ❌ binary only | ❌ |
| michael.g Email Verifier (Apify) | $0.60 | None | ❌ limited | ❌ |
| ZeroBounce (standalone) | $8.00 | Yes | Partial | Partial |
| NeverBounce (standalone) | $8.00 | Yes | Partial | ❌ |
| Kickbox (standalone) | $5.00 | Yes | Partial | ❌ |

**Zero external API dependency** means this actor can never break because a third-party service has downtime or changes its API. Every check runs on direct DNS + SMTP probes from the actor container.

***

### Output examples (real results)

```json
[
  {
    "email": "john.smith@acme.com",
    "normalized": "john.smith@acme.com",
    "domain": "acme.com",
    "syntax_valid": true,
    "has_mx": true,
    "mx_host": "aspmx.l.google.com",
    "smtp_reachable": true,
    "is_catch_all": false,
    "is_disposable": false,
    "is_role_based": false,
    "is_free_provider": false,
    "has_tag": false,
    "has_spf": true,
    "deliverability_score": 97,
    "risk_tier": "safe",
    "status": "valid",
    "reason": "All 8 checks passed. High deliverability.",
    "name_hint": "John Smith",
    "verified_at": "2026-07-01T12:00:00Z"
  },
  {
    "email": "throwaway@mailinator.com",
    "normalized": "throwaway@mailinator.com",
    "domain": "mailinator.com",
    "syntax_valid": true,
    "has_mx": true,
    "is_disposable": true,
    "deliverability_score": 2,
    "risk_tier": "bad",
    "status": "disposable",
    "reason": "mailinator.com is a known disposable/temporary email provider.",
    "name_hint": null,
    "verified_at": "2026-07-01T12:00:00Z"
  },
  {
    "email": "info@example-corp.com",
    "normalized": "info@example-corp.com",
    "domain": "example-corp.com",
    "syntax_valid": true,
    "has_mx": true,
    "smtp_reachable": null,
    "is_catch_all": null,
    "is_disposable": false,
    "is_role_based": true,
    "is_free_provider": false,
    "has_spf": true,
    "deliverability_score": 62,
    "risk_tier": "risky",
    "status": "role",
    "reason": "Role-based address (info@) — shared inbox, low reply rate.",
    "name_hint": null,
    "verified_at": "2026-07-01T12:00:00Z"
  }
]
```

The **summary** in the Key-Value Store gives you aggregate stats:

```json
{
  "total_verified": 500,
  "valid": 312,
  "risky": 88,
  "bad": 54,
  "disposable": 31,
  "role_based": 15,
  "catch_all": 19,
  "safe_pct": 62.4,
  "verified_at": "2026-07-01T12:00:00Z"
}
```

***

### Other GoCreative data tools

Pair this actor with our full data stack for a complete outbound pipeline:

- **[Google Maps Lead Extractor](https://apify.com/store)** — verified local business contacts from any city or ZIP code
- **[Realtor.com Pro Leads](https://apify.com/store)** — active real estate agent contacts
- **[SEC Form D Startup Funding Leads](https://apify.com/store)** — recently funded companies + investor contacts
- **[People Enrichment API](https://api.gocreativeai.com)** — name + company + verified work email at $0.15/lookup

***

### Frequently Asked Questions

#### What is a catch-all email domain?

A catch-all (or "accept-all") domain is configured to accept any incoming email, even to mailboxes that don't exist. This means an SMTP probe returns `250 OK` for `xyz@example.com` even if that mailbox is empty — you only find out when you send a real campaign and get a silent bounce.

This actor probes the domain with a random UUID address to detect catch-all behavior and clearly marks those results as `status: catch_all` with a reduced deliverability score, rather than returning a misleading "valid."

#### Why does Microsoft / Office 365 email show as risky?

Microsoft 365 and Exchange Online reject SMTP probes from most cloud IPs by default (a spam-protection measure). This means the SMTP layer returns `null` (inconclusive) for these domains. The actor still performs the other 7 checks and scores accordingly — a legitimate O365 mailbox typically scores 70–85/100 (risky tier) because SMTP is inconclusive, not because the address is bad.

**Recommended approach:** treat `risky` O365 addresses as warm-sendable but watch bounce rates closely.

#### How accurate is this verifier?

| Check | Accuracy |
|---|---|
| Syntax, MX, disposable, role, free-provider, tag | ~100% (deterministic) |
| SPF | ~100% (DNS) |
| SMTP reachability | ~60–80% (port 25 accessible from Apify cloud) |
| Catch-all detection | ~70% (only when SMTP is accessible) |

The actor never returns a false "valid" for an address that is syntactically wrong, from a no-MX domain, or from a disposable provider. These are the highest-impact catches.

#### Is this legal to use?

Email verification of your own lists (lists where recipients have opted in or are existing contacts) is legal in all major jurisdictions. This actor does not collect email addresses — it only verifies addresses you already have. Comply with GDPR, CAN-SPAM, CASL, and any applicable data-handling laws in your jurisdiction.

#### What if I have more than 10,000 emails?

Schedule multiple runs (the actor picks up where you left off when using CSV input) or split your list into batches of up to 10,000 per run.

***

*Need help or have a feature request? Contact support via the Apify actor messaging system.*

# Actor input Schema

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

List of email addresses to verify (up to 10,000 per run). Each entry should be a valid RFC 5321 email string. Use this OR 'csvUrl', not both.

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

URL of a publicly accessible CSV file with email addresses in the first column (header row optional). Use this OR 'emails', not both.

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

Maximum number of emails to verify in this run (cap: 10,000). Duplicates are automatically removed.

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

Number of emails to verify in parallel. Higher = faster but more network load. Default 10 is a good balance.

## Actor input object example

```json
{
  "emails": [
    "john.smith@acme.com",
    "info@example.org",
    "throwaway@mailinator.com",
    "sarah.jones@techfirm.co"
  ],
  "csvUrl": "https://example.com/my-email-list.csv",
  "maxEmails": 10000,
  "concurrency": 10
}
```

# Actor output Schema

## `verifiedEmails` (type: `string`):

No description

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

No description

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("gocreative.ai/email-verifier-deliverability").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("gocreative.ai/email-verifier-deliverability").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call gocreative.ai/email-verifier-deliverability --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=gocreative.ai/email-verifier-deliverability",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Email Verifier Deliverability Scraper",
        "description": "Verify bulk email lists across 8 layers: syntax, MX, SMTP, catch-all, disposable, role-based, free provider, and tag detection. Returns a 0-100 deliverability score, risk tier (safe/risky/bad), and per-check flags. Pay-per-result $0.50/1k emails. No external API — 100% self-contained.",
        "version": "0.1",
        "x-build-id": "JGZmxJrWGVX5fmCqq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/gocreative.ai~email-verifier-deliverability/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-gocreative.ai-email-verifier-deliverability",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/gocreative.ai~email-verifier-deliverability/runs": {
            "post": {
                "operationId": "runs-sync-gocreative.ai-email-verifier-deliverability",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/gocreative.ai~email-verifier-deliverability/run-sync": {
            "post": {
                "operationId": "run-sync-gocreative.ai-email-verifier-deliverability",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "emails": {
                        "title": "Email Addresses",
                        "type": "array",
                        "description": "List of email addresses to verify (up to 10,000 per run). Each entry should be a valid RFC 5321 email string. Use this OR 'csvUrl', not both.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "csvUrl": {
                        "title": "CSV File URL",
                        "type": "string",
                        "description": "URL of a publicly accessible CSV file with email addresses in the first column (header row optional). Use this OR 'emails', not both.",
                        "default": ""
                    },
                    "maxEmails": {
                        "title": "Max Emails",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of emails to verify in this run (cap: 10,000). Duplicates are automatically removed.",
                        "default": 10000
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Number of emails to verify in parallel. Higher = faster but more network load. Default 10 is a good balance.",
                        "default": 10
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
