Как понять правила тарификации GPT-6.2 Sol? Пересчёт счёта на $0.0479 по использованию Responses

Как понять правила тарификации GPT-6.2 Sol? Пересчёт счёта на $0.0479 по использованию Responses

Примечание автора: отправной точкой служит один usage из Responses — постатейно пересчитываем обычный ввод, чтение и запись кэша, а также вывод рассуждений для GPT-6.2 Sol, а затем объясняем, как срок жизни кэша и состояние запроса меняют счёт в одном и том же рабочем процессе.

Счёт за GPT-6.2 Sol можно пересчитать по фиксированной методике. В записи запроса usage разбивает ввод на обычный ввод, чтение кэша, запись в 30-минутный кэш и запись в 12-часовой кэш — эти четыре категории взаимоисключающие. Вывод образует отдельную категория, и токены рассуждений уже включены в неё. Число токенов каждой категории умножается на соответствующий тариф, после чего значения складываются — это и есть стоимость модели за данный запрос. Плата за инструменты рассчитывается отдельно.

Есть три условия, которые меняют результат. Первое — превышает ли общий объём ввода одного запроса 272K; после превышения весь запрос переходит на тариф длинного контекста. Второе — срок жизни кэша и фактическое число попаданий: если один и тот же префикс записывается на 30 минут или на 12 часов, точка окупаемости различается. Третье — состояние запроса: incomplete, повторные попытки и фоновые задачи влияют на общий счёт рабочего процесса.

OpenAI выпустила GPT-6.2 Sol 17 ноября 2026 года. ID модели в API — gpt-6.2-sol, её можно вызывать через Responses и Chat Completions; вызов функций и встроенные инструменты идут через путь Responses. В этой статье за основу берутся официальные долларовые цены OpenAI при прямом подключении, а также описывается, как эта модель указана в публичном интерфейсе цен APIYI apiyi.com. Все расчёты в статье основаны на синтетическом использовании, а не на реальных счетах.

gpt-6-2-sol-billing-responses-usage-recalculation-ru-image-0

Table of Contents

Карта знаний по тарификации GPT-6.2 Sol и порядок чтения

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

Responses usage
 ├─ Общий объём ввода input_tokens
 │   ├─ Чтение из кэша cached_tokens ──────────┐
 │   ├─ Запись 30m ttl_30m_tokens ─────────────┤
 │   ├─ Запись 12h ttl_12h_tokens ─────────────┼─→ ×соответствующий тариф → стоимость модели за один запрос (раздел 2)
 │   └─ Обычный ввод = всего − чтение − все записи ┤
 └─ Вывод output_tokens (включая reasoning_tokens)┘
                                          ↓
         Выбор срока жизни кэша (раздел 3) ← сравнение общей цены при многократных запросах с одним префиксом
                                          ↓
         Сверка рабочего процесса (раздел 4) ← плата за инструменты + повторные попытки + incomplete + выгрузка расходов
Номер Отвечает на вопрос Зависит от предыдущего раздела Что можно сделать после прочтения
1 Какие числа в usage участвуют в тарификации — Разложить один ответ на пять единиц тарифицируемого объёма
2 Сколько стоят эти объёмы Пять объёмов из раздела 1 Переводить числа из логов в доллары, определять длинный или короткий тариф
3 Кэш писать на 30 минут или на 12 часов Алгоритм расчёта цены из раздела 2 Выбирать срок жизни кэша по интервалу между вызовами и числу попаданий
4 Сколько же на самом деле стоил один задача Расчёт одного запроса из разделов 2 и 3 Строить минимальную таблицу логов и находить расхождение в счёте

Если вам нужно лишь объяснить одну разницу в стоимости, достаточно прочитать разделы 1 и 2. Тем, кто отвечает за стратегию кэширования или учёт затрат, советуем читать все четыре раздела по порядку.

Термины биллинга GPT-6.2 Sol, которые нужно знать

