Normalize Soft Bounce Labels | Email List Validation

Why do Mailgun and Amazon SES report soft bounces differently?

You’ve just sent a campaign through Mailgun, and your dashboard says 2% of recipients were soft bounced. You clean the list, re-send — and the same addresses now show as delivered through Amazon SES. What’s actually happening?

It’s not you. It’s how each API defines a “soft bounce.” Mailgun and Amazon SES use different internal thresholds and logic, so the same delivery failure can be classified in completely different ways. One treats a full inbox as a soft bounce. The other may not flag it at all.

This inconsistency ruins list hygiene. Healthier addresses get marked as problematic just because the email provider’s definition of “soft” varies. When you normalize soft bounce labels, you stop treating temporary issues as permanent problems.

Key takeaways

Mailgun may label full inboxes or rate-limited deliveries as soft bounces; Amazon SES often reports these as transient failures or ignores them entirely.
Different internal thresholds mean the same recipient failure gets classified differently across platforms, leading to false positives in list cleanup.
Normalizing bounce labels between Mailgun and Amazon SES ensures you only remove addresses that are truly undeliverable, preserving sender reputation and deliverability.

What is the real risk of unnormalized soft bounce labels?

Unnormalized soft bounce labels misrepresent email delivery issues, leading to valid addresses being incorrectly suppressed. This inflates your bounce rate, shrinks your list unnecessarily, and weakens sender reputation over time due to outdated data and poor deliverability hygiene. You're not just losing contacts—you're undermining your ability to send reliably.

Soft bounces aren’t failures. They’re alerts.

When Mailgun and Amazon SES report soft bounces differently—say, as "mailbox full" or "message size too large" in one system, but "temporary delivery failure" in another—you lose the signal behind the noise. Without standardization, your system can’t distinguish between genuinely problematic addresses and those that are just temporarily unreachable.

Let’s say a user’s inbox is full. That’s a soft bounce. If your system treats it as a permanent failure and suppresses the address, you’ll miss future communication. That’s not just bad for engagement—it’s a stealth degradation of list quality. Over time, your list shrinks with good addresses, not just bad ones.

How this hurts your sender reputation and campaign reach

Every suppressed address is an opportunity lost. Over time, your list grows smaller than it should, forcing you to rely more heavily on stale or outdated data. That directly impacts segmentation accuracy and reduces the relevance of your campaigns.

And here’s the real cost: senders with high suppression rates—even if only from soft bounces—often see reduced inbox placement. According to industry data from Return Path (now part of Validity), a sender’s reputation is influenced not just by hard bounces, but by the overall bounce behavior, including misclassified soft bounces. A poorly normalized system sends a signal of unreliability to email providers.

It’s a cycle: incorrect label handling → premature suppression → smaller list → weaker signal → lower deliverability. You’re not just filtering out bad data—you’re burying good data, too. The result is higher hard bounce rates later, as your list becomes increasingly outdated.

For validation at scale, tools that process and normalize bounce data are essential. With Email List Validation, you can clean your list in bulk before sending—identifying catch-all or risky addresses and eliminating false soft bounce noise early. This keeps your list accurate and your reputation healthy. Clean your list before it becomes a problem.

What does 'normalize' actually mean in this context?

Normalization means applying the same rules to determine whether a soft bounce from Mailgun or Amazon SES truly indicates a temporary delivery issue or a non-existent address—using external validation to resolve ambiguity. You’re not changing how either API labels bounces; those labels are fixed. Instead, you’re using an independent email verification system to assign accurate verdicts, so your list reflects reliable, up-to-date delivery status.

Why fixed API labels aren’t enough

Mailgun and Amazon SES both mark soft bounces as temporary failures—like full mailboxes or transient server errors. But they don’t tell you whether the address is actually valid or permanently broken. An email might soft bounce due to a full inbox, but it could also be a typo or a disconnected account. Without deeper verification, you can’t know.

For instance, a soft bounce from Amazon SES might mean the server was down at the time, while the same label from Mailgun could mean the user’s subscription is paused. One is a temporary glitch; the other might indicate a dead address. Without validation, you’re treating both the same—leading to wasted sends or poor deliverability.

How external validation turns ambiguity into clarity

This is where external verification comes in. You send suspected soft bounces to a real-time verification service that checks against DNS, SMTP, and known list of disposable domains, catch-all setups, and role accounts. These services use standardized, repeatable logic that goes beyond the APIs’ internal definitions.

