Gemini 4 Neon API einrichten: Modell-ID, Denkstufen und ein geprüfter erster Request

gemini-4-neon aus einem bezahlten Gemini-API-Projekt aufrufen, zwischen high und xhigh wählen, Denk- und Cache-Token in den Nutzungsdaten auslesen und die Fehler beheben, die sich von Carbon unterscheiden.

Ein Drehschalter mit vier Stellungen auf einem Holzsockel, die vierte Stellung orange markiert, verbunden mit einer nicht leuchtenden Glasröhrenlampe.

Um Gemini 4 Neon aufzurufen, senden Sie model: "gemini-4-neon" aus einem Gemini-API-Projekt in der kostenpflichtigen Stufe; eine kostenlose Stufe gibt es für Neon nicht. Standardmäßig denkt das Modell auf high, akzeptiert aber auch low, medium und xhigh. Eingabe, Denkprozess und Ausgabe teilen sich ein Kontextfenster von 1.048.576 Token. Googles Neon-Leitfaden setzt für neuen Code auf die Interactions API, generateContent funktioniert aber ebenfalls. Ein Request gilt erst dann als erfolgreich, wenn die Interaction den Status completed hat (oder der Candidate mit STOP endet), sichtbarer Text vorhanden ist und der Nutzungsdatensatz zeigt, was Ihnen berechnet wird, einschließlich der Denk-Token.

Google hat gemini-4-neon am 18. November 2026 allgemein verfügbar (GA) gemacht. Dieser Leitfaden wurde am 19. November 2026 mit der Google-Dokumentation abgeglichen. Er konzentriert sich auf das, was speziell für Neon gilt. Projekteinrichtung, API-Schlüssel und Abrechnung sind dieselben wie beim anderen kostenpflichtigen Gemini-4-Modell. Sie werden deshalb einmal ausführlich in unserem Leitfaden zur Einrichtung der Gemini 4 Carbon API behandelt und hier nur zusammengefasst.

