Rate Limits

Scope: Authenticated users
Method: All platform features
Identification: User account
Rate: Based on subscription plan
```text

**Public Access:**
```text
Scope: Public features only
Method: Limited functionality
Identification: IP address
Rate: Conservative limits
```text

### Interactive Usage Limits

Limits on web application usage:

**Chat Interface:**
- Message sending frequency
- File upload rates
- Search query limits
- Agent execution frequency

**User Actions:**
- Account modifications
- Settings updates
- File management operations

## Rate Limit Structure

### Current Rate Limits by Plan

**Free Plan:**
```text
API Requests:
├── Rate: 60 requests per hour
├── Burst: 10 requests per minute
├── Daily cap: 1,440 requests
└── Reset: Rolling 60-minute window

Interactive Usage:
├── Chat messages: 20 per hour
├── File uploads: 5 per month
├── Web searches: 10 per hour
└── Agent runs: 5 per day
```text

**Pro Plan:**
```text
API Requests:
├── Rate: 1,000 requests per hour
├── Burst: 100 requests per minute
├── Daily cap: 24,000 requests
└── Reset: Rolling 60-minute window

Interactive Usage:
├── Chat messages: 500 per hour
├── File uploads: 100 per day
├── Web searches: 200 per hour
└── Agent runs: 100 per day
```text

**Team Plan:**
```text
API Requests:
├── Rate: 10,000 requests per hour
├── Burst: 500 requests per minute
├── Daily cap: 240,000 requests
└── Reset: Rolling 60-minute window

Interactive Usage:
├── Chat messages: 2,000 per hour
├── File uploads: 1,000 per day
├── Web searches: 1,000 per hour
└── Agent runs: 1,000 per day
```text

**Enterprise:**
```text
API Requests:
├── Rate: Custom (typically 50,000+ per hour)
├── Burst: Custom (typically 2,000+ per minute)
├── Daily cap: Custom or unlimited
└── Reset: Configurable windows

Interactive Usage:
├── All limits: Custom or unlimited
├── Priority processing: Guaranteed
├── Dedicated resources: Available
└── SLA guarantees: Included
```text

## Rate Limit Headers

### HTTP Response Headers

Every API response includes rate limit information:

```http
HTTP/1.1 200 OK
X-RateLimit-Limit: 1000
X-RateLimit-Remaining: 999
X-RateLimit-Reset: 1640995200
X-RateLimit-Window: 3600
X-RateLimit-Type: sliding
```text

**Header Explanations:**
- `X-RateLimit-Limit`: Maximum requests allowed in the time window
- `X-RateLimit-Remaining`: Number of requests left in current window
- `X-RateLimit-Reset`: Unix timestamp when the limit resets
- `X-RateLimit-Window`: Time window in seconds (3600 = 1 hour)
- `X-RateLimit-Type`: Type of rate limiting (sliding, fixed, token-bucket)

### Rate Limit Exceeded Response

When limits are exceeded:

```http
HTTP/1.1 429 Too Many Requests
Content-Type: application/json
X-RateLimit-Limit: 1000
X-RateLimit-Remaining: 0
X-RateLimit-Reset: 1640995200
Retry-After: 3600

{
  "error": {
    "code": "rate_limit_exceeded",
    "message": "Rate limit exceeded. Try again in 3600 seconds.",
    "details": {
      "limit": 1000,
      "remaining": 0,
      "reset_at": "2022-01-01T00:00:00Z",
      "retry_after": 3600
    }
  }
}
```text

## Rate Limiting Algorithms

### Sliding Window

mixus uses a sliding window algorithm for most rate limits:

**How it works:**
```text
Time Window: 1 hour (3600 seconds)
Request Limit: 1000 requests

