Что такое токены в Claude и как работает их расчет

Что такое токены в Claude?

Токен — это единица текста, которую Claude читает и записывает; фрагмент слова. Согласно собственному глоссарию Anthropic, для моделей до Claude Opus 4.7 один токен составлял примерно 3,5 английских символа. В текущем токенизаторе это значение ближе к 2,5, так как Anthropic оценивает 1M токенов примерно в 2,5M символов. В любом случае, с учетом пробелов и знаков препинания, на одно слово приходится более одного токена, поэтому тысяча слов обычного текста — это уверенно более 1300 токенов. Код «весит» больше в пересчете на строку: фигурные скобки, операторы, символы подчеркивания и отступы разбиваются на большее количество токенов на символ, чем английский язык, и исходный файл на несколько сотен строк обычно занимает несколько тысяч токенов. Если агент решает прочитать файл на 2000 строк, это потребует покупки пятизначного количества токенов еще до того, как будет написана хотя бы одна строка нового кода.

Две особенности токенизаторов часто вводят пользователей в заблуждение. Во-первых, они зависят от модели. По состоянию на октябрь 2026 года, Claude Opus 4.7 и все последующие модели, включая текущие Fable 5.1, Opus 5.5, Sonnet 5.5 и Haiku 5.5, используют более новый токенизатор. Он генерирует примерно на 30% больше токенов для того же текста, чем ранние модели Claude, такие как Haiku 4.5 (точное увеличение зависит от контента). Это меняет любые бюджеты, рассчитанные в токенах, даже несмотря на то, что цена за токен при этом не выросла. Во-вторых, tiktoken, библиотека, к которой обращается каждая статья в блогах, — это токенизатор OpenAI, а не Claude, поэтому ее подсчеты не совпадут с тем, что выставляет к оплате Anthropic. Единственный надежный способ подсчета — это эндпоинт count_tokens, описанный ниже.

Почему сеанс программирования стоит именно столько

Любой счет за использование Claude, будь то инвойс API или лимит подписки, формируется в основном на основе одного показателя: входящих и исходящих токенов. Некоторые инструменты API добавляют свои пункты (например, веб-поиск по состоянию на октябрь 2026 года стоит 10 долларов за 1000 запросов сверх токенов, которые добавляют его результаты), но в сеансе программирования основной расход идет именно на токены. Страница с ценами выглядит просто: столько-то долларов за миллион входных токенов, столько-то за миллион выходных. Однако там не сказано, что в агентском сеансе программирования счетчик входных данных работает гораздо интенсивнее, чем кажется на первый взгляд, поскольку весь ход беседы отправляется заново при каждом обращении. Я занимаюсь продажей инфраструктуры с тарификацией по потреблению уже 15 лет, и токены — это первый показатель, при котором большинство клиентов искренне не понимают, что именно его накручивает. Этот урок посвящен чтению счетчика: что считается входными и выходными данными в агентском сеансе, почему цикл повторной отправки так дорог, почему кэширование промптов (prompt caching) меняет расчеты и какие рычаги действительно влияют на итоговую сумму.

Всё является входными данными: что на самом деле учитывает счетчик

Пользователи полагают, что платят за код, который пишет Claude. В агентской сессии это лишь небольшая статья расходов. Поэтому навыки, которые заставляют Claude отвечать в телеграфном стиле, экономят меньше, чем обещают: разбор навыка Caveman по цифрам его собственного README показывает сокращение вывода на 3% для /caveman и на 35% для /ultracave вместо вирусных 75%. Входные токены, имеющие более низкую стоимость, но значительно больший объем, включают:

