== My view on accepting bounces and replies to your email This topic came up in comments on [[yesterday's entry about Yahoo Groups not accepting bounces of their email YahooGroupsSpamII]], so I'm going to make it an entry and elaborate on my views here. My views on accepting bounces are pretty simple: if you send out email using anything but the SMTP null sender, you have a responsibility to accept bounces of it back. In fact, not just bounces alone; bounces and replies, because some of the recipients will have out-of-office and other auto-responders (whether implemented on the server or in their IMAP client, and yes I've seen both). Since you have to accept replies and replies may be in arbitrary formats and come from random addresses that are the result of forwarding and other things, in practice you must accept all email to any address that has recently sent out email. (We can have a rousing debate over whether you 'must' accept email merely to the _MAIL FROM_ of outgoing email or also to the _From:_ or _Reply-To:_ of the email. My pragmatic answer is that there exist systems that will send replies to the latter, so yes, you should.) By 'accept' I mean merely that your SMTP receiver must accept the message during a SMTP transaction. Technically you may immediately drop the message in _/dev/null_ if you want; your obligation is merely to insure that the mail systems generating bounces and replies are not stuck with either the bounces (as they would be if you don't accept or reject them outright) or bounces-of-replies (as they would be if you rejected replies). (Throwing bounces away locally is a sign of a spam operation, since you're ignoring delivery failures and will therefor continue grimly trying to email addresses that are simply not working. But that's different from [[irritating other mail system operators FriendlyNoreplies]].) You have no obligation to accept bounces, replies, or even general email from the null sender address to addresses that have not sent email, or that do not send email that will ever leave your domain. In particular, people with sender address verification systems that assume that all addresses will accept email from the null sender are [[doing it wrong CallbackCheckDont]]. (Not that sender address verification is a good idea in general, but there are more worse and less worse ways of implementing it.) Since [[modern mailing list systems individualize the _MAIL FROM_ of every outgoing message to every recipient https://en.wikipedia.org/wiki/Variable_envelope_return_path]], they have a built in way of knowing what local email addresses have recently sent email and thus should accept it back. Or they can just accept everything if they're going to throw it all away anyways. When receiving replies I feel that it is legitimate to respect the [[DMARC policies UnderstandingDMARC]] of the _MAIL FROM_, even if this causes you to reject some incoming messages. I will wave my hands about rejecting things at SMTP time that are properly identified as spam. In the specific case of mailing list software and [[VERP https://en.wikipedia.org/wiki/Variable_envelope_return_path]], I think you should accept everything since it's just going to automation. On a purely pragmatic level, I've written before about [[how not accepting bounces make you look bad BrokenBounceAddresses]] and how [[broken bounce addresses don't fool anyone any more BrokenBouncesNotFoolingUs]]. The pragmatics are pretty clear: if a random new sending domain doesn't accept bounces and (auto-)replies to their email, the odds are very good that they're a spammer. It's not a sure thing, but it is a strong smell and you can expect people to react to it. (And it's not as if it's particularly difficult or expensive to set up a simple email server that just throws away everything it receives. I even have something that can do this [[sitting around https://github.com/siebenmann/sinksmtp/]] and I'm pretty sure you could run a high-capacity install of it on the smallest, cheapest instance AWS offers.)