# Email Verification MX Checker — Syntax, DNS & SMTP (`perryay/email-verification-mx-checker`) Actor Verify email addresses with multi-layer checks: syntax validation, MX record lookup, SMTP mailbox verification, disposable domain detection, role-based detection, and domain typo suggestions. - **URL**: https://apify.com/perryay/email-verification-mx-checker.md - **Developed by:** [Perry AY](https://apify.com/perryay) (community) - **Categories:** Developer tools - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $0.035 / actor start This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage. Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event ## What's an Apify Actor? Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases. 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 MX Checker — Syntax, DNS & SMTP ### Email Verification MX Checker — Syntax, DNS & SMTP **Verify email addresses with multi-layer checks including syntax validation, MX record lookup, SMTP mailbox verification, disposable domain detection, and typo suggestions.** Whether you're cleaning a mailing list, validating sign-up forms, or checking lead quality, this actor provides comprehensive email verification in a single run. --- ### What does it do? This actor verifies email addresses through multiple layers of checks. It starts with syntax validation to catch obviously malformed addresses, then performs DNS MX record lookups to confirm the domain can receive email. For the most accurate results, it attempts SMTP verification by connecting directly to the recipient's mail server and checking whether the mailbox actually exists — without sending an actual email. Additional checks include detecting disposable email domains (Mailinator, TempMail, etc.), identifying role-based addresses (admin@, info@, support@), and suggesting corrections for common domain typos (gmial.com → gmail.com). Each email receives a numeric score (0-100) and a clear verdict that helps you decide how to handle it. ### Features 1. **Syntax validation** — Checks email format, length limits, allowed characters, and structural rules per RFC 5321/5322. 2. **MX record lookup** — Queries DNS for mail exchanger records using the `dig` command. Falls back to socket resolution if `dig` is unavailable. 3. **SMTP mailbox verification** — Connects to the mail server, performs EHLO/HELO, issues MAIL FROM, and checks RCPT TO to verify the mailbox exists without sending email. 4. **Disposable domain detection** — Checks against a built-in database of 80+ known disposable email providers. 5. **Role-based detection** — Flags common role addresses (admin, info, support, sales, etc.). 6. **Domain typo suggestions** — Recognizes 25+ common domain typos and suggests corrections. 7. **Confidence scoring** — Each email receives a 0-100 score with a clear verdict label. 8. **Batch processing** — Verify hundreds of email addresses concurrently with configurable worker count. 9. **Error resilience** — Per-email error isolation. A timeout or DNS failure for one email doesn't affect others. ### Why use this? | Problem | Solution | |---------|----------| | Your email list has high bounce rates | Verify emails before sending to identify undeliverable addresses | | Users register with fake or disposable emails | Detect disposable domains and role-based addresses at sign-up | | You're scoring leads from web scraping | Verify email quality before passing to sales | | You need to clean a legacy mailing list | Batch verify hundreds of emails in a single run | | You want to catch typo errors in email collection | Get automatic domain typo suggestions | | You need programmatic email validation | Integrate via API with documented cURL and Python examples | ### Who is it for? | Persona | What they use it for | |---------|---------------------| | Email Marketer | Cleaning mailing lists before campaigns to reduce bounce rates | | Web Developer | Validating email addresses at sign-up form submission | | Data Analyst | Scoring lead quality by email deliverability | | System Administrator | Maintaining user database hygiene | | Sales Operations | Verifying prospect email addresses before outreach | | Fraud Analyst | Detecting disposable and role-based email registrations | ### Input Parameters | Field | Type | Default | Description | |-------|------|---------|-------------| | `email` | string | — | A single email address to verify | | `emails` | array | — | Multiple email addresses to verify in batch mode | | `verifySmtp` | boolean | `true` | Enable SMTP verification (connects to mail server to check mailbox existence). Disable for faster but less accurate results. | | `maxWorkers` | integer | `10` | Maximum concurrent verifications. Range: 1-30. | #### Example Input JSON ```json { "email": "user@gmail.com", "verifySmtp": true } ```` #### Example Batch Input ```json { "emails": [ "user@gmail.com", "test@mailinator.com", "invalid-email", "admin@company.com", "nonexistent@example.com" ], "verifySmtp": true, "maxWorkers": 15 } ``` ### Output Format | Field | Type | Description | |-------|------|-------------| | `email` | string | The email address that was verified | | `verdict` | string | Overall result: `deliverable`, `likely_deliverable`, `undeliverable`, `risky_disposable`, `invalid_domain`, `invalid_syntax`, `uncertain` | | `score` | integer | Confidence score 0-100 | | `checks` | object | Detailed per-layer check results | #### Verdict Meanings | Verdict | Score Range | Meaning | |---------|-------------|---------| | `deliverable` | 85-100 | SMTP confirmed the mailbox exists | | `likely_deliverable` | 70-84 | Syntax valid, domain has MX, not disposable | | `undeliverable` | 0-10 | SMTP rejected the mailbox | | `risky_disposable` | 50-65 | Valid address but using a disposable provider | | `invalid_domain` | 50 | Syntax valid but domain has no MX/A records | | `invalid_syntax` | 0 | Email format is invalid | | `uncertain` | 50-69 | Could not fully verify, but not rejected | #### `checks` Object | Check | Fields | Description | |-------|--------|-------------| | `syntax` | `valid`, `local_part`, `domain`, `error` | RFC email format validation | | `disposable` | `disposable` | Whether domain is a known disposable provider | | `role_based` | `role_based` | Whether local part is a role-based address | | `typo` | `has_typo`, `suggestion`, `suggested_email` | Domain typo detection | | `mx` | `has_mx`, `mx_records`, `error` | DNS MX record lookup results | | `smtp` | `smtp_status`, `smtp_response`, `error` | SMTP verification results | #### Example Output JSON ```json { "email": "user@gmail.com", "verdict": "deliverable", "score": 95, "checks": { "syntax": { "valid": true, "local_part": "user", "domain": "gmail.com", "error": null }, "disposable": { "disposable": false }, "role_based": { "role_based": false }, "typo": { "has_typo": false, "suggestion": null }, "mx": { "has_mx": true, "mx_records": [ {"priority": 5, "hostname": "gmail-smtp-in.l.google.com"}, {"priority": 10, "hostname": "alt1.gmail-smtp-in.l.google.com"} ], "error": null }, "smtp": { "smtp_status": "deliverable", "smtp_response": "RCPT accepted (code 250)", "error": null } } } ``` ### API Usage #### cURL ```bash curl -X POST "https://api.apify.com/v2/acts/perryay~email-verification-mx-checker/runs?token=YOUR_API_TOKEN" \ -H "Content-Type: application/json" \ -d '{"email": "user@example.com", "verifySmtp": false}' ``` #### Python (ApifyClient) ```python from apify_client import ApifyClient client = ApifyClient("YOUR_API_TOKEN") run = client.actor("perryay~email-verification-mx-checker").call( run_input={"emails": ["user@gmail.com", "test@mailinator.com"]} ) dataset = client.dataset(run["defaultDatasetId"]).list_items() for item in dataset.items: print(f'{item["email"]}: {item["verdict"]} (score: {item["score"]})') ``` ### Use Cases 1. **Email list cleaning** — Before a marketing campaign, run your subscriber list through the checker to remove invalid and disposable addresses. Reduce bounce rates and protect sender reputation. 2. **Sign-up validation** — Integrate into your registration flow to detect fake or disposable email addresses at sign-up. Reject role-based addresses for personal accounts or flag them for review. 3. **Lead scoring** — When scraping leads from the web, verify each email's deliverability before passing to sales. Prioritize high-scoring leads and flag suspicious ones for manual review. 4. **User database hygiene** — Periodically check your user database for invalid emails resulting from expired domains or deleted accounts. Proactively reach out to affected users to update their contact information. 5. **Fraud detection** — Disposable email providers are commonly used for fraudulent registrations, spam accounts, and review manipulation. Flag or block disposable addresses at registration. 6. **Typo recovery** — A user types "gmial.com" instead of "gmail.com". Catch the typo at the point of entry and suggest the correction before the email is saved, preventing future delivery failures. 7. **Bulk domain migration verification** — When migrating email from one provider to another, batch-verify all user emails to identify accounts that may have been lost or misconfigured during migration. ### FAQ **Q: Does SMTP verification send an email to the address?** A: No. SMTP verification uses the SMTP protocol's RCPT TO command, which checks whether the mail server will accept mail for that address without actually delivering a message. The connection is closed before any email is sent. **Q: How fast is email verification?** A: Syntax-only checks are instant. MX lookups take 1-3 seconds per domain. SMTP verification takes 3-10 seconds per email depending on mail server responsiveness. With 10 concurrent workers, a batch of 100 emails typically completes in 30-60 seconds. **Q: Why would SMTP verification fail for a valid email?** A: Some mail servers reject RCPT TO verification from unknown senders, return generic responses to prevent address harvesting, or require STARTTLS which the basic SMTP check doesn't support. These emails will show as "uncertain" rather than undeliverable. **Q: What domains are considered disposable?** A: The actor checks against a built-in list of 80+ known disposable email providers including Mailinator, Guerrilla Mail, TempMail, 10 Minute Mail, YopMail, TrashMail, and others. The list is included in the code and can be extended if needed. **Q: What is a "role-based" email?** A: Role-based addresses are generic addresses like admin@, info@, support@, sales@, contact@, and postmaster@. These are often shared among multiple people and are not tied to a specific individual. They are flagged but not rejected. **Q: Can I use this actor without SMTP verification?** A: Yes. Set `verifySmtp` to `false` for faster results. The actor will still perform syntax validation, MX record lookup, disposable detection, role-based detection, and typo checking. The verdict will be based on these checks alone. **Q: How does the score work?** A: The score starts at 50 for passing syntax validation. MX records add 20 points. Not being disposable adds 15 points. SMTP deliverability adds 15 points. The maximum is 100. A score below 50 indicates invalid syntax or SMTP rejection. **Q: What happens if a domain doesn't have MX records?** A: The actor falls back to checking for A/AAAA records. If neither exists, the verdict is "invalid\_domain". If only A records exist, the domain is noted as possibly unable to receive email but not definitively invalid. **Q: What is the maximum number of emails I can check in one run?** A: There is no hard limit, but runs are subject to the actor's timeout (default 300 seconds). With 10 workers, a batch of 500 emails typically completes within timeout. For larger lists, increase the timeout or process in multiple runs. **Q: Does the actor work with international email addresses?** A: The syntax validator handles standard ASCII email addresses per RFC rules. Full internationalized email (EAI/RFC 6531) support is limited. Non-ASCII characters in the local part or domain may be flagged as invalid. **Q: Can SMTP verification get my IP blocked?** A: SMTP verification connects to mail servers and issues standard protocol commands (EHLO, MAIL FROM, RCPT TO). This is normal SMTP protocol behavior and is unlikely to result in blocking. However, rapidly checking hundreds of addresses against the same mail server may trigger rate limiting. **Q: What's the difference between "deliverable" and "likely\_deliverable"?** A: "deliverable" means SMTP confirmed the mailbox exists. "likely\_deliverable" means the email passed syntax and MX checks but SMTP verification was either skipped or inconclusive. Likely deliverable addresses are expected to receive email in most cases. ### Usage & Billing This actor uses Apify's PAY\_PER\_EVENT pricing model. You are charged per event: | Event Name | Price (USD) | Trigger | |------------|-------------|---------| | `apify-actor-start` | $0.035 | Charged on every actor start | | `email-verification` | $0.020 | Charged per email verified | | `smtp-verify` | $0.010 | Charged when SMTP verification is attempted | | `disposable-check` | $0.005 | Charged when a disposable domain is detected | Platform infrastructure costs (Apify's compute and storage) are passed through at cost. ### MCP Integration This actor can be used through the [Apify MCP server](https://docs.apify.com/integrations/mcp). Once connected, your MCP client (Claude Desktop, Cursor, etc.) can discover and run this actor from the Apify Store. #### Quick Start 1. **Install the Apify connector** in your MCP client: - **Claude Desktop**: Search for "Apify" in the connector directory, or use the remote server at `https://mcp.apify.com` - **Other clients**: See the [Apify MCP server docs](https://docs.apify.com/integrations/mcp) for setup instructions 2. **Ask your AI assistant** to use the actor. #### Claude Desktop Configuration ```json { "mcpServers": { "apify": { "url": "https://mcp.apify.com" } } } ``` #### Bearer Token Alternative ```json { "mcpServers": { "apify": { "url": "https://mcp.apify.com", "headers": { "Authorization": "Bearer " } } } } ``` ### Related Tools - **[Domain Intel](https://apify.com/perryay/domain-intel)** — WHOIS lookups, DNS enumeration, and SSL certificate validation for complete domain reconnaissance. - **[SSL Certificate Inspector](https://apify.com/perryay/ssl-cert-inspector)** — Validate SSL/TLS certificate chains and expiry dates for email server domains. - **[Cron Expression Builder & Validator](https://apify.com/perryay/cron-expression-builder-validator)** — Build, validate, and explain cron expressions for scheduling email campaigns. # Actor input Schema ## `email` (type: `string`): A single email address to verify ## `emails` (type: `array`): Array of email addresses to verify in batch ## `verifySmtp` (type: `boolean`): Attempt SMTP connection to verify mailbox existence (slower but more accurate) ## `maxWorkers` (type: `number`): Maximum concurrent email verifications (1-30) ## Actor input object example ```json { "email": "user@example.com", "emails": [ "user@example.com", "test@gmail.com" ], "verifySmtp": true, "maxWorkers": 10 } ``` # Actor output Schema ## `results` (type: `string`): Email verification results 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "email": "user@example.com", "emails": [ "user@example.com", "test@gmail.com" ] }; // Run the Actor and wait for it to finish const run = await client.actor("perryay/email-verification-mx-checker").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "email": "user@example.com", "emails": [ "user@example.com", "test@gmail.com", ], } # Run the Actor and wait for it to finish run = client.actor("perryay/email-verification-mx-checker").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 '{ "email": "user@example.com", "emails": [ "user@example.com", "test@gmail.com" ] }' | apify call perryay/email-verification-mx-checker --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=perryay/email-verification-mx-checker", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Email Verification MX Checker — Syntax, DNS & SMTP", "description": "Verify email addresses with multi-layer checks: syntax validation, MX record lookup, SMTP mailbox verification, disposable domain detection, role-based detection, and domain typo suggestions.", "version": "1.0", "x-build-id": "3nHPfnchlZ73SmqU1" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/perryay~email-verification-mx-checker/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-perryay-email-verification-mx-checker", "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/perryay~email-verification-mx-checker/runs": { "post": { "operationId": "runs-sync-perryay-email-verification-mx-checker", "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/perryay~email-verification-mx-checker/run-sync": { "post": { "operationId": "run-sync-perryay-email-verification-mx-checker", "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": { "email": { "title": "Email Address", "type": "string", "description": "A single email address to verify" }, "emails": { "title": "Email Addresses (Batch)", "type": "array", "description": "Array of email addresses to verify in batch" }, "verifySmtp": { "title": "SMTP Verification", "type": "boolean", "description": "Attempt SMTP connection to verify mailbox existence (slower but more accurate)", "default": true }, "maxWorkers": { "title": "Max Workers", "minimum": 1, "maximum": 30, "type": "number", "description": "Maximum concurrent email verifications (1-30)", "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 } } } } } } } } } } ```