• Системный промпт. Инструкции самой среды Claude Code, а также ваши файлы CLAUDE.md и файлы памяти, которые загружаются при запуске сессии и присутствуют в каждом последующем запросе.
• Определения инструментов. Каждая схема инструмента, который может вызвать агент. Каждый подключенный вами MCP server увеличивает эти фиксированные накладные расходы, хотя Claude Code теперь по умолчанию откладывает передачу полных определений инструментов MCP, поэтому в контексте остаются только имена инструментов до момента их первого использования, что снижает, но не устраняет затраты.
• Каждый файл, который читает агент. Команда Read для исходного файла помещает его содержимое целиком в контекст, где оно и остается.
• Каждый результат работы инструмента. Запуски тестов, вывод grep, данные из терминала, логи сборки — всё это возвращается в виде входных токенов. Непрошедший набор тестов, выводящий 8000 строк, по объему равен небольшой книге. По состоянию на октябрь 2026 года Claude Code по умолчанию передает в строке около 30000 символов вывода команды, а всё, что длиннее, сохраняется в файл с превью до 2000 символов, однако каждый вывод в пределах этого лимита, как и каждое последующее чтение сохраненного файла, оплачивается в полном объеме.
• Вся история беседы, повторно отправляемая на каждом шаге. Этот пункт заслуживает отдельного раздела.

Повторная отправка, которую никто не учитывает в цене

API Claude не имеет состояния. Он не запоминает сессию между запросами, никто этого не делает. Поэтому на шаге 2 клиент отправляет шаг 1, его ответ и ваше новое сообщение. На шаге 50 он повторно отправляет всё, что осталось в контексте с шага 1 по 49: каждый прочитанный файл, результат инструмента и diff, которые не были сжаты. (Сжатие заменяет старую историю кратким содержанием, а чтение файлов субагентом остается в его собственном контексте, возвращая только результат). Модель каждый раз перечитывает весь сохраненный транскрипт, и каждый из этих токенов при повторном чтении оплачивается как входной.

Следствие: стоимость одного шага растет примерно линейно с длиной сессии, а общая стоимость сессии растет примерно квадратично. Сообщение, которое стоило полцента на шаге 3, может стоить в двадцать раз больше на шаге 60 при том же однострочном вопросе, потому что оно несет на себе груз шестидесяти шагов. Это единственный факт, объясняющий большинство тикетов «почему мой счет такой большой», и это не особенность Claude: любой продукт на базе LLM, создающий ощущение наличия состояния, под капотом является API без состояния с циклом повторной отправки.

Выходные данные: то, что вы видите, плюс «мышление», которое вы не видите

Выходные токены — самые дорогие, их цена в пять раз выше входных в текущей линейке ($10/$50 для Fable 5.1, $4/$20 для Opus 5.5, $2/$10 для Sonnet 5.5, $0.10/$0.50 для Haiku 5.5 при промптах до 100000 токенов по состоянию на октябрь 2026 года). Выходные данные включают текст и код, которые генерирует Claude, а также токены мышления: внутренние рассуждения, которые модель выполняет перед ответом. Здесь важны два факта. Мышление оплачивается по тарифам выходных токенов и расходует max_tokens; ответ API, который прерывается с stop_reason: "max_tokens", часто означает, что мышление исчерпало бюджет раньше, чем был сформирован ответ. В текущих моделях краткое содержание рассуждений может вообще не отображаться: API по умолчанию скрывает его в Fable 5.1, Opus 5.5, Sonnet 5.5, Haiku 5.5 и более ранних моделях вплоть до Opus 4.7, но процесс мышления всё равно происходит и оплачивается. Невидимое не означает бесплатное.

Claude Code включает расширенное мышление по умолчанию, так как это заметно улучшает работу над многошаговыми задачами, и бюджет по умолчанию может достигать десятков тысяч токенов на запрос. В простых задачах его можно уменьшить: снизить уровень усилий с помощью /effort или в /model, либо отключить мышление в /config на моделях, которые это позволяют. По состоянию на октябрь 2026 года Claude Code не может отключить мышление в Opus 5.5, Sonnet 5.5, Haiku 5.5 или моделях Fable, поэтому рычагом управления здесь являются усилия. API предоставляет больше возможностей для двух из них. Haiku 5.5 принимает thinking: {"type": "disabled"} при высоком уровне усилий или ниже, как и более старые Opus 5 и Sonnet 5. Sonnet 5.5 отклоняет "disabled" и принимает thinking: {"type": "between_tools"}, что отключает предварительное мышление при низком, среднем или высоком уровне усилий, поэтому запрос без инструментов получает ответ без предварительного мышления. Только Opus 5.5 и модели Fable сохраняют мышление независимо от того, что вы отправляете. Это реальный рычаг управления затратами, а не суеверие.

