Rate limiting en Node: ventana deslizante en 15 líneas
En la práctica/ 16 min de lectura
Un rate limiter de ventana deslizante en 15 líneas de Node y Lua, atómico en Redis, más una versión en Postgres, el 429 con Retry-After y límites por ruta. Todo probado.
- Node.js
- Seguridad
- Bases de datos
En este artículo (9)
Para hacer rate limiting en Node con ventana deslizante, guarda cada petición aceptada en un sorted set de Redis con su hora como score. En cada petición, un script Lua borra lo que salió de la ventana, cuenta lo que queda y solo anota la nueva si hay cupo. Si no hay cupo, respondes 429 con Retry-After.
Aquí tienes la función de 15 líneas (las contamos), la versión con Postgres para quien no tiene Redis, el servidor que responde 429 y una tabla de límites por ruta. El código de Redis lo probamos contra fakeredis 2.40, un emulador de Redis en Python que ejecuta Lua 5.1, y el de Postgres contra PGlite (PostgreSQL 18.6 en WebAssembly). Más abajo está qué demuestran esas pruebas y qué no.
Qué es el rate limiting y qué protege
Un rate limit es un tope de peticiones por cliente en un tiempo dado. El código HTTP para avisarlo es el 429, definido en la sección 4 del RFC 6585 (abril de 2012): el usuario mandó demasiadas peticiones en cierto tiempo, lo que el propio RFC llama «rate limiting». La página de MDN sobre el 429 lo describe como pedirle al cliente que baje el ritmo.
El RFC no define cómo identificas al usuario ni cómo cuentas: puede ser por recurso, por servidor o entre varios servidores, por credenciales o por cookie. Eso lo decides tú, en tres partes: la clave (de quién cuentas: una IP, una cuenta, una API key), el límite (cuántas peticiones aceptas) y la ventana (en cuánto tiempo).
En una tienda, el límite protege rutas concretas: el login, contra quien prueba contraseñas; los códigos de descuento, contra quien los adivina; la búsqueda, contra el scraping; los formularios, contra el spam; y lo que llama a una API que te cobra por uso. Un rate limit no autentica a nadie, igual que CORS no protege tu API: solo cuenta. Y no frena un ataque repartido entre miles de IPs.
Ventana fija vs. ventana deslizante
La forma más simple es la ventana fija: un contador por clave y por minuto de reloj. La documentación de INCR la trae como patrón «rate limiter»: un contador por IP y por segundo, con INCR y EXPIRE dentro de MULTI/EXEC. Esta es la versión que usamos en las pruebas, con la hora inyectada:
async function fixedWindow(redis, key, limit, windowMs, now = Date.now()) {
const bucket = `${key}:${Math.floor(now / windowMs)}`;
const [count] = await redis.multi().incr(bucket).pExpire(bucket, windowMs).exec();
return count <= limit;
}
bucketpega a la clave el número de ventana: las peticiones del mismo minuto de reloj caen en el mismo contador, que se borra solo al vencer.multi()mandaINCRyPEXPIREjuntos; la petición pasa si el contador, ya sumado, no superó el límite.
Es barato, pero tiene un hueco en el borde. Con un límite de 10 por minuto, mandamos 10 peticiones en el segundo 59,9 y otras 10 en el 60,1. La ventana fija dejó pasar las 20 en 200 ms, porque son dos minutos de reloj distintos. La ventana deslizante dejó pasar 10, porque mira siempre los últimos 60 segundos contados desde ahora, no desde el inicio del minuto.
| Algoritmo | Qué guarda por clave | Precisión | En el borde del minuto (prueba) |
|---|---|---|---|
| Ventana fija | Un contador por ventana | Por minuto de reloj | Pasaron 20 de 20 con límite 10 |
| Ventana deslizante (registro) | Una entrada por petición aceptada, como máximo el límite | Exacta en los últimos N segundos | Pasaron 10 de 20 |
| Contador deslizante | Dos contadores, el de la ventana actual y el de la anterior | Aproximada: supone tráfico parejo en la ventana anterior | No lo probamos |
El registro gasta una entrada por petición aceptada, pocas con límites como 5 o 60, y a cambio el límite es exacto. Es el que implementamos.
Implementación en 15 líneas con Redis
La estructura es un sorted set por clave. Cada petición aceptada es un miembro: su score es la hora en milisegundos y su nombre, un id único. Lo de único importa: según la documentación de ZADD, si el miembro ya existe, Redis solo actualiza su score; no lo agrega dos veces. Si usaras la hora como nombre, dos peticiones del mismo milisegundo contarían como una. La misma página dice que los scores son doubles que representan enteros exactos hasta 2^53, así que una hora en milisegundos cabe sin redondeo.
Este es limiter.mjs completo:
const SCRIPT = `
redis.call('ZREMRANGEBYSCORE', KEYS[1], '-inf', ARGV[1] - ARGV[2])
if redis.call('ZCARD', KEYS[1]) < tonumber(ARGV[3]) then
redis.call('ZADD', KEYS[1], ARGV[1], ARGV[4])
redis.call('PEXPIRE', KEYS[1], ARGV[2])
return 0
end
local oldest = redis.call('ZRANGE', KEYS[1], 0, 0, 'WITHSCORES')
return oldest[2] + ARGV[2] - ARGV[1]`;
export async function slidingWindow(redis, key, limit, windowMs, now = Date.now()) {
const member = `${now}-${crypto.randomUUID()}`;
const args = [now, windowMs, limit, member].map(String);
const retryAfterMs = await redis.eval(SCRIPT, { keys: [key], arguments: args });
return { allowed: retryAfterMs === 0, retryAfterMs };
}
SCRIPTes Lua que Redis ejecuta entero.KEYS[1]es la clave;ARGV[1]la hora,ARGV[2]la ventana en milisegundos,ARGV[3]el límite yARGV[4]el id de esta petición.- ZREMRANGEBYSCORE borra los miembros con score desde
-infhasta ahora menos la ventana, ambos extremos incluidos: lo que ya salió de la ventana. - ZCARD cuenta lo que queda (0 si la clave no existe). Si es menos que el límite,
ZADDanota la petición y PEXPIRE pone a la clave una caducidad de una ventana, en milisegundos. Devuelve 0: aceptada. - Sin cupo, ZRANGE con
0 0 WITHSCOREStrae el miembro más antiguo, porque el orden va del score menor al mayor. La espera es su hora más la ventana menos ahora; según la referencia de la API de Lua, un número de Lua llega al cliente como entero. - En Node,
memberune la hora concrypto.randomUUID(), global en Node 22, ymap(String)está porqueredis.eval(SCRIPT, { keys, arguments }), la firma de node-redis 6.3.1 con la que probamos, recibe strings.nowes un parámetro para que las pruebas fijen la hora.
Son 15 líneas sin contar la línea en blanco: 9 del script y 6 de la función. Una de nuestras pruebas lee el archivo y falla si dejan de ser 15.
Lo que hace correcto al código es que no hay hueco entre contar y anotar. La documentación de scripts Lua de Redis garantiza la ejecución atómica: mientras corre el script, toda otra actividad del servidor queda bloqueada, así que ninguna petición cuenta entre nuestro ZCARD y nuestro ZADD. La misma página pide pasar las claves en KEYS, para que funcione igual en Redis Cluster, y explica que Redis guarda cada script en caché por su SHA1: un script fijo entra una vez; uno generado en cada petición la hace crecer.
Desliza la figura para verla completa
Lo que probamos, y contra qué
No tenemos un servidor Redis instalado, así que corrimos el código con node-redis 6.3.1 contra el servidor TCP de fakeredis 2.40, en 127.0.0.1 y un puerto aleatorio. Esta es la salida de node --test --test-reporter=spec redis.test.mjs, sin las líneas de tiempos:
one connection: 10 allowed, 40 rejected, ZCARD 10
five connections: 10 allowed, 90 rejected
20 requests in the same ms -> ZCARD 20
non-unique member, limit 10: 20 allowed, ZCARD 1
after 15 calls, limit 5: ZCARD 5, PTTL 59994 ms
non-atomic version, limit 10, 100 requests over 5 connections: 97 allowed
10 at 59.9 s + 10 at 60.1 s, limit 10/min: fixed 20, sliding 10
- Con límite 10 pasan exactamente 10, por una conexión o repartidas en cinco.
- Con la hora sola como nombre, 20 peticiones del mismo milisegundo quedan en un miembro y pasan todas. Las rechazadas no se anotan y la clave caduca en 60 segundos.
- El control hace lo mismo en comandos separados: pasaron 97 de 100 con límite 10, y 91 en otra corrida.
Otra prueba fija la hora: con 3 por segundo, la cuarta petición, a los 300 ms, espera 700 ms. El límite de todo esto: fakeredis ejecuta cada comando, EVAL incluido, bajo un solo candado. Eso reproduce la atomicidad de Redis, pero no su velocidad, su memoria ni su comportamiento en cluster. Antes de producción, corre las pruebas contra un Redis de staging.
Versión con Postgres
Si no tienes Redis, la misma idea funciona en Postgres con una tabla de peticiones. Ya usamos Postgres para algo que suele hacerse con Redis en la cola de trabajos con SKIP LOCKED; aquí el truco es otro: un candado por clave. Este es schema.sql:
CREATE TABLE rate_limit_hits (
key text NOT NULL,
at timestamptz NOT NULL
);
CREATE INDEX rate_limit_hits_key_at ON rate_limit_hits (key, at);
- Cada fila es una petición aceptada: la clave y la hora. No hace falta un id único, porque dos filas iguales siguen siendo dos filas.
- El índice sobre
(key, at)sirve al borrado y al conteo, que siempre filtran por clave.
Y este es limiter-pg.mjs, con Postgres.js:
export async function slidingWindowPg(sql, key, limit, windowMs, now = new Date()) {
const since = new Date(now.getTime() - windowMs);
return sql.begin(async (tx) => {
await tx`SELECT pg_advisory_xact_lock(hashtext(${key}))`;
await tx`DELETE FROM rate_limit_hits WHERE key = ${key} AND at <= ${since}`;
const [{ count, oldest }] = await tx`
SELECT count(*)::int AS count, min(at) AS oldest FROM rate_limit_hits WHERE key = ${key}`;
if (count >= limit) {
return { allowed: false, retryAfterMs: oldest.getTime() + windowMs - now.getTime() };
}
await tx`INSERT INTO rate_limit_hits (key, at) VALUES (${key}, ${now})`;
return { allowed: true, retryAfterMs: 0 };
});
}
sql.beginabre una transacción en una conexión reservada; si algo falla, Postgres.js haceROLLBACK.pg_advisory_xact_locktoma un candado exclusivo con el número de la clave y, según la tabla de funciones de candados, espera si otro lo tiene. Se suelta solo al terminar la transacción.- Con el candado tomado, borra lo viejo, cuenta y busca la fila más antigua. Sin cupo devuelve la espera, como en Redis; con cupo, inserta y devuelve 0.
El candado reemplaza la atomicidad del script. En Read Committed, el nivel por defecto, cada SELECT ve lo confirmado antes de empezar: dos transacciones simultáneas pueden contar 9 y meter las dos su fila. Con el candado, la segunda espera a que la primera confirme y ve 10. Según la documentación de candados advisory, su significado lo pone tu aplicación.
Sobre hashtext: convierte la clave en el entero que pide el candado, pero es interna, no aparece en la documentación y su resultado puede cambiar entre versiones mayores. Para un candado que dura una transacción da igual; si dos claves dan el mismo número, solo se esperan entre sí.
En PGlite 0.5.10, con cinco conexiones de Postgres.js, 100 peticiones con límite 10 dejaron 10 aceptadas y 10 filas; sin transacción ni candado, 64. Pero el servidor de sockets de PGlite nunca solapa dos transacciones, y la transacción sin candado también dio 10. Que el candado evita el doble conteo en un PostgreSQL normal lo dice la documentación, no nuestra prueba.
Dos costos: cada petición limitada es una transacción de cuatro sentencias en tu base principal (bien para el login, no para cada GET de una API con mucho tráfico), y las claves que no vuelven dejan filas viejas. Programa un borrado periódico de todo lo anterior a tu ventana más larga.
Responder 429 con Retry-After
El RFC 6585 dice que la respuesta 429 debería explicar la condición, puede incluir Retry-After y no debe guardarse en una caché. El formato de Retry-After está en la sección 10.2.3 del RFC 9110: una fecha HTTP o un número de segundos, entero y no negativo. Por eso redondeamos hacia arriba con Math.ceil: una espera de casi 900 segundos sale como 900, sin decimales y nunca como 0.
Este es server.mjs, un servidor de Node sin dependencias además de node-redis:
import http from "node:http";
import { createClient } from "redis";
import { slidingWindow } from "./limiter.mjs";
const MINUTE = 60_000;
const LIMITS = {
"POST /login": { limit: 5, windowMs: 15 * MINUTE },
"POST /api/discount-code": { limit: 10, windowMs: MINUTE },
"GET /api/search": { limit: 60, windowMs: MINUTE },
};
const redis = await createClient({ url: process.env.REDIS_URL, disableOfflineQueue: true })
.on("error", (err) => console.error("redis:", err.message))
.connect();
http.createServer(async (req, res) => {
const route = `${req.method} ${new URL(req.url, "http://localhost").pathname}`;
const rule = LIMITS[route];
if (rule) {
const key = `rl:${route}:${req.socket.remoteAddress}`;
const verdict = await slidingWindow(redis, key, rule.limit, rule.windowMs).catch((err) => {
console.error("rate limiter unavailable, letting the request through:", err.message);
return { allowed: true };
});
if (!verdict.allowed) {
const seconds = Math.ceil(verdict.retryAfterMs / 1000);
res.writeHead(429, { "Content-Type": "application/json", "Retry-After": String(seconds) });
res.end(JSON.stringify({ error: "too_many_requests", retryAfterSeconds: seconds }));
return;
}
}
res.writeHead(200, { "Content-Type": "application/json" });
res.end(JSON.stringify({ ok: true, route }));
}).listen(Number(process.env.PORT ?? 3000));
LIMITSasigna a cada ruta, método incluido, su límite y su ventana; lo que no está ahí no se limita.disableOfflineQueue: truehace que node-redis rechace los comandos mientras reconecta, en vez de guardarlos; su configuración lo trae enfalse.- La clave une la ruta y la IP del socket: cada ruta tiene su contador. Si Redis falla, el
catchdeja pasar la petición y lo registra. - Sin cupo, responde 429 con
Retry-Afteren segundos y un cuerpo que explica qué pasó, como pide el RFC.
Así respondió la sexta petición a /login, con curl -si -X POST contra el servidor en local y fakeredis detrás:
HTTP/1.1 429 Too Many Requests
Content-Type: application/json
Retry-After: 900
Date: Wed, 11 Nov 2026 18:32:05 GMT
Connection: keep-alive
Keep-Alive: timeout=5
Transfer-Encoding: chunked
{"error":"too_many_requests","retryAfterSeconds":900}
429 Too Many Requestslleva la frase que Node pone por defecto.Retry-After: 900son 15 minutos: lo que tarda en salir la primera petición de la ventana. El cuerpo lo repite para quien no lee cabeceras.
Desliza la figura para verla completa
No cuentes con que el cliente obedezca. La página de MDN sobre Retry-After avisa que el soporte en clientes y servidores todavía es desigual. El límite lo aplica tu servidor en cada petición; la cabecera solo le dice al cliente cuánto le conviene esperar.
Límites distintos por ruta
No todas las rutas valen lo mismo. Estos son los valores con los que nosotros empezaríamos. Son puntos de partida, no mediciones: ajústalos mirando tus registros.
| Ruta | Clave | Límite | Ventana | Por qué |
|---|---|---|---|---|
POST /login | IP, y aparte la cuenta | 5 | 15 min | Frena a quien prueba contraseñas |
POST /password-reset | Cuenta | 3 | 1 h | Cada intento manda un correo |
POST /api/discount-code | IP | 10 | 1 min | Frena a quien adivina códigos |
GET /api/search | IP | 60 | 1 min | Scraping y costo por consulta |
POST /contact | IP | 5 | 1 h | Spam |
POST /webhooks/shopify | Ninguna | — | — | Se verifica la firma y se encola |
En el login conviene contar dos veces, con dos llamadas y dos claves (rl:login:ip:… y rl:login:account:…): por IP, para quien prueba muchas cuentas, y por cuenta, para quien prueba una desde muchas IPs. Cualquiera puede agotar el límite de una cuenta ajena, así que ahí conviene una espera corta, no un bloqueo largo.
Detrás de un proxy o un CDN, req.socket.remoteAddress es la IP del proxy y la del cliente llega en X-Forwarded-For. La página de MDN sobre X-Forwarded-For es clara: para rate limiting solo sirven las direcciones que agregó un proxy de confianza. La primera de la lista la escribe el cliente, y usarla permite saltarse el límite.
El webhook de Shopify va sin límite por IP: lo llama Shopify, no un cliente. Lo que protege esa ruta es verificar el HMAC del webhook antes de hacer nada; si el trabajo pesa, guárdalo en una cola de trabajos en Postgres y responde de inmediato.
Desliza la figura para verla completa
En las pruebas del servidor, /api/search aceptó 60 peticiones y la 61 recibió 429 con Retry-After: 60, mientras /products, fuera de LIMITS, siguió en 200. Con fakeredis apagado, POST /api/discount-code respondió 200 y el error quedó en el registro: eso es fallar abierto. Para el login quizá prefieras fallar cerrado con un 503; es la misma línea del catch.
Errores comunes
- Contar y anotar en dos comandos. Se cuelan otras peticiones: pasaron 97 de 100 con límite 10. Usa un script, o una transacción con candado en Postgres.
- Usar la hora como miembro del sorted set. Las peticiones del mismo milisegundo se vuelven una. Agrega un id único.
- Creer que la ventana fija es exacta. En el borde del minuto deja pasar el doble.
- Armar el script con la clave adentro. La documentación de Redis lo llama antipatrón: llena la caché de scripts y puede fallar en cluster. Pasa la clave en
KEYS. - Confiar en la primera IP de
X-Forwarded-For. La escribe el cliente. - Mandar
Retry-Afteren milisegundos o con decimales. El RFC 9110 pide segundos enteros. - No decidir qué pasa si Redis cae. Por defecto, node-redis guarda los comandos mientras reconecta y la petición espera. Elige fallar abierto o cerrado, y pruébalo.
- Dejar crecer la tabla en Postgres. Programa un borrado periódico.
Preguntas frecuentes
¿Limito por IP o por usuario?
Según la ruta. Antes del login solo tienes la IP; después, la cuenta o la API key identifican mejor, porque una oficina o una red de celular comparten IP entre muchas personas.
¿Cuánta memoria usa en Redis?
Como máximo, tantas entradas por clave como el límite, porque el script no anota las rechazadas: tras 15 llamadas con límite 5, el sorted set tenía 5 miembros. Y cada clave caduca una ventana después de su última petición aceptada, gracias a PEXPIRE. No medimos bytes: fakeredis no sirve para eso.
¿Funciona con varios servidores de Node o con Redis Cluster?
Sí, mientras todos usen el mismo Redis: el script toca una sola clave y la recibe en KEYS, como pide la documentación para cluster. La hora la pone cada proceso de Node con Date.now(), así que una diferencia de reloj entre servidores corre la ventana esa misma diferencia. Si prefieres un solo reloj, lee la hora dentro del script con TIME: la documentación de Redis permite escribir después de TIME desde la versión 5. No lo probamos.
¿Qué pasa si el cliente no respeta Retry-After?
Nada distinto: el script sigue rechazando hasta que se libera un lugar, y como las rechazadas no se anotan, insistir no alarga la espera. Para castigar a quien insiste, agrega un segundo límite más largo.
Checklist
- Cada ruta sensible tiene clave, límite y ventana escritos en un solo lugar.
- El conteo y el registro ocurren en un paso atómico: un script Lua en Redis o una transacción con
pg_advisory_xact_locken Postgres. - Cada miembro del sorted set lleva un id único, no solo la hora.
- La clave de Redis caduca con
PEXPIRE, y la tabla de Postgres tiene un borrado periódico. - La respuesta es 429 con
Retry-Afteren segundos enteros y un cuerpo que lo explica. - La IP sale del socket o de lo que agregó tu proxy de confianza, nunca de la primera de
X-Forwarded-For. - Está decidido y probado qué pasa si Redis no responde.
- Los webhooks no se limitan por IP: se verifican y se encolan.
Con 15 líneas y un script atómico, cada ruta sensible tiene su tope y el cliente sabe cuándo volver. Si lo que llega son webhooks, empieza por verificar el HMAC de los webhooks de Shopify y saca el trabajo pesado a una cola de trabajos en Postgres. Y recuerda que CORS no protege tu API: el límite lo pone el servidor.
¿Viste esto en Instagram? Comenta RATELIMIT en el Reel y te mando la guía.
Escrito por

Publicado el 11 de noviembre de 2026