Command Line Tool for Email Validation

Why You Need Real-Time Email Validation at the Command Line

You’re about to deploy a new feature that sends transactional emails. The first test run fails—half your recipients bounce. Not because the code broke, but because the user list hasn’t been validated in months. Outdated addresses, catch-all domains, inactive mailboxes—these aren’t just noise. They hurt deliverability, degrade sender reputation, and waste bandwidth.

Most email validation tools sit in a web UI and queue jobs that take hours. But what if you could check an address instantly—right from your terminal—during development, testing, or pipeline automation? A command-line tool for real-time email domain and mailbox validation gives you that speed, control, and integration power.

Key takeaways

Validating email addresses in real time via CLI reduces deployment friction by catching invalid addresses before sending.
Command-line email validation integrates directly into scripts and CI/CD pipelines without GUI dependencies or latency.
It identifies not just invalid addresses, but catch-all domains and risky mailbox patterns—giving actionable feedback during data processing.

What Is a Command Line Tool for Real-Time Email Domain and Mailbox Validation?

A command line tool for real-time email domain and mailbox validation is a lightweight interface that sends individual email addresses to an email verification service via API, returning immediate results on validity, domain existence, and mailbox responsiveness—without sending actual emails. It checks syntax, domain records (MX, SPF), and whether the mailbox accepts inbound messages, giving you a real-time signal on deliverability.

How It Works Under the Hood

When you run the tool, it doesn't just parse an email address for format—it connects to the actual mail servers (via SMTP) and follows standard validation protocols. This means it checks the domain’s MX records, probes the mail server for acceptance, and reads the response code. A response like “250 OK” confirms the mailbox is active and ready to receive.

Unlike a simple syntax check, which might pass an address like [email protected], a real-time CLI tool detects when the domain doesn’t exist, has no MX record, or is rejecting mail. It can also flag catch-all domains (which accept all mail) and disposable email addresses—common red flags for spam or low engagement.

Why Real-Time Validation Matters

Even if an email passes syntax and domain checks, the mailbox might be inactive, quarantined, or filtered. Only real-time server interaction can confirm if it's actually receptive. As the Messaging, Malware, and Mobile Security Report notes, up to 20% of email addresses may appear valid but are non-deliverable due to inactive or blocked accounts.

Using a command line tool lets you integrate this validation directly into your workflows—testing new signups, cleaning batches before campaigns, or automating list quality checks in CI/CD pipelines. It gives instant feedback at the point of input, minimizing bounces and protecting sender reputation.

For teams using MailTester’s CLI tool, results include precise verdicts: valid, invalid, catch-all, risky, or disposable. With 98.9% accuracy, the tool helps you avoid sending to addresses that never receive mail—without needing to store or manage sensitive data.

Learn more about how to integrate this into your pipeline: send real-time verification requests, test inbox placement before launch: see how your emails land across inboxes, or verify entire lists: bulk check and clean your database.

How MailTester Provides Real-Time Verification Through the CLI

You can use MailTester’s real-time verification API directly from the command line with tools like curl or a custom script to validate email addresses instantly. Each request triggers a full SMTP-level check—DNS, MX records, server response behavior—returning results in under a second: valid, invalid, catch-all, risky, or disposable. It’s the closest thing to a live mailbox health check without sending an actual message.

How the CLI Verification Works Under the Hood

When you send an email address via the MailTester API from the command line, the request reaches our infrastructure, which performs a series of standard email validation checks. It starts by resolving the domain’s DNS and MX records, then establishes a real SMTP connection to verify whether the mailbox server accepts or rejects the address.

We simulate what a legitimate email sender would do: we initiate a handshake with the receiving server. If the server responds with a 5xx error or ignores the connection, the address is likely invalid. If it accepts the address, we classify it as valid. We also detect catch-all domains, disposable domains, and risky patterns using behavior patterns observed in real-world SMTP responses. This is the same process used by inbox providers to filter spam.

You’re not just checking syntax or domain existence—you’re testing the actual mailbox’s ability to receive email, which is why the results are so reliable. This is the same method used by major ESPs to assess sender reputation and inbox placement.

Integration and Use Cases

Let’s say you’re cleaning a list before a campaign. You can run a script that loops through each email in your CSV using curl to hit the MailTester API. The response is JSON—easy to parse, filter, and store. No need for GUIs or third-party upload systems.

