Skip to content
AdminKit

Email bounces and backscatter explained: why misconfigured mail servers amplify abuse

A bounce is a notification a mail server generates when it can't deliver a message, sent to the original envelope sender per RFC 5321. Backscatter happens when a spammer forges that sender as an innocent third party's address, so bounces from a misconfigured server land on someone who never sent anything. AdminKit's MX lookup shows who handles a domain's mail.

By AdminKit team, Netbase JSC · Updated

Key takeaways

  • A bounce goes to the envelope sender (MAIL FROM), and SMTP never checked that address. Forge it, and the bounces go to whoever owns it.
  • Backscatter is created by servers that accept mail first and find the problem later. A server that refuses bad mail during the SMTP conversation never sends a bounce at all.
  • Once a server replies 250 to the message data, RFC 5321 makes it responsible for delivering the message or sending a failure notice. So the place to refuse mail is before that point.
  • Autoresponders and sender callouts misfire in the same way. Backscatterer.org lists servers that do any of the three.
  • If you are on the receiving end, the forgery happened elsewhere. You can filter the flood, and SPF and DMARC make your domain harder to forge, but nothing in your DNS stops it outright.

What is a bounce supposed to do?

Mail delivery is not guaranteed to succeed on the first attempt — a mailbox may not exist, may be full, or may reject a message outright — and RFC 5321 expects whichever server detects that failure to tell the sender. RFC 3464 standardizes the format of that notification as a Delivery Status Notification (DSN), a machine-readable report of what failed and why, attached to a human-readable explanation. The specific failure reason a DSN reports is typically expressed as an enhanced status code (for example, 5.1.1, unknown recipient) drawn from IANA’s SMTP Enhanced Status Codes registry, which standardizes what those codes mean across mail servers. This is ordinary, necessary plumbing: without bounces, a sender would have no way to learn that a message silently failed to reach anyone.

One detail in RFC 5321 matters more than it first appears: Section 4.5.5 requires non-delivery notifications to carry a null reverse-path — an empty MAIL FROM:<> — specifically so a bounce can never itself bounce and start an infinite loop of notifications about notifications. This single rule is why a bounce message, when it does go somewhere wrong, dead-ends rather than cascading.

The machine-readable part of a bounce is a short block of fields. This one is illustrative, built on the field layout of the examples in RFC 3464 with documentation names:

Reporting-MTA: dns; mx1.example.net
Final-Recipient: rfc822; nobody@example.net
Action: failed
Status: 5.1.1
Diagnostic-Code: smtp; 550 5.1.1 <nobody@example.net>: Recipient address rejected
FieldWhat it tells you
Reporting-MTAThe server that wrote this report
Final-RecipientThe address delivery was attempted to
Actionfailed, delayed, delivered, relayed or expanded
StatusThe enhanced status code. The first digit is the class: 2 success, 4 temporary, 5 permanent
Diagnostic-CodeThe reply the remote server actually sent, when there was one

RFC 3463 names the codes you see most in bounces: X.1.1 “Bad destination mailbox address”, X.2.2 “Mailbox full”, X.4.7 “Delivery time expired” and X.7.1 “Delivery not authorized, message refused”. AdminKit’s SMTP status code decoder explains any reply or bounce line you paste, in your browser.

Where does backscatter come from?

A bounce is addressed to the original message’s envelope sender — the address given in the SMTP MAIL FROM command — not necessarily the “From:” header a reader sees in their inbox. A legitimate bulk sender can use that same envelope-sender field on purpose, encoding the original recipient into a unique return path via VERP (Variable Envelope Return Path), so a bounce maps back to exactly the subscriber that caused it instead of a single shared address. SMTP as specified by RFC 5321 places no requirement that the envelope sender be authenticated or even real at the moment a server accepts a message; a spammer can put any address at all in MAIL FROM, including an address belonging to someone who has nothing to do with the spam run.

Backscatter is what happens next: a spam campaign goes out to a large list of addresses, many invalid, all carrying the same forged envelope sender, and every receiving server that accepted a message before realizing the recipient didn’t exist now has to send a bounce — to the forged address, not to the real spammer. One spam run can generate thousands of bounces, all converging on a single innocent victim whose address was simply picked at random as the forged sender. This pattern is well-documented enough to have its own dedicated tracking project: Backscatterer.org lists mail servers observed generating exactly this kind of misdirected bounce traffic, independently of any single mail provider’s own abuse reporting. RFC 3834, which sets out recommendations for automatic email responses generally, exists precisely because automated replies sent to a forged or unchecked address are a long-standing, documented source of unwanted and sometimes overwhelming mail traffic.

Why does rejecting during SMTP prevent backscatter?

RFC 5321 §6.1 draws the line. When a receiving server answers the end of the message data with 250 OK, “it is accepting responsibility for delivering or relaying the message”. If delivery then fails, the server “MUST formulate and mail a notification message”, sent to the envelope sender. A server that accepts first has no way out later: it must notify someone, and that someone is whoever the forger named.

