Перейти к содержанию

OpenAI Decisions API: что это, сколько стоит и когда дешевле Luna

POST /v1/decisions возвращает вероятность, вариант из списка или оценку. Короткий промпт дешевле через Decisions, длинный кешируемый — через Luna в Responses.

•••16 мин чтения•Руководства по API
Схема Decisions API: вход за $0,10 за 1 млн токенов проходит через POST /v1/decisions на gpt-6-luna и даёт ответы predicate, choice и score, выход $0

Decisions API — endpoint OpenAI POST /v1/decisions, который получает текст или изображения и ваши вопросы, а возвращает типизированные ответы: вероятность того, что условие выполнено, один вариант из заданного списка или оценку по упорядоченной шкале. Работает он только на модели gpt-6-luna. С 6 октября 2026 года (по времени США) endpoint находится в публичной бете, а общий запуск (GA) OpenAI ожидает «в ближайшие недели» (руководство Decisions, журнал изменений API).

Цена опубликована: $0,10 за 1 млн входных токенов, а за выходные токены, чтение и запись кеша плата не берётся. Скидки на кешированный вход при этом тоже нет, поэтому короткий промпт выгоднее отправлять в Decisions, а длинную повторяющуюся инструкцию — в обычную GPT-6 Luna через Responses API с кешированием: при 1 500 кешируемых токенах инструкции разница достигает примерно 5,3 раза в пользу Luna (расчёт ниже). Попробовать вопросы без кода можно в Playground Decisions. Из России OpenAI API напрямую не работает — варианты разобраны ниже.

Что такое OpenAI Decisions API и для каких задач он нужен

Модель здесь не пишет текст, а оценивает вход по вашим вопросам. Вы присылаете общий контекст (input) и массив вопросов (questions) трёх типов:

Тип вопросаДля чегоЧто возвращает
predicateПроверить условие: есть ли на фото повреждение, относится ли отрывок к запросуprobability — оценка от 0 до 1, что условие истинно
choiceВыбрать один вариант без порядка: отдел, категория контентаchoice — одно из ваших значений, плюс probabilities по всем вариантам и отдельное поле confidence
scoreОценить по упорядоченным уровням: серьёзность ошибки, срочностьscore — средневзвешенный по вероятностям индекс уровня (с нуля), плюс probabilities и confidence

Типичные задачи для такого вызова:

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

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

Зачем отдельный endpoint, если выбирать из списка умеет и обычная модель? Ради скорости и вероятностей. OpenAI пишет, что Decisions отвечает «примерно в 10 раз быстрее», чем Responses API, но бенчмарк не публикует. Сторонние замеры: у classmethod (DevelopersIO) медиана по пяти запросам через curl — 273 мс на примере с choice и 256 мс на примере со score (разбор classmethod); участник форума OpenAI с изображениями на входе и каналом около 3 Мбит/с видел примерно 0,8 с (тред о публичной бете). Для сравнения: строгая JSON-схема на Luna без рассуждений в тесте eesel давала медиану 1,46 с. Цифра «150 мс» встречается в прессе и в презентации, а не в документации.

Не путайте Decisions API с платформой Decisions (decisions.com) и сайтом decisionapi.net — к OpenAI они отношения не имеют.

Статус Decisions API: публичная бета с 6 октября 2026 года

Анонс на DevDay 29 сентября открыл только ограниченное превью для выбранных клиентов. 6 октября OpenAI выпустила endpoint в публичную бету: запись в журнале изменений — «Released the Decisions API in beta with gpt-6-luna», а в объявлении на форуме сказано, что бета доступна всем разработчикам. Ниже — что известно по состоянию на 10 октября 2026 года.

Что нужно разработчикуЧто опубликовано
ДоступПубличная бета; GA ожидается «в ближайшие недели», точная дата не названа
Endpoint и модельPOST https://api.openai.com/v1/decisions, единственная модель — gpt-6-luna
SDKМетод client.decisions.create(...) (в Go — client.Decisions.New); минимальные версии: Python 3.26.0, JavaScript 7.30.0, Go 3.73.0, Ruby 0.101.0, Java 4.78.0
ДокументацияРуководство и API reference «Create a decision»
Цена$0,10 за 1 млн входных токенов; выход, чтение и запись кеша не тарифицируются
Хранение данныхZero Data Retention (ZDR) и HIPAA для допущенных клиентов; резидентность данных и региональная обработка — США и Европа (ЕЭЗ и Швейцария)
Лимиты запросовОтдельные лимиты для Decisions не опубликованы
Чего нет в документацииДата и цена GA, максимум вопросов в одном запросе, максимум уровней в score, появится ли скидка на кеш