Кэширование промптов меняет экономику

Кэширование промптов — это причина, по которой цикл повторной отправки запросов не приводит к финансовым потерям. API может кэшировать стабильный префикс вашего промпта, системный промпт, определения инструментов и историю диалога, а при следующем запросе использовать его за малую часть стоимости. По состоянию на октябрь 2026 года действуют следующие коэффициенты: запись в кэш стоит 1.25× от базовой цены входных токенов (2× для часового варианта), а чтение из кэша — 0.1× для большинства моделей, 0.05× для Claude Opus 5.5 и Claude Sonnet 5.5, и 0.025× для Claude Fable 5.1. Запись стоит дороже, зато чтение дает скидку 90% для большинства моделей, 95% для Opus 5.5 и Sonnet 5.5, и 97.5% для Fable 5.1. (Стоимость чтения для Sonnet 5.5 была снижена с 0.1× до 0.05× 7 октября 2026 года.) Одно чтение уже полностью окупает наценку за 5-минутную запись.

Claude Code управляет кэшированием автоматически, и при нормальной работе сессии почти весь объем повторно отправляемых данных берется из кэша. Однако кэш сбрасывается после периода неактивности. По состоянию на октябрь 2026 года Claude Code предоставляет для основного диалога часовой кэш при наличии подписки в рамках лимитов вашего плана, и пятиминутный кэш с момента последнего использования при работе через API key, облачного провайдера или при расходовании кредитов (настройкой promptCacheTtl можно запросить часовой кэш в этих случаях, с коэффициентом записи 2×). При пятиминутном кэше, если вы отвлеклись на долгий перерыв, а затем вернулись и отправили сообщение, кэш успевает истечь, и весь накопленный префикс перезаписывается с коэффициентом 1.25× вместо чтения по льготной ставке. В сессии на 150K токенов один такой «холодный» запрос приводит к записи всех 150K токенов по цене 1.25×, тогда как «горячий» запрос прочитал бы их по 0.1×. Это дает 12.5-кратную разницу для префикса (25-кратную для Opus 5.5 и Sonnet 5.5, 50-кратную для Fable 5.1). Важно усвоить этот контринтуитивный результат: ритм «простой — возобновление» может стоить дороже, чем непрерывная работа, так как каждый перерыв, превышающий TTL, превращает ваш следующий запрос из дешевого чтения в дорогую перезапись. Работайте сессиями; при пятиминутном кэше не отправляйте сообщения в огромной сессии по одному разу в десять минут.

Если вы обращаетесь к API из вашего собственного приложения на VPS, ничего из этого не происходит автоматически: вы должны активировать функцию через cache_control. Типичная ошибка — вставка временной метки или ID запроса в системный промпт. Это меняет байты префикса в каждом запросе и незаметно отключает кэширование. Признаком проблемы является нулевое значение usage.cache_read_input_tokens при внешне идентичных запросах.

Формула и пример расчёта

Не доверяйте утверждениям о том, что «сессия стоит $X». Стоимость сессий различается на два порядка. Единственный верный подход — использование формулы:

turn cost = (uncached input        x base input price)
          + (cache writes          x 1.25 x base input price)
          + (cache reads           x read multiplier x base input price)
          + (output incl. thinking x output price)

read multiplier = 0.10 on most models, 0.05 on Opus 5.5 and Sonnet 5.5, 0.025 on Fable 5.1
session cost = sum over all turns

Пример расчёта для Claude Opus 4.8. Это устаревшая модель, но она всё ещё доступна. По состоянию на октябрь 2026 года стоимость составляет $5 за миллион входных токенов и $25 за миллион выходных. Рассмотрим средний шаг сессии с накопленным контекстом в 80 000 токенов: 75 000 прочитано из кэша, 3 000 записано в кэш, 2 000 новых входных токенов без кэширования, 1 500 выходных токенов, включая процесс «мышления».

