Mit CometAPI entwickelnEine API für mehrere Modelle erforderlich?Teste den Workflow im Playground und erstelle anschließend einen API-Schlüssel, sobald Modell und Kosten zu deinem Anwendungsfall passen.
Wie verwendet man die Gemini 4 Carbon API? Ein vollständiger Entwicklerleitfaden
Richten Sie die Gemini 4 Carbon API mit CometAPI ein. Folgen Sie den Python- und REST-Beispielen, validieren Sie Antworten, analysieren Sie PDFs und Bilder und verarbeiten Sie Streaming.
Nutzen Sie die Gemini 4 Carbon API in CometAPI, um über die Gemini-native GenerateContent-Schnittstelle Reasoning und Dokumentanalyse in Ihre Anwendung einzubinden. Starten Sie mit einer kurzen Textanfrage, prüfen Sie, dass die Generierung beendet wurde, und speichern Sie die Antwort, bevor Sie PDF-Eingaben, Bilder, Streaming oder strukturiertes JSON hinzufügen. Dieser Leitfaden stellt die Einrichtung und den Code zur Antwortbehandlung für jeden Schritt bereit.
Key Takeaways
Modell-ID: gemini-4-carbon. Kein Free-Tier — erfordert bezahlten Gemini API-/Cloud Billing-Zugang.
Vereinheitlichtes 1M-Token-Fenster (Input + Thinking + Output). Standard-Maximum für Output ca. 65K; Long Decode erweitert sich auf nahezu 1M.
CometAPI bietet den einfachsten Produktionszugang mit einem einzigen Key, wettbewerbsfähigen Preisen und nahtlosem Wechsel zwischen Gemini 4 Carbon, Claude und 500+ weiteren Modellen.
Launch-Artwork zu Gemini 4 Carbon. Bild: Google. Original artwork.
What Is Gemini 4 Carbon API?
Gemini 4 Carbon ist Googles Frontier-Reasoning-Modell für langhorizontale agentische Workflows, komplexe Softwareentwicklung, Cybersecurity und wissenschaftliche Forschung. Aufgebaut auf Gemini 4 Argon nutzt es tieferes Reasoning und erweiterte Verifikationsschleifen, um mehrstufige Aufgaben zu bewältigen, die nachhaltige Problemlösung statt einer einzigen Antwort erfordern. Im Vergleich zu Argon ist Carbon für anspruchsvollere Workloads ausgelegt, bei denen Genauigkeit und Zielerreichung wichtiger sind als die Minimierung des Tokenverbrauchs. Google kündigte bezahlten Entwicklerzugang am 10. November 2026 an. Die Multimodal-Unterstützung erlaubt die Kombination von Text mit visuellen und anderen Medieneingaben; der generierte Output ist Text. CometAPI bietet rabattierten API-Zugang.
Für eine API-Integration beginnen Sie mit einer Aufgabe, deren Ergebnis Sie prüfen können: eine Zusammenfassung eines Dokuments, das Extrahieren von Feldern aus einer Incident-Notiz oder das Review eines Screenshots. Ein breiterer Agent-Workflow kann darauf aufbauen, sobald Sie die unterstützten Tools und das Antwortverhalten der Route verifiziert haben.
Other Ways to Use It
Google AI Studio Playground: Modell auswählen und Prompts interaktiv testen (erfordert bezahlten Zugang für Carbon).
Gemini app / AI Mode / Antigravity: Verfügbar, wenn Sie Google AI Ultra haben (Modell dort auswählen, wo angeboten).
Enterprise / Cloud: Nutzung über Gemini Enterprise Agent Platform oder Vertex-ähnliche Endpunkte mit derselben Modell-ID (Projekt- und Standort-Setup).
Wissenschaftler/Forschende können in manchen Fällen begrenzten kostenlosen Zugang beantragen.
What Are the Gemini 4 Carbon API Specifications ?
Die offiziellen Modellspezifikationen unterscheiden das gemeinsame Kontextbudget von der Ausgabelimitierung jedes Foreground-Segments. Dies sind Modellgrenzen; Ihr Gateway kann zusätzlich Request-Größen- und Feature-Beschränkungen anwenden.
Limitations and API Considerations
Bevor Sie Ihre Integration erweitern, prüfen Sie, wie Carbon Kontext, Generierungseinstellungen, Caching und Zugriff handhabt. Die Tabelle koppelt jede Einschränkung mit einer praktischen Maßnahme, um ungültige Requests, unvollständige Ergebnisse und unerwartete Kosten zu vermeiden.
Bereich
Einschränkung oder Anforderung
Implikation für Entwickler
Einheitliches Tokenbudget
Input und Output teilen sich 1.048.576 Tokens, einschließlich Thinking und Funktionsaufrufen.
Reservieren Sie Output-Spielraum, bevor Sie Konversationsverlauf oder Dateien hinzufügen.
Long Decoding
Ein Foreground-Segment erlaubt bis zu 65.536 Output-Tokens beim Streaming oder 32.768 ohne Streaming;
längere Generierung benötigt Fortsetzung.
Thinking-Levels
Low, Medium, High; Medium ist Standard
Für GenerateContent LOW, MEDIUM oder HIGH senden; MINIMAL wird abgelehnt.
Thinking-Budget
Der Legacy-Parameter thinking_budget wird abgelehnt
Entfernen Sie thinking_budget aus Request-Buildern und verwenden Sie thinking_config.thinking_level in Python bzw. thinkingConfig.thinkingLevel in REST-JSON.
Sampling
Benutzerdefinierte temperature-, top_p- und top_k-Werte werden ignoriert
Verwenden Sie thinking_level zur Wahl der Reasoning-Tiefe und response_schema für strukturierten Output.
Kontext-Caching
Implizites Caching wird unterstützt; explizite Erstellung eines Kontext-Caches nicht
Platzieren Sie wiederverwendbaren Kontext zuerst und die wechselnde Frage zuletzt. Entfernen Sie explizite Cache-Erstellungsaufrufe und cached_content-Referenzen.
API-Kosten
Thinking-Tokens werden als Output berechnet
Berücksichtigen Sie Thinking ebenso wie den sichtbaren Output.
Cybersecurity-Zugang
Spezialisierter Cyber-Zugang ist eingeschränkt
Prüfen Sie die Berechtigung für spezialisierten Fairwind-Zugang. Standard-Carbon-Zugang gewährt nicht automatisch Zugriff auf die cyber-permissive Variante.
Googles Carbon-Entwicklerleitfaden dokumentiert die API-Regeln; die Model Card beschreibt Zuverlässigkeit und Einschränkungen für spezialisierten Zugriff. Bestätigen Sie die entsprechenden Funktionen auf Ihrer CometAPI-Route, bevor Sie sie in der Produktion aktivieren.
Thinking Levels: How to Choose the Right Setting
Starten Sie mit MEDIUM und passen Sie das Level an die Aufgabe und die benötigte Qualität an.
LOW: Nutzen Sie es für einfache Extraktion, Klassifikation und Zusammenfassungen, wenn Reaktionszeit und Kosten Priorität haben. Testen Sie es etwa für das Labeln von Support-Tickets und prüfen Sie, ob es Ihre Genauigkeitsziele erfüllt.
MEDIUM: Verwenden Sie diesen Standardausgangspunkt für alltägliches Coding, Dokumentanalyse und routinemäßiges Reasoning. Es ist eine praktische Basis, um zu bewerten, ob ein anderes Level Ihre Anwendung verbessert.
HIGH: Nutzen Sie es für komplexes Debugging, mehrschrittige Recherche und wissenschaftliches Reasoning, das von tieferer Untersuchung profitiert. Planen Sie zusätzliche Reasoning-Tokens ein und belassen Sie es nur, wenn der Qualitätsgewinn die zusätzlichen Kosten und die Zeit rechtfertigt.
Höhere Thinking-Levels garantieren nicht automatisch bessere Ergebnisse für jede Aufgabe. Benchmarken Sie Ihre eigenen Workloads und vergleichen Sie Aufgabenabschlussqualität, Latenz und gesamten Tokenverbrauch, bevor Sie Produktionsstandards ändern.
How Does Gemini 4 Carbon Perform on AI Benchmarks?
Selected Benchmark Results
Benchmark
Gemini 4 Carbon
Gemini 4 Argon
GPT-6 Astra
Claude Opus 5.5
Artificial Analysis Intelligence Index v5.0
59
50
57
58
SWE-sweep
9.60%
4.30%
9.50%
3.60%
FrontierSWE 2
61.20%
55.00%
65.50%
62.30%
Terminal-Bench 4.0
65.20%
57.10%
59.10%
59.60%
Agents' Last Exam v1.1
77.40%
69.00%
73.10%
71.60%
OSWorld-2.1
81.50%
74.70%
80.90%
87.20%
AutomationBench
53.90%
51.30%
41.40%
42.50%
Chartography
72.50%
71.60%
71.00%
66.30%
GraphWalks (256K–1M)
96.20%
84.20%
71.80%
66.80%
Die Seiten Artificial Analysis Carbon (High) und Argon (High) zeigen den folgenden Snapshot, geprüft am 12. November 2026. Dies sind Benchmark-Ergebnisse, keine Messungen der CometAPI-Latenz.
Metrik
Carbon (High)
Argon (High)
Intelligence Index
60
50
Output-Geschwindigkeit
80 Tokens/s
65 Tokens/s
Zeit bis zum ersten Answer-Token
67,83 s
37,64 s
Zeit pro Intelligence-Index-Task
25,5 min
30,0 min
Output-Tokens über die Evaluation
205M
113M
Kosten pro Intelligence-Index-Task
$7,76
$9,95
Die Output-Token-Summen beziehen sich auf die Evaluation, nicht auf eine einzelne Anfrage. Die Task-Kosten nutzen die Preisannahmen von Artificial Analysis statt der aktuellen CometAPI-Rabatte. Carbon wartet länger auf das erste Answer-Token, schließt jedoch die Benchmark-Aufgabe schneller und zu geringeren gemeldeten Kosten ab; das Token-Volumen allein bestimmt den Wert nicht.
Nutzen Sie Carbon, wenn seine tiefere Verifikation schwierige Code-Reviews, Recherchen oder andere kostspielige Aufgaben verbessert, bei denen Fehler teuer sind. Testen Sie Argon für Routine-Coding- und Wissensaufgaben, prüfen Sie jedoch Einsparungen an Ihrem eigenen Workload. Führen Sie identische Prompts aus und vergleichen Sie die Gesamtausgaben pro akzeptiertem Ergebnis sowie Abschlusszeit und Fehlerrate.
How Do You start with the Gemini 4 Carbon API in CometAPI?
Sie benötigen ein CometAPI-Konto mit Zugriff auf das Modell und ausreichendem Guthaben, eine Python-Umgebung und grundlegende Erfahrung mit dem Ausführen von Skripten. Verwenden Sie ein Projektverzeichnis für die untenstehenden Dateien, damit jedes Beispiel dieselbe Client-Konfiguration importieren kann.
Why Use Gemini 4 Carbon API Through CometAPI?
CometAPI ist hilfreich, wenn Sie Carbon neben anderen Modellen evaluieren und den Zugriff sowie die Abrechnung über einen Anbieter verwalten möchten. Die Carbon-Route bietet sowohl die Gemini-native GenerateContent- als auch eine OpenAI-kompatible Chat-Schnittstelle, sodass Sie das Request-Format passend zu Ihrer Anwendung wählen können.
Für diesen Leitfaden ermöglicht die native Route die Wiederverwendung des Google Gen AI SDK mit einem CometAPI-Key und einer Base-URL. Aktuelle Default-Group-Preise liegen 20% unter Googles Einführungspreisen. Behalten Sie die Modell-ID in der Konfiguration, damit Sie Carbon und Argon vergleichen können, ohne Ihre Anwendung neu zu schreiben, und prüfen Sie den routespezifischen Support, bevor Sie Tools, Datei-Uploads oder lange Fortsetzungen hinzufügen.
Step 1: Create Your Account and Set Your API Key
Melden Sie sich bei CometAPI an, erstellen oder öffnen Sie Ihren API-Key und speichern Sie ihn als Umgebungsvariable. Vermeiden Sie es, Keys direkt im Quellcode zu platzieren oder in ein Repository zu committen.
Verwenden Sie den Befehl für Ihre Shell. Setzen Sie die Variablen in demselben Terminal, in dem Sie Python ausführen; ersetzen Sie den Key-Platzhalter durch Ihren eigenen Key.
Step 2: Install the SDK and Configure the Endpoint
Installieren Sie das SDK in Ihrer Projektumgebung. Die Verwendung von python -m pip bindet den Installer an den Interpreter, der das Beispiel ausführt.
Installieren oder aktualisieren Sie das Google Gen AI SDK.
python -m pip install --upgrade google-genai
CometAPI dokumentiert einen Gemini-nativen Endpunkt mit einer benutzerdefinierten SDK-Base-URL. Verwenden Sie Ihren CometAPI-Key für diesen Endpunkt. Die folgenden Einstellungen gelten für GenerateContent-Requests.
Einstellung
Wert
SDK
google-genai
Base-URL
https://api.cometapi.com
API-Version
v1beta
REST-Auth-Header
x-goog-api-key
Key-Umgebungsvariable
COMETAPI_KEY
Modell-Umgebungsvariable
COMETAPI_MODEL
Modell-ID
gemini-4-carbon
Step 3: Create a Reusable Client and Validate Responses
Speichern Sie dieses Setup als carbon_client.py. Es definiert den Client einmal und stellt completed_text für die rein textbasierten Antworten in diesem Leitfaden bereit. Der Helper prüft den candidate finish reason, bevor er Antworttext zurückgibt, sodass ein leerer oder abgeschnittener Output nicht stillschweigend als Erfolg behandelt wird.
Erstellen Sie carbon_client.py mit dem CometAPI-Client und einem Validator für Textantworten.
import os
from google import genai
from google.genai import types
client = genai.Client(
api_key=os.environ["COMETAPI_KEY"],
http_options={
"api_version": "v1beta",
"base_url": "https://api.cometapi.com",
},
)
model = os.getenv("COMETAPI_MODEL", "gemini-4-carbon")
def completed_text(response):
if not response.candidates:
raise RuntimeError("No candidate returned; inspect prompt feedback.")
candidate = response.candidates[0]
reason = getattr(candidate.finish_reason, "value", candidate.finish_reason)
if reason != "STOP":
raise RuntimeError(f"Generation did not finish normally: {reason}")
parts = candidate.content.parts if candidate.content else []
text = "".join(
part.text or "" for part in (parts or []) if not part.thought
)
if not text.strip():
raise RuntimeError("The completed candidate contains no answer text.")
return text
Step 4: Send Your First Request and Check the Result
Erstellen Sie first_request.py neben carbon_client.py und fügen Sie den folgenden Code hinzu. Er sendet eine kurze Checklisten-Aufforderung mit MEDIUM Thinking und einem Output-Budget von 4.096 Tokens, prüft die Fertigstellung mit completed_text(response) und speichert die Antwort als UTF-8 in answer.txt. Führen Sie python first_request.py in Ihrem Projektverzeichnis aus, öffnen Sie anschließend answer.txt und prüfen Sie, dass alle fünf Review-Punkte relevant und nutzbar sind. Prüfen Sie die gedruckten Nutzungsmetadaten auf den Tokenverbrauch, einschließlich Thinking; ein normales Finish belegt nicht die Antwortqualität. Wenn die Anfrage fehlschlägt oder unvollständigen Output liefert, verwenden Sie den Troubleshooting-Abschnitt, um Credentials, Fehlerdetails und den Finish-Reason zu prüfen, bevor Sie es erneut versuchen.
from pathlib import Path
from carbon_client import client, model, types, completed_text
response = client.models.generate_content(
model=model,
contents="Give me a five-point checklist for reviewing a Python API client.",
config=types.GenerateContentConfig(
max_output_tokens=4096,
thinking_config=types.ThinkingConfig(thinking_level="MEDIUM"),
),
)
answer = completed_text(response)
Path("answer.txt").write_text(answer, encoding="utf-8")
print(answer)
print("Saved answer.txt")
if response.usage_metadata:
print(response.usage_metadata.model_dump(exclude_none=True))
python first_request.py
## How Can Gemini 4 Carbon API Analyze Files?
Führen Sie diese Beispiele aus demselben Verzeichnis wie carbon_client.py aus. Sie laden lokale Dateien in Inline-Content-Parts, sodass der anfängliche Workflow unabhängig von einem separaten Datei-Upload-Dienst bleibt.
PDF-Verständnis umfasst visuelle Inhalte: Gemini kann Text, Tabellen, Diagramme und Bilder gemeinsam interpretieren. Der [Dokumentenverarbeitungsleitfaden von Google](https://ai.google.dev/gemini-api/docs/document-processing) beschreibt die Unterstützung für PDFs mit bis zu 1.000 Seiten, vorbehaltlich Datei- und Kontextgrenzen. Die Seitenzahl ist eine Obergrenze, keine Garantie, dass jedes Dokument in eine Gateway-Anfrage passt.
Verwenden Sie Inline-Eingaben für kleine, temporäre PDFs. Für größere Dateien oder wiederholte Mehrfachfragen empfiehlt Google die Files API, um das erneute Senden der gesamten Datei zu vermeiden. Bevor Sie diesen Workflow über CometAPI verwenden, prüfen Sie dessen Upload-Endpunkt und die Unterstützung von Dateireferenzen; das untenstehende Inline-Beispiel bleibt ein praktischer Einstieg.
### Summarize a local PDF
Google dokumentiert [Inline-PDF-Eingaben](https://ai.google.dev/gemini-api/docs/document-processing) für GenerateContent. Platzieren Sie eine kleine, nicht sensible report.pdf im Projektverzeichnis, speichern Sie dann Folgendes als analyze_pdf.py und führen Sie python analyze_pdf.py aus.
Senden Sie ein lokales PDF und speichern Sie die abgeschlossene Zusammenfassung.
from pathlib import Path
from carbon_client import client, model, types, completed_text
response = client.models.generate_content(
model=model,
contents=[
types.Part.from_bytes(
data=Path("report.pdf").read_bytes(),
mime_type="application/pdf",
),
"Summarize this report in five bullets. Do not invent missing figures.",
],
config=types.GenerateContentConfig(max_output_tokens=4096),
)
Vergleichen Sie die Zusammenfassung mit der Datei, bevor Sie auf größere Dokumente erweitern. Request-Größenlimits und File-Reference-Support hängen vom Gateway ab. Googles Unterstützung für Office-Formate oder Cloud-Storage-Referenzen begründet nicht automatisch die Unterstützung dieser Inputs über Ihre CometAPI-Route.
### Review a local screenshot
Für [Inline-Bildeingaben](https://ai.google.dev/gemini-api/docs/image-understanding) muss der MIME-Typ zur Datei passen. Platzieren Sie einen PNG-Screenshot namens screen.png neben dem Skript. Speichern Sie dieses Beispiel als analyze_image.py und führen Sie python analyze_image.py aus, um sichtbaren Text und Layout zu prüfen.
Analysieren Sie einen PNG-Screenshot, ohne sich auf eine öffentliche Bild-URL zu stützen.
from pathlib import Path
from carbon_client import client, model, types, completed_text
response = client.models.generate_content(
model=model,
contents=[
types.Part.from_bytes(
data=Path("screen.png").read_bytes(),
mime_type="image/png",
),
"Review this screenshot for unreadable text and overlapping elements. "
"Describe only visible issues and identify their locations.",
],
config=types.GenerateContentConfig(max_output_tokens=4096),
)
print(completed_text(response))
Vergleichen Sie jedes gemeldete Problem mit dem Screenshot. Wenn Sie stattdessen eine JPEG-Datei senden, ändern Sie sowohl Dateiname als auch MIME-Typ entsprechend; das Ändern der Dateierweiterung allein konvertiert das Bild nicht.
## How Do You Stream Gemini 4 Carbon Responses ?
### Display streamed text and check completion
Streaming liefert Antwort-Chunks als Server-Sent Events (SSE), sodass eine Anwendung während der laufenden Generierung Teil-Output anzeigen kann.
Das SDK stellt [Streaming-Textgenerierung](https://ai.google.dev/gemini-api/docs/text-generation) über generate_content_stream bereit. Für direkte HTTP-Anfragen verwendet CometAPI streamGenerateContent mit alt=sse.
Speichern Sie Folgendes als stream_response.py und führen Sie python stream_response.py aus. Es zeigt Text bei Eintreffen an und verifiziert anschließend, dass der Stream mit einem normalen Finish-Reason endete. Eine Ausnahme lässt den angezeigten Text als Teilergebnis stehen, nicht als akzeptierte Antwort.
Lesen Sie Streaming-Text und verlangen Sie ein normales Finish, bevor Sie ihn akzeptieren.
from carbon_client import client, model, types
finish_reason = None
received_text = False
for chunk in client.models.generate_content_stream(
model=model,
contents="Write a concise checklist for investigating intermittent API timeouts.",
config=types.GenerateContentConfig(max_output_tokens=4096),
):
if not chunk.candidates:
continue
candidate = chunk.candidates[0]
if candidate.finish_reason is not None:
finish_reason = getattr(candidate.finish_reason, "value", candidate.finish_reason)
parts = candidate.content.parts if candidate.content else []
for part in parts or []:
if part.text and not part.thought:
received_text = True
print(part.text, end="", flush=True)
print()
if finish_reason != "STOP" or not received_text:
raise RuntimeError(f"Stream not accepted as complete: {finish_reason}")
### Extract structured JSON
Für [schema-begrenzten Output](https://ai.google.dev/gemini-api/docs/structured-output) fordern Sie application/json an und definieren die Felder, die Ihre Anwendung erwartet. Dieses Beispiel extrahiert zwei Felder aus einer kurzen Incident-Notiz und prüft anschließend deren Typen, bevor es das Ergebnis ausgibt.
Speichern Sie dieses Beispiel als structured_output.py und führen Sie python structured_output.py aus. Es nutzt den Response-Validator erneut, bevor das JSON geparst wird.
Extrahieren Sie Incident-Felder, prüfen Sie das Completion und validieren Sie deren Typen.
import json
from carbon_client import client, model, types, completed_text
response = client.models.generate_content(
model=model,
contents=(
"Extract the service and impact from this incident note: "
"The checkout API returned errors for ten minutes during a database restart."
),
config=types.GenerateContentConfig(
max_output_tokens=4096,
response_mime_type="application/json",
response_schema={
"type": "OBJECT",
"properties": {
"service": {"type": "STRING"},
"impact": {"type": "STRING"},
},
"required": ["service", "impact"],
},
),
)
data = json.loads(completed_text(response))
if not isinstance(data, dict) or not all(
isinstance(data.get(field), str) for field in ("service", "impact")
):
raise ValueError("The response does not match the expected field types.")
print(json.dumps(data, indent=2))
Sie sollten ein Objekt mit service und impact erhalten. Schema-Compliance belegt keine faktische Korrektheit: Vergleichen Sie extrahierte Werte mit der Eingabe und wenden Sie vor dem Speichern oder Handeln ggf. Geschäftsregeln an.
## Gemini 4 Carbon API Price
Googles [Einführungspreise](https://blog.google/innovation-and-ai/models-and-research/gemini-models/gemini-4-carbon-now-available/) laufen bis zum 30. November 2026; die Standardtarife gelten ab dem 1. Dezember. Prüfen Sie die aktuellen Tarife Ihres Kontos, bevor Sie spätere Requests budgetieren.
Beide Modelle gehören zur Familie Gemini 4, richten sich jedoch an unterschiedliche Workloads.
| API-Preisstufe | Input / 1M Tokens | Output / 1M Tokens |
| ---------------------------- | ----------------- | ------------------ |
| Standard (bis 30. Nov) | $2.00 | $10.00 |
| Standard (ab 1. Dez) | $4.00 | $20.00 |
| Batch (bis 30. Nov) | $1.00 | $5.00 |
| Batch (ab 1. Dez) | $2.00 | $10.00 |
| Flex (bis 30. Nov) | $1.00 | $5.00 |
| Priority (bis 30. Nov) | $3.60 | $18.00 |
Weitere Preisdaten:
* Gecachter Input: $0.10 pro Million Tokens bis 30. November, ansteigend auf $0.20 ab 1. Dezember.
* Batch und Flex bieten kostengünstigere Verarbeitung für Workloads, die ihre Dienstcharakteristika tolerieren.
* Thinking-Tokens werden als Output-Tokens berechnet.
* Tokens, die durch interne Tool-Instruktionen und Funktionsdeklarationen verbraucht werden, können ebenfalls abrechenbar sein.
Google empfiehlt explizit Argon für die meisten Softwareentwicklungs- und Wissensarbeiten und reserviert Carbon für Aufgaben, die tieferes Reasoning und erweiterte Verifikation erfordern.
Praktische Empfehlung: Wählen Sie Carbon, wenn die Kosten einer falschen Antwort hoch sind oder wenn eine Aufgabe substanzielle Exploration und Verifikation erfordert. Wählen Sie Argon, wenn Sie starkes Reasoning bei effizienterem Tokenbudget benötigen.
### CometAPI Price
Stand 12. November 2026 listet der [Default-Group-Tarif von CometAPI](https://www.cometapi.com/models/google/gemini-4-carbon/) $1.60 pro Million Input-Tokens, $8.00 pro Million Output-Tokens einschließlich Thinking und $0.08 pro Million gecachter Input-Tokens bei Cache-Treffern. Diese Tarife liegen 20% unter den entsprechenden Einführungspreisen von Google.
CometAPI-Preise können sich mit Änderungen der offiziellen Google-Tarife ändern. Vergleichen Sie den aktuellen offiziellen Tarif mit dem Rabatt Ihres Kontos, statt den heutigen Dollarpreis als dauerhaft zu betrachten. Wird derselbe 20%-Rabatt nach einer Tarifänderung beibehalten, beträgt Ihr Tarif offizieller neuer Tarif × 0,80; bestätigen Sie den tatsächlichen CometAPI-Tarif vor der Budgetierung. Andere Account-Gruppen können andere Rabatte haben.
Für eine Anfrage mit 100.000 ungecachten Input-Tokens und 10.000 Output-Tokens, einschließlich Thinking, betragen die reinen Tokenkosten $0,24 zum angezeigten CometAPI-Tarif: $0,16 für Input plus $0,08 für Output. Dieselben Mengen kosten $0,30 zu Googles Einführungspreisen oder $0,60 zu den Dezembertarifen. Die kombinierten 110.000 Tokens passen in das gemeinsame Budget des Modells.
Diese Schätzung schließt Tools, Retries und kontospezifische Preisadjustierungen aus. Die Output-Kosten beinhalten Thinking-Tokens, sodass ein höheres Reasoning-Level die Rechnung erhöhen kann, selbst wenn die sichtbare Antwort kurz ist.
### How to Optimize Gemini 4 Carbon API Costs?
Optimieren Sie auf die Kosten eines korrekten, verwendbaren Ergebnisses. Eine billigere Anfrage ist wertlos, wenn Sie sie wiederholen oder die Antwort manuell korrigieren müssen.
1. Wählen Sie Reasoning bewusst. Starten Sie bei MEDIUM, testen Sie LOW für einfache Arbeiten und verwenden Sie HIGH, wenn es die Akzeptanz ausreichend erhöht, um zusätzliche Zeit und Tokens zu rechtfertigen.
2. Nutzen Sie wiederverwendbaren Kontext durch implizites Caching. Die Workflows von Googles [Argon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-argon) und [Carbon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-carbon) unterstützen keine explizite Kontext-Cache-Erstellung; sie unterstützen implizites Caching. Platzieren Sie wiederverwendbare Instruktionen und Dokumente zuerst, gefolgt von der wechselnden Frage. Google dokumentiert die Eignung für geteilte Präfixe von mindestens 4.096 Tokens. Verifizieren Sie tatsächliche Cache-Treffer und Gebühren auf Ihrer CometAPI-Route; Wiederholung garantiert keinen Rabatt.
3. Reduzieren Sie unnötige Arbeit. Senden Sie relevante Seiten oder Auszüge, fordern Sie die Output-Felder an, die Sie benötigen, und setzen Sie ein ausreichendes Output-Budget. Thinking zählt zum Output-Verbrauch, daher kann eine zu kleine Obergrenze zu Abschneidung und Retries führen.
4. Messen Sie den gesamten Workflow. Inklusive Reasoning, Tool-Nutzung, Retries und abgelehnten Antworten in den Gesamtausgaben. Speichern Sie gültige Antworten, damit nachgelagerte Speicherfehler keine weitere Generierung auslösen.
5. Routen Sie nach nachgewiesenem Wert. Vergleichen Sie Carbon und Argon bei identischen Aufgaben. Erwägen Sie Batch oder Flex nur, wenn Ihr Anbieter sie unterstützt und der Workload deren Dienstcharakteristika toleriert.
Verfolgen Sie Kosten pro akzeptiertem Ergebnis = Gesamtausgaben des Workflows ÷ akzeptierte Ergebnisse. Prüfen Sie dies zusammen mit Latenz und Qualität nach Änderungen am Modell, Prompt oder Thinking-Level.
## Which API Format Should You Use for Gemini 4 Carbon?
Entwickler können über die native Gemini API und eine OpenAI-kompatible Chat-API auf die [Gemini 4 Carbon API in CometAPI](https://www.cometapi.com/models/google/gemini-4-carbon/) zugreifen. Verwenden Sie die Schnittstelle, die zum Request-Format Ihrer Anwendung und zu den dokumentierten Feature-Anforderungen passt.
| Schnittstelle | Wann sie passt | Integrations-Check |
| ----------------------------- | ----------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- |
| Gemini-native GenerateContent | Die Python- und REST-Beispiele in diesem Leitfaden; Anwendungen, die bereits contents und generationConfig verwenden | Nutzen Sie die Gemini-Base-URL und die oben gezeigten Feldnamen |
| OpenAI-kompatible Chat-API | Eine bestehende Anwendung, die um Chat-Nachrichten organisiert ist | Prüfen Sie den dokumentierten Endpunkt, die Felder und unterstützten Features der Carbon-Route, bevor Sie Code anpassen |
Kompatibilität gilt für einen bestimmten Endpunkt und Request-Aufbau. Senden Sie keine OpenAI-Responses-Felder an den Gemini-nativen Endpunkt und nehmen Sie nicht an, dass eine Chat-kompatible Route auch Responses implementiert. Eine toolfähige Anwendung benötigt einen verifizierten Roundtrip von einem Funktionsaufruf zu seinem passenden Ergebnis, nicht nur einen erfolgreichen Textprompt.
## How to Migrate from Gemini 4 Argon to Gemini 4 Carbon API?
Wenn Ihre Argon-Anwendung bereits CometAPIs Gemini-native GenerateContent-Route verwendet, beginnen Sie mit dem Wechsel des konfigurierten Modells auf gemini-4-carbon. Belassen Sie Key, Base-URL, Prompt und Validierungslogik für den ersten Vergleich unverändert. Sowohl [Argon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-argon) als auch [Carbon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-carbon) teilen viele Gemini-4-Request-Konventionen; Legacy-Parameterbereinigung ist nur nötig, wenn diese Felder in Ihrer Anwendung verblieben sind.
### 1. Change the model and run a controlled comparison
Im Setup dieses Leitfadens ändern Sie COMETAPI_MODEL von gemini-4-argon auf gemini-4-carbon und starten dann den Python-Prozess neu, damit die Variable neu geladen wird. Verwenden Sie für beide Modelle denselben repräsentativen Prompt und dasselbe Thinking-Level. Das folgende Standalone-Beispiel nutzt carbon_client.py erneut und wählt explizit Carbon:
from carbon_client import client, types, completed_text
response = client.models.generate_content(
model="gemini-4-carbon",
contents="Review this function for correctness: def add(a, b): return a + b",
config=types.GenerateContentConfig(
max_output_tokens=4096,
thinking_config=types.ThinkingConfig(thinking_level="MEDIUM"),
),
)
print(completed_text(response))
### 2. Check request settings and conversation history
Belassen Sie LOW, MEDIUM oder HIGH bei GenerateContent. Entfernen Sie verbleibende thinking_budget, MINIMAL oder explizite cached_content-Nutzung. Verlassen Sie sich nicht auf temperature, top_p oder top_k zur Steuerung des Ergebnisses. Entfernen Sie frequency_penalty, presence_penalty und candidate_count > 1. Wenn Sie Tools aufrufen, erhalten Sie passende Function-Call-IDs, Namen und die Antwortreihenfolge bei. Dies sind Kompatibilitätsprüfungen, keine neu in Argon entfernten Features.
### 3. Validate quality, cost, and latency before rollout
Führen Sie denselben Testsatz durch beide Modelle. Prüfen Sie Aufgabenerfolg, JSON-Validierung, Toolausführung, vollständige Fertigstellung, abgerechnete Tokens und verstrichene Zeit. Halten Sie die Argon-Konfiguration verfügbar, lenken Sie einen kleinen Teil des Traffics zu Carbon und erweitern Sie nur, wenn es Ihre Akzeptanz- und Budgetziele erfüllt.
### 4. Keep long-output support separate from the model switch
Beginnen Sie mit Requests, die in einem Foreground-Segment enden. Wenn Sie eine Fortsetzung benötigen, prüfen Sie zunächst, ob CometAPI den erforderlichen Endpunkt und die Response-Felder unterstützt. Eine reine Modellnamen-Änderung aktiviert nicht Googles v1beta1-Fortsetzungsworkflow auf dem v1beta-Gateway dieses Leitfadens. Behandeln Sie Partial-Output als unvollständig, bis die Generierung normal beendet ist.
## Conclusion
Verwenden Sie die erste erfolgreiche Anfrage als Ausgangspunkt für einen Integrationstest. Fügen Sie nur die Eingabetypen und Antwortformate hinzu, die Ihre Anwendung benötigt, und prüfen Sie vollständige Outputs, Fehlerbehandlung und Kosten bei repräsentativen Aufgaben. Leiten Sie einen kleinen Anteil des Traffics über die neue Integration, bevor Sie sie ausweiten, und behalten Sie eine bekannte funktionierende Konfiguration bei, falls sich Ergebnisse ändern.
## Gemini 4 Carbon FAQ
### How large is Gemini 4 Carbon's context window?
Gemini 4 Carbon unterstützt ein vereinheitlichtes Input-und-Output-Kontextlimit von 1.048.576 Tokens. Dieses Budget umfasst Input, Reasoning, Funktionsaufrufe und generierten Output.
### What are Gemini 4 Carbon's strongest benchmarks?
Hervorstechende gemeldete Ergebnisse umfassen 88,2% auf SEC-bench Pro, 54,8% auf ExploitGym, 71,0% auf CWE-bench und 96,2% auf GraphWalks. Diese Ergebnisse unterstreichen seine Fähigkeiten in Cybersecurity, Langkontext und agentischem Reasoning.
### How does Gemini 4 Carbon compare with Gemini 4 Argon?
Carbon verbessert sich gegenüber Argon deutlich in mehreren gemeldeten Benchmarks, darunter Artificial Analysis Intelligence Index (59 vs. 50), SWE-sweep (9,6% vs. 4,3%) und SEC-bench Pro (88,2% vs. 83,4%). Der Hauptunterschied liegt in der stärkeren Leistung bei erweitertem Reasoning und komplexen agentischen Aufgaben.
### Is Gemini 4 Carbon better than Claude Opus 5.5?
Kein Modell führt in allen Benchmarks. Carbon erzielt höhere Werte beim Artificial Analysis Intelligence Index, Terminal-Bench 4.0, GraphWalks und Cybersecurity-Evaluierungen, während Claude Opus 5.5 OSWorld-2.1 und FrontierSWE 2 in Googles veröffentlichter Gegenüberstellung anführt.
### What thinking levels does Gemini 4 Carbon support?
Gemini 4 Carbon unterstützt LOW, MEDIUM und HIGH als Thinking-Levels, wobei MEDIUM der Standard ist. Entwickler können diese Einstellungen nutzen, um Reasoning-Tiefe, Latenz und Tokenverbrauch auszubalancieren.
### Can Gemini 4 Carbon process images, audio, and video?
Ja. Die Model Card listet Text, Bilder, Audio und Video als unterstützte Eingabemodalitäten. Die dokumentierte Output-Modalität ist Text.
### What is Gemini 4 Carbon's knowledge cutoff?
Googles Model Card von November 2026 nennt März 2026 als Wissensstand. Das Modell kann daher Wissen über Ereignisse und Entwicklungen nach diesem Datum fehlen, sofern diese nicht über externe Tools oder vom Nutzer gelieferte Kontexte bereitgestellt werden.
Zuverlässigkeit
Halluzinationen, gelegentliche Timeouts und höherer Tokenverbrauch können auftreten
Validieren Sie Fakten, Code und extrahierte Felder.