Пока это бета, названия полей и поведение могут измениться до GA. Есть и мелкая нестыковка в документации: таблица endpoint на странице модели GPT-6 Luna по-прежнему не упоминает v1/decisions, хотя руководство и журнал изменений называют именно эту модель.

Как вызвать POST /v1/decisions: первый запрос и поля ответа

Запрос состоит из трёх полей: model, input (строка или сообщения роли user с частями input_text и input_image) и questions. Каждому вопросу дайте уникальное name — API вернёт его в ответе, и вы не перепутаете ответы. Пример ниже повторяет форму запроса из официального руководства, только с русским текстом; нужен пакет openai версии 3.26.0 или новее и ключ в переменной окружения OPENAI_API_KEY.

Запрос к /v1/decisions с полями model, input и questions и ответ answers с полями для predicate, choice, score и refusal
python
from openai import OpenAI

client = OpenAI()
decision = client.decisions.create(
    model="gpt-6-luna",
    input="С меня дважды списали деньги за заказ.",
    questions=[
        {
            "type": "choice",
            "name": "department",
            "instructions": "Какой отдел должен разобрать это обращение?",
            "choices": [
                {"value": "billing", "description": "Платежи, счета и возвраты."},
                {"value": "technical", "description": "Проблемы с работой продукта."},
                {"value": "shipping", "description": "Доставка и отслеживание."},
                {"value": "other", "description": "Всё, что не подходит под эти категории."},
            ],
        }
    ],
)

answer = decision.answers[0]
if answer.type == "refusal":
    print(f"Refused: {answer.name}")
elif answer.type == "choice":
    print(f"Department: {answer.choice} (confidence: {answer.confidence})")

Ответ приходит в массиве answers в том же порядке, что и вопросы. Фрагмент, который OpenAI приводит как иллюстрацию (реальные числа будут другими):

json
{
  "answers": [
    {
      "type": "choice",
      "name": "department",
      "choice": "billing",
      "probabilities": [
        { "value": "billing", "probability": 0.95 },
        { "value": "technical", "probability": 0.02 },
        { "value": "shipping", "probability": 0.01 },
        { "value": "other", "probability": 0.02 }
      ],
      "confidence": 0.93
    }
  ]
}

Что означают поля:

  • probability (только у predicate) — оценка того, что условие истинно, от 0 до 1;
  • choice — одно из переданных вами значений; значения типизированы, строка "true" и булево true считаются разными вариантами;
  • probabilities (у choice и score) — распределение по всем вариантам или уровням;
  • confidence (у choice и score) — отдельное поле уверенности; у predicate его нет;
  • score — средневзвешенный индекс уровня: при вероятностях 0,1 / 0,7 / 0,2 для уровней 0, 1, 2 получится 1,1, то есть значение может попасть между уровнями;
  • type: "refusal" — модель отказалась отвечать на конкретный вопрос; в ответе будет его name (или null, если имени не было);
  • usage — токены запроса: input_tokens, cached_tokens, cache_write_tokens, output_tokens. В тесте classmethod output_tokens всегда был 0.

predicate с фото и score по шкале

Для проверки фото вопрос типа predicate получает сообщение с двумя частями. Изображение передавайте как data URL в base64 — это единственный формат, с которым согласны и руководство, и API reference (подробнее в разделе об ограничениях):

python
import base64
from pathlib import Path

image_base64 = base64.b64encode(Path("product.png").read_bytes()).decode("ascii")

decision = client.decisions.create(
    model="gpt-6-luna",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Осмотри товар на фото."},
                {"type": "input_image", "image_url": f"data:image/png;base64,{image_base64}"},
            ],
        }
    ],
    questions=[
        {
            "type": "predicate",
            "name": "visible_damage",
            "instructions": "Есть ли на товаре видимое повреждение: трещина, разрыв, вмятина? "
                            "Тени и повреждения упаковки не учитывай.",
        }
    ],
)
print(decision.answers[0].probability)  # если answers[0].type == "predicate"

