Why rate limiting protects services in Rest API - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

What is the main purpose of rate limiting in APIs?

Imagine a busy coffee shop that only has 10 seats. What is the main reason the shop owner would limit the number of customers inside at once?

Similarly, why do APIs use rate limiting?

A To prevent too many requests from overwhelming the service and causing it to slow down or crash.

B To make the API slower on purpose so users wait longer.

C To allow unlimited requests from all users without any restrictions.

D To block all users from accessing the API permanently.

💡 Hint

Think about how too many people in a small space can cause problems.

Rate limiting helps protect services by controlling how many requests a user or client can make in a given time. This prevents overload and keeps the service stable.

❓ Predict Output

intermediate

What will this rate limiting code output when requests exceed the limit?

Consider this simplified Python code snippet for rate limiting an API endpoint:

requests = 0
limit = 3

for i in range(5):
    if requests < limit:
        requests += 1
        print("Request allowed")
    else:
        print("Too many requests")

What is the output?

Rest API

requests = 0
limit = 3

for i in range(5):
    if requests < limit:
        requests += 1
        print("Request allowed")
    else:
        print("Too many requests")

A

Too many requests
Too many requests
Too many requests
Too many requests
Too many requests

B

Request allowed
Request allowed
Too many requests
Too many requests
Too many requests

C

Request allowed
Request allowed
Request allowed
Too many requests
Too many requests

D

Request allowed
Request allowed
Request allowed
Request allowed
Request allowed

💡 Hint

Count how many times the request is allowed before the limit is reached.

The code allows 3 requests, then blocks the next 2 because the limit is 3.

🔧 Debug

advanced

How does this rate limiting code handle excess requests?

Look at this code snippet that tries to limit requests to 2 per user:

user_requests = {}
limit = 2

requests = ["user1", "user1", "user1"]

for user in requests:
    if user_requests.get(user, 0) < limit:
        user_requests[user] = user_requests.get(user, 0) + 1
        print(f"Request from {user} allowed")
    else:
        print(f"Request from {user} blocked")

What is the output?

Rest API

user_requests = {}
limit = 2

requests = ["user1", "user1", "user1"]

for user in requests:
    if user_requests.get(user, 0) < limit:
        user_requests[user] = user_requests.get(user, 0) + 1
        print(f"Request from {user} allowed")
    else:
        print(f"Request from {user} blocked")

A

Request from user1 allowed
Request from user1 allowed
Request from user1 allowed - It fails because the count is updated after the check.

B SyntaxError due to missing colon in if statement.

C

Request from user1 blocked
Request from user1 blocked
Request from user1 blocked - It blocks all requests.

D

Request from user1 allowed
Request from user1 allowed
Request from user1 blocked - It works correctly.

💡 Hint

Check how the count is updated and compared before allowing requests.

The code correctly blocks the third request because it increments the count before the next check.

📝 Syntax

advanced

Identify the syntax error in this rate limiting code snippet

Find the syntax error in this Python code that tries to implement rate limiting:

limit = 5
requests = 0

while requests <= limit
    print("Request allowed")
    requests += 1

Rest API

limit = 5
requests = 0

while requests <= limit
    print("Request allowed")
    requests += 1

A Missing colon ':' after the while condition.

B Indentation error on the print statement.

C Using '<=' instead of '<' in the while condition.

D Missing parentheses in the print statement.

💡 Hint

Check the syntax of the while loop header.

Python requires a colon ':' at the end of the while condition line.

🚀 Application

expert

How many requests will be allowed in this sliding window rate limiter?

This code implements a sliding window rate limiter allowing 3 requests per 10 seconds:

import time

class SlidingWindowLimiter:
    def __init__(self, limit, window):
        self.limit = limit
        self.window = window
        self.timestamps = []

    def allow_request(self):
        now = time.time()
        self.timestamps = [t for t in self.timestamps if now - t < self.window]
        if len(self.timestamps) < self.limit:
            self.timestamps.append(now)
            return True
        return False

limiter = SlidingWindowLimiter(3, 10)

results = []
for _ in range(5):
    results.append(limiter.allow_request())
    time.sleep(1)

print(results)

What will be printed?

Rest API

import time

class SlidingWindowLimiter:
    def __init__(self, limit, window):
        self.limit = limit
        self.window = window
        self.timestamps = []

    def allow_request(self):
        now = time.time()
        self.timestamps = [t for t in self.timestamps if now - t < self.window]
        if len(self.timestamps) < self.limit:
            self.timestamps.append(now)
            return True
        return False

limiter = SlidingWindowLimiter(3, 10)

results = []
for _ in range(5):
    results.append(limiter.allow_request())
    time.sleep(1)

print(results)

A [True, True, True, True, True]

B [True, True, True, False, False]

C [False, False, False, False, False]

D [True, False, True, False, True]

💡 Hint

Think about how the sliding window removes timestamps older than 10 seconds.

The limiter allows the first 3 requests because they are within the limit. The 4th and 5th requests happen within 10 seconds and exceed the limit, so they are blocked.