Claude API и OpenAI API: цены и расчёт стоимости задач

При 20 000 обычных входных и 1 000 оплачиваемых выходных токенов стоимость одного запроса составляет 0,125 USD для Claude Opus 4.7 и 0,13 USD для GPT-5.5. Это расчёт по тарифам, проверенным 8 сентября 2026 года, без записи или чтения кэша и дополнительных услуг. Он показывает разницу в цене заданного числа токенов, но не доказывает, что одна модель дешевле выполнит ваш документ или напишет нужный код. Тарифы Anthropic, цены GPT-5.5.

Для выбора API нужно пройти ещё два шага: посчитать повторно используемый контекст и проверить стоимость результата, который вы действительно приняли. Ниже есть три законченных примера и небольшой калькулятор. Число запросов и токенов в примерах задано условно; это не результаты платных вызовов API и не сравнение качества моделей.

Какие модели и тарифы сравниваем

GPT-5.5 и Opus 4.7 включены для команд, которые продолжают использовать эти версии: их цены по-прежнему опубликованы в официальных документах. GPT-6 Astra и Claude Fable 5.1 добавлены как более новые модели с другими правилами кэширования. Такая подборка позволяет увидеть, почему формулу нельзя переносить между версиями без проверки.

Все ставки ниже указаны в USD за 1 миллион токенов, для прямого API и стандартной обработки. Для OpenAI используется строка короткого контекста. Региональные надбавки, услуги посредников, инструменты и хранение файлов в таблицу не включены. Это выбранные примеры, а не полный каталог и не утверждение о равных возможностях моделей. Текущая таблица OpenAI, таблица Anthropic.

У Opus 4.7 запись на 1 час стоит 10 USD за миллион токенов, у Fable 5.1 — 20 USD. Чтение Fable 5.1 стоит 0,025 от базовой цены входа, тогда как в примере с Opus 4.7 применяется 0,1. Поэтому правило «кэш Claude всегда стоит 10%» уже недостаточно точно.

У OpenAI отдельная плата за запись действует для GPT-5.6 и более новых моделей. У GPT-5.5 её нет: первый вход оплачивается по обычной ставке. Кроме цены различаются способы выбора границы кэша и срок хранения. Эти условия описаны в руководстве OpenAI по кэшированию и руководстве Anthropic.

Пример 1. Одна задача без кэша

Предположим, сервис обрабатывает документ. На один запрос приходится 20 000 обычных входных токенов и 1 000 выходных. Ни один токен в этом примере не относится к записи или чтению кэша. Дополнительных платных инструментов нет.

Формула для одного запроса:

text
Стоимость = (входные токены × ставка входа
           + выходные токены × ставка выхода) / 1 000 000

Для Opus 4.7: (20 000 × 5 + 1 000 × 25) / 1 000 000 = 0,125 USD.

Для GPT-5.5: (20 000 × 5 + 1 000 × 30) / 1 000 000 = 0,13 USD.

Разница между Opus 4.7 и GPT-5.5 здесь возникает только из-за цены выходных токенов. Если ответы имеют разную длину или одна модель требует дополнительного вызова, итог изменится. В одинаковом исходном тексте разные токенизаторы также могут насчитать разное число токенов: 20 000 для обеих сторон — условие примера, а не свойство любого документа.

Отсутствие попаданий в кэш не означает отсутствие записи. Например, если все 20 000 входных токенов Astra оплачены как новая запись по 12,50 USD, первый запрос с тем же выходом будет стоить уже 0,30 USD, а не 0,25. Для применения таблицы проверьте категории в usage; не считайте любой первый запрос автоматически «обычным входом».

Пример 2. Один контекст используется десять раз

Теперь у сервиса есть неизменная инструкция и справочный документ на 16 000 токенов. К ним в каждом запросе добавляются 4 000 новых токенов, а оплачиваемый выход составляет 1 000 токенов.

Условия расчёта:

• Всего 10 запросов, включая первый.
• Префикс из 16 000 токенов обрабатывается впервые один раз; следующие 9 обращений действительно читают его из кэша.
• Все запросы выполняются в пределах пяти минут, префикс не меняется.
• Новые 4 000 токенов каждого запроса оплачиваются как обычный вход и не записываются в кэш.
• Нет дополнительных вызовов инструментов и повторных попыток.