Für diesen Artikel gelten zwei Einschränkungen:

  • Neon ist bei Ofox nicht verfügbar. Wir haben die Ofox-Modellliste (GET https://api.ofox.io/v1/models) am 19. November 2026 geprüft: Sie enthält google/gemini-4-hydrogen und google/gemini-4-argon, aber nicht Neon, und https://ofox.io/models/google/gemini-4-neon lieferte 404. Alle folgenden Beispiele verwenden Googles nativen Endpunkt und einen Google-API-Schlüssel. Dieser Blog wird von Ofox herausgegeben.
  • Wir haben keinen echten Neon-Aufruf durchgeführt. Für diesen Leitfaden stand uns kein Google-Schlüssel zur Verfügung. Die Request-Bodys wurden mit Googles veröffentlichter API-Spezifikation abgeglichen (Neon-Leitfaden, Referenzen zu Interactions und generateContent, Dokumentation zu Denkprozess, Caching und Long Decode). Das Prüfskript für Antworten wurde offline mit 15 synthetischen Antworten getestet. Das belegt die Parser-Logik, aber nicht Authentifizierung, Latenz oder Antwortqualität.

Gemini 4 Neon API: die wichtigsten Daten

Alle Werte stammen aus Googles Leitfaden What’s new in Gemini 4 Neon, der Preisseite und der Neon-Modellkarte (alle auf Englisch), geprüft am 19. November 2026.

PunktWert für Neon
Modell-IDgemini-4-neon (ohne Suffix -preview)
ZugangNur kostenpflichtige Stufe der Gemini API; außerdem Google AI Studio mit den Tarifen Google AI Pro und Ultra
APIsInteractions API (in Googles Quickstart verwendet) und generateContent
Denkstufenlow, medium, high (Standard), xhigh; minimal wird abgelehnt
Kontext1.048.576 Token, gemeinsam für Eingabe, Denkprozess und Ausgabe
Synchrone Ausgabe65.536 Token als Standard und Obergrenze pro Hop (Generierungsabschnitt), mit und ohne Streaming
Längere AusgabeHintergrundausführung oder clientseitige Fortsetzung, bis 1M minus Eingabe
Standardpreis (USD pro 1M Token)3,00 USD Eingabe, 0,15 USD gecachte Eingabe, 15,00 USD Ausgabe inklusive Denkprozess
CachingNur implizit, ab 4.096 Prompt-Token; explizites cachedContents wird nicht unterstützt
Samplingtemperature, top_p, top_k werden innerhalb des gültigen Bereichs ignoriert; Werte außerhalb liefern 400
WissensstandMärz 2026 (Modellkarte)

Anders als Carbon, dessen Einführungspreis am 30. November endet, hat Neon keinen Einführungspreis. Die Kosten pro Aufgabe nach Denkstufe finden Sie in unserer Preisübersicht zu Gemini 4 Neon.

Was sich gegenüber einem Carbon- oder Hydrogen-Request ändert

Google schreibt, dass der Wechsel von einem anderen Gemini-4-Modell zu Neon „keine Änderungen am Request-Schema erfordert“. Die Felder bleiben gleich; es ändern sich die Werte und die Grenzen drumherum. Wenn Sie bereits funktionierenden Code aus unseren Einrichtungsleitfäden für Carbon oder Hydrogen haben, sind diese Unterschiede zu berücksichtigen.

BereichCarbonHydrogenNeon
Modell-IDgemini-4-carbongemini-4-hydrogengemini-4-neon
Kostenlose StufeNeinJaNein
Standard-Denkstufemediumhighhigh
xhighNicht unterstütztUnterstütztUnterstützt
Hop ohne Streaming32.768 Token pro Hop bei rohem REST65.53665.536
Sampling-ParameterIgnoriertIm Bereich ignoriert, außerhalb 400Im Bereich ignoriert, außerhalb 400
Standardpreis (Eingabe / Ausgabe)2 / 10 USD bis 30. Nov., danach 4 / 20 USD1,50 / 7,50 USD3 / 15 USD, fest

Quellen: die „What’s new“-Leitfäden zu Carbon, Hydrogen und Neon sowie die Seite Choosing a model (auf Englisch). Der Vergleich der Hops mit 32.768 und 65.536 Token steht in Googles Hydrogen-Leitfaden.

Daraus ergeben sich drei praktische Folgen:

  1. Beim Umstieg von Carbon steigen die Standardkosten pro Aufruf. Carbon nutzt standardmäßig medium, Neon high. Code, der thinking_level nie gesetzt hat, denkt auf Neon mehr, ohne dass Sie etwas geändert haben. Setzen Sie die Stufe explizit, damit das Verhalten im Code-Review sichtbar ist.
  2. Beim Umstieg von Hydrogen kann der Schlüssel scheitern, nicht der Request. Eine Hydrogen-Integration läuft womöglich in einem Projekt der kostenlosen Stufe. Mit demselben Schlüssel erreichen Sie Neon nicht. Prüfen Sie, zu welchem Projekt der Schlüssel gehört, bevor Sie den Payload debuggen.
  3. Für Neon geschriebener Code kann auf Carbon scheitern. xhigh ist für Neon und Hydrogen gültig, nicht aber für Carbon oder Argon. Wenn Sie Schritte auf verschiedene Modelle verteilen, machen Sie die Denkstufe zum Teil der Route statt zu einer globalen Konstante. Wann sich welches Modell lohnt, behandelt unser Vergleich von Neon und Carbon.

Schritt 1: Prüfen, ob der Schlüssel zu einem bezahlten Projekt gehört

Für Neon müssen vier Dinge zusammenpassen: ein Google-Konto, das die Gemini API nutzen darf, ein Projekt in Google AI Studio, ein API-Schlüssel, der zu diesem Projekt gehört, und aktive Abrechnung in der kostenpflichtigen Stufe für dasselbe Projekt. Googles Abrechnungsleitfaden beschreibt den Wechsel von der kostenlosen in die kostenpflichtige Stufe als Verknüpfung eines Rechnungskontos mit einem Projekt; die Seite Projects zeigt die Abrechnungsstufe jedes Projekts. Ein Abo für Google AI Pro oder Ultra gibt Ihnen Neon in AI Studio, ist aber kein Beleg dafür, dass das Projekt Ihres API-Schlüssels in der kostenpflichtigen Stufe ist. Prüfen Sie die Stufe des Projekts auf dieser Seite.

Die Schritt-für-Schritt-Anleitung (Cloud-Projekt importieren, Schlüsseltypen und Einschränkungen, Vorauszahlung oder nachträgliche Abrechnung) steht im ersten Abschnitt des Carbon-Leitfadens und gilt unverändert für Neon. Googles Quellen sind der Leitfaden zu API-Schlüsseln und der Abrechnungsleitfaden (beide auf Englisch).

Legen Sie den Schlüssel in einer Umgebungsvariablen ab und prüfen Sie, ob er geladen ist, ohne ihn auszugeben:

export GEMINI_API_KEY="..."   # in der Shell oder im Secret-Manager setzen, niemals committen
python3 -c 'import os; print("Key configured:", bool(os.environ.get("GEMINI_API_KEY")))'

True bedeutet nur, dass ein Wert vorhanden ist. Ob das Projekt Neon erreicht, zeigt erst der erste Request.

Schritt 2: Den ersten Request mit der Interactions API senden

Googles Neon-Quickstart verwendet die Interactions API, also beginnen Sie neuen Code dort. Installieren Sie das aktuelle SDK (google-genai, importiert als from google import genai; nicht das ältere Paket google-generativeai):

python3 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade google-genai

Speichern Sie dies als neon_first_call.py:

import json
import os
from pathlib import Path
from google import genai

client = genai.Client(api_key=os.environ["GEMINI_API_KEY"])

interaction = client.interactions.create(
    model="gemini-4-neon",
    input="List exactly three checks for confirming a new API integration works.",
    store=False,
    generation_config={
        "thinking_level": "low",
        "max_output_tokens": 65536,
    },
)

Path("neon-response.json").write_text(
    json.dumps(interaction.model_dump(mode="json"), indent=2), encoding="utf-8"
)
print("Status:", interaction.status)
print("Usage:", interaction.usage)
print(interaction.output_text)

Drei Einstellungen in diesem Request sind bewusst gewählt:

  • thinking_level: "low" hält die Zugangsprüfung günstig. Sonst würde Neon auf high denken. Nutzen Sie low, um die Route nachzuweisen, und setzen Sie danach die Stufe, die Ihre echte Arbeitslast braucht (Schritt 5).
  • max_output_tokens: 65536 ist Neons dokumentierter Standardwert und die Obergrenze pro Hop. Es ist eine Obergrenze für Denkprozess plus sichtbare Ausgabe, keine Vorhersage der Rechnung. Google rät davon ab, niedrige Grenzen wie 8.192 aus älteren Anwendungen zu übernehmen; wer weniger ausgeben will, sollte stattdessen die Denkstufe senken.
  • store=False nimmt diesen einmaligen Aufruf von der Speicherung aus. Lassen Sie die Speicherung eingeschaltet (Standard), wenn Sie background=True oder previous_interaction_id nutzen wollen; beide benötigen gespeicherte Interactions. In der kostenpflichtigen Stufe bewahrt Google gespeicherte Interactions 55 Tage auf.

Derselbe Request als REST-Aufruf, nützlich, um genau zu sehen, was übertragen wird:

curl --silent --show-error --max-time 900 \
  "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-4-neon",
    "input": "List exactly three checks for confirming a new API integration works.",
    "store": false,
    "generation_config": {
      "thinking_level": "low",
      "max_output_tokens": 65536
    }
  }' \
  --output neon-response.json

