Why DSN reports matter for deliverability and list health

You sent emails to 10,000 addresses. Got 500 bounces. You checked the dashboard. “All good,” you thought. But what if half those bounces were hard bounces—and you didn’t know it?

Mailgun’s DSN (Delivery Status Notification) reports are the raw, machine-readable log of every email delivery outcome. They don’t just say “bounce”—they say why, when, and how. Ignoring them is like flying blind through storm clouds.

Without analyzing DSN reports, you risk sending to addresses that are inactive, invalid, or blocked. That inflates your bounce rate, hurts sender reputation, and directly reduces inbox placement. In 2026, even a 1% hard bounce rate can trigger filtering by major ISPs.

Key takeaways

  • DSN reports provide granular, machine-readable evidence of delivery outcomes—including hard and soft bounce types from Mailgun.
  • Unanalyzed hard bounces degrade sender reputation and increase the risk of being filtered or blacklisted by ISPs.
  • Regular DSN report analysis is essential for maintaining list hygiene and improving long-term deliverability in 2026.

What is a DSN report, and how does Mailgun send it?

When Mailgun tries to deliver an email, the recipient’s mail server sends back a DSN (Delivery Status Notification) — an automated message informing Mailgun whether delivery succeeded, failed, or is delayed. These reports contain status codes (like 550 for permanent failure or 450 for temporary rejection), timestamps, and the recipient address. Mailgun captures this data and stores it in your account’s DSN logs, where you can analyze hard and soft bounces directly in your dashboard.

How DSNs work at the protocol level

DSNs are part of the SMTP standard, defined in RFC 3464. They’re triggered when a mail transfer agent (MTA) at the receiving end processes your message and determines the outcome. Unlike simple bounces, DSNs are more structured — they don’t just say “failed,” they explain why. A 5xx code means the address is permanently unreachable (e.g., invalid or rejected), while 4xx codes indicate temporary issues like overcapacity or greylisting.

For example, if a recipient server returns a 550 error because the email address doesn’t exist, Mailgun logs that as a hard bounce. If it returns a 421 timeout due to a temporary server overload, that’s a soft bounce. These distinctions matter for list hygiene — ignoring 4xx codes can lead to unnecessary hard bounces later.

How Mailgun processes and stores DSNs

Mailgun automatically receives DSNs from the receiving MTAs and routes them through its reporting pipeline. You can view them in real time via the Mailgun control panel or access them through the API. Each log entry includes the original to address, delivery timestamp, final status code, and an optional diagnostic message from the remote server.

You can export DSN logs for long-term analysis. This makes it easier to detect patterns — like a sudden rise in 550 errors from a specific domain — which might signal a problem with your email list or sender reputation. Many email systems, including SendGrid and Amazon SES, work similarly, but Mailgun’s DSN reporting is designed to be transparent and easy to query.

Use this data to prune invalid addresses and avoid further delivery issues. If you’re not already filtering for hard and soft bounces, it’s time to start. The alternative—keeping outdated or incorrect addresses in your list—leads to higher bounce rates, worse sender reputation, and lower inbox placement.

For a more proactive approach, you can clean your list before sending. Use real-time email validation to catch invalid addresses early. Bulk email list cleaning helps remove hard bounces, invalid domains, and risky addresses before they even hit Mailgun.

Hard vs soft bounces: what each DSN status code means

Hard bounces (5xx) mean an email failed permanently — the address is invalid, doesn’t exist, or is blocked. Soft bounces (4xx) mean a temporary issue, like a full inbox or server delay. Understanding the status codes helps you clean your list, avoid reputation damage, and improve deliverability. You can validate your list before sending to catch errors early.

Hard bounces: permanent delivery failure

When Mailgun returns a 5xx DSN code, it’s a hard bounce — the message will never be delivered. These are usually due to invalid syntax, non-existent users, or domains that block messages outright. The most common 5xx codes you’ll see are 5.1.1 (user unknown), 5.2.1 (mailbox unavailable), and 5.4.4 (mailing list closed).

For example, a 5.1.1 error means the mailbox address doesn’t exist on the receiving server. A 5.2.1 implies the server rejected the address, possibly because it’s been disabled or disabled due to policy. If you see 5.4.4, the list is likely closed — common with mailing list providers that restrict inbound mail.

These errors aren’t recoverable. If you continue sending to them, your sender reputation takes a hit. ISPs and inbox providers track these failures. Consistently sending to invalid addresses can land you on a blocklist or trigger throttling.

Preventing hard bounces starts with verification. Tools like bulk email list cleaning can catch invalid addresses before you send, reducing bounce rates and protecting your domain reputation.

