OpenAI API de Decisiones vs API de Respuestas

Utilice la API de Decisions cuando el trabajo sea clasificar, enrutar, puntuar o controlar algo y desee obtener probabilidades: se ejecuta en GPT-6 Luna, devuelve respuestas tipadas en lugar de texto, factura la entrada a solo $0.10 por 1M de tokens sin cargos de salida, lectura o escritura en caché, y OpenAI dice que es aproximadamente 10 veces más rápida que la API de Responses. Utilice la API de Responses cuando necesite texto generado, JSON en su propio esquema, llamadas a herramientas, streaming o estado de conversación. Decisions entró en beta pública el 06-10-2026.

Esta publicación ejecuta una tarea (enrutar un ticket de soporte) a través de ambos endpoints, compara lo que devuelve cada uno, calcula el costo una vez y concluye con una nota de migración y una forma de probar ambos en un proyecto de Apidog. Para la anatomía del endpoint, comience con el pilar de la API de Decisions; para la base, consulte nuestra guía de la API de Responses.

Matriz de características

Cada fila proviene de la guía de Decisions de OpenAI, la referencia de la API y la página de precios.

La misma tarea de dos maneras: enrutar un ticket de soporte

El ticket dice “Se me cobró dos veces por mi pedido.” Los departamentos son facturación, técnico, envío y otros. Aquí está la solicitud de Responses con Salidas Estructuradas, que es como la mayoría de los equipos lo hacen hoy en día:

curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-luna",
    "input": "Route this support ticket to one department.\n\nTicket: I was charged twice for my order.",
    "text": {
      "format": {
        "type": "json_schema",
        "name": "ticket_route",
        "strict": true,
        "schema": {
          "type": "object",
          "properties": {
            "department": {
              "type": "string",
              "enum": ["billing", "technical", "shipping", "other"]
            }
          },
          "required": ["department"],
          "additionalProperties": false
        }
      }
    }
  }'

Y la solicitud de Decisions para el mismo ticket:

curl https://api.openai.com/v1/decisions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-luna",
    "input": "I was charged twice for my order.",
    "questions": [
      {
        "type": "choice",
        "name": "department",
        "instructions": "Which department should handle this ticket?",
        "choices": [
          {"value": "billing", "description": "Charges, refunds, invoices"},
          {"value": "technical", "description": "Bugs, errors, login problems"},
          {"value": "shipping", "description": "Delivery, tracking, returns in transit"},
          {"value": "other", "description": "Anything else"}
        ]
      }
    ]
  }'

El cuerpo de Responses lleva la pregunta dentro del prompt y las respuestas permitidas dentro de un esquema. El cuerpo de Decisions lleva el ticket original como input y la pregunta como una choice con 2 a 255 valores únicos; no tiene campos temperature, reasoning, stream o text, porque ninguno existe en ese endpoint.

Lo que devuelve cada uno

Responses devuelve texto generado. Con un esquema estricto, ese texto es JSON válido, por lo que después de analizarlo, se obtiene una etiqueta:

{"department": "billing"}

Si desea un número de confianza, añada un campo al esquema y pida al modelo que lo escriba; lo que regresa es texto generado que parece una probabilidad, no una medida.

Decisions devuelve la etiqueta más la distribución subyacente. Los números a continuación son el ejemplo de la guía de OpenAI para esta entrada exacta:

{
  "model": "gpt-6-luna",
  "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
    }
  ]
}

Un objeto usage sigue a answers (mostrado en la sección de costos). Sin analizador, sin regex. El campo confidence es lo que se utiliza como umbral, y la guía de OpenAI es establecer ese umbral a partir de sus propios ejemplos etiquetados, porque no se publican cifras de precisión o calibración. Una negativa llega como {"type": "refusal", "name": "department"}; otras preguntas en la misma solicitud aún reciben respuestas.

Costo: la aritmética una vez

