I built the Swiss army knife of Ratelimiting

Myke Aneke — Tue, 03 Mar 2026 12:17:03 +0000

Introducing Ratethrottle

The Swiss Army knife of rate limiting - everything you need in one library.

What is RateThrottle?

An advanced rate limiting library for Python that goes far beyond basic REST API protection.

The problem: Most rate limiting libraries are limited to one framework and only handle basic REST APIs.

The solution: RateThrottle supports everything - multiple frameworks, multiple protocols, advanced features - all in one well-tested package.

🌟 Core Features

1. Universal Framework Support

Works with all major Python web frameworks:

# Flask
@app.route('/api')
@limiter.limit("100/minute")
def api(): return {'data': 'value'}

# FastAPI
@app.get("/api")
async def api(_=Depends(limiter.limit(100, 60))):
    return {"data": "value"}

# Django
@django_ratelimit(limit=100, window=60)
def api(request): return JsonResponse({'data': 'value'})

2. Multiple Protocols

Beyond REST - WebSocket, gRPC, GraphQL:

# WebSocket - limit connections & messages
limiter = WebSocketRateLimiter(
    WebSocketLimits(
        connections_per_minute=10,
        messages_per_minute=100
    )
)

# gRPC - server interceptors
interceptor = GRPCRateLimitInterceptor(
    GRPCLimits(requests_per_minute=100)
)

# GraphQL - complexity & depth analysis
limiter = GraphQLRateLimiter(
    GraphQLLimits(
        queries_per_minute=100,
        max_complexity=1000
    )
)

3. Four Rate Limiting Strategies

Choose the algorithm that fits your needs:

Token Bucket - APIs with bursts
Leaky Bucket - Smooth traffic
Fixed Window - Simple use cases
Sliding Window - Accurate limiting

# Choose your strategy
RateThrottleRule(
    name='api',
    limit=100,
    window=60,
    strategy='sliding_window'  # or token_bucket, leaky_bucket, fixed_window
)

4. DDoS Protection

Built-in attack detection:

from ratethrottle import DDoSProtection

ddos = DDoSProtection(threshold=1000)

is_attack, pattern = ddos.analyze_traffic(client_ip)

if is_attack:
    ddos.block_ip(client_ip)
    alert_ops_team(pattern)

Detection:

Volume-based (request spikes)
Pattern-based (behavior analysis)
Distributed (coordinated attacks)

5. Distributed Systems Ready

Redis for multi-server deployments:

# Development: In-memory
storage = InMemoryStorage()

# Production: Redis
storage = RedisStorage('redis://localhost:6379/0')

limiter = RateThrottleCore(storage=storage)

6. Analytics & Monitoring

Track everything:

from ratethrottle import RateThrottleAnalytics

analytics = RateThrottleAnalytics(limiter)
report = analytics.generate_report(last_24_hours)

# Metrics:
# - Total requests: 152,384
# - Blocked: 1,523 (1.0%)
# - Top violators
# - Attack patterns

7. CLI Tools

Manage from command line:

# Monitor real-time
ratethrottle monitor --interval 1

# Test rules
ratethrottle test --rule api --requests 150

# Manage IPs
ratethrottle manage --blacklist-add 192.168.1.50

🎯 Real-World Use Cases

Public API

@app.route('/api/public')
@limiter.limit("60/minute")  # Conservative
def public(): return {'data': 'public'}

WebSocket Chat

limiter = SocketIOLimiter(
    WebSocketLimits(messages_per_minute=200)
)

Microservices Gateway

# Different services, different limits
limiter.add_rule(RateThrottleRule(
    name='auth_service', limit=1000
))
limiter.add_rule(RateThrottleRule(
    name='payment_service', limit=100
))

GraphQL API

# Prevent expensive queries
limiter = GraphQLRateLimiter(
    GraphQLLimits(max_complexity=1000)
)

📦 Installation

# Basic
pip install ratethrottle

# With framework
pip install ratethrottle[flask]
pip install ratethrottle[fastapi]

# With protocols
pip install ratethrottle[grpc]
pip install ratethrottle[graphql]
pip install ratethrottle[websocket]

# Everything
pip install ratethrottle[all]

🚀 Quick Start (2 minutes)