Вопрос типа score вместо choices получает levels — уровни от низшего к высшему, у каждого label и description, например «косметическая», «есть обходной путь», «полностью блокирует». Независимые вопросы можно положить в один массив questions и оценить общий вход за один запрос, причём типы могут быть разными. Если второй вопрос зависит от ответа на первый (сначала «есть ли повреждение», потом «какой ремонт»), отправляйте два запроса. Необязательное поле safety_identifier (до 128 символов) передаёт идентификатор вашего конечного пользователя.

Эти примеры написаны по официальной форме запросов; для боевого кода добавьте обработку openai.APIError и проверку answer.type для каждого ответа.

Ограничения Decisions API: 2–255 вариантов и 128 изображений

ОграничениеЧто указано в документации
Варианты в choiceОт 2 до 255, каждый уникален
ИзображенияДо 128 на запрос по всем сообщениям; detail: low, high, auto (по умолчанию) или original
Формат изображенийРуководство: только base64 data URL, ссылки HTTP(S) и file_id не поддерживаются. API reference: base64 или публичный HTTP(S) URL. file_id не принимается в обоих случаях
Роли и типы входаТолько сообщения user; файлы, аудио, инструменты, вызовы функций и ссылки на элементы не поддерживаются
МодельТолько gpt-6-luna
Длинный контекст и регионМножители цены за длинный контекст и надбавка за региональную обработку действуют (у Luna надбавка — 10 %)
Лимиты RPM/TPMДля Decisions не опубликованы

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

С лимитами осторожнее. 6 октября OpenAI заменила уровни Tier 1–5 на Free, Build, Launch и Grow, поэтому прежняя цифра «Tier 1 — 500 запросов в минуту» больше не действует. Для самой Luna опубликованы лимиты Build — 5 000 RPM и 2 млн TPM, Launch — 10 000 RPM и 10 млн TPM, Grow — 30 000 RPM и 180 млн TPM (лимиты и уровни), но нигде не сказано, что они распространяются на /v1/decisions. Смотрите фактические значения в Settings → Organization → Limits своего аккаунта. Доступен ли Decisions на уровне Free, в документации тоже не сказано. Как устроены новые уровни, разобрано в статье «Уровни API OpenAI (tiers): Free, Build, Launch, Grow и что стало с Tier 1–5».

Ошибка 403 «Decision API is not enabled for this user»

До публичной беты так выглядел ответ для всех, кого не включили в превью. Автор блога eesel 1 и 2 октября отправлял POST https://api.openai.com/v1/decisions с обычным ключом и оба раза получал HTTP 403 (разбор eesel):

json
{
  "error": {
    "message": "Decision API is not enabled for this user.",
    "type": "invalid_request_error",
    "param": null,
    "code": null
  }
}

После 6 октября публичных сообщений об этой ошибке нет: тестировщики classmethod и участники форума OpenAI вызывали endpoint без ошибок доступа. Официально ошибка нигде не описана, поэтому если она всё же приходит, проверьте по порядку:

  1. Версию SDK. Если client.decisions не существует, обновите пакет до минимальной версии из таблицы выше; ошибка в этом случае будет на стороне клиента, а не 403.
  2. Путь и модель. Нужен ровно /v1/decisions и "model": "gpt-6-luna". Соседние пути вроде /v1/decisions/create и /v1/beta/decisions в тесте eesel возвращали 404.
  3. Ограничения организации и проекта. Ключ проекта, которому администратор ограничил модели или endpoint, — вероятная причина отказа (это предположение, а не документированное поведение).
  4. Не повторяйте вызов в цикле. Обрабатывайте 403 как «функция недоступна» и переключайтесь на реализацию на Luna, описанную ниже.

Сколько стоят 1 000 и 1 000 000 решений в Decisions API и на GPT-6 Luna

У Decisions тарифицируется только вход: $0,10 за 1 млн токенов. У Luna через Responses API в режиме Standard вход стоит те же $0,10, кешированный вход — $0,01, запись в кеш — $0,125, выход — $0,50 за 1 млн токенов (страница модели). Формулы на одно решение:

Decisions = (все входные токены) × $0,10 / 1 000 000

Luna Responses = кешированные × $0,01 / 1 000 000 + некешированные × $0,10 / 1 000 000 + выходные × $0,50 / 1 000 000

Допущение на одно решениеМаршрутОдно решение1 000 решений1 000 000 решений
A. Короткий промпт: 400 входных токенов, без кешаDecisions$0,00004$0,04$40
A. То же + 15 выходных токенов у LunaLuna Responses$0,0000475$0,0475$47,50
B. 1 500 токенов постоянной инструкции + 100 переменныхDecisions$0,00016$0,16$160
B. То же + 10 выходных, инструкция в кешеLuna Responses$0,00003$0,03$30