Bei der Interactions API sind die Feldnamen in generation_config in Python, JavaScript und REST durchgehend snake_case. output_text ist eine Komfort-Eigenschaft des SDK; in der rohen REST-Antwort steht der Text in steps-Einträgen vom Typ model_output, innerhalb von content-Einträgen vom Typ text.

Die 900 Sekunden für --max-time folgen Googles Migrationshinweis, für schwierige Prompts mindestens 15 Minuten einzuplanen. Ein trivialer Prompt auf low sollte deutlich schneller zurückkommen. Läuft der Client in ein Timeout, kann der Server den Request trotzdem verarbeitet (und berechnet) haben. Starten Sie also keinen automatischen Retry, bevor Sie das geprüft haben.

Schritt 3: Oder generateContent verwenden, wenn Ihr Client es schon nutzt

generateContent wird für Neon weiterhin unterstützt. Wenn Ihre Anwendung bereits candidates auswertet, reicht es womöglich, den Modellnamen und die Denkkonfiguration zu ändern. Achten Sie auf die andere Schreibweise: REST für generateContent verwendet camelCase.

curl --silent --show-error --max-time 900 \
  "https://generativelanguage.googleapis.com/v1beta/models/gemini-4-neon:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{"role": "user", "parts": [{"text": "List exactly three checks for confirming a new API integration works."}]}],
    "generationConfig": {
      "thinkingConfig": {"thinkingLevel": "low"},
      "maxOutputTokens": 65536
    }
  }' \
  --output neon-response.json

Mit dem Python-SDK sieht das so aus:

from google import genai
from google.genai import types

