# B2B Email Verifier — MX, SMTP, Catch-all & Risk Scoring (`noniner/b2b-email-verifier`) Actor

Verify emails for deliverability before you send. Give it an email list; get back syntax check, MX records, SMTP probe and catch-all/risk classification per address.

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

## Pricing

from $44.00 / 1,000 email verifieds

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

## B2B Email Verifier — MX, SMTP, Catch-all & Risk Scoring

> **⚑ Beta — rounding off the last nine.** This Actor is live and fully usable today; a polished v1 is due **October 28, 2026**. Current rough edge: cloud runs verify on MX records plus heuristics (outbound SMTP port 25 is blocked on the runners), so inbox-level confirmation isn’t available yet.

**Stop your cold emails bouncing.** Paste a list of email addresses and this Actor hands back a deliverability verdict for each one: syntax check, live MX lookup, mail-provider detection, an SMTP mailbox probe, catch-all detection, free / role / disposable / gibberish classification, and a single **0–100 confidence score** with a plain-English reason. No API keys, no monthly subscription, no account to create — it runs on pure DNS and SMTP.

You bring the list. It hands back a clean, scored list you can safely send to.

***

### The flow

```
1. Paste emails                 2. Verify (DNS + SMTP)            3. Get a scored list
   from your CRM / scraper   →      syntax · MX · provider    →      status · confidence ·
   / lead tool                      · SMTP · catch-all               reason · flags
```

1. **Paste the emails** you want to check into the `emails` field — straight from your CRM export, a scraper dataset, or a lead tool. One per line.
2. **Run the Actor.** Each address goes through a deterministic decision tree: syntax → classification → MX lookup → SMTP probe → score.
3. **Read back a verdict per email** — `deliverable`, `risky`, `undeliverable`, `unknown` or `invalid`, each with a confidence number and the reasoning. Filter out the junk before it ever hits your sending domain.

***

### What you get per email

For every address, the Actor runs:

1. **Syntax validation** — a pragmatic RFC-5322-ish check that rejects the common garbage (`foo@@bad`, missing TLD, 254-char overruns) while accepting real-world dotted / plus / dashed local parts. Bad syntax short-circuits to `invalid`.
2. **Classification (deterministic, no network):** `isFree` (Gmail / Outlook / Yahoo / iCloud / Proton …), `isDisposable` (Mailinator / Guerrilla / 10-minute-mail and ~100 throwaway domains), `isRole` (`info@`, `sales@`, `support@`, `admin@`, `hello@` …), and `isGibberish` (random/consonant-heavy or digit-heavy local parts).
3. **MX lookup** — resolves the domain's real mail exchangers (with an A-record fallback). No MX and no fallback → `undeliverable`, cannot receive mail. Captures `mxHost` and maps it to a `mailProvider` (Google Workspace, Microsoft 365, Zoho, Proofpoint, Mimecast, Fastmail, …).
4. **Live SMTP mailbox probe** (optional, `smtpCheck`) — connects to the MX on port 25 and speaks minimal SMTP (`HELO` → `MAIL FROM` → `RCPT TO`) to see whether the mailbox is accepted (`250`), rejected (`550`) or greylisted (`4xx`). It then runs a **catch-all probe** against a random non-existent address at the same domain — if that is *also* accepted, the domain is flagged `isCatchAll` and the positive result is downgraded (acceptance is no longer proof the mailbox exists).
5. **Score** — all signals collapse into a `status`, a `confidence` (0–100) and a human `reason`, ordered strongest-signal-first.

***

### Three ways people use it

- **Cold-email & outreach teams** — run every list through verification before loading it into your sequencer to cut **bounce rates**, protect sender reputation and stay out of spam folders. A free, no-subscription **ZeroBounce / NeverBounce / Kickbox alternative** that bills only per email checked.
- **RevOps & CRM hygiene** — bulk **list cleaning** of a CRM export: drop `undeliverable` rows, flag `catch-all` and `role-based` inboxes, and tag disposable sign-ups before they pollute reporting.
- **Lead-gen & data pipelines** — chain it after an email finder or scraper so every address you collect ships pre-scored. Pairs naturally with the Email Finder and Company Enrichment actors below.

***

### Input

| Field | Type | Notes |
|---|---|---|
| `emails` | array | **Required.** Email addresses to verify, one per line. |
| `smtpCheck` | boolean | Attempt the live SMTP mailbox probe. Default `true`. (See the note on port 25 below.) |
| `fromAddress` | string | Envelope sender used in the SMTP `MAIL FROM`. Use a real domain you control for best results. Default `verify@example.com`. |
| `maxResults` | integer | Cap how many emails to verify. Default `1000`. |
| `maxConcurrency` | integer | How many emails to verify in parallel. Default `10`. |

#### Minimal input example

```json
{
  "emails": [
    "support@shopify.com",
    "ceo@stripe.com",
    "this-user-does-not-exist-xyz@gmail.com",
    "foo@mailinator.com"
  ],
  "smtpCheck": true
}
```

***

### Output example

One record per email:

```json
{
  "email": "ceo@stripe.com",
  "valid": true,
  "status": "risky",
  "confidence": 55,
  "reason": "Mailbox accepted, but the domain is catch-all so acceptance is not proof of existence. Role-based (shared) mailbox, not a specific person.",
  "domain": "stripe.com",
  "mxHost": "aspmx.l.google.com",
  "mailProvider": "Google Workspace",
  "isFree": false,
  "isRole": true,
  "isDisposable": false,
  "isGibberish": false,
  "isCatchAll": true,
  "smtpResult": "ok",
  "smtpCode": 250,
  "smtpMessage": "2.1.5 OK"
}
```

`status` is one of `deliverable` · `risky` · `undeliverable` · `unknown` · `invalid`. `smtpResult` is one of `ok` · `rejected` · `greylisted` · `blocked` · `error` · `skipped`.

***

### A note on SMTP from the cloud

Be aware of one real limitation: **Apify's datacenter blocks outbound port 25.** That means the strongest SMTP verdicts — a confirmed `deliverable` (RCPT `250`) or `undeliverable` (RCPT `550`) — will **rarely fire from the default datacenter**. When the port is unreachable the probe returns `smtpResult: "blocked"` and the Actor **falls back to MX + heuristic scoring** (typically `status: "risky"` or `"unknown"`), rather than wrongly marking the address dead.

Everything else — syntax, MX lookup, provider detection, and free / role / disposable / gibberish / catch-all classification — works fully from the cloud. If you need live SMTP confirmation at scale, run the Actor from an **egress with port 25 open** (your own server, or a proxy that permits it); the full `250`/`550` discrimination then kicks in automatically. The `reason` field and the run `SUMMARY` always tell you whether port 25 was reachable, so a verdict is never silently overstated.

***

### Pay-per-event pricing

This Actor uses **pay-per-event** billing with a single event:

| Event | Charged when |
|---|---|
| `email-verified` | Once per email that was run through the checks (syntax, MX, provider, classification and the SMTP probe). Invalid-syntax lines are processed and counted too. |

At **$0.10 per email** there is no monthly commitment and no seat — you pay only for what you verify.

***

### Setup

**No API keys. No account. No configuration.** The Actor uses Node's built-in DNS and TCP networking only — there is nothing to set up. Just give it emails and run.

***

### Use it from an AI agent (Apify MCP server)

This Actor is available through the [Apify MCP server](https://mcp.apify.com), so AI agents (Claude, ChatGPT, or anything that speaks MCP) can call it as a tool — hand it a list of `emails` and read back the scored verdicts — with no custom integration code.

***

### Run it locally

```bash
npm install
## put your input in storage/key_value_stores/default/INPUT.json
apify run -p
```

Running it locally (or from any host with outbound port 25 open) also unlocks the full live SMTP `deliverable` / `undeliverable` verdicts that the Apify datacenter cannot reach.

***

### Chain it

**This Actor is a building block in the No Niner B2B suite.** Wire it to the next step with no code in the **Integrations** tab (trigger: *Run succeeded* → start the next Actor), or run them in sequence.

- ⬆️ Upstream: [Email Finder](https://apify.com/noniner/email-finder-scraper) and [B2B CRM Enricher](https://apify.com/noniner/b2b-crm-enricher) — collect the emails first.
- ⬇️ Next: [AI Cold Email Personalizer](https://apify.com/noniner/ai-cold-email-personalizer) and [B2B Cold Email Sequence Writer](https://apify.com/noniner/b2b-cold-outreach-sequencer) — only mail the verified addresses.

### Related actors

- [Email Finder](https://apify.com/noniner/email-finder-scraper) — Find email addresses for any domain by crawling the homepage plus contact / about / team pages. Feed its output straight into this verifier.
- [AI Cold Email Personalizer](https://apify.com/noniner/ai-cold-email-personalizer) — Turn a list of domains into personalized cold-email openers that reference something real about each company.
- [Company Enrichment API](https://apify.com/noniner/ai-company-enrichment) — Turn domains into structured company profiles — firmographics, contacts, socials and ICP fit.

***

Built by the No Niner team.

# Actor input Schema

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

Email addresses to verify. One per line.

## `smtpCheck` (type: `boolean`):

Attempt live SMTP mailbox probe (may be blocked from datacenter IPs; falls back to MX+heuristics).

## `fromAddress` (type: `string`):

The envelope sender address used in the SMTP probe (MAIL FROM). Use a real domain you control for best results.

## `maxResults` (type: `integer`):

Max emails to verify. One pay-per-event charge per email verified.

## `maxConcurrency` (type: `integer`):

How many emails to verify in parallel.

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

Optional. Read the inputs from a previous Actor run's dataset — for no-code chaining via the Integrations tab.

## `datasetField` (type: `string`):

Which dataset field to read. Leave blank to auto-detect.

## Actor input object example

```json
{
  "emails": [
    "support@shopify.com",
    "ceo@stripe.com"
  ],
  "smtpCheck": true,
  "fromAddress": "verify@example.com",
  "maxResults": 1000,
  "maxConcurrency": 10
}
```

# Actor output Schema

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

All email verification records in the default dataset.

# 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": [
        "support@shopify.com",
        "ceo@stripe.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("noniner/b2b-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": [
        "support@shopify.com",
        "ceo@stripe.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("noniner/b2b-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": [
    "support@shopify.com",
    "ceo@stripe.com"
  ]
}' |
apify call noniner/b2b-email-verifier --silent --output-dataset

```

## MCP server setup

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