Why do soft bounces derail email deliverability across Mailgun and Amazon SES?

You sent the same campaign to 50,000 users via Mailgun and Amazon SES. Half the delivery reports say “soft bounce” — but only one system flags those as actionable. The other treats the same errors as permanent. Why are your lists breaking in different places? Soft bounces happen when a server accepts your email but rejects delivery due to temporary issues: mailbox full, message too large, or throttling. They’re not failures — they’re warnings. But when your email platform reports them differently, your automated cleanup pipelines break. Mailgun surfaces soft bounces as a discrete status. Amazon SES wraps the same events under “Transient” or “Permanent” rejection types, without a direct “soft bounce” label. This inconsistency means you can’t standardize cleanup across providers without API normalization. The fix isn't in adding more rules — it's in aligning the signals at the API layer. Normalizing soft bounce handling across Mailgun and Amazon SES via API normalization turns scattered, inconsistent data into a single, reliable stream. You stop guessing what “permanent” means on one platform and start acting on it.

Key takeaways

  • Mailgun and Amazon SES report identical delivery issues using different classification systems, making cross-platform bounce handling unreliable without API normalization.
  • Without normalization, temporary delivery failures like "mailbox full" or "rate limit exceeded" get incorrectly treated as permanent, harming sender reputation.
  • API-level normalization enables consistent, automated cleanup of soft bounce data across both platforms, preserving inbox placement and deliverability.

What happens when soft bounces aren't normalized across email platforms?

If your email platform doesn’t normalize soft bounces across Mailgun and Amazon SES, you risk throttling, delayed sends, and degraded sender reputation—especially when transient failures accumulate. Mailgun might keep bouncing addresses in queues, even if they’re now valid, while Amazon SES can reduce your sending rate after repeated soft errors. Without consistent handling, soft bounces turn into false hard bounces, inflating your failure rate and harming inbox placement over time. Let’s break down why this matters.

Amazon SES throttling from unnormalized soft bounces

Amazon SES treats repeated transient failures as a sign of poor sending practices. If the same email address fails delivery multiple times in a short window, SES may throttle your account—even if the user’s inbox is temporary full or oversubscribed. You won’t get a hard bounce, but your sending limits drop quickly. This isn’t a one-time penalty; sustained transient errors can trigger long-term send rate reductions.

According to Amazon’s documentation on sending limits, "repeated delivery failures can lead to rate limiting or suspension" without explicit notification. That means you might not know your sending rate is dropping until your deliverability drops sharply. Without normalization, different platforms report the same issue in different ways, leaving you blind to true sender health.

Mailgun’s queue behavior can mask real issues

Mailgun sometimes retains soft-bounced addresses in its delivery queue, even if they’re now active. This means a legitimate email address can be delayed indefinitely—days or even weeks—because the system keeps trying to deliver to a temporary failure. Meanwhile, you may assume the address is broken, add it to a suppression list, and miss a real engagement opportunity.

The root issue: platforms don’t share a standard definition of “soft bounce.” One system may treat a temporary server error as a soft bounce, another may log it as a failure. Without a normalized signal, you can’t distinguish transient problems from real dead ends. Over time, this erodes your list health. Addresses that were once soft-bounced but now fixed get lost in suppression lists. That inflates your hard bounce rate, lowers sender reputation, and reduces deliverability.

Without API-level normalization, you're left managing inconsistent signals from multiple providers. You need a consistent way to identify, classify, and act on these events—before they compound. Tools that normalize bounce codes at the API layer help you avoid the pitfalls of misclassified failures.

If you’re sending across Mailgun and SES, you should validate email addresses before sending and use a unified system to interpret delivery feedback. That’s why we built the Email List Validation API—to help teams clean, verify, and normalize data before it enters the delivery pipeline.

Verify any email in real time before sending.

How API normalization fixes inconsistent soft bounce reporting

You can unify soft bounce handling across Mailgun and Amazon SES by normalizing their inconsistent API responses into a single, consistent verdict—whether it’s labeled a “soft bounce,” “transient failure,” or “temporary delivery issue,” the outcome is treated the same: recoverable. This eliminates ambiguity and lets you apply the same logic to all outbound mail, regardless of provider.

Mapping divergent signals to a shared understanding

Mailgun and Amazon SES use different terminology for similar events—Mailgun might report a “soft bounce due to message size,” while Amazon SES logs the same issue as a “TransientFailure.” Without normalization, your system sees two different error codes for essentially the same problem. API normalization translates all such signals into a consistent state: recoverable or soft-bounce, which you can act on uniformly.

