OpenAI Decisions API vs. Responses API Vergleich

Nutzen Sie die Decisions API, wenn die Aufgabe darin besteht, etwas zu klassifizieren, zu routen, zu bewerten oder zu filtern und Sie Wahrscheinlichkeiten zurückerhalten möchten: Sie läuft auf GPT-6 Luna, gibt typisierte Antworten anstelle von Text zurück, berechnet die Eingabe nur mit 0,10 $ pro 1 Mio. Tokens ohne Ausgabe-, Cache-Lese- oder Cache-Schreibgebühren, und OpenAI sagt, sie sei etwa 10-mal schneller als die Responses API. Nutzen Sie die Responses API, wenn Sie generierten Text, JSON in Ihrem eigenen Schema, Tool-Aufrufe, Streaming oder Konversationszustand benötigen. Decisions wurde am 06.10.2026 in die öffentliche Beta-Phase überführt.

Dieser Beitrag führt eine Aufgabe (das Weiterleiten eines Support-Tickets) über beide Endpunkte aus, vergleicht, was jeder zurückgibt, berechnet die Kosten einmal und schließt mit einem Migrationshinweis und einer Möglichkeit, beide in einem Apidog-Projekt zu testen. Für die Anatomie des Endpunkts beginnen Sie mit dem Grundpfeiler der Decisions API; für die Grundlagen, siehe unseren Leitfaden zur Responses API.

Funktionsmatrix

Jede Zeile stammt aus dem Decisions-Leitfaden von OpenAI, der API-Referenz und der Preisseite.

Die gleiche Aufgabe auf beide Arten: ein Support-Ticket weiterleiten

Das Ticket lautet: „Mir wurde meine Bestellung zweimal berechnet.“ Die Abteilungen sind Abrechnung, Technik, Versand und Sonstiges. Hier ist die Responses-Anfrage mit strukturierten Ausgaben, wie es die meisten Teams heute tun:

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

Und die Decisions-Anfrage für dasselbe 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"}
        ]
      }
    ]
  }'

Der Responses-Body enthält die Frage innerhalb des Prompts und die erlaubten Antworten innerhalb eines Schemas. Der Decisions-Body enthält das rohe Ticket als input und die Frage als choice mit 2 bis 255 einzigartigen Werten; er hat keine temperature-, reasoning-, stream- oder text-Felder, da diese an diesem Endpunkt nicht existieren.

Was jeder zurückgibt

Responses gibt generierten Text zurück. Mit einem strengen Schema ist dieser Text gültiges JSON, sodass Sie nach dem Parsen ein Label erhalten:

{"department": "billing"}

Wenn Sie eine Konfidenzzahl wünschen, fügen Sie dem Schema ein Feld hinzu und bitten das Modell, eines zu schreiben; was zurückkommt, ist generierter Text, der wie eine Wahrscheinlichkeit aussieht, und keine gemessene.

Decisions gibt das Label plus die dahinterliegende Verteilung zurück. Die unten stehenden Zahlen sind das Beispiel aus dem OpenAI-Leitfaden für genau diese Eingabe:

{
  "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
    }
  ]
}

Ein usage-Objekt folgt answers (im Kostenabschnitt gezeigt). Kein Parser, kein Regex. Das Feld confidence ist das, was Sie als Schwellenwert verwenden, und OpenAIs Empfehlung ist, diesen Schwellenwert anhand Ihrer eigenen gelabelten Beispiele festzulegen, da keine Genauigkeits- oder Kalibrierungsdaten veröffentlicht werden. Eine Ablehnung kommt als {"type": "refusal", "name": "department"} an; andere Fragen in derselben Anfrage erhalten weiterhin Antworten.

Kosten: die Berechnung einmalig

Beide Endpunkte berechnen Luna-Eingaben mit 0,10 $ pro 1 Mio. Tokens im kurzen Kontext (bis zu 272.000 Eingabe-Tokens). Die Aufteilung erfolgt bei der Ausgabe. Nehmen Sie ein 500-Token-Ticket bei 1.000.000 Anfragen:

• Decisions: 500 / 1.000.000 x 0,10 $ = 0,00005 $ pro Anfrage, also 50 $ für die Million, ohne Ausgabe- oder Cache-Zeilen hinzuzufügen.
• Responses: die gleichen 50 $ Eingabe, plus Ausgabe zu 0,50 $ pro 1 Mio. Ein 40-Token-JSON-Label kostet 40 / 1.000.000 x 0,50 $ = 0,00002 $ pro Anfrage oder 20 $ für die Million. Dazu kommen noch Reasoning-Tokens, die Luna als Ausgabe zum gleichen Preis von 0,50 $ abrechnet.

