Rate limiting en Next.js 16: proxy.ts, Redis y la IP que de verdad es del cliente
Limitar peticiones en Next.js 16 sin Vercel: dónde ponerlo, por qué el contador en memoria se queda corto y cómo leer la IP real detrás de un proxy.
Este blog es de CREA.MBA, un boilerplate de Next.js con auth, pagos y panel de admin ya montados. Ver qué incluye
Un formulario de login sin límite de peticiones acepta tantos intentos de contraseña como alguien quiera mandar. Un endpoint de registro sin límite acaba lleno de cuentas falsas. Y una ruta que llama a un modelo de IA puede convertir un script de cuatro líneas en una factura.
El rate limiting en Next.js se suele explicar con Upstash y Vercel. Aquí lo montamos para una app que corre en un servidor propio (Docker, Coolify, un VPS), que es donde aparecen los problemas interesantes: el contador que vive en memoria, los reinicios en cada despliegue y la cabecera X-Forwarded-For que cualquiera puede falsificar. El código sale del limitador que usa el boilerplate de CREA.MBA.
Dónde va: proxy.ts para lo general, el handler para lo concreto
En Next.js 16 el antiguo middleware.ts se llama proxy.ts, y una diferencia importa aquí: el proxy corre siempre en el runtime de Node.js. La documentación de la versión 16 lo deja claro: el runtime edge no está soportado en proxy y no se puede configurar. Si vienes de un middleware en Edge que solo podía hablar con Redis por HTTP, ahora puedes usar un cliente TCP normal como ioredis.
La división que mejor funciona tiene dos capas:
- En
proxy.ts, un límite grueso por tipo de ruta: autenticación, API, webhooks y páginas, cada uno con su cupo. - En el route handler o la server action, límites finos que dependen del negocio: tres envíos de un formulario por hora, cincuenta mensajes al asistente de IA por usuario y día.
El proxy ve todas las peticiones, pero no sabe nada de tu dominio. El handler sabe quién es el usuario y qué está haciendo, así que puede limitar por userId en lugar de por IP.
Cupos distintos para rutas distintas
Un único límite para toda la app no sirve. Una página de listado puede disparar decenas de prefetch de enlaces en un segundo, y un endpoint de login no debería aceptar ni una fracción de eso. Así reparte el boilerplate las peticiones en proxy.ts:
function getRateLimitConfig(request: NextRequest) {
const { pathname } = request.nextUrl;
if (SENSITIVE_AUTH_PREFIXES.some((p) => pathname.startsWith(p))) {
return { limit: RATE_LIMITS.AUTH_SENSITIVE, prefix: 'auth-sensitive' };
}
if (pathname.startsWith('/api/auth')) return { limit: RATE_LIMITS.AUTH_GENERAL, prefix: 'auth' };
if (pathname.startsWith('/api/webhooks'))
return { limit: RATE_LIMITS.WEBHOOK, prefix: 'webhook' };
if (pathname.startsWith('/api/')) return { limit: RATE_LIMITS.API, prefix: 'api' };
if (request.headers.get('sec-fetch-dest') === 'empty') {
return { limit: RATE_LIMITS.NAVIGATION, prefix: 'navigation' };
}
return { limit: RATE_LIMITS.PAGE, prefix: 'page' };
}Los valores por defecto son 10 intentos cada 15 minutos para login, registro y recuperación de contraseña; 100 peticiones por minuto para la API; 300 por minuto para cargas de página y 1.000 para navegaciones del cliente.
Ese último caso merece una explicación. Cuando el usuario navega dentro de la app, Next.js pide los datos de la siguiente ruta con un fetch (y lo mismo hace con los prefetch de los `` visibles). Si esas peticiones comparten cupo con las cargas de página, un listado con muchos enlaces agota el límite y empieza a devolver 429 a visitantes reales y a los rastreadores. Next.js quita sus cabeceras internas de RSC antes de que corra el proxy, así que el boilerplate las distingue por la cabecera que pone el navegador: una carga de página llega con Sec-Fetch-Dest: document y un fetch() con empty.
Y el matcher evita contar estáticos:
export const config = {
matcher: ['/((?!_next|.*\\..*).*)'],
};Sin matcher, la documentación de Next.js avisa de que el proxy se ejecuta también para _next/static, las imágenes optimizadas y todo lo que hay en public/.
El contador en memoria y sus dos problemas
La implementación más sencilla es un Map en memoria con las marcas de tiempo de cada cliente, una ventana deslizante:
async check(key: string, config: RateLimitConfig): Promise {
const now = Date.now();
const windowStart = now - config.windowSeconds * 1000;
const records = (requestStore.get(key) ?? []).filter((r) => r.timestamp > windowStart);
const success = records.length < config.maxRequests;
if (success) {
records.push({ timestamp: now });
requestStore.set(key, records);
}
// ...
}Fíjate en que la petición rechazada no se apunta. Si se apuntara, alguien que sigue intentando durante el bloqueo lo iría alargando sin fin.
Para un único servidor, esto funciona. Pero tiene dos limitaciones que en producción importan:
- Cada proceso cuenta lo suyo. Con dos instancias detrás de un balanceador, el límite efectivo es el doble del configurado.
- Cada despliegue lo pone a cero. Para alguien probando contraseñas, esperar al siguiente deploy es reiniciar el contador gratis.
Redis (o Valkey) para compartir el contador
La solución es mover el contador a un almacén compartido. Con un sorted set de Redis, la ventana deslizante se resuelve en un script Lua que se ejecuta de forma atómica en el servidor, así dos instancias no pueden leer el mismo valor antes de que ninguna lo escriba:
local now = tonumber(ARGV[1])
local window = tonumber(ARGV[2])
local limit = tonumber(ARGV[3])
local member = ARGV[4]
redis.call('ZREMRANGEBYSCORE', KEYS[1], '-inf', now - window)
local used = redis.call('ZCARD', KEYS[1])
local allowed = 0
if used < limit then
redis.call('ZADD', KEYS[1], now, member)
allowed = 1
end
redis.call('PEXPIRE', KEYS[1], window)
return { allowed, used }Con ioredis se registra como un comando propio con defineCommand, y cada comprobación es una única llamada. Un detalle: el member del sorted set tiene que ser único aunque dos peticiones lleguen en el mismo milisegundo, por eso el boilerplate lo compone con la marca de tiempo, un id de instancia y un contador.
En Coolify, un Redis o un Valkey se añade como recurso con dos clics y te da la REDIS_URL interna. Si la variable no existe, el limitador sigue usando la memoria, sin errores ni conexiones a ningún sitio.
Si Redis se cae, la app sigue
Un limitador que tumba la aplicación cuando su almacén falla es peor que no tenerlo. Tres decisiones del cliente de Redis del boilerplate van en esa línea:
{
lazyConnect: true,
enableOfflineQueue: false, // sin esto, las peticiones se quedan esperando
maxRetriesPerRequest: 1,
connectTimeout: 1000,
commandTimeout: 1000,
}Con enableOfflineQueue: false, un comando enviado con la conexión caída falla al momento en vez de quedarse en cola hasta que Redis vuelva (y la petición del usuario colgada con él). Cuando falla, la estrategia de Redis pasa a la de memoria durante unos segundos, deja una sola línea en el log y vuelve a probar. Mientras Redis esté caído, cada instancia cuenta lo suyo, que es mejor que no contar.
La IP del cliente: no te fíes del primer valor
Para limitar por IP hay que saber cuál es. Detrás de Traefik, nginx o Cloudflare, la IP de la conexión es la del proxy, y la del cliente viene en X-Forwarded-For. El código que circula por ahí hace esto:
// ❌ El primer valor lo pone el cliente
const ip = request.headers.get('x-forwarded-for')?.split(',')[0];El problema es que los proxies añaden su entrada al final de la cabecera. El primer valor es lo que mandó el cliente, y el cliente puede mandar lo que quiera. Basta con poner una IP inventada distinta en cada petición para tener un cupo nuevo cada vez, y el límite de login deja de servir.
La forma correcta es contar desde la derecha tantas entradas como proxies de confianza tengas delante:
function getClientIp(request: NextRequest): string {
const hops = Number(process.env.TRUSTED_PROXY_HOPS ?? 1);
const chain = (request.headers.get('x-forwarded-for') ?? '')
.split(',')
.map((entry) => entry.trim())
.filter(Boolean);
if (hops > 0 && chain.length > 0) {
const trusted = chain[Math.max(0, chain.length - hops)];
if (trusted) return trusted;
}
return request.headers.get('x-real-ip')?.trim() || chain.at(-1) || 'unknown';
}Con un solo Traefik delante (lo habitual en Coolify), TRUSTED_PROXY_HOPS=1 y la IP buena es la última. Si además pones Cloudflare delante, son dos saltos. Si te equivocas por exceso, vuelves a leer un valor que controla el cliente; si te equivocas por defecto, todos tus usuarios comparten la IP del proxy y se bloquean entre ellos. Merece la pena comprobarlo una vez con un endpoint que devuelva lo que ve.
Better Auth tiene el mismo dilema con su propio limitador, que viene activado en producción y guarda los contadores en memoria por defecto. Su documentación recomienda listar en advanced.ipAddress.ipAddressHeaders solo la cabecera que pone tu proxy, o declarar los trustedProxies si se añaden a X-Forwarded-For. Si usas los dos limitadores, configúralos con el mismo criterio. Lo vimos con más detalle en el setup de producción de Better Auth en Next.js 16.
Límites por usuario dentro del handler
Para las operaciones que cuestan dinero o que se pueden abusar con una cuenta válida, el límite va por usuario. El mismo limitador sirve; así quedaría en un endpoint de chat con IA:
export const POST = createAuthenticatedApiHandler({
schema: chatSchema,
handler: async (input, req, user) => {
await requireRateLimit(req, RATE_LIMITS.API, { userId: user.id, prefix: 'ai-chat' });
// ...
},
});requireRateLimit lanza un TooManyRequestsError que el envoltorio convierte en una respuesta 429. (El Retry-After viaja dentro del error; si quieres que llegue también como cabecera, como en el proxy, es una línea en el manejador de errores). La clave ai-chat:user: no depende de la IP, así que cambiar de red o usar una VPN no da un cupo nuevo.
Qué devolver cuando se pasa del límite
Un 429 con cabeceras que el cliente pueda usar:
return NextResponse.json(
{ success: false, error: { code: 'RATE_LIMIT_EXCEEDED', message: config.message } },
{
status: 429,
headers: {
'X-RateLimit-Limit': result.limit.toString(),
'X-RateLimit-Remaining': result.remaining.toString(),
'X-RateLimit-Reset': result.reset.toString(),
'Retry-After': Math.max(0, result.reset - Math.floor(Date.now() / 1000)).toString(),
},
},
);Retry-After en segundos le dice a un cliente bien hecho cuánto esperar. En el formulario de login, en vez de un error genérico, se puede enseñar «Demasiados intentos, vuelve a probar en unos minutos».
Cómo comprobar que funciona
Un bucle con curl contra el login basta para ver el 429:
for i in $(seq 1 12); do
curl -s -o /dev/null -w "%{http_code}\n" -X POST \
-H "Origin: http://localhost:3000" -H "Content-Type: application/json" \
-d '{"email":"a@b.com","password":"x"}' \
http://localhost:3000/api/auth/sign-in/email
doneLas primeras peticiones devuelven un error de credenciales y, a partir de la undécima, 429 (o antes, si salta el limitador de Better Auth, que en producción es más estricto con /sign-in/email). Para el caso de la IP falsificada, repite el bucle añadiendo -H "X-Forwarded-For: 1.2.3.$i" contra la app desplegada: el 429 tiene que llegar igual.
Lo que te llevas
- En Next.js 16, el proxy corre en Node.js; puedes usar
ioredissin rodeos. - Límites gruesos por tipo de ruta en
proxy.tsy límites por usuario en el handler. - El contador en memoria sirve con una instancia; con dos o con despliegues frecuentes, Redis o Valkey.
- La IP del cliente se lee desde la derecha de
X-Forwarded-For, contando los proxies que controlas.
En CREA.MBA este limitador viene montado: cupos por tipo de ruta en el proxy, Redis o Valkey opcional con REDIS_URL y la IP leída con TRUSTED_PROXY_HOPS. Si te interesa el resto de la seguridad de la API, en cada usuario ve solo sus datos contamos por qué el proxy no debe ser el sitio donde se decide quién puede leer qué.
¿Has visto alguna vez en tus logs una ráfaga contra el login? ¿Cómo lo resolviste?
¿Te gustó este artículo?
Suscríbete para más tutoriales y tips sobre crear productos con IA