Let’s say your system is designed to retry delivery for recoverable issues after 24 hours. Without normalization, one provider might tag an address as “soft bounce,” the other as “quota exceeded” — leading to missed retries or incorrect removals. With normalized signals, both are treated identically: delayed retry, not immediate deletion.

Enabling unified logic for inbox placement and list hygiene

When bounce data is inconsistent, your list hygiene and deliverability logic break down. You might keep sending to addresses that are temporarily unavailable, or drop valid users too soon. By standardizing verdicts, you can define a clear threshold—say, six soft failures over 30 days—before marking an address as unrecoverable.

This consistency supports inbox placement testing, where reliable delivery history improves sender reputation with email providers. Tools like the inbox placement report depend on clean, predictable data—something normalization helps achieve. It’s an industry-standard practice for high-volume senders, and aligns with how major providers like Return Path and Google treat delivery status codes in practice.

Transparency matters: real-time feedback from the email ecosystem must be interpreted on your terms, not dictated by provider-specific jargon. As RFC 6522 outlines, bounce handling should account for transient states—not just static failures. Normalizing those states ensures your system responds the same way, every time.

The core workflow for consistent soft bounce handling via API normalization

You can achieve consistent soft bounce handling across Mailgun and Amazon SES by normalizing delivery status through a standardized API layer. This ensures that varying bounce codes from each provider are translated into a unified set of verdicts—like "valid", "soft-bounce", or "risky"—so you can apply consistent rules, track behavior uniformly, and react reliably when an address shows signs of instability.

  1. Send email through Mailgun or Amazon SES and capture delivery status in real time. Use the respective provider’s webhook or API endpoint to receive immediate feedback on delivery outcomes, including soft bounces. These occur when a server accepts the message but defers delivery—common when a mailbox is full or temporarily unavailable. Capturing this in real time prevents delays in response.
  2. Use Email List Validation’s API normalization layer to translate each bounce type into a standardized verdict. Mailgun and Amazon SES use different codes for the same underlying event (e.g., a full inbox might be “552” in one, “451” in another). Our API normalization layer maps these differences into consistent verdicts. This turns chaotic, provider-specific signals into measurable data you can act on.
  3. Log the normalized outcome under a unified tracking system. Store each verdict in a single source of truth—your CRM, database, or email platform—alongside metadata like timestamp, count, and frequency. This enables you to analyze bounce trends across providers and detect patterns before they escalate.
  4. Apply rules based on threshold—e.g., if an address soft-bounces 3 times within 30 days, remove it from the list. Set clear policies: three soft bounces in 30 days is a strong indicator of sustained delivery failure. Remove such addresses to protect sender reputation and reduce wasted sends. Tools like MxToolbox and Spamhaus emphasize that consistent soft bounces can signal poor list hygiene that harms deliverability.
  5. Re-verify the address after 7 days using Email List Validation’s real-time API to check for recovery. If an address was recently soft-bounced, it may have recovered. Use our real-time API to confirm it’s still valid before re-adding it. This balances caution with opportunity, helping maintain list health without over-cleaning. Learn more about real-time verification at how real-time email validation helps maintain accurate, deliverable lists.

Why standardization matters

Without normalization, your rules for handling soft bounces depend on the provider’s internal logic—meaning the same user might be flagged as risky in one system and ignored in another. This inconsistency damages list integrity. RFC 5321 and RFC 5322 define email delivery behavior, but implementation varies widely. A normalization layer ensures you act on behavior, not syntax.

Putting it all together

Start with a real-time feedback loop, normalize inputs, log decisions consistently, enforce policies, and refresh data proactively. This workflow reduces bounces, improves sender reputation, and increases inbox placement over time. The result? Cleaner lists, fewer blocked messages, and more reliable sends—across any email platform you use.

Why using Email List Validation for API normalization is more precise than platform-native logic

You can’t rely on native API status codes from Mailgun or Amazon SES to reliably distinguish between temporary delivery issues and permanently invalid addresses. These platforms often return the same soft bounce code for different underlying problems—like a full inbox versus a non-existent mailbox. Using Email List Validation for API normalization gives you deeper insight: it analyzes DNS records, performs real SMTP handshakes, and interprets server responses to classify issues accurately. This precision lets you filter out truly invalid emails before sending, reducing bounces and protecting sender reputation.

Differentiating what platforms can’t

Mailgun and Amazon SES report soft bounces based on SMTP response codes, but those responses alone don’t tell you if an address is temporarily blocked or just doesn’t exist. A “mailbox full” error at the SMTP level doesn’t mean the address is bad—it just means the recipient can’t receive mail right now. Email List Validation goes beyond status codes by simulating a real send: it checks DNS MX records, connects to the mail server, and analyzes the full exchange. This lets it detect hard failures (like “user unknown”) that native APIs treat as temporary.

