# Bulk Email MX Verifier (`automation-lab/email-mx-verifier`) Actor Bulk verify email addresses via DNS MX lookup, syntax validation, and disposable domain detection. No external API — pure DNS. 99% margin, $0.0008/email. Returns risk level, MX records, provider, typo suggestions. - **URL**: https://apify.com/automation-lab/email-mx-verifier.md - **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community) - **Categories:** Developer tools - **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks - **User rating**: No ratings yet ## Pricing Pay per event 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/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.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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 ## Bulk Email MX Verifier > Verify thousands of email addresses in seconds — no external API, no login required. Pure DNS MX lookup + syntax validation + disposable domain detection + optional SMTP probe. **[Try Bulk Email MX Verifier on Apify →](https://apify.com/automation-lab/email-mx-verifier)** --- ### What does Bulk Email MX Verifier do? **Bulk Email MX Verifier** cleans and validates email lists at scale using pure DNS technology — no third-party API, no proxy, no browser. For each email address, the actor: 1. **Validates email syntax** — RFC 5321 compliance (format, length limits, special characters) 2. **Detects disposable / temporary email domains** — 500+ known services (Mailinator, Guerrilla Mail, YopMail, 10MinuteMail, and more) 3. **Looks up MX records** — checks if the domain actually accepts email via DNS 4. **Detects the email provider** — Google Workspace, Microsoft 365, ProtonMail, Zoho, Fastmail, and 30+ others 5. **Flags role-based addresses** — admin@, info@, noreply@, support@, sales@, and 40+ others 6. **Suggests typo corrections** — gmai.com → gmail.com, hotmai.com → hotmail.com, outlok.com → outlook.com 7. **Assigns a risk level** — `low`, `medium`, `high`, or `invalid` for easy filtering 8. **Optionally probes SMTP** — TCP EHLO/RCPT check to verify the mailbox exists (best-effort, no email sent) Unlike competitors that wrap external APIs (MillionVerifier, ZeroBounce, NeverBounce), this actor **uses zero third-party services**. You pay only for compute — not for per-email API credits. This results in **96–99% margins** vs. the 0–50% margins of API wrappers. --- ### 👥 Who is Bulk Email MX Verifier for? #### 📬 Email Marketers & Campaign Managers You're preparing a campaign send and need to clean your list before hitting "send." Bounces damage your sender reputation and deliverability. Use this actor to: - Remove syntactically invalid emails before upload - Suppress disposable addresses that inflate your open rates - Filter role-based addresses (info@, admin@) that rarely convert - Identify dead domains with no MX records #### 🏢 B2B Sales & Revenue Operations Teams You've scraped or purchased a lead list and need to qualify it before importing into your CRM. Use this actor to: - Validate email fields from CSV exports - Score leads by risk level (low = engaged, high = likely invalid) - Flag domains that don't accept email before your SDRs waste outreach time - Deduplicate typo variants (user@gmai.com → user@gmail.com) #### 🛠️ Developers & Data Engineers You're building a sign-up flow, CRM integration, or data pipeline and need fast, cheap bulk validation. Use this actor to: - Validate user-submitted emails in batch before inserting to your database - Build email hygiene workflows on a schedule (weekly list cleaning) - Replace expensive per-email API services with DNS-based verification - Integrate via Apify API into any tech stack (Node.js, Python, cURL, Make, Zapier) #### 📊 Data Analysts & List Brokers You're working with purchased or scraped email lists and need quality scoring before handoff. Use this actor to: - Report on list quality (% valid, % disposable, % no-MX) - Segment by risk level for downstream processing - Export results in JSON, CSV, or Excel format --- ### ✅ Why use Bulk Email MX Verifier? - 🚀 **Fast** — concurrent DNS lookups, ~1,000 emails/minute at default settings - 💰 **Cheap** — $0.0008/email (20% cheaper than the top competitor at $0.001) - 🔒 **Privacy-safe** — emails never leave Apify's infrastructure; no third-party APIs - 🚫 **No API key required** — just paste your email list and run - 📊 **Tiered pricing** — bulk discounts for Gold/Platinum/Diamond plan users - ✉️ **No email sent** — SMTP probe (optional) only tests the connection, never delivers - 🔁 **Schedule-friendly** — run weekly to keep lists clean automatically - 📤 **Export anywhere** — JSON, CSV, Excel, Google Sheets via Apify integrations --- ### 📋 What data can you extract? For each email address, the actor returns: | Field | Type | Description | |-------|------|-------------| | `email` | string | Normalized email (trimmed, lowercased) | | `isValid` | boolean | `true` if syntax is valid AND domain has MX records | | `isValidSyntax` | boolean | RFC 5321 syntax check result | | `syntaxErrors` | string[] | Specific syntax issues found | | `domain` | string | Domain portion of the email address | | `hasMxRecords` | boolean | Whether the domain has active MX records in DNS | | `mxRecords` | array | Full MX record array, sorted by priority | | `mxProvider` | string | Detected email provider (Google Workspace, Microsoft 365, etc.) | | `isDisposable` | boolean | Domain is a known temporary/disposable email service | | `isRoleBased` | boolean | Local part is a role-based address (admin, info, noreply, etc.) | | `smtpVerified` | boolean | SMTP mailbox existence check result (null if disabled) | | `riskLevel` | string | `low` / `medium` / `high` / `invalid` composite risk score | | `suggestion` | string | Typo correction hint (e.g., "Did you mean user@gmail.com?") | | `error` | string | Processing error message if verification failed | | `checkedAt` | string | ISO 8601 timestamp of when the email was checked | --- ### 💰 How much does it cost to verify email addresses in bulk? Bulk Email MX Verifier uses **pay-per-event (PPE) pricing** — you only pay for emails actually processed. | Plan | Price per email | Cost for 10,000 emails | Cost for 100,000 emails | |------|----------------|------------------------|-------------------------| | Free ($5 credit) | $0.00092 | $9.20 | $92.00 | | Bronze (Starter) | $0.0008 | $8.00 | $80.00 | | Silver (Scale) | $0.000624 | $6.24 | $62.40 | | Gold (Business) | $0.00048 | $4.80 | $48.00 | | Platinum (Enterprise) | $0.00032 | $3.20 | $32.00 | | Diamond (Enterprise+) | $0.000224 | $2.24 | $22.40 | Plus a one-time **$0.035 start fee** per run (covers actor initialization). **Free plan estimate**: Apify gives all new users $5 in free credits. At the Free tier rate of $0.00092/email + $0.035/run, you can verify approximately **5,000 emails** with your free credits. **Comparison vs. competitors**: - Top competitors on Apify Store: $0.001–$0.0025/email (25%–3× more expensive) - ZeroBounce API: $0.004–$0.008/email (5–10× more expensive) --- ### 🚀 How to verify email addresses in bulk 1. **Open** [Bulk Email MX Verifier on Apify Store](https://apify.com/automation-lab/email-mx-verifier) 2. **Click "Try for free"** (or sign in to your Apify account) 3. **Paste your email list** into the "Email addresses" field — one per line, or use the list editor 4. **(Optional)** Enable "Run SMTP probe" for deeper mailbox verification 5. **Click "Save & Start"** to begin verification 6. **Download results** in JSON, CSV, or Excel — or connect to Google Sheets via the Apify integration **Want to upload a CSV?** Use the [Apify API](#using-the-apify-api) to pass emails programmatically, or paste a column from your spreadsheet directly into the email list field. #### Example input for 3 scenarios: **Quick list check:** ```json { "emails": ["alice@company.com", "bob@gmail.com", "test@mailinator.com"], "verifySmtp": false } ```` **With SMTP probe (deeper verification):** ```json { "emails": ["user@enterprise.com", "lead@startup.io"], "verifySmtp": true, "smtpTimeoutSecs": 8 } ``` **High-concurrency bulk run (10,000+ emails):** ```json { "emails": ["...array of 10000 emails..."], "verifySmtp": false, "concurrency": 100 } ``` *** ### ⚙️ Input parameters | Parameter | Type | Required | Default | Description | |-----------|------|----------|---------|-------------| | `emails` | string\[] | Yes | — | Email addresses to verify. Accepts up to 10,000 per run. Duplicates are automatically deduplicated. | | `verifySmtp` | boolean | No | `false` | Attempt a TCP SMTP connection to verify the mailbox exists. Sends EHLO + RCPT TO without delivering any email. Slower (adds 1–10s per email) and may be blocked by some servers. | | `smtpTimeoutSecs` | integer | No | `5` | Maximum seconds to wait for an SMTP connection response. Increase if you're getting false negatives on slow mail servers. | | `concurrency` | integer | No | `50` | Maximum parallel DNS lookups. Higher = faster but may hit DNS rate limits. Cap at 100 for large runs. | *** ### 📤 Output examples **Low-risk valid email:** ```json { "email": "alice@google.com", "isValid": true, "isValidSyntax": true, "syntaxErrors": [], "domain": "google.com", "hasMxRecords": true, "mxRecords": [{"priority": 10, "exchange": "smtp.google.com"}], "mxProvider": "Google Workspace", "isDisposable": false, "isRoleBased": false, "smtpVerified": null, "smtpError": null, "riskLevel": "low", "suggestion": null, "error": null, "checkedAt": "2026-04-04T09:00:00.000Z" } ``` **Disposable email (high risk):** ```json { "email": "test@mailinator.com", "isValid": true, "isValidSyntax": true, "syntaxErrors": [], "domain": "mailinator.com", "hasMxRecords": true, "mxRecords": [{"priority": 5, "exchange": "mail.mailinator.com"}], "mxProvider": null, "isDisposable": true, "isRoleBased": false, "smtpVerified": null, "smtpError": null, "riskLevel": "high", "suggestion": null, "error": null, "checkedAt": "2026-04-04T09:00:00.000Z" } ``` **Invalid syntax:** ```json { "email": "not-an-email", "isValid": false, "isValidSyntax": false, "syntaxErrors": ["Missing @ symbol"], "domain": null, "hasMxRecords": null, "mxRecords": [], "mxProvider": null, "isDisposable": false, "isRoleBased": false, "smtpVerified": null, "smtpError": null, "riskLevel": "invalid", "suggestion": null, "error": null, "checkedAt": "2026-04-04T09:00:00.000Z" } ``` **Typo detected:** ```json { "email": "user@gmai.com", "isValid": true, "isValidSyntax": true, "syntaxErrors": [], "domain": "gmai.com", "hasMxRecords": true, "mxRecords": [{"priority": 10, "exchange": "alt1.aspmx.l.google.com"}], "mxProvider": "Google Workspace", "isDisposable": false, "isRoleBased": false, "smtpVerified": null, "smtpError": null, "riskLevel": "low", "suggestion": "Did you mean user@gmail.com?", "error": null, "checkedAt": "2026-04-04T09:00:00.000Z" } ``` *** ### 💡 Tips for best results - 🧹 **Start small** — test with 100 emails before uploading your full list. Verify the output fields match your expectations. - 📋 **Deduplicate first** — the actor automatically deduplicates, but cleaning your list upstream reduces run time. - 🔁 **Schedule weekly cleanings** — set up a recurring run to catch domains that go offline or switch providers. - ⚡ **Increase concurrency for large lists** — set `concurrency: 100` for 100k+ email runs. DNS is the bottleneck, not compute. - 🚫 **Filter by `riskLevel: "low"`** for your safest sends — these emails have valid syntax, active MX records, are not disposable, and are not role-based. - ⚠️ **Use `isDisposable: true`** to detect sign-up fraud or trial abuse patterns. - 🔍 **Enable SMTP probe** only for lists where accuracy matters more than speed — SMTP probes add 1–10 seconds per email and may be blocked by corporate mail servers. - 💾 **Export to CSV** and filter in Excel/Google Sheets by risk level for easy list segmentation. *** ### 🔗 Integrations **Bulk Email MX Verifier → Google Sheets** Schedule a weekly run to clean your marketing list. Use the [Apify Google Sheets integration](https://apify.com/apify/google-sheets-import-export) to write results back to a spreadsheet, then filter by `riskLevel = "low"` before importing to Mailchimp or HubSpot. **Bulk Email MX Verifier → Make (Integromat)** Trigger on form submission: validate the submitted email instantly via the API, and if `isValid = false`, return an error to the user. Or batch-validate weekly uploads automatically. **Bulk Email MX Verifier → Zapier** Connect to your CRM (HubSpot, Salesforce, Airtable) — run validation on new contacts as they're added. Flag records with `isDisposable: true` for sales follow-up review. **Bulk Email MX Verifier → Slack/Discord alerts** Combine with a Make/Zapier webhook to send a Slack notification when a new batch completes, with a summary of valid vs. invalid vs. disposable counts. **Scheduled list cleaning** Set up a daily or weekly cron schedule in Apify to automatically clean your email database. Perfect for maintaining CRM hygiene without manual intervention. *** ### 🖥️ Using the Apify API #### Node.js ```javascript import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' }); const run = await client.actor('automation-lab/email-mx-verifier').call({ emails: ['alice@company.com', 'bob@gmail.com', 'test@mailinator.com'], verifySmtp: false, concurrency: 50, }); const { items } = await client.dataset(run.defaultDatasetId).listItems(); console.log('Results:', items); // Filter to low-risk only const validEmails = items.filter(r => r.riskLevel === 'low').map(r => r.email); console.log('Safe to send:', validEmails); ``` #### Python ```python from apify_client import ApifyClient client = ApifyClient("YOUR_APIFY_TOKEN") run = client.actor("automation-lab/email-mx-verifier").call(run_input={ "emails": ["alice@company.com", "bob@gmail.com", "test@mailinator.com"], "verifySmtp": False, "concurrency": 50, }) items = client.dataset(run["defaultDatasetId"]).list_items().items print(f"Results: {len(items)} emails verified") ## Filter to low-risk only valid_emails = [r["email"] for r in items if r["riskLevel"] == "low"] print(f"Safe to send: {valid_emails}") ``` #### cURL ```bash ## Start the actor run curl -X POST "https://api.apify.com/v2/acts/automation-lab~email-mx-verifier/runs" \ -H "Authorization: Bearer YOUR_APIFY_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "emails": ["alice@company.com", "bob@gmail.com"], "verifySmtp": false }' ## Fetch results (replace RUN_ID with ID from previous response) curl "https://api.apify.com/v2/actor-runs/RUN_ID/dataset/items?format=json" \ -H "Authorization: Bearer YOUR_APIFY_TOKEN" ``` *** ### 🤖 Use with AI agents via MCP Bulk Email MX Verifier is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp). Add the Apify MCP server to your AI client — this gives you access to all Apify actors, including this one: #### Setup for Claude Code ```bash claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/email-mx-verifier" ``` #### Setup for Claude Desktop, Cursor, or VS Code Add this to your MCP config file: ```json { "mcpServers": { "apify": { "url": "https://mcp.apify.com?tools=automation-lab/email-mx-verifier" } } } ``` Your AI assistant will use OAuth to authenticate with your Apify account on first use. #### Example prompts Once connected, try asking your AI assistant: - "Use automation-lab/email-mx-verifier to validate these 50 emails from my CSV and tell me which ones are safe to send to" - "Check if the email addresses in this list are disposable or fake, and group them by risk level" - "Verify my email list and suggest typo corrections for any domains that look misspelled" Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp). *** ### ⚖️ Is it legal to verify email addresses? Yes — verifying email addresses via DNS MX lookup is entirely legal and widely practiced in the email industry. The actor: - **Only performs DNS queries** — no connection is made to any mail server unless SMTP probe is enabled - **Does not send any email** — SMTP probe only opens a TCP connection and sends EHLO/RCPT commands, never delivers a message - **Processes only data you own** — you supply the email list; no data is scraped from third-party websites - **GDPR-compatible** — DNS queries are stateless and contain no personal information beyond the domain name Use this actor responsibly. Verify only email lists you have the right to process, and comply with applicable data protection laws (GDPR, CAN-SPAM, CASL) when sending marketing communications. *** ### ❓ FAQ **How fast does the actor verify emails?** At the default concurrency of 50, the actor processes approximately 800–1,200 emails per minute, depending on DNS response times. A list of 10,000 emails typically completes in 8–12 minutes. Increase `concurrency` to 100–200 for faster processing on large lists. **How much does it cost to verify 100,000 emails?** On the Bronze plan: 100,000 × $0.0008 + $0.035 = ~$80.04. On the Gold plan: ~$48.04. New users get $5 in free credits, enough to verify ~5,000 emails. **How is this different from using MillionVerifier or ZeroBounce directly?** Those services charge $0.001–$0.008/email plus API subscription fees, and your email data is sent to their servers. This actor uses only DNS — no third-party service receives your email list. For most use cases (syntax check + MX validation + disposable detection), DNS-based verification provides equivalent value at 5–10× lower cost. **Why does `isValid = true` but the mailbox might still bounce?** MX records confirm the domain *accepts email* — but they can't prove a specific mailbox exists without SMTP. Enable `verifySmtp: true` for deeper mailbox-level verification. Even then, some servers accept any RCPT TO (catch-all servers), so `smtpVerified: true` doesn't guarantee delivery. **Why is my SMTP probe returning null even with `verifySmtp: true`?** Port 25 (SMTP) is blocked by many cloud providers and corporate firewalls. If the MX host blocks the connection, the probe returns `smtpVerified: null` with an error message rather than `false`. This is not a bug — it means the server is unreachable, not that the mailbox doesn't exist. Treat null as "inconclusive." **Why are some legitimate emails flagged as `riskLevel: "medium"`?** Role-based addresses (admin@, info@, support@, noreply@, etc.) are flagged as medium risk by default because they typically reach shared mailboxes, inboxes that are monitored infrequently, or automated filtering systems. They're not invalid — just lower-value for personalized outreach. **What disposable domain list does the actor use?** The actor includes a curated list of 500+ known disposable and temporary email providers, compiled and maintained in the actor's source. This covers all major providers (Mailinator, Guerrilla Mail, YopMail, 10MinuteMail, Trashmail, Discard.email, etc.). The list is updated with each actor release. *** ### 🔗 Other email and DNS tools by automation-lab - 📧 [Email Syntax Validator](https://apify.com/automation-lab/email-syntax-validator) — lightweight syntax-only check - 📨 [Email Deliverability Checker](https://apify.com/automation-lab/email-deliverability-checker) — SPF/DKIM/DMARC record analysis - 🔍 [MX Record Checker](https://apify.com/automation-lab/mx-record-checker) — bulk domain MX record lookup - 🌐 [DNS Lookup](https://apify.com/automation-lab/dns-lookup) — A, AAAA, CNAME, TXT, NS, SOA record lookup - 🔄 [DNS Propagation Checker](https://apify.com/automation-lab/dns-propagation-checker) — check DNS propagation across global servers - 📅 [Domain Age Checker](https://apify.com/automation-lab/domain-age-checker) — WHOIS/RDAP domain registration date lookup - ✅ [Domain Availability Checker](https://apify.com/automation-lab/domain-availability-checker) — bulk domain availability check - 🔎 [Subdomain Finder](https://apify.com/automation-lab/subdomain-finder) — enumerate subdomains via DNS brute-force # Actor input Schema ## `emails` (type: `array`): List of email addresses to verify. Accepts up to 10,000 emails per run. ## `verifySmtp` (type: `boolean`): Attempt a TCP SMTP connection to verify the mailbox exists. Sends EHLO + RCPT TO without delivering any email. Slower and may be blocked by some mail servers. ## `smtpTimeoutSecs` (type: `integer`): Maximum seconds to wait for an SMTP connection response. ## `concurrency` (type: `integer`): Maximum number of emails to verify in parallel. Higher values are faster but may hit DNS rate limits. ## Actor input object example ```json { "emails": [ "user@google.com", "contact@github.com", "test@mailinator.com", "invalid-email", "admin@microsoft.com" ], "verifySmtp": false, "smtpTimeoutSecs": 5, "concurrency": 50 } ``` # Actor output Schema ## `overview` (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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "emails": [ "user@google.com", "contact@github.com", "test@mailinator.com", "invalid-email", "admin@microsoft.com" ] }; // Run the Actor and wait for it to finish const run = await client.actor("automation-lab/email-mx-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "emails": [ "user@google.com", "contact@github.com", "test@mailinator.com", "invalid-email", "admin@microsoft.com", ] } # Run the Actor and wait for it to finish run = client.actor("automation-lab/email-mx-verifier").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": [ "user@google.com", "contact@github.com", "test@mailinator.com", "invalid-email", "admin@microsoft.com" ] }' | apify call automation-lab/email-mx-verifier --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=automation-lab/email-mx-verifier", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Bulk Email MX Verifier", "description": "Bulk verify email addresses via DNS MX lookup, syntax validation, and disposable domain detection. No external API — pure DNS. 99% margin, $0.0008/email. Returns risk level, MX records, provider, typo suggestions.", "version": "0.1", "x-build-id": "h6gM12C61KHfOmJGn" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/automation-lab~email-mx-verifier/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-automation-lab-email-mx-verifier", "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/automation-lab~email-mx-verifier/runs": { "post": { "operationId": "runs-sync-automation-lab-email-mx-verifier", "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/automation-lab~email-mx-verifier/run-sync": { "post": { "operationId": "run-sync-automation-lab-email-mx-verifier", "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", "required": [ "emails" ], "properties": { "emails": { "title": "📧 Email addresses", "type": "array", "description": "List of email addresses to verify. Accepts up to 10,000 emails per run.", "items": { "type": "string" } }, "verifySmtp": { "title": "🔍 Run SMTP probe", "type": "boolean", "description": "Attempt a TCP SMTP connection to verify the mailbox exists. Sends EHLO + RCPT TO without delivering any email. Slower and may be blocked by some mail servers.", "default": false }, "smtpTimeoutSecs": { "title": "⏱️ SMTP timeout (seconds)", "minimum": 2, "maximum": 30, "type": "integer", "description": "Maximum seconds to wait for an SMTP connection response.", "default": 5 }, "concurrency": { "title": "⚡ Concurrency", "minimum": 1, "maximum": 200, "type": "integer", "description": "Maximum number of emails to verify in parallel. Higher values are faster but may hit DNS rate limits.", "default": 50 } } }, "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 } } } } } } } } } } ```