Термин Объяснение
usage поле в ответе API, где суммируется расход токенов текущего запроса
обычный ввод объём, оставшийся от общего ввода после вычета чтения из кэша по тарифу и всех записей в кэш
чтение из кэша та часть ввода текущего запроса, которая тарифицируется по цене повторного использования
точка останова кэша граница, позволяющая сохранить или переиспользовать префикс ввода
TTL настройка минимального времени, которое покрывается тарификацией кэша; Sol поддерживает запись на 30 минут и на 12 часов
токены рассуждения токены, которые модель создаёт на этапе размышления и которые входят в общий оплачиваемый объём вывода
ID ответа идентификатор, связывающий журнал сверки, фоновый опрос и соответствующий ответ модели
плата за инструменты отдельная плата за использование отдельных хостинговых инструментов

1 Пять категорий тарифицируемого объёма GPT-6.2 Sol из usage объекта Responses

1.1 Четыре вида входа и один вид выхода

Объект usage в Responses раздельно записывает вход и выход одного запроса. На стороне входа даётся общий объём и несколько детализаций, на стороне выхода — общий объём и подкатегория рассуждений. При пересчёте нужно искать следующие поля:

Категория тарификации Читаемое поле Пояснение
Общий объём входа usage.input_tokens Сумма четырёх видов входа; сам по себе напрямую не умножается на ставку
Чтение из кэша input_tokens_details.cached_tokens Объём чтения в биллинговом смысле
Суммарная запись в кэш cache_write_tokens Сумма записей с двумя сроками жизни
Запись на 30 минут cache_write_tokens_details.ttl_30m_tokens Используется при возврате детализации по сроку жизни
Запись на 12 часов cache_write_tokens_details.ttl_12h_tokens Используется при возврате детализации по сроку жизни
Выход usage.output_tokens Уже включает токены рассуждений
Подкатегория рассуждений output_tokens_details.reasoning_tokens Нужна для понимания структуры выхода, отдельно не тарифицируется

1.2 Формула расчёта обычного входа

Для обычного входа в usage нет отдельного поля — его нужно получить вычитанием:

обычный вход = input_tokens − cached_tokens − cache_write_tokens

Здесь вычитается вся запись, то есть сумма обоих сроков — 30 минут и 12 часов. Две записи, чтение и обычный вход — четыре взаимоисключающие категории: один и тот же токен попадает только в одну из них. Токены, записанные в кэш, тарифицируются по ставке записи и больше не накладываются на цену обычного входа. Именно здесь чаще всего ошибаются: если оставить объём записи в обычном входе и дополнительно начислить плату за запись, итог получится завышенным.

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

gpt-6-2-sol-billing-responses-usage-recalculation-ru-image-1

1.3 Для пересчёта — биллинговые поля, диагностические только для поиска проблем

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

Если какой-то канал не вернул детализацию по сроку жизни или в нём отсутствует cache_write_tokens, не стоит по отсутствующим полям восстанавливать счёт. В такой ситуации ориентируйтесь на собственные записи о списаниях этого канала. В примере расчёта из следующего раздела используется синтетический usage — все поля заполнены, чтобы удобно показать полный алгоритм.


2 Переводим числа из логов GPT-6.2 Sol в доллары

2.1 Официальная таблица тарифов Standard

В таблице ниже — официальные тарифы OpenAI при прямом подключении, единица измерения — USD за миллион токенов. Короткий или длинный тариф определяется по общему объёму входных данных каждого запроса: если он превышает 272K, весь запрос переключается на тариф длинного контекста — ставки на вход и все виды кэша ×2, на выход ×1.5.

Категория тарификации Standard Короткий контекст (≤272K) Длинный контекст (>272K)
Обычный вход $2.00 $4.00
Чтение кэша $0.10 $0.20
Запись кэша на 30 минут $2.50 $5.00
Запись кэша на 12 часов $5.00 $10.00
Выход (включая токены рассуждений) $10.00 $15.00

Базовая цена короткого контекста такая же, как у GPT-6.1 Sol. Кроме того, в карточке модели указано контекстное окно 1,050,000 токенов, максимальный вход 922,000 токенов и максимальный выход 128,000 токенов. «Сколько максимум можно подать на вход» и «с какого момента начинается тарификация по длинному тарифу» — два независимых числа: запрос с 300K входных данных вполне допустим, но оплачиваться он будет целиком по длинному тарифу.

