Лимиты Claude API: полный гайд (2026)

Лимиты Claude API: полный гайд для 2026 года

Если вы разрабатываете приложения с использованием Anthropic Claude API, понимание rate limits критически важно. Наткнуться на лимит в неподходящий момент — и ваше приложение встанет, пользователи увидят ошибки, а очередь запросов начнёт накапливаться. В этом гайде разобраны все тарифные уровни, способы отслеживания приближения к лимитам и проверенные стратегии их graceful-обработки.

Как работают rate limits Claude API

Anthropic применяет rate limits к Claude API по трём измерениям одновременно:

Измерение	Что считает	Как сбрасывается
Запросов в минуту (RPM)	Количество API-вызовов	Скользящее 1-минутное окно
Входных токенов в минуту (ITPM)	Токены, отправленные в API	Скользящее 1-минутное окно
Выходных токенов в минуту (OTPM)	Токены, сгенерированные Claude	Скользящее 1-минутное окно

Лимит срабатывает при превышении любого из трёх измерений. Это значит, что даже если вы далеко не достигли порога по RPM, несколько очень длинных промптов могут максимально загрузить ваш лимит по входным токенам.

Тарифные уровни rate limit

Anthropic использует многоуровневую систему, основанную на истории использования аккаунта и суммарных расходах. По состоянию на начало 2026 года уровни выглядят следующим образом:

Tier 1 (Новые аккаунты)

Модель	RPM	Input TPM	Output TPM
Claude Opus 4	50	20,000	4,000
Claude Sonnet 4	50	40,000	8,000
Claude Haiku 3.5	50	50,000	10,000

Tier 2

Модель	RPM	Input TPM	Output TPM
Claude Opus 4	1,000	80,000	16,000
Claude Sonnet 4	1,000	160,000	32,000
Claude Haiku 3.5	2,000	200,000	40,000

Tier 3

Модель	RPM	Input TPM	Output TPM
Claude Opus 4	2,000	400,000	80,000
Claude Sonnet 4	2,000	800,000	160,000
Claude Haiku 3.5	4,000	1,000,000	200,000

Tier 4 (Высокий объём)

Модель	RPM	Input TPM	Output TPM
Claude Opus 4	4,000	2,000,000	400,000
Claude Sonnet 4	4,000	4,000,000	800,000
Claude Haiku 3.5	8,000	5,000,000	1,000,000

Примечание: Точные цифры могут отличаться. Anthropic периодически корректирует лимиты и может предоставлять кастомные лимиты для корпоративных аккаунтов. Актуальные данные всегда смотрите в официальной документации Anthropic.

Как проверить свой текущий уровень

Ваш уровень и текущие лимиты можно посмотреть в Anthropic Console в разделе Settings > Limits. Уровень повышается автоматически по мере накопления расходов на аккаунте со временем.

Заголовки ответа при rate limit

Каждый ответ API Claude содержит заголовки, показывающие ваше текущее положение относительно лимитов:

anthropic-ratelimit-requests-limit: 1000
anthropic-ratelimit-requests-remaining: 998
anthropic-ratelimit-requests-reset: 2026-02-06T12:01:00Z
anthropic-ratelimit-tokens-limit: 160000
anthropic-ratelimit-tokens-remaining: 145230
anthropic-ratelimit-tokens-reset: 2026-02-06T12:01:00Z

Заголовок	Значение
anthropic-ratelimit-requests-limit	Ваш лимит RPM
anthropic-ratelimit-requests-remaining	Запросов осталось в текущем окне
anthropic-ratelimit-requests-reset	Когда сбрасывается счётчик запросов
anthropic-ratelimit-tokens-limit	Ваш лимит токенов в минуту
anthropic-ratelimit-tokens-remaining	Токенов осталось в текущем окне
anthropic-ratelimit-tokens-reset	Когда сбрасывается счётчик токенов

Чтение заголовков в коде

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Claude!"}]
)