Example Timeline:
├── 10:00 AM: 500 requests made
├── 10:30 AM: 300 requests made
├── 11:00 AM: Check limit from 10:00-11:00 (800 total) ✅
├── 11:15 AM: 300 requests made
└── 11:30 AM: Check limit from 10:30-11:30 (900 total) ✅
```text

**Benefits:**
- Smooth traffic distribution
- Prevents request hoarding
- Fair usage across time periods
- Predictable behavior

### Token Bucket (Burst Handling)

For burst protection, mixus implements token bucket algorithm:

**Configuration:**
```text
Bucket Capacity: 100 tokens
Refill Rate: 1 token per 36 seconds (100 per hour)
Burst Allowance: Use all 100 tokens immediately
Recovery Time: 1 hour to fully refill
```text

**Example Scenario:**
```text
Initial State: 100 tokens available
├── Send 50 requests: 50 tokens remaining
├── Wait 18 minutes: 80 tokens available (30 refilled)
├── Send 80 requests: 0 tokens remaining
└── Must wait for token refill to continue
```text

## Best Practices for Rate Limits

### Client-Side Implementation

**Respect Rate Limits:**
```python
import time
import requests

def api_request_with_backoff(url, headers, data=None, max_retries=3):
    for attempt in range(max_retries):
        response = requests.post(url, headers=headers, json=data)
        
        if response.status_code == 200:
            return response.json()
        elif response.status_code == 429:
            # Rate limit exceeded
            retry_after = int(response.headers.get('Retry-After', 60))
            print(f"Rate limited. Waiting {retry_after} seconds...")
            time.sleep(retry_after)
        else:
            response.raise_for_status()
    
    raise Exception("Max retries exceeded")
```text

**Exponential Backoff:**
```python
import random
import time

def exponential_backoff(attempt, base_delay=1, max_delay=60):
    """Calculate delay with jitter"""
    delay = min(base_delay * (2 ** attempt), max_delay)
    jitter = random.uniform(0.1, 0.9)
    return delay * jitter

def retry_with_backoff(func, max_attempts=5):
    for attempt in range(max_attempts):
        try:
            return func()
        except RateLimitError:
            if attempt == max_attempts - 1:
                raise
            delay = exponential_backoff(attempt)
            time.sleep(delay)
```text

### Batch Processing

**Efficient Batch Operations:**
```python
def batch_requests(items, batch_size=10):
    """Process items in batches to stay within rate limits"""
    results = []
    for i in range(0, len(items), batch_size):
        batch = items[i:i + batch_size]
        
        # Process batch
        batch_results = process_batch(batch)
        results.extend(batch_results)
        
        # Rate limit friendly delay
        if i + batch_size < len(items):
            time.sleep(1)  # 1 second between batches
    
    return results
```text

### Monitoring Usage

**Track Rate Limit Usage:**
```python
class RateLimitMonitor:
    def __init__(self):
        self.usage_log = []
    
    def log_request(self, response):
        rate_limit_info = {
            'timestamp': time.time(),
            'limit': response.headers.get('X-RateLimit-Limit'),
            'remaining': response.headers.get('X-RateLimit-Remaining'),
            'reset': response.headers.get('X-RateLimit-Reset')
        }
        self.usage_log.append(rate_limit_info)
    
    def get_usage_summary(self):
        if not self.usage_log:
            return None
        
        latest = self.usage_log[-1]
        usage_percentage = (
            (int(latest['limit']) - int(latest['remaining'])) / 
            int(latest['limit']) * 100
        )
        
        return {
            'usage_percentage': usage_percentage,
            'remaining_requests': latest['remaining'],
            'reset_time': latest['reset']
        }
```text

## WebSocket Rate Limits

### Real-Time Connections

**Connection Limits:**
```text
Free Plan: 1 concurrent connection
Pro Plan: 5 concurrent connections
Team Plan: 20 concurrent connections
Enterprise: Custom limits
```text

**Message Limits:**
```text
Messages per second: 10 (all plans)
Message size: 64KB maximum
Connection duration: 24 hours maximum
Reconnect throttling: 1 second minimum delay
```text

### WebSocket Events

**Event Rate Limits:**
```javascript
// Client-side rate limiting for WebSocket
class WebSocketRateLimit {
    constructor(maxMessages = 10, windowMs = 1000) {
        this.maxMessages = maxMessages;
        this.windowMs = windowMs;
        this.messages = [];
    }
    