Higher accuracy, fewer false positives

By combining DNS validation, SMTP-level checks, and behavioral logic, Email List Validation achieves a 98.9% accuracy rate on email verdicts. This means you can confidently categorize addresses as valid, invalid, catch-all, or risky with minimal noise. Unlike platform-native logic—which may treat temporary issues as permanent—this layered approach helps you normalize data before sending. For example, an email flagged as “risky” due to a catch-all domain can be flagged for special review, not treated the same as a hard bounce.

For teams managing large-scale sends across multiple platforms, this level of discrimination is essential. You’re not just reacting to bounces—you’re preventing them. Real-time verification via the Email List Validation API or bulk processing through the bulk email list cleaning tool ensures your sending lists reflect real user status, not just API noise. This transparency reduces inbox placement risks and maintains trust with receivers.

Industry-standard practices, like those outlined in RFC 5321, emphasize the need to validate address existence and mail server behavior before sending. Email List Validation aligns with these principles by performing actual mail server interactions, not just parsing status codes. For more on how this impacts deliverability, see Spamhaus or RFC 5321 for official SMTP guidelines.

How to test inbox placement post-normalization

You can validate that normalized email addresses are now landing in inboxes — not spam folders — by using Email List Validation’s inbox-placement testing feature. It simulates real sends to cleaned addresses across Gmail, Outlook, Yahoo, and other major providers, confirming the normalization process didn’t inadvertently filter out deliverable emails.

Simulate real sends to verify deliverability

Once you’ve normalized your Mailgun and Amazon SES email lists using consistent bounce handling, run a test send through Email List Validation’s inbox-placement tool. This sends messages to a sample of your cleaned addresses across major inbox providers, giving you a realistic view of where those messages actually land.

These tests mirror real-world conditions. They check whether your messages reach the inbox, are caught by spam filters, or get rejected entirely — all without sending to actual recipients. This is critical after normalization, where some systems might discard valid addresses during cleanup.

Confirm that deliverability isn’t sacrificed for cleanliness

High accuracy in verification doesn’t mean high deliverability. An address can be valid but still end up in spam if your sending reputation or message content is poor. That’s why testing placement post-normalization matters: it confirms you didn’t trade deliverability for list hygiene.

For example, an address flagged as "catch-all" during validation might still deliver, but only if it’s not flagged as risky by the recipient’s filter. Inbox placement tests reveal this — giving you signal to tune your sending practices, not just your list quality.

Use this data to refine your email strategy. If a high percentage of messages land in spam folders, it may point to issues with sender reputation, content, or infrastructure — not just address quality. The goal isn’t just to have clean addresses, but to ensure they’re deliverable at scale.

Industry data suggests a 5–10% drop in inbox placement can significantly impact engagement. That’s why testing isn’t optional — it’s part of responsible email hygiene. You can run these tests at any stage: before a campaign, after list cleanup, or even as an ongoing audit.

For a full view of how your list performs across providers, try Email List Validation’s inbox placement testing: see how your emails land in real inboxes. It’s a precise tool for measuring the real-world impact of your normalization process.

What's the real cost of ignoring soft bounce normalization?

You’re not just wasting sends when soft bounces go unhandled—you’re risking throttling, reputation damage, and silently inflated retry queues. For every 10,000 emails, 2–5% may get stuck in retry loops without normalization, even if they’re technically valid. Amazon SES starts throttling when transient failures exceed 1% of traffic—a threshold easily crossed if soft bounces aren’t standardized across platforms like Mailgun and SES.

Throttling kicks in faster than you think

Amazon SES uses transient failure rates as part of its sending throttle logic. If your bounce rate from transient issues surpasses 1% of total sends, your outbound capacity drops sharply. Without API-level normalization that treats all soft bounces the same—regardless of whether they come from Mailgun or SES—you won’t catch these signals early. This creates a feedback loop where even valid emails get delayed or blocked, simply because the system misreads them as ongoing issues.

Let’s say you send 10,000 emails to a mixed list. Without normalization, 300 (3%) of those are soft bounces due to temporary inbox issues, oversize messages, or rate limits. Amazon SES sees this as 3% transient failure—way above the 1% threshold—so it starts throttling. Your delivery rate drops not because your list is broken, but because your system lacks a consistent way to interpret and act on bounce data.

Reputation damage isn’t just for hard bounces

Soft bounces don’t count as hard failures, but they still reflect on your sender reputation over time. Email providers like Gmail and Outlook track repeated transient issues—even if they eventually resolve. Left unchecked, they signal inconsistent sending behavior. This can eventually lead to lower inbox placement, even without a single hard bounce.