Проверка строки B для Luna: 1 500 × 0,01 / 1 000 000 = $0,000015, плюс 100 × 0,10 / 1 000 000 = $0,00001, плюс 10 × 0,50 / 1 000 000 = $0,000005, итого $0,00003. Для Decisions: 1 600 × 0,10 / 1 000 000 = $0,00016. В примере A Decisions дешевле примерно на 16 %, в примере B Luna — примерно в 5,3 раза. Числа токенов здесь — допущения для примера, а не замер; подставьте свои из поля usage.

Отсюда правило. Обозначим P — кешируемый префикс, O — выходные токены Luna. Разница на решение равна 0,09 × P − 0,50 × O (в долларах за миллион токенов), так что Decisions дешевле, только пока P < 5,6 × O: при 15 выходных токенах это примерно 83 токена префикса. Responses кеширует префиксы не короче 1 024 токенов (кеширование промптов), поэтому любая инструкция, которую вообще можно закешировать, при попадании в кеш обходится дешевле через Luna — если ответ Luna короче примерно 180 токенов, как у классификатора с одним полем.

Сравнение цены миллиона решений: при коротком промпте Decisions $40 против $47,50 у Luna, при инструкции в кеше Decisions $160 против $30 у Luna

Что меняет расчёт:

  • Промахи кеша. Кеш живёт не меньше 30 минут после последнего использования; при редком трафике запросы идут по полной цене плюс запись в кеш по $0,125, и преимущество Luna тает.
  • Рассуждения Luna. По умолчанию reasoning.effort у Luna — medium; для классификации ставьте none, иначе токены рассуждений добавятся к выходу.
  • Изображения добавляют входные токены на обоих маршрутах; считайте по usage первых вызовов.
  • Batch и Flex у Luna стоят 50 % от Standard, так что фоновая переразметка архива через Batch вдвое дешевле строки A для Luna.
  • Цена — не единственный критерий. Скорость и вероятности есть только у Decisions; при живом чате или агенте с десятками выборов на задачу разница в задержке может весить больше, чем разница в долларах.

Для ориентира по маленьким запросам: в тесте eesel вызов Luna на 60 входных и 12 выходных токенов обошёлся в $0,000012. Как Luna соотносится по цене со старшей моделью Sol, если простой классификации окажется мало, разобрано в статье «GPT-6 Luna или Sol: сколько стоят и когда Sol окупается».

Переходить ли с Luna на Decisions API: правило выбора

Если у вас уже работает классификатор на Luna со строгой схемой enum, переносите на Decisions то, где важны скорость или вероятности, а длинные кешируемые инструкции оставьте на Luna.

Ваша ситуацияЧто выбратьПочему
Короткая инструкция, живой чат или агент с частыми выборамиDecisions APIДешевле при коротком входе и заметно быстрее по заявлению OpenAI и сторонним замерам
Нужна вероятность, чтобы автоматизировать по порогуDecisions API, лучше вопрос predicateСхема enum вероятностей не даёт; пороги всё равно подбирайте на своих данных (см. ниже)
Длинная постоянная инструкция с примерами и ровный поток запросовLuna через Responses с кешемВ примере B — $30 против $160 за миллион решений
Фоновая переразметка, ответ не нужен сразуLuna через BatchАсинхронно и за полцены
Нужен свой JSON: извлечённые поля, пояснение к решениюStructured Outputs в Responses APIDecisions возвращает только вероятность, вариант или оценку; так рекомендует и OpenAI
Модель должна вызвать инструментFunction calling в Responses APIИнструменты в Decisions не поддерживаются
Вы работаете через шлюз без DecisionsLuna со строгой схемойEndpoint /v1/decisions у такого шлюза недоступен

Порядок переноса без риска для продакшена:

  1. Спрячьте вызов за одной функцией вроде decide() (её версия на Luna показана в следующем разделе), если ещё не сделали этого.
  2. Напишите вторую реализацию на client.decisions.create с той же сигнатурой: список вариантов из enum превращается в choices, а запасной вариант unsure — в other с описанием.
  3. Пустите один и тот же трафик через обе реализации в теневом режиме и пишите в лог ответ, confidence, задержку и usage.
  4. Сравните точность с решениями людей и подберите порог confidence, ниже которого ответ уходит на проверку.
  5. Переключайте флагом и держите реализацию на Luna как запасную, пока API в бете.

