# Email Verifier | 13 Verdicts, Spamtrap Detection | $0.15/1k (`smtping/email-verifier`) Actor

Email verification against 150M spamtraps, 70M complainers, 1M spambots and bot clickers, 3,500+ disposable domains monitored daily. 13 verdicts incl. typo and catch-all. From $0.15/1k, unknown results free, 25 free credits daily. Paste emails or a CSV URL. Bring your own SMTPing API key.

- **URL**: https://apify.com/smtping/email-verifier.md
- **Developed by:** [SMTPing](https://apify.com/smtping) (community)
- **Categories:** Open source
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 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

## SMTPing Email Verifier: 13 verdicts, from $0.15 per 1,000

Verify and clean email lists before you send. Most verifiers stop at valid, invalid and catch-all. SMTPing also flags **spamtraps, complainers, spambots, blacklisted domains and disposables**, the addresses that pass a basic SMTP check and still damage your sender reputation.

The Actor is free. Verifications use credits on your SMTPing account.

### Why SMTPing

- **Price.** From **$0.15 per 1,000** on the 1M pack, $0.38 per 1,000 on 100k. Credits never expire on pay-as-you-go.
- **Unknown is free.** When a server gives no reliable answer, the result is `unknown` and you are not charged. Duplicates and rejected requests are free too.
- **Largest risk databases.** 150M known spamtraps, 70M complainers, 1M spambots and bot clickers, 3,500+ disposable domains monitored daily.
- **25 free credits every day** on every account, no card required.
- **Rich verdicts.** 13 statuses in 3 groups, each with a recommended action, plus free-provider, role-account and typo flags.
- **No email is sent.** The SMTP conversation stops before any message is transmitted.

### How to use

1. Create a free account at [smtping.com](https://smtping.com) and copy your key from Dashboard > API.
2. Paste the key, then paste your addresses or a public CSV/TXT URL.
3. Choose which rows to keep and click **Start**.

From 50 addresses, the Actor submits one bulk job (up to 100,000 per run) and shows live progress.

### Verdicts and groups

#### safe: send

| Verdict | Meaning |
| --- | --- |
| `valid` | Mailbox exists and accepts mail |
| `alias` | Privacy alias forwarding to a real mailbox |

#### judgement: decide per campaign

| Verdict | Meaning | Recommended action |
| --- | --- | --- |
| `catchall` | Domain accepts every address, this mailbox cannot be confirmed | Send to engaged contacts, exclude from cold outreach |
| `valid_catchall` | Catch-all domain with positive signals for this address | Lower risk than `catchall` |
| `unknown` | No usable answer (greylisting, timeouts) | Retry in a few hours; not charged |

#### do\_not\_send: remove

| Verdict | Meaning |
| --- | --- |
| `invalid` | Mailbox or domain cannot receive mail; will bounce |
| `spamtrap` | Exists only to catch senders; the most damaging address on a list |
| `disposable` | Temporary, throwaway address |
| `blacklisted` | Domain appears on blocklists |
| `complainer` | History of marking mail as spam |
| `spambot` | Automated clicker that inflates engagement metrics |
| `inbox_full` | Mailbox over quota; mail bounces |
| `typo` | Misspelled domain (gmial.com); correct it or remove |

Real example, a 27,850-address B2B list: 150 spamtraps (0.5%), 76 complainers and 24 spambots, none of which a basic valid/invalid check would remove.

### Output

One dataset row per address:

```json
{
  "email": "john@example.com",
  "status": "valid",
  "band": "safe",
  "action": "Send",
  "statusDescription": "safe to send",
  "isFreeDomain": false,
  "isRoleBasedDomain": false,
  "isTypos": false,
  "domain": "example.com"
}
```

The `SUMMARY` record in the key-value store gives counts per group and per verdict. Export as CSV, JSON or Excel from the Output tab, or connect Make, Zapier or n8n.

### Input

| Field | Description |
| --- | --- |
| SMTPing API key | Required, stored as a secret |
| Email addresses | One per line; duplicates removed |
| List URL | Public CSV or TXT; every address found is verified |
| Rows to keep | `all`, `safe_judgement` or `safe` |
| Bulk threshold | Size from which one bulk job is used (default 50) |

### Links

- Pricing: https://smtping.com/pricing
- API docs and full verdict reference: https://smtping.com/docs
- Node, Python and PHP SDKs, MCP server: https://smtping.com/docs
- Blog: https://smtpedia.com

# Actor input Schema

## `apiKey` (type: `string`):

Your API key from smtping.com (Dashboard > API). Every account gets 25 free credits per day, no card required.

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

One address per line. Duplicates and malformed lines are removed.

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

Optional public URL of a CSV or TXT file. Every email address found in it is verified.

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

safe = valid and alias only. safe\_judgement also keeps catchall, valid\_catchall and unknown. all keeps everything, including do\_not\_send rows.

## `bulkThreshold` (type: `integer`):

Lists at or above this size use one bulk job instead of single calls.

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

Parallel single verifications for small lists.

## Actor input object example

```json
{
  "emails": [
    "john@example.com"
  ],
  "outputFilter": "all",
  "bulkThreshold": 50,
  "concurrency": 5
}
```

# Actor output Schema

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

One row per address: verdict, group, recommended action and flags.

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

Counts per group and per verdict.

# 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": [
        "john@example.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("smtping/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": ["john@example.com"] }

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

```

## MCP server setup

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