• Чтение из кэша: 75 000 × $0.50/M = $0.0375
• Запись в кэш: 3 000 × $6.25/M = $0.019
• Входные данные без кэша: 2 000 × $5/M = $0.010
• Выходные данные: 1 500 × $25/M = $0.0375

Итого около $0.10 за шаг. Пятьдесят таких шагов обойдутся примерно в $5. Теперь рассмотрим тот же шаг после истечения срока действия кэша: 78 000 кэшируемых токенов перезаписываются по цене $6.25/M, плюс те же 2 000 токенов без кэширования по $5/M. Это даёт около $0.50 до учёта выходных токенов — примерно в пять раз дороже, чем при «разогретом» кэше, при выполнении той же самой работы. Эта разница и есть суть кэширования в одном числе. Для актуальной модели Claude Opus 5.5 ($4/$20, чтение из кэша 0.05×) тот же «разогретый» шаг стоит около $0.07 (чтение $0.015, запись $0.015, входные данные без кэша $0.008, выходные данные $0.030), а «холодный» вариант обходится в $0.40 до учёта выходных токенов, что почти в шесть раз дороже. Эти четыре строки — единственный честный способ сравнения поставщиков, так как официальные тарифы полностью игнорируют чтение из кэша и затраты на «мышление». Проверка на трёх реальных задачах показывает, в каких случаях счёт от Claude оказывается выше или ниже счёта от OpenAI.

Если вам нужно понять суть единицы биллинга, а не стоимость одного шага, расчёт миллиона токенов в страницах, файлах и долларах выполняет ту же арифметику на уровень выше. Для калибровки, а не прогнозирования: опубликованные Anthropic данные для корпоративных внедрений Claude Code по состоянию на октябрь 2026 года показывают средний расход около $13 на разработчика в активный день, или от $150 до $250 в месяц, при этом 90% пользователей тратят менее $30 в день. Итоговая сумма зависит от выбора модели, гигиены сессий и размера кодовой базы — именно поэтому важны рычаги управления, описанные ниже.

Просмотр собственной статистики использования

В Claude Code используется команда /usage (/cost также работает, это псевдоним). Блок Session в верхней части экрана отображает статистику токенов и локально рассчитанную стоимость текущей сессии; при наличии подписки на этом же экране отображаются индикаторы лимитов вашего тарифного плана, а также детализация использования, распределенная по навыкам, субагентам, плагинам и отдельным MCP-серверам. В последних версиях блок Session также содержит строку Prompt cache (main), показывающую долю входных данных, полученных из кэша, количество промахов кэша и текущее состояние прогрева кэша. Для получения точных данных о биллинге в аккаунтах API используйте страницу использования в Claude Console — она является единственным достоверным источником, в то время как данные CLI являются лишь оценочными. Команда /context выводит цветную сетку того, что занимает контекстное окно, включая системный промпт, инструменты, определения MCP, файлы и историю. Это самый быстрый способ обнаружить перегруженный CLAUDE.md или слишком «разговорчивый» MCP-сервер; используйте флаг all, чтобы развернуть полную детализацию по каждому элементу.

При работе через API каждый ответ содержит точную информацию о произошедшем:

response = client.messages.create(model="claude-sonnet-5-5", max_tokens=2048,
                                  messages=messages)
u = response.usage
total_prompt = u.input_tokens + u.cache_creation_input_tokens + u.cache_read_input_tokens
print(f"uncached={u.input_tokens} written={u.cache_creation_input_tokens} "
      f"read={u.cache_read_input_tokens} output={u.output_tokens}")

Обратите внимание, что input_tokens — это только некэшированный остаток, а реальный размер промпта представляет собой сумму всех трех полей ввода. Агент, который работал в течение часа и показал input_tokens: 4000, не является дешевым; остальные 200 000 токенов были получены из кэша. Чтобы оценить стоимость перед отправкой запроса, используйте эндпоинт для подсчета токенов. Его вызов бесплатен, он имеет собственный лимит запросов и выполняет подсчет с использованием токенизатора выбранной вами модели (рассматривайте результат как близкую оценку; биллинг основывается на реальном запросе):

