Работа с ИИ измеряется и оплачивается не словами и не запросами, а токенами. Понимать их нужно по двум причинам: из токенов складывается стоимость (иногда неожиданно большая), и в токенах измеряется контекст — сколько модель вообще может «удержать» за раз.

Обязательно

Что такое токен

Модель не работает с буквами или словами напрямую — она разбивает текст на токены: в английском тексте это кусочки примерно в 3–4 символа. Короткое частое слово («кот», «the») — один токен; длинное или редкое слово разбивается на несколько. Код токенизируется тоже: скобки, отступы, имена переменных — всё это токены.

Грубый ориентир: один токен ≈ 0,75 слова для английского; для русского и для кода токенов на тот же текст заметно больше — кириллица режется мельче. Страница английского текста — это несколько сотен токенов, такая же страница по-русски — ближе к тысяче.

Точное число знать наизусть не нужно — важно чувствовать масштаб: длинный документ или большой файл кода, отданные модели, — это тысячи токенов, и они не бесплатны.

Входные и выходные токены

Каждое обращение к модели считает токены с двух сторон:

  • Входные (input) — всё, что вы отправили: ваш запрос, приложенные файлы, история переписки, системные инструкции. Модель «читает» это целиком каждый раз.
  • Выходные (output) — всё, что модель сгенерировала в ответ.

Обычно выходные токены дороже входных, и причина в устройстве: вход модель обрабатывает разом, за один проход, а выход рождается по токену за проход — сколько токенов в ответе, столько и проходов. И важный неочевидный момент: в диалоге история накапливается — каждый следующий запрос тащит за собой всю предыдущую переписку как входные токены. Длинный разговор дорожает с каждым ходом, даже если ваши реплики короткие.

ход 1 правила реплика 1 ход 2 правила ход 1 реплика 2 ход 3 правила ход 1 ход 2 реплика 3 ход 4 правила ход 1 ход 2 ход 3 реплика 4

Вход каждого следующего хода длиннее предыдущего: неизменное начало (правила и описания инструментов) кешируют, а история тянется целиком и оплачивается заново.

Как складывается стоимость

Цена считается за токены (обычно за миллион токенов, отдельно за вход и выход). Практические следствия для продукт-инженера:

  • Большой контекст стоит денег. Отдать модели весь репозиторий «на всякий случай» — дорого и часто вредно для качества (см. контекст). Давайте релевантное, а не всё подряд.
  • Длинные диалоги накапливают стоимость. Иногда дешевле начать новый разговор с чистого листа, чем тащить огромную историю.
  • Автоматизация умножает цену. Один запрос стоит копейки, но агент, делающий сотни шагов в цикле, или обработка тысяч элементов — это уже заметные суммы. Прикидывайте стоимость до запуска на объёме.
  • Модели разного размера — разная цена. Мощная модель дороже за токен. Не для каждой задачи нужна самая сильная — простое стоит отдать модели попроще.
  • Размышления считаются выходом. У моделей с режимом рассуждения есть внутренний черновик, которого вы не видите, — и тарифицируется он как выходные токены. Поэтому «я же попросил короткий ответ» не спасает: ответ на три строки может стоить как страница текста. Сегодня это самый частый источник неожиданного счёта.

Самый крупный рычаг — повторяющийся вход. Системный промпт, справочные материалы и история диалога отправляются заново при каждом обращении; в длинном диалоге они составляют большую часть входных токенов. Провайдеры умеют кешировать промпт: неизменный префикс запроса (он должен стоять в начале и не меняться от вызова к вызову) при повторном обращении оплачивается в разы дешевле обычного входа.

Только выигрыш этот не даровой, и две оговорки важнее самой скидки. Первая: запись в кеш обычно стоит дороже обычного входа — примерно на четверть, — то есть первый вызов вы переплачиваете и окупаете это со второго-третьего. Вторая: кеш живёт минуты, каждое обращение продлевает ему жизнь, а пауза обнуляет. Выгода появляется на частых вызовах подряд; при одном запросе в час кеш только удорожает.

