Rate limits LLM API: RPM, TPM и лимиты ключа Relay
Rate limit - это потолок на число запросов или токенов за окно времени. У вендоров моделей обычно три таких потолка: запросы в минуту, входные и выходные токены в минуту. Relay ограничивает свои запросы в минуту и число одновременных потоков, а расход ключа режет деньгами и отвечает на него другим кодом, 402, а не 429.
Коротко
429 в Relay приходит в трёх случаях: темп запросов (
rate_limited), слишком много одновременных потоков (concurrency_limit) и занятая мощность модели (pool_exhausted). Во всех трёх ждитеRetry-After.Лимит расходов ключа даёт 402
key_limit_exceeded. Деньги при этом не списываются, а повтор ничего не меняет.Свой потолок темпа читайте из
rate_limit_rpmвGET /v1/keyи держите клиента заметно ниже него.
Какие лимиты бывают у вендоров моделей?
Anthropic меряет лимиты на уровне организации и отдельно для каждого класса моделей: запросы в минуту (RPM), входные токены в минуту (ITPM) и выходные токены в минуту (OTPM). Запас пополняется непрерывно по схеме token bucket, а не обнуляется раз в минуту. Поэтому короткий всплеск может упереться в лимит, даже если среднее за минуту в норме. Всё это описано на странице лимитов Anthropic, по состоянию на 14 октября 2026 года.
Таблицы тарифных уровней я не переношу: они меняются, и устаревшая цифра в статье хуже, чем её отсутствие. Актуальные значения вендор показывает в своей консоли.
Через Relay эти потолки напрямую не видны. Заголовки anthropic-ratelimit-* шлюз клиенту не передаёт. Когда общая мощность под модель занята, вы получаете pool_exhausted с Retry-After, а не заголовки вендора. Токены в минуту Relay не считает: большой запрос упрётся в деньги (баланс, лимит ключа, потолок для новых аккаунтов), а не в отдельный токенный лимит.
Что ограничивает Relay?
| Что сработало | Ответ | Повторять | Что делать |
|---|---|---|---|
| Темп запросов ключа, аккаунта или адреса | 429 rate_limited | да, после Retry-After | снизить темп, поставить очередь |
| Слишком много одновременных потоков | 429 concurrency_limit | да, когда завершатся текущие | ограничить параллелизм |
| Мощность модели занята | 429 pool_exhausted | да, после Retry-After | подождать, при частом повторе сменить модель |
| Лимит расходов ключа: на весь срок, день или месяц | 402 key_limit_exceeded | нет | поднять лимит в настройках ключа или взять другой ключ |
| Баланс | 402 insufficient_balance | нет | пополнить баланс |
Темп считается и по ключу, и по аккаунту, и отказ любого из двух даёт 429. Отсюда практический вывод: несколько ключей одного аккаунта делят общий запас запросов. Добавить ключей, чтобы получить больше запросов в минуту, не получится. Отдельные ключи полезны для другого: у каждого свой лимит расходов и своя история в журнале запросов.
Текст сообщения подсказывает, какое окно сработало. В нём может быть названо, чей это лимит (this key, this account или this address), а рядом стоят число запросов в минуту и пауза до повтора. Вариант с адресом часто удивляет: код rate_limited получает и адрес, с которого много раз присылали неверные ключи. Если 429 появляется при вашем обычном темпе, проверьте, нет ли на общем адресе забытого скрипта с устаревшим ключом.
Лимит одновременности касается потоков и медиа-запросов. Обычный текстовый запрос без stream слот не занимает и упирается только в темп. Подсчёт токенов через POST /v1/messages/count_tokens лимитом не ломается: когда запросов на подсчёт слишком много, шлюз отвечает собственной оценкой и ставит заголовок x-token-count-estimated: true.
Как узнать, сколько запросов в минуту вам доступно?
Лимит ключа отдаёт метод GET /v1/key:
curl -s https://relay-llm.ru/v1/key -H "Authorization: Bearer $RELAY_API_KEY"В ответе поле rate_limit_rpm показывает запросы в минуту для этого ключа. Рядом лежат limits с установленными ограничениями расходов (total, day, month), вложенный объект limits.remaining с остатками по тем же трём полям, а также balance и spent. Описание полей есть в документации методов моделей и ключа. Ключу можно задать RPM ниже лимита аккаунта, выше нельзя.
Текущее окно показывают и заголовки ответа. Шлюз ставит x-ratelimit-limit-requests, x-ratelimit-remaining-requests и x-ratelimit-reset-requests на ответы инференса и на их 429. Берётся то окно, где осталось меньше всего запросов, ключа или аккаунта. Время сброса приходит строкой вроде 4s или 1m30.5s. Посмотреть заголовки можно минимальным запросом (он тарифицируется как обычный):
curl -s -D - -o /dev/null https://relay-llm.ru/v1/chat/completions \
-H "Authorization: Bearer $RELAY_API_KEY" \
-H "Content-Type: application/json" \
-d '{"model":"claude-sonnet-5","max_tokens":1,"messages":[{"role":"user","content":"ok"}]}' \
| grep -i '^x-ratelimit'Страница совместимости заголовки x-ratelimit-* не гарантирует. Я бы использовал их как подсказку для метрик, а решения о повторе строил на статусе, x-should-retry и Retry-After.
Как читать Retry-After?
На ответах 429, 502 и 503 шлюз присылает Retry-After целым числом секунд от 1 до 60. Заголовок x-should-retry приходит на каждой ошибке шлюза и отвечает на вопрос, имеет ли смысл повтор. Есть одно исключение: когда шлюз недоступен совсем, 503 отдаёт прокси перед ним. В таком ответе есть Retry-After и JSON с кодом service_unavailable, но нет x-should-retry и request_id. Считайте его временным. Потолок в 60 секунд не случаен: Claude Code в обычном режиме останавливает автоповторы, если Retry-After больше 60 (страница о шлюзах в документации Claude Code, на 14 октября 2026 года).
Если заголовка нет, как при 500 и 504, пауза растёт экспоненциально, с ограничением сверху и случайной добавкой. Разбор самой ошибки 429 и пример повтора на Node.js лежат в статье про 429 и Retry-After. Здесь важнее другое: как сделать так, чтобы до 429 не доходило.
Как построить очередь, чтобы лимит не срабатывал?
Окно в Relay пополняется равномерно. Вы можете выпустить весь минутный запас сразу, но дальше запросы проходят по одному через равные промежутки. Поэтому ровный темп надёжнее серий: серия съедает запас за секунды, и следующие запросы ждут.
Минимальная схема из двух частей. Темп задаёт пейсер: он держит блокировку, пока ждёт, и отсчитывает следующий интервал от фактической отправки, поэтому запросы выходят с интервалом, рассчитанным от rate_limit_rpm, даже если цикл событий на время задержался. Параллелизм ограничивает семафор: для потоков он страхует от concurrency_limit, для обычных запросов просто не даёт одному воркеру забить сеть. Порядок важен: слот берётся раньше пейсера. Если сделать наоборот, запросы пройдут пейсер, скопятся у занятого семафора и уйдут пачкой, как только слоты освободятся. После 429 запрос ждёт Retry-After и снова проходит через слот и пейсер, а не в обход них. Функция should_retry читает x-should-retry и допускает один случай без него: 503 с Retry-After, который отдаёт прокси при недоступном шлюзе.
import asyncio
import os
import random
import time
import httpx
BASE = "https://relay-llm.ru"
HEADERS = {"Authorization": f"Bearer {os.environ['RELAY_API_KEY']}"}
class Pacer:
def __init__(self, rpm: int, share: float = 0.8):
self.gap = 60 / (rpm * share)
self.next_at = 0.0
self.lock = asyncio.Lock()
async def wait(self) -> None:
async with self.lock:
delay = self.next_at - time.monotonic()
if delay > 0:
await asyncio.sleep(delay)
self.next_at = time.monotonic() + self.gap
def should_retry(response):
flag = response.headers.get("x-should-retry")
if flag is not None:
return flag == "true"
return response.status_code == 503 and "retry-after" in response.headers
async def ask(client, pacer, slots, prompt, attempts=4):
for attempt in range(attempts):
async with slots:
await pacer.wait()
response = await client.post(
f"{BASE}/v1/chat/completions",
headers=HEADERS,
json={
"model": "claude-sonnet-5",
"messages": [{"role": "user", "content": prompt}],
},
)
if response.is_success:
return response.json()
if not should_retry(response) or attempt == attempts - 1:
response.raise_for_status()
wait = int(response.headers.get("retry-after", "1"))
await asyncio.sleep(wait + random.uniform(0, 1))
async def main(prompts):
async with httpx.AsyncClient(timeout=httpx.Timeout(10.0, read=120.0)) as client:
info = (await client.get(f"{BASE}/v1/key", headers=HEADERS)).json()
pacer = Pacer(info["rate_limit_rpm"])
slots = asyncio.Semaphore(4)
return await asyncio.gather(*(ask(client, pacer, slots, p) for p in prompts))
if __name__ == "__main__":
answers = asyncio.run(main(["Привет"] * 10))
print(len(answers))Доля share=0.8 оставляет запас: тот же ключ и тот же аккаунт могут одновременно использовать другие процессы. Если на ключе работают Claude Code с субагентами и ваши скрипты, пейсер в одном процессе остальных не видит, а субагенты, по описанию самого Claude Code, шлют запросы параллельно. Складывайте темпы всех процессов и сравнивайте сумму с общим запасом аккаунта. Четыре слота семафора взяты для примера: для потоков увеличивайте число, пока не появится concurrency_limit, и вернитесь на шаг назад. Слот потока занят до конца потока, а не до первого фрагмента. Об очередях и накопившихся задачах подробнее в статье про параллельные запросы.
Какие метрики показывают приближение к лимиту?
Четыре величины ловят проблему до 429. Первая: число ответов 429 по кодам. rate_limited, concurrency_limit и pool_exhausted лечатся по-разному, поэтому складывать их в одну корзину нельзя. Вторая: x-ratelimit-remaining-requests как измеряемое значение, если заголовок пришёл. Третья: сколько времени запросы проводят в ожидании пейсера, рост означает, что очередь копится. Четвёртая: число занятых слотов семафора. Если оно подолгу упирается в потолок, потоки закрываются медленнее, чем приходят новые.
Что делать, если лимита не хватает?
Сначала проверьте, не создаёте ли вы нагрузку сами. Повторы без паузы множат поток: каждый отказ приводит к новым запросам. Параллельные воркеры без общего пейсера дают тот же эффект. Это чинится в клиенте и не требует нового лимита.
Если честная нагрузка стабильно упирается в потолок аккаунта, напишите в поддержку с request_id типичного 429 и описанием нагрузки. Решение о лимитах принимает Relay, а не клиентский код. Параметры ключа, включая лимиты расходов и RPM, описаны на странице ключей и доступа.
Мой порядок: сначала пейсер и семафор, потом повторы по Retry-After как страховка, и только потом разговор о лимитах. Повтор после 429 нужен, но как стратегия управления темпом он плох: клиент узнаёт о потолке, уже упёршись в него.
Чем RPM отличается от TPM?
RPM считает запросы в минуту независимо от их размера, TPM считает токены. Один очень длинный промпт может упереться в TPM, даже когда запросов мало. В Relay токены в минуту не лимитируются: ограничены запросы в минуту, число одновременных потоков и расход ключа в деньгах.
Сколько ждать после 429?
Столько, сколько указано в Retry-After: целое число секунд от 1 до 60. Раньше повторять нет смысла, запрос получит тот же ответ. Если заголовка нет, увеличивайте паузу от попытки к попытке и добавляйте случайную часть.
Почему исчерпанный лимит ключа даёт 402, а не 429?
Лимит расходов за секунды сам не освобождается. Суточный лимит обнуляется в начале нового дня по UTC, месячный в начале месяца, а лимит на весь срок действует, пока вы его не поднимете. До этого повтор получит тот же отказ. Код 402 key_limit_exceeded говорит об этом прямо, а деньги за такой запрос не списываются.
Можно ли опираться на заголовки x-ratelimit?
Как на подсказку для метрик и очереди можно. Страница совместимости не гарантирует их наличие, поэтому клиент должен работать и без них: решение о повторе принимайте по статусу, x-should-retry и Retry-After.
Источники
Rate limits, документация Anthropic, проверено 14 октября 2026 года.
Gateway compatibility guide, документация Claude Code, проверено 14 октября 2026 года.