    canSendMessage() {
        const now = Date.now();
        const cutoff = now - this.windowMs;
        
        // Remove old messages
        this.messages = this.messages.filter(time => time > cutoff);
        
        if (this.messages.length < this.maxMessages) {
            this.messages.push(now);
            return true;
        }
        
        return false;
    }
}
```text

## Regional Rate Limits

### Geographic Distribution

**Rate Limits by Region:**
```text
US East (Primary):
├── Standard rate limits apply
├── Lowest latency processing
└── Primary data center

US West:
├── Standard rate limits apply
├── Low latency processing
└── Secondary data center

Europe:
├── Standard rate limits apply
├── GDPR compliant processing
└── EU data residency

Asia-Pacific:
├── 90% of standard rate limits
├── Higher latency tolerance
└── Regional optimization ongoing
```text

### CDN and Edge Limits

**Static Content:**
- No rate limits on cached content
- 1GB bandwidth per user per day (Free)
- 10GB bandwidth per user per day (Pro)
- 100GB bandwidth per user per day (Team)

## Troubleshooting Rate Limits

### Common Issues

**1. Unexpected 429 Errors**
```text
Cause: Burst requests exceeding limits
Solution: Implement proper request spacing
Code: Add delays between requests
```text

**2. Inconsistent Rate Limit Behavior**
```text
Cause: Multiple API keys or shared IP addresses
Solution: Check API key usage in dashboard
Monitoring: Review rate limit headers
```text

**3. WebSocket Connection Drops**
```text
Cause: Exceeding connection or message limits
Solution: Implement connection pooling
Monitoring: Track WebSocket events
```text

### Debugging Tools

**Rate Limit Inspector:**
```bash
# Check current rate limit status
curl -H "Authorization: Bearer $API_KEY" \
     -I https://api.mixus.ai/v1/chat/completions

# Response headers show current limits
```text

**Usage Analytics:**
```javascript
// Browser-based rate limit monitoring
function checkRateLimit() {
    return fetch('/status', {
        method: 'HEAD',
        headers: {
            'Authorization': `Bearer ${apiKey}`
        }
    }).then(response => ({
        limit: response.headers.get('X-RateLimit-Limit'),
        remaining: response.headers.get('X-RateLimit-Remaining'),
        reset: response.headers.get('X-RateLimit-Reset')
    }));
}
```text

## Rate Limit Optimization

### Plan Upgrade Considerations

**When to Upgrade:**
- Consistently hitting 80% of rate limits
- Frequent 429 errors in logs
- Business needs require higher throughput
- Development teams need more API access

**Expected Improvements:**
```text
Free → Pro: 16.7x increase in API limits
Pro → Team: 10x increase in API limits
Team → Enterprise: Custom, typically 5x+ increase
```text

### Architecture Optimization

**Caching Strategies:**
- Implement Redis/Memcached for API responses
- Cache static content locally
- Use ETags for conditional requests

**Request Optimization:**
- Combine multiple operations in single requests
- Use GraphQL-style queries where available
- Implement request deduplication

## Support and Escalation

### Rate Limit Increases

**Temporary Increases:**
- Available for special events or launches
- Request through support channel
- Typically granted for 24-48 hours
- Requires business justification

**Permanent Increases:**
- Available for Enterprise plans
- Requires custom contract negotiation
- Includes SLA guarantees
- Dedicated support included

### Support Channels

**Rate Limit Support:**
- Documentation: This page and API docs
- Email support: support@mixus.com
- Priority support: Available for Pro+ plans
- Enterprise support: Dedicated account manager

## Next Steps

- [Understand storage limits](/limits/storage)
- [Learn about model limits](/limits/models)
- [Monitor your usage](/tokens/tracking)

## Related Resources

- [Platform Authentication](/security/authentication)
- [Token Usage](/tokens/how-it-works)
- [Billing & Pricing](/tokens/billing)