How to Implement Rate Limiting with Redis: A Practical Guide

Rate limiting controls the number of requests a user can make within a time window. Redis is ideal for this because of its in-memory speed and atomic operations. This tutorial covers two efficient methods to implement rate limiting using Redis.

Implementing rate limiting prevents abuse and ensures fair usage of your API. Redis provides the data structures and atomicity needed for accurate, low-latency throttling. Below we explore two common approaches.

Article illustration

Method 1: Sliding Window with Sorted Sets

This approach uses a Redis sorted set where each member is a timestamp of the request. The window is maintained by removing entries older than the limit period.

How it works

  • Each user gets a sorted set key (e.g., limiter:user:123).
  • For each request, add the current timestamp (member) with a unique score (same timestamp).
  • Use ZREMRANGEBYSCORE to remove timestamps out of the window.
  • Count remaining members with ZCARD and compare to the limit.
  • Set expiry on the key to save memory.

Example code (Python):

now = time.time()
pipe = r.pipeline()
pipe.zadd(key, {now: now})
pipe.zremrangebyscore(key, 0, now - window)
pipe.zcard(key)
pipe.expire(key, window)
results = pipe.execute()
if results[3] > limit:
    # reject request

Method 2: Fixed Window Counter with INCR/EXPIRE

This simpler technique uses a counter that resets at the end of each window. It may allow short bursts at the window boundary.

How it works

  • Use one key per user per window (e.g., rate:user:123:1609459200).
  • On each request, INCR the key and check the value against the limit.
  • If the key is new, set an EXPIRE equal to the window length.
  • If the counter exceeds the limit, block the request.

Example code (Node.js):

const key = `rate:${userId}:${Math.floor(Date.now()/1000/window)}`;
const count = await redis.incr(key);
if (count === 1) redis.expire(key, window);
if (count > limit) return reject;

Important Considerations

  • For atomicity in sliding window, use a Lua script or Redis transactions to avoid race conditions.
  • Use EXPIRE on keys to prevent memory leaks.
  • In distributed environments, Redis ensures consistent state across servers.
  • Choose sliding window for precise control; fixed window for lower complexity.

Conclusion

Redis provides fast, reliable building blocks for rate limiting. The sorted set method gives accurate sliding windows, while the fixed counter is simpler. Both can be scaled horizontally with Redis clustering. Evaluate your precision needs and choose accordingly.

sarah antaboga
Author: sarah antaboga

Leave a Reply

Your email address will not be published. Required fields are marked *