OpenAI API Décisions vs API Réponses

Utilisez l'API Decisions lorsque la tâche consiste à classifier, acheminer, noter ou filtrer quelque chose et que vous souhaitez obtenir des probabilités en retour : elle fonctionne sur GPT-6 Luna, renvoie des réponses typées au lieu de texte, facture l'entrée uniquement à 0,10 $ par million de jetons sans frais de sortie, de lecture ou d'écriture de cache, et OpenAI affirme qu'elle est environ 10 fois plus rapide que l'API Responses. Utilisez l'API Responses lorsque vous avez besoin de texte généré, de JSON selon votre propre schéma, d'appels d'outils, de streaming ou de l'état de la conversation. Decisions est entrée en bêta publique le 06/10/2026.

Cet article exécute une tâche (acheminer un ticket de support) via les deux endpoints, compare ce que chacun renvoie, calcule le coût une fois, et se termine par une note de migration et une façon de tester les deux dans un seul projet Apidog. Pour l'anatomie de l'endpoint, commencez par le pilier de l'API Decisions ; pour la référence, consultez notre guide de l'API Responses.

Matrice des fonctionnalités

Chaque ligne provient du guide Decisions d'OpenAI, de la référence API et de la page de tarification.

La même tâche des deux manières : acheminer un ticket de support

Le ticket indique « J'ai été facturé deux fois pour ma commande ». Les départements sont facturation, technique, expédition et autre. Voici la requête Responses avec des Sorties Structurées, ce qui est la manière dont la plupart des équipes le font aujourd'hui :

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
        }
      }
    }
  }'

Et la requête Decisions pour le même 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"}
        ]
      }
    ]
  }'

Le corps de la requête Responses contient la question à l'intérieur de l'invite (prompt) et les réponses autorisées à l'intérieur d'un schéma. Le corps de la requête Decisions contient le ticket brut comme input et la question comme un choice avec 2 à 255 valeurs uniques ; il n'a pas de champs temperature, reasoning, stream ou text, car aucun n'existe sur cet endpoint.

Ce que chacun renvoie

Responses renvoie du texte généré. Avec un schéma strict, ce texte est un JSON valide, donc après analyse, vous obtenez une étiquette :

{"department": "billing"}

Si vous voulez un nombre de confiance, vous ajoutez un champ au schéma et demandez au modèle d'en écrire un ; ce qui revient est un texte généré qui ressemble à une probabilité, pas une probabilité mesurée.

Decisions renvoie l'étiquette plus la distribution qui la sous-tend. Les nombres ci-dessous sont l'exemple du guide d'OpenAI pour cette entrée exacte :

{
  "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 objet usage suit answers (montré dans la section sur le coût). Pas de parseur, pas d'expressions régulières. Le champ confidence est ce que vous seuillez, et les directives d'OpenAI sont de définir ce seuil à partir de vos propres exemples étiquetés, car aucune donnée de précision ou de calibration n'est publiée. Un refus arrive sous la forme {"type": "refusal", "name": "department"} ; les autres questions de la même requête reçoivent toujours des réponses.

Coût : le calcul une fois pour toutes

Les deux endpoints facturent l'entrée Luna à 0,10 $ par million de jetons en contexte court (jusqu'à 272K jetons d'entrée). La différence est sur la sortie. Prenons un ticket de 500 jetons pour 1 000 000 de requêtes :

• Decisions : 500 / 1 000 000 x 0,10 $ = 0,00005 $ par requête, soit 50 $ pour le million, sans frais de sortie ou de cache à ajouter.
• Responses : les mêmes 50 $ d'entrée, plus la sortie à 0,50 $ par million. Une étiquette JSON de 40 jetons coûte 40 / 1 000 000 x 0,50 $ = 0,00002 $ par requête, soit 20 $ pour le million. Ajoutez ensuite les jetons de raisonnement, que Luna facture en sortie au même tarif de 0,50 $.

Ainsi, l'écart visible pour l'étiquette seule est de 50 $ contre 70 $. L'écart plus important concerne la ligne de raisonnement, et la manière honnête de l'exprimer est que Decisions ne facture aucun jeton de sortie ; les deux compteurs affichent 0 dans l'exemple de référence d'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
}

Deux mises en garde. Responses dispose de leviers que Decisions n'a pas : reasoning.effort peut être réduit à none sur Luna, la mise en cache des invites réduit les entrées répétées à 0,01 $ par million, et l'API Batch divise par deux les tarifs standards. Aucun de ceux-ci n'est documenté pour Decisions. Et l'entrée en contexte long (plus de 272K jetons) double le taux d'entrée sur les deux, donc une longue requête Decisions coûte 0,20 $ par million d'entrées (dérivé du multiplicateur de la page de tarification) ; le traitement régional ajoute 10 %.

Vitesse

OpenAI affirme que l'API Decisions est environ 10 fois plus rapide que l'API Responses. Aucun chiffre de latence absolue n'est publié, alors considérez cette affirmation comme une indication plutôt qu'un budget et mesurez vos propres p50 et p95 avant de déplacer un chemin critique. Un développeur sur le forum d'OpenAI a signalé que les décisions d'entrée d'image revenaient en environ 0,8 seconde sur une connexion lente ; c'est une anecdote, pas un benchmark. Cette direction est plausible : Responses génère des jetons, raisonnement inclus, et vous attendez le dernier.

La règle de décision

Choisissez Decisions lorsque la sortie est l'une des suivantes :

