К содержимому
Блог

Rate limits LLM API: RPM, TPM и лимиты ключа Relay

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:

bash
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. Посмотреть заголовки можно минимальным запросом (он тарифицируется как обычный):

bash
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, который отдаёт прокси при недоступном шлюзе.

python
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.

Источники

Создать аккаунт

Готовы подключиться?Войдите в консоль, пополните баланс и создайте API-ключ.