Perplexity API Errors and Rate Limits

import random
import time

from perplexity import Perplexity

client = Perplexity()
RETRYABLE = {429, 500, 502, 503, 504}

def create_with_retry(max_attempts: int = 6, **kwargs):
    for attempt in range(max_attempts):
        try:
            return client.responses.create(**kwargs)
        except Exception as error:
            status = getattr(error, "status_code", None)
            if status not in RETRYABLE or attempt == max_attempts - 1:
                raise  # 400/401/403 etc.: fix the request, don't retry

            # Prefer the server's Retry-After header when present
            response = getattr(error, "response", None)
            retry_after = response.headers.get("retry-after") if response is not None else None
            if retry_after and retry_after.replace(".", "", 1).isdigit():
                wait = float(retry_after)
            else:
                wait = min(60, 2 ** attempt) + random.uniform(0, 1)  # backoff + jitter

            print(f"{status}: retrying in {wait:.1f}s (attempt {attempt + 1})")
            time.sleep(wait)

answer = create_with_retry(preset="fast", input="What is the capital of Canada?")
print(answer.output_text)

// Node.js 18+ (ESM). Server-side only.
const RETRYABLE = new Set([429, 500, 502, 503, 504]);
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

export async function agentRequest(body, maxAttempts = 6) {
  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    const res = await fetch("https://api.perplexity.ai/v1/agent", {
      method: "POST",
      headers: {
        Authorization: `Bearer ${process.env.PERPLEXITY_API_KEY}`,
        "Content-Type": "application/json",
      },
      body: JSON.stringify(body),
    });
    if (res.ok) return res.json();

    const text = await res.text();
    if (!RETRYABLE.has(res.status) || attempt === maxAttempts - 1) {
      throw new Error(`Perplexity API ${res.status}: ${text}`);
    }
    const retryAfter = Number(res.headers.get("retry-after"));
    const wait = Number.isFinite(retryAfter) && retryAfter > 0
      ? retryAfter * 1000
      : Math.min(60000, 2 ** attempt * 1000) + Math.random() * 1000;
    await sleep(wait);
  }
}

const data = await agentRequest({ preset: "fast", input: "What is the capital of Canada?" });
console.log(data.output_text);

import asyncio
import time

from perplexity import AsyncPerplexity

client = AsyncPerplexity()

class RateLimiter:
    """Allow at most `qps` request starts per second."""
    def __init__(self, qps: float):
        self.interval = 1.0 / qps
        self.lock = asyncio.Lock()
        self.next_time = 0.0

    async def wait(self):
        async with self.lock:
            now = time.monotonic()
            if now < self.next_time:
                await asyncio.sleep(self.next_time - now)
            self.next_time = max(now, self.next_time) + self.interval

limiter = RateLimiter(qps=2.5)   # stay a little under your tier's limit (e.g. 3 QPS)

async def ask(question: str) -> str:
    await limiter.wait()
    response = await client.responses.create(preset="fast", input=question)
    return response.output_text

async def main():
    questions = [f"Give me one fact about the number {n}" for n in range(1, 11)]
    answers = await asyncio.gather(*(ask(q) for q in questions))
    for a in answers:
        print(a)

asyncio.run(main())