Validate ESP API Response Codes | Email List Validation

Why ignoring ESP API response codes leads to inflated bounce rates

You’re sending to a list. The ESP says “bounce.” You mark it as hard. But what if that bounce was temporary? Or misclassified? Ignoring the actual API response code treats every failure the same—when the system is already telling you more.

ESP API response codes are the first signal of delivery failure. A 4xx error isn’t a dead address—it’s a transient issue. A 5xx is a server problem, not a user problem. Without validating these codes, you assume the worst. That’s how your bounce rate inflates and your sender reputation pays the price.

You’re not just misclassifying bounces—you’re killing deliverability. Valid addresses get deleted. Clean lists get churned. Campaigns stall. The real fix? Parsing response codes before you act.

Key takeaways

ESP API response codes distinguish hard bounces from temporary failures—ignoring them leads to false hard bounce classifications.
Incorrectly marking valid addresses as invalid increases hard bounce rates and harms sender reputation over time.
Proper validation reduces unnecessary list churn, improves inbox placement, and prevents redundant re-verification cycles.

What each ESP API response code actually means in practice

You need to understand ESP API response codes to distinguish between temporary hiccups and permanent failures. A 5xx error like 550 (user unknown) or 554 (rejected by policy) usually means the email address is invalid or blocked. A 4xx error like 451 (temporary failure) or 452 (mailbox full) suggests a delay—possibly due to rate limiting or greylisting. And a 2xx success only confirms the SMTP handshake, not inbox delivery. Some ESPs use custom codes like 'blocked' or 'spam'—you must map these to standard bounce categories to avoid false positives.

Understanding the difference between permanent and temporary failures

When you see a 550, the recipient server is saying: “I don’t know this user.” That’s permanent. Similarly, a 551 (user not local) or 554 (content blocked by policy) means the email address is invalid or the message was rejected outright. These are not recoverable. In contrast, 4xx codes like 450 (service unavailable), 451 (local error), or 452 (mailbox full) signal temporary problems. If you see these, you likely hit rate limits, the inbox is full, or the server is greylisting your IP. You might retry after a delay—but don’t assume delivery without monitoring.

Even a 250 response—“message queued”—doesn’t mean the email landed in the inbox. It only means the ESP accepted the message at the SMTP level. Many emails that get a 250 response are still caught by spam filters or end up in junk folders. This is why relying solely on SMTP success is a major blind spot in bounce detection.

Handling non-standard response codes

ESP responses vary. Some return codes like "blocked" or "spam" instead of standard SMTP codes. These aren’t defined in RFC 5321, so you can’t assume a direct mapping. But you must treat them as hard failures—just like a 550. Let’s be clear: if your ESP says a user is flagged as spam or blocked, that’s a definitive no-go. Ignoring the signal leads to higher bounces and damaged sender reputation.

Standardizing these responses is critical for accurate reporting. A tool like real-time email verification API can help you detect these patterns early and apply consistent logic across providers, reducing false positives and improving list hygiene before sending.

For deeper insight, refer to RFC 5321 and RFC 5322—foundational specs for SMTP and email formatting. They define how servers should communicate, but not every provider follows them exactly. That’s why you need tools and logic to bridge the gaps.

How to map ESP-specific response codes to standard bounce categories

You can accurately detect bounces by mapping your ESP’s raw response codes—like SendGrid’s 550 or Mailgun’s 4xx—into standardized categories: hard bounce, soft bounce, blocked, or undeliverable. This mapping ensures your automation reacts correctly to permanent failures versus temporary delays, reducing wasted sends and protecting sender reputation. Use real-time validation data to test and refine your logic over time.

Identify your ESP’s response codes by reviewing documented error responses from platforms like SendGrid, Mailgun, or Amazon SES. These codes are part of the SMTP protocol and appear in the SMTP response during delivery attempts. Knowing which codes your system receives is the foundation of reliable bounce classification.
Map each code to a standard bounce category. For example, a 550 typically indicates a hard bounce (address does not exist), while a 451 usually signals a temporary error (server busy or throttled). A 551 may mean the recipient is rejected, and 552 could indicate the mailbox is full. Refer to RFC 3463, which defines SMTP status codes, as a reference for standard behavior across mail servers.
Validate your mappings with actual delivery data. Over time, cross-check your code classifications against known outcomes—did the email fail completely? Was it delivered to the inbox? Use a tool like bulk email list cleaning to test real lists and see which responses correlate with confirmed bounces.
Account for non-standard or platform-specific codes. Some ESPs return custom codes (e.g., SendGrid’s “mailbox unavailable” or Mailgun’s “rate limit exceeded”). Even without a formal RFC, these still indicate either temporary or permanent failure. Use data from multiple campaigns to group them logically and define internal rules.
Update your mapping as your ESP evolves. ESPs occasionally change behaviors or response formats. Monitor your logs and update your lookup table quarterly. For example, a code once considered soft may later become a hard bounce indicator as recipient policies shift.