A server that refuses during the conversation never takes on that duty. The failure goes back to the connecting client, which for spam is the spammer’s own software. This illustrative exchange shows a server refusing an unknown recipient at the RCPT TO step:

S: 220 mx1.example.net ESMTP
C: EHLO sender.example.org
S: 250 mx1.example.net
C: MAIL FROM:<victim@example.com>
S: 250 2.1.0 Ok
C: RCPT TO:<nobody@example.net>
S: 550 5.1.1 <nobody@example.net>: Recipient address rejected
C: QUIT

No message was accepted, so no bounce goes to victim@example.com. The same comparison, side by side:

Reject during SMTPAccept, then bounce
When the problem is foundBefore the server accepts the messageAfter 250 OK to the message data
Who learns about the failureThe connecting clientThe address in MAIL FROM
If MAIL FROM was forgedThe spammer’s software gets the errorAn innocent third party gets a bounce
Backscatter riskNoneHigh

RFC 5321 accepts that some late failures can’t be avoided, for example when a relay has no access to the final recipient list. The aim is to make them rare, not to pretend they never happen.

Which server settings turn a mail server into a backscatter source?

The deciding factor is when a mail server checks whether a recipient actually exists. A server that validates the recipient during the live SMTP conversation — before accepting the message — can simply refuse it on the spot; the failure happens in real time, between the two servers, and no bounce is ever generated because nothing was accepted in the first place. A server that accepts every message up front and only checks mailbox validity afterward has already committed to notifying somebody, and that somebody is whoever the envelope sender claimed to be. This “accept first, bounce later” pattern is almost entirely what turns ordinary bounce-handling into a backscatter source, and it is avoidable: rejecting unknown recipients during the SMTP transaction, a standard and widely supported mail server setting, removes the server from the backscatter problem entirely. A domain-wide catch-all address is one common way a server ends up accepting mail for recipients that don’t really exist in the first place, setting up exactly this failure mode.

Recipient checks are the biggest source, but not the only one:

BehaviourWhy it misfiresWhat to do instead
Accepting mail for any recipient, then bouncing unknown onesEvery invalid address in a spam run turns into a bounce to the forged senderCheck recipients at RCPT TO and reject unknown ones with a 550
A backup MX or filtering relay with no list of valid recipientsIt has to accept everything, then bounce what the main server refusesGive the relay the same recipient list, or have it check with the main server during SMTP
Spam or authentication filtering after acceptance, with a bounce for failuresThe failure notice goes to an address that was probably forgedReject during SMTP, before the end of the message data
Autoresponders (out-of-office, ticket receipts) answering everythingThe reply goes to the forged senderFollow RFC 3834: skip Auto-Submitted mail and empty return paths
Sender callouts (probing the sender’s server to see if MAIL FROM exists)The probe hits the forged sender’s serverUse SPF and DMARC results instead of probing

RFC 7208 makes the authentication case explicit. It says SPF checks belong at the time of the MAIL command, and that “generating non-delivery notifications to forged identities that have failed the authorization check often constitutes backscatter”. Operators “are strongly advised to avoid such practices”. The DMARC specification, RFC 9989 §7.2, discusses a third choice: accepting and then silently discarding. That avoids backscatter but means the server reports success it never delivered, which makes problems hard to trace.

What should you do if you’re receiving backscatter?

If your domain or address is suddenly flooded with “Undelivered Mail Returned to Sender” notifications for messages you never sent, your address was almost certainly forged as the envelope sender in someone else’s spam run — there’s no configuration fix on your end for a forgery that happened on infrastructure you don’t control, only filtering the resulting flood. A correctly deployed SPF/DKIM/DMARC setup, covered in our SPF, DKIM and DMARC explained guide and the rest of AdminKit’s email authentication cluster, makes your domain harder to use as a forged envelope sender in the first place, since a receiving server that checks SPF/DMARC before accepting a message is less likely to accept — and later bounce — mail that falsely claims to be from you. If your own forwarding setup is involved, see our guide on why email forwarding breaks SPF for a related way envelope-sender handling causes authentication failures.

A few practical steps while it lasts:

  1. Confirm the bounces are not about your own mail. A genuine bounce quotes the headers of a message you sent. Compare the returned Message-ID and the sending server in the quoted Received lines with your own outgoing mail. Pasting the quoted headers into AdminKit’s email header analyzer lays out the delivery chain in order. If you run Postfix, its Backscatter Howto shows how to use those quoted headers, such as a Received: line with a HELO name your own servers never announce, to recognize and block bounces of forged mail.
  2. Filter, don’t reply. Bounces arrive with an empty MAIL FROM:<>. If the targeted address never sends mail itself, every bounce to it is misdirected, so a rule can move them into a separate folder. Never send automatic replies to them.
  3. Make your own envelope senders recognisable. A sender that tags its own MAIL FROM addresses, as VERP does for mailing lists, can tell its real bounces from forged ones. RFC 7208 points to Bounce Address Tag Validation (BATV), an Internet-Draft, as one way to sign the local part.
  4. Publish strict SPF and DMARC. They won’t stop every forgery, but receivers that check them during SMTP can refuse forged mail instead of accepting it and bouncing it to you later.