Soft bounces: temporary delivery issues

Soft bounces (4xx) mean the message was received but not delivered for a temporary reason. These can still happen even with valid addresses. Common 4xx codes include 4.2.2 (mailbox full), 4.4.7 (server busy), and 4.4.4 (message too large).

For instance, a 4.2.2 error means the recipient's inbox has hit its storage limit. The server says “try again later,” which is why it’s classified as temporary. A 4.4.7 error often appears during peak traffic or when a server is under maintenance.

Many soft bounces are resolved on retry. But if a soft bounce happens repeatedly — say, five times in a row — Mailgun may stop relaying to that address. That’s why tracking repeated soft bounces is just as important as tracking hard bounces.

The key takeaway: soft bounces are a signal. They suggest the address is valid but may be overloaded or misconfigured. Monitoring them helps you assess deliverability risks and avoid unnecessary list deletions. For real-time validation, real-time email verification can flag risky addresses before they cause issues.

For deeper insight, you can find definitions of DSN codes in RFC 3463, the standard that defines delivery status notifications. It explains all codes — including the nuances between 4xx and 5xx responses — in technical detail.

How to extract and structure DSN data from Mailgun

You can extract and structure DSN bounce data from Mailgun by using the Events API or Webhooks to pull real-time or historical DSN events. Filter records by status and type—focusing on 'bounce' with 'hard' or 'soft' type—and extract key fields like recipient, reason, status, and timestamp to build a clean dataset for analysis. This lets you distinguish permanent failures from temporary ones and act before deliverability suffers.

Step-by-step: Collect and parse DSN events

  1. Enable the Events API or set up a Webhook in your Mailgun dashboard to capture DSN events as they occur. These events include both delivery status and bounce notifications, and they’re essential for catching hard and soft bounces early. Mailgun logs every event with a standardized format, making it possible to automate analysis.
  2. Filter events by status and type. Focus on events where event is delivery or bounce, and type is either hard or soft. Hard bounces (status 5xx) indicate permanent failure—like invalid addresses or blocked domains. Soft bounces (status 4xx) suggest temporary issues, such as full inboxes or rate limits.
  3. Extract core metadata. Pull the recipient, reason, status, and timestamp from each event. The reason field often includes the exact SMTP error code or human-readable explanation (e.g., 550 5.1.1 User unknown). This data is raw and must be cleaned for consistency.
  4. Structure the data for analysis. Normalize the reason field by mapping common codes (e.g., 550, 450, 552) into descriptive categories. Use the timestamp to track bounce patterns over time—spikes in soft bounces may signal server or content issues.
  5. Build your dataset. Store the filtered and cleaned data in a structured format—CSV, JSON, or a database—for querying, trend reporting, and integration with your analytics stack. This dataset becomes the foundation of your DSN report analysis.

What to do with your bounce dataset

Once you have the data, use it to identify trends: recurring hard bounces from the same domain may point to outdated list sources. Frequent soft bounces from a single IP could indicate poor sender reputation or high message volume. Monitoring these patterns helps you proactively clean your list and improve inbox placement. For context, a RFC 3463 specifies how DSN status codes should be structured, and industry standards like those from Spamhaus help validate your interpretation of codes.

Consider using a tool like bulk email list cleaning to test lists before sending. It helps catch invalid addresses before they trigger bounces—reducing your reliance on post-send DSN analysis. For real-time validation, the real-time verification API can catch issues at the point of capture, not after delivery.

When Mailgun’s DSN reports show repeated hard bounces from the same address across multiple campaigns, that address is almost certainly invalid or non-existent. Persistent soft bounces—especially when they occur consistently across different sends—often point to a full mailbox, high spam filtering thresholds, or throttling by the receiving server. You can use these trends to proactively flag and remove problem addresses before they harm your sender reputation or inflate your bounce rate.

Hard bounces: signals of invalid or disconnected inboxes

Each hard bounce means the email address couldn't be delivered due to an unrecoverable reason—like a non-existent domain or a permanently disabled mailbox. If the same address generates hard bounces in three or more campaigns, it’s a clear sign the inbox no longer exists. You’re not just wasting sends—you’re risking your sender reputation with every failed delivery.

According to industry standards, a hard bounce rate above 2% across a campaign is a red alert. This is not just a delivery issue; it reflects poorly on your list hygiene and can trigger automatic filtering or blocking by providers like Gmail or Outlook. Use DSN reports to isolate and remove these addresses—before they drag down your deliverability.

Soft bounces: tracking persistent delivery issues

