Почему выходные токены Claude стоят дороже входных

Почему выходные токены стоят дороже входных

Выходные токены стоят в пять раз дороже входных у каждой модели Claude в текущем каталоге. Причина связана с характером вычислений. Модель обрабатывает prompt за один проход. Ответ она формирует по одному токену за проход, и каждый проход должен дождаться завершения предыдущего.

Это соотношение одинаково для каждой строки прайс-листа, поэтому выбранная модель не влияет на долю выходных токенов в счёте. Её определяет характер рабочей нагрузки. На шаге агента, который читает 60,000 токенов и отвечает 800 токенами, затраты на выходные токены почти отсутствуют. Задача подготовки черновика, которая читает 2,000 токенов и создаёт 12,000, почти не требует затрат на входные токены. Ниже оба случая разобраны на основе опубликованных Anthropic тарифов, проверенных 27 October 2026.

Префилл выполняется один раз, декодирование — один раз на каждый токен

Inference server обрабатывает запрос в два этапа с очень разной стоимостью. На этапе prefill он читает prompt. На этапе decoding он формирует ответ.

Prefill обрабатывает весь prompt сразу. Каждый токен prompt проходит через network в одном forward pass, поэтому операции attention и feed-forward сводятся к небольшому числу крупных matrix multiplication, которые одновременно охватывают тысячи токенов. Одного чтения model weights из памяти достаточно для обработки всего prompt. Matrix units accelerator загружены, поэтому prefill обычно ограничен вычислительной мощностью: предел задаёт скорость умножения матриц чипом. В документации NVIDIA по serving указаны исключения: очень короткие prefills и prefills, в которых длинный prefix уже найден в cache, становятся ограниченными пропускной способностью памяти.

Обычное decoding не может работать таким образом, потому что token 2 зависит от token 1. Токен, который только что сгенерировала модель, становится частью input для следующего шага, поэтому шаги выполняются последовательно. Для каждого output token требуется отдельный forward pass, и каждый такой проход считывает из high-bandwidth memory полный набор model weights, а также KV cache (key/value cache, сохранённое состояние attention для каждого уже обработанного токена), чтобы сформировать один токен. Поэтому decoding обычно ограничен пропускной способностью памяти: предел задаёт скорость перемещения weights и сохранённого состояния, а не скорость их умножения. Для длинных context NVIDIA отдельно выделяет чтение KV cache как узкое место. При prefill тот же объём операций с weights обрабатывает весь prompt, а при decoding позволяет получить только один токен.

Speculative decoding изменяет это правило, не нарушая его. Небольшая draft model предсказывает несколько следующих токенов, а большая model проверяет их параллельно за один проход. По словам NVIDIA, это может сместить decoding в сторону ограничения вычислительной мощностью. Большая model по-прежнему принимает предсказания по порядку и останавливается на первом неверном токене, поэтому длинный ответ всё равно требует много проходов.

Serving systems компенсируют это с помощью batching. Несколько запросов декодируются одновременно, поэтому одно чтение weights позволяет получить по одному токену для каждого запроса в batch. Поэтому decoding вообще остаётся доступным по стоимости. Ограничение снова связано с памятью. Каждый выполняемый запрос хранит собственный KV cache. Этот cache увеличивается с каждым сгенерированным токеном. Когда accelerator заполняется, batch больше не может увеличиваться.

Ничего из этого не даёт точного числа, поэтому не следует воспринимать 5x как измеренное соотношение для hardware. Это цена, установленная Anthropic с учётом этой асимметрии. Самостоятельно можно проверить направление различия. Это занимает около минуты.

Самостоятельно измерьте разрыв между входом и выходом

Установите инструменты на любом сервере Ubuntu:

sudo apt update && sudo apt install -y curl jq moreutils

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

curl -sN https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{"model":"claude-sonnet-5","max_tokens":1000,"stream":true,
       "messages":[{"role":"user","content":"Count from 1 to 300, one number per line."}]}' \
  | ts -s '%.s'

