OpenAI Agents SDK-Preise: Responses-API-Kosten für Agents

Ein OpenAI-Agent kostat zwischen vier Cent und etwa einem Dollar pro 12-Schritt-Lauf, je nach Model, und das SDK fügt nichts hinzu. Das Agents SDK (Agent, Runner) ist eine Open-Source-Orchestrierungsebene über der Responses API; Sie bezahlen die Token-Raten des Models, das der Agent verwendet. Mit einem 4.000-Token-Systemprompt plus Werkzeugschemas, 1.500-Token-Werkzeugresultaten und 300 Ausgabetoken pro Schritt (166.800 Eingabetoken und 3.600 Ausgabetoken über 12 Schritte) betragen die ungeachten Laufkosten:

Preise sind USD pro 1M Token aus unserem Katalog datiert 2026-09-11. Für GPT-5.4: 166.800 × $2.50 ÷ 1.000.000 = $0.417 Eingabe, plus 3.600 × $15 ÷ 1.000.000 = $0.054 Ausgabe, gesamt $0.471. GPT-5.5 Pro zum 12-fachen des GPT-5.4-Satzes gehört zu einmaligen schwierigen Problemen, nicht zu Schleifen.

Ein Responses-API-Agenten-Schritt ist client.responses.create mit tools=[...] und input=[...]. Das Modell gibt function_call-Emene zurück; Sie führen sie aus, hängen function_call_output-Emene an und rufen erneut auf. Jeder Aufruf berechnet die gesamte Eingabeliste, so sendet der zwölfte Aufruf in der Spur 23.800 Token und der Lauf sendet 166.800.

Zwei Responses-spezifische Mechaniken ändern, was Sie bezahlen. previous_response_id speichert die Konversation server-seitig, sodass Sie nur neue Emene senden; dies ist eine Bequemlichkeit, kein Rabatt, da der gespeicherte Kontext dennoch als Eingabe pro Schritt berechnet wird. Was es tut, ist, Ihr Präfix byte-identisch zu halten, was automatisches Caching auslöst. Und Reasoning-Token werden als Ausgabe berechnet: GPT-5.5 und GPT-5.4 reasoning standardmäßig, setzen Sie also reasoning={"effort": "low"} auf Worker-Agenten, die nur ein Werkzeug auswählen müssen. Ausgabe ist 11% des GPT-5.4-Laufs; Eingabe, fast alles wiederholter Kontext, ist die anderen 89%.

OpenAI wendet Prompt Caching automatisch auf jede Anforderung an, deren Präfix mit einer kürzlichen Anforderung übereinstimmt, wobei gecachte Eingabetoken zu etwa 10% des normalen Eingabesatzes berechnet werden. Es gibt keinen cache_control-Block hinzuzufügen; die Arbeit besteht darin, das Präfix stabil zu halten. Setzen Sie den Systemprompt und die Tooldefinitionen an den Anfang, sortieren Sie Tools zwischen Aufrufen nie um und halten Sie Zeitstempel und Anfrage-IDs aus dem Präfix heraus.

Bei der 12-Schritt-Spur bringt Caching GPT-5.4 von $0.471 auf etwa $0.15 und GPT-5.4 mini von $0.141 auf etwa $0.045. Bei einem 30-Schritt-Lauf (903.000 Eingabetoken ungecacht) fällt GPT-5.4 von $2.39 auf etwa $0.49. Überprüfen Sie, indem Sie usage.input_tokens_details.cached_tokens lesen; bleibt es nach dem ersten Schritt bei Null, bewegt sich etwas im Präfix.

from openai import OpenAI

client = OpenAI()
tools = [{
    "type": "function", "name": "lookup_invoice", "strict": True,
    "description": "Fetch an invoice by number",
    "parameters": {"type": "object", "properties": {"number": {"type": "string"}},
                   "required": ["number"], "additionalProperties": False},
}]
resp = client.responses.create(
    model="gpt-5.4",
    instructions=SYSTEM_PROMPT,          # stable prefix: instructions + tools
    tools=tools,
    input=history,                       # growing list of items
    reasoning={"effort": "low"},
    max_output_tokens=2000,
)
u = resp.usage
cached = u.input_tokens_details.cached_tokens
# GPT-5.4: $2.50 in, ~$0.25 cached in, $15 out per 1M
cost = ((u.input_tokens - cached) * 2.5 + cached * 0.25
        + u.output_tokens * 15) / 1_000_000

