ratethrottle
Get Started
Installation
Basic Installation
Installation with Optional Dependencies
Redis Storage
Flask Integration
FastAPI Integration
Django Integration
All Frameworks
GRPC Integration
GraphQL Integration
Websocket Integration
All Protocols
All dependencies
Development Installation
Installing from Source
Verifying Installation
System Requirements
Next Steps
Quick Start
Simple Rate Limiting
Flask Integration
FastAPI Integration
Using Redis for Distributed Systems
Using Different Strategies
Whitelist and Blacklist
Monitoring and Metrics
DDoS Protection
Command Line Interface
Configuration Files
Next Steps
Basic Usage
Core Concepts
Creating a Rate Limiter
Quick Creation
Manual Creation
Defining Rules
Basic Rule
Rule with Strategy
Rule with Scope
Rule with Block Duration
Checking Rate Limits
Basic Check
Using Status Object
Adding Metadata
Managing Rules
Add Rules
Remove Rules
List Rules
Get Specific Rule
Whitelist and Blacklist
Whitelist Management
Blacklist Management
Violation Callbacks
Metrics and Monitoring
Get Metrics
Reset Metrics
System Status
Error Handling
Handling RateLimitExceeded
Using with Context Managers
Parsing Rate Limit Strings
Best Practices
Next Steps
User Guide
Core Concepts
Rate Limiting Basics
What is Rate Limiting?
Key Components
Rules
Storage Backends
Limiter Engine
Scopes
IP Scope
User Scope
Endpoint Scope
Global Scope
Rate Limiting Status
Attributes
Using Status Information
Violations
Violation Object
Violation Callbacks
Whitelist and Blacklist
Whitelist
Blacklist
Block Duration
Metrics and Monitoring
Threading and Concurrency
Distributed Systems
Best Practices
Architecture Diagram
Next Steps
Rate Limiting Strategies
Overview
Available Strategies
Token Bucket Strategy
How It Works
Example Behavior
Best For
Implementation
Leaky Bucket Strategy
How It Works
Example Behavior
Best For
Implementation
Fixed Window Strategy
How It Works
Example Behavior
Boundary Condition Problem
Best For
Implementation
Sliding Window Counter Strategy
How It Works
Example Behavior
Solves Boundary Problem
Best For
Implementation
When to Use vs Other Strategies
Sliding Window Strategy
How It Works
Example Behavior
Best For
Implementation
Strategy Comparison
Performance
Burst Handling
Choosing a Strategy
Decision Tree
Use Case Matrix
Combining Strategies
Advanced Configuration
Token Bucket Fine-Tuning
Testing Strategies
Next Steps
Storage Backends
Available Backends
In-Memory Storage
Redis Storage
In-Memory Storage
Usage
Configuration
When to Use
Redis Storage
Installation
Basic Usage
Advanced Configuration
Redis Connection Options
Connection Pooling
SSL/TLS Connection
Redis Sentinel
Redis Cluster
Storage Operations
Get
Set
Increment
Delete
Exists
Clear
Performance Considerations
In-Memory
Redis
Optimizing Redis Performance
Distributed Systems
Architecture
Implementation
High Availability
Redis Sentinel Setup
Redis Persistence
Custom Storage Backend
Monitoring Storage
Redis Monitoring
Storage Metrics
Best Practices
Next Steps
Configuration
Configuration Methods
Programmatic Configuration
Basic Setup
With Storage
YAML Configuration
Configuration File Format
Loading Configuration
Environment Variables
Configuration Options
Rule Configuration
Storage Configuration
DDoS Configuration
Analytics Configuration
Best Practices
Example Complete Configuration
Next Steps
ML Adaptive Limiting
Overview
Installation
Quick Start
Basic Usage
How It Works
1. Pattern Learning
2. Anomaly Detection
3. Trust Scoring
4. Limit Adjustment
Configuration
Basic Configuration
Advanced Configuration
Configuration Guidelines
Use Cases
1. Public API Protection
2. SaaS Application
3. E-commerce Checkout
4. Internal API Gateway
Monitoring & Insights
Get User Profile
Get Statistics
Callbacks
Model Persistence
Save Model
Load Model
Use Case: Graceful Restarts
Integration Examples
Flask
FastAPI
Django
Best Practices
1. Start Conservative
2. Use Appropriate Identifiers
3. Monitor and Alert
4. Combine with Traditional Limits
5. Persist Models
Framework Integration
Flask Integration
Installation
Quick Start
Basic Usage
Decorator-based Limiting
Multiple Limits
Custom Key Functions
By IP Address
By User
By API Key
Configuration
Flask Configuration
With Redis Storage
Error Handling
Custom Error Handler
Response Headers
Complete Example
Best Practices
Next Steps
FastAPI Integration
Installation
Quick Start
Basic Usage
Dependency Injection Pattern
Alternative: Using dependencies Parameter
Configuration
With Redis Storage
Custom Key Functions
By IP Address (Default)
By User ID
By API Key
Error Handling
Custom Exception Handler
Complete Example
Next Steps
Django Integration
Installation
Quick Start
Usage
Using the Decorator
Configuration
Settings
Complete Example
Next Steps
Starlette Integration
Installation
Quick Start
Complete Example
Next Steps
Protocols Reference
GRPC Rate Limiting
Overview
Installation
Quick Start
1. Basic Server with Rate Limiting
Complete Examples
Example 1: User Service with Global Rate Limiting
Example 2: Per-Method Rate Limiting
Example 3: Custom Client ID Extraction
Example 4: Per-Service Rate Limits
Example 5: Multiple Services with Different Limits
Example 6: Streaming RPCs
Example 7: Violation Callbacks
Example 8: Redis Storage for Distributed Systems
Client-Side Usage
Handling Rate Limit Errors
Reading Rate Limit Headers
Configuration Examples
Public API (Strict)
Authenticated API (Moderate)
Internal Services (Generous)
Monitoring & Statistics
Protobuf Example
Best Practices
1. Use Per-Method Limits for Fine Control
2. Combine Global + Method Limits
3. Use Custom Metadata for Better Tracking
4. Monitor Violations
Summary
Next Steps
GraphQL Rate Limiting
Overview
Installation
Quick Start
1. Basic Rate Limiting
Framework Integrations
1. Ariadne
2. Graphene (Django/Flask)
3. Strawberry (FastAPI)
Complete Examples
Example 1: E-commerce API
Example 2: Social Network API
Complexity Analysis
How Complexity is Calculated
Custom Field Costs
Depth Limiting
Field-Level Rate Limiting
Violation Callbacks
Configuration Examples
Public API (Strict)
Authenticated API (Moderate)
Premium/Internal (Generous)
Best Practices
1. Set Reasonable Complexity Limits
2. Define Custom Costs for Expensive Fields
3. Use Field-Level Limits for Critical Operations
4. Monitor and Adjust
Summary
Next Steps
WebSocket Rate Limiting
Overview
Quick Start
Installation
Basic Usage
Simple Rate Limiter
Framework Integrations
1. FastAPI WebSocket
2. Socket.IO
3. Django Channels
Advanced Usage
Custom Client ID Extraction
Per-Room/Channel Limits
Violation Callbacks
Statistics and Monitoring
Complete Examples
Example 1: Real-Time Chat
Example 2: Live Dashboard
Configuration Examples
Strict Limits (API)
Moderate Limits (Chat)
Generous Limits (Internal Tools)
Best Practices
1. Choose Appropriate Limits
2. Handle Rate Limit Gracefully
3. Monitor and Alert
4. Use Redis for Distributed Systems
Summary
Next Steps
Advanced Features
DDoS Protection
Overview
Quick Start
Configuration
Detection Methods
High Request Rate
Scanning Behavior
Bot Behavior
Usage Examples
Basic Protection
With Auto-Blocking
Monitoring
Get Statistics
Blocked IPs
Unblock IP
Integration with Rate Limiting
Best Practices
Next Steps
Analytics and Reporting
Overview
Quick Start
Configuration
Recording Data
Record Requests
Record Violations
Analyzing Data
Top Violators
Violation Timeline
Rule Statistics
Exporting Data
Export to JSON
Export to CSV
Best Practices
Next Steps
Command Line Interface
Installation
Usage
Basic Commands
Testing Rate Limits
Viewing Metrics
Managing Whitelist/Blacklist
Statistics
Configuration
Next Steps
ML Adaptive - Reference
Installation
Basic Usage
Configuration Quick Reference
Result Fields
Common Patterns
Pattern 1: Simple Integration
Pattern 2: User-Based Limiting
Pattern 3: With Callbacks
Pattern 4: Tiered Limits
Pattern 5: Model Persistence
Example Applications
Example 1: Public API
Example 2: SaaS Application
Example 3: E-commerce Checkout
Example 4: API Gateway
Example 5: WebSocket with Adaptive Limiting
Tips & Tricks
Tip 1: Start Conservative, Then Loosen
Tip 2: Different Limiters for Different Endpoints
Tip 3: Combine with Traditional Limits
Tip 4: Manual Trust Adjustments
Cheat Sheet
Summary
Next Steps
Distributed Deployments
Overview
Architecture
Setup
Each Server
High Availability
Best Practices
Next Steps
ratethrottle
Index
Index