2.2 Полный пересчёт синтетического usage

Предположим, один запрос Standard с коротким контекстом возвращает следующий usage, инструменты не использовались, доплат нет: общий объём ввода 12 000, чтение из кэша 4 000, запись 30 минут 3 000, запись 12 часов 4 000, вывод 1 800 (из них рассуждение 1 200).

Сначала найдём обычный ввод: 12 000 − 4 000 − 3 000 − 4 000 = 1 000. Затем умножим каждую позицию на тариф:

Статья биллинга Кол-во токенов Тариф (USD/миллион) Сумма (USD)
Обычный ввод 1 000 2.00 0.0020
Чтение из кэша 4 000 0.10 0.0004
Запись 30 минут 3 000 2.50 0.0075
Запись 12 часов 4 000 5.00 0.0200
Вывод (включая рассуждение 1 200) 1 800 10.00 0.0180
Итого — — 0.0479

В этом счёте запись на 12 часов занимает всего 4 000 токенов, но даёт больше сорока процентов суммы. Причина в том, что её цена за единицу в 2,5 раза выше, чем у обычного ввода: сама запись несёт только затраты, а отдача наступает лишь при последующих попаданиях. В разделе 3 разберём это отдельно.

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

2.3 Длинный контекст: сначала меняем тарифы, потом применяем ту же формулу

Когда общий объём ввода превышает 272 тыс. токенов, сам алгоритм не меняется — достаточно заменить весь столбец тарифов из таблицы выше на значения для длинного контекста. Важно: переключение действует на весь запрос целиком, чтение и запись кэша тоже удваиваются синхронно, а вывод считается с коэффициентом 1,5. Поэтому определять, короткий у вас диапазон или длинный, нужно до того, как начнёте перемножать по пунктам.

При вызове через сторонние каналы тарифы нужно брать по их собственной сетке. Возьмём для примера APIYI apiyi.com: при повторном чтении их публичного интерфейса цен 2026-11-20 выражение billing_expr для gpt-6.2-sol тоже переключается на пороге 272 000 входных токенов: короткий диапазон — обычный ввод $2, чтение кэша $0.10, запись в кэш $2.50, вывод $10; длинный диапазон — $3, $0.15, $3.75 и $11.25 соответственно (USD за миллион токенов). Как видите, множители для длинного диапазона отличаются от официального прямого подключения, а выражение в интерфейсе указывает только одну цену записи в кэш. Фактические группы, возможности и выставление счетов в реальном проекте определяются текущей конфигурацией платформы и её счетами.

Код ниже отправляет один запрос Responses через OpenAI-совместимый интерфейс APIYI и печатает usage как есть — чтобы потом можно было пересчитать вручную:

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # OpenAI-совместимый интерфейс APIYI
)

resp = client.responses.create(
    model="gpt-6.2-sol",
    input=[
        {"role": "developer", "content": "固定规则与公共资料(放在前部便于缓存复用)"},
        {"role": "user", "content": "本次请求的具体问题"},
    ],
    max_output_tokens=4000,
)

print(resp.id, resp.status)
print(resp.usage.model_dump())

Получив usage, переводим пять показателей расхода в деньги одной функцией. Тарифную таблицу делаем параметром: чтобы переключиться на официальную сетку или на сетку канала, достаточно поменять конфигурацию:

Посмотреть полную функцию пересчёта
LONG_THRESHOLD = 272_000

# Официальный тариф OpenAI Standard, USD / миллион токенов
OFFICIAL_RATES = {
    "short": {"input": 2.00, "cached": 0.10, "w30m": 2.50, "w12h": 5.00, "output": 10.00},
    "long":  {"input": 4.00, "cached": 0.20, "w30m": 5.00, "w12h": 10.00, "output": 15.00},
}

def _get(d, *keys, default=None):
    for k in keys:
        if not isinstance(d, dict) or k not in d:
            return default
        d = d[k]
    return d