Условие о незаписываемой динамической части особенно важно для новых моделей OpenAI: неявная граница кэша может включить изменяющуюся часть запроса. В таком случае появятся дополнительные записи. Официальная документация предлагает явно поставить границу после стабильного содержимого и использовать prompt_cache_options.mode: "explicit", чтобы не записывать последующий изменяющийся текст. У GPT-5.5 кэширование неявное; объём фактического чтения нужно брать из ответа, а не считать весь совпадающий текст гарантированным попаданием.

Обозначим размер префикса как S, новый вход каждого запроса как D, выход как O, число запросов как N. Тогда:

text
Стоимость серии = (
    S × ставка первой обработки префикса
  + (N − 1) × S × ставка чтения кэша
  + N × D × ставка обычного входа
  + N × O × ставка выхода
) / 1 000 000

Полный расчёт для Opus 4.7 с пятиминутным кэшем:

text
Первая запись:   16 000 × 6,25 / 1 000 000 = 0,100 USD
Девять чтений:  144 000 × 0,50 / 1 000 000 = 0,072 USD
Новый вход:      40 000 × 5,00 / 1 000 000 = 0,200 USD
Весь выход:     10 000 × 25,00 / 1 000 000 = 0,250 USD
Итого:                                     0,622 USD

В этой серии Fable 5.1 и Astra имеют одинаковые базовые ставки входа и выхода, но более дешёвое чтение кэша у Fable уменьшает сумму на 0,108 USD. Это преимущество именно заданной серии с девятью попаданиями, а не доказательство общей экономичности платформы.

Когда первая запись окупается

Сравним только один и тот же префикс, оставив остальные расходы неизменными. Для Opus 4.7 обычная обработка стоит 5 USD за миллион токенов при каждом обращении.

Значения в этой таблице — USD за обработку префикса размером 1 миллион токенов указанное число раз. При префиксе другого размера они масштабируются пропорционально. Пятиминутная запись окупается после одного чтения, часовая — после двух чтений, если все эти чтения состоялись. Это соответственно два и три запроса вместе с первым.

Срок жизни кэша — TTL — меняет не только ставку записи, но и возможность повторного использования. Если в примере с Fable 5.1 выбрать запись на час и сохранить те же девять попаданий, сумма станет 1,256 USD вместо 1,136 USD. Если же пятиминутный кэш успевает истекать между обращениями, появятся новые записи и прежняя таблица перестанет описывать расход.

У новых OpenAI используется срок 30 минут, у Claude в нашем примере — 5 минут либо 1 час. Это разные условия хранения. Для GPT-5.5 значение 24h также не означает, что любой запрос в течение суток обязательно попадёт в кэш: документация описывает типичное сохранение примерно на 30 минут с возможностью удержания до 24 часов. Сумму подтверждают счётчики фактического использования.

Пример 3. Тысяча задач через Batch

Пакетная обработка подходит, если результаты нужны позднее: например, для ночного разбора документов или проверки набора ответов. Для текстовых запросов OpenAI и Anthropic публикуют скидку 50% на вход и выход. OpenAI Batch API, Anthropic Message Batches.

Возьмём 1 000 независимых запросов из первого примера: всего 20 миллионов обычных входных токенов и 1 миллион выходных, без записи и чтения кэша.

Например, для Opus 4.7 пакетные ставки равны 2,50 USD за вход и 12,50 USD за выход: 20 × 2,50 + 1 × 12,50 = 62,50 USD.

Не делите весь счёт приложения пополам: в нём могут быть инструменты, хранение, региональные надбавки и другие расходы. Здесь уменьшены только указанные входные и выходные токены. Также не предполагается, что повторяемый контекст автоматически даст попадания в кэш внутри пакета.

OpenAI описывает окно обработки до 24 часов. У Anthropic незавершённые за 24 часа запросы могут истечь. Проверяйте результат каждого элемента, а не только принятие пакета сервисом. Для интерактивного ответа пользователю такая задержка обычно не подходит; для ночной обработки она может быть приемлемой.