Следующий рычаг — не отправлять всю историю, а держать последние реплики и краткое резюме более ранних; ещё один — сократить сам системный промпт и подтягивать справочные данные по запросу через инструмент, а не держать их в промпте всегда.

Настройка агента — это постоянная строка расхода

Есть часть входа, о которой не думают вовсе, потому что её не набирают руками: то, что агент отправляет за вас при каждом обращении. А отправляет он немало.

Что уходит во вход на каждом шаге, кроме вашей реплики:

  • Системные правила — инструкция самого агента плюс файл правил вашего проекта («как у нас принято»). Это сотни, а с подробным файлом правил и тысячи токенов.
  • Описания инструментов — у каждого инструмента есть имя, назначение и список параметров с пояснениями, и модель должна видеть их все, чтобы выбрать. Десять инструментов — это обычно одна-две тысячи токенов; подключили несколько внешних наборов инструментов — легко пять тысяч и больше.
  • История сессии — все предыдущие реплики, вызовы инструментов и их результаты. Последнее важнее всего: вывод команды на пятьсот строк остаётся в истории и переотправляется на каждом следующем шаге.

Отсюда два неочевидных следствия. Первое: цена одного шага агента растёт по ходу сессии, потому что история растёт. Сессия из пятидесяти шагов стоит заметно больше, чем пятьдесят отдельных запросов, и это ответ на недоумение «почему я потратил столько на одну задачу». Второе: подключённый и ни разу не использованный инструмент всё равно стоит денег — его описание уходит в каждый вызов.

Что с этим делают на практике: держат подключёнными только нужные наборы инструментов, а не все, какие есть; не вываливают в диалог вывод длинных команд (просят агента посмотреть нужную часть); держат файл правил проекта коротким и по делу — это не место для документации; и завершают сессию, когда задача сделана, вместо того чтобы продолжать в том же диалоге следующую. Кеширование неизменного начала запроса, о котором выше, покрывает как раз правила и описания инструментов — и именно поэтому оно так заметно на агентах.

Токены — это ещё и скорость

Стоимость — не единственное следствие. Модель генерирует ответ токен за токеном, поэтому длинный вывод дольше. И большой вход модель дольше «прочитывает». Поэтому раздутый контекст бьёт по трём фронтам сразу: дороже, медленнее и часто хуже по качеству.

Объём: пакетный режим и потолок в минуту

Сценарий «обработать тысячу элементов» — разметить обращения, перевести описания товаров, извлечь поля из документов — упирается не в те ограничения, что разговор с агентом. Здесь появляются два инструмента, о которых полезно знать до того, как запустите цикл.

Пакетный режим — половина цены. У провайдеров есть отложенная обработка: вы отдаёте файл с тысячами запросов и получаете результат не сразу, а в течение нескольких часов (обычно обещают сутки как предел). Стоит это примерно вдвое дешевле обычного обращения, и это самая большая экономия из всех возможных, доступная одним изменением способа вызова. Подходит ровно тогда, когда ответ не нужен немедленно: ночная разметка накопленного, первичное наполнение данных, пересчёт после смены модели. Не подходит для всего, что ждёт пользователь.

Потолок токенов в минуту. Кроме денег, у ключа есть ограничение скорости: столько-то запросов и столько-то токенов в минуту. И на объёме он бьёт раньше бюджета: цикл, который на десяти элементах работал прекрасно, на тысяче начинает получать отказы с кодом «слишком много запросов». Что из этого следует:

  • Обработку на объёме пишут с повторами и ожиданием: получил отказ — подождал (провайдер часто сообщает, сколько именно), повторил. Без этого цикл падает на середине.
  • Параллелить имеет смысл до потолка, а не «на сколько хватит потоков»: десять потоков против одного ускорят работу, сто — просто получат отказы.
  • Потолок зависит от уровня учётной записи и повышается по запросу; на новом ключе он низкий, и это отдельный сюрприз при первом запуске на объёме.
  • Пакетный режим живёт со своими, более щедрыми ограничениями — ещё одна причина взять его для объёма.