Flask:

from flask import Flask
from ratethrottle import FlaskRateLimiter

app = Flask(__name__)
limiter = FlaskRateLimiter(app)

@app.route('/api')
@limiter.limit("100/minute")
def api(): 
    return {'data': 'protected'}

FastAPI:

from fastapi import FastAPI, Depends
from ratethrottle import FastAPIRateLimiter

app = FastAPI()
limiter = FastAPIRateLimiter()

@app.get("/api")
async def api(_=Depends(limiter.limit(100, 60))):
    return {"data": "protected"}

📚 Resources

📦 Install: pip install ratethrottle

📖 Docs: Documentation

⭐ GitHub: GitHub

🗺️ What Makes It Complete?

✅ Frameworks: Flask, FastAPI, Django, Starlette
✅ Protocols:REST, WebSocket, gRPC, GraphQL
✅ Strategies: Token Bucket, Leaky Bucket, Fixed Window, Sliding Window
✅ Features: DDoS Protection, Analytics, CLI Tools.
✅ Storage: In-Memory, Redis
✅ Quality: comprehensive docs

💡 Why Choose RateThrottle?

If you need:

✅ Multiple frameworks → RateThrottle
✅ WebSocket/gRPC/GraphQL → RateThrottle
✅ DDoS protection → RateThrottle
✅ Advanced features → RateThrottle
✅ Everything in one place → RateThrottle

🎉 Try It Today!

pip install ratethrottle

⭐ Star on GitHub if useful!

Questions? Feature requests? Issues?

Drop them below! 👇

Open Source Is One of techs' greatest strengths — So Why Don’t More Developers Contribute?

Myke Aneke — Fri, 13 Feb 2026 20:36:25 +0000

Almost every developer depends on open source software every single day.

Your frameworks, libraries, containers, security tools, machine learning stacks, and even operating systems are built on code shared openly by developers around the world.

Modern software simply wouldn’t exist without open source.

Yet there’s a paradox:

Most developers consume open source, but very few actively contribute back.

So the real discussion isn’t whether open source matters — it clearly does.

The discussion is:

What responsibility, if any, do we have toward the projects we rely on?

Open Source Is More Than “Free Code”

Open source isn’t just software you don’t pay for. It represents:

Global collaboration
Shared innovation
Public learning resources
Community-driven problem solving
Faster technological progress

A developer anywhere in the world can improve tools used globally. Few industries allow this level of cooperation across borders.

But Participation Is Uneven

Most successful projects follow the same pattern:

Thousands of users
Dozens of contributors
A handful of maintainers
Sometimes just one exhausted creator

Which raises some uncomfortable questions:

Why don’t more users become contributors?
Are projects difficult to contribute to?
Do developers underestimate their ability to help?
Or are we all simply too busy shipping our own work?

Contribution Isn’t Only About Writing Complex Code

Many developers think:

“If I’m not building features or fixing deep bugs, I’m not helping.”

But many projects grow through smaller contributions:

Improving documentation
Fixing setup instructions
Reporting clear, reproducible bugs
Improving examples and tutorials
Helping others in discussions
Improving onboarding for newcomers

Sometimes better documentation helps more people than a new feature ever could.

Open Source Builds Better Developers

Contributing also improves skills that are hard to learn in isolation:

Reading large codebases
Collaborating with unfamiliar teams
Receiving and giving code reviews
Writing maintainable code
Working with production-level tools

Many experienced engineers credit open source contributions for accelerating their growth.

The Discussion Worth Having

Here’s where opinions differ:

Should developers feel responsible for contributing back?
Should companies financially support projects they rely on?
Should projects make contributing easier?
Should maintainers expect help from users?
Or is simply using open source enough?

There isn’t a single correct answer.

But discussing these questions helps keep the ecosystem healthy.

Final Thought

Open source thrives because people choose to share, improve, and collaborate.

At some point, every developer decides:

Am I only a user, or also a participant?

Both roles are valid — but projects grow stronger when more users eventually become contributors.

Discussion time 👇

Have you contributed to open source? Why or why not?
What makes contributing intimidating?
Maintainers: what do you wish users understood?

Curious to hear different perspectives.

DEV Community: Myke Aneke