Rate Limits#

X-RateLimit-Limit: 600
X-RateLimit-Remaining: 599
X-RateLimit-Reset: 1705318260

HTTP/1.1 429 Too Many Requests
Retry-After: 60

{
  "error": {
    "code": "RATE_LIMITED",
    "message": "Rate limit exceeded",
    "details": {
      "limit": 600,
      "reset_at": "2024-01-15T10:31:00Z"
    }
  }
}

import time
import random

def send_with_backoff(send_func, max_retries=5):
    for attempt in range(max_retries):
        try:
            return send_func()
        except RateLimitError as e:
            if attempt == max_retries - 1:
                raise

            # Exponential backoff with jitter
            delay = (2 ** attempt) + random.uniform(0, 1)
            time.sleep(delay)

import asyncio
from collections import deque

class RateLimitedQueue:
    def __init__(self, rate_per_second: float = 1.0):
        self.queue = deque()
        self.rate = rate_per_second
        self.last_request = 0

    async def enqueue(self, request):
        self.queue.append(request)
        await self._process()

    async def _process(self):
        while self.queue:
            now = time.time()
            wait_time = (1 / self.rate) - (now - self.last_request)

            if wait_time > 0:
                await asyncio.sleep(wait_time)

            request = self.queue.popleft()
            self.last_request = time.time()

            try:
                await request.execute()
            except RateLimitError:
                self.queue.appendleft(request)
                await asyncio.sleep(60)  # Wait for reset

class PlatformRateLimiter:
    LIMITS = {
        "whatsapp": {"per_second": 80, "daily": 1000},
        "telegram": {"per_second": 30},
        "slack": {"per_second": 1},
        "sms": {"per_second": 1},
    }

    def __init__(self, platform: str):
        self.limits = self.LIMITS.get(platform, {})
        self.window_start = time.time()
        self.request_count = 0

    def can_send(self) -> bool:
        now = time.time()

        # Reset window if needed
        if now - self.window_start >= 1:
            self.window_start = now
            self.request_count = 0

        # Check rate
        per_second = self.limits.get("per_second", float("inf"))
        return self.request_count < per_second

    def record_request(self):
        self.request_count += 1

query UsageStats {
  application {
    usage {
      messagesThisMonth
      apiCallsToday
    }
  }
}

@app.post("/webhook")
async def webhook(request: Request, background_tasks: BackgroundTasks):
    body = await request.json()
    background_tasks.add_task(process_webhook, body)
    return {"received": True}  # Return immediately

query RateLimitStatus {
  rateLimitStatus {
    limit
    remaining
    resetAt
    percentUsed
  }
}