Rate limits

Rate limits cap how many requests and tokens you can use in a given window. Your limits are set by your tier, and each limit applies separately to your organization, each project, and each API key. The limits that currently apply to your organization, projects, and keys are shown on the Limits page in the Console.

How limits are measured

Limit	Counts
Requests per minute (RPM)	requests started per minute
Requests per day (RPD)	requests started per day
Tokens per minute (TPM)	input + output tokens per minute
Tokens per day (TPD)	input + output tokens per day
Concurrent requests	requests in flight at the same time

Every limit is enforced at three scopes — organization, project, and API key — and a request counts against all three.

Tiers

Your tier is the higher of two things:

your subscription plan, and
the spend tier you earn from your total lifetime payments.

Whichever is higher applies, so paying more — by subscription or by usage — only ever raises your limits.

Tier	Lifetime paid	Subscription
Free	—	Free
Tier 1	$20	Developer
Tier 2	$50	Growth
Tier 3	$200	Scale
Tier 4	$1,000	—
Tier 5	$5,000	—

A subscription sets your tier immediately. Spend accumulates over time and graduates you automatically — a free account that has paid $200 in usage reaches Tier 3 without a subscription.

Limits by tier

Values below are per API key.

Tier	RPM	TPM	Requests/day	Tokens/day	Concurrent
Free	60	1M	10,000	50M	4
Tier 1	120	2M	15,000	150M	8
Tier 2	300	4M	25,000	300M	12
Tier 3	500	6M	50,000	600M	16
Tier 4	700	8M	75,000	800M	32
Tier 5	900	10M	100,000	1B	32

Project limits are 1.5× and organization limits are 2× the per-key request and token values. Concurrent-request limits are set per scope:

Tier	API key	Project	Organization
Free	4	6	8
Tier 1	8	10	12
Tier 2	12	14	16
Tier 3	16	16	16
Tier 4–5	32	32	32

Rate limit headers

Every response reports your current usage. Header names match the OpenAI API.

Header	Meaning
`x-ratelimit-limit-requests`	request limit for the window
`x-ratelimit-remaining-requests`	requests remaining
`x-ratelimit-reset-requests`	time until the request window resets
`x-ratelimit-limit-tokens`	token limit for the window
`x-ratelimit-remaining-tokens`	tokens remaining
`x-ratelimit-reset-tokens`	time until the token window resets
`x-ratelimit-limit-project-tokens`	project token limit, when a project token limit is the constraint
`x-ratelimit-remaining-project-tokens`	project-scoped tokens remaining
`x-ratelimit-reset-project-tokens`	time until the project token window resets

Reset values are durations, like 42s. The request and token headers report the scope — key, project, or organization — that is closest to its limit.

When you hit a limit

A request over a limit returns 429 Too Many Requests with a Retry-After header (seconds to wait). The error body follows the OpenAI format on /v1/chat/completions and /v1/responses, and the Anthropic format on /v1/messages.

Error response body

{
  "error": {
    "message": "Rate limit exceeded.",
    "type": "rate_limit_error",
    "param": null,
    "code": "rate_limit_exceeded"
  }
}

{
  "type": "error",
  "error": {
    "type": "rate_limit_error",
    "message": "Rate limit exceeded."
  }
}

Honor Retry-After when it is present: wait at least that long, then add a small random delay so multiple clients do not retry at the same time. If it is absent, fall back to exponential backoff with jitter. Cap both the attempt count and the total retry time. Do not retry 401, 402, or 403; those require you to fix the key, add credits, or change scope.

Handle a 429

The official SDKs retry eligible 429s automatically and honor Retry-After. For most workloads, raise the retry count instead of writing your own loop. Expand an example below.

OpenAI SDK

The OpenAI SDKs retry 429 and transient errors with exponential backoff (2 attempts by default). Raise max_retries for bursty traffic.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.abliteration.ai/v1",
    api_key=os.environ["ABLIT_KEY"],
    max_retries=5,
)

# Or override per request:
resp = client.with_options(max_retries=5).chat.completions.create(
    model="abliterated-model",
    messages=[{"role": "user", "content": "Hello"}],
)

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.abliteration.ai/v1",
  apiKey: process.env.ABLIT_KEY,
  maxRetries: 5,
});

Pydantic AI

Pydantic AI calls abliteration.ai through the OpenAI SDK, so it inherits the same retry and Retry-After handling. Configure it on the AsyncOpenAI client you pass to the provider.