Der Kostenvergleich des Prompt Caching stellt dies neben Anthropics explizites cache_control und Geminis Kontext-Caching.

Der Agents SDK führt die Schleife für Sie aus: Runner.run ruft das Modell auf, führt Ihre @function_tool- Funktionen aus, hängt Ergebnisse an und wiederholt dies, bis der Agent eine endgültige Ausgabe zurückgibt oder max_turns erreicht. Es kostet nichts extra, ändert aber zwei Dinge an den Ausgaben. max_turns (Standard 10) ist Ihr Schrittlimit; setzen Sie es bewusst. Und Übergaben tragen das Gespräch in den Kontext jedes neuen Agents, was die Eingaberechnung erhöht, ohne dass es offensichtlich ist.

from agents import Agent, Runner, function_tool

@function_tool
def lookup_invoice(number: str) -> str:
    return db.invoice(number)

agent = Agent(name="billing", model="gpt-5.4-mini",
              instructions=SYSTEM_PROMPT, tools=[lookup_invoice])
result = Runner.run_sync(agent, task, max_turns=12)
usage = result.context_wrapper.usage
# GPT-5.4 mini: $0.75 in / $4.50 out per 1M; 12 reference steps ~= $0.14
run_cost = (usage.input_tokens * 0.75 + usage.output_tokens * 4.5) / 1_000_000

Eingebauute gehostee Werkzeuge (Websuche, Dateisuche, Code-Interpreter, Computer-nutzung) werden getrennt von Token zu nutzungsabhängigen Sätzen abgerech net, die nicht in unserem Katalog sind; überprüfen Sie die Preisseite des Anbieters, bevor Sie sie aktivieren. Die Inhalte, die sie züruckgben, werden dan als normae Eingabe bei jedem späteren Schritt berechnet.

Das günstigste Modell, das dies zuverlässig schaft: GPT-5.4 mini zu $0.141 pro 12-Schritt-Lauf (ungefähr $0.045 ge cached). Mit strict: True bei jeder Funkion folgt es konsistent den Schemata, sein 400K-Kontext deckt jede annehmbare Schleife ab, und es kostet 30% von GPT-5.4. Es ist unser Standard für Arbeiter-Agenten und für jede Schleife, deren Werkzeugauftufe vor der Ausführung validirt werden.

GPT-5.4 nano zu $0.038 pro Lauf ist ein Dritel von mini. Verwenden Sie es für Klassifikations-und-Routing-Schritte, Extraktion und Werkzeugauswahl über eine kleine Werkzeugmenge, wo ein falscher Auftuf günsig zu fangen ist. Machen Sie es nicht zum Planer: Wenn nano abschweift, schweift es über viele Schritte, und 30 nano-Schritte ($0.19) kosten mehr als 12 mini-Schritte.

GPT-5.3-Codex zu $1.75/$14 ($0.342 pro Lauf) ist der Codier-Spezialist. Für Agenten, die Code schreiben und bearbeiten, endet es in der Regel in weniger Schritten als GPT-5.4 mini, was der einzige Grund ist, das 2.4× mehr pro Schritt zu zahlen.

Wann man für das Flaggschiff zahlt: GPT-5.4 ($0.471) für offene Aufgaben und alles mit Nebenwirkungen; GPT-5.5 ($0.942) nur als Planer in einem Multi-Agent-Setup oder wenn ein einziger fehlgeschlagener Lauf mehr als etwa einen Dollar kostet. GPT-5.5 kostet genau 2× GPT-5.4 pro Lauf und muss die Fehlrate oder die Schrittanzahl halbiren, um die Gewinnschwelle zu erreichen. Der günstigste LLM für Agenten-Leitfaden reit alle diese gegen Anthropic, Google und Open-Weight-Modelle auf demselben Trace.