Как сделать то же на GPT-6 Luna: строгая JSON-схема с enum

До публичной беты это был единственный способ получить решение из списка, а теперь — запасной путь и вариант для длинных кешируемых инструкций, шлюзов без Decisions и задач, где нужен свой JSON. На странице GPT-6 Luna указано всё нужное: вход текстом и изображениями, Structured Outputs, reasoning.effort от none до max, поддержка Responses API, Chat Completions и Batch. Structured Outputs с strict: true заставляет ответ соответствовать JSON-схеме; если единственное поле схемы — enum, модель может вернуть только значение из вашего списка. Требования руководства: все поля перечислены в required, в каждом объекте additionalProperties: false, во всей схеме не больше 1 000 значений enum.

Функция decide() на Responses API

Полный скрипт для Python 3.10+ и пакета openai; ключ читается из переменной окружения OPENAI_API_KEY. Вариант unsure добавляется к каждому списку автоматически.

python
import json
import logging

import openai
from openai import OpenAI

client = OpenAI()
UNSURE = "unsure"


def decide(question: str, options: list[str], text: str,
           image_url: str | None = None) -> str:
    """Возвращает один вариант из options или UNSURE."""
    allowed = options + [UNSURE]
    schema = {
        "type": "object",
        "properties": {"answer": {"type": "string", "enum": allowed}},
        "required": ["answer"],
        "additionalProperties": False,
    }
    content = [{"type": "input_text", "text": text}]
    if image_url:
        content.append({"type": "input_image", "image_url": image_url})

    try:
        resp = client.responses.create(
            model="gpt-6-luna",
            reasoning={"effort": "none"},
            input=[
                {"role": "developer",
                 "content": f"{question} Если данных не хватает или ни один "
                            f"вариант не подходит, ответь {UNSURE}."},
                {"role": "user", "content": content},
            ],
            text={"format": {"type": "json_schema", "name": "decision",
                             "strict": True, "schema": schema}},
        )
    except openai.APIError as err:
        logging.warning("decide: ошибка API: %s", err)
        return UNSURE

    if resp.status != "completed":      # например, incomplete
        return UNSURE
    try:
        answer = json.loads(resp.output_text)["answer"]
    except (ValueError, KeyError, TypeError):
        return UNSURE                    # отказ модели или пустой ответ
    return answer if answer in allowed else UNSURE


if __name__ == "__main__":
    print(decide(
        "В какую очередь отправить обращение?",
        ["billing", "shipping", "technical", "other"],
        "С меня дважды списали деньги за заказ №4471",
    ))

Что здесь важно:

  • reasoning={"effort": "none"} отключает рассуждения: так ответ приходит быстрее и не тратит токены на рассуждения. Если точность на ваших примерах не устраивает, попробуйте low и сравните задержку и цену.
  • Инструкция про unsure нужна не для красоты. Руководство Structured Outputs предупреждает: на входе, который не подходит под схему, модель всё равно старается ей соответствовать и может выдумать ответ. Без отдельного варианта ей некуда деться.
  • Отказ модели, обрезанный ответ и ошибку API функция тоже превращает в unsure, так что вызывающему коду достаточно обработать один запасной исход.
  • Проверка answer in allowed дублирует схему. Она почти ничего не стоит и спасёт, если вызов однажды пойдёт через сервис, который схему не соблюдает.
  • Длинную постоянную часть инструкции держите в начале и без изменений: только одинаковый префикс от 1 024 токенов попадает в кеш.

Скриншоты и фото в том же вызове

Изображение передаётся вторым элементом content с типом input_image: в Responses API в image_url подойдёт ссылка https://… или data URL вида data:image/png;base64,…. Так тот же decide() решает, к какой очереди относится скриншот ошибки или можно ли принять возврат по фото. Картинка добавляет входные токены, и их число зависит от размера изображения, поэтому стоимость таких решений считайте по фактическому расходу в первых вызовах.

Та же сигнатура на Decisions API

Вторая реализация для шага 2 из плана переноса. Она написана по форме запросов из руководства OpenAI; порог min_confidence — заглушка, которую нужно подобрать на ваших размеченных примерах.

python
import logging

import openai
from openai import OpenAI

client = OpenAI()  # пакет openai 3.26.0 или новее
UNSURE = "unsure"