import os
from openai import AsyncOpenAI
from pydantic_ai import Agent
from pydantic_ai.models.openai import OpenAIChatModel
from pydantic_ai.providers.openai import OpenAIProvider

client = AsyncOpenAI(
    base_url="https://api.abliteration.ai/v1",
    api_key=os.environ["ABLIT_KEY"],
    max_retries=5,
)
model = OpenAIChatModel(
    "abliterated-model",
    provider=OpenAIProvider(openai_client=client),
)
agent = Agent(model)

For per-status retries or custom backoff, pass a retrying http_client. See OpenAI-compatible models in the Pydantic AI docs.

Anthropic SDK

On /v1/messages, the Anthropic SDKs retry 429 and honor Retry-After the same way.

import os
from anthropic import Anthropic

client = Anthropic(
    base_url="https://api.abliteration.ai",
    api_key=os.environ["ABLIT_KEY"],
    max_retries=5,
)

Custom backoff

To manage retries yourself, add exponential backoff with jitter. Each example sets max_retries=0 so the SDK’s own retries do not stack.

import os
from openai import OpenAI, RateLimitError
from tenacity import (
    retry,
    retry_if_exception_type,
    stop_after_attempt,
    wait_random_exponential,
)

client = OpenAI(
    base_url="https://api.abliteration.ai/v1",
    api_key=os.environ["ABLIT_KEY"],
    max_retries=0,
)


@retry(
    retry=retry_if_exception_type(RateLimitError),
    wait=wait_random_exponential(min=1, max=60),
    stop=stop_after_attempt(6),
)
def completion_with_backoff(**kwargs):
    return client.chat.completions.create(**kwargs)


completion_with_backoff(
    model="abliterated-model",
    messages=[{"role": "user", "content": "Hello"}],
)

import os
import backoff
from openai import OpenAI, RateLimitError

client = OpenAI(
    base_url="https://api.abliteration.ai/v1",
    api_key=os.environ["ABLIT_KEY"],
    max_retries=0,
)


@backoff.on_exception(backoff.expo, RateLimitError)
def completion_with_backoff(**kwargs):
    return client.chat.completions.create(**kwargs)


completion_with_backoff(
    model="abliterated-model",
    messages=[{"role": "user", "content": "Hello"}],
)

import os
import random
import time

from openai import OpenAI, RateLimitError

client = OpenAI(
    base_url="https://api.abliteration.ai/v1",
    api_key=os.environ["ABLIT_KEY"],
    max_retries=0,
)


def retry_with_exponential_backoff(
    func,
    initial_delay: float = 1,
    exponential_base: float = 2,
    jitter: bool = True,
    max_retries: int = 10,
    errors: tuple = (RateLimitError,),
):
    """Retry a function with exponential backoff."""

    def wrapper(*args, **kwargs):
        num_retries = 0
        delay = initial_delay
        while True:
            try:
                return func(*args, **kwargs)
            except errors:
                num_retries += 1
                if num_retries > max_retries:
                    raise Exception(f"Maximum number of retries ({max_retries}) exceeded.")
                delay *= exponential_base * (1 + jitter * random.random())
                time.sleep(delay)
            except Exception:
                raise

    return wrapper


@retry_with_exponential_backoff
def completion_with_backoff(**kwargs):
    return client.chat.completions.create(**kwargs)

Tenacity and backoff are third-party tools; abliteration.ai makes no guarantees about their reliability or security. The manual example is a starting point, not a complete solution; as written it honors neither Retry-After nor a total-time cap.

Reduce rate-limit errors

Read x-ratelimit-remaining-requests and x-ratelimit-remaining-tokens and slow down before you reach zero.
Cap retry attempts and total retry time. Every attempt, including failed ones, counts against your limit.
Raise your limits by subscribing or spending more; whichever tier is higher applies.

See pricing for per-token rates and plans to subscribe or buy credits.

Get started

Capabilities

Integrations

Policy Gateway

Reference

How limits are measured

Tiers

Limits by tier

Rate limit headers

When you hit a limit

Handle a 429

Reduce rate-limit errors

​How limits are measured

​Tiers

​Limits by tier

​Rate limit headers

​When you hit a limit

​Handle a 429

​Reduce rate-limit errors

How limits are measured

Tiers

Limits by tier

Rate limit headers

When you hit a limit

Handle a 429

Reduce rate-limit errors