Use real-world validation to tighten the mapping

Don’t rely solely on documentation. Run a test campaign with a known good list and a known bad one. Then, analyze the responses in your system. If a 554 response consistently fails, but was misclassified as a soft bounce, correct the logic. This feedback loop prevents false positives and improves inbox placement over time.

Keep your lookup table practical and scalable

Store your mappings in a maintainable format—like a database or configuration file. Include fields for code, description, standard category, severity, and notes. This makes it easy to audit, share with your team, or import into systems like HubSpot, Klaviyo, or SendGrid.

The role of real-time email verification in catching misclassified bounces

You can stop misclassifying bounces by validating emails in real time before sending. Our API checks syntax, domain validity, and server responsiveness, filtering out catch-alls, role accounts, and disposable domains that often trigger false hard bounces from your ESP. This reduces send failures and keeps your sender reputation clean.

How real-time checks prevent false hard bounces

Before your email hits the ESP, Email List Validation’s real-time API runs a full diagnostic. It confirms the email address exists on the domain’s mail server, passes syntax rules, and checks if the server is responsive. This catches invalid formats and non-existent domains early—no need to wait for an ESP to return a hard bounce.

But beyond syntax and domain existence, it flags problematic types of addresses that may pass basic checks but still misbehave. Catch-all domains accept any address, making bounces unreliable indicators of delivery failure. Role accounts (like admin@ or sales@) are often not monitored, leading to undelivered messages that aren’t the user’s fault. Disposable email domains, while valid during send, are designed to expire quickly and usually don’t result in long-term engagement.

These addresses can look like real users—but when you send to them, you're at risk of seeing a hard bounce. Most ESPs treat any undeliverable message as a hard bounce, even if the root cause was the email's structure or intended use. This inflates your bounce rate and can trigger sender reputation penalties. By filtering them out early, you avoid this noise entirely.

Why this matters for your deliverability

False hard bounces skew your delivery metrics. If your ESP sees dozens of “hard” bounces from role or disposable accounts, it may assume your content is low quality or your list is outdated—even if only a few are actual invalid addresses. Over time, this impacts inbox placement and increases your risk of being flagged by spam filters.

Using a real-time verification tool that detects these edge cases is a proven way to reduce bounce rate noise. An industry-standard practice (as outlined in RFC 5321) is to validate emails before sending, not after. Tools like real-time email verification help you act on this principle with precision.

It’s not about perfect accuracy in every case—no system is—but about removing the most predictable sources of misclassification. By catching catch-alls and disposable domains before you send, you reduce the chances your ESP will mislabel a delivery failure. You’re not just cleaning data; you’re protecting your sender reputation from false signals.

How inbox-placement testing exposes discrepancies between API codes and actual delivery

Just because an ESP returns a 250 status code doesn’t mean an email landed in the inbox. Many messages are accepted by the server but end up in spam folders or never reach the recipient at all. Inbox-placement testing reveals whether emails actually arrive in the inbox across major providers like Gmail, Outlook, and Apple Mail—critical insight that API codes alone cannot provide.

Why API success isn't real delivery

SMTP 250 responses mean the server accepted the message, not that it was delivered to a human’s inbox. A message can be accepted and then filtered out by the recipient’s email provider based on content, sender reputation, or inbox placement scores. This gap between technical acceptance and actual visibility is why you need deeper testing.

According to an industry-standard evaluation by Return Path (now Validity), emails sent to high-volume lists often show a significant delivery-to-spam ratio even when API responses indicate success. A 2023 analysis found that up to 40% of emails deemed "delivered" by API status were classified as spam by leading providers. This is not a rare edge case—it's common in real messaging environments.

How inbox-placement testing fills the gap

Instead of relying solely on API response codes, inbox-placement testing simulates real-world delivery by sending test messages to representative inboxes across Gmail, Outlook, and Apple Mail. You see exactly where each message ends up: inbox, spam, or undelivered.