def decide_v2(question: str, options: dict[str, str], text: str,
              image_base64_png: str | None = None,
              min_confidence: float = 0.8) -> str:
    """options: {значение: когда его выбирать}. Возвращает значение или UNSURE."""
    choices = [{"value": v, "description": d} for v, d in options.items()]
    choices.append({"value": UNSURE,
                    "description": "Данных не хватает или ни один вариант не подходит."})
    content = [{"type": "input_text", "text": text}]
    if image_base64_png:
        content.append({"type": "input_image",
                        "image_url": f"data:image/png;base64,{image_base64_png}"})
    try:
        decision = client.decisions.create(
            model="gpt-6-luna",
            input=[{"role": "user", "content": content}],
            questions=[{"type": "choice", "name": "answer",
                        "instructions": question, "choices": choices}],
        )
    except openai.APIError as err:
        logging.warning("decide_v2: ошибка API: %s", err)
        return UNSURE

    answer = decision.answers[0]
    if answer.type != "choice":          # refusal
        return UNSURE
    if answer.confidence < min_confidence:
        return UNSURE
    return answer.choice

Вызывающий код по-прежнему получает одно значение или unsure, поэтому переключение между decide() и decide_v2() сводится к флагу. Пишите в лог вопрос, версию инструкции, ответ, confidence, задержку и итоговое решение человека, если оно было: без этого порог не подобрать.

Строгая схема гарантирует формат, а не правильный ответ

Строгая схема отвечает за одно: в ответе будет значение из списка. Правильность она не гарантирует — руководство OpenAI прямо пишет, что Structured Outputs «can still contain mistakes». То же верно для choice в Decisions: API вернёт одно из ваших значений, но не обязательно верное.

Насколько велика разница между задачами, показывает тест eesel: 20 обращений, четыре настройки (Luna с рассуждениями none, low, medium и GPT-6.1 Sol), по два прогона, 160 вызовов. Очередь все настройки выбрали верно в 40 случаях из 40, а на вопросе «можно ли ответить автоматически» Luna без рассуждений справилась в 33 из 40, Sol — в 39 из 40. Выборка маленькая, и тест проводил поставщик, который продаёт собственный продукт для поддержки, но направление понятно: выбрать отдел легко, понять, когда не действовать, — трудно.

Вероятности Decisions API: пороги подбирайте на своих данных

Поля probability и confidence соблазнительно сразу превратить в порог «выше 0,9 — действуем сами». Первые сторонние проверки советуют не спешить:

  • classmethod прогнал официальные примеры по пять раз и получил для billing вероятность 1,0 и confidence 1,0 во всех прогонах, хотя иллюстрация в документации показывает 0,95 и 0,93; значения повторялись от запуска к запуску и шли с точностью до двух знаков;
  • участник форума OpenAI проверил «монету» с известной долей 70 %: predicate дал около 70 %, а choice — около 98 %, и вероятности choice сдвигались при смене порядка вариантов.

Это небольшие тесты, а не заявления OpenAI, но вывод совпадает с рекомендацией самой OpenAI: пороги для маршрутизации, фильтрации и проверки подбирайте на размеченных примерах из своего приложения, исходя из цены ложных срабатываний и пропусков. Если нужна откалиброванная вероятность, начните с predicate; в choice держите запасной вариант вроде other, который отправляет вход в общую очередь на проверку.

Поэтому разделяйте решения по цене ошибки:

  • ошибка дешёвая (не та очередь, не тот тег): действуйте по ответу сразу, ошибки найдутся при разборе;
  • ошибка дорогая — отправка сообщения клиенту, списание или возврат денег, изменение или удаление данных: автоматически действуйте только когда ответ не unsure/other, проходит подобранный порог и ваше правило (белый список разрешённых действий), всё остальное отправляйте человеку.

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

Из России: OpenAI API напрямую недоступен

В списке стран, где работает OpenAI API, России нет, а OpenAI предупреждает: «Accessing or offering access to our services outside of the countries and territories listed below may result in your account being blocked or suspended». Даже бесплатный уровень Free требует, чтобы пользователь находился в разрешённой стране. Обходить это ограничение чужими аккаунтами или подменой страны не стоит: OpenAI прямо пишет о блокировке.

Через сторонние шлюзы Decisions теперь доступен, но не везде:

МаршрутЕсть ли DecisionsЧто учесть
Vercel AI GatewayДа, модель openai/gpt-6-luna-decisions, вход $0,10 за 1 млн токеновВызов идёт через AI SDK Vercel, а не в формате /v1/decisions; код придётся адаптировать
OpenRouterВ каталоге значится «GPT-6 Luna Decisions» за $0,10 за 1 млн входных и $0 за выходные токеныФормат запроса уточняйте в документации OpenRouter
laozhang.aiНет; есть gpt-6-luna через OpenAI-совместимый APIПодходит для реализации на Luna со строгой схемой

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

Для реализации на Luna laozhang.ai даёт gpt-6-luna по тем же ставкам, что у OpenAI: по состоянию на 10 октября 2026 года это $0,10 за вход и $0,50 за выход на 1 млн токенов (таблица моделей laozhang.ai). Документация сервиса описывает запросы в формате Chat Completions, поэтому там удобнее вариант со схемой в response_format:

python
from openai import OpenAI

client = OpenAI(base_url="https://api.laozhang.ai/v1", api_key="ВАШ_КЛЮЧ")

schema = {
    "type": "object",
    "properties": {"answer": {"type": "string",
                              "enum": ["billing", "shipping", "technical",
                                       "other", "unsure"]}},
    "required": ["answer"],
    "additionalProperties": False,
}

resp = client.chat.completions.create(
    model="gpt-6-luna",
    reasoning_effort="none",
    messages=[
        {"role": "system",
         "content": "В какую очередь отправить обращение? "
                    "Если ни одна не подходит, ответь unsure."},
        {"role": "user", "content": "С меня дважды списали деньги за заказ №4471"},
    ],
    response_format={"type": "json_schema",
                     "json_schema": {"name": "decision", "strict": True,
                                     "schema": schema}},
)
print(resp.choices[0].message.content)

Передаёт ли шлюз строгую схему и reasoning_effort до модели без изменений, нужно проверить одним тестовым вызовом до запуска: ответ должен быть JSON с одним полем answer и значением из списка, а на постороннее сообщение («какая погода завтра?») — unsure. Проверку answer in allowed в своём коде оставьте в любом случае. Другие варианты доступа, включая российские модели GigaChat и YandexGPT, собраны в руководстве «Как использовать OpenAI API в России: прокси, GigaChat, YandexGPT и шлюзы».

Частые вопросы о Decisions API

Сколько стоит OpenAI Decisions API?

$0,10 за 1 млн входных токенов на gpt-6-luna; за выходные токены, чтение и запись кеша плата не берётся. При 400 входных токенах это $0,00004 за решение, $0,04 за тысячу и $40 за миллион. Скидки на кешированный вход нет, а надбавки за региональную обработку и длинный контекст действуют. Цена указана в руководстве Decisions, а не на общей странице цен, и относится к бете: цену после GA OpenAI не объявляла.

Бесплатен ли Decisions API?

Нет. «Выход не тарифицируется» не означает «бесплатно»: каждый входной токен оплачивается по $0,10 за миллион. Можно ли вызывать Decisions на бесплатном уровне Free, OpenAI не уточняет.

Когда Decisions API откроют для всех?

Уже открыли: с 6 октября 2026 года (по времени США) Decisions API в публичной бете для всех разработчиков OpenAI API в поддерживаемых странах. Следующий этап — GA; OpenAI пишет, что ожидает его «в ближайшие недели», но дату не называет.

Чем Decisions API отличается от Jev?

Jev — отдельная модель для решений от компании TypeSafe, принимает только текст. Decisions API принимает и изображения и работает внутри платформы OpenAI с ZDR, HIPAA и резидентностью данных в США и Европе. Сторонние сравнения расходятся: у classmethod задержка сопоставимая (255 мс против 238 мс у Jev), а запрос на 406 входных токенов обошёлся в $0,0000406 против $0,0000169 у Jev; один участник форума OpenAI считает Jev точнее в спорных случаях, а в другом тесте на документах все модели показали почти одинаковый результат. Проверяйте на своих данных.

Есть ли Decisions API в ChatGPT?

Нет, это endpoint OpenAI API для разработчиков. Вызывать его можно из кода через POST /v1/decisions или пробовать в Playground на platform.openai.com; о функции в интерфейсе ChatGPT OpenAI не сообщала.

Нашли ошибку или столкнулись с проблемой, которой нет в статье? Отправьте адрес статьи и описание на hi@laozhang.ai. Мы проверим и обновим текст.