Saltar al contenido

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)
  1. Qué es el rate limiting y qué protege
  2. Ventana fija vs. ventana deslizante
  3. Implementación en 15 líneas con Redis
  4. Versión con Postgres
  5. Responder 429 con Retry-After
  6. Límites distintos por ruta
  7. Errores comunes
  8. Preguntas frecuentes
  9. Checklist

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;
}
  1. bucket pega 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.
  2. multi() manda INCR y PEXPIRE juntos; 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.

AlgoritmoQué guarda por clavePrecisiónEn el borde del minuto (prueba)
Ventana fijaUn contador por ventanaPor minuto de relojPasaron 20 de 20 con límite 10
Ventana deslizante (registro)Una entrada por petición aceptada, como máximo el límiteExacta en los últimos N segundosPasaron 10 de 20
Contador deslizanteDos contadores, el de la ventana actual y el de la anteriorAproximada: supone tráfico parejo en la ventana anteriorNo 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 };
}
  1. SCRIPT es 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 y ARGV[4] el id de esta petición.
  2. ZREMRANGEBYSCORE borra los miembros con score desde -inf hasta ahora menos la ventana, ambos extremos incluidos: lo que ya salió de la ventana.
  3. ZCARD cuenta lo que queda (0 si la clave no existe). Si es menos que el límite, ZADD anota la petición y PEXPIRE pone a la clave una caducidad de una ventana, en milisegundos. Devuelve 0: aceptada.
  4. Sin cupo, ZRANGE con 0 0 WITHSCORES trae 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.
  5. En Node, member une la hora con crypto.randomUUID(), global en Node 22, y map(String) está porque redis.eval(SCRIPT, { keys, arguments }), la firma de node-redis 6.3.1 con la que probamos, recibe strings. now es 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.

ventana deslizante en un sorted set: lo viejo se borra, lo nuevo se cuentaventana: los últimos 60 sya no cuentanZCARD = 9 < 10nuevaahora − 60 sahoraZREMRANGEBYSCOREborra todo lo anterior a ahora − 60 sZCARDcuenta lo que queda: 9, menos que el límite de 10ZADD now idanota esta petición con un id únicoPEXPIRE 60000la clave caduca si nadie vuelve en 60 slos cuatro pasos corren en un script Lua: atómicoejemplo ilustrativo, límite 10/min; con 10 la petición no se anota: 429

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
  1. Con límite 10 pasan exactamente 10, por una conexión o repartidas en cinco.
  2. 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.
  3. 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);
  1. 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.
  2. 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 };
  });
}
  1. sql.begin abre una transacción en una conexión reservada; si algo falla, Postgres.js hace ROLLBACK.
  2. pg_advisory_xact_lock toma 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.
  3. 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));
  1. LIMITS asigna a cada ruta, método incluido, su límite y su ventana; lo que no está ahí no se limita.
  2. disableOfflineQueue: true hace que node-redis rechace los comandos mientras reconecta, en vez de guardarlos; su configuración lo trae en false.
  3. La clave une la ruta y la IP del socket: cada ruta tiene su contador. Si Redis falla, el catch deja pasar la petición y lo registra.
  4. Sin cupo, responde 429 con Retry-After en 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}
  1. 429 Too Many Requests lleva la frase que Node pone por defecto.
  2. Retry-After: 900 son 15 minutos: lo que tarda en salir la primera petición de la ventana. El cuerpo lo repite para quien no lee cabeceras.
una petición rechazada: el script decide, el servidor responde 429clienteservidor NodeRedisPOST /login · la 6.ªEVAL script, límite 5, 15 minZCARD 5 ≥ 5: no se anotaZRANGE 0 0: la más antiguaretryAfterMs ≈ 900000429 · Retry-After: 900el script devuelve la espera; Node la sube a segundosmedido en local con fakeredis 2.40: 5 × 200 y luego 429 con Retry-After: 900

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.

RutaClaveLímiteVentanaPor qué
POST /loginIP, y aparte la cuenta515 minFrena a quien prueba contraseñas
POST /password-resetCuenta31 hCada intento manda un correo
POST /api/discount-codeIP101 minFrena a quien adivina códigos
GET /api/searchIP601 minScraping y costo por consulta
POST /contactIP51 hSpam
POST /webhooks/shopifyNinguna——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.

un límite por ruta: puntos de partida, no medicionesrutaclavelímiteventanamotivoPOST /loginIP y cuenta515 minadivinar contraseñasPOST /password-resetcuenta31 hcorreos de reinicioPOST /api/discount-codeIP101 minprobar códigosGET /api/searchIP601 minscraping y costoPOST /contactIP51 hspamPOST /webhooks/shopify———verifica HMAC y encolael webhook no se limita por IP: se verifica y se encolaajusta cada valor con los registros de tu tráfico real

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-After en 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_lock en 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-After en 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

Luis Morales

Luis Morales

Desarrollador frontend y Shopify, EcomLabs

@luismoralesdev en Instagram

Publicado el 11 de noviembre de 2026

← Blog