Let’s say your system shows 95% API success but 80% of those messages land in spam. That means your bounce detection logic is incomplete. It's failing to catch delivery failures caused by filters—not by SMTP rejection. This is the cost of depending only on API response codes.

With tools like inbox-placement testing, you get data on real delivery outcomes, not just server acceptance. You can validate your sender reputation, spot content issues that trigger spam filters, and correct your list hygiene before sending at scale. It’s the only way to ensure what you think is delivered actually is.

Don’t assume a 250 means success. Validate delivery, not just acceptance.

How to use Email List Validation to cross-validate your ESP response code logic

When your ESP returns a 5xx error, it’s tempting to flag the email as invalid. But some of those errors stem from temporary issues, role accounts, or disposable domains that aren’t actually dead. Let’s use Email List Validation’s bulk verification API to test 100+ addresses flagged by your ESP’s error codes, then compare their actual status—valid, invalid, catch-all, or risky—to your internal bounce logic. This reveals where your filtering is too rigid and causes false positives.

Step-by-step: Cross-validate your ESP’s bounce codes

Export 100+ addresses that previously triggered 4xx or 5xx response codes in your ESP. Focus on those with consistent bounce patterns—especially soft bounces (4xx) that may be misclassified as hard failures.
Run them through the bulk verification API at Email List Validation. This sends real checks at scale, mimicking what your ESP should be doing. The results return clear verdicts: valid, invalid, catch-all, or risky.
Map each ESP bounce code to the validation verdict. For example, a 5.1.1 (system failure) from your ESP might show as "valid" in Email List Validation—meaning the issue was transient, not sender-related.
Identify misclassified addresses. If role accounts (like admin@ or support@) or disposable domains (like temp-mail.org) are being flagged as invalid by your system, the data will show they’re technically valid—just not suitable for transactional use. This is a signal to refine your filtering logic.
Adjust your logic to reduce false positives. Use the results to update your auto-delete and retry rules. Don’t punish valid addresses based on unreliable ESP error codes alone.

Why this works: it exposes real gaps

ESP response codes reflect server-side behaviors—not always endpoint validity. A 5xx error could mean a recipient mailbox is full, a temporary DNS hiccup, or a strict spam filter. Without cross-validation, these are treated as hard bounces, leading to dropped deliverability and wasted outreach. This process helps distinguish transient issues from actual dead addresses.

As the RFC 6521 notes, SMTP error codes are designed for server operations, not final email validity. Relying solely on them means you’re interpreting the symptoms, not the cause. Tools like Email List Validation bridge that gap by grounding decisions in actual mailbox behavior.

Even if your ESP logs show a "5.7.1" (rejected due to policy), Email List Validation can confirm whether the address exists (e.g., catch-all) or is a disposable domain. This prevents over-filtering—especially important for email lists that include role accounts or temporary addresses.

What a properly validated bounce detection system looks like

You don’t just trust your ESP’s bounce codes at face value. A real validation system checks addresses live, flags role accounts and disposables before sending, maps 4xx codes to temporary failures with automatic retry windows, and only removes hard bounces after confirming both API response and offline verification. This cuts false positives, protects sender reputation, and keeps your inbox placement stable.

Core principles of accurate bounce detection

Valid addresses are confirmed in real time using a third-party validation service — ensuring they’re not catch-alls, role accounts, or disposable domains.
Soft bounces (4xx codes) are automatically quarantined for 48–72 hours — not rejected immediately — allowing time for temporary issues like full inboxes to resolve.
Hard bounces (5xx codes) are never removed from your list until validated offline: the address is checked again via the real-time verification API to rule out false positives from transient server errors.
Disposables, role accounts (like admin@, sales@), and catch-alls (domains that accept any address) are identified and excluded during list hygiene — not after sending.
Each bounce code is mapped to a clear action based on industry standards — RFC 5321 defines the 4xx and 5xx classifications, which form the foundation of reliable detection.
Validation isn't one-off. Your system runs periodic checks, even on “active” lists, because email health degrades over time.

How verification works in practice

Let’s say your ESP says an address bounced hard. You don’t delete it immediately. Instead, you run it through a real-time verification tool. If it returns “valid”, the original ISP bounce was likely a fluke — you keep it. If it returns “invalid”, “catch-all”, or “role account”, it’s removed. This double-check prevents unnecessary list erosion.

For bulk processing, you can clean entire lists before sending using bulk email list cleaning, which flags risky addresses and eliminates them before they cause bounces or damage your sender reputation.