count = client.messages.count_tokens(model="claude-sonnet-5-5",
                                     messages=[{"role": "user", "content": big_file}])
print(count.input_tokens)

Никогда не используйте tiktoken по указанной выше причине.

Тарифные планы против оплаты по факту использования

Механика работы в этом руководстве везде одинакова; различается только порядок расчетов. При использовании API-ключа Anthropic выставляет счета по факту использования, за каждый токен, по опубликованным тарифам; все указанные выше цифры — это реальные деньги. Тарификация начинается раньше, чем ожидает большинство пользователей, так как бесплатного уровня нет: есть только небольшой кредит при регистрации и несколько эндпоинтов, которые не тарифицируются. Это то, что получает новый API-аккаунт до привязки банковской карты. Исключением с 7 октября 2026 года являются подписки Max или Team: эти планы теперь включают ежемесячные API-кредиты для ваших собственных приложений и агентов на платформе Claude — 100 долларов в месяц на Max 5x и 200 долларов на Max 20x, а в плане Team — 20 долларов на стандартное место и 100 долларов на премиальное место (общий лимит — 500 долларов). Кредиты активируются путем привязки организации в консоли, неиспользованные остатки сгорают в конце каждого расчетного периода, и они не покрывают использование Claude Code в интерактивном режиме. При наличии подписки на Claude (Pro, Max, Team и устаревшие планы Enterprise с оплатой за место) использование Claude Code расходует лимит вашего плана: по состоянию на октябрь 2026 года это скользящее пятичасовое окно сессии плюс еженедельное окно, общие для всех моделей и чата claude.ai, а сумма в /usage долларов носит информационный характер, а не является счетом. Два исключения на октябрь 2026 года: текущие Enterprise-места с оплатой по факту использования не включают лимитов, поэтому каждый токен оплачивается по стандартным тарифам API, а модели Fable не входят в лимит на планах Pro, стандартных местах Team или стандартных устаревших местах Enterprise, где они работают за счет кредитов на использование. Если окно исчерпано, вы увидите сообщение "You've hit your session limit" или "You've hit your weekly limit" с указанием времени сброса; переключение моделей с помощью /model не восстановит доступ, так как окна общие для всех моделей. Эти окна привязаны к аккаунту, а не к клиенту, в котором вы работаете, что полезно знать, если вы еще разбираетесь, что работает на Linux нативно и какой план покрывает каждую платформу. То, какое именно из двух окон вы исчерпали, определяет время ожидания и то, что стоит делать в это время, поэтому полезно знать ваши варианты при достижении лимита в процессе выполнения задачи. В планах можно опционально включить кредиты на использование, управляемые через /usage-credits, чтобы оплачивать работу сверх установленного лимита. Я намеренно не привожу квоты планов: это самые изменчивые цифры во всей теме, поэтому проверяйте claude.com/pricing и свои собственные индикаторы /usage. Механика токенов важна и при подписке: неэффективная сессия расходует ваше окно точно так же, как она расходовала бы доллары. Информацию о подписках см. в какой план Claude подходит для вашего использования.

Рычаги, которые действительно работают