client = genai.Client()
response = client.models.generate_content(
    model="gemini-4-neon",
    contents="List exactly three checks for confirming a new API integration works.",
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(thinking_level="low"),
        max_output_tokens=65536,
    ),
)
print(response.text)
print("Thinking tokens:", response.usage_metadata.thoughts_token_count)

In beiden Varianten sind die Stufenwerte kleingeschriebene Strings ("low", "xhigh"), wie in Googles Leitfaden zum Denkprozess (auf Englisch). Mischen Sie die beiden APIs nicht: generation_config.thinking_level gehört in einen Interactions-Body, generationConfig.thinkingConfig.thinkingLevel in einen generateContent-Body. Wenn nach dem Kopieren von Code zwischen den beiden APIs ein 400 auftritt, prüfen Sie zuerst die Feldstruktur. Entfernen Sie außerdem ein altes thinkingBudget (thinking_budget): Es ist in Gemini 4 veraltet, und zusammen mit einer Denkstufe gesendet liefert es 400.

Wählen Sie pro Codepfad eine API. Die Interactions API bietet serverseitigen Zustand (previous_interaction_id) und Hintergrundausführung. Mit generateContent verwalten Sie den Verlauf selbst und müssen frühere Modell-Turns einschließlich ihrer Thought Signatures unverändert zurücksenden.

Schritt 4: Status, Text und Nutzung prüfen, bevor Sie dem Aufruf trauen

Ein HTTP 200 reicht nicht. Eine Interaction kann mit einem anderen Status als completed zurückkommen, und ein generateContent-Candidate kann mit MAX_TOKENS enden, nachdem er sein gesamtes Budget für den Denkprozess verbraucht hat. In beiden Fällen fehlt sichtbarer Text unter Umständen ganz. Googles Long-Decode-Leitfaden (auf Englisch) nennt für jeden Interactions-Status die passende Reaktion:

StatusBedeutungVorgehen
queued, in_progressLäuft noch (Hintergrundaufrufe)interactions.get mit derselben id abfragen
completedFertigmodel_output-Text zusammenfügen und usage lesen
requires_actionDas Modell fordert einen Tool-Aufruf anTool ausführen und das Ergebnis mit dieser id senden
requires_continuationEin Vordergrund-Hop hat die Grenze von 65.536 erreicht, Budget ist noch übrigDas SDK setzt standardmäßig fort; bei REST den nächsten Hop mit previous_interaction_id und continuation_token senden
incompletemax_output_tokens vollständig verbraucht; Text kann leer seinFortsetzen oder mit höherem max_output_tokens erneut senden
failedDer Server konnte nicht abschließenEinmal wiederholen; schlägt es erneut fehl, die id für den Support aufbewahren
cancelledSie haben abgebrochenusage lesen, um zu sehen, was berechnet wurde

Bei generateContent entsprechen dem die Werte von finishReason: STOP bedeutet Erfolg, MAX_TOKENS heißt, die Grenze wurde erreicht, und CONTINUATION heißt, ein weiterer Hop ist nötig (aktuelle SDKs setzen automatisch fort).

Dieses Prüfskript liest eine gespeicherte Antwort aus beiden APIs. Es stellt keine Netzwerkverbindungen her und wiederholt nie:

import json
import sys
from pathlib import Path

PENDING = {"queued", "in_progress"}


def check_interaction(p):
    status = p.get("status")
    if status in PENDING:
        raise ValueError(f"Still {status}: poll interactions.get with this id later")
    if status != "completed":
        raise ValueError(f"Interaction status is {status}, not completed (see the status table)")
    text = "".join(
        c.get("text", "")
        for s in p.get("steps", [])
        if s.get("type") == "model_output"
        for c in s.get("content", [])
        if c.get("type") == "text"
    )
    u = p.get("usage") or {}
    usage = {
        "input": u.get("total_input_tokens"),
        "cached_input": u.get("total_cached_tokens"),
        "output": u.get("total_output_tokens"),
        "thinking": u.get("total_thought_tokens"),
        "tool_use": u.get("total_tool_use_tokens"),
        "total": u.get("total_tokens"),
    }
    return text, usage


def check_generate_content(p):
    cands = p.get("candidates") or []
    if not cands:
        reason = (p.get("promptFeedback") or {}).get("blockReason")
        raise ValueError(f"No candidates (prompt block reason: {reason})")
    c = cands[0]
    reason = c.get("finishReason")
    if reason != "STOP":
        raise ValueError(f"finishReason is {reason}, not STOP")
    text = "".join(
        part.get("text", "")
        for part in (c.get("content") or {}).get("parts", [])
        if not part.get("thought")
    )
    u = p.get("usageMetadata") or {}
    usage = {
        "input": u.get("promptTokenCount"),
        "cached_input": u.get("cachedContentTokenCount", 0),
        "output": u.get("candidatesTokenCount"),
        "thinking": u.get("thoughtsTokenCount"),
        "tool_use": u.get("toolUsePromptTokenCount", 0),
        "total": u.get("totalTokenCount"),
    }
    return text, usage