For example, a service like Email List Validation’s real-time API confirms whether the domain exists, the mailbox responds, and there are no red flags like disposable email addresses. That’s how you normalize: by applying one consistent standard to labels that were originally inconsistent across platforms.

That’s not magic. It’s just better data. The RFC 5321 specification defines SMTP error codes, but it doesn’t dictate which failures are temporary or permanent in practice. Standards help, but real-world delivery depends on a mix of technical and behavioral signals. RFC 5321 covers SMTP, but not the business logic behind bounce classification.

With verification, you’re not rewriting the API outputs. You’re just interpreting them correctly. And that’s the core of normalization: a clear, repeatable way to know what’s a recoverable failure and what’s a dead end.

How to verify email addresses that failed due to soft bounces

When emails bounce softly in Mailgun or Amazon SES, don’t assume they’re permanently invalid. Run the list through a trusted email-verification service—like Email List Validation—to confirm whether the addresses still exist. A valid result means the inbox is functional, even if temporary delivery issues (like full inboxes or rate limiting) caused the soft bounce. This prevents removing valid users unnecessarily and keeps your sender reputation strong, especially when you're trying to reduce long-term bounce rates.

Step-by-step verification process

Identify soft-bounced addresses from your Mailgun or Amazon SES delivery reports. These are typically labeled as "5xx" errors (like 552, 550, or 554) and indicate temporary failures, not permanent ones.
Exclude known hard bounces immediately—those are definitive. But for soft bounces, proceed with verification, as the failure may be temporary and the address still valid.
Use a real-time email-verification API to test each soft-bounced address. The Email List Validation API checks DNS, MX records, and mailbox existence in real time. It returns clear verdicts: valid, invalid, catch-all, or risky.
Review the validation results—if the address returns as valid, it confirms the inbox exists despite the temporary delivery issue. This means the soft bounce wasn’t due to a dead email but to a transient condition.
Reintegrate valid addresses into your campaign flow. You can retry delivery or update your sequence timing. The goal is to preserve your contact list without over-cleaning.

Why this works, even when delivery fails

Soft bounces are common and often fix themselves. According to RFC 3463, soft bounces are meant to signal temporary issues—like a full inbox or a server temporarily blocking messages—rather than permanent rejection. You’re not just guessing; you’re testing the underlying address with a system that validates delivery potential, not just message routing.

The 5 steps described in “Step-by-step verification process”, in order.

Services like Mailgun and Amazon SES use different thresholds for soft bounce detection—Mailgun might trigger a soft bounce at 500KB, while Amazon might wait until 1GB. Without a clear understanding of whether the address is still active, you risk losing real users. That’s where Email List Validation’s 98.9% accuracy comes in. It separates temporary glitches from permanent invalidity.

Test your soft-bounced contacts with the real-time API—it’s fast, accurate, and lets you keep your list clean without losing outreach opportunity.

Use verified status to override inconsistent API labels

If your system treats every soft bounce as a delivery failure, you’re likely suppressing valid addresses. Normalize labels by using real-time verification: if an address is confirmed as valid, treat it as healthy—even if Mailgun or Amazon SES flags it as soft-bounced. Only suppress addresses marked as invalid or catch-all, regardless of API bounce status. This reduces false positives and aligns your list health with actual inbox placement risk.

How to apply verified status to normalize bounce labels

After receiving a soft bounce from Mailgun or Amazon SES, immediately verify the email address using a trusted validation service.
If the verification returns valid, treat the address as healthy—do not suppress it. Soft bounces can occur due to rate limits, temporary server issues, or mailbox quotas, not address invalidity.
If verification returns invalid or catch-all, suppress the address immediately. These labels indicate either a non-existent mailbox or a general-purpose inbox that won’t engage with content.
Store the verification result as the source of truth for deliverability risk—not the API’s bounce code. This ensures consistency across platforms.
Update your suppression list only when validation confirms the address is dead, not when an API label suggests temporary issues.

Why this works: The technical truth behind inconsistent labels

Mailgun and Amazon SES use different internal metrics to classify soft bounces—Mailgun may flag a large attachment as a soft bounce, while SES might treat a full inbox as a delivery failure. These do not reflect the email’s validity. A RFC 5321 compliant system only rejects permanently; temporary failures require a different handling strategy.

