Limits and errors

#API allowances by plan

Your account’s policy version determines its allowances. Check Usage in the developer dashboard or Settings → Usage for the limits assigned to your account. A policy listed below is not a promise that it is active or available to purchase.

#Monthly calls by policy version

API access is available on Plus, Pro, Teams and Enterprise and is activated by our team. Contact us to request access. Teams and Enterprise allowances are set by agreement; your agreement defines monthly calls, request rates, concurrency, active keys and processing limits.

#Also applies to Plus and Pro

• Input per request: 16,000 bytes (UTF-8), counting the message, the conversation history and any other text you send.
• Output per answer: up to 4,096 tokens.
• Monthly calls reset at the start of each calendar month in UTC.
• Shared across keys: the per-minute and concurrent allowances apply to the whole account, not to each key.
• Pro plans: only the account owner can use the API.
• API requests still follow your account’s message, processing and web allowances. Processing and web allowances are shared with chat, Deep Research and Agent. Hosted Agent tasks have their own task allowance; their internal steps do not use monthly or purchased messages. Purchased messages do not increase API call or Agent task limits.

#Error format

{
  "error": "Error description",
  "code": "ERROR_CODE",
  "message": "User-facing explanation"
}

Branch on the HTTP status and code. Some errors add requestId, retryAfterSeconds or recovery details, and not every error uses exactly this shape. Include requestId when you contact support.

#Error codes

Other account and processing codes exist. Log and show the code and message you receive rather than replacing every failure with one generic error.

#Retrying safely

• Honor Retry-After when the response includes it, or retryAfterSeconds in the body.
• Otherwise back off exponentially, with jitter, and stop after a few attempts.
• Don’t retry authentication failures, invalid input, blocked content or a used-up monthly or compute allowance. They fail the same way until something changes.
• Retries can repeat work. The API doesn’t guarantee exactly-once processing or remove duplicate requests, so design your app to tolerate a request that ran twice.

import os
from pathlib import Path
import random
import time
import requests

URL = "https://praus.ai/api/chat/compound-pipeline-sync"
HEADERS = {"Content-Type": "application/json", "X-Api-Key": os.environ["PRAUS_API_KEY"]}

# Worth retrying after a pause. Everything else needs a fix, not a retry.
RETRYABLE = {"CONSUMER_API_RATE_LIMIT", "CONSUMER_API_CONCURRENCY_LIMIT",
             "AUTH_UNAVAILABLE", "INFERENCE_UNAVAILABLE", "SERVICE_UNAVAILABLE"}


def ask(body, attempts=5):
    for attempt in range(attempts):
        try:
            response = requests.post(URL, headers=HEADERS, json=body, timeout=120)
        except requests.ConnectionError:
            response = None  # network failure: retry
        if response is not None and response.ok:
            return response.json()["result"]["content"]

        data = response.json() if response is not None else {}
        code = data.get("code")
        if response is not None and code not in RETRYABLE and response.status_code < 500:
            raise RuntimeError(f"{response.status_code} {code}: {data.get('message')}")
        if attempt == attempts - 1:
            break

        wait = None
        if response is not None and response.headers.get("Retry-After", "").isdigit():
            wait = int(response.headers["Retry-After"])
        elif isinstance(data.get("retryAfterSeconds"), (int, float)):
            wait = data["retryAfterSeconds"]
        if wait is None:
            wait = min(30, 2 ** attempt) * random.uniform(0.5, 1.0)  # exponential backoff with jitter
        time.sleep(wait)

    raise RuntimeError(f"Gave up after {attempts} attempts (last code: {code})")

#Staying within your limits

• Run requests one at a time on Plus, or two at a time on Pro. Teams and Enterprise use the concurrency allowance in their agreement. Queue the rest in your app.
• Keep conversation history short. It counts toward the input allowance.
• Cache answers your app asks for repeatedly.
• If you need higher limits, tell us what you’re building.