How do you know if your own server is the source?

Backscatterer.org’s listing policy is simple: any IP that sends misdirected bounces, misdirected autoresponders or sender callouts is listed for the next four weeks. A listing there is a strong hint that your server accepts mail it later refuses. Work through the table in the previous section against your mail server’s settings, starting with recipient checks on every host listed in your MX records. Use AdminKit’s MX lookup to list those hosts. A backup MX you forgot about can hide accept-then-bounce behaviour. Backscatterer.org offers its list to other mail operators over DNS for scoring or rejecting bounces, autoresponders and callouts from listed servers, so like any DNSBL listing it can affect mail your server sends.

Backscatter, blacklisting and forwarding-related authentication failures are three different symptoms of the same underlying SMTP trust gap — the protocol never required the envelope sender to be verified. See why is my IP blacklisted for what happens when a server’s outbound reputation is damaged by abuse like this, and use AdminKit’s MX lookup tool to confirm which servers are actually authoritative for handling a domain’s mail before investigating further.

This guide is general information, not a security audit of your specific network — see our disclaimer for what AdminKit's guidance does and does not commit to.

Frequently asked questions

What is a bounce message, technically?

When a mail server can't deliver a message — the recipient address doesn't exist, the mailbox is full, content was rejected — RFC 5321 expects the server that detected the failure to notify the sender, and RFC 3464 defines the standard machine-readable format for that notification, a Delivery Status Notification (DSN). Critically, RFC 5321 Section 4.5.5 requires non-delivery notifications to be sent with a 'null reverse-path' (`MAIL FROM:<>`), specifically so that a bounce about a bounce can never trigger an infinite notification loop.

Where does the bounce actually get sent, and why does that matter?

A bounce is sent to the envelope sender of the original message — the address in the SMTP `MAIL FROM` command, which is not necessarily the same as the human-readable 'From:' header a mail client displays. Spam and phishing routinely forge the envelope sender to an address the attacker doesn't control, because SMTP has no built-in requirement that the envelope sender be authentic at the time a message is accepted; whoever's address was forged is who receives the bounce if the message later fails to deliver.

What exactly is backscatter?

Backscatter is the flood of bounce messages that lands on a forged envelope-sender address after a spam run, generated not by the spammer but by the receiving mail servers that accepted the spam and only discovered a delivery problem afterward. A single spam campaign sent to thousands of addresses, many of them invalid, with one forged sender, can generate thousands of bounce notifications — all addressed to a victim who never sent a single message. RFC 3834's recommendations for automatic email responses exist specifically because automated replies and notifications sent to a forged or inappropriate address are a long-documented source of unwanted mail.

Why do some mail servers generate backscatter and others don't?

The difference is when the receiving server checks whether a recipient address is valid. A server that rejects an unknown recipient during the SMTP conversation itself — before accepting the message — never generates a bounce at all, because the sending server (or spam tool) gets the failure immediately and the receiving server never took responsibility for the message. A server that accepts every message first and only checks recipient validity afterward has no choice but to generate a bounce to whatever envelope sender was given, and if that sender was forged, the bounce becomes backscatter. Rejecting at SMTP time, rather than accepting-then-bouncing, is the single configuration choice that eliminates the problem at its source.

How do I know if my domain is a backscatter victim, or a source?

As a victim, a sudden flood of bounce messages ('Undelivered Mail Returned to Sender', 'Mailbox not found') for messages you never sent is the signature — it usually means your domain or a specific address was forged as the envelope sender in a spam run, and there's no fix on your end beyond filtering, since the forgery happened upstream. As a potential source, check whether your own mail server rejects unknown recipients during the SMTP transaction (the correct behavior) or accepts everything and bounces later — the latter configuration makes your server a backscatter generator for anyone whose address gets forged in spam sent toward your domain. A correctly configured SPF/DMARC policy, covered in our SPF/DKIM/DMARC guide, also makes it harder for your own domain to be used as a forged envelope sender in the first place.

Should an out-of-office reply count as backscatter?

It can. An autoresponder that answers spam sends its reply to the forged sender, just like a misdirected bounce. RFC 3834 asks responders not to reply to messages that carry an Auto-Submitted header (other than 'no'), never to reply when the return address is empty, and to send vacation notices only when the recipient's address is explicitly in To, Cc or Bcc. Backscatterer.org lists misdirected autoresponders alongside misdirected bounces.

Want AdminKit to watch this for you?

Free checks tell you the state today. Protective DNS and monitoring tell you when it changes.

Huy Nguyen (David), Founder and CEO of Netbase JSC

Talk to an expert

Huy Nguyen (David), Founder & CEO, Netbase JSC

Ask whether this fix applies to your setup, or get a second pair of eyes on your DNS and mail records.