Mailbox Gone or Policy Block? Teach Your AI to Read Bounces
Updated November 19, 2026
8 min read
When a customer reports bounces, have your agent match each one to the saved verification result for the same address, then read what the receiving server actually said. If the server says the mailbox doesn't exist, the fix is a contact update. If it refused your sender, the fix is in your sending setup, and no amount of verification will change it.
I'm a Customer Success Manager at Emailable, and we regularly see this message in support chat: "I verified my list, and it still bounced." Sometimes the customer is right to be worried. More often, the bounce report holds two different problems that look identical in a dashboard total.
An agent like Claude Code or Codex is well suited to separating them. It can read hundreds of bounce messages, line each one up against the result saved for that address, and sort them before anyone deletes contacts or blames the list. Here's how I'd teach it to do that, using two real support cases, anonymized.
Start With the Evidence, Not the Bounce Count
A bounce total tells you how much went wrong, not what. Before your agent draws any conclusion, it needs three things for each bounced address:
- The full rejection from your sending platform: the status code, the text that came with it, and when it happened.
- The Emailable result saved for that exact address: its state, reason, and score.
- When that result was produced, and when the message was sent.
Match on the exact address and nothing looser. A result for jane.doe@ says nothing about jdoe@ at the same company. And count each address once, not each event: when a platform retries a message, the same address can appear in the export several times.
Timing matters as much as the address. A result from the morning of the send and one from three months earlier describe different moments, and lists decay in between. That's also why our guarantee covers only addresses emailed within 24 hours of verification, among other conditions.
There's one practical catch. Emailable's results don't carry a timestamp for each address. So save the results when you verify, and record the date with them. The Emailable CLI can write a batch's results to a file with emailable batch get <id> --output results.csv.
Case 1: The Mailbox Is Gone
When the receiving server says the mailbox doesn't exist, the problem is the address, so the fix is a contact update. The clearest sign is a 5.1.1 status code. In the official registry of these codes, it means the part before the @ is invalid. Gmail's version reads: "The email account that you tried to reach does not exist."
What your agent recommends next depends on the saved result:
- Saved as Undeliverable: the address should never have been sent to. Fix the step that should have filtered it out, not just the contact.
- Saved as Deliverable, verified weeks before the send: the mailbox most likely closed in between. Update or remove the contact, and verify closer to the send next time.
- Saved as Deliverable, and emailed within 24 hours of verification: flag it for Emailable support right away. It may qualify under the guarantee, and support needs to hear about it within 72 hours.
Here's what that looked like in one real report. A customer sent us 88 bounces. Among them were an "account does not exist" from a university on Google's mail service, and a "user unknown" passed back by an organization's mail relay. When we re-checked those addresses, they came back Undeliverable, matching what the servers had said. Two more were test addresses on the customer's own domain that didn't belong on the list at all.
None of those bounces pointed to the sending setup. They pointed to contacts that needed updating.
Case 2: The Server Refused the Sender
When the receiving server refuses your sender, the address may be perfectly fine, and the fix is in your sending setup. These rejections usually carry a 5.7.x code. In the registry, 5.7.1 means the sender isn't authorized to send to the destination, often because of filtering. Related codes name specific failures, like a failed SPF check (5.7.23) or several failed authentication checks (5.7.26), which is the code Gmail uses for unauthenticated mail. Microsoft's 5.7.515 and Yahoo's 554 5.7.9 play similar roles.
Not every 5.7.x points to authentication, though. Some reflect content filtering, reputation, or the recipient organization's own policy, so have your agent quote the full response rather than assume broken SPF.
The second real case looked very different. A customer verified a list, sent their first campaign, and watched 13% of it hard-bounce until their sending platform paused the campaign. They assumed the verification was wrong.
The bounce report said otherwise. About 92% of the bounces were blocks: Microsoft rejecting the messages as spam, and Gmail refusing mail from the sender. They arrived in large batches within seconds of each other, which is what a blocked sender looks like. Only about 0.5% of the bounces were truly invalid addresses, and a re-check showed most of the list was still Deliverable. The customer was also sending from a brand-new IP address.
No amount of re-verification would have fixed that. The right next step was a review of the sending setup: authentication, the new IP's warm-up, and how much volume they started with. Our guarantee draws the same line, since it excludes bounces caused by sender reputation or misconfiguration.
When the Message Doesn't Match the Meaning
Most bounces sort cleanly into those two cases. The rest are where an agent earns its keep, because the words in a bounce don't always mean what they seem.
- "Access denied" is really a missing mailbox. Microsoft 365 can answer with "550 5.4.1 Recipient address rejected: Access denied." It reads like a policy block, but Microsoft documents it as its directory rejecting an invalid recipient. That's a Case 1 bounce, despite the wording. The exact text matters, though: "550 5.4.1 Relay Access Denied" is a different problem, a server refusing to relay mail for that domain.
- "No such user" in a cluster. In the same 88-bounce report from Case 1, 70 bounces came from one university domain, all saying "No such user here," in tight bursts. A re-check still found most of those addresses Deliverable. That doesn't look like 70 people leaving at once, so instead of deleting them, we held them back and opened an internal investigation.
- Temporary failures recorded as permanent. In Case 2, about 8% of the bounces were temporary deferrals from two internet providers, which the sending platform logged as hard bounces. Treated as dead, they would have been good contacts lost.
So give your agent one rule for anything that doesn't fit: when the code, the text, the timing, and the saved result disagree, it holds the contact and asks a person. A wrong deletion costs more than a short delay.
Put the Decision in One Table
Here's the whole decision in one place. The actions are policy choices you can adjust; they don't change what the bounce or the result means.
Bounce evidence | Saved result | Next action |
|---|---|---|
5.1.1, or "does not exist" | Undeliverable | Fix the step that should have filtered it out |
5.1.1, or "does not exist" | Deliverable, verified well before the send | Update or remove the contact; verify closer to the send next time |
5.1.1, or "does not exist" | Deliverable, emailed within 24 hours of verification | Flag it for Emailable support within 72 hours |
5.7.x, "blocked," "spam," or an authentication failure | Any | Review the sending setup; keep the contact |
4.x.x, or a deferral | Any | Let the platform retry; don't suppress |
Code, text, timing, and result disagree | Any | Hold the contact and ask a person |
Any bounce | No saved result | Mark it unverified, and verify only with approval |
Turn It Into a Bounce-Reading Skill
A skill is a set of written instructions your agent follows for a specific task. The Emailable CLI offers to install one the first time you run it, and it teaches agents how to verify addresses and read the results. A bounce-reading skill is one you write on top of it, for your own team.
- Trigger it when a bounce report arrives, or within a day of each campaign, before anyone removes contacts. That timing keeps any guarantee claim inside the 72-hour window.
- Require the inputs: the bounce export with each address's full response and time, the saved Emailable results with their verification date, and the send date. If one is missing, the report says so instead of guessing.
- Apply the decisions: match on the exact address, classify each bounce from its code and text together, and use the table above. Trust a 4.x.x code over a "hard bounce" label. Look for patterns too, like many rejections at one domain or provider within minutes.
- Return a report anyone can follow: one row per bounced address with its saved result, its rejection and the recommended action, plus a short summary by category and a list of anything held for review. When the summary leaves your team, share counts, not addresses.
- Keep it read-only: no deleting contacts, no new verifications without approval, and no sending or reading. Because it only reads saved results, it doesn't use credits.
- Test it on a case you already know: run it on a past bounce report with a known answer, and check that a cluster like the university one above gets held rather than deleted.
With that in place, the request is simple:
Match this bounce report to our saved verification results, sort each bounce into a missing mailbox, a sender problem, a temporary failure, or unclear, and don't change any contacts.
One honest limit: the skill can only be as good as the saved results. If nobody saved them when the list was verified, it can tell you what the servers said, but not what verification found.
Ask Which Kind Before Asking How Many
When a bounce report lands in our support chat, the first question I ask isn't how many bounced. It's which kind. A missing mailbox and a refused sender can produce the same number on a dashboard, but they have opposite fixes, and treating one like the other costs you either good contacts or more blocked sends.
That's the habit worth teaching your agent. Save your results when you verify, match every bounce to them, and let the server's own words decide the next step. When the evidence disagrees, stop and ask.