ts -s добавляет к каждой строке число секунд, прошедших с запуска команды. Из этого вывода важно понять две вещи. Время первой строки content_block_delta — это время до получения первого токена; весь prefill выполняется в этот период. Каждая следующая строка соответствует одному небольшому шагу декодирования, а временные метки увеличиваются, пока не появляется message_stop.

Теперь измените соотношение. Передайте в prompt длинный документ и ограничьте ответ несколькими токенами.

curl -sN https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d "$(jq -n --rawfile doc ./long-document.txt \
       '{model:"claude-sonnet-5", max_tokens:16, stream:true,
         messages:[{role:"user", content:("Answer in one word. Is this document about networking?\n\n" + $doc)}]}')" \
  | ts -s '%.s'

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

Каждый ответ без потоковой передачи заканчивается числами, на основании которых рассчитывается стоимость.

{
  "usage": {
    "input_tokens": 41283,
    "output_tokens": 6,
    "cache_creation_input_tokens": 0,
    "cache_read_input_tokens": 0
  }
}

Записывайте все четыре поля для каждого запроса. output_tokens включает токены рассуждений, поэтому модель, которая рассуждает перед ответом, тарифицирует эти токены по тарифу вывода. Чтобы узнать стоимость prompt до его отправки, POST /v1/messages/count_tokens принимает то же тело запроса для большинства запросов, возвращает {"input_tokens": N} в качестве оценки без запуска модели и не тарифицируется в пределах собственного rate limit. Он отклоняет несколько типов тел, которые принимает Messages API: большинство server tools, например web search, MCP connector, а также блоки изображений или документов с источником url или file. Поэтому при подсчёте передавайте изображения и PDF в формате base64. Это не единственная часть API, которая предоставляется бесплатно. Перед расчётом бюджета первого проекта стоит проверить, за какие части Claude API с вас никогда не взимается плата.

Сколько Claude взимает за миллион токенов по состоянию на October 2026

[
  {
    "label": "Haiku 4.5",
    "input_usd": 1,
    "output_usd": 5,
    "output_multiple": 5
  },
  {
    "label": "Sonnet 5",
    "input_usd": 2,
    "output_usd": 10,
    "output_multiple": 5
  },
  {
    "label": "Opus 5",
    "input_usd": 5,
    "output_usd": 25,
    "output_multiple": 5
  },
  {
    "label": "Fable 5",
    "input_usd": 10,
    "output_usd": 50,
    "output_multiple": 5
  }
]

В последнем столбце выходные данные разделены на входные, и в каждой строке указано значение 5. Haiku 4.5 взимает $1 за входные данные и $5 за выходные. Opus 5 взимает $5 и $25. Fable 5, самая дорогая модель, взимает $10 и $50, поэтому перед тем, как списывать верхнюю строку со счетов, стоит прочитать что дают эти тарифы Fable 5. При переходе вверх по диапазону обе стороны умножаются на один и тот же коэффициент. Поэтому меняется общая стоимость, но соотношение входных и выходных данных остаётся прежним.

Sonnet 5 взимает $2 за входные данные и $10 за выходные. Anthropic запустила модель по этому тарифу как вводную цену до 31 August 2026. С 1 September был запланирован рост до $3 и $15, но вместо этого стандартная цена стала равна $2 и $10. Повышение так и не вступило в силу. Поэтому во всех приведённых ниже примерах используется тариф, который действует сегодня.

