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

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

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

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

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

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

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

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

Системы обслуживания запросов решают эту проблему с помощью пакетной обработки (batching). Множество запросов декодируются одновременно, поэтому одно считывание весов позволяет сгенерировать по одному токену для каждого запроса в пакете. Именно поэтому декодирование вообще является экономически оправданным. Ограничивающим фактором снова становится память. Каждый активный запрос удерживает KV 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 — это время до получения первого токена (TTFT), в которое уложился весь процесс префилла (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'

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

Любой не потоковый ответ завершается статистикой, по которой производится тарификация.

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

Регистрируйте все четыре поля для каждого запроса. output_tokens включает в себя расширенный процесс мышления, поэтому модель, которая «размышляет» перед ответом, тарифицирует это время по ставке вывода. Чтобы рассчитать стоимость запроса до его отправки, используйте 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 подробно описано, как этот объём выглядит на практике.

В какой момент стоимость вывода начинает преобладать в счете?

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

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

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

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

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