• Un oui/non avec une probabilité (predicate) : « Ce message est-il du spam ? »
• L'une des N catégories non ordonnées (choice) : département, intention, quel modèle ou outil appeler ensuite. Incluez un mécanisme de repli comme « autre ».
• Un niveau ordonné (score) : gravité, priorité, urgence. Le score est une moyenne pondérée par la probabilité des indices de niveau basés sur 0, donc 1,1 signifie entre le niveau 1 et le niveau 2, proche de 1.
• Une porte : comparez la confidence ou la probability à un seuil et envoyez les éléments à faible confiance à une file d'attente humaine.

Choisissez Responses si l'une des conditions suivantes est vraie :

• Vous avez besoin de texte qu'une personne lira : un résumé, une réponse, une explication.
• Vous avez besoin d'un objet de votre propre forme : champs extraits, structures imbriquées, tableaux de longueur inconnue. C'est le territoire des Sorties Structurées, et le guide d'OpenAI le dit.
• Le modèle doit demander un appel d'outil avec des arguments : appel de fonction.
• Vous avez besoin de streaming, de l'état de la conversation, ou d'un modèle autre que Luna.
• Une décision dépend d'une autre et vous voulez les deux en un seul aller-retour. Decisions gère plusieurs questions indépendantes sur une seule entrée, mais les décisions dépendantes nécessitent des requêtes séparées.

De nombreuses pipelines veulent les deux : Decisions pour classer et filtrer, Responses pour écrire la réponse.

Migration d'un classificateur de Responses vers Decisions

Si vous acheminez déjà des tickets avec un schéma d'énumération strict, la migration est minime :

1. Gardez le même input, réduit au ticket brut ; la question sort de l'invite (prompt).
2. Placez la question dans questions comme un choice, avec vos valeurs d'énumération comme choices[].value et une description d'une ligne pour chacune. Les valeurs peuvent être des chaînes de caractères ou des booléens, et true et "true" sont distincts.
3. Supprimez le parseur. Lisez answers[0].choice et answers[0].confidence ; les réponses arrivent dans l'ordre demandé et reflètent le name que vous avez défini. Définissez ensuite un seuil à partir d'un échantillon étiqueté.
4. Vérifiez le chemin d'entrée. Decisions n'accepte que les messages utilisateur : pas de rôles système ou assistant, pas d'appels de fonction, pas de fichiers, pas de file_id. Intégrez les règles d'invite système dans les instructions ou les descriptions de choix. Les images sont transmises sous forme d'URLs de données base64 ; la référence liste également les URLs HTTP(S) publiques, alors testez d'abord les images hébergées.
5. Divisez les chaînes. « Classer, puis si c'est de la facturation, décider de l'éligibilité au remboursement » devient deux requêtes.

Testez les deux dans un seul projet Apidog

La manière la plus propre de décider est d'exécuter les deux requêtes sur les mêmes tickets étiquetés et de comparer. Dans Apidog, stockez la clé une fois comme variable d'environnement et référencez {{OPENAI_API_KEY}} dans l'en-tête Authorization: Bearer des deux requêtes enregistrées, afin qu'aucune clé littérale n'atterrisse dans un corps enregistré.

Donnez aux deux requêtes la même assertion : le département est égal à billing. Sur la requête Decisions, il s'agit d'une assertion JSONPath sur $.answers[0].choice, avec $.answers[0].confidence supérieur à 0,8 et $.usage.output_tokens égal à 0 à côté. Sur la requête Responses, l'étiquette se trouve dans le texte généré, donc un court script post-requête l'analyse en une variable que l'assertion vérifie. Comparez ensuite usage sur les deux réponses : Decisions signale zéro jeton de sortie et de raisonnement, Responses non.

Transformez la paire en un scénario de test piloté par les données à partir d'un CSV de texte de ticket et de département attendu, et l'exécution montre combien de tickets chaque endpoint achemine correctement au-dessus de votre ligne de confiance. Simulez le tableau answers afin que le routeur puisse être construit en premier, comme dans les réponses de simulation conditionnelles, et exécutez le scénario en CI avec l'interface CLI Apidog afin qu'un changement de formulation ou d'alias de modèle échoue à un test au lieu de mal acheminer les tickets. Voir tester les applications LLM pour plus de modèles d'assertion.

FAQ

L'API Responses peut-elle renvoyer des probabilités comme Decisions ? Pas en tant que valeurs mesurées. Un champ confidence dans un schéma JSON vous donne un nombre écrit par le modèle, qui est du texte généré. Decisions renvoie des probabilités sur les options que vous avez fournies, directement depuis l'endpoint.

Puis-je utiliser un modèle autre que GPT-6 Luna sur Decisions ? Non. Le guide indique que gpt-6-luna est le seul modèle actuellement disponible. Consultez notre aperçu de GPT-6 Luna.

En quoi Decisions est-elle différente de Jev de TypeSafe ? Les deux renvoient des réponses typées avec des probabilités et facturent uniquement l'entrée ; elles diffèrent sur le prix, les entrées et les formes de réponse. Voir API Decisions vs Jev.

L'API Decisions est-elle gratuite ? Non. Elle facture 0,10 $ par million de jetons d'entrée, sans niveau gratuit de Decisions documenté. Pour les routes gratuites vers Luna elle-même, consultez comment utiliser GPT-6 Luna gratuitement.

Étape suivante

Prenez un classificateur que vous utilisez actuellement via Responses, reconstruisez-le comme une question choice, et exécutez les deux sur 50 tickets étiquetés dans Apidog avec la même assertion. Si le seuil de confiance est respecté et que l'utilisation montre zéro jeton de sortie, vous avez votre réponse. Téléchargez Apidog, puis suivez comment utiliser l'API Decisions pour le premier appel et le parcours de test complet.