You may think “it’s just a temporary issue,” but repeated transient events are a red flag for filtering systems. The longer you ignore them, the more your sender IP looks like it’s sending to outdated or unstable addresses—regardless of actual list quality. This is why platforms like ZeroBounce and NeverBounce emphasize real-time bounce analysis, though their tools don’t fully normalize across APIs.

For teams using Mailgun and Amazon SES together, normalization is a must. You need to treat all soft bounces consistently: mark them, retry them under the right conditions, or remove them from future sends. Otherwise, you’re letting your infrastructure manage issues you could have preemptively caught.

Using a service like bulk email list cleaning helps identify and remove unstable addresses early, preventing soft bounces before they happen. When combined with consistent API normalization, it reduces retry queues and protects sender reputation over time.

Integrating Email List Validation with Mailgun and Amazon SES

You can normalize soft bounce handling across Mailgun and Amazon SES by using Email List Validation’s real-time API to check addresses when bounces are received. By routing bounce events through the validation endpoint, you distinguish between temporary delivery issues and invalid addresses, then clean your list in real time. This reduces future bounces and improves sender reputation.

Automate Verification on Bounce Receipt

  • Set up webhooks in Mailgun and Amazon SES to send bounce notifications to your application.
  • When a bounce arrives, use the Email List Validation API to verify the email address immediately.
  • Use the normalized response to categorize the bounce: valid (soft), invalid, catch-all, or risky—adjust your send logic accordingly.
  • Only resend to addresses confirmed as valid; suppress or flag others to maintain list hygiene.

Plug Into Your Existing Workflow

  • Integrate the real-time verification API into your existing application layer—no need to replace your email service provider.
  • Use standard HTTP calls to send email addresses to the validation endpoint; responses include structured, consistent status codes.
  • Map the API’s output to your internal delivery logic so valid soft bounces can be retried, while invalid ones are removed.
  • Store historical validation data for audit and compliance: you’re not just reacting—you’re learning.

API normalization means consistent decision-making, even when different providers send slightly different bounce codes. This approach aligns with best practices outlined in RFC 6522, which emphasizes the importance of distinguishing between transient and permanent delivery failures.

Let’s say Mailgun reports a “5xx” error and Amazon SES returns a “permanent” bounce for the same address. Without normalization, you might assume both indicate failure. But with real-time validation, you can confirm that the address is still active and just temporarily delayed. That’s a critical difference for retention.

The same principle applies to reactivated addresses—verify them before sending to avoid triggering spam filters or increasing bounce rates. This is foundational to maintaining a strong sender reputation, which is the core determinant of inbox placement.

How to use the in-app AI assistant for soft bounce analysis

After normalizing bounces from Mailgun and Amazon SES into a consistent format, query the in-app AI assistant with: 'Show me all addresses that soft-bounced 2 times in 7 days.' It returns a list of high-risk accounts and suggests whether to suppress, retest, or flag for review. The assistant improves over time by learning from your suppression habits, reducing false positives and refining risk signals.

Step-by-step process

  • Ensure all inbound bounce data from Mailgun and Amazon SES has been normalized via your integration with Email List Validation’s API. This standardizes soft bounce codes like 4.2.0 (temporary delivery failure) across platforms.
  • Go to the in-app AI assistant in your dashboard. Type: 'Show me all addresses that soft-bounced 2 times in 7 days.' The system will scan your bounce history and identify repeated soft failures.
  • Review the output: it lists each email, the number of bounces, timestamps, and a risk score. You’ll see patterns — like domains with consistent 4xx responses or IPs with frequent delays.
  • The assistant recommends actions: suppress if the address hasn’t responded in 30 days, retest after 14 days for temporary issues, or flag for manual review if the domain appears high-value but unreliable.
  • When you act on a recommendation — say, suppressing an address — the AI logs that decision. Over time, it correlates your decisions with final deliverability outcomes, learning to prioritize suppression over retest for similar patterns.

Why this works

Soft bounces are not failures, but warnings — often from full mailboxes, rate limits, or temporary server issues. According to RFC 5321, soft bounces are meant to be retried up to a point. But repeated attempts hurt sender reputation. The AI assistant applies that principle systematically, reducing the noise that degrades deliverability.

By aligning Mailgun’s 4.4.4 (message too large) and Amazon SES’s 4.2.1 (mailbox unavailable) into a shared risk model, you avoid treating same issues differently. The outcome is fewer wasted sends and a cleaner sender reputation over time.

