VERP Email Addresses: Correlate Bounces Without Trusting the Message Body
MAIL FROM:<b+v1.ABEiM0RVZneImaq7zN3u_w.5h5rTWu6u-cgzEsT@bounces.example.com>
RCPT TO:<alice@example.net>
That variable envelope sender is VERP: a different reverse-path for each delivery, so a later bounce can be mapped back to one delivery record without trusting the bounce subject or quoted message. The safe version encodes an opaque delivery ID, authenticates it, and still parses the delivery status notification before changing suppression state.
VERP solves correlation. It does not prove that a mailbox exists, that a message reached an inbox, or that every failure is permanent.
Follow one delivery from MAIL FROM to the bounce handler
The address after MAIL FROM is the SMTP reverse-path. It can differ from the visible From: address. When final delivery happens, that value is normally recorded as Return-Path:. RFC 5321 says its primary purpose is to receive non-delivery reports.
If the receiving system accepts the message and later cannot deliver it, the notification is sent to that reverse-path. The notification itself uses an empty reverse-path to avoid bounce loops:
MAIL FROM:<>
RCPT TO:<b+v1.ABEiM0RVZneImaq7zN3u_w.5h5rTWu6u-cgzEsT@bounces.example.com>
The local part now gives the bounce handler a delivery ID. The handler can look up the intended recipient, campaign, provider, send time, and current suppression state in its own database.
That lookup is only half the job. A standards-shaped delivery status notification has per-recipient fields such as Final-Recipient, Action, and Status. RFC 3464 defines actions including failed, delayed, delivered, relayed, and expanded. A delayed notification is not a hard bounce, and a correlated bounce is not automatically a reason to suppress an address.
I keep those jobs separate: VERP identifies the delivery; the DSN supplies failure evidence; the bounce classifier interprets that evidence; the suppression model applies policy.
Encode a delivery ID, not the recipient address
The familiar VERP example embeds a transformed recipient address in the envelope sender, such as bounces+alice=example.net@example.com. It works, but it also copies personal data into SMTP logs, message traces, and any system that stores the Return-Path.
I prefer an opaque 16-byte delivery ID plus a truncated HMAC tag:
b+v1.<22-char-delivery-id>.<16-char-tag>@bounces.example.com
The ID is a database key, not a reversible email address. The HMAC stops someone from inventing valid-looking bounce recipients and using your handler as an oracle for arbitrary IDs. A dedicated bounce domain also makes routing explicit and keeps these addresses away from human mailboxes.
Length matters. RFC 5321 requires the local part to fit within 64 octets and the complete reverse-path within 256 octets. The format above uses 44 ASCII octets before the @, leaving room without relying on an oversized address.
There is a current standards caveat. An individual Internet-Draft published on August 3, 2026 describes a VERP SMTP extension and a recipient-embedding format. As of November 5, 2026, it has no formal standing in the IETF standards process. The implementation here does not require that extension. It sets a normal per-delivery reverse-path using existing SMTP behavior.
A compact Node.js VERP codec
This codec expects a base64url delivery ID made from 16 random bytes and a secret of at least 32 random bytes. Keep the secret in a secret manager, version it for rotation, and never derive it from an API key or user password.
import { createHmac, timingSafeEqual } from 'node:crypto';
const VERSION = 'v1';
const PREFIX = `b+${VERSION}.`;
function tagFor(deliveryId, secret) {
return createHmac('sha256', secret)
.update(`${VERSION}:${deliveryId}`, 'utf8')
.digest()
.subarray(0, 12)
.toString('base64url');
}
export function buildVerpAddress({ deliveryId, bounceDomain, secret }) {
if (!/^[A-Za-z0-9_-]{22}$/.test(deliveryId)) {
throw new TypeError('deliveryId must be a 16-byte base64url value');
}
const localPart = `${PREFIX}${deliveryId}.${tagFor(deliveryId, secret)}`;
if (Buffer.byteLength(localPart, 'ascii') > 64) {
throw new RangeError('VERP local-part exceeds 64 octets');
}
return `${localPart}@${bounceDomain}`;
}
export function parseVerpAddress({ address, bounceDomain, secret }) {
const suffix = `@${bounceDomain}`;
if (!address.endsWith(suffix)) return null;
const localPart = address.slice(0, -suffix.length);
if (!localPart.startsWith(PREFIX)) return null;
const [deliveryId, suppliedTag, extra] =
localPart.slice(PREFIX.length).split('.');
if (extra !== undefined || !/^[A-Za-z0-9_-]{22}$/.test(deliveryId)) {
return null;
}
const expected = Buffer.from(tagFor(deliveryId, secret), 'base64url');
const supplied = Buffer.from(suppliedTag ?? '', 'base64url');
if (supplied.length !== expected.length) return null;
if (!timingSafeEqual(supplied, expected)) return null;
return { deliveryId };
}
Node documents timingSafeEqual() as suitable for comparing HMAC digests, while warning that the surrounding code must also avoid timing leaks. The length check is required because the function throws when buffers differ in length.
For this article, I ran the codec with a fixed test secret and delivery ID, then tested a valid address, a modified tag, and the wrong bounce domain. The valid case decoded to ABEiM0RVZneImaq7zN3u_w; both modified cases returned null.
What should happen after the address decodes?
Decoding should produce an event for one immutable delivery record. It should not directly delete a subscriber or mark a mailbox invalid.
- Reject an invalid domain, prefix, version, length, or HMAC before any database lookup.
- Load the delivery by opaque ID and confirm the bounce recipient belongs to the configured bounce domain.
- Parse the DSN when it is present. Store the action, enhanced status code, diagnostic text, reporting MTA, and raw event reference separately from the delivery row.
- Apply an idempotent transition. Replaying the same bounce must not increment counters or repeat a suppression action.
Some bounces are not RFC 3464 DSNs, and some automatic replies are not bounces at all. Preserve an unclassified outcome instead of turning unfamiliar content into a permanent failure. The same restraint applies to email verification: an unknown result is evidence of uncertainty, not evidence that a mailbox is bad.
If bounce events arrive through HTTP as well as SMTP, keep the transport checks too. Signature verification, timestamp windows, and replay protection still belong in the webhook receiver. A valid VERP token does not authenticate an HTTP request.
Do you need VERP when your provider already returns message IDs?
Often, no. If one provider gives every recipient a stable delivery ID and sends authenticated, idempotent bounce events, adding another identifier may only create work.
VERP becomes useful when you run your own MTA, send through multiple providers, receive DSNs over SMTP, or need one correlation key that survives provider-specific payloads. It also helps when a bounce omits the original message body, which RFC 3464 permits.
The strongest objection is that the bounce address itself can be forged. That is true, which is why the tag is authenticated and the DSN is treated as evidence rather than an instruction. A valid token only identifies an existing delivery. Your parser and policy still decide whether the event means delayed, failed, or unclassified.
In the opening trace, the decoded ID locates one delivery. If the accompanying DSN says Action: failed with a permanent recipient status such as 5.1.1, the suppression workflow can act once and record why. If the action is delayed, the same address stays out of permanent suppression while the sender continues its retry policy.
That separation is the point: VERP answers “which delivery?” The DSN answers “what happened?” Your application decides “what changes now?”
Sources: RFC 5321: Simple Mail Transfer Protocol; RFC 3461: SMTP Service Extension for DSNs; RFC 3464: Delivery Status Notifications; draft-nurpmeso-smtp-verp-03 (work in progress); Node.js crypto documentation.