For developers and operations teams, this real-time validation is ideal for integration into pipelines, customer onboarding flows, or data ingestion systems. The API supports both single checks and bulk workflows—just use our real-time verification API, or process larger lists through our bulk verification tool.

As defined in RFC 5321, the SMTP protocol governs how mail servers communicate. We follow those standards rigorously. Real-time server behavior is what separates a valid mail server from a dead end or a trap. For context on how infrastructure-level checks shape deliverability, see RFC 5321 on SMTP.

How to Run Real-Time Email Validation Using MailTester's CLI Interface

You can validate an email address in real time using MailTester’s command line tool or a direct curl request with your API key. Send the email in a JSON body, get back a structured response with status, verdict, and reason code—like invalid_syntax or mailbox_exists. Use that result to decide: deliver, review, or reject. It's fast, accurate, and built for automation.

Set Up Your Validation Pipeline

Install the MailTester CLI wrapper using your preferred package manager. It simplifies authentication, formatting, and error handling. No need to manually manage headers or JSON structure.
Alternatively, use curl directly with your API key in the Authorization header. This works in scripts, CI/CD pipelines, or any environment where you can execute a single HTTP request. You can test this on the command line with a known-valid address.
Structure your request as JSON: send {"email": "[email protected]"}. This is the only required payload. MailTester handles parsing, syntax checks, and domain resolution behind the scenes.
Receive a machine-readable response with fields like status (e.g., success), verdict (e.g., valid), and reason (e.g., domain_not_found). The reason field tells you exactly why an email failed—no guessing.
Use the verdict to route logic. A valid verdict means deliver. A invalid or risky status can trigger rejection or manual review. This avoids sending to non-existent or problematic addresses.

Integrate with Your Workflow

The real power comes from automation. Let’s say you integrate this into a sign-up form or a CRM sync. Your system checks every incoming email against MailTester’s live infrastructure before storing it. It blocks disposable domains like temp-mail.org, identifies catch-all addresses, and catches syntax errors immediately. You can also validate entire lists in bulk. If you’re processing large volumes, use the bulk verification tool to clean your database before campaigns run. For real-time decisions at scale, the API scales reliably—no rate limits for standard users. Industry best practices, like those outlined in RFC 5321 for SMTP, confirm that real-time validation reduces bounce rates and protects sender reputation. According to data from major email providers, lists with less than 1% invalid addresses see higher inbox placement—something you can achieve with consistent pre-delivery checks. This isn’t just about filtering bad emails. It’s about building a clean, trustworthy data pipeline. Every validated email improves your deliverability over time. Start for free with 100 verifications. Credits never expire.

Understanding Verdicts from Real-Time Email Validation

You get clear verdicts when validating emails in real time: valid means the mailbox exists and accepts messages; invalid means the address is syntactically flawed or the domain doesn’t exist; catch-all means the domain accepts all mail, increasing spam risk; risky flags addresses with high bounce rates, role-based names, or disposable domains; disposable signals a temporary email service; unknown means no clear response was received during the SMTP handshake. These verdicts let you act fast and avoid wasted sends.

The 5 steps described in “Set Up Your Validation Pipeline”, in order.

What Each Verdict Means in Practice

Let’s break down what each status actually tells you about the email.

Verdict	Meaning	Risk Level	Recommended Action
valid	The mailbox exists and the mail server accepted the connection and the message.	Low	Proceed with sending. These are your best leads.
invalid	Incorrect syntax, non-existent domain, or DNS issues.	High	Remove immediately. It won’t deliver and harms sender reputation.
catch-all	The domain accepts all messages, even for non-existent addresses.	Very High	Highly risky. These often include spam traps. Avoid sending to these.
risky	High bounce rate history, role-based address (e.g., admin@, sales@), or disposable domain.	Medium to High	Use cautiously. Consider scrubbing or tagging for low-priority campaigns.
disposable	Email from a temporary service (e.g., Mailinator, Guerrilla Mail).	Very High	Remove or exclude. These are not reliable for long-term communication.
unknown	No clear response during the SMTP handshake; could be temporary issue or blocked server.	Medium	Flag for review. Test again later or exclude if persistent.

These statuses aren’t just labels—they reflect real delivery mechanics. For example, a catch-all domain is a common spam trap, and sending to it can hurt your sender reputation (Spamhaus). Role-based addresses like info@ or support@ are often high-bounce and not ideal for transactional content.