ChatGPT-Pläne beinhalten keine API-Credits. ChatGPT Plus ($20), Pro (ab $100, in den Stufen $100, $200 und $500) und Business ($25 pro Sitzplatz monatlich, $20 jährlich) verschaffen einer Person Zugang zu ChatGPT und dem darin integrierten Codex-Agenten. Sie basieren auf Nutzungskontingenten statt auf einem Token-Zähler, daher gilt der Vergleich nur für einen Menschen, der einen Agenten interaktiv steuert. Dieses Kontingent ist nicht von der Chat-Arbeit getrennt: ChatGPT Work und Codex teilen es sich bereits, und OpenAI gibt an, dass das Plus-, Pro- und Business-Kontingent ab Dezember 2026 über ChatGPT und Codex hinweg gebündelt wird. Der Sofort-Chat greift nicht darauf zurück. Plus- und Pro-Nutzer können zusätzliche Credits kaufen, aber OpenAI veröffentlicht keinen festen Preis pro Credit.

Ein Entwickler, der Codex für ein paar Coding-Aufgaben am Tag nutzt, liegt deutlich im Rahmen dessen, was Plus oder Business abdeckt. Business fügt Admin-Steuerungen hinzu und stellt standardmäßig sicher, dass Workspace-Daten nicht zum Training verwendet werden. Pro macht nur für jemanden Sinn, dessen interaktive Nutzung sonst etwa 212 Flagship-Läufe pro Monat auf der $100-Stufe ($100 ÷ $0.47) oder 425 auf der $200-Stufe überschreiten würde, und dessen Codex- und ChatGPT-Arbeit zusammen ins gemeinsame Kontingent passt. Details zu den Plänen finden Sie auf unseren Preisseiten für ChatGPT und OpenAI Codex.

Die API überzeugt bei allen unbeaufsichtigten, parallelen oder in ein Produkt eingebetteten Anwendungen, und beim Preis sofort, wenn Routine-Schritte auf Mini oder Nano umgestellt werden: 1.000 zwischengespeicherte GPT-5.4-Mini-Läufe kosten etwa $45, wofür kein Sitzplan aufkommt.

Wenden Sie alle vier an; jede fängt einen anderen Fehler:

• max_output_tokens pro Auftuf: 1.000 bis 4.000 für Werkzeug-aufrufende Runden. Dies begrenzt eine Runde, einschließlich Reasoning-Token.
• max_turns auf Runner.run, oder manueller Schritt-Zähler: 12 bis 15 für die meisten Aufgabenarten.
• Stop-Bedingungen: eine erfordrliche finish- Funkion, ein Abbruch bei zwei identischen aufeinanderfolgenden Funkionsaufrufen und ein Abbruch bei einem zweimal wiederholten Werkzeugfehler.
• Ein pro-Lauf-USD-Budget, das nach jedem Auftuf aus usage berechnet wird, mit gecachten Token zu etwa 10% des Listenpreises. Brechen Sie ab, wenn Ihr Lmit übertritten wird, und erfassen Sie die Gesamtzahl pro Aufgabe, um die Kosten pro erfoldreicher Aufgabe zu berechnen.

Bei GPT-5.4-Sätzen deckt ein Budget von $0.50 pro Lauf etwa 12 ungecachte Referenzschritte oder etwa 35 gecachte ab. Für Fan-out-Arbeit, die warten kann, läuft die Batch-API zu etwa 50% des Listenpreises; sie kann keine live-Schleife aufführen, aber über Nacht 10.000 kurze Agenten ausführen. Siehe LLM-Batch-API-Preise und den KI-Kostenrechner für monatliche Budgets.

Was es kostet: $0.04 bis $0.94 pro 12-Schritt-Lauf über die GPT-5-Palle vor dem Caching, ungefähr $0.01 bis $0.30 danach. Wer API-Sätze zahle sollte: jeder, der Agenten unbeaufsichtigt, in großem Umfang oder in einem Produkt betreibt, mit routinemäßigen Schritten auf GPT-5.4 mini oder nano. Wer nicht: ein einzener Entwickler, der Codex interaktiv nutzt, für den Plus oder Business zu $20 bis $25 jede potenzielle API-Rechnung schlägt. Günstigster Weg zum Ergebniss: GPT-5.4 mini mit strengen Schemata und einem stabien gecachten Präfix, GPT-5.4 für offene oder nebenwirkungsreiche Schritte, GPT-5.5 als gelegenlichen Planer, max_turns absichtlich gesetzt. Siehe die Claude-Agent-API-Kosten- und Gemini-Agent-API-Kosten-Leitfäden für die anderen Stacks, wie viel ein KI-Agent zu betreiben kostet, und das ChatGPT-101-Tutorial für API-Grundlagen.