For example, a bounced email might return a 4xx status code from one provider but a 5xx from another—without meaning the address is dead. Relying on API labels alone leads to over-suppression. Instead, let real-time verification determine the real risk.

Use tools like bulk email list cleaning to run this process at scale. They detect catch-alls, role accounts, disposable domains, and greylisted inboxes early—before they trigger false positives.

Why email verification can’t fix SMTP timeouts or server issues

You can’t normalize soft bounce labels between Mailgun and Amazon SES by verifying emails alone—verification checks syntax, domain validity, and mailbox responsiveness, not whether your outbound server timed out during transmission. A soft bounce due to a Mailgun queue delay or a rate-limiting throttle on Amazon SES isn’t fixed by knowing if the email address still exists. Verification helps you identify functional addresses, but it doesn’t solve delivery failures caused by infrastructure load, network latency, or API misconfiguration.

What verification actually checks

Email verification confirms whether an address follows valid syntax (like RFC 5322), exists at the domain level (via MX records), and responds to a mail server test (a connection attempt to the SMTP server). It doesn’t monitor server health, queue depth, or how long a message takes to send. If your server is overloaded or your API request gets throttled by Amazon SES due to rate limits, the address might be perfectly valid—but your message won’t reach it.

Let’s be clear: a soft bounce in Mailgun could mean a temporary SMTP timeout, a rejected message due to size limits, or a rate limit hit on Amazon SES. None of these are caught by verification. The address remains valid, but delivery fails. That’s why you see different bounce labels between the two platforms—even for the same email.

Verification is useful for filtering stale or malformed addresses before sending. You can clean your list, reduce delivery failures, and improve sender reputation. But it won’t change how Mailgun’s outbound queue behaves or how aggressively Amazon SES enforces its rate limits. For that, you need to adjust sending frequency, scale infrastructure, or use connection pooling.

How verification still helps

Even if it won’t fix a timeout, knowing the address is still valid helps you interpret which bounces matter. If you see a "550 mailbox unavailable" on Amazon SES, the address might be dead. But if you see a soft bounce only on Mailgun, it might be a transient issue. Verification tells you whether the mailbox is still functional—giving you insight into whether a bounce reflects a real problem or just a routing hiccup.

Use real-time verification to catch invalid addresses early. For instance, if an address used to fail on Mailgun but now passes verification, it may have been a temporary block or DNS glitch. Run a bulk verification to clean your list, and then use inbox placement testing to see how well your messages land across providers.

For a comprehensive approach, try bulk email list cleaning before sending campaigns. It reduces soft bounces by removing likely invalid addresses—making the bounces you do see more meaningful. Use the real-time verification API to validate addresses on sign-up or before sending. This way, you catch errors early and improve your deliverability baseline.

Integrate verification with your email service workflows

You can normalize soft bounce labels between Mailgun and Amazon SES by verifying soft-bounced addresses before acting on them. Soft bounces often stem from temporary issues, but some reflect invalid or risky addresses. Run a bulk verification on them using a real-time API to distinguish true transient issues from permanent delivery failures. Only exclude addresses that return 'invalid' or 'risky'—not those marked 'valid' or 'catch-all' which may still be recoverable.

Process: Normalize soft bounce labels with verification

Hook verification into your automation pipeline. After receiving a soft bounce report from Mailgun or Amazon SES, pause processing and route the email address through a verification step. This prevents premature exclusion of addresses that may still deliver.
Batch-check soft-bounced addresses with the Email List Validation API. Feed the list into the real-time verification API to validate each address in parallel. This process takes seconds per batch and returns structured results: valid, invalid, catch-all, or risky. This aligns your internal logic with sender reputation signals from major providers.
Act only on verified 'invalid' or 'risky' results. Exclude addresses labeled as invalid or risky from future sends. Keep valid and catch-all addresses in your list—the latter may resolve during retry, and their soft bounce history is likely temporary.
Retain a log of verification outcomes. Store the verification result alongside the bounce report. This audit trail helps explain discrepancies between provider reports and helps refine your long-term suppression logic.

Why this matters

Mailgun and Amazon SES apply different thresholds for soft bounces. For example, a Mailgun soft bounce might trigger after three retries, while Amazon SES may count one hard failure from a full inbox as soft. Without verification, you risk over-cleaning—removing addresses that are still usable. This reduces your deliverability rate unnecessarily and lowers list quality.

