Kosten, Abrechnung und Betrieb24. September 2026Flatkey Team

OpenAI-API-Preise (Oktober 2026): GPT-6, GPT-5.6 und alle Token-Tarife erklärt

Alle aktuellen Token-Tarife der OpenAI-API für GPT-6 und GPT-5.6, dazu Batch, Flex, gecachter Input, Regeln für langen Kontext, Kostenbeispiele und Code.

OpenAI-API-Preise (Oktober 2026): GPT-6, GPT-5.6 und alle Token-Tarife erklärt

Im Oktober 2026 reichen die OpenAI-API-Preise von $0,10 pro 1M Input-Tokens und $0,50 pro 1M Output-Tokens bei gpt-6-luna bis zu $10 Input und $50 Output beim Flaggschiff gpt-6-astra; dazwischen liegt gpt-6.1-sol mit $2 Input und $10 Output. Batch und Flex halbieren diese Tarife, der Fast-Modus verdoppelt sie, und jede Anfrage mit mehr als 272K Input-Tokens wechselt in einen höheren Langkontext-Tarif. Alle Zahlen unten stammen von OpenAIs offizieller API-Preisseite, geprüft am 21. Oktober 2026.

Dieser Leitfaden richtet sich an Indie-Hacker und kleine Teams, die ihre Rechnung selbst bezahlen. Er behandelt die aktuellen GPT-6- und GPT-5.6-Modelle, die Verarbeitungsstufen, die Ihre tatsächlichen Kosten verändern, den neuen Cache-Write-Preis, Tarife für Tools und Medien, eine durchgerechnete Monatsschätzung, kopierfertigen Kostencode und einen Preisvergleich mit Claude, Gemini und DeepSeek.

OpenAI-API-Preise auf einen Blick

Frage	Antwort (Stand 21. Okt. 2026)
Günstigstes Modell der aktuellen Familie	`gpt-6-luna`: $0,10 Input / $0,01 gecacht / $0,50 Output pro 1M Tokens
Ausgewogener Standard	`gpt-6.1-sol`: $2,00 Input / $0,10 gecacht / $10,00 Output
Spitzenmodell	`gpt-6-astra`: $10,00 Input / $1,00 gecacht / $50,00 Output
Schwelle für langen Kontext	Über 272K Input-Tokens gilt die Langkontext-Spalte
Batch und Flex	50% der Standard-Tarife
Fast-Modus (früher Priority)	2x die Standard-Tarife
Ultrafast	6x die Standard-Tarife (nur Astra und 6.1 Sol)
Regionale Datenresidenz	+10% für Modelle, die ab dem 5. März 2026 erschienen sind
Websuche-Tool	$10 pro 1.000 Aufrufe plus Tokens der Suchinhalte

Quelle: OpenAI-API-Preise, 21. Oktober 2026. Laut OpenAI wurde die Priority-Verarbeitung am 30. Juli 2026 in Fast-Modus umbenannt.

GPT-6- und GPT-5.6-Preise pro 1M Tokens

Die Tabelle zeigt Standard-Tarife. „Kurz“ bedeutet bis zu 272K Input-Tokens, „Lang“ mehr als 272K. OpenAIs Modellseite positioniert Astra für komplexes Reasoning und Programmierung, 6.1 Sol als Balance aus Intelligenz und Kosten und Luna für kostensensible Massenverarbeitung.

Modell	Input (kurz)	Gecachter Input	Output (kurz)	Input (lang)	Output (lang)
`gpt-6-astra`	$10,00	$1,00	$50,00	$20,00	$75,00
`gpt-6.1-sol`	$2,00	$0,10	$10,00	$4,00	$15,00
`gpt-6-sol`	$2,00	$0,20	$10,00	$4,00	$15,00
`gpt-6-luna`	$0,10	$0,01	$0,50	$0,20	$0,75
`gpt-5.6-sol`	$4,00	$0,40	$20,00	$8,00	$30,00
`gpt-5.6-terra`	$2,00	$0,20	$12,00	$4,00	$18,00
`gpt-5.6-luna`	$0,20	$0,02	$1,20	$0,40	$1,80
`gpt-5.5`	$5,00	$0,50	$30,00	$10,00	$45,00
`gpt-5.4`	$2,50	$0,25	$15,00	$5,00	$22,50

Quelle: OpenAI-API-Preise, Standard-Stufe, 21. Oktober 2026.

Liest man die Zeilen nebeneinander, fallen drei Dinge auf:

gpt-6.1-sol und gpt-6-sol kosten pro Token gleich viel, aber 6.1 Sol hat den halben Preis für gecachten Input ($0,10 statt $0,20). Wenn Ihre App einen langen System-Prompt wiederholt sendet, ist 6.1 Sol bei echtem Traffic das günstigere Sol.
Älter heißt nicht billiger. gpt-5.6-sol kostet bei Input und Output doppelt so viel wie gpt-6.1-sol, und gpt-5.5 kostet beim Input das 2,5-Fache. OpenAI gibt an, dass der Aktionspreis für GPT-5.6 Sol mindestens bis zum 21. November 2026 gilt; prüfen Sie ihn also erneut, bevor Sie darüber hinaus budgetieren.
Lange Prompts ändern die Preisklasse. Über 272K Input-Tokens verdoppelt sich der Input in allen GPT-6-Zeilen, der Output steigt um 50%. Retrieval oder Chunking, das Anfragen unter 272K hält, ist bei dokumentenlastigen Workloads oft die größte einzelne Ersparnis.

Ältere und kleinere Modelle, die noch in der Preisliste stehen

Modell	Input	Gecachter Input	Output
`gpt-5.4-mini`	$0,75	$0,075	$4,50
`gpt-5.4-nano`	$0,20	$0,02	$1,25
`gpt-5-mini`	$0,25	$0,025	$2,00
`gpt-5-nano`	$0,05	$0,005	$0,40
`gpt-4.1`	$2,00	$0,50	$8,00
`gpt-4o-mini`	$0,15	$0,075	$0,60
`o3`	$2,00	$0,50	$8,00
`o4-mini`	$1,10	$0,275	$4,40

Quelle: OpenAI-API-Preise, 21. Oktober 2026. gpt-5-nano hat den niedrigsten Token-Preis auf der Seite, aber testen Sie die Qualität, bevor Sie gpt-6-luna dagegen tauschen: Luna ist das Modell, das OpenAI derzeit für Massenverarbeitung empfiehlt.

Verarbeitungsstufen: Standard, Batch, Flex, Fast und Ultrafast

Dasselbe Modell hat bis zu fünf Preise, je nachdem, wie schnell Sie die Antwort brauchen. Hier gpt-6.1-sol nach Stufe (kurzer Kontext, pro 1M Tokens):

Stufe	Input	Gecachter Input	Output	Wann verwenden
Standard	$2,00	$0,10	$10,00	Interaktiver Produkt-Traffic
Batch	$1,00	$0,05	$5,00	Offline-Jobs, die auf die Batch API warten können
Flex	$1,00	$0,05	$5,00	Anfragen mit niedriger Priorität, die langsamere, gelegentlich nicht verfügbare Kapazität vertragen
Fast	$4,00	$0,20	$20,00	Latenzkritische Pfade (früher Priority)
Ultrafast	$12,00	$0,60	$60,00	Geringste Latenz, nur Astra und 6.1 Sol

Quelle: OpenAI-API-Preise, 21. Oktober 2026.

Für ein Indie-Produkt ist die Faustregel einfach: Evals, nächtliche Datenanreicherung, Backfills und Content-Generierung in Batch, den nutzerseitigen Chat in Standard, und Fast nur für die ein, zwei Endpunkte bezahlen, bei denen Latenz im Conversion-Funnel sichtbar wird. Wenn Sie auch Durchsatzgrenzen beschäftigen, lesen Sie unseren Leitfaden zu LLM-Rate-Limits: RPM, TPM und Retries, bevor Sie Geschwindigkeit kaufen.

Prompt Caching: Cache-Lesezugriffe und die neuen Schreibtarife

OpenAIs Preisliste hat jetzt zwei Spalten für Cache-Writes. Laut dem Prompt-Caching-Leitfaden kostet ein Cache-Write für GPT-5.6 und neuer bei der Standard-Lebensdauer von 30 Minuten das 1,25-Fache des normalen Input-Tarifs, eine Lebensdauer von 12 Stunden (Responses API) das 2,5-Fache, und spätere Lesezugriffe das 0,1-Fache. Der Write-Preis ist kein Aufschlag: Jeder Input-Token wird genau einmal berechnet, zum ungecachten, gecachten oder Write-Tarif.

OpenAIs eigene Rechnung: Ein Präfix einmal schreiben und einmal wiederverwenden kostet das 1,35-Fache der normalen Input-Kosten, gegenüber dem 2-Fachen ohne Caching; ein Write plus neun Reads kostet das 2,15-Fache gegenüber dem 10-Fachen. Caching rechnet sich also schon bei der zweiten Anfrage.

Was das für Ihre App bedeutet:

Stabile Inhalte zuerst: System-Prompt, Tool-Definitionen, Few-Shot-Beispiele, Produktdokumentation.
Nutzerspezifische und wechselnde Inhalte zuletzt, damit keine neuen Writes ausgelöst werden.
Die 12-Stunden-Lebensdauer nur für Präfixe nutzen, die Sie über den Tag viele Male treffen, denn der Write kostet doppelt so viel wie ein 30-Minuten-Write.

Die Break-even-Rechnung vertiefen wir in Kosten und ROI von Prompt Caching.

Tarife für Tools, Bilder, Audio und mehr

Token-Tarife sind nur ein Teil der Rechnung, sobald Sie eingebaute Tools oder Medienmodelle nutzen. Tarife laut offizieller Preisseite, 21. Oktober 2026:

Posten	Preis
Websuche (alle Modelle)	$10,00 pro 1.000 Aufrufe + Tokens der Suchinhalte zum Modelltarif
Dateisuche	$0,10 pro GB und Tag Speicher (1 GB frei); $2,50 pro 1.000 Aufrufe
Hosted-Shell- / Code-Interpreter-Container	Von $0,03 pro 20-Minuten-Sitzung (1 GB) bis $1,92 (64 GB)
`gpt-image-2.5-sunburst` / `gpt-image-2.5-flare`	Bild-Input $8,00, Bild-Output $30,00, Text-Input $5,00 pro 1M Tokens
`gpt-realtime-2.1`	Audio $32,00 Input / $64,00 Output; Text $4,00 / $24,00 pro 1M Tokens
`gpt-live-1` Sprachsitzungen	$0,05 pro Minute, sekundengenau abgerechnet
`gpt-transcribe`	$0,0045 pro Minute
`gpt-5.3-codex`	$1,75 Input / $14,00 Output pro 1M Tokens

OpenAI gibt außerdem an, dass die Responses-, Chat-Completions-, Realtime-, Batch- und Assistants-APIs keinen eigenen Preis haben: Sie zahlen die Token-Tarife des Modells, egal über welchen Endpunkt. Fine-Tuning wird auslaufen gelassen und ist für neue Nutzer geschlossen, planen Sie also keine neuen Projekte darauf. Für Bildbudgets siehe unseren Leitfaden zu OpenAI-Bild-API-Preisen.

Beispiel: was ein kleines SaaS tatsächlich zahlt

Angenommen, ein KI-Feature sendet 20M Input-Tokens und erzeugt 4M Output-Tokens pro Monat in Standard, kurzer Kontext, ohne Caching:

Modell	Input-Kosten	Output-Kosten	Monatlich gesamt
`gpt-6-luna`	20 x $0,10 = $2,00	4 x $0,50 = $2,00	$4,00
`gpt-5.6-luna`	20 x $0,20 = $4,00	4 x $1,20 = $4,80	$8,80
`gpt-6.1-sol`	20 x $2,00 = $40,00	4 x $10,00 = $40,00	$80,00
`gpt-5.6-terra`	20 x $2,00 = $40,00	4 x $12,00 = $48,00	$88,00
`gpt-6-astra`	20 x $10,00 = $200,00	4 x $50,00 = $200,00	$400,00

Berechnet mit OpenAIs veröffentlichten Tarifen, 21. Oktober 2026.

Nun Caching bei gpt-6.1-sol hinzu. Ist die Hälfte des Inputs (10M Tokens) ein wiederverwendetes Präfix, wird 1M für $2,50 in den Cache geschrieben und 9M für $0,10 gelesen: 10M x $2 + 1M x $2,50 + 9M x $0,10 + 4M x $10 = $20 + $2,50 + $0,90 + $40 = $63,40, rund 21% weniger. Verschieben Sie denselben Job in Batch, halbiert sich die Summe ungefähr noch einmal. Die günstigste Änderung ist meist die Modellwahl: Besteht Luna Ihre Evals für eine Route, ist es bei diesem Workload 20-mal billiger als 6.1 Sol.

Beachten Sie, dass Output bei Sol und Astra die Hälfte der Rechnung ausmacht. max_output_tokens begrenzen, strukturierte Ausgabe statt Fließtext anfordern und den Reasoning-Aufwand bei einfachen Routen senken kürzt die teuerste Position.

Code zum Kopieren: API aufrufen und jede Anfrage bepreisen

Verwenden Sie das usage-Objekt, das die API zurückgibt, statt Tokens von Hand zu schätzen.

curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6.1-sol",
    "input": "Summarize this changelog in three bullet points: ...",
    "max_output_tokens": 300
  }'