С момента публикации этой страницы Anthropic также выпустила более новые модели. Сейчас claude.com/pricing относит четыре перечисленные выше модели к устаревшим, но по-прежнему доступным. Новые модели сохраняют то же соотношение 5x. Opus 5.5 взимает $4 и $20, Sonnet 5.5 — $2 и $10, Fable 5.1 — $10 и $50, а Haiku 5.5 — $0.10 и $0.50 для запросов объёмом до 100,000 токенов и $0.50 и $2.50 при большем объёме. Стоимость шага агента на 60,000 токенов, рассчитанная ниже, находится в пределах этого порога. Однако история агента, которая постоянно увеличивается, в конечном счёте его превысит. В материале как два тарифных уровня Haiku 5.5 проявляются в реальных задачах показано, как это влияет на счёт. Базовые тарифы Opus 5.5 на входные и выходные данные на 20% ниже, чем у Opus 5. Поэтому каждая приведённая ниже сумма для некэшированных данных Opus 5 на Opus 5.5 будет на 20% ниже. Для кэшированных данных стоимость снижается ещё сильнее: Opus 5.5 обрабатывает обращения к кэшу по $0.20 за миллион токенов, тогда как Opus 5 — по $0.50. Это снижение на 60%. Стоимость кэшированного шага агента, которая ниже для Opus 5 равна $0.0725, для Opus 5.5 составляет примерно $0.047, то есть примерно на 35% ниже.

Тарифы меняются, поэтому проверять их нужно не на этой странице. Источник актуальной информации — claude.com/pricing. Метод расчёта сохраняет актуальность даже после изменения цены.

Есть одна оговорка. Она приведена в примечаниях под таблицей тарифов Anthropic, а не в самих тарифах. На странице с тарифами Anthropic указано, что в Claude 4.7 и более поздних моделях используется новый токенизатор. Для одного и того же текста он создаёт примерно на 30% больше токенов, чем токенизатор в Sonnet 4.6 и более ранних моделях. Сравнение двух моделей только по цене за миллион токенов создаёт преимущество для более новой модели, поскольку один и тот же документ в ней содержит больше токенов. Сравнивайте стоимость завершённой задачи и учитывайте фактические запросы для модели, которую планируете использовать. Такая же проблема возникает при сравнении провайдеров, поскольку их токенизаторы также отличаются. Поэтому расчёт стоимости реальной задачи для Claude и ChatGPT даст больше информации, чем простое сопоставление двух тарифных таблиц. В материале сколько стоят миллион токенов Claude в реальном тексте показано, как этот объём выглядит на практике.

Когда стоимость вывода начинает доминировать в счете?

Поскольку цена вывода в 5 раз выше стоимости ввода, точку безубыточности легко рассчитать в уме. Обозначим входные токены как I, а выходные — как O. Затраты на ввод составляют I. Затраты на вывод составляют 5 умножить на O. Вывод начинает составлять более половины ваших расходов, когда 5 умножить на O больше, чем I, что соответствует соотношению 5 токенов ввода к 1 токену вывода.

Таким образом, если ваш промпт более чем в пять раз длиннее ответа, основной статьей расходов является ввод. Если меньше — вывод.

[
  {
    "label": "100:1",
    "input_share_pct": 95.2,
    "output_share_pct": 4.8
  },
  {
    "label": "75:1",
    "input_share_pct": 93.75,
    "output_share_pct": 6.25
  },
  {
    "label": "20:1",
    "input_share_pct": 80,
    "output_share_pct": 20
  },
  {
    "label": "10:1",
    "input_share_pct": 66.7,
    "output_share_pct": 33.3
  },
  {
    "label": "5:1",
    "input_share_pct": 50,
    "output_share_pct": 50
  },
  {
    "label": "1:1",
    "input_share_pct": 16.7,
    "output_share_pct": 83.3
  },
  {
    "label": "1:6",
    "input_share_pct": 3.2,
    "output_share_pct": 96.8
  }
]

При соотношении 100 к 1 вывод составляет 4.8% расходов, и единственное, что имеет смысл оптимизировать — это сокращение промпта. При соотношении 5 к 1 затраты уравниваются. При соотношении 1 к 6 вывод составляет 96.8% расходов, а промпт становится статистической погрешностью. Большинство людей ошибаются в оценке собственного соотношения, поэтому перед началом оптимизации извлеките данные из своих логов.

Рабочая нагрузка агента: большой объем контекста на входе, короткий ответ на выходе

Рассмотрим один шаг работы агента: 60,000 входных токенов из извлеченных документов и истории диалога и 800 токенов ответа. Это соотношение 75 к 1, что является нормальным для любой задачи, где чтение предшествует записи.