def check(payload):
    if "error" in payload:
        raise ValueError("API error: " + json.dumps(payload["error"]))
    if "candidates" in payload or "promptFeedback" in payload:
        text, usage = check_generate_content(payload)
    elif "status" in payload or "steps" in payload:
        text, usage = check_interaction(payload)
    else:
        raise ValueError("Unrecognised response shape")
    if not text.strip():
        raise ValueError("Completed, but no visible text")
    return text, usage


if __name__ == "__main__":
    path = sys.argv[1] if len(sys.argv) > 1 else "neon-response.json"
    payload = json.loads(Path(path).read_text(encoding="utf-8"))
    try:
        text, usage = check(payload)
    except ValueError as exc:
        raise SystemExit(str(exc))
    print("Usage:", json.dumps(usage))
    print(text)

Führen Sie python3 check_neon.py neon-response.json aus. Bei Erfolg gibt das Skript eine normalisierte Nutzungszeile und die sichtbare Antwort aus. Lesen Sie danach die Antwort selbst: drei passende Prüfungen, keine Verweigerung und kein abgeschnittener Satz.

Was wir getestet haben. Wir haben das Prüfskript genau in der oben abgedruckten Form gegen 15 von Hand geschriebene Fixtures laufen lassen: eine abgeschlossene Interaction mit einem Denkschritt, deren Text auf zwei model_output-Schritte verteilt ist; dieselbe Interaction nach einem Durchlauf durch das Interaction-Modell des google-genai-SDK und model_dump(mode="json"), so wie Schritt 2 sie speichert; Interactions mit in_progress, incomplete, requires_action, requires_continuation, failed sowie abgeschlossen, aber leer; ein API-Fehler-Body; und generateContent-Antworten, die mit STOP (mit einem auszuschließenden Denk-Part), MAX_TOKENS, CONTINUATION oder MALFORMED_FUNCTION_CALL enden, ein blockierter Prompt und eine Antwort, die nur aus Denkinhalt besteht. Die drei wohlgeformten Erfolgsfälle bestanden, die übrigen zwölf endeten mit der erwarteten Meldung. Die Fixtures folgen den dokumentierten Feldnamen; es handelt sich nicht um mitgeschnittene Neon-Ausgaben.

Welche Nutzungsfelder bei Neon zählen

Im Nutzungsdatensatz zeigen sich Neons zwei Kostenhebel: Denkprozess und Cache-Treffer.

BedeutungInteractions usagegenerateContent usageMetadata
Eingabe-Tokentotal_input_tokenspromptTokenCount
Eingabe aus Cache-Trefferntotal_cached_tokenscachedContentTokenCount
Sichtbare Ausgabetotal_output_tokenscandidatesTokenCount
Denkprozesstotal_thought_tokensthoughtsTokenCount
Prompt-Token für Tool-Nutzungtotal_tool_use_tokenstoolUsePromptTokenCount
Gesamttotal_tokenstotalTokenCount

Die Feldnamen stammen aus Googles API-Referenzen für Interactions und generateContent (beide auf Englisch). Das Beispiel in Googles Referenz (ein früheres Modell, nicht Neon) zeigt den Denkprozess getrennt von der sichtbaren Ausgabe: 49 Denk-Token neben 23 Ausgabe-Token für eine Antwort aus einem Satz. Bei Neon wird der Denkprozess zum Ausgabepreis von 15,00 USD pro 1M Token berechnet. Google zählt jedes Token, das das Modell verarbeitet, einschließlich des Denkprozesses und, bei Grounding, interner Systemanweisungen und Funktionsdeklarationen. Eine kurze sichtbare Antwort kann bei high oder xhigh also trotzdem hohe Ausgabekosten verursachen. Protokollieren Sie thinking neben output für jeden Aufruf; wenn eine Rechnung merkwürdig aussieht, schauen Sie sich zuerst dieses Paar an.

Schritt 5: Die Denkstufe pro Aufgabe wählen

Googles Leitfaden beschreibt die vier Stufen sinngemäß so:

