Microsoft Safe Links está dando de baja a tus suscriptores sin que hagan clic
Si tu página de baja da de baja al abrirse, los escáneres del correo corporativo vacían tu lista. Cómo hacerlo bien en Next.js 16 con Resend.
Este blog es de CREA.MBA, un boilerplate de Next.js con auth, pagos y panel de admin ya montados. Ver qué incluye
Un suscriptor trabaja en una empresa con Microsoft 365. Le llega tu newsletter, no la abre, y al día siguiente ya no está en tu lista. En tu panel aparece como baja voluntaria. Él no ha hecho nada.
Lo más probable es que tu enlace de baja lo haya «pulsado» un robot. Si la página de /unsubscribe da de baja en cuanto se abre, cualquier cosa que siga enlaces puede dar de baja a tus suscriptores: el filtro de correo de su empresa, el antivirus o un navegador que precarga páginas.
La página de baja de CREA.MBA funcionaba así hasta la versión 2.1.4 del boilerplate, del 2 de noviembre, que es donde lo arreglamos. Este artículo cuenta qué cambiamos y cómo dejarlo bien en Next.js 16 con Resend.
Quién abre tus enlaces antes que la persona
Microsoft Defender for Office 365 incluye Safe Links, que viene activado por defecto en las organizaciones con licencia (la política Built-in protection lo aplica a todos los buzones que no tengan otra). Su documentación dice dos cosas que importan aquí:
- Mientras Safe Links esté activo, las URLs se analizan antes de entregar el mensaje, estén reescritas o no.
- Las URLs que no tienen una reputación válida se «detonan» de forma asíncrona en segundo plano. Es decir, se visitan.
Un enlace de baja con un token único por suscriptor es justo el tipo de URL sin reputación previa. Microsoft no es el único: otros filtros de correo corporativo y algunos clientes que generan vistas previas hacen lo mismo. Y no te avisan, porque desde tu servidor una de esas visitas es un GET como cualquier otro.
El propio estándar del one-click lo reconoce. El RFC 8058, de enero de 2017, explica que existe precisamente porque el software de correo a veces visita las URLs de las cabeceras y da de baja sin querer, y el remitente no tiene forma de distinguir esa visita de la de una persona.
La regla: un GET nunca da de baja
La solución no tiene misterio: abrir la página no cambia nada. La baja se hace con un POST, y ese POST solo lo dispara una acción deliberada.
Hay dos caminos para llegar a ese POST, y conviene tener los dos:
- El enlace del pie del email. Lleva a una página que pregunta «¿Darte de baja de la newsletter de X?» y tiene un botón. El botón hace el
POST. Un escáner que abra el enlace solo ve la pregunta. - La baja en un clic del cliente de correo (RFC 8058). Gmail y otros clientes muestran un «Cancelar suscripción» junto al remitente. Al pulsarlo, es el propio cliente el que hace un
POSTa una URL que tú pones en las cabeceras del mensaje. Aquí no hay confirmación: el RFC dice que la baja tiene que funcionar sin pasar por ninguna página, porque el cliente de correo no va a leer una.
El segundo camino no lo tocan los escáneres porque no es un enlace que se siga: es una cabecera que el cliente usa para mandar un POST, y el RFC le prohíbe hacerlo sin el consentimiento de la persona.
Y no es opcional si envías en volumen: la documentación de Resend recuerda que Gmail y Yahoo exigen el one-click a quien manda más de 5.000 mensajes al día a sus buzones, y que la baja hay que aplicarla en un máximo de 48 horas.
Lo que pide el RFC 8058
Antes del código, las reglas, porque son pocas y estrictas:
List-Unsubscribetiene que llevar una URL HTTPS, entre<y>.List-Unsubscribe-Posttiene que llevar exactamenteList-Unsubscribe=One-Click.- El mensaje tiene que ir firmado con DKIM, y la firma tiene que cubrir esas dos cabeceras.
- El
POSTllega sin cookies ni autenticación. Todo lo que necesites para saber a quién dar de baja tiene que ir en la propia URL. - La respuesta no puede ser una redirección.
La consecuencia práctica: la URL de la cabecera lleva el email y un token firmado. Si solo llevara el email, cualquiera podría dar de baja a otro con un curl.
Paso 1: el token
Un HMAC del email con un secreto del servidor. No hace falta guardar nada en la base de datos.
// lib/unsubscribe.ts
import { createHmac, timingSafeEqual } from 'node:crypto';
const secret = process.env.UNSUBSCRIBE_SECRET ?? '';
export function unsubscribeToken(email: string): string {
return createHmac('sha256', secret).update(email).digest('hex');
}
export function verifyUnsubscribeToken(email: string, token: string): boolean {
if (!secret) return false; // sin secreto, cualquiera podría calcular el HMAC
const expected = unsubscribeToken(email);
if (expected.length !== token.length) return false;
return timingSafeEqual(Buffer.from(expected), Buffer.from(token));
}
export function unsubscribeLinks(email: string, locale: string) {
const base = process.env.NEXT_PUBLIC_SITE_URL;
const query = new URLSearchParams({ email, token: unsubscribeToken(email) });
return {
pageUrl: `${base}/${locale}/unsubscribe?${query}`,
oneClickUrl: `${base}/api/unsubscribe?${query}`,
};
}Dos detalles. La comparación con timingSafeEqual evita que se pueda adivinar el token midiendo tiempos. Y el if (!secret) no es paranoia: un HMAC con la clave vacía lo puede calcular cualquiera, así que sin secreto no se acepta ningún token. El boilerplate tuvo justo ese agujero hasta la 2.1.3.
Paso 2: las cabeceras al enviar con Resend
resend.emails.send() acepta un objeto headers con cabeceras propias:
import { Resend } from 'resend';
import { unsubscribeLinks } from '@/lib/unsubscribe';
const resend = new Resend(process.env.RESEND_API_KEY);
export async function sendNewsletter(email: string, locale: string) {
const { pageUrl, oneClickUrl } = unsubscribeLinks(email, locale);
return resend.emails.send({
from: 'TuApp ',
to: email,
subject: 'Lo nuevo de este mes',
react: NewsletterEmail({ unsubscribeUrl: pageUrl }),
headers: {
'List-Unsubscribe': `<${oneClickUrl}>`,
'List-Unsubscribe-Post': 'List-Unsubscribe=One-Click',
},
});
}Fíjate en que son dos URLs distintas. El pie del email apunta a la página (pageUrl), que pregunta. La cabecera apunta al endpoint (oneClickUrl), que solo acepta POST. Si pones la misma URL en los dos sitios, o la página da de baja con el GET (y vuelves al problema) o el one-click recibe una página HTML.
Los ángulos <…> no son decoración: el RFC 2369, que define List-Unsubscribe, pone las URLs entre ángulos.
Paso 3: el endpoint del one-click
Un route handler que solo exporta POST:
// app/api/unsubscribe/route.ts
import { NextRequest } from 'next/server';
import { verifyUnsubscribeToken } from '@/lib/unsubscribe';
import { unsubscribe } from '@/lib/newsletter';
export async function POST(request: NextRequest) {
const email = request.nextUrl.searchParams.get('email');
const token = request.nextUrl.searchParams.get('token');
if (!email || !token || !verifyUnsubscribeToken(email, token)) {
return new Response(null, { status: 403 });
}
await unsubscribe(email);
return new Response(null, { status: 200 });
}Como no hay GET, Next.js responde 405 Method Not Allowed a cualquiera que abra esa URL. Un escáner que la visite no consigue nada.
El email y el token se leen de la query, no del cuerpo. El cliente de correo manda en el cuerpo List-Unsubscribe=One-Click y nada más, así que todo lo demás tiene que ir en la URL.
Esto tiene que ser un route handler y no una Server Action. Las Server Actions de Next.js solo se pueden invocar desde la propia app: usan su propio protocolo y comparan la cabecera Origin con Host. Gmail no va a mandar ninguna de las dos cosas. Por lo mismo, si tienes un proxy.ts (el antiguo middleware) que valida el origen de los POST, exime esta ruta: aquí la prueba es el token. En el boilerplate tuvimos que hacerlo, porque en producción el proxy rechazaba con 403 los POST del one-click.
Paso 4: la página que pregunta
La página verifica el token al renderizar, pero no escribe nada. La baja va en una Server Action ligada al formulario:
// app/[locale]/unsubscribe/page.tsx
import { verifyUnsubscribeToken } from '@/lib/unsubscribe';
import { confirmUnsubscribe } from './actions';
type Props = {
params: Promise<{ locale: string }>;
searchParams: Promise<{ email?: string; token?: string; done?: string }>;
};
export default async function UnsubscribePage({ params, searchParams }: Props) {
const { locale } = await params;
const { email, token, done } = await searchParams;
if (done) return <p>Listo. No te llegarán más emails de la newsletter.</p>;
if (!email || !token || !verifyUnsubscribeToken(email, token)) {
return <p>Este enlace no es válido.</p>;
}
const confirm = confirmUnsubscribe.bind(null, locale, email, token);
return (
<h1>¿Darte de baja de la newsletter?</h1>
<p>Dejarás de recibir emails en {email}.</p>
Confirmar la baja
);
}Si tienes cacheComponents activado, como el boilerplate, añade un loading.tsx en esa carpeta: la página lee searchParams y Next exige un límite de ``.
// app/[locale]/unsubscribe/actions.ts
'use server';
import { redirect } from 'next/navigation';
import { verifyUnsubscribeToken } from '@/lib/unsubscribe';
import { unsubscribe } from '@/lib/newsletter';
export async function confirmUnsubscribe(locale: string, email: string, token: string) {
if (!verifyUnsubscribeToken(email, token)) return;
await unsubscribe(email);
redirect(`/${locale}/unsubscribe?done=1`);
}Tres cosas que se ven fáciles de saltar:
- El token se verifica otra vez en la acción. La documentación de Next.js insiste en ello: las Server Functions se pueden llamar con un
POSTdirecto, no solo desde tu interfaz. Que la página lo haya comprobado no te protege. binden vez de inputs ocultos. Según la doc, funciona en Server Components y con mejora progresiva: el botón da de baja aunque el navegador no tenga JavaScript.- Nada de efectos al renderizar. La guía de seguridad de Next.js 16 lo pone como ejemplo de lo que no hay que hacer: una mutación como efecto secundario del render. Una página de baja que da de baja al cargar es eso mismo.
¿Puede un escáner pulsar el botón? Los que siguen enlaces hacen GET, no rellenan formularios. Algún sandbox más agresivo podría hacerlo, y por eso la acción no se dispara sola al cargar, ni siquiera con JavaScript. Es la misma línea que traza el RFC: lo automático no da de baja; lo da de baja una persona que pulsa algo.
Cómo comprobarlo
curl -icontra tu URL de one-click tiene que devolver405. Con-X POST, un200.- Abre el enlace del pie en una ventana privada y recarga varias veces: el suscriptor tiene que seguir dado de alta hasta que pulses el botón.
- En Gmail, abre el mensaje con Mostrar original y busca la cabecera
DKIM-Signature. Su campoh=lista las cabeceras firmadas, y ahí tienen que aparecerList-UnsubscribeyList-Unsubscribe-Post. Si no están, el RFC no se cumple aunque las cabeceras lleguen.
Lo que trae resuelto el boilerplate
En CREA.MBA esto está hecho desde la 2.1.4: el token HMAC, la página con botón, el endpoint de one-click exento de la validación de origen del proxy y las cabeceras en el email de bienvenida de la newsletter, todo saliendo de un único buildUnsubscribeLinks(). El endpoint, además, limita los intentos fallidos a 10 por hora y por IP, pero nunca bloquea un token válido: los proveedores de correo mandan todos sus one-click desde pocas IPs compartidas, y un límite por IP acabaría rechazando bajas reales. Lleva tests para las tres cosas: que abrir la página no da de baja, que el botón sí, y que el POST del cliente de correo funciona sin confirmación.
Si ya tienes una página de baja en tu proyecto, haz la prueba hoy: ábrela con un enlace válido y mira si el suscriptor sigue en la lista. ¿Lo sigue?
¿Te gustó este artículo?
Suscríbete para más tutoriales y tips sobre crear productos con IA