Real-time validation cuts through ambiguity. With MailTester’s verification API, you can check individual addresses or bulk lists on demand, using actual SMTP connections to test mailbox existence. You’re not guessing—you’re seeing what the server says in real time.

For larger campaigns, use bulk verification to clean your list before sending. It’s especially useful before launching a new email series or entering a new market. You can also test inbox placement with inbox tester to see how your message arrives across major providers.

Where Real-Time CLI Validation Fits in Your Workflow

You can integrate a command line tool for real-time email domain and mailbox validation at critical points in your data flow—during sign-up, CRM syncs, campaign prep, and API ingestion. It stops bad emails before they enter your system, saving storage, reducing bounces, and protecting your sender reputation. It’s not a one-off task; it’s a continuous gatekeeper.

At Registration: Catch Invalid Emails Before They’re Stored

Run the CLI tool on every new signup to verify the email address immediately, before it reaches your database.
Reject invalid or disposable domains on the spot—no need to store placeholders that only waste space and inflate bounce rates.
Use the bulk verification endpoint if you’re dealing with a new user influx.

Syncing and Ingesting Data: Protect Your Pipeline

Validate incoming leads from forms, webhooks, or third-party tools (like Salesforce or HubSpot) before adding them to your sales funnel.
Automatically filter out catch-all domains or role-based addresses (e.g., sales@, info@) that rarely engage and can hurt deliverability.
Use the real-time API to validate individual emails as they come in, minimizing downstream cleanup.

Before Sending Campaigns: Shield Your Reputation

Filter your email list just before a campaign—ensuring only valid, deliverable addresses are included.
High bounce rates damage sender reputation. Even one bad email can trigger blacklisting; real-time CLI validation stops that before it starts.
Test inbox placement with MailTester’s inbox placement tool to estimate how likely your message will land in the primary inbox, not the spam folder.

Across Integrations: Clean Incoming Data

When your system receives email data from external sources (like an API from a partner app), validate it before processing.
Stop fake or malformed addresses early—especially if those addresses are used for notifications or tracking.
For high-volume pipelines, the CLI offers automation without delays. You can script it into a data ingestion pipeline with no manual oversight.

Consistently validating emails at the edge of your workflow isn’t just about cleaning data—it’s about maintaining trust with email providers and protecting your deliverability.

Why CLI Tools Beat GUI-Based Tools for Automation and Scale

Command-line tools automate email validation at scale without manual input, letting you run scripts, pipelines, and batch jobs seamlessly. Unlike GUIs that need clicks, delays, and sessions, a CLI tool works statelessly—fast, consistent, and ready to integrate into any workflow. You validate 10,000 addresses in minutes, not hours.

Automation is the Real Differentiator

GUIs are built for one-off checks, not repeatable processes. A command-line interface, by contrast, is designed for scripts. Whether it’s a cron job, CI/CD pipeline, or a shell loop, you can run validation without human involvement. Let’s say you’re importing a new list daily: a CLI tool executes the same validation step each time, reliably and without error.

Tools like MailTester’s real-time verification API or bulk verification can be invoked via command line, meaning you don’t need a browser or login. This is especially valuable when handling sensitive data or scaling across multiple servers.

Speed, Consistency, and Auditability

GUIs introduce lag: browser startup, login delays, and session timeouts. A CLI tool skips all that. It’s stateless—no cached sessions, no account lockouts, no login prompts. When you run a command, it starts and finishes. That’s critical when testing thousands of addresses in a short window.

Every command is logged. Every input and output is reproducible. That means teams can audit validation results consistently across environments. You can rerun a script tomorrow and get the same result. No guessing. No inconsistency. This is how reliable systems scale.

Consider RFC 5321, which defines SMTP—the underlying protocol for email delivery. It was designed for programmatic use, not human interaction. A command-line tool works at the same layer as the real mail system, making it far more accurate than a GUI that abstracts away protocol-level behavior.

For developers, operations teams, and data engineers, CLI tools aren’t just convenient—they’re essential. You’re not validating email addresses to check a box. You’re building a reliable data pipeline. That demands real-time, scalable, transparent tools. The command line is where that happens.

MailTester’s 98.9% Accuracy: What That Really Means

You're not just checking syntax or DNS records with MailTester. The 98.9% accuracy means we validate domains and mailboxes in real time using full SMTP sessions across live infrastructure—free providers, corporate inboxes, catch-all setups. This isn’t prediction, it’s confirmation. We verify what actually receives mail, not what a model assumes.

