How should I handle `do_not_send`, `catch_all`, and `unknown` results from email verification APIs in my signup form?
Matthew Whittaker
Co-founder & CTO, Suped
Published 7 Aug 2025
Updated 16 Aug 2025
7 min read
When building a signup form, integrating an email verification API is a crucial step for maintaining a healthy email list and strong sender reputation. These APIs typically categorize email addresses as deliverable or undeliverable. However, a challenge arises with ambiguous results like do_not_send, catch_all, and unknown. These statuses indicate that the address is neither definitively valid nor invalid. Determining how to handle them impacts both user experience and your long-term email deliverability.
The core dilemma is whether to proactively reject these emails at the point of capture, even if they might technically be valid, or to accept them and manage potential issues later through post-transmission event processing. Each approach has its trade-offs. Rejecting them upfront can prevent bad data from entering your system and protect your sender reputation. However, it risks alienating legitimate users whose emails fall into these gray areas.
Understanding email verification results
Before deciding on a strategy, understanding what each of these statuses signifies is essential. An email verification API performs various checks, including syntax validation, DNS lookups, and SMTP checks, to assess an email address's deliverability. The ambiguous results usually stem from specific characteristics or limitations during this process.
Do_not_send usually flags addresses that are technically valid but should not receive mail due to high bounce rates, being a known spam trap, or having a history of complaints. These are typically addresses that could severely harm your deliverability if you attempt to send to them.
Catch_all domains accept all mail sent to them, regardless of whether the specific mailbox exists. This makes it impossible for verification services to confirm if a particular address on that domain is truly valid without actually sending an email. While many legitimate businesses use catch_all configurations to ensure no mail is missed, they are also frequently abused by spammers for lead generation. This ambiguity presents a significant challenge for email verification, as it may incorrectly flag a valid email as undeliverable. You can learn more about this on Infobip's documentation.
Unknown results typically mean the verification service could not determine the email's status, often due to temporary network issues, server timeouts, or strict anti-spam measures on the recipient's side. These addresses could be perfectly valid, but the verification process hit a snag. The Email Hippo API reference elaborates on such scenarios.
Handling ambiguous results
For do_not_send results, the recommendation is clear: always reject these at the point of signup. Allowing them can quickly lead to high bounce rates, trigger spam filters, and get your IP addresses or domains on a blacklist (or blocklist). Your signup form should display an error message prompting the user to provide a different email address.
For catch_all and unknown statuses, a more nuanced approach is often best. Strictly rejecting them can lead to a poor user experience, especially for legitimate users. Instead, consider accepting them, but with additional safeguards. Implementing a double opt-in process is highly effective. This ensures that only engaged, valid users make it onto your active mailing list, as they must explicitly confirm their subscription.
Another strategy for these ambiguous cases is to accept them and rely on post-transmission event processing. This means you allow the signup, attempt to send a welcome or verification email, and then monitor bounce rates, unsubscribes, and spam complaints. If an email to a catch_all or unknown address bounces, you can then remove it from your list. This approach prioritizes user experience while still maintaining list hygiene, though it requires robust backend processing.
Balancing user experience and data hygiene
Striking the right balance between preventing bad signups and avoiding false positives is key. While it's tempting to block anything that isn't a clear deliverable status, this can unnecessarily turn away legitimate users. For example, some users intentionally use catch_all domains and expect their emails to be accepted.
For catch_all domains, if your business model relies on high-quality, engaged leads (e.g., B2B), you might consider accepting these and then segmenting them for a more cautious sending approach. For general marketing, a double opt-in is a robust solution to vet these. You can also implement additional backend validations to reduce spam.
When dealing with unknown results, a common practice is to retry the verification after a short delay, as the issue might be transient. If it persists, treating it similarly to a catch_all (i.e., accept with caution and monitor bounces) is often appropriate. This helps to prevent rejecting a valid email due to a temporary technical glitch.
Here's an example of how you might implement a decision flow:
function handleEmailVerificationResult(status) {
switch (status) {
case 'deliverable':
return { action: 'accept', message: 'Email is valid.' };
case 'undeliverable':
return { action: 'reject', message: 'Please enter a valid email address.' };
case 'do_not_send':
return { action: 'reject', message: 'This email address is invalid or problematic.' };
case 'catch_all':
return { action: 'accept_with_caution', message: 'Email accepted, but verification required. Please check your inbox.' };
case 'unknown':
return { action: 'retry_or_accept_with_caution', message: 'Could not verify email. Please try again or check your inbox.' };
default:
return { action: 'reject', message: 'An unexpected error occurred.' };
}
}
Advanced considerations and continuous improvement
Beyond the initial signup, continuous email list hygiene is vital. This involves regular monitoring of your sending metrics, such as bounce rates and spam complaints. Even if you accept catch_all and unknown addresses, unresponsive or bouncing ones should be swiftly removed. This proactive email list validation prevents long-term damage to your sender reputation.
Another consideration is addressing disposable email addresses, which often fall under a do_not_send or similar category. While they might pass basic validity checks, their temporary nature means engagement will be nil. Maintaining a list of known disposable email domains, such as the one found on GitHub's disposable email domains list, and proactively suppressing them can prevent wasted sending efforts. Additionally, ensuring your forms protect against bot signups is important, as bots often use invalid or problematic email addresses.
Views from the trenches
Best practices
Always reject emails explicitly flagged as `do_not_send` to protect your sender reputation.
Implement double opt-in for `catch_all` and `unknown` email addresses to confirm user engagement.
Monitor post-transmission events, such as bounces, to identify and remove any problematic addresses that were initially accepted.
Regularly clean your email list by removing unengaged or bouncing subscribers to maintain deliverability.
Employ anti-bot measures like CAPTCHA on your signup forms to deter automated invalid signups.
Common pitfalls
Blindly rejecting all `catch_all` emails, which can alienate legitimate users who use such domains.
Ignoring `unknown` email statuses, potentially missing out on valid subscribers or sending to problematic addresses.
Failing to implement a double opt-in, leading to lower quality subscribers for ambiguous email statuses.
Neglecting post-signup email list hygiene, allowing bad addresses to accumulate and harm your deliverability.
Not having a strategy for disposable email addresses, which can inflate list sizes with unengaged contacts.
Expert tips
For `unknown` results, try re-verifying the email address after a short delay, as the initial issue might have been temporary.
Segment `catch_all` and `unknown` subscribers and approach them with a more cautious sending strategy, monitoring engagement closely.
Consider the trade-off between strict validation and user experience based on your specific business goals and audience.
For B2B scenarios, prioritize verifying domains of `catch_all` addresses even if individual emails are unconfirmable.
Automate the suppression of emails from known disposable domains to prevent them from entering your active lists.
Marketer view
Marketer from Email Geeks says that when handling these ambiguous email verification results, a cautious approach is usually best, and slow and monitor activity. These addresses may have a lower threshold for removal if not engaged, and double opt-in is good for all signups.
2023-04-10 - Email Geeks
Expert view
Expert from Email Geeks says that they typically advise users to rerun checks for `unknown` statuses because the initial inability to verify might be temporary. Often, retrying the verification process works, and it doesn't usually incur extra costs.
2023-04-10 - Email Geeks
Finding the right balance
Navigating do_not_send, catch_all, and unknown results from email verification APIs requires a strategic approach that balances user experience with the imperative of maintaining a clean email list. Proactive rejection of do_not_send addresses is always recommended to protect your sender reputation and avoid blacklisting.
For catch_all and unknown results, a more flexible strategy, often involving double opt-in and continuous post-transmission monitoring, is frequently the most effective. By combining robust inline validation with intelligent backend processing and ongoing list hygiene, you can maximize deliverability while still providing a seamless experience for your users.