Как подставить свою нагрузку и не посчитать вход дважды

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

У Claude отдельные поля называются cache_creation_input_tokens и cache_read_input_tokens. Для смешанных сроков хранения записи дополнительно разделяются по TTL. У GPT-5.5 отдельная надбавка за запись не применяется, поэтому нельзя механически подставлять коэффициент новой линейки. Если поле отсутствует, сначала проверьте схему ответа своей версии API; неизвестное значение не следует выдавать за измеренный ноль.

Следующий калькулятор использует уже разделённые категории и тарифы таблицы. Он работает локально, не обращается к API и не обновляет цены автоматически. Сохраните его как api_cost.py и запустите python api_cost.py. При изменении тарифов сначала обновите соответствующую строку.

python
from decimal import Decimal

MILLION = Decimal(1_000_000)
# Ставки: обычный вход, первая обработка префикса, чтение, выход.
PRICES = {
    "GPT-5.5": ("5", "5", "0.5", "30"),
    "Opus 4.7 / 5m": ("5", "6.25", "0.5", "25"),
    "GPT-6 Astra / 30m": ("10", "12.5", "1", "50"),
    "Fable 5.1 / 5m": ("10", "12.5", "0.25", "50"),
}


def cost(ordinary, first_write, cached_read, output, prices):
    counts = (ordinary, first_write, cached_read, output)
    if any(type(n) is not int or n < 0 for n in counts):
        raise ValueError("Число токенов должно быть целым и неотрицательным")
    rates = tuple(Decimal(p) for p in prices)
    if len(rates) != 4 or any(not p.is_finite() or p < 0 for p in rates):
        raise ValueError("Нужны четыре неотрицательные конечные ставки")
    return sum(Decimal(n) * p for n, p in zip(counts, rates)) / MILLION


def repeated_cost(n, prefix, new_input, output, prices):
    if type(n) is not int or n < 1:
        raise ValueError("Нужен хотя бы один запрос")
    return cost(n * new_input, prefix, (n - 1) * prefix, n * output, prices)


if __name__ == "__main__":
    for name, prices in PRICES.items():
        one = cost(20_000, 0, 0, 1_000, prices)
        series = repeated_cost(10, 16_000, 4_000, 1_000, prices)
        batch = cost(20_000_000, 0, 0, 1_000_000, prices) / 2
        print(f"{name}: запрос={one:.3f}; серия={series:.3f}; Batch={batch:.2f} USD")

Параметр first_write в строке GPT-5.5 обозначает первый обычный вход этого префикса, а не отдельный оплачиваемый тип записи. Это позволяет сравнить серию одной формулой. Функция repeated_cost предполагает ровно одну первую обработку и попадание при каждом следующем обращении. Для реальных промахов суммируйте фактические категории через cost, а не увеличивайте ожидаемую долю попаданий.

Сравнивайте цену принятой задачи

Последний шаг — выполнить на каждой модели одинаковые по смыслу задачи и одинаково проверить результат: правильность фактов, нужные поля, пригодность к использованию. Затем разделить все реально начисленные расходы на число принятых результатов. В расходы входят и оплаченные попытки, которые пришлось переделать. Если не принят ни один результат, стоимость успешной задачи ещё не определена.

Записывайте отдельно количество вызовов, обычные и кэшированные токены, оплачиваемый выход, инструментальные расходы и принятые результаты. Не заменяйте эти величины числом слов или ценой самого первого ответа. Если модель справилась за один вызов, а другой понадобилось три, сравнивается весь путь до пригодного результата.

На больших контекстах, в ускоренном режиме или при требованиях к региону обработки повторно проверьте соответствующую строку цены: приведённые примеры используют 20 000 входных токенов и стандартную обработку. Для оплаты через посредника берите его тарифы по категориям; простой перевод официальной долларовой суммы в рубли может не описывать ваш счёт.

Если вопрос связан с ручной работой в Claude Code и выбором между подпиской и оплатой токенов, это другой расчёт: см. сравнение подписки и API для Claude Code. А для сравнения Claude и OpenAI в собственном приложении исходными данными остаются фактическое использование, ставка выбранной модели и проверенный результат задачи.