def recalc_cost(usage: dict, rates: dict = OFFICIAL_RATES) -> dict:
    total_in = usage["input_tokens"]
    details = usage.get("input_tokens_details") or {}
    cached = details.get("cached_tokens", 0) or 0

    # Расположение полей записи зависит от фактической структуры ответа — здесь проверяем оба места
    write_total = details.get("cache_write_tokens", usage.get("cache_write_tokens"))
    ttl = details.get("cache_write_tokens_details") or usage.get("cache_write_tokens_details")
    if write_total is None:
        raise ValueError("缺少 cache_write_tokens,改用渠道出账记录,不要推定")
    w30 = _get(ttl, "ttl_30m_tokens")
    w12 = _get(ttl, "ttl_12h_tokens")
    if write_total and (w30 is None or w12 is None):
        raise ValueError("缺少写入寿命明细,无法区分 30m/12h 费率")
    w30, w12 = w30 or 0, w12 or 0

    plain = total_in - cached - write_total
    output = usage["output_tokens"]
    tier = "long" if total_in > LONG_THRESHOLD else "short"
    r = rates[tier]

    items = {
        "plain_input": plain * r["input"] / 1e6,
        "cache_read": cached * r["cached"] / 1e6,
        "write_30m": w30 * r["w30m"] / 1e6,
        "write_12h": w12 * r["w12h"] / 1e6,
        "output": output * r["output"] / 1e6,
    }
    items["tier"] = tier
    items["model_total"] = round(sum(v for k, v in items.items() if k != "tier"), 6)
    return items

# Проверка на синтетическом usage из раздела 2.2
demo = {
    "input_tokens": 12000,
    "input_tokens_details": {
        "cached_tokens": 4000,
        "cache_write_tokens": 7000,
        "cache_write_tokens_details": {"ttl_30m_tokens": 3000, "ttl_12h_tokens": 4000},
    },
    "output_tokens": 1800,
    "output_tokens_details": {"reasoning_tokens": 1200},
}
print(recalc_cost(demo))  # model_total: 0.0479

При отсутствии поля функция сразу выбрасывает ошибку, а не подставляет 0. Это сделано для того, чтобы не обсчитать запрос без детализации записи как «всё по обычному входу».

🎯 Технический совет: когда ведёте учёт затрат, сначала прогоните функцию пересчёта на синтетическом usage и только потом подключайте реальные логи. Через APIYI apiyi.com можно тем же API-ключом отправить тестовые запросы с небольшим трафиком, сопоставить возвращённый usage со счётом платформы строка за строкой и, убедившись в трактовке полей, запускать статистику в продакшене.


3 Выбор срока жизни кэша GPT-6.2 Sol в зависимости от ритма вызовов

3.1 Расчёт для одного и того же префикса при двух и трёх обращениях

Предположим, есть фиксированный префикс на 40 000 токенов (системные правила плюс общие материалы), тарифицируется по Standard для короткого контекста. Стоимость каждого типа операции за один раз следующая: обычный ввод — $0.08, первая запись на 30 минут — $0.10, первая запись на 12 часов — $0.20, чтение при полном попадании в кэш — $0.004. В таблице ниже сравнивается только часть с фиксированным префиксом, без переменного содержимого каждого запроса и вывода.

Режим доступа Обычный ввод Схема записи 30m Схема записи 12h
Всего 2 раза (1 запись + 1 чтение) $0.160 $0.104 $0.204
Всего 3 раза (1 запись + 2 чтения, все в пределах окна) $0.240 $0.108 $0.208

При двух обращениях запись на 12 часов оказывается на $0.044 дороже, чем без кэширования. При трёх обращениях оба варианта кэширования дешевле обычного ввода, но 30-минутная схема всё ещё составляет примерно половину стоимости 12-часовой. При условии, что все эти обращения укладываются в 30-минутное окно.

gpt-6-2-sol-billing-responses-usage-recalculation-ru-image-2

3.2 Точка окупаемости: сколько попаданий нужно, чтобы отбить затраты