Ambos endpoints facturan la entrada de Luna a $0.10 por 1M de tokens en contexto corto (hasta 272K tokens de entrada). La división está en la salida. Tomemos un ticket de 500 tokens con 1,000,000 de solicitudes:

• Decisions: 500 / 1,000,000 x $0.10 = $0.00005 por solicitud, lo que suma $50 por el millón, sin líneas de salida o caché que añadir.
• Responses: los mismos $50 de entrada, más salida a $0.50 por 1M. Una etiqueta JSON de 40 tokens es 40 / 1,000,000 x $0.50 = $0.00002 por solicitud, o $20 por el millón. Luego, añada los tokens de razonamiento, que Luna factura como salida al mismo precio de $0.50.

Entonces, la brecha visible solo en la etiqueta es de $50 frente a $70. La brecha mayor es la línea de razonamiento, y la forma honesta de decirlo es que Decisions no factura ningún token de salida; ambos contadores marcan 0 en el ejemplo de referencia de OpenAI:

"usage": {
  "input_tokens": 42,
  "input_tokens_details": {"cached_tokens": 0, "cache_write_tokens": 0},
  "output_tokens": 0,
  "output_tokens_details": {"reasoning_tokens": 0},
  "total_tokens": 42
}

Dos advertencias. Responses tiene palancas que Decisions no tiene: reasoning.effort se reduce a none en Luna, el almacenamiento en caché de prompts reduce la entrada repetida a $0.01 por 1M, y la API de Batch reduce a la mitad las tarifas estándar. Ninguno de estos está documentado para Decisions. Y la entrada de contexto largo (más de 272K tokens) duplica la tarifa de entrada en ambos, por lo que una solicitud larga de Decisions es de $0.20 por 1M de entrada (derivado del multiplicador de la página de precios); el procesamiento regional añade un 10%.

Velocidad

OpenAI afirma que la API de Decisions es aproximadamente 10 veces más rápida que la API de Responses. No se publica ningún número absoluto de latencia, así que trate la afirmación como una dirección en lugar de un presupuesto y mida su propio p50 y p95 antes de mover una ruta crítica. Un desarrollador en el foro de OpenAI informó que las decisiones con entrada de imagen se devolvían en aproximadamente 0.8 segundos en una conexión lenta; eso es una anécdota, no un benchmark. La dirección es plausible: Responses genera tokens, incluido el razonamiento, y usted espera hasta el último.

La regla de decisión

Elija Decisions cuando la salida sea una de estas:

• Un sí/no con una probabilidad (predicate): “¿Es este mensaje spam?”
• Una de N categorías no ordenadas (choice): departamento, intención, qué modelo o herramienta llamar a continuación. Incluya una opción de reserva como “otro”.
• Un nivel ordenado (score): gravedad, prioridad, urgencia. La puntuación es un promedio ponderado por probabilidad de índices de nivel basados en 0, por lo que 1.1 significa entre el nivel 1 y el nivel 2, cerca de 1.
• Una puerta: compare confidence o probability con un umbral y envíe los elementos de baja confianza a una cola humana.

Elija Responses cuando cualquiera de estas sea verdadera:

• Necesita texto que una persona leerá: un resumen, una respuesta, una explicación.
• Necesita un objeto con su propia forma: campos extraídos, estructuras anidadas, arrays de longitud desconocida. Ese es el territorio de las Salidas Estructuradas, y la guía de OpenAI así lo indica.
• El modelo debe solicitar una llamada a herramienta con argumentos: llamada a funciones.
• Necesita streaming, estado de conversación o un modelo distinto de Luna.
• Una decisión depende de otra y desea ambas en un solo viaje de ida y vuelta. Decisions contiene varias preguntas independientes sobre una entrada, pero las decisiones dependientes requieren solicitudes separadas.

Muchas pipelines desean ambos: Decisions para clasificar y controlar, Responses para escribir la respuesta.

Migrando un clasificador de Responses a Decisions

Si ya enruta tickets con un esquema enum estricto, el cambio es pequeño:

1. Conserve el mismo input, reducido al ticket original; la pregunta se mueve fuera del prompt.
2. Ponga la pregunta en questions como una choice, con sus valores enum como choices[].value y una description de una línea para cada uno. Los valores pueden ser cadenas o booleanos, y true y "true" son distintos.
3. Elimine el analizador. Lea answers[0].choice y answers[0].confidence; las respuestas llegan en el orden que solicitó y reflejan el name que estableció. Luego, establezca un umbral a partir de una muestra etiquetada.
4. Verifique la ruta de entrada. Decisions solo acepta mensajes de usuario: sin roles de sistema o asistente, sin llamadas a funciones, sin archivos, sin file_id. Incorpore las reglas del prompt del sistema en instructions o en las descripciones de las opciones. Las imágenes se introducen como URLs de datos base64; la referencia también lista URLs HTTP(S) públicas, así que pruebe primero las imágenes alojadas.
5. Divida las cadenas. “Clasificar, luego si es facturación, decidir la elegibilidad del reembolso” se convierte en dos solicitudes.

Pruebe ambos en un proyecto de Apidog

La forma más limpia de decidir es ejecutar ambas solicitudes contra los mismos tickets etiquetados y comparar. En Apidog, almacene la clave una vez como variable de entorno y haga referencia a {{OPENAI_API_KEY}} en el encabezado Authorization: Bearer de ambas solicitudes guardadas, para que ninguna clave literal termine en un cuerpo guardado.

Dé a ambas solicitudes la misma aserción: el departamento es igual a billing. En la solicitud de Decisions, es una aserción JSONPath en $.answers[0].choice, con $.answers[0].confidence mayor que 0.8 y $.usage.output_tokens igual a 0 al lado. En la solicitud de Responses, la etiqueta se encuentra dentro del texto generado, por lo que un script post-solicitud corto lo analiza en una variable que la aserción verifica. Luego, compare el usage en las dos respuestas: Decisions informa cero tokens de salida y razonamiento, Responses no.

Convierta el par en un escenario de prueba basado en datos sobre un CSV de texto de tickets y departamento esperado, y la ejecución mostrará cuántos tickets cada endpoint enruta correctamente por encima de su línea de confianza. Simule el array answers para que el enrutador pueda construirse primero, como en respuestas mock condicionales, y ejecute el escenario en CI con la CLI de Apidog para que un cambio de redacción o de alias de modelo falle una prueba en lugar de enrutar incorrectamente los tickets. Consulte pruebas de aplicaciones LLM para obtener más patrones de aserción.

Preguntas frecuentes

¿Puede la API de Responses devolver probabilidades como lo hace Decisions? No como valores medidos. Un campo confidence en un esquema JSON le proporciona un número que el modelo escribió, que es texto generado. Decisions devuelve probabilidades sobre las opciones que usted proporcionó desde el propio endpoint.

¿Puedo usar un modelo diferente a GPT-6 Luna en Decisions? No. La guía indica que gpt-6-luna es el único modelo disponible actualmente. Consulte nuestra descripción general de GPT-6 Luna.

¿En qué se diferencia Decisions de Jev de TypeSafe? Ambos devuelven respuestas tipadas con probabilidades y facturan solo la entrada; difieren en precio, entradas y formas de respuesta. Vea API de Decisions vs Jev.

¿Es gratuita la API de Decisions? No. Cobra $0.10 por 1M de tokens de entrada, sin un nivel Decisions gratuito documentado. Para rutas gratuitas a Luna, vea cómo usar GPT-6 Luna gratis.

Siguiente paso

Tome un clasificador que ejecute hoy a través de Responses, reajústelo como una pregunta de choice y ejecute ambos sobre 50 tickets etiquetados en Apidog con la misma aserción. Si el umbral de confianza se mantiene y el uso muestra cero tokens de salida, tendrá su respuesta. Descargue Apidog, luego siga cómo usar la API de Decisions para la primera llamada y el recorrido completo de prueba.