StufeBeschreibung laut GoogleTypischer Einsatz
lowWenigste Token, geringste LatenzSchneller Chat, Verarbeitung mit hohem Durchsatz, günstige Zugangsprüfungen
mediumGeringerer Token-Verbrauch, schnellere AntwortenInteraktives Programmieren, UI-Prototypen, latenzkritische Tool-Aufrufe
high (Standard)Ausgewogenes Verhältnis von Intelligenz und GeschwindigkeitDie meisten komplexen Programmieraufgaben, agentische Ausführung, multimodale Wissensarbeit
xhighMeiste Token, tiefstes ReasoningSchwierige mehrstufige Engineering-Aufgaben, analytische und wissenschaftliche Probleme, bei denen high nicht reicht

Googles empfohlene Methode: Bewerten Sie Ihre Aufgabe auf allen vier Stufen mit einem hohen max_output_tokens, damit die Grenze keine Antworten abschneidet, und nutzen Sie dann die niedrigste Stufe, die Ihre Qualitätsanforderung erfüllt. So fordern Sie xhigh an:

interaction = client.interactions.create(
    model="gemini-4-neon",
    input="Audit this retry queue for race conditions and rewrite the lock logic.",
    generation_config={"thinking_level": "xhigh"},
)

Zwei Hinweise, die speziell Neon betreffen:

  • xhigh und die Grenze von 65.536 beeinflussen sich gegenseitig. Die Grenze umfasst Denkprozess plus Ausgabe. Googles Leitfaden zum Denkprozess warnt, dass xhigh bei einfachen Prompts wie Text- oder JSON-Extraktion zu viel nachdenken und max_output_tokens ausschöpfen kann. Sehen Sie MAX_TOKENS oder eine incomplete-Interaction mit wenig sichtbarem Text, schauen Sie zuerst auf die Aufgabe. Bei einer einfachen Aufgabe senken Sie die Stufe. Bei einer wirklich schweren behalten Sie die Stufe und geben ihr mit Hintergrundausführung und einem größeren max_output_tokens mehr Raum (siehe Abschnitt zur Hintergrundausführung unten). Verkleinern Sie max_output_tokens nicht, um Geld zu sparen: Laut Google wird die Antwort dadurch abgeschnitten, und der bereits erfolgte Denkprozess wird trotzdem berechnet.
  • Googles Kostenangaben wurden auf bestimmten Stufen gemessen. In Googles Neon-Ankündigung heißt es, dass Neon auf der Standardstufe high einen hohen Wert im Artificial Analysis Intelligence Index mit 32 % niedrigeren Kosten pro Aufgabe als Carbon verbindet und seinen höchsten Intelligenzwert auf xhigh erreicht. Google verknüpft die 32 % mit dem AA Intelligence Index, gibt aber nicht an, mit welcher Carbon-Denkstufe, welcher Carbon-Preisperiode oder welchem AA-Datenstand verglichen wurde; mit den AA-Zahlen, die wir am 19. November 2026 gelesen haben, lassen sich die 32 % nicht nachvollziehen. Den Vergleich zeigt unsere Neon-Preisübersicht. Das sind von Google berichtete Benchmark-Ergebnisse, keine Prognose für Ihre Arbeitslast. Messen Sie Ihre eigene Aufgabe mit den oben genannten Nutzungsfeldern.

previous_interaction_id überträgt nur den Gesprächsverlauf. generation_config, tools und system_instruction werden nicht übernommen. Ein Folge-Turn ohne thinking_level fällt deshalb auf Neons Standard high zurück. Senden Sie die Stufe in jedem Turn erneut.

Implizites Caching statt cachedContents verwenden

Neon unterstützt nur implizites Caching. Wenn Sie Code migrieren, der Caches mit caches.create anlegt oder cached_content sendet, entfernen Sie diese Felder. Laut Googles Caching-Leitfaden wird explizites Caching weder in der Interactions API noch für Gemini-4-Modelle unterstützt.

Implizites Caching greift automatisch bei Prompts ab 4.096 Token. Ein Treffer wird mit 0,15 USD statt 3,00 USD pro 1M Eingabe-Token berechnet, ein Rabatt von 95 %. Erzwingen lässt sich ein Treffer nicht, aber Googles Caching-Leitfaden (auf Englisch) nennt zwei Wege, die Chancen zu erhöhen:

  • Große, gemeinsam genutzte Inhalte (Systemanweisungen, eine Repository-Übersicht, ein Referenzdokument) an den Anfang des Prompts stellen und die Frage des jeweiligen Requests ans Ende.
  • Requests mit demselben Präfix zeitlich nah beieinander senden.

