What is rate limiting?

Rate limiting is a strategy for limiting network traffic. It's used to control the amount of incoming and outgoing traffic to or from a network. For example, a web server might limit the number of requests a single IP address can make in a given period.

What are common rate limiting algorithms?

Common rate limiting algorithms include Token Bucket, Leaky Bucket, Fixed Window Counter, and Sliding Window Log. Each algorithm has different characteristics regarding memory usage, performance, and how it handles bursts of traffic.

System Design Interview

Rate Limiting

Protect your services from abuse and ensure availability by implementing effective rate limiting strategies. Explore various algorithms and their trade-offs.

Example: Token Bucket Algorithm in Python

A simple implementation of the Token Bucket algorithm, a popular choice for rate limiting due to its ability to handle bursts of traffic smoothly.


                                import time
                                
                                class TokenBucket:
                                    def __init__(self, tokens, time_unit):
                                        self.tokens = tokens
                                        self.time_unit = time_unit
                                        self.last_check = time.time()
                                        self.allowance = tokens
                                
                                    def is_allowed(self):
                                        current = time.time()
                                        time_passed = current - self.last_check
                                        self.last_check = current
                                
                                        self.allowance += time_passed * (self.tokens / self.time_unit)
                                
                                        if (self.allowance > self.tokens):
                                            self.allowance = self.tokens
                                
                                        if (self.allowance < 1.0):
                                            return False
                                        else:
                                            self.allowance -= 1.0
                                            return True