> ## Documentation Index > Fetch the complete documentation index at: https://docs.aihubmix.com/llms.txt > Use this file to discover all available pages before exploring further. # GPT-5.6 verfügbar: Neue Prompt-Caching-Abrechnung erklärt > Juli 2026: gpt-5.6-sol / gpt-5.6-terra / gpt-5.6-luna auf AIHubMix – 1.050.000 Kontext, Cache-Writes 1,25x, prompt_cache_key, Claude-Vergleich. Illustration der drei GPT-5.6-Modellstufen Sol, Terra und Luna und des Prompt-Caching-Mechanismus OpenAI hat am 9. Juli 2026 die GPT-5.6-Serie offiziell veröffentlicht. AIHubMix hat die drei Modellstufen integriert: `gpt-5.6-sol`, `gpt-5.6-terra` und `gpt-5.6-luna` sind ab sofort über Chat Completions und Responses aufrufbar. Mit dem Release wurden zugleich Mechanismus und Abrechnung des Prompt Caching angepasst – Cache-Writes werden jetzt separat abgerechnet. Dieser Artikel stellt die Positionierung der drei Stufen vor und geht die Cache-Änderungen Punkt für Punkt durch. ## Was sich bei den drei GPT-5.6-Stufen ändert GPT-5.6 stellt das Namensschema um: Die Zahl steht für die Modellgeneration, Sol, Terra und Luna sind eigenständig weiterentwickelbare Leistungsstufen. Die offizielle Definition: Sol ist das Flaggschiffmodell, Terra die günstige Stufe mit einer Leistung auf dem Niveau von GPT-5.5, Luna die schnellste und günstigste Stufe. | | gpt-5.6-sol | gpt-5.6-terra | gpt-5.6-luna | | :------------------------------------------ | :--------------------------------------------- | :----------------------------------------- | :--------------------------- | | Offizielle Positionierung | Flaggschiff für komplexe professionelle Arbeit | Ausgewogen zwischen Intelligenz und Kosten | Für kostensensible Workloads | | Kontextfenster | 1.050.000 | 1.050.000 | 1.050.000 | | Maximaler Output | 128.000 | 128.000 | 128.000 | | Wissensstand | 2026-02-16 | 2026-02-16 | 2026-02-16 | | Ungefähre Entsprechung der alten Generation | Stufe ohne Suffix | mini-Stufe | nano-Stufe | Offizielle Angaben zur Leistung: Sol erzielt State-of-the-art-Ergebnisse bei Coding, Wissensarbeit, Cybersecurity und wissenschaftlichen Aufgaben; OpenAI bezeichnet es als bislang bestes Coding-Modell mit neuen Bestwerten auf Terminal-Bench 2.1 und DeepSWE. Terra erreicht die Leistung von GPT-5.5 zum halben Preis. Die Serie führt die neue Reasoning-Stufe max ein; die Responses API erhält Programmatic Tool Calling und multi-agent-Fähigkeiten (Beta). ## Die Cache-Mechanik im Detail Vor GPT-5.6 lief das Prompt Caching der GPT-Serie vollständig automatisch: Ein Präfix ab 1.024 Token wurde automatisch gecached, Entwickler konnten weder steuern, was gecached wird, noch wie lange, und der Cache wurde nach 5–10 Minuten Inaktivität gelöscht. OpenAI fasst die Cache-Änderungen von GPT-5.6 als „more predictable prompt caching" zusammen, konkret in drei Punkten: 1. **Die Aufbewahrung steigt von „mindestens 5 Minuten" auf „mindestens 30 Minuten"**. `prompt_cache_options.ttl` unterstützt derzeit nur `"30m"`; das ist die garantierte Mindestdauer, tatsächlich kann der Cache länger erhalten bleiben. 2. **Neue explizite Cache-Breakpoints**. Mit `prompt_cache_breakpoint` auf einem Content-Block lässt sich die Cache-Grenze am Ende des stabilen Inhalts fixieren; Änderungen hinter dem Breakpoint invalidieren den davor liegenden Präfix-Cache nicht. Ist `prompt_cache_options.mode` auf `"explicit"` gesetzt, werden nur manuelle Breakpoints verwendet. 3. **`prompt_cache_key` wird von einer Optimierungsoption zur offiziellen Anforderung**. Ab GPT-5.6 ist der Parameter zu setzen, um zuverlässigeres Cache-Matching zu aktivieren; OpenAI empfiehlt, den Traffic pro Key bei etwa 15 Anfragen/Minute zu halten. ## Wie die 1,25x-Abrechnung für Cache-Writes zu bewerten ist Ab GPT-5.6 werden Cache-Writes mit dem 1,25-Fachen des Basis-Inputpreises abgerechnet, Cache-Reads mit dem 0,1-Fachen; bei den bisherigen Modellen wurden Cache-Writes nicht separat abgerechnet. Offizieller Wortlaut (aus der [GPT-5.6-Release-Ankündigung](https://openai.com/index/gpt-5-6/)): "For GPT-5.6 and later models, cache writes are billed at 1.25x the model's uncached input rate, while cache reads continue to receive the 90% cached-input discount." Die Bilanz lässt sich direkt aus den offiziellen Faktoren berechnen: Das Schreiben eines Präfixes kostet gegenüber dem Verzicht auf Caching das 0,25-Fache des Inputpreises zusätzlich; jeder anschließende Hit spart das 0,9-Fache des Inputpreises – **eine einzige Wiederverwendung des Präfixes ergibt bereits eine Nettoersparnis**, und je mehr Wiederverwendung, desto größer die Ersparnis. * **Workloads mit klarem Nutzen**: Agent-Workflows mit langen System-Prompts, RAG mit wiederholt referenziertem langem Referenzmaterial, Anwendungen mit umfangreichen Tool-Definitionen, Multi-Turn-Konversationen, die Nachrichten nur hinten anfügen. Diese Workloads haben eine hohe Präfix-Wiederverwendungsrate; der 0,1x-Lesepreis dominiert. * **Workloads, die Aufmerksamkeit erfordern**: Einmalige lange Anfragen ohne Präfix-Wiederverwendung. Automatisches Caching ist standardmäßig aktiv, sodass diese Anfragen eine 1,25x-Write-Gebühr ohne Gegenwert erzeugen; setzen Sie `prompt_cache_options.mode` auf `"explicit"` und lassen Sie Breakpoints weg, dann nutzt die Anfrage keinen Cache und erzeugt keine Write-Gebühr. ## Vergleich: Prompt Caching bei GPT-5.6 und Claude Das Cache-Design von GPT-5.6 nähert sich Claudes `cache_control` in mehreren Dimensionen an; der Kernunterschied liegt im Standardverhalten: GPT cached automatisch ohne jeden Parameter, bei Claude muss Caching in der Anfrage aktiviert werden – über das `cache_control`-Feld auf oberster Ebene (automatische Breakpoints) oder explizite Breakpoints auf Content-Block-Ebene. | Dimension | GPT-5.6-Serie | Claude-Serie (alle aktiven Modelle) | | :---------------------- | :---------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------- | | Auslösung | Automatisches Caching, explizite Breakpoints optional | Aktivierung erforderlich: `cache_control` auf oberster Ebene für automatische Breakpoints oder explizite Breakpoints auf Content-Block-Ebene | | Breakpoint-Parameter | `prompt_cache_breakpoint` (Content-Block-Ebene) | `cache_control` (oberste Ebene oder Content-Block-Ebene) | | Breakpoint-Obergrenze | Maximal 4 neue Writes pro Anfrage | Maximal 4 Breakpoints | | Cache-Aufbewahrung | Mindestens 30 Minuten | Standard 5 Minuten (bei Hit kostenlose Auffrischung), optional 1 Stunde | | Abrechnung Cache-Writes | 1,25x Inputpreis | 5-Minuten-Cache 1,25x, 1-Stunden-Cache 2x | | Abrechnung Cache-Reads | 0,1x Inputpreis | 0,1x Inputpreis | | Mindest-Cache-Länge | 1.024 Token | Je nach Modell 512–4.096 Token | | Hit-Voraussetzung | Byte-für-Byte-Übereinstimmung vor dem Breakpoint | Byte-für-Byte-Übereinstimmung vor dem Breakpoint | Die Claude-Spalte gibt die einheitlichen Werte aller aktiven Claude-Modelle wieder: Writes 1,25x im 5-Minuten-Cache, 2x im 1-Stunden-Cache, Reads 0,1x – einheitlich für die gesamte Reihe ([Anthropic-Prompt-Caching-Dokumentation](https://platform.claude.com/docs/en/docs/build-with-claude/prompt-caching)); die Modelle unterscheiden sich nur in der Mindest-Cache-Länge. Quelle der GPT-5.6-Spalte ist der [OpenAI-Prompt-Caching-Leitfaden](https://developers.openai.com/api/docs/guides/prompt-caching). Breakpoint-Obergrenze, Write-Faktoren (je Stufe) und Read-Faktoren stimmen bei beiden Anbietern vollständig überein; für Entwickler bedeutet das, dass dieselbe Prompt-Strukturstrategie „fester Inhalt vorn, veränderlicher Inhalt hinten" bei beiden Anbietern funktioniert. Der Migrationsaufwand konzentriert sich auf die Parametersyntax: GPT verwendet `prompt_cache_breakpoint` + `prompt_cache_key`, Claude verwendet `cache_control`. ## Die Cache-Syntax beider Protokolle im Vergleich Für dasselbe Szenario „feste lange Anweisungen cachen" sehen die Minimalimplementierungen der beiden Protokolle so aus. Als Beispiele dienen `gpt-5.6-sol` und `claude-opus-4-8` – beide haben denselben Basis-Inputpreis (\$5/M), und die aus Cache-Writes (1,25x) und Reads (0,1x) errechneten effektiven Preise sind identisch; nur die Syntax unterscheidet sich: Das GPT-Protokoll setzt `prompt_cache_key` auf oberster Ebene (lange Präfixe werden automatisch gecached, keine Breakpoint-Markierung nötig); das Claude-Protokoll aktiviert automatisches Caching mit `cache_control` auf oberster Ebene und wechselt für präzise Kontrolle der Cache-Grenze auf Breakpoints auf Content-Block-Ebene: ```shell GPT-5.6 (Chat Completions) theme={null} curl https://aihubmix.com/v1/chat/completions \ -H "Content-Type: application/json" \ -H "Authorization: Bearer $AIHUBMIX_API_KEY" \ -d '{ "model": "gpt-5.6-sol", "prompt_cache_key": "my-app-report-v1", "messages": [ { "role": "system", "content": "[Feste lange Anweisungen, ≥1024 Token]" }, { "role": "user", "content": "Summarize the key figures." } ] }' ``` ```shell Claude (Messages) theme={null} curl https://aihubmix.com/v1/messages \ -H "Content-Type: application/json" \ -H "x-api-key: $AIHUBMIX_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -d '{ "model": "claude-opus-4-8", "max_tokens": 1024, "cache_control": {"type": "ephemeral"}, "system": "[Feste lange Anweisungen, ≥1024 Token]", "messages": [ { "role": "user", "content": "Summarize the key figures." } ] }' ``` Im Vergleich der beiden Requests konzentrieren sich die Unterschiede auf: Endpunkt (`/v1/chat/completions` gegenüber `/v1/messages`), Auth-Header (`Authorization: Bearer` gegenüber `x-api-key` + `anthropic-version`), Cache-Parameter (`prompt_cache_key` auf oberster Ebene gegenüber `cache_control` auf oberster Ebene) und das bei Claude erforderliche explizite `max_tokens`. Beide Requests wurden über aihubmix.com gemessen (2026-07-10): `gpt-5.6-sol` lieferte beim zweiten Aufruf `cached_tokens: 2816`; `claude-opus-4-8` beim ersten Aufruf `cache_creation_input_tokens: 3632` und beim zweiten `cache_read_input_tokens: 3632`. Über das Request-Format hinaus gibt es drei mechanische Unterschiede: 1. **Aktivierung**: GPT cached auch ohne Cache-Parameter automatisch; `prompt_cache_key` erhöht die Zuverlässigkeit der Hits. Claude erfordert eine Deklaration – `cache_control`-Breakpoints auf Content-Block-Ebene oder der automatische Modus mit `cache_control` auf oberster Ebene des Requests. 2. **usage-Felder**: GPT meldet die gelesene Cache-Menge in `prompt_tokens_details.cached_tokens`; Claude meldet Writes und Reads getrennt als `cache_creation_input_tokens` und `cache_read_input_tokens`, was die separate Kontrolle von Writes und Hits erleichtert. 3. **Lebensdauer-Steuerung**: Bei GPT-5.6 unterstützt `ttl` derzeit nur `"30m"`; Claude bietet standardmäßig 5 Minuten (bei Hit kostenlose Auffrischung) und optional `"ttl": "1h"` (Writes werden mit dem 2-Fachen abgerechnet). ### Was beim protokollübergreifenden Modellwechsel anzupassen ist Das AIHubMix-Gateway unterstützt protokollübergreifende Aufrufe: Die OpenAI-kompatible Schnittstelle kann Claude-Modelle aufrufen (`cache_control` wird direkt in die Content-Blöcke des OpenAI-Formats geschrieben, Syntax siehe [Prompt Caching](/de/practices/prompt-caching)); das Claude-kompatible `/v1/messages` kann auch GPT-5.6 aufrufen (in Messungen bestätigt). Beim Modellwechsel sind drei Punkte zu prüfen: * `model` auf die Ziel-Modell-ID ändern; * Cache-Parameter-Syntax wechseln: `prompt_cache_key` / explizite Breakpoints entsprechen Claudes `cache_control`; * usage-Feldnamen wechseln: `cached_tokens` entspricht Claudes `cache_read_input_tokens`. Empfohlener Pfad für Prompt Caching: GPT-Modelle über Chat Completions (der in diesem Artikel gemessene Hit-Pfad), Claude-Modelle über beide Protokolle. ## Vergleich: GPT-5.6 und das Caching der älteren GPT-Generationen | Dimension | Vor GPT-5.6 | GPT-5.6 und neuer | | :--------------------------------- | :---------------------------------------------------------- | :----------------------------------------------------------------------------------- | | Cache-Writes | Keine separate Abrechnung | 1,25x Inputpreis | | Cache-Aufbewahrung | Löschung nach 5–10 Minuten Inaktivität, maximal 1 Stunde | Mindestens 30 Minuten | | Cache-Steuerung | Keine | Explizite Breakpoints, explicit-Modus, zuverlässiges Matching mit `prompt_cache_key` | | Erweiterte 24-Stunden-Aufbewahrung | Von einigen Modellen unterstützt (`prompt_cache_retention`) | Ersetzt durch `prompt_cache_options.ttl` (derzeit nur 30m) | Die Richtung der Änderungen ist einheitlich: Das Caching der älteren Generation war kostenlos, aber ohne Steuerungsmöglichkeit und mit unbestimmter Aufbewahrung; GPT-5.6 berechnet Writes und liefert dafür eine garantierte Aufbewahrungsdauer und präzise Cache-Steuerung. Nach den Faktoren gerechnet übersteigt die Ersparnis die neuen Write-Kosten, sobald ein Präfix im Schnitt mehr als einmal wiederverwendet wird; die garantierten 30 Minuten Aufbewahrung und die steuerbaren Breakpoints erhöhen die Planbarkeit, diese Wiederverwendungsrate zu erreichen. ## Auf AIHubMix loslegen Alle drei Stufen sind verfügbar; die Modell-IDs lauten `gpt-5.6-sol`, `gpt-5.6-terra` und `gpt-5.6-luna`. Caching erfordert keine zusätzliche Konfiguration; aufeinanderfolgende Anfragen mit demselben langen Präfix treffen den Cache: ```py Python theme={null} import os from openai import OpenAI client = OpenAI( api_key=os.environ["AIHUBMIX_API_KEY"], base_url="https://aihubmix.com/v1", ) long_context = "You are a meticulous assistant for analyzing quarterly financial reports... [Feste lange Anweisungen, ≥1024 Token]" for i in range(2): completion = client.chat.completions.create( model="gpt-5.6-sol", prompt_cache_key="my-app-report-assistant-v1", messages=[ {"role": "system", "content": long_context}, {"role": "user", "content": "Summarize the key figures in one sentence."}, ], ) print(completion.usage.prompt_tokens_details) ``` Ist `usage.prompt_tokens_details.cached_tokens` beim zweiten Aufruf größer als 0, liegt ein Hit vor (gemessenes Beispiel: `cached_tokens: 2816`). Parameterbeschreibung, Abrechnungsdetails und Fehlersuche bei Cache-Misses finden Sie in der Dokumentation [GPT Prompt Caching](/de/api/GPT-Cache). ## Häufig gestellte Fragen (FAQ) ### Über welche Schnittstellen ist GPT-5.6 auf AIHubMix aufrufbar? Chat Completions (`/v1/chat/completions`), Responses (`/v1/responses`) und die Claude-kompatible Messages-Schnittstelle (`/v1/messages`) sind verfügbar; alle drei Modellstufen sind online. Für Prompt Caching wird derzeit Chat Completions empfohlen. ### Was ändert sich an der Abrechnung nach dem Upgrade auf GPT-5.6 ohne Client-Anpassung? Prompt Caching greift standardmäßig automatisch: Anfragen mit einem Präfix ab 1.024 Token erzeugen einen Cache-Write-Posten zum 1,25-Fachen des Inputpreises; wird das Präfix wiederverwendet, wird zum 0,1-Fachen abgerechnet. Bei Anwendungen mit hoher Präfix-Wiederverwendung sinken die Gesamtkosten in der Regel; einmalige lange Anfragen ohne Präfix-Wiederverwendung können das Caching mit dem explicit-Modus abschalten. ### Ich habe Claude Prompt Caching genutzt – was muss ich für die Migration zu GPT-5.6 ändern? Die Prompt-Strukturstrategie bleibt gleich: fester Inhalt ganz nach vorn, veränderlicher Inhalt ans Ende. Die Parameter wechseln von `cache_control` zu `prompt_cache_breakpoint`, ergänzt um `prompt_cache_key`; die Aufbewahrung wechselt von den zwei Stufen 5 Minuten / 1 Stunde zu garantierten 30 Minuten. ### Wie wähle ich zwischen den drei GPT-5.6-Stufen? Offizielle Angabe: Für komplexe professionelle Arbeit und Coding-Aufgaben Sol; für alltägliche Workloads Terra (Leistung auf GPT-5.5-Niveau zum halben Preis); für kostensensible Szenarien mit hohem Volumen Luna. Kontextfenster und maximaler Output sind bei allen drei Stufen gleich, sodass sich Aufgaben nach Komplexität stufenweise routen lassen. ## Offizielle Referenzen Modellspezifikationen, Cache-Mechanismen und Abrechnungsfaktoren dieses Artikels stammen aus folgenden offiziellen Quellen: * [GPT-5.6-Release-Ankündigung](https://openai.com/index/gpt-5-6/) (OpenAI, 2026-07-09) * [OpenAI-Prompt-Caching-Leitfaden](https://developers.openai.com/api/docs/guides/prompt-caching) * [OpenAI Pricing](https://developers.openai.com/api/docs/pricing) * [Anthropic-Prompt-Caching-Dokumentation](https://platform.claude.com/docs/en/docs/build-with-claude/prompt-caching) Begleitende Dokumentation: [GPT Prompt Caching](/de/api/GPT-Cache) · [Claude Prompt Caching](/de/api/Claude-Cache) · [Prompt Caching](/de/practices/prompt-caching) *** Die Preise der GPT-5.6-Serie finden Sie im [Modell-Marktplatz](https://aihubmix.com/models); weitere Anbindungswege beschreibt das [Dokumentationszentrum](https://docs.aihubmix.com). *** Zuletzt aktualisiert: 2026-07-10