[
  {
    "label": "Haiku 4.5",
    "input_cost": 0.06,
    "output_cost": 0.004,
    "total_cost": 0.064
  },
  {
    "label": "Sonnet 5",
    "input_cost": 0.12,
    "output_cost": 0.008,
    "total_cost": 0.128
  },
  {
    "label": "Opus 5",
    "input_cost": 0.3,
    "output_cost": 0.02,
    "total_cost": 0.32
  },
  {
    "label": "Fable 5",
    "input_cost": 0.6,
    "output_cost": 0.04,
    "total_cost": 0.64
  }
]

На долю вывода приходится 6.25% стоимости такого вызова для любой модели, так как это соотношение фиксировано во всем прайс-листе. Вызов стоит $0.32 на Opus 5, $0.128 на Sonnet 5 и $0.064 на Haiku 4.5. Двести таких шагов в день на Opus 5 обходятся в $64 в день.

Рычаг управления становится очевиден, если посмотреть на распределение. Сокращение ответа с 800 до 400 токенов экономит около 3% стоимости вызова. Удаление 20,000 токенов устаревшего контекста из промпта экономит около трети стоимости. Оптимизация длины вывода для агента, ориентированного на чтение, практически бесполезна. В разделе на что на самом деле расходуются токены агента для написания кода подробно разбирается, чем именно заполняется промпт.

Рабочая нагрузка генерации: короткое задание, длинный черновик

Теперь рассмотрим обратную пропорцию. Бриф на 2,000 токенов, черновик на 12,000 токенов, соотношение 1 к 6.

[
  {
    "label": "Haiku 4.5",
    "input_cost": 0.002,
    "output_cost": 0.06,
    "total_cost": 0.062,
    "batch_total_cost": 0.031
  },
  {
    "label": "Sonnet 5",
    "input_cost": 0.004,
    "output_cost": 0.12,
    "total_cost": 0.124,
    "batch_total_cost": 0.062
  },
  {
    "label": "Opus 5",
    "input_cost": 0.01,
    "output_cost": 0.3,
    "total_cost": 0.31,
    "batch_total_cost": 0.155
  },
  {
    "label": "Fable 5",
    "input_cost": 0.02,
    "output_cost": 0.6,
    "total_cost": 0.62,
    "batch_total_cost": 0.31
  }
]

На вывод приходится 96.8% этой суммы. Opus 5 стоит $0.31 за черновик, а Haiku 4.5 — $0.062. Эта пятикратная разница почти полностью обусловлена выводом. Именно на нём более дешёвая модель позволяет сэкономить больше всего.

В последнем столбце указана та же задача через Batch API, который снижает стоимость ввода и вывода на 50%. Стоимость одного черновика для Opus 5 снижается до $0.155. Batch работает асинхронно, а не сразу. Anthropic сообщает, что большинство пакетных заданий завершается менее чем за час, но пакет, который всё ещё обрабатывается через 24 часа, истекает. Любой запрос, до которого система не дошла к этому моменту, также возвращается со статусом истёкшего срока, без начисления стоимости и без сообщения. Поэтому такой режим подходит для ночной генерации отчётов и массовой классификации, если предусмотреть повторную отправку всего, что истекло. Для задач, при которых человек ждёт результат, он не подходит.

Маршрутизация между моделями здесь даёт преимущество, которого нет на этапе работы агента. Если объёмная часть задачи носит механический характер — например, переформатирование текста или расширение уже утверждённого плана, — дешёвая модель создаёт эти токены по цене в пять раз ниже. В разделе выбор между Opus, Sonnet и Haiku объясняется, где на самом деле проходит граница качества.

Кэширование снижает стоимость входных данных, но не выходных

Кэширование промпта сохраняет его префикс на сервере и позволяет повторно читать его по доле тарифа за входные данные. По состоянию на 27 October 2026 запись кэша на 5 минут стоит 1.25x базового тарифа за входные данные, запись кэша на 1 час — 2x, а чтение при попадании в кэш для моделей с тарифами на этой странице — 0.1x. Новейшие модели читают данные из кэша дешевле: 0.05x для Opus 5.5 и Sonnet 5.5 и 0.025x для Fable 5.1.

