# Email Verifier: Syntax, MX, Disposable & Optional SMTP (`dami_studio/email-verification`) Actor

Verify email syntax and domain mail capability, flag disposable and role accounts, and optionally run a bounded SMTP probe without claiming mailbox deliverability when inconclusive.

- **URL**: https://apify.com/dami\_studio/email-verification.md
- **Developed by:** [Dami's Studio](https://apify.com/dami_studio) (community)
- **Categories:** Lead generation, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.60 / 1,000 email verifications

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 Verification: Syntax, MX, Disposable, Role and Optional SMTP

Keyless bulk email verification for list cleaning. The Actor checks practical syntax, domain mail routing (MX with implicit A/AAAA fallback), a built-in disposable-domain list, role-account patterns, and free-provider domains. It can optionally make one short SMTP recipient probe per address.

### Honest scope

This Actor does **not** claim that an inbox exists, that a person owns it, or that a future message will be delivered. A domain with MX records can still reject a recipient, use a catch-all, block probes, or accept mail temporarily. SMTP acceptance is labelled as a best-effort protocol response, not proof of deliverability. SMTP timeouts, port-25 blocks, provider anti-enumeration, and catch-all behavior are returned as `inconclusive`.

No email is sent. No login, API key, residential proxy, mailbox access, or guessed address is used. DNS-over-HTTPS is used so cloud DNS behavior is consistent and bounded by a deadline.

### Input

```json
{
  "emails": ["person@example.com", "info@example.com", "bad@@example.com"],
  "checkSmtp": false,
  "smtpTimeoutMs": 5000,
  "maxConcurrency": 10
}
````

Duplicate addresses are normalized and verified once. With an empty `emails` array, the Actor returns one `_sample: true` row and charges nothing. Diagnostic and sample rows are never charged.

### Output

Each completed address returns `status` (`valid`, `risky`, `invalid`, or `unknown`), `confidence` (a heuristic 0-100 score), syntax, domain, MX evidence, disposable and role flags, free-provider flag, and an optional SMTP object. `valid` means the address passed syntax and domain mail-routing checks; it is deliberately not a mailbox guarantee.

### SMTP behavior

When `checkSmtp` is true, the Actor connects to the first MX host on TCP port 25 and sends `EHLO`, `MAIL FROM`, and `RCPT TO`, with an 8-second maximum per connection. It never sends a message. Cloud providers frequently block port 25 or mail providers deliberately prevent mailbox enumeration. In those cases the row remains `valid`/`unknown` based on MX evidence and the SMTP field says `inconclusive`; it is never upgraded to a deliverability claim.

### Pricing proposal

Live pay-per-event price: **$0.0006 per completed verification ($0.60 per 1,000)**. Invalid syntax rows are still completed checks and are billed once; empty/sample/diagnostic rows are not billed. This is below the lowest observed comparable at $0.70 per 1,000 while leaving a positive measured margin after Apify fees and direct DNS costs. No residential proxy is required.

### Responsible use

Use only on addresses you are permitted to process. Respect privacy, anti-spam, data-protection, and recipient-domain policies. Results are list-cleaning signals, not consent or permission to send.

### Local development

```bash
npm install --omit=dev --no-audit --no-fund
npm test
npm run check
```

# Actor input Schema

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

Email addresses to verify. Duplicate addresses are normalized and processed once. Leave empty to run the free sample row.

## `checkSmtp` (type: `boolean`):

Attempt a short SMTP EHLO/MAIL FROM/RCPT TO probe against the first MX host. SMTP is best-effort: many providers block enumeration and Apify cloud may block outbound port 25, so inconclusive is reported rather than treated as invalid.

## `smtpTimeoutMs` (type: `integer`):

Per-connection SMTP deadline. It is capped at 8000 ms to keep cloud runs bounded.

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

Maximum number of email checks running at once. Lower this for conservative DNS and SMTP traffic.

## Actor input object example

```json
{
  "emails": [
    "person@example.com",
    "info@example.com"
  ],
  "checkSmtp": false,
  "smtpTimeoutMs": 5000,
  "maxConcurrency": 10
}
```

# Actor output Schema

## `dataset` (type: `string`):

One dataset row per completed verification. Empty input returns one labeled, uncharged sample row.

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

// Run the Actor and wait for it to finish
const run = await client.actor("dami_studio/email-verification").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": [
        "person@example.com",
        "info@example.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("dami_studio/email-verification").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 '{
  "emails": [
    "person@example.com",
    "info@example.com"
  ]
}' |
apify call dami_studio/email-verification --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Email Verifier: Syntax, MX, Disposable & Optional SMTP",
        "description": "Verify email syntax and domain mail capability, flag disposable and role accounts, and optionally run a bounded SMTP probe without claiming mailbox deliverability when inconclusive.",
        "version": "0.1",
        "x-build-id": "26IVFIdJsFmu7NTQ8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dami_studio~email-verification/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dami_studio-email-verification",
                "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/dami_studio~email-verification/runs": {
            "post": {
                "operationId": "runs-sync-dami_studio-email-verification",
                "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/dami_studio~email-verification/run-sync": {
            "post": {
                "operationId": "run-sync-dami_studio-email-verification",
                "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": "Email addresses to verify. Duplicate addresses are normalized and processed once. Leave empty to run the free sample row.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "checkSmtp": {
                        "title": "Attempt bounded SMTP probe",
                        "type": "boolean",
                        "description": "Attempt a short SMTP EHLO/MAIL FROM/RCPT TO probe against the first MX host. SMTP is best-effort: many providers block enumeration and Apify cloud may block outbound port 25, so inconclusive is reported rather than treated as invalid.",
                        "default": false
                    },
                    "smtpTimeoutMs": {
                        "title": "SMTP timeout (milliseconds)",
                        "minimum": 1000,
                        "maximum": 8000,
                        "type": "integer",
                        "description": "Per-connection SMTP deadline. It is capped at 8000 ms to keep cloud runs bounded.",
                        "default": 5000
                    },
                    "maxConcurrency": {
                        "title": "Concurrent checks",
                        "minimum": 1,
                        "maximum": 25,
                        "type": "integer",
                        "description": "Maximum number of email checks running at once. Lower this for conservative DNS and SMTP traffic.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```