Прикидка на объём целиком. Токены одного элемента из пробного прогона, умножить на число элементов, — это деньги; число элементов разделить на потолок в минуту — это время. Второе число обычно неприятнее первого: тысяча документов по пять тысяч токенов — это пять миллионов токенов, и при потолке в двести тысяч в минуту прогон займёт около полутора часов даже при идеальной параллельности. Знать это до запуска дешевле, чем узнать посреди прогона.

Что это значит на практике

Токены — это единица и денег, и внимания модели. Продукт-инженер держит их в голове как ресурс: даёт модели ровно то, что нужно для задачи, следит за раздуванием диалогов, прикидывает стоимость автоматизаций на объёме и выбирает размер модели под задачу. Экономия токенов почти всегда идёт рука об руку с ростом качества — короткий релевантный вход лучше огромного «на всякий случай».

Дополнительно: при первом чтении можно пропустить

Глубже: где смотреть расход и как прикинуть ценурасширенное

«Прикидывайте стоимость до запуска» требует двух вещей: знать, откуда взять числа, и уметь их перемножить.

Где смотреть. Каждый ответ API возвращает счётчик: сколько токенов ушло на вход, сколько на выход, сколько взято из кэша. Агент для кода показывает то же по сессии командой или в статусе: потрачено столько-то, стоит столько-то. У провайдера есть страница расхода по дням и по ключам, и лимит трат на ключ, который ставят до первого запуска. Первое, что делают с новой фичей, это один прогон с записью этих чисел, а не оценка на глаз.

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

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

private static final BigDecimal INPUT_PER_MILLION = new BigDecimal("3.00");
private static final BigDecimal OUTPUT_PER_MILLION = new BigDecimal("15.00");

ResponseCreateParams params = ResponseCreateParams.builder()
    .model("gpt-4.1")
    .input("Определи тему обращения одним словом:\n" + ticket)
    .build();

Response response = client.responses().create(params);
ResponseUsage usage = response.usage().orElseThrow();

BigDecimal cost = INPUT_PER_MILLION.multiply(BigDecimal.valueOf(usage.inputTokens()))
    .add(OUTPUT_PER_MILLION.multiply(BigDecimal.valueOf(usage.outputTokens())))
    .divide(BigDecimal.valueOf(1_000_000), 6, RoundingMode.HALF_UP);

log.info("in={} out={} cost={}", usage.inputTokens(), usage.outputTokens(), cost);

const inputPerMillion, outputPerMillion = 3.0, 15.0

response, err := client.Responses.New(ctx, responses.ResponseNewParams{
	Model: "gpt-4.1",
	Input: responses.ResponseNewParamsInputUnion{
		OfString: openai.String("Определи тему обращения одним словом:\n" + ticket),
	},
})
if err != nil {
	return err
}

in, out := response.Usage.InputTokens, response.Usage.OutputTokens
cost := (float64(in)*inputPerMillion + float64(out)*outputPerMillion) / 1e6

log.Printf("in=%d out=%d cost=%.6f", in, out, cost)

const inputPerMillion = 3.0;
const outputPerMillion = 15.0;

const response = await client.responses.create({
  model: 'gpt-4.1',
  input: `Определи тему обращения одним словом:\n${ticket}`,
});

const { input_tokens: inputTokens, output_tokens: outputTokens } = response.usage;
const cost = (inputTokens * inputPerMillion + outputTokens * outputPerMillion) / 1e6;

console.log(`in=${inputTokens} out=${outputTokens} cost=${cost.toFixed(6)}`);

INPUT_PER_MILLION = Decimal("3.00")
OUTPUT_PER_MILLION = Decimal("15.00")

response = client.responses.create(
    model="gpt-4.1",
    input=f"Определи тему обращения одним словом:\n{ticket}",
)

usage = response.usage
cost = (INPUT_PER_MILLION * usage.input_tokens
        + OUTPUT_PER_MILLION * usage.output_tokens) / 1_000_000

print(f"in={usage.input_tokens} out={usage.output_tokens} cost={cost:.6f}")