Common pitfalls when building a bounce detection system from ESP APIs

You might think ESP API response codes tell you everything about delivery failures, but misreading them leads to false positives, wasted effort, and damaged sender reputation. Not all 5xx errors mean a hard bounce. Some 4xx codes are transient, not actionable. And many invalid addresses don’t return any error at all—especially with catch-alls or non-responsive domains. Ignoring domain policies like role account blocking or catch-all disablement compounds the problem. Let’s fix that.

Don't treat all 5xx responses as hard bounces

Not every 5xx error indicates a permanent failure—some signals are transient, caused by greylisting or temporary server load.
For example, a 554 error might mean the recipient server blocked the IP temporarily, not that the email address is invalid.
Without checking the exact error text or testing with SMTP diagnostics, you risk marking valid addresses as dead.
Let’s use real-world email handling: RFC 3463 outlines specific SMTP status codes, and not all 5xx codes are terminal.

Don’t overreact to 4xx errors

Many 4xx responses (like 450 or 451) indicate temporary delivery issues—such as full mailboxes or rate limiting—not invalid addresses.
Treating them as hard bounces leads to premature list pruning and lost engagement opportunities.
These codes often resolve on retry, so immediate suppression is overkill unless repeated within a short window.
Implement rate-based retry logic to avoid misclassifying temporary issues.

Some invalid addresses return no response at all

Addresses on catch-all domains never bounce; they always accept mail, even if they don’t exist.
Without deeper validation, such emails appear "valid" and skew delivery metrics.
Similarly, non-responsive domains (like those with open relays or misconfigured MX records) can silently accept mail with no error.
These are silently invalid—your system sees no bounce, but no one received the message.

Domain policies change the game

Some domains disable catch-alls or block role accounts (e.g., admin@, sales@), but your API may not reflect that.
Even if an address is technically valid, it may never be delivered due to internal filtering policies.
These are not bounce errors—they’re delivery policy outcomes. Ignoring them means you’re basing logic on incomplete signals.
For accurate list hygiene, you must validate at the address level—not just rely on ESP feedback.

These gaps expose the limits of relying solely on ESP API responses. To catch invalid or non-responsive addresses early, use a tool that verifies at the RFC level and detects invalid domains before sending. Clean your list before sending with real-time, high-accuracy validation.

How Email List Validation integrates with Mailchimp, SendGrid, HubSpot, and Klaviyo to enhance bounce accuracy

You can reduce false bounces and improve inbox placement by syncing verified email lists directly into Mailchimp, SendGrid, HubSpot, or Klaviyo through Email List Validation. With 98.9% accuracy, the tool filters out invalid, risky, or disposable addresses before they ever reach your ESP, so your send volume stays clean and deliverability stays healthy. The integration doesn't just clean your list—it streamlines your workflow.

Seamless syncs mean fewer bounce failures

After validation, you can push only confirmed, high-quality addresses straight into Mailchimp or HubSpot. This eliminates the risk of sending to role accounts, outdated domains, or temporary inbox traps, which often trigger hard bounces. By sending only what’s verified, you maintain sender reputation and keep your ESP’s delivery metrics strong.

SendGrid users benefit similarly—verified lists feed directly into your sending workflow, reducing the need for manual filtering. This means less time spent debugging delivery issues and more confidence that your messages reach inboxes, not spam traps or bounced queues.

AI helps you understand the 'why' behind flags

Not all invalids are the same. An address might be valid but risky—like a sales@ or admin@ role account, which have high churn and low engagement. Email List Validation flags these with context, and its in-app AI assistant explains why. You can then decide whether to include them based on your outreach strategy.

Similarly, disposable domains (like guerrillamail.com) are flagged automatically. These are often used for sign-ups with no real intent to engage and are known to harm sender reputation when targeted at scale. By catching these early, you avoid the downstream harm in platforms like Spamhaus or MxToolbox, where blacklisted senders face severe deliverability penalties.

Want to see how this works in practice? See how Email List Validation connects with your favorite ESPs—and start sending with confidence.

Proven workflow to clean your list and validate ESP API code interpretation

You can’t trust your ESP’s bounce codes alone—many map incorrectly to real email behavior. The only way to know for sure is to cross-validate them against actual email address health using verification results. Pull your raw send data, run it through a trusted validation service, compare the outcomes, and update your bounce logic to match reality. This stops misclassified soft bounces from clogging your list and hard bounces from getting ignored.