How Real-Time SMTP Validation Works

Unlike tools that rely on pattern matching or cached DNS data, MailTester connects directly to the target mail server. We perform a complete SMTP handshake: we initiate a session, send a MAIL FROM command, and check if the server accepts the RCPT TO command. This mimics what actually happens during sending.

It’s the difference between guessing the door is open and actually knocking. And since we do this across a wide variety of domains—including Gmail, Outlook, Yahoo, and enterprise servers with catch-all policies—we see real-world behavior, not idealized lab conditions. This method is a standard practice, as defined in RFC 5321, the foundational protocol for email delivery.

Why Accuracy Matters Beyond the Number

A 98.9% accuracy rate means we drastically reduce both false positives and false negatives. You won’t waste sends on fake addresses that never accept mail, and you won’t block real users who might be on catch-all systems. That balance is essential for maintainable sender reputation and inbox placement.

Many tools claim high accuracy using synthetic data or incomplete checks. They may score well on test lists but fail with real-world complexity. MailTester’s score comes from controlled, post-delivery confirmation in environments that reflect live email infrastructure. It's not a model—it's a live test.

For teams managing large lists, this means fewer bounces, lower risk of hitting blocklists, and better deliverability over time. Whether you’re using our bulk verification, real-time API, or testing inbox placement with our inbox tester, the foundation is the same: real SMTP validation, not assumptions.

Real accuracy isn’t about how many addresses look valid—it’s about how many actually receive mail.

That’s why you don’t need to worry about expired credits. Unused verification credits never expire—so you can build confidence in your list, test over time, and scale with certainty.

Avoiding Common Pitfalls with Real-Time CLI Validation

Using a command line tool for real-time email validation is powerful—but missteps cost time, money, and deliverability. You’ll avoid most issues by respecting API rate limits, securing your keys, treating flagged results as warnings, and validating input at the source. Let’s walk through what actually breaks in practice.

Respect Limitations, Not Just Permissions

Don’t send more requests than your API plan allows—exceeding rate limits triggers throttling, slowing your workflow or blocking access entirely.
You're not just respecting quotas; you're preserving sender reputation. High-volume, uncontrolled requests look like spam behavior to receiving servers.
Use backoff logic in your scripts: if a request fails due to rate limits, wait and retry after a delay, not immediately.
Check the RFC 6655 for standard behavior around SMTP rate limits—this is how most mail servers manage load.

Security and Result Handling Are Not Optional

Never commit API keys to public repos. Even a single leaked key can lead to credential abuse or service disruption.
Always use environment variables—set them at deploy time, not in code. Tools like dotenv or CI/CD secret managers handle this securely.
Do not treat risky or catch-all as valid. These indicate high uncertainty: catch-alls accept all emails, so any deliverability is unreliable.
Flag these for manual review or exclude them entirely. Relying on them can hurt inbox placement and inflate your bounce rate.
Validate emails at entry: never trust user input. A form may collect invalid data, and that data will fail on send. Use real-time CLI validation during sign-up or data collection.
For full list hygiene, consider bulk verification before sending to identify and remove dead or risky addresses.

Remember: CLI tools don’t eliminate risk—they expose it faster. The best automation is one that doesn’t just run fast, but runs safely and correctly.

How MailTester Compares to Other Verification Services

MailTester stands out by combining real-time validation with inbox placement testing through actual SMTP interactions—unlike most tools that rely on prediction or delayed batch checks. You can use its API directly in CI/CD pipelines, scripting workflows, or even within your own apps, giving you immediate, actionable feedback. Unlike ZeroBounce or NeverBounce, which are primarily bulk-focused, or Kickbox and Bouncer, which prioritize large-scale processing over instant response, MailTester delivers both speed and depth. And while Hunter and Emailable help find roles or domains, only MailTester tests whether those emails actually get into inboxes via live SMTP checks. This makes it unique in the space.

Real-Time API, Built for Automation

Many email verification services are built for one-off or batch operations, often requiring you to upload files and wait hours or days for results. MailTester’s real-time API works in the background of your scripts, dev workflows, and CI/CD pipelines. You send a request, get a response in milliseconds. This is how you catch invalid addresses at sign-up, before they ever reach your server. It’s not just about accuracy; it’s about timing and integration. If you're building automated systems, you need a tool that doesn’t force delays or extra steps—MailTester’s API is designed for that reality.