Смотреть тут стоит на два места. Первое: числа берутся из ответа и ниоткуда больше, ни из длины запроса, ни из прикидки по словам. Второе, и об него спотыкаются: в счётчике есть ещё разбивка входа, и прочитанное из кэша (input_tokens_details.cached_tokens и его аналоги) уже посчитано внутри общего входа, но тарифицируется дешевле. Если эту часть не вычесть по своей цене, прикидка окажется завышена ровно на ту скидку, ради которой кэш и включали. И ещё: в логе цену считают как получится, а вот когда она идёт в счёт клиенту, её держат в точном десятичном типе, не в дробном числе с плавающей точкой.

Как считать. Цена задачи это входные токены умножить на цену входа плюс выходные умножить на цену выхода, цены даются за миллион токенов. Разбор одного обращения в поддержку: 6 тысяч токенов на входе (инструкция, история, документ) и 500 на выходе. У модели среднего класса по ценам 2026 года, около трёх долларов за миллион на вход и пятнадцать на выход, это 0,018 плюс 0,0075, около 2,5 цента за обращение. Тысяча обращений в день это 25 долларов в день, 750 в месяц. Та же задача на маленькой модели в десять-двадцать раз дешевле, на самой сильной в пять раз дороже, и это ответ на вопрос из следующего раздела.

Что удешевляет. Кэш повторяющегося начала промпта (инструкция и справочник одни и те же на каждое обращение) даёт скидку на эту часть входа в разы, если неизменная часть стоит в начале. Короткий выход дешевле длинного, и просьба отвечать по схеме, а не «подробно», это экономия. Агент в цикле переотправляет всю историю на каждом шаге, поэтому цена сессии растёт быстрее числа шагов, и лимит бюджета на сессию это не паранойя.

Прикидка до запуска. Токены одной задачи из пробного прогона, умножить на число задач в день, умножить на цену модели, плюс запас в полтора раза на повторы и длинные случаи. Число с этого листка сравнивают с тем, сколько стоит та же работа без модели, и это единственный честный способ решить, делать ли фичу.

Глубже: выбор модели под задачурасширенное

«Простое стоит отдать модели попроще» это одна строка, за которой стоит решение, влияющее на цену в десятки раз.

У каждого провайдера линейка из трёх ступеней: маленькая модель (быстрая, дешёвая, справляется с классификацией, извлечением полей, маршрутизацией и простым переписыванием), средняя (рабочая лошадь для кода, ответов по документам, разбора обращений) и старшая (сложные многошаговые задачи, проектирование, тексты, где важны нюансы). Разница в цене между ступенями пять-двадцать раз, в скорости тоже, а разница в качестве видна не везде: на задаче «определить тему письма» маленькая модель не хуже старшей.

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

Как убедиться, что на дешёвой не просело. Не «посмотрел десять ответов», а набор из сотни примеров с ожидаемыми ответами, прогнанный на обеих моделях, с долей приемлемых ответов и ценой на прогон рядом. Если разница в доле в пределах шума, а цена в десять раз ниже, выбор сделан; если просело на редких случаях, их отдают старшей модели по признаку. Тот же набор гоняют при каждой смене модели или промпта, о чём статья про создание LLM-приложений.

Коротко

  • Токен это единица и денег, и внимания модели; для русского и кода токенов на тот же текст больше.
  • Платят за вход и за выход, выход дороже; повторяющийся вход (инструкция, история) это главная статья, и её кэшируют.
  • Расход виден в ответе API, в статусе агента и на странице провайдера; цена задачи это токены на прогон умножить на цены, умножить на объём, с запасом в полтора раза.
  • Линейка из трёх ступеней различается в цене в разы: маленькая для классификации и извлечения, средняя для кода и документов, старшая для рассуждений; выбор подтверждают набором примеров, а не десятью ответами.
  • Агент отправляет за вас системные правила, описания всех подключённых инструментов и всю историю с выводом команд: цена шага растёт по ходу сессии, а неиспользованный инструмент всё равно платный.
  • Для объёма есть пакетный режим примерно за половину цены с ответом в течение часов; у ключа есть потолок токенов в минуту, и на объёме он бьёт раньше бюджета, поэтому нужны повторы с ожиданием.

Что почитать дальше

Токены — это ещё и мера того, сколько модель удерживает за раз. Про это — контекст и контекстное окно. А про то, как модели дают доступ к внешним данным вместо раздувания входа, — вызов инструментов.