# Access rate limit info from the response headers
print(f"Requests remaining: {response._response.headers.get('anthropic-ratelimit-requests-remaining')}")
print(f"Tokens remaining: {response._response.headers.get('anthropic-ratelimit-tokens-remaining')}")
print(f"Resets at: {response._response.headers.get('anthropic-ratelimit-requests-reset')}")

Что происходит при превышении rate limit

При превышении любого измерения rate limit API возвращает 429 Too Many Requests:

{
  "type": "error",
  "error": {
    "type": "rate_limit_error",
    "message": "Number of request tokens has exceeded your per-minute rate limit (https://docs.anthropic.com/en/api/rate-limits); see the response headers for current usage. Please reduce the prompt length or the number of messages, and try again. You may also contact sales at https://www.anthropic.com/contact-sales to discuss your options for a rate limit increase."
  }
}

В ответе также есть заголовок retry-after, указывающий, сколько секунд нужно подождать перед повторной попыткой.

Стратегии обработки rate limit

Базовый экспоненциальный backoff

Самый простой подход — повторять попытки с экспоненциально увеличивающимися задержками:

import time
import anthropic

client = anthropic.Anthropic()

def call_claude_with_retry(messages, max_retries=5):
    for attempt in range(max_retries):
        try:
            response = client.messages.create(
                model="claude-sonnet-4-20250514",
                max_tokens=1024,
                messages=messages,
            )
            return response
        except anthropic.RateLimitError as e:
            if attempt == max_retries - 1:
                raise
            wait_time = (2 ** attempt) + 0.5  # 1.5s, 2.5s, 4.5s, 8.5s, 16.5s
            print(f"Rate limited. Retrying in {wait_time}s...")
            time.sleep(wait_time)

Использование заголовка `retry-after`

Более правильный подход — читать заголовок retry-after из ответа 429:

import time
import anthropic

client = anthropic.Anthropic()

def call_claude_with_retry_after(messages, max_retries=5):
    for attempt in range(max_retries):
        try:
            response = client.messages.create(
                model="claude-sonnet-4-20250514",
                max_tokens=1024,
                messages=messages,
            )
            return response
        except anthropic.RateLimitError as e:
            if attempt == max_retries - 1:
                raise
            # Use retry-after header if available, otherwise exponential backoff
            retry_after = getattr(e, 'response', None)
            if retry_after and retry_after.headers.get('retry-after'):
                wait_time = int(retry_after.headers['retry-after'])
            else:
                wait_time = 2 ** attempt
            print(f"Rate limited. Waiting {wait_time}s before retry {attempt + 1}...")
            time.sleep(wait_time)

Очередь запросов с учётом токенов

Для продакшн-систем, обрабатывающих много одновременных запросов, реализуйте очередь с учётом токенов:

import asyncio
import time
from dataclasses import dataclass

@dataclass
class RateLimitState:
    requests_remaining: int = 1000
    tokens_remaining: int = 160000
    reset_time: float = 0.0

class TokenAwareQueue:
    def __init__(self, client):
        self.client = client
        self.state = RateLimitState()
        self.lock = asyncio.Lock()

    async def call(self, messages, estimated_tokens=500):
        async with self.lock:
            # Wait if we are close to the limit
            if self.state.tokens_remaining < estimated_tokens:
                wait_time = max(0, self.state.reset_time - time.time())
                if wait_time > 0:
                    await asyncio.sleep(wait_time)

            response = await self.client.messages.create(
                model="claude-sonnet-4-20250514",
                max_tokens=1024,
                messages=messages,
            )

            # Update state from response headers
            headers = response._response.headers
            self.state.requests_remaining = int(
                headers.get('anthropic-ratelimit-requests-remaining', 0)
            )
            self.state.tokens_remaining = int(
                headers.get('anthropic-ratelimit-tokens-remaining', 0)
            )

            return response

Лучшие практики для соблюдения rate limits

1. Используйте подходящую модель для задачи

Не используйте Claude Opus там, где справится Claude Haiku. У Haiku выше лимиты и он значительно дешевле:

Задача	Рекомендуемая модель
Простая классификация	Haiku 3.5
Резюмирование	Sonnet 4
Генерация кода	Sonnet 4
Сложные рассуждения	Opus 4
Быстрое извлечение данных	Haiku 3.5

2. Сократите расход входных токенов

• Обрезайте системные промпты. Каждый запрос отправляет ваш системный промпт. Уберите лишние инструкции.
• Используйте резюме диалогов. Вместо отправки полной истории разговора — резюмируйте старые сообщения.
• Ограничивайте контекст. Включайте только тот контекст, который модели действительно нужен.

# Bad: Sending entire file content for a simple question
messages = [{"role": "user", "content": f"What language is this file? {entire_10000_line_file}"}]

# Good: Send only what's needed
messages = [{"role": "user", "content": f"What language is this file? First 20 lines:\n{first_20_lines}"}]

3. Обрабатывайте запросы пакетами

Если нужно обработать 100 элементов — не запускайте 100 одновременных запросов. Ограничивайте параллелизм:

import asyncio

async def process_batch(items, max_concurrent=5):
    semaphore = asyncio.Semaphore(max_concurrent)

    async def process_one(item):
        async with semaphore:
            return await call_claude(item)

    results = await asyncio.gather(*[process_one(item) for item in items])
    return results

4. Используйте Message Batches API

Для нагрузки без жёстких требований к времени ответа Batches API Anthropic позволяет отправлять до 10 000 запросов в одном пакете. Пакетные запросы имеют отдельные, значительно более высокие лимиты и обрабатываются в течение 24 часов со скидкой 50%.

batch = client.messages.batches.create(
    requests=[
        {
            "custom_id": f"request-{i}",
            "params": {
                "model": "claude-sonnet-4-20250514",
                "max_tokens": 1024,
                "messages": [{"role": "user", "content": prompt}],
            }
        }
        for i, prompt in enumerate(prompts)
    ]
)

5. Кэшируйте повторяющиеся запросы

Если несколько пользователей задают похожие вопросы — кэшируйте ответы:

import hashlib
import json

def get_cache_key(messages, model):
    content = json.dumps({"messages": messages, "model": model}, sort_keys=True)
    return hashlib.sha256(content.encode()).hexdigest()

6. Используйте кэширование промптов

Anthropic поддерживает кэширование промптов для системных промптов и длинного контекста. Закэшированные токены не учитываются в rate limit по входным токенам при последующих запросах и стоят на 90% дешевле:

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": "Your very long system prompt here...",
            "cache_control": {"type": "ephemeral"}
        }
    ],
    messages=[{"role": "user", "content": "Your question"}]
)

Мониторинг использования rate limit

Для продакшн-систем логируйте заголовки rate limit и настройте алерты:

• Алерт при 80% использования — чтобы успеть отреагировать
• Отслеживайте паттерны для выявления пиковых часов
• Мониторьте по модели — у каждой модели независимые лимиты

Когда запрашивать повышение rate limit

Если вы постоянно упираетесь в лимиты несмотря на оптимизацию — обратитесь в отдел продаж Anthropic за кастомным планом. Подготовьте:

• Текущие паттерны использования (RPM, TPM)
• Ожидаемый рост в течение следующих 3–6 месяцев
• Описание вашего сценария использования

Построение AI-приложений в масштабе

Rate limits — лишь одна часть головоломки при создании продакшн AI-приложений. Если ваш проект включает генерацию медиа (изображений, видео, аудио, аватаров) наряду с текстовой генерацией — рассмотрите использование единой API-платформы, такой как Hypereal AI. Она берёт на себя rate limiting, очередь запросов и повторные попытки для множества AI-моделей, чтобы вы сосредоточились на логике приложения, а не на инфраструктуре.

Итог

Управление rate limits Claude API сводится к трём принципам: знать свои лимиты (проверять заголовки), эффективно расходовать токены (правильная модель, минимальный контекст), и gracefully обрабатывать ошибки 429 (экспоненциальный backoff с retry-after). Внедрите эти стратегии — и ваше приложение останется надёжным даже под высокой нагрузкой.