Soft bounces don’t mean the address is invalid, but they do mean delivery was temporarily blocked. Common causes include full mailboxes, message size restrictions, or aggressive spam filters. If an address soft-bounces repeatedly, it likely means the recipient’s inbox can’t handle more emails, or their server is applying strict delivery rules.

For instance, a mailbox over 100% of its quota will reject new messages unless the user deletes older ones. You can’t force the inbox to open, so the only option is to stop sending while the issue resolves—which means you’re still burning sends on dead ends. Tracking these patterns helps you identify not just bad addresses but entire domains that consistently trigger soft bounces.

Let’s say you notice soft bounces from domains like @gmx.com or @yahoo.com across five different sends. This could be a sign of broader delivery challenges. Use that insight to adjust your outreach strategy—either reducing volume to those domains or pausing them entirely until the trend changes.

For deeper insight and automated cleanup, consider using real-time list hygiene tools. With bulk email list cleaning, you can test your entire list against current delivery standards and catch invalid or high-risk addresses before sending. Real-time verification integrates directly with your send process to prevent bounces at the moment of delivery. Both help you maintain a list that’s not just clean—but resilient.

How email-verification tools prevent hard and soft bounces

You reduce hard and soft bounces in Mailgun 2026 by validating every email address before sending. Real-time verification catches invalid syntax, disposable domains, role accounts, and catch-all setups that would otherwise trigger delivery failures. This proactive step cuts wasted sends and improves sender reputation—key for consistent inbox placement.

Pre-send validation stops errors before they happen

Let’s be clear: no email list is perfect. Even with careful sourcing, you’ll find typos, outdated addresses, and placeholders. Before your Mailgun campaign goes live, run each address through a real-time verification tool. This checks for basic syntax (like missing @ or domain parts), and flags high-risk addresses like admin@, postmaster@, or no-reply@—common role accounts that rarely accept messages.

Disposable domains (like mailinator.com) are especially problematic. They often block inbound emails, trigger spam filters, or expire instantly. A good email-verification tool detects these domains by cross-referencing known patterns and provider lists. You can’t rely on sending to them—your sender reputation takes damage, and your deliverability drops.

Deep domain checks prevent hidden delivery risks

Email List Validation checks each address against 270+ domain-level policies—including whether a domain has a catch-all configuration. Catch-alls accept *any* email, which means an invalid address might still "deliver" silently. But that’s a soft bounce in disguise: the message is received, but it’s never read. This harms your engagement metrics and can hurt your sender reputation.

We also verify MX record validity, which confirms a domain can receive email. If the MX record is missing or misconfigured, the address is fundamentally unsendable. Our 98.9% accuracy means you can expect up to 85% fewer hard bounces on average compared to unverified lists. It’s not a guarantee—no tool is—but this level of precision consistently reduces failure rates across industries.

This isn’t about perfection. It’s about reducing friction. With real-time verification or bulk cleaning, you send to only addresses that are likely to receive and engage. For ongoing use, integrate the real-time API with your CRM or onboarding flow to catch invalid entries at the source. For large campaigns, clean your list before sending to avoid Mailgun’s bounce rate thresholds. These steps are industry-standard and supported by RFC 5321, the core email delivery specification.

Integrating Email List Validation with Mailgun for proactive hygiene

You can prevent hard and soft bounces in Mailgun by validating your list before upload, using real-time API checks to catch invalid addresses as they’re added, and automatically removing known bad or frequently bouncing addresses before your next send. This reduces list fatigue, improves sender reputation, and increases inbox placement over time.

Pre-upload validation with bulk checks

  1. Upload your list to Email List Validation’s bulk verification tool before sending via Mailgun. It checks every address for syntax errors, domain validity, and inbox existence—not just at the envelope level, but whether the mailbox is capable of receiving mail. This step removes 98.9% of invalid addresses upfront.
  2. Review the results: valid, invalid, catch-all, or risky addresses. Focus on invalid and risky entries—over 40% of bounces originate from addresses that were technically valid but non-receiving (e.g. auto-replies, role accounts, or closed inboxes).
  3. Export the clean list and import it into Mailgun. By filtering out non-functional addresses early, you avoid triggering hard bounces and reduce the burden on Mailgun’s delivery systems.

Real-time verification via webhook integration

  1. Use Email List Validation’s real-time verification API to validate every new subscriber address as it’s entered. Trigger the API call right after form submission or during signup workflows.
  2. Check the API response: if it returns “invalid” or “risky,” reject the address before storing it. If it returns “valid,” proceed with confirmation. This stops bad addresses from ever reaching Mailgun.
  3. Set up webhooks in your signup system to send new addresses to the API and receive responses within 100–300ms. This integrates directly with tools like HubSpot, Klaviyo, or your custom app.