According to RFC 6522, soft bounces should not be treated as permanent faults without confirmation. Many industry leaders use third-party validation before suppressing addresses, especially at scale. Tools like Spamhaus and MxToolbox provide data on delivery behavior, but only full validation confirms address status.

Let’s be honest: automated systems can't always tell the difference between a full inbox and a dead address. Verification closes that gap. The Email List Validation API integrates directly with your workflow, so you don’t need to switch tools. Use it to check soft-bounced addresses in real time and ensure your suppression logic reflects reality, not assumptions.

Real-world example: How to clean a 10K list with mixed bounce labels

You can normalize soft bounce labels between Mailgun and Amazon SES by exporting all soft bounces, merging and deduplicating the addresses, verifying them at scale with a trusted email validation service, filtering out invalid, catch-all, and risky addresses, then updating your database with only the valid ones. This reduces false positives and improves deliverability across platforms.

Step-by-step: Cleaning a 10K list with consistent labels

Export soft bounces from both Mailgun and Amazon SES. Use each platform’s reporting API or dashboard to pull every address flagged as a soft bounce. Mailgun may return a 4xx error with a reason; SES often logs a delivery status report with an event type like "Permanent" or "Temporary". These labels don't always mean the same thing across services — a soft bounce in one might be hard in another.
Merge and deduplicate the list. Combine both exports into a single dataset. Remove duplicates using tools like Excel, Google Sheets, or a simple script. Duplicate addresses can skew verification results and waste credits. A deduplicated list ensures each address is cleaned only once.
Run the merged list through Email List Validation’s bulk verification API. Submit the list to bulk email list cleaning. The service checks each address using SMTP validation, MX lookup, and DNS checks, including catch-all detection and role account identification. This provides a consistent, objective classification across all email addresses — regardless of how the original provider labeled them.
Filter results to keep only 'valid' addresses. In the verification report, retain only addresses marked as valid. Suppress all invalid, catch-all, and risky addresses. Catch-all addresses often lead to spam traps. Risky labels include disposable, temporary, or high-failure domains. These should not be in your active list.
Update your CRM or email platform with the refined dataset. Export the cleaned list and sync it with Mailgun, Amazon SES, or your sales database. This ensures future sends are targeted only at active, deliverable addresses. Over time, this reduces bounce rates and improves sender reputation.

Why this works

Soft bounce labels are not consistent across platforms. One system may flag a temporarily full inbox as soft; another might mark it as temporary and auto-retry. These differences create confusion during list hygiene. By replacing vendor-specific labels with a universal validation layer, you get objectivity. For example, the SMTP protocol defines specific response codes (like 4xx) that can help, but only if interpreted correctly. Most systems don’t normalize them.

Using a third-party verification tool is the only way to get a unified truth. You’re not fighting vendor-specific logic — you’re aligning against internet standards. This reduces false positives, improves inbox placement, and protects sender reputation. The result is a cleaner list, fewer undelivered messages, and better campaign outcomes.

How verification accuracy works under the hood

You don’t get accurate email validation by guessing or relying on surface-level patterns. Email List Validation uses real SMTP connections to check if an address actually receives mail, verifies the domain’s MX records, and detects catch-all setups—this means we analyze actual server responses, not proxies or rules of thumb. Our accuracy rate of 98.9% reflects real-world performance: 1 in every 100 valid addresses may be marked invalid due to transient server behavior, timing delays, or rare configuration quirks.

Real SMTP, real responses

Unlike tools that use heuristic rules or public databases, we initiate actual SMTP handshakes with mail servers. This means we follow the same process a legitimate sender would—connecting, sending commands like HELO, MAIL FROM, RCPT TO, and reading the server’s return codes. Only through this actual interaction can you detect temporary failures, greylisting, or hard bounces that aren’t captured by domain-only checks.

For example, a server may reply with a 450 or 4.7.1 error indicating the recipient is temporarily undeliverable, which we classify as a soft bounce. But because server responses vary widely in format and timing, understanding these nuances is critical for consistent labeling across platforms like Mailgun and Amazon SES, where soft bounces might otherwise be misclassified.

Why catch-all detection matters

Some domains accept any address—these are known as catch-alls. If you don’t detect them, you’ll wrongly mark valid addresses as invalid, inflating your list error rate. We check for catch-all behavior by sending test messages to randomly generated addresses on a domain. If multiple test addresses are accepted, we flag the domain as catch-all, which helps avoid false negatives.