Der sichtbare Unterschied beim Label allein beträgt also 50 $ gegenüber 70 $. Der größere Unterschied liegt in der Reasoning-Zeile, und die ehrliche Aussage ist, dass Decisions überhaupt keine Ausgabe-Tokens abrechnet; beide Zähler zeigen im OpenAI-Referenzbeispiel 0 an:

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

Zwei Vorbehalte. Responses verfügt über Hebel, die Decisions nicht hat: reasoning.effort geht bei Luna bis auf none herunter, Prompt-Caching reduziert wiederholte Eingaben auf 0,01 $ pro 1 Mio., und die Batch API halbiert die Standardtarife. Nichts davon ist für Decisions dokumentiert. Und Long-Context-Eingaben (über 272.000 Tokens) verdoppeln die Eingaberate bei beiden, sodass eine lange Decisions-Anfrage 0,20 $ pro 1 Mio. Eingaben kostet (abgeleitet vom Multiplikator der Preisseite); regionale Verarbeitung erhöht den Preis um 10 %.

Geschwindigkeit

OpenAI sagt, die Decisions API sei etwa 10-mal schneller als die Responses API. Es wird keine absolute Latenzzeit veröffentlicht, daher sollte die Behauptung eher als Richtung denn als Budget betrachtet werden, und messen Sie Ihre eigenen p50- und p95-Werte, bevor Sie einen heißen Pfad verschieben. Ein Entwickler im OpenAI-Forum berichtete, dass Bild-Input-Entscheidungen bei langsamer Verbindung in etwa 0,8 Sekunden zurückgegeben wurden; das ist eine Anekdote, kein Benchmark. Die Richtung ist plausibel: Responses generiert Tokens, Reasoning inklusive, und Sie warten auf den letzten.

Die Entscheidungsregel

Wählen Sie Decisions, wenn die Ausgabe eines der folgenden ist:

• Ein Ja/Nein mit einer Wahrscheinlichkeit (predicate): „Ist diese Nachricht Spam?“
• Eine von N ungeordneten Kategorien (choice): Abteilung, Absicht, welches Modell oder Tool als Nächstes aufgerufen werden soll. Fügen Sie einen Fallback wie „other“ hinzu.
• Ein geordnetes Level (score): Schweregrad, Priorität, Dringlichkeit. Der Score ist ein wahrscheinlichkeitsgewichteter Durchschnitt von 0-basierten Level-Indizes, d.h. 1,1 bedeutet zwischen Level 1 und Level 2, nahe bei 1.
• Ein Gate: Vergleichen Sie confidence oder probability mit einem Schwellenwert und senden Sie Items mit geringer Konfidenz an eine menschliche Warteschlange.

Wählen Sie Responses, wenn eines der folgenden zutrifft:

• Sie benötigen Text, den eine Person lesen wird: eine Zusammenfassung, eine Antwort, eine Erklärung.
• Sie benötigen ein Objekt in Ihrer eigenen Form: extrahierte Felder, verschachtelte Strukturen, Arrays unbekannter Länge. Das ist das Gebiet der strukturierten Ausgaben, und OpenAIs Leitfaden besagt dies auch.
• Das Modell sollte einen Tool-Aufruf mit Argumenten anfordern: Funktionsaufruf.
• Sie benötigen Streaming, Konversationszustand oder ein anderes Modell als Luna.
• Eine Entscheidung hängt von einer anderen ab und Sie möchten beide in einem Roundtrip. Decisions enthält mehrere unabhängige Fragen zu einer Eingabe, aber abhängige Entscheidungen erfordern separate Anfragen.

Viele Pipelines wollen beides: Decisions zum Klassifizieren und Filtern, Responses zum Schreiben der Antwort.

Migration eines Klassifizierers von Responses zu Decisions

Wenn Sie bereits Tickets mit einem strengen Enum-Schema routen, ist die Umstellung gering:

1. Behalten Sie dasselbe input bei, auf das rohe Ticket reduziert; die Frage wandert aus dem Prompt heraus.
2. Platzieren Sie die Frage in questions als choice, mit Ihren Enum-Werten als choices[].value und jeweils einer einzeiligen description. Werte können Strings oder Booleans sein, und true und "true" sind unterschiedlich.
3. Löschen Sie den Parser. Lesen Sie answers[0].choice und answers[0].confidence; Antworten treffen in der Reihenfolge ein, in der Sie gefragt haben, und spiegeln den von Ihnen gesetzten name wider. Legen Sie dann einen Schwellenwert aus einer gelabelten Stichprobe fest.
4. Überprüfen Sie den Eingabepfad. Decisions akzeptiert nur Benutzernachrichten: keine System- oder Assistentenrollen, keine Funktionsaufrufe, keine Dateien, keine file_id. Fassen Sie System-Prompt-Regeln in instructions oder den Optionsbeschreibungen zusammen. Bilder werden als Base64-Daten-URLs eingefügt; die Referenz listet auch öffentliche HTTP(S)-URLs auf, testen Sie also zuerst gehostete Bilder.
5. Ketten aufteilen. „Klassifizieren, dann bei Abrechnung die Erstattungsberechtigung entscheiden“ werden zu zwei Anfragen.

Beide in einem Apidog-Projekt testen

Der sauberste Weg zur Entscheidung ist, beide Anfragen gegen dieselben gelabelten Tickets auszuführen und zu vergleichen. Speichern Sie in Apidog den Schlüssel einmal als Umgebungsvariable und referenzieren Sie {{OPENAI_API_KEY}} im Authorization: Bearer-Header beider gespeicherter Anfragen, damit kein wörtlicher Schlüssel in einem gespeicherten Body landet.

Geben Sie beiden Anfragen dieselbe Assertion: die Abteilung entspricht billing. Bei der Decisions-Anfrage ist das eine JSONPath-Assertion auf $.answers[0].choice, mit $.answers[0].confidence größer als 0,8 und $.usage.output_tokens gleich 0 daneben. Bei der Responses-Anfrage befindet sich das Label im generierten Text, daher parst ein kurzes Post-Request-Skript es in eine Variable, die die Assertion prüft. Vergleichen Sie dann usage in den beiden Antworten: Decisions meldet null Ausgabe- und Reasoning-Tokens, Responses nicht.

Wandeln Sie das Paar in ein datengesteuertes Testszenario über eine CSV-Datei mit Tickettext und erwarteter Abteilung um, und der Lauf zeigt, wie viele Tickets jeder Endpunkt über Ihrer Konfidenzlinie korrekt routet. Mocken Sie das answers-Array, damit der Router zuerst erstellt werden kann, wie bei bedingten Mock-Antworten, und führen Sie das Szenario in CI mit der Apidog CLI aus, damit eine Änderung der Formulierung oder des Modell-Alias einen Test fehlschlagen lässt, anstatt Tickets falsch zu routen. Siehe Testen von LLM-Anwendungen für weitere Assertionsmuster.

Häufig gestellte Fragen

Kann die Responses API Wahrscheinlichkeiten wie die Decisions API zurückgeben? Nicht als gemessene Werte. Ein confidence-Feld in einem JSON-Schema liefert Ihnen eine Zahl, die das Modell geschrieben hat, was generierter Text ist. Decisions gibt Wahrscheinlichkeiten über die von Ihnen bereitgestellten Optionen direkt vom Endpunkt zurück.

Kann ich ein anderes Modell als GPT-6 Luna auf Decisions verwenden? Nein. Der Leitfaden besagt, dass gpt-6-luna das einzige derzeit verfügbare Modell ist. Siehe unsere GPT-6 Luna Übersicht.

Wie unterscheidet sich Decisions von TypeSafes Jev? Beide geben typisierte Antworten mit Wahrscheinlichkeiten zurück und berechnen nur die Eingabe; sie unterscheiden sich in Preis, Eingaben und Antwortformen. Siehe Decisions API vs. Jev.

Ist die Decisions API kostenlos? Nein. Sie berechnet 0,10 $ pro 1 Mio. Eingabe-Tokens, wobei keine kostenlose Decisions-Stufe dokumentiert ist. Für kostenlose Routen zu Luna selbst, siehe wie man GPT-6 Luna kostenlos nutzt.

Nächster Schritt

Nehmen Sie einen Klassifizierer, den Sie heute über Responses ausführen, bauen Sie ihn als choice-Frage um und führen Sie beide über 50 gelabelte Tickets in Apidog mit derselben Assertion aus. Wenn der Konfidenzschwellenwert hält und die Nutzung null Ausgabe-Tokens anzeigt, haben Sie Ihre Antwort. Laden Sie Apidog herunter und folgen Sie dann der Anleitung zur Verwendung der Decisions API für den ersten Aufruf und die vollständige Testanleitung.