Für Multi-Turn-Chats und Agentenschleifen ergänzt Google eine Regel für Gemini 4: Der vollständige vorherige Request wird nur gecacht, wenn der neue Request mindestens 2.050 Token hinzufügt (Modellausgabe, Denkprozess und Funktionsergebnisse zählen mit). Bei kleineren Ergänzungen werden die letzten 2.050 Token des vorherigen Requests zum normalen Eingabepreis erneut verarbeitet. Laut Google überschreiten die meisten Agenten-Turns diese Schwelle.

Prüfen Sie das dann anhand von Daten statt Annahmen: total_cached_tokens (Interactions) oder cachedContentTokenCount (generateContent) sollte beim zweiten und jedem weiteren Request mit langem gemeinsamem Präfix größer als null sein. Bleibt der Wert bei 0, prüfen Sie, ob das Präfix Byte für Byte identisch ist, einschließlich Zeitstempeln oder Request-IDs, die Sie womöglich am Anfang einfügen.

Ausgaben über 64K: Hintergrundausführung

Eine einzelne synchrone Neon-Antwort endet bei 65.536 Token für Denkprozess plus Ausgabe. Für eine lange Spezifikation, einen großen Refactoring-Plan oder eine vollständige Testsuite empfiehlt Google die Hintergrundausführung:

import time
from google import genai

client = genai.Client()
interaction = client.interactions.create(
    model="gemini-4-neon",
    input="Write a complete migration specification and test plan for this service.",
    background=True,
    generation_config={"max_output_tokens": 262144, "thinking_level": "high"},
)

while interaction.status in ("queued", "in_progress"):
    time.sleep(5)
    interaction = client.interactions.get(id=interaction.id)

# Text aus allen 64K-Fortsetzungs-Hops zusammenfügen.
text = "".join(
    content.text
    for step in interaction.steps
    if step.type == "model_output"
    for content in step.content
    if content.type == "text"
)
print("Status:", interaction.status)
print("Usage:", interaction.usage)
print(text)

Der Text kommt in mehreren model_output-Schritten an, weil der Server in Hops zu 64K fortsetzt; fügen Sie also alle zusammen (das Prüfskript oben macht es genauso). Eine Hintergrund-Interaction kann bis zu 24 Stunden laufen; endet sie mit failed, wiederholen Sie einmal, wie in der Statustabelle. Zwei weitere Details werden leicht übersehen. Wenn Sie background ohne max_output_tokens setzen, stoppt der Server trotzdem nach 65.536 Token. Und die Hintergrundausführung braucht Speicherung, kombinieren Sie sie also nicht mit store=False. Die Obergrenze liegt bei 1.048.576 abzüglich Ihrer Eingabe-Token. Googles Long-Decode-Leitfaden (auf Englisch) beschreibt die clientseitige Fortsetzung für den Fall, dass Sie keine Interactions speichern können.

Häufige Fehler der Gemini 4 Neon API und ihre Behebung

Notieren Sie Endpunkt, exakte Modell-ID, Projekt, SDK-Version und den vollständigen Fehler-Body (ohne Schlüssel), bevor Sie irgendetwas ändern. Beheben Sie zuerst die Ebene, die in der Kette als erste fehlgeschlagen ist.