Выходные данные в эту схему не входят. Кэширования выходных данных нет. Каждый токен, сгенерированный моделью, каждый раз оплачивается по полному тарифу за выходные данные независимо от того, какая доля промпта была получена из кэша.

Рассмотрим тот же шаг агента на Opus 5, при котором 55,000 из 60,000 входных токенов обслуживаются из прогретого кэша.

[
  {
    "label": "No cache",
    "input_cost": 0.3,
    "output_cost": 0.02,
    "total_cost": 0.32
  },
  {
    "label": "55k prefix cache read",
    "input_cost": 0.0525,
    "output_cost": 0.02,
    "total_cost": 0.0725
  }
]

Стоимость вызова снижается с $0.32 до $0.0725. Стоимость выходных данных не меняется: $0.02 до и $0.02 после. Кэширование уменьшает счёт и меняет его структуру. Выходные данные составляли 6.25% стоимости этого вызова. Теперь они составляют больше четверти стоимости, поэтому меняется следующий наиболее эффективный рычаг оптимизации.

Первый вызов оплачивает запись в кэш. Запись кэша на 5 минут стоит 1.25x базового тарифа за входные данные, поэтому окупается после одного попадания в кэш. Запись на 1 час стоит 2x, поэтому для окупаемости нужны два попадания. множители стоимости записи и чтения и условия, при которых кэширование перестаёт окупаться содержит расчёт.

Четыре рычага под вашим контролем

1. Устанавливайте max_tokens на уровне p95 длины вывода, а не на максимуме модели.
2. Передавайте подробные этапы более дешёвой модели.
3. Объединяйте в batch всё, для чего никто не ждёт результат.
4. Удаляйте инструкции, которые увеличивают объём ответов.

max_tokens — это жёсткий предел. Само по себе высокое значение ничего не стоит, поскольку оплата взимается за созданные токены, а не за установленный предел. Щедрый лимит лишь снимает ограничение с ответа, который пошёл не по плану. Извлеките распределение output_tokens из логов, установите лимит немного выше 95-го процентиля, а с stop_reason: "max_tokens" работайте в коде: продолжайте ответ или выполняйте повторную попытку. Обнаруженное усечение обходится дешевле, чем поток из 4,000 токенов, за который вы заплатите и который затем выбросите. Результат рассуждений также попадает в output_tokens и учитывается в max_tokens, поэтому рассчитывайте лимит на основе тех же данных. Для моделей с адаптивным рассуждением снизьте уровень усилий, если рассуждения постоянно занимают весь ответ.

Маршрутизация работает, когда дорогой частью этапа является объём, а не необходимость принимать решения. Оставьте сильную модель для принятия решения, а набор текста передайте более дешёвой модели. Сначала измерьте маршрутизируемый вариант на собственном наборе оценки, поскольку важна стоимость одной завершённой задачи. В приведённом выше этапе агента две попытки Haiku 4.5 стоят $0.128 против $0.32 за одну попытку Opus 5, поэтому разница в цене покрывает одну или две повторные попытки. Но она не покрывает неправильный ответ, который никто не обнаружит.

Batching — единственный рычаг, который снижает стоимость вывода. Скидка составляет 50% для обеих сторон, большинство batch завершается в течение часа, а задания по расписанию также подходят при условии, что задание повторно отправляет всё, срок действия чего истекает через 24 часа.