# pip install openai
from openai import OpenAI

# Standard short-context rates per 1M tokens, OpenAI pricing page, Oct 21, 2026
RATES = {
    "gpt-6-luna":  {"in": 0.10, "cached": 0.01, "out": 0.50},
    "gpt-6.1-sol": {"in": 2.00, "cached": 0.10, "out": 10.00},
    "gpt-6-astra": {"in": 10.00, "cached": 1.00, "out": 50.00},
}

def request_cost(model: str, usage) -> float:
    r = RATES[model]
    cached = getattr(usage.input_tokens_details, "cached_tokens", 0) or 0
    uncached = usage.input_tokens - cached
    return (uncached * r["in"] + cached * r["cached"] + usage.output_tokens * r["out"]) / 1_000_000

client = OpenAI()
resp = client.responses.create(model="gpt-6.1-sol", input="Write a SQL query that finds churned users.", max_output_tokens=400)
print(resp.output_text)
print(f"cost: ${request_cost('gpt-6.1-sol', resp.usage):.6f}")

// npm install openai
import OpenAI from "openai";

const client = new OpenAI(); // reads OPENAI_API_KEY
const resp = await client.responses.create({
  model: "gpt-6-luna",
  input: "Classify this ticket as billing, bug, or feature request: ...",
  max_output_tokens: 20,
});
const u = resp.usage;
const cost = (u.input_tokens * 0.10 + u.output_tokens * 0.50) / 1e6; // gpt-6-luna Standard
console.log(resp.output_text, `$${cost.toFixed(6)}`);

Die Preise in RATES sind eine Momentaufnahme. Speichern Sie sie mit dem Prüfdatum in der Konfiguration und richten Sie einen Alarm ein, wenn die berechneten Kosten von der Rechnung abweichen. Unser Leitfaden für ein Token-Nutzungs-Dashboard zeigt, wie Sie das pro Feature verfolgen.

OpenAI vs. Claude, Gemini und DeepSeek im Preisvergleich

Vergleichbare Klassen, Standard-Tarife pro 1M Tokens, jeweils von der offiziellen Seite des Anbieters, Stand 21. Oktober 2026:

Modell	Input	Output	Quelle
`gpt-6-luna`	$0,10	$0,50	OpenAI
`claude-haiku-5-5` (Prompts bis 100K)	$0,10	$0,50	Anthropic
`gemini-3.8-flash` (Aktion bis 31. Dez. 2026)	$0,75	$3,75	Google
`deepseek-v4-pro` (Spitze / Nebenzeit)	$1,32 / $0,66	$3,96 / $1,98	DeepSeek
`gpt-6.1-sol`	$2,00	$10,00	OpenAI
`claude-sonnet-5-5`	$2,00	$10,00	Anthropic
`gemini-3.1-pro-preview` (Prompts bis 200K)	$2,00	$12,00	Google
`gpt-6-astra`	$10,00	$50,00	OpenAI

Im Budgetsegment haben gpt-6-luna und Claude Haiku 5.5 identische Listenpreise, die Entscheidung hängt also von der Qualität bei Ihrer Aufgabe und den Rate-Limits des jeweiligen Anbieters ab. Im Mittelfeld kosten gpt-6.1-sol und Claude Sonnet 5.5 ebenfalls gleich viel; Gemini 3.1 Pro Preview ist beim Output etwas teurer. Das Gesamtbild finden Sie in unseren Leitfäden zu Claude-API-Preisen, Gemini-API-Preisen und DeepSeek-API-Preisen oder im anbieterübergreifenden KI-API-Preisvergleich.

Weniger zahlen, ohne viel Code zu ändern

Ist das richtige Modell gewählt, bleiben als Hebel die Verarbeitungsstufe, Caching und der Ort, an dem Sie Tokens kaufen. Flatkey ist ein OpenAI-kompatibles Gateway: Sie behalten das OpenAI-SDK, ändern die Base-URL auf https://router.flatkey.ai/v1 und zahlen aus einem einzigen Guthaben, das auch Claude, Gemini und DeepSeek abdeckt. Am 21. Oktober 2026 listete Flatkeys Modellverzeichnis gpt-6.1-sol mit $1,20 Input / $6,00 Output pro 1M Tokens (40% unter OpenAIs Listenpreis von $2/10) im Rahmen einer GPT-Aktion, die laut Startseite bis zum 23. Oktober läuft; gpt-6-luna lag bei $0,06 / 0,30. Rabatte ändern sich, prüfen Sie daher die Live-Seite, bevor Sie ein Budget festlegen.

