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

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

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

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

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

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

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

Декодирование не может работать таким образом, так как токен 2 зависит от токена 1. Токен, который модель только что сгенерировала, становится частью входных данных для следующего шага, поэтому эти шаги нельзя выполнить одновременно. Каждый выходной токен требует отдельного прохода, и каждый такой проход считывает полный набор весов модели из памяти с высокой пропускной способностью для генерации всего одного токена. Это делает декодирование ограниченным пропускной способностью памяти: предел определяется скоростью передачи весов, а не скоростью их умножения. Тот же объем трафика весов, который при 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 — это время до получения первого токена (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'

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

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

{
  "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} без запуска модели и является бесплатным.

Стоимость 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. При переходе к более мощным моделям обе части стоимости умножаются на один и тот же коэффициент, поэтому общая сумма меняется, а соотношение входных и выходных токенов остается прежним.

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

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

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

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

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

FAQ

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

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

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

Нет. Кэширование промптов применяется только к входным данным. По состоянию на август 2026 года чтение из кэша стоит 0.1 от базовой ставки за входные данные, а запись в кэш стоит 1.25 от базовой ставки при хранении в течение 5 минут или 2 от базовой ставки при хранении в течение 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.