Because no two servers behave identically, our system uses a combination of timing, response codes, and retry logic to distinguish between a transient issue and a permanent one. This is a known challenge in deliverability—RFC 5321 and RFC 5322 define the SMTP standard, but server implementations vary widely in how strictly they adhere to it.

For a deeper test of how your emails stack up in real-world inboxes, try our inbox placement testing to see how your messages land across major providers, including Gmail and Outlook.

Can you use free verifications to test the normalization process?

You can absolutely use the 100 free verifications from Email List Validation to test how soft bounce labels normalize when moving between Mailgun and Amazon SES. Run a small batch of soft-bounced emails through the free API to see how each provider flags them—then compare the results side by side. Credits never expire, so you can save them for larger batches later. This approach lets you validate your normalization logic without upfront cost.

How to test normalization with free credits

Start with a small list of 10–20 emails previously marked as soft-bounced in either Mailgun or Amazon SES.
Use the real-time verification API to check their current status—see whether they’re invalid, catch-all, or temporarily undeliverable.
Map each outcome back to the original soft bounce reason (e.g., "mailbox full" or "over quota") to identify how the API’s result aligns with your messaging platform's label.
Repeat with a comparable batch from the other platform (Amazon SES if you started with Mailgun, and vice versa) to compare consistency.

Why this works—and when to scale up

Soft bounce labels are often inconsistent across ESPs. Amazon SES may report a full mailbox, while Mailgun says “temp fail.” The same email might be flagged differently even within the same week. Using a consistent verification service like Email List Validation helps standardize that signal—so you’re not relying on provider-specific jargon.

Industry best practices—such as those from RFC 6522 on mail delivery status codes—highlight the need for normalization when cross-platform data is involved. But rules don’t eliminate platform noise. That’s where a clean verification layer helps.

Once you’ve validated your normalization logic with free credits, you can move on to bulk processing. You can always return to your saved credits later—not just for the same list, but for future campaigns, list hygiene routines, or even integration testing. The 100 free verifications are not a deadline; they’re a starting point.

Final takeaway: Fix the root cause, not the symptom

Soft bounce labels from Mailgun and Amazon SES APIs are inconsistent and often misleading. They reflect transient delivery issues, not permanent address invalidity.

Using these labels to filter lists creates false positives. A soft bounce today doesn’t mean an address is bad tomorrow — and ignoring this leads to unnecessary suppression of deliverable contacts.

The real fix: Verify at the source

Normalization isn’t about mapping one API’s “soft bounce” to another’s “undeliverable.” It’s about replacing inconsistent signals with verified data.

Real-time email validation confirms address validity before sending, eliminating reliance on post-send bounce interpretation.

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 is the difference between a soft bounce and an invalid email?

A soft bounce means delivery failed temporarily—like a full inbox. An invalid email means the address doesn’t exist or is malformed.

Can I normalize soft bounce labels without changing my email platform settings?

Yes—normalization is done by verifying addresses after the fact. You don’t need to modify Mailgun or Amazon SES configurations.

Why do Amazon SES and Mailgun have different soft bounce criteria?

Each service has its own internal thresholds and logic for classifying delivery failures. These are not standardized.

Is email verification enough to fix deliverability issues?

No—verification checks address validity, not inbox placement. It reduces bounce rates but not spam filtering or reputation signals.

How often should I verify a list that has soft bounce history?

Verify the list after every major campaign or when bounce rates exceed 2%. Use the Email List Validation API for recurring checks.

Can I automate the verification of soft-bounced addresses?

Yes—use the Email List Validation real-time API to integrate verification into your workflow automation, including Mailchimp, HubSpot, and SendGrid.

Do catch-all addresses hurt deliverability?

Yes—catch-all domains allow any email to be accepted, increasing spam risk. They should be cleaned from your list.

What happens if I suppress a valid email labeled as a soft bounce?

You lose a potential customer, reduce engagement, and harm sender reputation over time due to poor list quality.

How does Email List Validation handle role accounts like admin@ or sales@?

It identifies them as 'risky' and flags them for manual review—many role accounts are valid, but they are high-risk for engagement.

Are disposable email domains harmful to deliverability?

Yes—services like mailinator.com are used for spam registration and often have poor sender reputation. Remove them from your list.