from openai import OpenAI

client = OpenAI(api_key="YOUR_FLATKEY_KEY", base_url="https://router.flatkey.ai/v1")
resp = client.chat.completions.create(
    model="gpt-6.1-sol",
    messages=[{"role": "user", "content": "Draft a release note for v2.3."}],
)
print(resp.choices[0].message.content)

Der Flatkey-Quickstart und der OpenAI-SDK-Leitfaden erklären Schlüssel und Modell-IDs. Direkter OpenAI-Zugang bleibt die richtige Wahl, wenn Sie Funktionen brauchen, die es nur auf OpenAIs eigener Plattform gibt, etwa spezielle Responses-API-Tools oder einen Enterprise-Vertrag.

Checkliste zu OpenAI-API-Preisen vor dem Launch

Die exakte Modell-ID festlegen (zum Beispiel gpt-6.1-sol, kein generischer Alias) und Preis sowie Prüfdatum notieren.
Input und Output getrennt schätzen; Output macht oft 50% der Rechnung oder mehr aus.
Anfragen unter 272K Input-Tokens halten, sofern der Langkontext-Tarif nicht budgetiert ist.
Alles, was warten kann, in Batch oder Flex verschieben.
Prompts cachefreundlich strukturieren und cached_tokens loggen, um Treffer zu bestätigen.
Tool-Aufrufe (Websuche, Dateisuche, Container) als eigene Posten budgetieren.
10% aufschlagen, wenn Sie Endpunkte mit regionaler Datenresidenz nutzen.
Aktionspreise (GPT-5.6 Sol) vor ihrem Enddatum erneut prüfen.

Häufige Fragen

Wie viel kostet die OpenAI-API?

Das hängt vom Modell ab. Am 21. Oktober 2026 kostet gpt-6-luna $0,10 pro 1M Input-Tokens und $0,50 pro 1M Output-Tokens, gpt-6.1-sol $2 und $10 und gpt-6-astra $10 und $50, laut OpenAIs Preisseite. Ein typisches kleines Feature mit 20M Input und 4M Output im Monat kostet etwa $4 mit Luna und $80 mit 6.1 Sol.

Ist die OpenAI-API kostenlos oder kostenpflichtig?

Kostenpflichtig. OpenAI rechnet die API-Nutzung pro Token zu den Tarifen der Preisseite ab; die aktuelle Liste enthält keine kostenlose Zeile. Die API-Nutzung wird auf der API-Plattform abgerechnet, getrennt von ChatGPT-Abos. Wenn Sie kostenlos experimentieren möchten, sehen Sie sich unsere Liste kostenloser LLM-APIs an.

Warum ist die OpenAI-API so teuer?

Meist liegt es nicht am Basistarif, sondern an der Form des Traffics: lange Prompts, die bei jedem Aufruf erneut gesendet werden, ausschweifender Output, schwere Reasoning-Modelle für einfache Aufgaben und Fast-Modus, wo Standard genügen würde. Caching senkt wiederholten Input auf das 0,1-Fache, Batch halbiert alles, und einfache Anfragen an gpt-6-luna zu routen kostet 20-mal weniger als gpt-6.1-sol.

Ist die ChatGPT-API günstiger als ChatGPT Plus?

Es sind verschiedene Produkte. ChatGPT Plus ist ein festes Monatsabo für die Nutzung von ChatGPT; die API wird pro Token abgerechnet und dient dem Bau eigener Software. Eine leichte persönliche Nutzung mit gpt-6-luna kann unter einem Dollar im Monat kosten, eine intensive mit gpt-6-astra dagegen weit mehr als jedes Abo. Vergleichen Sie Ihr tatsächliches Token-Volumen mit den Tarifen oben.

Was ist der Unterschied zwischen Batch und Flex?

Beide kosten laut Preisseite 50% von Standard. Batch ist eine asynchrone Job-API für große Offline-Workloads; Flex behält den normalen Anfragefluss bei, tauscht aber Geschwindigkeit und Verfügbarkeit gegen einen niedrigeren Preis. Nutzen Sie Batch für Massenjobs und Flex für Hintergrundanfragen, die in Ihren bestehenden Code passen.

Kostet langer Kontext bei OpenAI mehr?

Ja. Bei den Modellreihen GPT-6, GPT-5.6, GPT-5.5 und GPT-5.4 werden Anfragen mit mehr als 272K Input-Tokens nach der Langkontext-Spalte abgerechnet, was bei den GPT-6-Modellen den Input verdoppelt und den Output um 50% erhöht.