Article
How Do Verifiers Detect Catch-All Domains? A Step-by-Step Canary Probe
By Unlimited Verifier Team ·

Summary
Verifiers detect a catch-all domain by sending its mail server a random, non-existent address during the SMTP handshake. If the server replies 250 OK to a name that cannot exist, it accepts every recipient, so SMTP alone cannot confirm any individual mailbox.Verifiers detect a catch-all domain by sending its mail server a random, non-existent address during the SMTP handshake. If the server replies 250 OK, it accepts every recipient, so SMTP alone cannot confirm any individual mailbox on that domain.
The probe stops before any message body is sent, so the verdict rests on reading one response code correctly. This guide explains the test step by step, how to interpret the replies, where the method breaks, and what to do with the addresses it flags. For the broader process, start with how email verification works.
Quick answer
- The test: Send an
RCPT TOcommand with a random address at the domain. A 250 reply to a name that cannot exist means the domain accepts everything. - The verdict: Real addresses on a catch-all domain also return 250, so the defensible label is Risky (plausible but unconfirmed), not Valid.
- The complications: Greylisting (4xx replies), filtering gateways and partial catch-all rules can blur the result, so a careful verifier retries before deciding.
- The efficiency gain: Catch-all status belongs to the server. One probe per domain classifies every address on it.
- The honest ceiling: No SMTP check can prove that a catch-all mailbox exists. Only a test send or a bounce or engagement signal can get closer.
What is a catch-all domain, and why does it break verification?
A catch-all domain, also called accept-all, is one whose mail server accepts RCPT TO for any local part, real or invented. The SMTP recipient rules in RFC 5321 define this step: the server tells the sending system whether it will take a recipient before any message body moves. A catch-all configuration says yes to everything and decides what to do with the mail afterwards. It may forward to a shared inbox, filter the message, or bounce it later.
Administrators set this up for practical reasons. A small business may route every misspelled address to one inbox. An enterprise gateway may accept first and filter afterwards. Catch-all is a configuration choice, not evidence of a malicious domain.
It breaks verification because a 250 reply looks identical whether the mailbox exists or not. A verifier that checks only the target address learns nothing about the person behind it. For more on how accept-all results are labelled, see what accept-all means in an email verifier.
The practical insight is that the probe mostly tells you about the domain, not the person. Classify the domain once and you have classified every address on it. That is why good verification tools treat catch-all as a property of the server.
Bottom line: A catch-all is a server-level setting that says yes to every recipient, so a single 250 on a real address proves nothing by itself.
How does the canary probe work, step by step?
The method is called a canary probe. It isolates the one question that matters: does this server accept names that cannot exist? The full check sequence includes steps that run before SMTP, and those matter here too.
- Run the syntax check first. Malformed addresses should never reach a server. Syntax rules follow RFC 5322, and the details are in what RFC 5322 email syntax is.
- Check the domain and MX records. A domain without a working mail exchanger cannot be probed at all.
- Connect and greet. Open a session with the lowest-preference MX host on port 25, send
EHLO, thenMAIL FROMusing a sender the verifier controls. Many cloud hosts restrict outbound port 25 by default, which is one reason verification infrastructure matters. - Send the canary. Issue
RCPT TOfor a random local part. Verifiers differ on canary length and character set. We recommend a 12–20 character string of lowercase letters and digits. - Read the canary, then test the real address in the same session. A 250 means accepted, a 550 means rejected, and a 4xx means a temporary deferral. Testing both in one session keeps them on the same server state, so a configuration change between two sessions cannot distort the comparison.
- Quit before
DATA. The verifier never sends a message body, so nothing reaches the recipient. For why this is non-delivering, see whether email verification sends an email.
Here is a catch-all session. The domain is the reserved example.com:
C: RCPT TO:<x8k3fq9wzr2t@example.com>
S: 250 2.1.5 OK
C: RCPT TO:<jane.doe@example.com>
S: 250 2.1.5 OK
A server that discriminates between names looks different:
C: RCPT TO:<x8k3fq9wzr2t@example.com>
S: 550 5.1.1 User unknown
C: RCPT TO:<jane.doe@example.com>
S: 250 2.1.5 OK
The second pattern is the one that makes a Valid verdict meaningful. In the first, the real address's 250 tells you nothing about that mailbox.
Why a random string and not test@ or info@? Role names often exist on real domains, so a 250 for them proves little. How verifiers detect role-based addresses explains why those addresses need their own label. A 12–20 character random string avoids both traps: it is very unlikely to exist, and it is ordinary enough not to trigger rejections for reasons unrelated to existence.
Why one canary per domain? A catch-all setting applies to the whole server, so one well-formed probe answers the question. Extra canaries add load without new information unless the server appears to accept only certain name patterns, which the alternatives section covers.
Bottom line: Probe with a random name first, then the real address in the same session, and never send DATA. The canary's reply tells you what the real address's reply means.
How do you read catch-all probe responses?
The verdict comes from the pair of replies, not from either one alone. The table shows the logic most verifiers follow, though vendors label the buckets differently.
| Canary (random name) | Real address | Verdict | What it means |
|---|---|---|---|
| 250 | 250 | Risky (catch-all) | The server accepts everything. The real address is unconfirmed. |
| 550 | 250 | Valid | The server discriminates between names, and the real address was accepted. |
| 550 | 550 | Invalid | The server rejects unknown names, and the real address was rejected. |
| 4xx | 4xx | Risky (retry) | A temporary deferral, often greylisting. Retry before deciding. |
| 250 | 550 | Invalid (verify first) | The server accepts random names but rejects this one. This points to a specific rule or block, so re-test before suppressing. |
The only pairing that produces a Valid verdict is a rejected canary with an accepted real address. A 250 on the canary at the same time as the target is the signature of a catch-all.
Note that Valid here means the server accepted the recipient during the SMTP conversation. It does not guarantee delivery or inbox placement.
Default reply patterns help calibrate expectations. Based on public documentation, Google Workspace typically rejects unknown users with 550 5.1.1, part of the enhanced status family described in RFC 3463. Microsoft 365 usually returns 550 5.1.10 for unknown recipients. Administrators can change both behaviours, so treat these as defaults to confirm on your own domains, not guarantees.
Bottom line: A Valid verdict requires a rejected canary and an accepted real address. Any other pairing means the domain's behaviour is ambiguous or the mailbox is not confirmed.
What are the alternative ways to detect catch-all domains?
The canary probe is the core technique, but it is not the only one. Each alternative answers a different question, and the table compares them.
| Method | What it reveals | Where it fails | Practical cost |
|---|---|---|---|
| Single canary probe | Whether the server accepts unknown names at this moment | A snapshot; blind to greylisting and rule changes | One extra RCPT TO per domain |
| Canary with retry | Separates temporary deferrals from true catch-alls | Still SMTP-only; adds time per deferred domain | An extra session only when the first reply is 4xx |
| Multiple canaries | Catches servers that accept only certain name patterns | Repeated probing looks like abuse and can be throttled | Several RCPT TO per domain |
| Test send and bounce watch | Whether a bounce arrives, a signal that the mailbox may not exist | Sends a real message and needs a waiting window; see bounce-based catch-all checks | A live send |
| VRFY command | Historically, a direct user lookup | Many servers disable it. RFC 5321 allows a 252 reply, meaning the server cannot verify but will attempt delivery | Usually no useful answer |
| Gateway and host fingerprinting | Hints that a filtering gateway sits in front of the domain | A heuristic: it flags risk but does not prove a mailbox | Very low |
| Engagement history (opens, clicks, replies) | Whether people on your list interact with you | Not an SMTP signal. Opens are unreliable because Apple Mail Privacy Protection preloads images | Uses data you already hold |
The pattern is simple. SMTP-based methods answer "does this server accept the name?" Only a test send, or a person's real engagement, gets closer to "did the person receive and read it?"
Bottom line: Use the canary probe for the domain verdict, add a retry for deferrals, and use bounce and engagement data for the person-level question.
Why are catch-all results ambiguous?
Four conditions keep catch-all results from being clean, and each changes how you should act on the Risky bucket.
- Greylisting. Some servers reject first contact with a 4xx reply and accept on retry. A verifier that does not retry will label legitimate addresses as Risky. Greylisting software such as Postgrey defaults to a delay of about five minutes, so a single retry after roughly 15 minutes is a reasonable starting point. That figure is our recommendation, not a published standard. These domains are often the slow ones, covered in why email verification is slow for some domains.
- Security gateways. Many filtering services accept every recipient at the SMTP layer and quarantine afterwards. A catch-all reading on these domains reflects the gateway, not the mailboxes behind it.
- Partial catch-alls. Some servers accept random names but reject specific addresses, or vary by sender or IP reputation. A single canary then gives a false picture.
- Full mailboxes. RFC 5321 defines
452for insufficient system storage and552for an exceeded storage allocation. Those replies mean the mailbox exists but is full, so they should not be treated as nonexistent. Mailbox-full results explain how to label them. - Drift over time. Administrators change catch-all settings whenever they reconfigure mail. A result from last quarter is a snapshot, not a permanent fact.
The practical consequence is that a Risky label should trigger a decision, not a permanent ban. We recommend re-checking high-value catch-all domains monthly, and before any large send, since that is when a configuration change would hurt most.
Bottom line: Catch-all results are ambiguous because of greylisting, gateways, partial rules, full mailboxes and configuration drift, so re-check before acting on them.
Worked example: how would you verify a 60,000-contact list with catch-alls?
These figures are illustrative. The arithmetic and plan limits are real.
A B2B software company exports 60,000 contacts from its CRM before a product launch. The team needs to know which addresses are safe to mail. A list of this shape is common in email verification for ecommerce and SaaS work.
Setup
- The list is split into three files of 20,000 rows each, under the Pro plan's 25,000-emails-per-list cap.
- Pro costs $29 a month, or $25 a month billed annually, which is $300 a year. For how plans compare on cost, see email verification pricing.
- Free allows 150 emails per list and 25 lists a month, which is 3,750 emails a month. 60,000 ÷ 150 = 400 lists, and 400 ÷ 25 = 16 months. Pro is the realistic choice here, and Free has no API access.
Illustrative results
- Valid: 46,100 (76.8%)
- Risky: 9,300 (15.5%), made up of 8,700 catch-all addresses and 600 still deferred after retry
- Invalid: 4,600 (7.7%)
- Check: 46,100 + 9,300 + 4,600 = 60,000.
The domain-level insight
- 1,240 distinct domains were flagged as catch-all. One canary per domain means 1,240 canary probes, with retries only on the deferred domains.
- The 8,700 catch-all addresses average 7.0 per domain (8,700 ÷ 1,240). One probe result covers all seven of them.
Segmenting the catch-all set
- 1,900 of the 8,700 (21.8%) opened or clicked in the last 180 days.
- The other 6,800 (78.2%) have no recent engagement, so they stay out of regular sends until a test shows otherwise.
Automating it
If the team calls the API instead of uploading files, 60,000 addresses in batches of 10,000 means 6 requests. That fits within the Pro plan's 100,000 API emails a month. For workflow patterns, see email verification API and automation.
Bottom line: For this list, 8,700 catch-all addresses cost one probe per domain to classify, and the real decision is about engagement, not the probe.
How do you find catch-all addresses in Unlimited Verifier?
Unlimited Verifier checks syntax, domain, MX records and the SMTP mailbox, detects catch-all domains, and sorts every address into Valid, Risky or Invalid. Here is how to run the workflow on your own list.
- Export a CSV from your ESP or CRM. Include the email column and an engagement field such as last open or last purchase date. A 60,000-row file with a few columns is roughly 3MB at about 50 bytes per row (our estimate), well under the 10MB upload limit.
- Sign up and check your plan's limits. Free allows 150 emails per list and keeps results for 24 hours. Pro allows lists of up to 25,000 emails and keeps results for 30 days.
- Split large files into lists under your cap. Three 20,000-row files fit within Pro.
- Upload and verify a list. CSV and Excel files are accepted, and the email column is detected automatically.
- Find the catch-all domains in your results and separate them from the Valid rows. Treat them as their own decision group, not a deletion list.
- Export as CSV, Excel or JSON. On Free, download before the 24-hour window closes, and save the bucket counts for your records.
- Spot-check edge cases with the free email checker, and read the catch-all email verification page for how these domains are handled.
- Re-import the Valid contacts into your ESP as a new segment, and suppress the Invalid ones. Unlimited Verifier has no native ESP, CRM or Zapier integrations, so re-import is a CSV upload or a call to the email verification API.
Bottom line: Export, upload, separate the catch-all domains, export before results expire, and re-import only what is Valid.
What should you do with catch-all addresses?
Decide by engagement and role, not by the catch-all flag alone. The table is a starting framework.
| Situation | Recommended action | Reasoning |
|---|---|---|
| Engaged in the last 90 days, on a catch-all domain | Send in a small tranche and watch bounces closely | Recent engagement offsets the uncertainty about the mailbox |
| No recent engagement, senior contact | Hold, and look for a confirmed alternative address | You would be sending blind to someone who matters, so the risk is worth reducing |
No engagement, generic role address (info@, sales@) |
Suppress from marketing | Role addresses carry their own risk; see role-based detection |
| Previously bounced on this domain | Suppress | Your own bounce history outweighs a fresh probe |
| Transactional mail (receipts, password resets) | Send if the person just entered the address, and monitor | The user supplied the address, which is a basis for sending |
A catch-all result does not establish consent. An address on an accept-all domain can still belong to someone who never opted in, which is why email verification compliance and hygiene is a separate question from the technical one. Google's bulk sender guidance says to keep spam rates below 0.10% and to avoid reaching 0.30%. Unengaged catch-all addresses that bounce or get marked as spam push those numbers the wrong way.
For ongoing upkeep, the email list maintenance best practices guide covers how to re-check catch-all domains on a schedule.
Bottom line: Engagement decides whether a catch-all address is worth a cautious send. The verification result alone never does.
How accurate is catch-all detection, and how do vendors differ?
No vendor can confirm a catch-all mailbox through SMTP. The useful question is how a tool labels these domains and whether it shows its method. Unlimited Verifier states 99.5% accuracy for deep verification. That is the company's own figure, not an independent benchmark, and it does not mean catch-all addresses are 99.5% confirmed.
When you compare options, including the tools in this best email verification tools roundup or our verification tool roundup, ask each vendor these questions:
- Where does catch-all land? Risky is the defensible answer, since Valid overstates what SMTP can prove.
- Does the tool retry deferrals before labelling a domain?
- How does it pace probes? Bursts against one domain can trigger throttling.
- Can you see the reason for an individual result, not just a bucket?
- Can you automate it? Check the API limits and whether bulk requests are supported.
Ask for these definitions in writing. Here is what Unlimited Verifier's documentation and product facts support: it detects catch-all domains and sorts results into Valid, Risky or Invalid. Results export as CSV, Excel or JSON, and the API accepts bulk requests of up to 10,000 emails per request. The verification engine is open source on GitHub, so you can read how its checks are built rather than relying on a summary. For a broader buyer's checklist, see how to choose an email verifier. To catch these domains at signup, see real-time email validation.
Bottom line: Judge a tool on how it labels catch-all domains and whether it shows its method, not on a single accuracy headline.
What are the common mistakes in catch-all detection?
- Treating a catch-all as Valid because the real address returned 250. Always check the canary reply first.
- Using a predictable canary such as
test@orinfo@, which may exist and produce a false 250. - Probing one domain in a burst of many requests. This is the fastest way to get throttled or blocked.
- Assuming the result is permanent. Administrators change catch-all settings, so re-check high-value domains before large sends.
- Repeating the check immediately and expecting a new answer. A catch-all is a stable setting. Retries resolve greylisting, not catch-all status.
- Ignoring partial catch-alls. A domain that accepts some names and rejects others needs more than a single probe.
- Suppressing on a single 250/550 mismatch. That pattern can reflect a rule or block, so re-test before acting.
- Sending the whole Risky bucket at once. Ramp in tranches, starting with the most engaged contacts.
- Forgetting the retention window. On Free, results are kept for 24 hours, so export before they expire.
- Losing your bounce history during a migration. Your own past bounces are better evidence than any probe.
- Confusing catch-all with consent. Passing a technical check does not prove someone wants your email.
Bottom line: Most errors come from trusting a single reply, skipping retries, or sending to Risky addresses before you have engagement data.
How we compared (and limitations)
This article is based on public documentation, including RFC 5321 for SMTP commands and reply codes, RFC 3463 for enhanced status codes, and Google's published sender guidance. We have not run controlled tests against any mailbox provider or verification tool, and we have not benchmarked competitor accuracy.
Mail server behaviour varies by configuration and changes without notice, so the reply patterns described here are typical, not guaranteed. The retry delay and re-check cadence are our recommendations, not published standards. Unlimited Verifier's 99.5% deep-verification accuracy is the company's stated figure. The worked example uses illustrative numbers; the plan limits, prices and API batch size are the product facts.
Bottom line: Treat the mechanics as reliable and the reply patterns as defaults to confirm on your own list.
Catch-all classification steps
- Run syntax check (RFC 5322).
- Look up MX records for the domain.
- Send RCPT TO with a random address, then stop before DATA.
- If 250: domain is catch-all, label addresses Risky.
- If 550 on random, test the real address: 250 means Valid, 550 means Invalid.
- If 4xx: retry after a delay before deciding.
- Store the result per domain and reuse it for all addresses on that domain.
Frequently asked questions
What is a canary probe in email verification?
A canary probe is a test that sends an SMTP RCPT TO command with a random, non-existent address to a domain. If the server accepts it with a 250 reply, the domain is likely catch-all, meaning it accepts mail for any address, so individual results on that domain are unreliable.
Can an email verifier confirm a catch-all address is real?
Not through SMTP alone. A catch-all server returns 250 for real and invented addresses alike, so the reply carries no information about a specific mailbox. Confirmation requires a test send, a bounce signal, or recent engagement data.
What does a 4xx reply mean during catch-all testing?
A 4xx reply is a temporary deferral, often from greylisting. It means the server asks the sender to try again later. A careful verifier retries the probe after a delay before deciding the domain's status.
Why do some domains reject the random address but accept real ones?
Some servers use partial catch-all rules or recipient validation tied to a directory. They reject unknown names with 550 but accept known mailboxes. In that case the domain is not a full catch-all, and the probe result is a clean rejection.
Should I remove catch-all addresses from my list?
Not automatically. Catch-all addresses are Risky, not invalid. Many senders keep them in lower-priority segments, watch bounce and engagement, and suppress them if they bounce or stay silent over time.
Do all verification tools flag catch-all domains?
Most mature tools expose an accept-all or catch-all status, but labels differ. Check how a tool defines its categories in its public documentation before relying on the label for sending decisions.
Is catch-all setup a sign of spam or a bad domain?
No. Catch-all is a configuration choice used by many small businesses and enterprise gateways. It is not evidence of malicious intent, so it should be treated as an uncertainty signal rather than a reason to block.
Why does a verifier send a random address instead of the real one first?
The random address isolates the server's behaviour. If it accepts a name that cannot exist, the server accepts everything, so the result for the real address cannot distinguish a valid mailbox from an invented one.
Does a catch-all test send an actual email?
No. The probe stops after the RCPT TO response and before any message body is transmitted, so no message is delivered to the mailbox.
Cut Bounces and Protect Your Sender Reputation With Unlimited Email Verification
Every invalid address you send to hurts your sender reputation and your inbox placement. Verifying your list before each send means fewer bounces, healthier deliverability, and a predictable cost. With Unlimited Verifier, standard verification is unlimited on every plan, with no per-email fees.
Unlimited Verifier checks syntax, domain, MX records and the SMTP mailbox. It also detects catch-all domains and flags disposable and role-based addresses. Export a CSV from your email platform or CRM, upload and verify the list, then re-import the clean results. You can also automate checks with the email verification API.
| Free | Pro | |
|---|---|---|
| Price | $0 | $29/month ($25/month billed annually) |
| Lists | 25 a month, up to 150 emails each | Unlimited, up to 25,000 emails each |
| Deep verifications | 750 a month | 25,000 a month |
| API access | No | Yes (100,000 emails a month) |
| Result retention | 24 hours | 30 days |
Why teams choose Unlimited Verifier
- Unlimited standard verification on all plans, including Free, with no per-email fees.
- Catch-all detection so you know which domains accept every address.
- Clear Valid / Risky / Invalid results, exportable as CSV, Excel or JSON.
- An open-source verification engine you can inspect on GitHub.
Unlimited Verifier states 99.5% accuracy for deep verification.
Create a free account and verify your next list before you hit send.
Want to test a single address first? Try the free email checker.