Live SMTP Checks Beyond Bulk Prediction

Some tools, like MillionVerifier, rely heavily on data patterns and scoring to predict validity. That’s fast—but it’s also limited. MailTester goes further: where possible, it runs actual SMTP conversations to confirm mailbox existence, catching temporary bounces, greylisting, and role-account behavior in real time. This is the same method used by major ESPs and enterprise systems. According to RFC 5321, SMTP is the definitive protocol for mail delivery testing—no shortcuts here. While other tools may flag a domain as “valid” based on syntax or DNS records, MailTester checks whether a mailbox is actually receptive.

And unlike domain-focused tools like Hunter or Emailable, which excel at finding roles (e.g., [email protected]) but don’t verify delivery, MailTester validates the full path—from domain to mailbox. If you're sending to leads, customers, or subscribers, knowing an address is syntactically correct isn’t enough. You need to know if it’s still active and willing to receive mail. MailTester checks that, and it’s available whether you’re working in a 10k list or a single address check. Try the API to see the difference, or test inbox placement with a real delivery simulation at MailTester Inbox Tester.

Start Validating Emails in Real Time — No Expiry, No Limits

Validate email domains and mailboxes in real time with a reliable command line tool built for scalability and precision. No need to wait for batch results — get instant feedback on deliverability, syntax, and domain health.

Get Started with No Risk

You begin with 100 free verifications. These are not temporary — any credits you purchase never expire, so your workflow remains uninterrupted.

Seamless Integration & Smarter Decisions

Connect directly to Mailchimp, HubSpot, Klaviyo, or SendGrid to automatically clean imported lists before sending.
Use the in-app AI assistant to decode validation verdicts, understand why an address was flagged, and act on recommendations.
Your data never leaves your control — no logs are retained, and third parties never access your input.

Sources

The number of top domains at DMARC enforcement grew from 233,249 in 2023 to 411,935 in 2026 — a 77% increase driven largely by mailbox-provider sender mandates. — EasyDMARC 2026 DMARC Adoption & Enforcement Report (2026)
Gmail requires bulk senders to keep user-reported spam rates below 0.3%, warning that rates above 0.1% already hurt inbox delivery — just 3 complaints per 1,000 emails crosses the line. — Google Email Sender Guidelines FAQ (2024)

Keep reading

Ready to put this into practice? MailTester verifies emails with 98.9% accuracy — start with 100 free verifications.

Frequently asked questions

Can I use a command line tool to verify emails in real time?

Yes. Tools like MailTester’s API can be called via the command line using curl or a simple script to validate email addresses instantly.

How accurate is real-time email validation with a CLI?

MailTester’s real-time validation has a 98.9% accuracy rate, based on live SMTP checks and domain behavior analysis, not predictions.

What’s the difference between syntax and real-time validation?

Syntax validation checks format only. Real-time validation confirms the domain exists and the mailbox accepts messages via SMTP.

Does using a CLI for email verification affect deliverability?

Yes — by catching invalid, catch-all, and disposable addresses, you improve sender reputation and inbox placement over time.

How do catch-all domains impact email deliverability?

They increase the risk of spam trap exposure and lead to higher bounce rates, negatively affecting sender reputation.

Can I use the MailTester CLI in a GitHub Actions workflow?

Yes. MailTester’s API supports integration in CI/CD pipelines, including GitHub Actions, for automated list validation at build time.

Is real-time verification more expensive than batch verification?

Real-time verification has a higher per-request cost but supports immediate decisions, reducing bounce rates and delivery failures.

Why should I avoid disposable email addresses?

They are temporary, often used by bots, and lead to poor engagement. Including them harms sender reputation and deliverability.

What happens if I send to a catch-all email address?

The message is accepted, but it’s often flagged as spam by email providers. It can degrade sender reputation and increase blacklisting risk.

Can I verify 100,000 emails using the MailTester CLI?

Yes — you can process large lists in batches. Each request uses one credit, and purchased credits never expire.

Does MailTester support role-based email validation?

Yes — it identifies common role addresses like info@, sales@, support@, and flags them as 'risky' to reduce spam risk.

Is my data safe when using MailTester’s real-time API?

Yes. MailTester does not store your email data beyond the validation process. All requests are processed securely and deleted immediately.