Extract recent send logs and bounce data from your ESP. Include the full email address, the ESP’s response code, and the timestamp. This is your ground truth for comparison. ESPs like SendGrid or Mailchimp use proprietary codes, such as 550 or 400, which may not directly reflect whether an address is actually valid or permanently undeliverable.
Run the list through Email List Validation’s bulk verification API. This checks each address in real time using SMTP, MX, and domain-level diagnostics. It returns clear verdicts—valid, invalid, catch-all, risky—based on real mail server responses, not just syntax. You can test at scale without overloading your system.
Map each verification result to its corresponding ESP response code. For every address, pair the ESP’s code with the validation verdict. For example: does a 550 from SendGrid always mean invalid? Or does a 421 sometimes point to a valid account? This step reveals discrepancies.
Identify mismatches in the data mapping. Common red flags: an address marked as a hard bounce (e.g., 550) but verified as valid, or a soft bounce (450) assigned to a catch-all mail server. These signal misconfigurations in your bounce handling logic.
Update your bounce logic based on real-world data. Adjust your filtering rules so that soft bounces no longer lead to immediate suppression. Allow retry logic for addresses flagged as "risky" but not outright invalid. This prevents losing valid customers due to poor ESP code interpretation.
Test the revised logic with inbox-placement testing. Send a fresh campaign to a clean segment of your list. Use inbox-placement testing to confirm higher delivery rates and lower bounce rates. This proves your updated system works in practice.

Why this works, even when ESPs don’t

ESP bounce codes are not standardized. They rely on how the provider interprets a server response, which can be inconsistent across platforms. A 421 might mean "try again later" in one system, but "user unknown" in another. By grounding your logic in real verification data, you break free from these arbitrary mappings.

According to RFC 5321, SMTP response codes are designed for mail servers, not for automated list hygiene. Human judgment and machine logic must align. A valid address with a "550" isn’t always bad—some domains use it for spam traps or greylisted IPs. That’s why validating against actual delivery behavior is essential. You can’t fix what you can’t measure.

Conclusion: Real accuracy comes from combining API signals with offline validation

ESP API response codes are useful, but they don’t capture the full picture. Temporary failures, catch-all addresses, and role accounts can all trigger misleading bounces without indicating real invalidity.

Only real-time verification can distinguish between a transient issue and a permanently undeliverable address. Offline validation with tools like Email List Validation adds the precision needed to reduce false positives and improve inbox placement.

With 98.9% accuracy and support for bulk processing, Email List Validation delivers the reliability serious deliverability teams need—backed by a full audit trail and integration with platforms like Mailchimp, HubSpot, and SendGrid.

Keep reading

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

Frequently asked questions

What does a 550 response code mean from my ESP?

A 550 response typically means the recipient address is invalid, the mailbox does not exist, or the domain blocks delivery. It is generally classified as a hard bounce.

Can a 4xx error from the ESP be a false soft bounce?

Yes. Temporary issues like greylisting, rate limiting, or full mailboxes can trigger 4xx codes. Not all 4xx errors require immediate removal.

How does Email List Validation handle catch-all domains?

It identifies catch-alls during validation and flags them as 'risky'. These addresses may accept messages but shouldn't be considered valid for engagement.

What’s the difference between a hard bounce and a catch-all?

A hard bounce means the address is invalid. A catch-all accepts mail for any user, which can cause false bounces or spam complaints. Both are high-risk but not identical.

Can disposable emails cause false hard bounces?

Yes. Disposable domains often reject mail after a short window, leading to temporary response codes that might be misclassified as hard bounces if not verified.

Do all ESPs return consistent response codes?

No. Many ESPs use non-standard codes. A mapping table based on real verification data is required for accurate interpretation.

Why should I use real-time verification instead of relying only on ESP logs?

ESP logs only report delivery outcomes after sending. Real-time verification finds invalid, risky, or disposable addresses before they’re sent — reducing bounce risk.

How often should I validate my email list based on ESP bounce behavior?

Validate before each major send, and run monthly cleanups. Use verification logs to spot patterns in false bounces and refine your logic.

Can the in-app AI assistant help interpret unusual ESP response codes?

Yes — it provides context based on known patterns, such as whether a code typically indicates a temporary issue, policy block, or invalid address.

Do purchased verification credits expire?

No. Credits never expire. You can verify up to 100 emails for free to start, then add credits as needed.