Последний рычаг часто игнорируют. Фразы вроде «будьте подробны» и «объясните ход рассуждений» увеличивают длину вывода каждого вашего запроса. Заменяйте их указанием нужного формата: «Ответьте не более чем в трёх предложениях» или «Верните только JSON-объект без вводного текста». Системный prompt, добавляющий 300 токенов к каждому ответу, стоит в пять раз дороже, чем те же 300 токенов в prompt. Материал о контроле затрат работающего агента посвящён мониторингу. Также стоит заранее решить что дешевле для вашего сценария: API или фиксированная подписка, прежде чем неделю оптимизировать расходы на отдельные токены, которые покрыла бы подписка. Для одного разработчика всё в основном сводится к тому, покрывают ли Claude Pro за $20 в месяц и связанные с ним лимиты использования работу, за которую в противном случае пришлось бы платить по счётчику. Если вы уже достигаете этих лимитов в середине сеанса, сначала нужно определить, какого окна вы ждёте, поскольку после этого решением может быть меньшая модель, более лёгкий контекст, дополнительные кредиты использования или перенос этой работы в API с оплатой по счётчику. Если API с оплатой по счётчику окажется более дешёвым вариантом для этой работы, переход на меньший план или отмена подписки сохранит уже оплаченный месяц, поэтому такой переход ничего вам не будет стоить. Если вы сравниваете Pro не с API с оплатой по счётчику, а с планом ChatGPT, две линейки подписок с ценами, приведёнными рядом показывают, какой вариант дешевле для работы с кодом. Если этот вопрос касается команды, а не одного разработчика, учтите, что Claude Enterprise сочетает плату за каждого пользователя с оплатой токенов по тем же тарифам API, поэтому каждый рычаг на этой странице по-прежнему применим к части счёта, которая оплачивается по счётчику.

FAQ

Почему выходные токены стоят дороже входных?

Их генерация требует значительно больше времени работы ускорителей на каждый токен. Промпт обрабатывается за один прямой проход по всему содержимому, поэтому одного чтения весов модели достаточно для обработки тысяч токенов, а производительность оборудования обычно ограничивается скоростью умножения. При обычном декодировании ответ формируется по одному токену за раз. Для каждого токена требуется отдельный прямой проход, который снова считывает веса модели и растущий KV cache, поэтому производительность оборудования обычно ограничивается пропускной способностью памяти. Такие методы, как speculative decoding, сокращают этот разрыв, но не устраняют его. Anthropic устанавливает цену на выходные токены, в 5 раз превышающую цену входных, для всего текущего каталога — от Haiku 5.5 до Fable 5.1.

Делает ли prompt caching выходные токены дешевле?

Нет. Prompt caching применяется только к входным данным. По состоянию на 27 October 2026 чтение из cache стоит 0.1x базовой ставки для входных данных в большинстве моделей, 0.05x для Opus 5.5 и Sonnet 5.5 и 0.025x для Fable 5.1. Запись в cache стоит 1.25x при длительности 5 минут или 2x при длительности 1 час. Выходные данные оплачиваются по полной ставке при каждом вызове независимо от того, что произошло с cache. Поэтому caching меняет не только размер счёта, но и его структуру: когда стоимость входных данных резко снижается, именно выходные данные становятся частью счёта, на которой стоит сосредоточиться.

Нужно ли платить за высокий max_tokens, если ответ получен коротким?

Нет. Оплата начисляется за токены, которые модель фактически сгенерировала, поэтому max_tokens — это верхний предел, а не резерв. Параметр всё равно важен, потому что это единственное жёсткое ограничение для ответа, который может стать чрезмерно длинным. Установите его немного выше 95-го перцентиля наблюдаемого значения output_tokens, а ситуацию с stop_reason: "max_tokens" обрабатывайте в коде, чтобы не отправлять пользователю ответ, молча обрезанный по длине.

Как определить собственное соотношение входных и выходных токенов?

Записывайте input_tokens, output_tokens, cache_read_input_tokens и cache_creation_input_tokens из объекта usage каждого ответа, затем разделите общие значения за неделю. Если на 1 выходной токен приходится более 5 входных, основная часть расходов связана с промптом. В этом случае кэшируйте стабильную часть и сокращайте остальное. Если соотношение ниже, основная часть расходов связана с ответом. Тогда ограничьте его длину, а шаги, которые генерируют большую часть ответа, перенесите в более дешёвую модель или в Batch API.