Email Syntax Validator

Validate email address syntax and check domain MX records.

What does Email Syntax Validator do?

This actor validates email address syntax and checks if the domain has MX (mail exchange) records. It detects disposable email domains, role-based addresses (admin@, support@), and provides detailed syntax error messages. No external dependencies -- uses the Node.js DNS module for MX record lookups. Pass in a list of email addresses and get structured results showing which are valid, which domains can receive email, and which addresses are disposable or role-based.

Use cases

• Email marketers -- clean email lists before sending campaigns to reduce bounces and protect sender reputation
• Product managers -- validate email addresses submitted through sign-up forms to keep your user database clean
• Sales teams -- filter out disposable and role-based emails from lead lists to focus on real contacts
• Data analysts -- verify email formatting in datasets before importing them into CRM or marketing tools
• Developers -- use as a server-side validation step in your application's registration flow

Why use Email Syntax Validator?

• Multi-layer validation -- checks syntax, domain MX records, disposable domain detection, and role-based address detection in one pass
• Disposable email detection -- identifies throwaway email services so you can filter out fake sign-ups
• Role-based detection -- flags addresses like admin@, info@, support@ that are not personal mailboxes
• Batch processing -- validate thousands of email addresses in a single run
• Ultra-low cost -- only $0.0005 per email validated, so validating 10,000 emails costs just $5.04
• Structured output -- each result includes the local part, domain, MX records, and all classification flags

Input parameters

Parameter	Type	Required	Default	Description
emails	array of strings	Yes	--	List of email addresses to validate. Example: ["test@google.com", "invalid@.com"]

{
    "emails": [
        "test@google.com",
        "user@github.com",
        "invalid@.com"
    ]
}

Output example

Each email address produces a result object with the following fields:

Field	Type	Description
email	string	The original email address
isValidSyntax	boolean	Whether the email syntax is valid
localPart	string	The part before the @ sign
domain	string	The domain part after the @ sign
hasMxRecords	boolean	Whether the domain has MX records
mxRecords	object[]	List of MX records with priority and exchange
isDisposable	boolean	Whether the domain is a known disposable email provider
isRoleBased	boolean	Whether the address is role-based (e.g., admin@, info@)
syntaxErrors	string[]	List of syntax errors found
error	string/null	Error message if validation failed

{
    "email": "test@google.com",
    "isValidSyntax": true,
    "localPart": "test",
    "domain": "google.com",
    "hasMxRecords": true,
    "mxRecords": [
        { "priority": 10, "exchange": "smtp.google.com" }
    ],
    "isDisposable": false,
    "isRoleBased": false,
    "syntaxErrors": [],
    "error": null
}

An invalid email address returns:

{
    "email": "invalid@.com",
    "isValidSyntax": false,
    "localPart": "invalid",
    "domain": ".com",
    "hasMxRecords": false,
    "mxRecords": [],
    "isDisposable": false,
    "isRoleBased": false,
    "syntaxErrors": ["Domain starts with a dot"],
    "error": null
}

How much does it cost?

Event	Price	Description
Start	$0.035	One-time per run
Email validated	$0.0005	Per email validated

Example costs:

• 100 emails: $0.035 + 100 x $0.0005 = $0.085
• 1,000 emails: $0.035 + 1,000 x $0.0005 = $0.535
• 10,000 emails: $0.035 + 10,000 x $0.0005 = $5.035

Using the Apify API

You can start Email Syntax Validator programmatically from your own applications using the Apify API. The following examples show how to run the actor and retrieve results.

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('automation-lab/email-syntax-validator').call({
    emails: ['test@google.com', 'invalid@.com'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python

from apify_client import ApifyClient

client = ApifyClient('YOUR_TOKEN')
run = client.actor('automation-lab/email-syntax-validator').call(run_input={
    'emails': ['test@google.com', 'invalid@.com'],
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

Integrations

Email Syntax Validator works with all major integration platforms supported by Apify. Connect it to Make (formerly Integromat), Zapier, n8n, or Slack to build automated email validation pipelines. Export results directly to Google Sheets for collaborative list cleaning or use webhooks to trigger downstream actions when validation completes. You can also chain this actor with the Email Deliverability Checker for a full email infrastructure audit.

Tips and best practices

• Validate before sending -- always run your email list through this validator before launching campaigns to avoid high bounce rates that damage sender reputation.
• Filter disposable emails early -- use the isDisposable flag to remove throwaway addresses from sign-up lists before they enter your database.
• Handle role-based addresses carefully -- addresses like info@ or support@ are valid but often monitored by teams, not individuals. Decide whether to include them based on your use case.
• Batch your validations -- processing all emails in a single run is far cheaper than multiple runs, since the $0.035 start fee is charged only once.
• Combine with deliverability checks -- use this actor for syntax and domain validation, then run the Email Deliverability Checker on unique domains to check SPF, DKIM, and DMARC.

FAQ

Does this actor verify that an email address actually exists? No. This actor validates the email syntax and checks that the domain has MX records capable of receiving email. It does not connect to the mail server or verify whether the specific mailbox exists. This avoids triggering spam detection systems.

What counts as a disposable email? Disposable emails are addresses from temporary email services like Mailinator, Guerrilla Mail, and similar providers. These addresses are designed to be short-lived and are commonly used for fake sign-ups.

Can I validate emails with international characters? The actor validates standard email syntax per RFC 5321. Internationalized domain names (IDN) with punycode encoding are supported, but local parts with non-ASCII characters may be flagged as invalid depending on the format.

What are role-based email addresses? Role-based addresses are emails that go to a function or department rather than a specific person. Examples include admin@, info@, support@, sales@, billing@, and webmaster@. These addresses are valid but are often shared mailboxes, which makes them less suitable for personalized outreach.

How many disposable email providers does this actor detect? The actor checks against a comprehensive list of known disposable email providers including popular services like Mailinator, Guerrilla Mail, TempMail, and hundreds of others. The list is regularly updated to include new disposable email services.