When you combine pre-upload validation with live checks, you build a self-cleaning system. For example, if the same address fails multiple times in a short period, mark it as a known hard-bounce candidate and remove it from future campaigns. This is consistent with best practices from industry standards like RFC 6521, which defines bounce categorization and suggests sender-side filtering for persistent failures.

Leverage Mailgun’s webhook system to receive DSN reports and correlate them with your validation data. Over time, you’ll see fewer hard bounces and consistent soft bounce patterns—indicating you’ve filtered out the worst of the noise. This improves deliverability and protects your sender reputation, even when sending at scale.

Real-world benchmarks: what typical bounce rates look like

Healthy email campaigns maintain hard bounce rates under 0.5% per send. Consistently above 5% soft bounces signal list hygiene or infrastructure issues. Sustained hard bounce rates over 2% increase blacklisting risk and can reduce inbox placement by 30–60%—a clear red flag for deliverability health. You’re not just sending to inactive users; you’re sending to non-existent ones, which hurts sender reputation fast.

Hard bounces: when the recipient doesn’t exist

Hard bounces happen when an email address is invalid—either misspelled, permanently discontinued, or rejected by the recipient’s mail server. If your hard bounce rate exceeds 0.5% per send, your list likely contains outdated or poorly collected data. Over time, consistent high hard bounce rates hurt your sender reputation. According to industry standards, ISPs like Google and Microsoft treat sustained rates above 2% as a strong signal of poor list quality, often leading to filters or blocklist entries.

Soft bounces: temporary delivery failures

Soft bounces occur when a server accepts the message but can’t deliver it—common causes include a full inbox, server downtime, or message size limits. While occasional soft bounces are normal, rates above 5% per send mean something’s wrong. This could be due to overloaded sending infrastructure, outdated domains, or a list with too many temporary or sensitive recipients. High soft bounce rates correlate with lower long-term deliverability. Return Path’s deliverability guidelines note that sustained soft bounce spikes are among the top reasons for inbox placement failures.

If you're seeing consistent bounces—hard or soft—your list quality is under strain. Let’s be clear: you can’t fix deliverability with better copy or subject lines if your list is full of invalid or problematic addresses. The fix starts with verification. Use real-time validation to catch invalid addresses before they ever hit your send queue. Clean your entire list in bulk or integrate verification into your signup workflow to stop bad data at the source. Even small improvements in list hygiene can prevent drops in inbox placement and reduce sending costs.

How to use Email List Validation to clean a Mailgun bounce report

You can clean a Mailgun bounce report by exporting hard and soft bounce DSN events, uploading them to Email List Validation’s bulk verification tool, and filtering results by invalid, catch-all, risky, or hard bounce verdicts. This removes dead or high-risk addresses before your next send, reducing delivery failures and protecting sender reputation.

Export DSN bounce data from Mailgun

Log into your Mailgun dashboard and navigate to the “Events” tab. Filter for DSN events with “hard” or “soft” bounce status. Select a date range matching your recent campaigns and export the full list as a CSV. This ensures you’re reviewing only the most relevant delivery failures.

  1. Download your bounce report: Use Mailgun’s built-in export to save the raw list of bounced addresses. This is your input for cleaning.
  2. Copy the email list: Open the CSV in a spreadsheet or text editor. Copy only the email addresses, one per line, to avoid parsing issues.
  3. Paste into Email List Validation’s bulk endpoint: Go to Email List Validation’s bulk verification tool. Paste your list and start the check. The system validates each address in real time against SMTP, DNS, and mailbox rules.
  4. Review the verdicts: After processing, filter the results by “invalid,” “catch-all,” “risky,” or “hard bounce.” These are the addresses that are either permanently undeliverable or likely to cause spam complaints.
  5. Remove or flag problematic entries: Delete invalid and hard bounce entries from your list. Flag risky or catch-all addresses for suppression or manual review — they may still deliver but have higher failure rates.

Why this works

Mailgun’s DSN reports distinguish between temporary (soft) and permanent (hard) failures. But soft bounces often obscure longer-term issues like outdated addresses or overwhelmed inboxes. Email List Validation detects these deeper problems by checking for valid mailboxes, open relay configurations, and domain behavior — not just bounce codes.

For example, a catch-all address may accept a message but doesn’t route it to the intended user, leading to undeliverable emails and higher spam complaints. According to RFC 5321, catch-alls are a known source of deliverability erosion, especially in large-scale sends. Cleaning them early prevents reputation damage.