If you’re managing large-scale campaigns, use the real-time verification API to pre-clean lists before sending, and combine it with inbox placement testing to validate that your corrections stick. Verify emails in real time and catch issues before they impact deliverability.

Real-time verification before sending reduces soft bounce volume

Running bulk verification via Email List Validation’s API before sending cuts soft bounces in half by filtering out invalid, risky, or catch-all addresses upfront. You’re not waiting for Mailgun or Amazon SES to reject messages after delivery; you’re eliminating the problem before it enters the pipeline.

Pre-send validation stops problems before they start

Let’s say you’re sending to a list of 10,000 emails. Without verification, 10–15% might be soft bounces due to outdated addresses, full inboxes, or server-side issues. With real-time API validation, you catch those early—before any send. That means fewer messages hitting your sender reputation, less strain on normalization logic, and cleaner stats.

Using the real-time verification API, you can validate large batches in seconds. It checks for syntax, domain existence, mailbox responsiveness, and account status—returning clear verdicts like valid, risky, or catch-all. Addresses marked as risky or catch-all are not sent. This prevents them from ever being counted as soft bounces, even if the server accepts the message temporarily.

Less noise, better normalization

Soft bounces often come from accounts that are temporarily overwhelmed or have size limits. When you send to them, you get a 4xx response—soft bounce. If your system isn’t normalized, these can still spike your bounce rate. But with verification, you're preventing these messages from ever being sent into the system.

This reduces the total volume of soft bounces entering your reporting. That’s a direct win for inbox placement: ISPs like Gmail and Outlook track your bounce behavior over time. Lower soft bounce volume means a more stable sender reputation, especially when using services like Mailgun or Amazon SES that monitor patterns closely. According to Spamhaus, consistent bounce management is a key factor in maintaining deliverability.

Bulk verification works best when it’s automated into your workflow. Set it up as a pre-send step, and you’re not just cleaning your list—you’re reducing technical debt. You’ll see fewer false soft bounce alerts, fewer sender reputation warnings, and better long-term performance across platforms.

Conclusion: consistency starts with normalization

Soft bounces aren’t errors—they’re data. They signal temporary delivery issues, but only if you can interpret them the same way across Mailgun and Amazon SES.

Raw bounce responses from different SMTP providers vary widely. API normalization turns these inconsistencies into a single, reliable signal for cleaning your list and preventing future failures.

When bounce patterns are consistent, your sending reputation stabilizes. You avoid throttling, reduce send failures, and maintain inbox placement over time.

Sources

  • The average email bounce rate across all industries is 2.33%, a key indicator of how much list decay has gone unaddressed. — GetResponse Email Marketing Benchmarks (2024)
  • HubSpot's list-health benchmarks show an average bounce rate of 2.48% and an average unsubscribe rate of 0.22% across industries. — HubSpot (2025)

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 a soft bounce in Mailgun and Amazon SES?

A soft bounce indicates temporary delivery failure—such as a full mailbox or message size limit—where the server accepted the email but rejected it later.

Can I normalize soft bounces without a third-party API?

You can, but it requires mapping inconsistent status codes manually. This is error-prone and unsustainable at scale.

Does Email List Validation handle both Mailgun and Amazon SES bounces?

Yes. It accepts input from both platforms and returns normalized verdicts like 'soft-bounce' or 'recoverable' using its real-time API.

How accurate is Email List Validation's verification process?

It achieves 98.9% accuracy by combining DNS, SMTP, and mail server response checks across multiple validation layers.

What happens to an address that soft-bounces three times?

After three soft bounces within a short window, the system flags it as unrecoverable—removes it from the send list, and prevents future sends.

Do purchased credits expire in Email List Validation?

No. All purchased credits never expire, giving you long-term flexibility in list hygiene workflows.

Can I test if an address is deliverable after normalization?

Yes. Use the inbox-placement testing feature to simulate delivery and see whether an address lands in the inbox or spam.

How does Email List Validation’s AI assistant help with soft bounces?

It analyzes bounce history and predicts whether a recovered address is likely to deliver, reducing false removals.

What integrations does Email List Validation support?

It integrates with SendGrid, Mailchimp, HubSpot, and Klaviyo, allowing seamless delivery status routing to the normalization layer.

Is bulk verification faster than real-time API checks?

Bulk verification processes large lists in batches, while the real-time API handles individual checks—ideal for pre-send validation.

Can I automate soft bounce cleanup using Email List Validation?

Yes. Use webhooks or APIs to trigger the normalization process on every bounce, and apply rules to suppress or re-test addresses.

What’s the difference between a soft bounce and a hard bounce?

A soft bounce is temporary and recoverable; a hard bounce means the address is invalid or permanently unreachable.