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

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

Стоимость выходных токенов в пять раз превышает стоимость входных для каждой модели Claude в текущем каталоге. Причина заключается в структуре вычислений. Чтение промпта — это один проход по модели. Написание ответа — это один проход на каждый токен, при этом каждый последующий проход ожидает завершения предыдущего.

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

Этап Prefill выполняется один раз, декодирование — по одному разу на каждый токен

Сервер инференса обрабатывает запрос в две фазы с существенно различающимися затратами. Prefill считывает промпт. Декодирование записывает ответ.

На этапе Prefill весь промпт обрабатывается целиком. Каждый токен промпта поступает в нейронную сеть за один проход (forward pass), поэтому операции внимания (attention) и полносвязные слои (feed-forward) сводятся к небольшому количеству крупных матричных умножений, охватывающих тысячи токенов одновременно. Одно считывание весов модели из памяти обслуживает весь промпт. Матричные вычислители ускорителя работают с полной загрузкой, поэтому Prefill ограничен вычислительной мощностью: предел определяется скоростью выполнения умножений чипом.

Декодирование не может работать таким образом, так как токен 2 зависит от токена 1. Токен, который модель только что сгенерировала, становится частью входных данных для следующего шага, поэтому шаги нельзя выполнять параллельно. Каждый выходной токен требует отдельного прохода, и каждый такой проход считывает полный набор весов модели из памяти с высокой пропускной способностью (HBM) для генерации всего одного токена. Это делает декодирование ограниченным пропускной способностью памяти: предел определяется скоростью перемещения весов, а не скоростью их умножения. Тот же объем трафика весов, который при Prefill обрабатывал целый промпт, при декодировании дает лишь один токен.

Системы обслуживания запросов борются с этим с помощью пакетной обработки (batching). Множество запросов декодируются одновременно, поэтому одно считывание весов позволяет сгенерировать по одному токену для каждого запроса в пакете. Именно поэтому декодирование вообще является экономически оправданным. Ограничивающим фактором снова становится память. Каждый активный запрос удерживает KV cache (key/value cache, сохраненное состояние внимания для каждого сгенерированного токена), этот кэш растет с каждым новым токеном, и когда он заполняет память ускорителя, размер пакета больше увеличивать нельзя.

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

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

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

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

Теперь отправьте короткий запрос, требующий развернутого ответа, и добавьте временную метку к каждой строке вывода.

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 — это время до получения первого токена (Time To First Token), в течение которого выполняется весь процесс prefill. Каждая последующая строка — это один шаг декодирования, и временные метки будут увеличиваться до тех пор, пока не придет message_stop.

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

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'

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

Любой не потоковый (non-streaming) ответ завершается числами, на основе которых выставляется счет.

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

Регистрируйте все четыре поля для каждого запроса. output_tokens включает расширенный процесс мышления (extended thinking), поэтому модель, которая «размышляет» перед ответом, тарифицирует это время по ставке вывода. Чтобы рассчитать стоимость запроса до его отправки, используйте POST /v1/messages/count_tokens: этот метод принимает то же тело запроса, возвращает {"input_tokens": N} без запуска модели и является бесплатным. Это не единственная часть API, за которую не взимается плата, и перед планированием бюджета проекта стоит ознакомиться с тем, за какие части Claude API плата не взимается.

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

[
  {
    "label": "Haiku 4.5",
    "input_usd": 1,
    "output_usd": 5,
    "output_multiple": 5
  },
  {
    "label": "Sonnet 5 (to 31 Aug)",
    "input_usd": 2,
    "output_usd": 10,
    "output_multiple": 5
  },
  {
    "label": "Sonnet 5 (from 1 Sep)",
    "input_usd": 3,
    "output_usd": 15,
    "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 указана дважды, так как её вводный тариф ограничен по времени. До 31 августа 2026 года она стоит $2 и $10. С 1 сентября 2026 года начинает действовать стандартный тариф $3 и $15, что на 50% дороже для обеих сторон. Все приведенные ниже примеры расчетов используют августовские тарифы.

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

Есть один нюанс, который не отражен в прайс-листе. В документации 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 (Aug)",
    "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 токенов устаревшего контекста из промпта экономит около трети стоимости. Оптимизация длины вывода для агента с интенсивным чтением практически бесполезна. на что на самом деле расходуются токены агента для написания кода подробно описывает, чем именно заполняется промпт.

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

Теперь изменим подход. Краткое описание на 2000 токенов, черновик на 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 (Aug)",
    "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 за черновик против $0.062 у Haiku 4.5. Эта пятикратная разница почти полностью обусловлена объемом вывода, где использование более дешевой модели дает наибольшую экономию.

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

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

Кэширование промптов: скидки только на входные данные

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

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

Рассмотрим тот же шаг агента на 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 на уровне 95-го перцентиля (p95) длины вывода, а не на максимально возможном для модели значении.
2. Перенаправляйте подробные этапы работы на более дешевую модель.
3. Используйте пакетную обработку для задач, не требующих немедленного ответа.
4. Удалите инструкции, которые увеличивают объем ответов.

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

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

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

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

FAQ

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

Их генерация требует значительно больше времени работы ускорителя на каждый токен. Промпт обрабатывается за один прямой проход по всему тексту, поэтому одно чтение весов модели охватывает тысячи токенов, а производительность оборудования ограничивается скоростью операций умножения. Ответ создаётся по одному токену за раз, и для каждого токена требуется отдельный прямой проход, который снова считывает все веса модели, поэтому оборудование ограничивается пропускной способностью памяти. Anthropic устанавливает цену на вывод в пять раз выше, чем на ввод, для всего текущего каталога, от Haiku 4.5 до Fable 5.

Делает ли кэширование промптов выходные токены дешевле?

Нет. Кэширование промптов применяется только к входным данным. По состоянию на август 2026 года чтение из кэша стоит 0.1x от базовой ставки ввода, а запись в кэш стоит 1.25x при длительности 5 минут или 2x при длительности 1 час. Вывод оплачивается по полной ставке при каждом вызове, независимо от того, что было в кэше. Именно поэтому кэширование меняет структуру вашего счёта, а не только его размер: как только затраты на ввод сокращаются, вывод становится основной статьёй расходов, которую стоит оптимизировать.

Стоит ли мне денег высокий max_tokens, если ответ приходит коротким?

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

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

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