Once cleaned, you’ll see a measurable drop in future bounce rates, especially with high-volume senders. This isn't just about removing failures — it's about preserving sender authority. Use this process monthly or after each campaign to build a reliable contact database.

The limits of DSN analysis and when to supplement with verification

DSN reports in Mailgun tell you when an email was rejected, but they miss critical issues like role accounts (e.g. admin@, sales@), disposable domains, or silent rejections where no DSN is sent at all. These hidden problems contribute significantly to hard and soft bounces—even if your SMTP connection succeeds. You need pre-send verification to catch them early, reducing total bounce rates by up to 90% before messages even leave your server.

What DSNs can't see

DSN reports only record explicit rejection responses. They don’t detect whether an email is a role account, which often leads to high bounce rates despite the address being technically valid. According to RFC 6522, role accounts are designed to be general-purpose and frequently lack proper handling on recipient mail servers. Even if the address exists, messages may be dropped silently or quarantined without a delivery status notification.

Some domains also reject messages without sending a DSN—especially those using greylisting or temporary filters. These are common in hosted services and enterprise environments. You’ll never know they happened unless you verify addresses in advance.

Supplementing DSNs with pre-send validation

Let’s be clear: DSN analysis is reactive. It tells you after the fact that something failed. But it can’t prevent the failure. That’s where tools like Email List Validation come in. It checks for role accounts, disposable domains, and invalid syntax—before you send. This catches errors that DSNs never see.

Using real-time verification or bulk list cleaning can reduce your overall bounce rate by up to 90%, according to user case studies from enterprise clients using the service. With a 98.9% accuracy rate, it identifies and flags issues like catch-all domains, inactive addresses, and malformed syntax that would otherwise slip through.

For example, an address like [email protected] may pass SMTP connectivity checks but fail at delivery. Verification catches these before they hit the inbox, improving sender reputation and long-term deliverability. You can run a bulk cleanup of your list using email list validation or integrate real-time checks via the API for ongoing cleanup.

Conclusion: treat DSN reports as a diagnostic, not a solution

DSN reports from Mailgun reveal where delivery failed — hard bounces indicate invalid addresses, soft bounces signal temporary issues. But they don’t stop failures before they happen.

Use DSN analysis to understand delivery outcomes, but rely on real-time email verification to prevent bad addresses from entering your list in the first place. Verification catches invalid, disposable, and role-based addresses before they hurt sender reputation or trigger blocklists.

A clean list reduces hard and soft bounces, improves inbox placement, and strengthens sender reputation over time. Prevention beats diagnosis.

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 error in a Mailgun DSN report mean?

A 550 error means the recipient email address is rejected by the destination server, usually due to a non-existent or blocked mailbox. It’s a hard bounce and should be removed from your list.

Can soft bounces cause sender reputation issues?

Repeated soft bounces over time can harm sender reputation, especially if they suggest high spam scores or full inboxes. Persistent soft bounces should be investigated and addressed.

How often should I analyze DSN reports?

Analyze DSN reports after every major send campaign to identify persistent bounces. Use automation to track trends over time.

What is a catch-all email address, and why does it affect deliverability?

A catch-all address accepts all emails sent to a domain, even invalid ones. It can appear as valid in checks but may increase spam perception and hurt deliverability if overused.

Can I use Email List Validation to fix broken Mailgun integrations?

No. Email List Validation doesn’t fix SMTP or integration issues. It helps clean your list before the send, which reduces the load on your integration pipeline.

Why does my hard bounce rate stay high even after list cleaning?

High hard bounce rates may stem from outdated data sources, poor capture forms, or third-party list purchases. Real-time validation helps catch new invalid entries at ingestion.

Are disposable email domains safe to send to?

No. Disposable domains often trigger spam filters and are linked to high bounce rates. Email List Validation detects and flags them during verification.

How does Email List Validation compare to Mailgun’s built-in bounce handling?

Mailgun tracks bounces but doesn’t prevent them. Email List Validation stops invalid addresses before sending, reducing bounce rates and protecting sender reputation.

Can I automate DSN analysis with Email List Validation?

Yes. Use the Email List Validation API with Mailgun’s events API to automatically verify addresses that trigger bounce events.

What is the best practice for maintaining a healthy Mailgun list?

Verify every new address before adding it, remove all hard bounces immediately, and clean soft bounce entries after three failed attempts.

How accurate is Email List Validation’s detection of hard bounces?

Our engine detects invalid addresses with 98.9% accuracy using real-time checks, including syntax, domain policy, and mailbox status verification.

Does Email List Validation integrate with Mailgun?

Yes. You can integrate Email List Validation with Mailgun using webhooks and API calls for real-time verification of new subscribers.