SymptomWahrscheinliche Ursache bei NeonLösung
Zugriffs- oder Kontingentfehler mit einem Schlüssel, der für Hydrogen funktioniertSchlüssel gehört zu einem Projekt der kostenlosen Stufe; Neon gibt es nur in der kostenpflichtigen StufeSchlüssel aus einem Projekt mit aktiver kostenpflichtiger Abrechnung verwenden (Schritt 1)
Modell nicht gefundenTippfehler, erfundenes Suffix wie -preview oder ein Gateway, das Neon nicht routetgemini-4-neon gegen generativelanguage.googleapis.com verwenden
400 bei thinking_levelminimal gesendet (bei Gemini 4 abgelehnt), Feldstrukturen von Interactions und generateContent vermischt oder ein altes thinkingBudget zusammen mit der Stufe gesendetlow/medium/high/xhigh verwenden; Feldnamen an den Endpunkt anpassen; thinkingBudget entfernen
400-Validierungsfehler mit Sampling-Parameterntemperature, top_p oder top_k außerhalb des gültigen BereichsSampling-Parameter entfernen; Werte im Bereich werden ohnehin ignoriert
Request schlägt nach Migration von Cache-Code fehlAlter Verweis auf cached_content / cachedContents (explizites Caching nicht unterstützt)Entfernen; auf implizites Caching setzen
MAX_TOKENS, incomplete oder leerer TextNiedriges max_output_tokens, vom Denkprozess aufgebraucht65.536 wiederherstellen, für lange Aufgaben Hintergrundausführung nutzen oder die Denkstufe gezielt senken
MALFORMED_FUNCTION_CALLModell soll Tool-Aufrufe als JSON in Rohtext ausgeben, ohne dass Tools deklariert sindTools per Function Calling deklarieren oder strukturierte Ausgabe verwenden
Signaturfehler bei Multi-Turn-Tool-NutzungThought Signatures verloren oder zwischen parallelen Aufrufen kopiertprevious_interaction_id verwenden oder frühere Turns unverändert zurückgeben; siehe unseren Fix für fehlende Thought Signatures (auf Englisch)
Client-Timeout bei schwierigen PromptsReasoning auf high/xhigh dauert MinutenHTTP-Timeout auf mindestens 15 Minuten erhöhen oder Hintergrundausführung verwenden
429Rate Limits gelten auch in der kostenpflichtigen StufeParallelität senken und mit Backoff wiederholen; siehe unseren Leitfaden zu Retries bei 429 (auf Englisch)

Die meisten Zeilen stammen direkt aus Googles Migrations-Checkliste für Neon. Durchgespielte Diagnosen zu Route, Kontingent und Antwort an einem verwandten Modell finden Sie in unserer Fehleranalyse zur Gemini 4 Argon API; die Argon-spezifischen Werte dort (Standard-Denkstufe, verfügbare Stufen) gelten nicht für Neon. Fehler bei Carbon, Neon und Hydrogen, einschließlich leerer oder abgeschnittener Antworten, sammelt unser Leitfaden zu Fehlern bei Gemini 4 Carbon, Neon und Hydrogen.

Lässt sich Gemini 4 Neon über Ofox aufrufen?

Stand 19. November 2026: nein. Die Ofox-Modellliste lieferte Gemini 4 Hydrogen und Argon, aber nicht Neon, und der Pfad der Neon-Modellseite ergab 404. Richten Sie den Code oben nicht auf eine Ofox-Basis-URL: Der Interactions-Endpunkt und ein Ofox-Schlüssel gehören zu verschiedenen Systemen, und es gibt keine Route zu Neon.

Um später erneut zu prüfen, suchen Sie google/gemini-4-neon in der Ofox-Modellliste (GET https://api.ofox.io/v1/models mit Ihrem Ofox-Schlüssel) oder unter ofox.ai/models. Taucht das Modell dort auf, nennt seine Modellseite die unterstützten Protokolle und den aktuellen Preis. Das Request-Format für Gemini-Modelle bei Ofox steht in der Ofox-Dokumentation zur Gemini API. Nutzen Sie diese Dokumentation für Endpunkt und Authentifizierung; gehen Sie nicht davon aus, dass der Google-native Code aus diesem Artikel unverändert funktioniert.

Wenn Sie heute ein Gemini-4-Modell über Ofox brauchen: Gemini 4 Hydrogen ist gelistet, und der Einrichtungsleitfaden behandelt die Ofox-Route. Wie Neon im Vergleich zu den konkurrierenden Flaggschiffen abschneidet, mit denen Google es in Benchmarks vergleicht, lesen Sie in Gemini 4 Neon vs. Claude Opus 5.5 vs. GPT-6.2 Sol.

Abnahme-Checkliste für den ersten Aufruf

Bevor Sie die Neon-Integration als fertig betrachten, speichern Sie diesen Datensatz ohne Geheimnisse:

  • Modell-ID gemini-4-neon, Endpunkt, SDK-Version und Projektkennung.
  • Eine gespeicherte Antwort, die das Prüfskript besteht: completed oder STOP, nicht leerer Text.
  • Die Nutzungszeile, mit Denk-Token und gecachten Eingabe-Token getrennt erfasst.
  • Die gesendeten Werte für thinking_level und max_output_tokens, explizit im Code gesetzt statt von Standardwerten geerbt.
  • Jeder aufgetretene Fehler und die Änderung, die ihn behoben hat.

Mit dieser Grundlage fügen Sie Tools, lange Dokumente oder Hintergrundjobs einzeln hinzu. Wenn etwas fehlschlägt, wissen Sie, dass es am neuen Teil lag.

Weiterführende Dokumentation