• Ограничивайте область чтения агента. Запрос «исправь ошибку валидации в auth.py» заставляет прочитать один файл, а «улучши эту кодовую базу» — сорок. Держите CLAUDE.md в минимальном объеме: он загружается в каждую сессию, поэтому оставьте там только самое необходимое, а специфические для рабочего процесса инструкции перенесите в навыки, которые загружаются по требованию.
• Будьте кратки и лаконичны. /clear между несвязанными задачами: устаревший контекст повторно отправляется и оплачивается при каждом последующем сообщении. В рамках одной длительной задачи /compact Focus on the failing tests and the diff позволяет сократить историю и избежать квадратичного роста затрат.
• Выбирайте подходящую модель. Sonnet справляется с большинством задач программирования по цене $2/$10 за миллион токенов по состоянию на октябрь 2026 года; это стандартная цена, а не вводная. Sonnet 5.5 стоит $2/$10, а Sonnet 5 сохранил цену $2/$10 после того, как запланированное на 1 сентября повышение до $3/$15 было отменено. Для сравнения: Opus 5.5 стоит $4/$20, а Haiku 5.5 за $0.10/$0.50 (для промптов до 100,000 токенов, $0.50/$2.50 при превышении этого объема) — подходящий инструмент для механической работы вспомогательных агентов, например, для сортировки логов. Fable 5.1 находится на другом конце спектра с ценой $10/$50, что соответствует тарифу Fable 5 и в два с половиной раза дороже Opus 5.5 по обоим показателям, поэтому стоит понимать, какие задачи действительно оправдывают такую стоимость, прежде чем оставлять эту модель для рутинной работы. /model позволяет переключаться в середине сессии.
• Предварительно фильтруйте объемный вывод. Хук, который с помощью grep оставляет в результатах тестирования только ошибки перед тем, как их увидит Claude, превращает 20,000 токенов результата работы инструмента в 300, и это экономит ресурсы при каждой последующей отправке этого этапа.
• Пакетная обработка для неинтерактивных задач. Для ваших API-конвейеров, классификации, массовой проверки и ночных заданий Batches API позволяет использовать те же модели со скидкой 50% в обмен на асинхронную доставку.
• Учитывайте время жизни кэша. Работайте непрерывными сессиями. Отсоединенная сессия Claude Code в tmux на VPS ничего не стоит в режиме ожидания, токены расходуются только при выполнении запроса. Однако простой, превышающий TTL кэша, приводит к его сбросу, и следующий запрос потребует оплаты за повторную запись.

FAQ

Сколько токенов расходует сессия программирования в Claude Code?

Фиксированного числа нет. Один запрос в середине сессии часто содержит десятки тысяч токенов промпта по мере накопления файлов и истории, а рабочая сессия в сумме достигает миллионов. Большая часть этих данных обслуживается из кэша по цене, составляющей десятую часть от базового тарифа или меньше, в зависимости от модели. Для ориентира: опубликованные Anthropic корпоративные показатели на октябрь 2026 года составляют в среднем около $13 на разработчика в день активной работы, при этом у 90% пользователей затраты не превышают $30. Запустите /usage в своей сессии; пять минут наблюдения за этим инструментом дадут более точное представление, чем любая опубликованная статистика.

Оплачиваются ли «токены мышления», даже если я их не вижу?

Да. Токены мышления тарифицируются как выходные токены (по более высокой ставке) и учитываются в max_tokens. Текущие модели выставляют за них счет, даже если интерфейс скрывает сводку рассуждений от пользователя. Если ответ обрывается с stop_reason: "max_tokens" до завершения видимой части, значит, бюджет был исчерпан процессом мышления. В Claude Code для задач, не требующих глубоких рассуждений, снижайте уровень усилий с помощью /effort.

Почему длинная сессия Claude Code становится дороже с каждым сообщением?

Потому что API не сохраняет состояние: каждый запрос повторно отправляет всю историю диалога, находящуюся в контексте, все прочитанные файлы, результаты работы инструментов и предыдущие обмены данными, которые не были сжаты. Таким образом, 50-й запрос несет в себе «груз» с 1-го по 49-й. Кэширование промптов позволяет обрабатывать повторяющийся префикс по цене в одну десятую от базовой стоимости входных данных на большинстве моделей (5% на Opus 5.5 и Sonnet 5.5, 2.5% на Fable 5.1), но сам префикс постоянно растет. Любой простой, превышающий TTL кэша, превращает следующий запрос в полноразмерную оплату. /compact сокращает историю; /clear сбрасывает её.

Как проверить использование токенов и расходы в Claude Code?

В Claude Code команда /usage выводит статистику токенов сессии, локальную оценку стоимости и индикаторы лимитов подписки (/cost — это псевдоним); /context показывает, что именно заполняет контекстное окно. Для получения официальных данных по биллингу API используйте страницу использования в Claude Console. В собственном коде считывайте response.usage: суммирование input_tokens, cache_creation_input_tokens и cache_read_input_tokens дает точный размер промпта. Оценивайте затраты заранее с помощью эндпоинта count_tokens, но никогда не используйте для этого tiktoken.