Если взглянуть на эти цифры под другим углом, картина станет нагляднее (расчёты ниже — по тарифам M3). Каждое полное попадание экономит $0.076 по сравнению с обычным вводом. Запись с TTL 30 минут стоит на $0.02 дороже обычного ввода — хватает одного попадания, чтобы её отбить. Запись с TTL 12 часов дороже на $0.12, и для окупаемости нужно минимум два попадания внутри окна.

Так что ценность 12-часовой записи не в том, что «внутри одного окна больше попаданий», а в том, что попадание срабатывает даже при интервале между вызовами больше 30 минут. Если два соседних запроса с одинаковым префиксом обычно идут с разницей в несколько минут, 30-минутной записи достаточно, а выбор 12 часов лишь добавит плату за запись. Если же запросы приходят раз в один-два часа, 30-минутный кэш давно истекает и каждый раз приходится писать заново — вот тогда 12-часовая запись вместе с несколькими попаданиями может оказаться выгоднее.

Есть ещё два момента, которые меняют картину. TTL — это минимальное время, за которое берётся плата, и оно не означает, что кэш обязательно живёт именно столько; в итоге смотреть надо на фактический объём чтения в usage. У 30-минутной записи при чтении действует правило продления, так что в высокочастотных сценариях фактическое покрытие может оказаться дольше номинальных 30 минут. Поэтому после выбора конфигурации стоит оглянуться на реальные записи о попаданиях, а не смотреть только на настройки.

3.3 Схема точек кэширования: стабильный контент — в начало

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

  • Долгоживущие общие материалы, например руководства по продукту или сводки кодовой базы: размещайте в самом начале и рассматривайте запись на 12 часов.
  • Короткоживущие записи сеанса, например историю текущего диалога: размещайте после них и рассматривайте запись на 30 минут.
  • Мгновенные инструкции, которые меняются каждый раз: размещайте в конце, вне кэша.

У GPT-6.2 есть один нюанс, на котором легко споткнуться: верхнеуровневый instructions находится после точки кэширования. Если записать фиксированные правила в instructions, эта часть не будет переиспользована. Фиксированные правила лучше поместить в developer-сообщение в начале input, а instructions оставить для содержимого, которое может меняться от запроса к запросу.

💡 Совет по выбору: срок жизни кэша стоит определять по реальному трафику. Рекомендую сначала на APIYI apiyi.com отправить несколько запросов с одним и тем же префиксом в реальном темпе, посмотреть статистику попаданий cached_tokens, а затем решить, для какого слоя использовать 30 минут, а для какого — 12 часов. Разные каналы могут по-разному тарифицировать запись в кэш; ориентируйтесь на счёт платформы.


4. Как суммировать затраты GPT-6.2 Sol по рабочему процессу и отследить расхождение

4.1. Три статуса запросов, из-за которых счёт может не совпасть с ожиданиями

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

  1. incomplete: когда вывод достигает max_output_tokens, ответ может завершиться со статусом incomplete. В этот момент видимого текста может ещё не быть, но входные токены и токены рассуждения уже созданы и оплачены. Если учитывать только запросы, которые «успешно вернули контент», эти затраты выпадут из расчёта.
  2. Фоновые задачи: если у фоновой задачи уже есть ID ответа, при опросе отслеживайте её по тому же ID. Не считайте каждый опрос новым запросом, иначе затраты задвоятся.
  3. Повторы: отдельные вызовы, которые запускаются заново из-за таймаута или статуса incomplete, создают новый ответ, и их нужно учитывать отдельно. Чем больше повторов, тем больше раз вы снова платите за входные токены одной и той же задачи.

4.2 Стоимость инструментов и дополнительные токены, которые они порождают

Responses поддерживает такие инструменты, как поиск по файлам, веб-поиск, интерпретатор кода и генерация изображений. При использовании генерации изображений Sol в ходе процесса инициирует вызов инструмента, само изображение создаётся отдельным инструментом, и оплата идёт по правилам для инструментов. Плата за инструменты сверяется по фактическому типу: например, веб-поиск считается как $10 за тысячу вызовов, а токены контента, возвращённого поиском, тарифицируются отдельно по ставке модели.

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

