No último post eu estava do lado de quem recebe uma decisão de spam e não conseguia ver quase nada. Quatro verificações de autenticação passaram, a mensagem foi para o Spam mesmo assim, e o motivo ficou com o Gmail. Do lado de quem envia, os provedores contam algumas coisas, num formato que um programa consegue ler. Se alguma coisa no seu sistema muda por causa disso, aí depende de você.
Trabalhei nisso quando construí uma plataforma SMTP que mandava milhões de e-mails por mês. Aplicações, CRMs e ferramentas de marketing mandavam mensagens para uma API escrita em Go, e a API passava para um pool de MTAs, os servidores de e-mail que abrem a conexão SMTP com o Gmail, o Outlook ou o Yahoo. Quando um provedor dizia não, a resposta voltava como um e-mail. Ou um bounce, o aviso de que uma mensagem não pôde ser entregue, ou uma reclamação, o relatório que alguns provedores mandam quando um usuário deles aperta “denunciar spam”.
Nenhuma das peças foi difícil de construir. O que deu trabalho de pensar foi onde a consulta fica. Uma lista de supressão que alguém abre depois de uma semana ruim conta o que deu errado. A mesma lista lida pela API em toda requisição impede a plataforma de repetir, e esse lugar é a parte do desenho que eu ainda defenderia.
De onde vêm os avisos #
A maioria das recusas acontece durante a entrega, “about 95% of all returns” segundo as Sender Best Common Practices de 2015 do M3AAWG, o grupo onde provedores de e-mail e remetentes escrevem a prática que compartilham. O resto vem depois, de servidores que aceitaram a mensagem antes. SMTP é uma conversa, e depois que o MTA diz quem é o destinatário, o servidor do outro lado responde com um código. Um 550 quer dizer que a mensagem foi recusada. O MTA fica sabendo na hora, a API que recebeu a mensagem do cliente não, e o jeito de o MTA avisar alguém é escrever um aviso de falha para o remetente de envelope. Esse é o endereço do MAIL FROM no começo da conversa, separado do From: que o leitor vê. A RFC 5321 diz que o propósito principal dele “is to designate the address to which messages indicating non-delivery or other mail system failures are to be sent”, e o servidor final copia ele para o cabeçalho Return-Path.
Reclamações vêm de uma pessoa. Quando alguém no Yahoo ou no Outlook.com aperta o botão de spam, o provedor pode mandar um relatório por um feedback loop, um programa em que quem envia se inscreve com cada provedor. O Yahoo amarra o programa ao domínio que assina com DKIM e a Microsoft aos IPs de envio, então a plataforma precisava ser quem assina ou a dona dos IPs. O Gmail não manda isso por mensagem.
Então toda mensagem saía com um remetente de envelope num domínio cujo registro MX apontava para o Amazon SES. Os bounces voltavam para lá pelo protocolo, e os feedback loops estavam cadastrados para mandar para lá também. Esse domínio também é o que o SPF verifica, então o registro SPF dele ainda precisa listar os MTAs que enviam.
Lendo um bounce #
Um bounce padrão é um e-mail multipart/report (RFC 6522) com três partes. Texto para uma pessoa, uma parte message/delivery-status da RFC 3464 que um programa consegue ler e, quando o servidor inclui, a mensagem original ou os cabeçalhos dela.
Content-Type: message/delivery-status
Reporting-MTA: dns; mx.example.net
Final-Recipient: rfc822; someone@example.net
Action: failed
Status: 5.1.1
Diagnostic-Code: smtp; 550 5.1.1 The email account that you tried to reach does not exist
Action: failed quer dizer que o MTA desistiu, delayed que ele ainda está tentando. Status é um código de status estendido da RFC 3463, em que o primeiro número é a classe. 2 é sucesso, 4 uma falha temporária, 5 permanente. Diagnostic-Code são as palavras do próprio servidor, e as práticas do M3AAWG avisam que os códigos numéricos “do not clearly state whether or not the address should be removed”.
O classificador precisa decidir uma coisa mais estreita que hard ou soft, se o aviso fala do endereço ou de quem enviou.
| Status | Significado | Do que fala |
|---|---|---|
5.1.1 | Bad destination mailbox address | Do endereço |
4.2.2, 5.2.2 | Mailbox full | Do endereço, por enquanto |
5.7.1 | Delivery not authorized, message refused | De quem enviou ou da mensagem |
O Gmail manda uma caixa que não existe como um 5.1.1 limpo, “550 5.1.1 The email account that you tried to reach does not exist”. A Microsoft responde com “550 5.4.1 Recipient address rejected: Access denied” e o Yahoo com “554 delivery error: dd This user doesn’t have a yahoo.com account”, sem código estendido nenhum. Um classificador que lê só o Status manda os dois para revisão, e casar o texto provedor por provedor vem depois disso. Toda mensagem mandada para um 5.1.1 de verdade depois do primeiro aviso é um bounce que quem envia escolheu produzir. As diretrizes de remetente do Gmail dizem “Automatically unsubscribe recipients who have multiple bounced messages.”
Um 5.7.1 também é permanente, e suprimir por causa dele é o erro que eu mais queria que alguém construindo isso evitasse. A RFC 3463 diz que o remetente “is not authorized to send to the destination”, o que “can be the result of per-host or per-recipient filtering”. O filtro pode estar olhando o IP, o domínio ou o conteúdo, e nada disso diz se o endereço existe. Suprimir por ele deixa o problema de quem envia onde estava e ainda cria uma lista de destinatários bons para quem ninguém escreve de novo.
Falhas temporárias ganham novas tentativas do MTA primeiro. Quando ele desiste, o aviso diz Action: failed e ainda pode trazer o status 4 da última tentativa. Um 4.2.1 ou 4.2.2 é uma caixa desativada ou cheia e conta para o endereço. Um 4.7.x quer dizer que o servidor deixou quem envia para depois, que é como um provedor segura um IP em que ainda não confia. Um MTA que desiste depois de dias de 4.7.0 escreve um aviso de falha para cada destinatário naquele provedor, e um contador que pega esses avisos suprime um provedor inteiro de endereços bons. Esses vão para revisão. Alguns servidores mandam caixa cheia como 5.2.2, e no Gmail o 5.2.2 quer dizer “out of storage space and inactive”. Continua sendo caixa cheia, então entra na contagem.
A plataforma contava todo soft bounce por endereço e suprimia num limite. Hoje eu contaria só os códigos de caixa, pelo motivo de cima. O M3AAWG sugere tirar um endereço que “bounces consecutively at least two times over two weeks or more”. O Mailchimp permite 7 soft bounces para um endereço sem atividade e 15 para um com atividade, e uma entrega no meio zera a contagem. O esboço de baixo não zera, e é a primeira coisa que eu acrescentaria.
A decisão em Go, escrita para este post e não tirada da plataforma. Ela recebe o Action e o Status de um destinatário do aviso.
// Package dsn decides what a delivery status notification asks a sender to do.
package dsn
import (
"errors"
"fmt"
"strings"
)
// Verdict is what the feedback pipeline does with one recipient of a notice.
type Verdict int
const (
// Review keeps the address off the suppression list until a person reads the notice.
Review Verdict = iota
// Ignore means the notice reports no final failure.
Ignore
// CountTransient adds one transient failure to the address's count.
CountTransient
// Suppress stops future sends to the address for the client that sent the message.
Suppress
)
// String returns the name of v, or Verdict(n) for a value outside the set.
func (v Verdict) String() string {
names := [...]string{"Review", "Ignore", "CountTransient", "Suppress"}
if v >= 0 && int(v) < len(names) {
return names[v]
}
return fmt.Sprintf("Verdict(%d)", int(v))
}
// ErrStatus is wrapped by the error Classify returns when the Status field
// is not an enhanced status code as defined in RFC 3463.
var ErrStatus = errors.New("not an enhanced status code")
type status struct{ class, subject, detail int }
// Classify returns the Verdict for one per-recipient group of a
// message/delivery-status part (RFC 3464), given its Action and Status
// field values. Surrounding spaces are ignored, the action is matched
// without regard to case, and anything from the first parenthesis on is
// dropped from the status, where RFC 3464 allows a comment.
//
// Only a failed recipient can be counted or suppressed. A mailbox that
// does not exist (5.1.1) or whose domain publishes a null MX (5.1.10) is
// Suppress. A disabled or full mailbox (4.2.1, 4.2.2, and 5.2.2 from
// servers that send a full mailbox as permanent) is CountTransient. Other
// transient codes describe the route or the sender, not the address, and
// are Review with every other failed status. A delayed, delivered, relayed
// or expanded recipient with a valid status is Ignore, and any other action
// is Review. A malformed status returns Review and an error wrapping
// ErrStatus.
func Classify(action, statusField string) (Verdict, error) {
s, ok := parseStatus(statusField)
if !ok {
return Review, fmt.Errorf("dsn: status %q: %w", statusField, ErrStatus)
}
switch strings.ToLower(strings.TrimSpace(action)) {
case "delayed", "delivered", "relayed", "expanded":
return Ignore, nil
case "failed":
switch {
case s == status{5, 1, 1}, s == status{5, 1, 10}:
return Suppress, nil
case s == status{4, 2, 1}, s == status{4, 2, 2}, s == status{5, 2, 2}:
return CountTransient, nil
}
}
return Review, nil
}
func parseStatus(field string) (status, bool) {
code, _, _ := strings.Cut(field, "(")
parts := strings.Split(strings.TrimSpace(code), ".")
if len(parts) != 3 {
return status{}, false
}
var n [3]int
for i, p := range parts {
if p == "" || len(p) > 3 || (len(p) > 1 && p[0] == '0') {
return status{}, false
}
for _, c := range []byte(p) {
if c < '0' || c > '9' {
return status{}, false
}
n[i] = n[i]*10 + int(c-'0')
}
}
if n[0] != 2 && n[0] != 4 && n[0] != 5 {
return status{}, false
}
return status{n[0], n[1], n[2]}, true
}
Testei contra cada linha da tabela, um conjunto de códigos malformados e um alvo de fuzz, e passa em go vet, go test -race e 30 segundos de fuzz no Go 1.27.
O que o classificador não reconhece volta como Review e fica fora da lista até alguém olhar. Um status quebrado cai ali também, com um erro. A RFC 3464 diz que cada campo “MUST be expressed without leading zero digits”, e um parser que lê 5.01.1 como 5.1.1 suprimiria um endereço por uma leitura errada. Uma supressão que faltou custa mais um bounce. Uma errada custa uma pessoa que nunca mais recebe nada daquele remetente, e ninguém fica sabendo.
Reclamações e o id da mensagem #
Uma reclamação usa o Abuse Reporting Format da RFC 5965, o mesmo formato multipart/report com uma parte message/feedback-report no meio. Ela não precisa de classificação. Alguém disse que não queria a mensagem, e a plataforma parava de mandar para essa pessoa os e-mails daquele cliente.
Ligar qualquer um dos dois avisos a uma mensagem pede mais que o Final-Recipient. Encaminhamentos e aliases mudam o endereço, alguns provedores de feedback removem ele, e o aviso não diz qual cliente mandou a mensagem.
Por isso toda mensagem levava um cabeçalho da própria plataforma com o id da mensagem, vamos chamar de X-Message-Ref. A RFC 6449 recomenda a mesma coisa. A Lambda lia o id da terceira parte, e com ele a plataforma sabia o cliente e o endereço exato. Num bounce essa terceira parte é opcional, e sem ela só sobra o Final-Recipient. O VERP evita isso escrevendo o destinatário no próprio remetente de envelope. Esta plataforma guardava o id num cabeçalho.
Uma lista por cliente #
Uma reclamação sobre a newsletter de um cliente diz algo sobre aquela newsletter e aquela pessoa. Não diz nada sobre a recuperação de senha de outra empresa na mesma plataforma. A RFC 6449 diz assim, “Suppressing the address across an entire ESP is likely too broad.” O custo é que uma caixa morta está morta para todo mundo, e cada cliente descobria isso com um bounce próprio. Compartilhar 5.1.1 entre clientes tiraria esse custo e deixaria os dados ruins de um cliente chegarem nos outros. A gente ficou com a lista por cliente.
A consulta no caminho de envio #
Antes de aceitar uma mensagem, a API consultava cada destinatário para aquele cliente. Um destinatário na lista nunca ganhava entrada na fila nem conexão com um MTA. A API era interna, então ela recusava a requisição, dizia que o destinatário estava suprimido e deixava quem chamou decidir.
Quando a consulta falhava, a API não enviava. Isso amarra o envio ao DynamoDB estar no ar, e fui eu que escolhi assim. Uma mensagem segurada pode sair depois. Uma mensagem entregue para um endereço que a gente já sabia que devia evitar não tem como voltar.
A consulta não para uma mensagem que já está numa fila. A API lê a lista quando aceita, o MTA entrega depois, e com o padrão do Postfix, maximal_queue_lifetime em cinco dias, essa brecha pode durar quase uma semana para um destinatário cujo servidor continua adiando.
O caminho de retorno #
O domínio do Return-Path era uma identidade verificada no SES com um MX 10 inbound-smtp.<region>.amazonaws.com, como o recebimento de e-mail do SES pede. Uma receipt rule guardava cada mensagem no S3, um objeto por mensagem. Antes de qualquer regra rodar, o SES descarta e-mail de “addresses on the block lists of either Spamhaus or SES”, e a documentação diz que há “no logs that show which IP addresses are being blocked”. Um aviso vindo de um MTA listado some sem deixar rastro.
Guardar primeiro mantinha o aviso cru, então uma mudança no classificador podia rodar de novo sobre avisos antigos. O SES tem uma lista de supressão própria, mas ela age sobre o e-mail que o SES envia. Aqui o SES só recebia, então a lista que importava tinha que ser a nossa.
A Lambda lê cada objeto novo, percorre as partes MIME, classifica e escreve. O S3 entrega notificações de evento “at least once”. A Lambda, chamada desse jeito, tenta um evento que falhou mais duas vezes por padrão e descarta ele depois de três falhas ou seis horas, a não ser que uma dead-letter queue ou um destino em caso de falha guarde o evento.
Duplicatas não fazem mal para uma supressão, porque escrever a mesma chave duas vezes deixa uma entrada só. Para um contador fazem, porque uma duplicata conta a mesma falha duas vezes e adianta uma supressão. O contador precisa lembrar quais avisos já contou e fazer isso na mesma escrita do incremento, com uma atualização condicional que registra a chave do objeto do S3 ou com uma transação. Um evento perdido é uma supressão que nunca acontece. O objeto continua no S3, e um S3 Inventory do bucket cruzado com um export da tabela de vez em quando acha o que escapou.
O que os provedores pedem hoje #
Desde fevereiro de 2024, o Gmail e o Yahoo pedem a quem envia em grande volume mais ou menos esse ciclo e um pouco mais. O Gmail quer a taxa de spam do Postmaster Tools “below 0.10% and avoid ever reaching a spam rate of 0.30% or higher”. As boas práticas do Yahoo pedem abaixo de 0,3%. A Microsoft anunciou em abril de 2025 que domínios mandando mais de 5.000 mensagens por dia para o Outlook.com precisam passar em SPF, DKIM e DMARC, com rejeições que trazem 5.7.515, uma recusa 5.7 sobre quem envia que um classificador não pode ler como endereço morto.
As reclamações do Gmail não voltam por mensagem. O feedback loop do Gmail mostra taxas de spam agregadas por Feedback-ID num painel. No Gmail esse ciclo aprende só com bounces. O sinal por pessoa que o Gmail repassa é o descadastro com um clique da RFC 8058, um POST HTTPS que chega fora do caminho de e-mail do diagrama.
O que isto não cobre #
Não tem nenhum número da plataforma aqui. Nem taxa de bounce antes e depois, nem quantidade de endereços suprimidos, nem latência da consulta, nem o limite de falhas temporárias. É a descrição de um desenho, sem medir o efeito dele. O classificador lê só o Status, então endereços mortos na Microsoft e no Yahoo esperam uma pessoa ou um casamento de texto que este post não escreve. O contador não zera. Reclamações do Gmail nunca chegam numa lista por endereço. Descadastros e o caminho de volta para quem quer receber e-mail de novo depois de ser suprimido ficam de fora, e a brecha entre aceitar e entregar continua aberta.
Se você roda um ciclo parecido e trata o 5.7.1 ou os códigos de adiamento de outro jeito, eu queria saber o que você viu.