4.3 Минимальный набор полей журнала

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

Поле журнала Назначение
ID рабочего процесса объединяет несколько запросов в одну задачу
ID ответа связывает с фоновым опросом, отличает повторную попытку от того же запроса
Модель определяет тарифную таблицу, например gpt-6.2-sol
Уровень сервиса проверить, что используется Standard
Финальный статус распознать completed, incomplete и т. п.
Статьи расхода обычный вход, чтение, запись 30m, запись 12h, выход, рассуждения
Инструменты тип инструмента и количество вызовов
Стоимость сумма, пересчитанная по статьям, с пометкой короткого/длинного тарифа

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

4.4 Перекрёстная сверка оценки по каждому запросу с официальным экспортом

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

💰 Совет по стоимости: если команда одновременно использует несколько моделей, можно через APIYI apiyi.com вызывать их единым API-ключом и сохранять в базу по минимальному набору полей лога из этой статьи. Единая точка входа позволяет держать идентификаторы рабочих процессов и методику расчёта затрат согласованными, а при сверке в конце месяца избавляет от лишнего слоя пересчёта по каналам.


Методика проверки счёта GPT-6.2 Sol

Получив любую запись запроса Sol, можно проверить счёт в таком порядке: сначала убедитесь, превышает ли общий объём ввода 272K, и выберите колонку тарифов; затем вычтите из input_tokens чтение и все записи, чтобы получить обычный ввод; после этого умножьте пять пунктов на соответствующие тарифы, сложите и сравните со счётом. Если отдельный запрос совпадает, а сумма по рабочему процессу — нет, ищите в логах incomplete, повторные попытки и вызовы инструментов.

Окупается ли кеш, в итоге определяется фактическим объёмом чтения в usage и интервалом между вызовами. Кеш-запись на 30 минут окупается одним попаданием, запись на 12 часов требует минимум двух попаданий в пределах окна, и преимущество проявляется только при интервале между вызовами больше 30 минут.

Если нужно проверить эти выводы на реальном трафике, можно запросить бесплатную тестовую квоту в APIYI apiyi.com и построчно сверять счёты платформы с помощью функции пересчёта из статьи.

📚 Справочные материалы

  1. Анонс релиза OpenAI GPT-6.2 Astra и Sol: дата выхода и позиционирование продукта

    • Ссылка: openai.com/index/introducing-gpt-6-2-astra-sol
    • Описание: узнать о позиционировании Sol для повседневной работы и многошаговых агентов
  2. Карточка модели GPT-6.2 Sol: спецификации контекста, тарифы и множитель для длинного контекста

    • Ссылка: developers.openai.com/api/docs/models/gpt-6.2-sol
    • Описание: источник таблицы тарифов в этой статье и правила ступени 272K
  3. Руководство по Prompt Caching и диагностике кэша: поля кэша, TTL и правила контрольных точек

    • Ссылка: developers.openai.com/api/docs/guides/prompt-caching
    • Описание: объясняет cached_tokens, время жизни записи и минимальный кэшируемый префикс
  4. Руководство по Reasoning: токены рассуждений и статус incomplete

    • Ссылка: developers.openai.com/api/docs/guides/reasoning
    • Описание: как понять, каким образом расход рассуждений учитывается в выводе
  5. Руководство по контролю затрат на один запуск рабочего процесса: агрегирование затрат Responses по рабочим процессам

    • Ссылка: developers.openai.com/cookbook/articles/per_run_spending_controller_responses_api
    • Описание: референсная реализация бюджетного контроля на уровне рабочего процесса
  6. Сводная таблица моделей APIYI: доступные каналы и информация о входных точках

    • Ссылка: docs.apiyi.com/models.md
    • Описание: доступные входы и группы для gpt-6.2-sol

Автор: техническая команда APIYI
Обратная связь: будем рады, если вы свяжетесь с нами через главную страницу APIYI apiyi.com; больше материалов по подключению — в центре документации docs.apiyi.com

Читайте также

Похожие записи