TL;DR
Gemini 4 Hydrogen API is beschikbaar via Googleโs Gemini API en via ondersteunde gateways van derden zoals CometAPI. Kies eerst de route: gebruik Google voor providerspecifieke functies en accountbeheer, of gebruik CometAPI wanneer je een uniforme modelgateway of een OpenAI-compatibele client wilt. Begin met een kleine tekstaanvraag en voeg daarna streaming, gespreksgeschiedenis, bestanden en tools toe.
Je hebt Python 3.10 of hoger nodig, een sleutel voor de gekozen route en toegang tot gemini-4-hydrogen. Het optionele JavaScript-voorbeeld gebruikt Node.js 22 of hoger. Bewaar gedurende de hele tutorial je inloggegevens in de serveromgeving.
Key Takeaways
- Gebruik
gemini-4-hydrogenals model-ID voor de Gemini 4 Hydrogen API. - Google en CometAPI hanteren aparte inloggegevens en facturatie. Match de sleutel met het endpoint dat je kiest.
- Begin met native GenerateContent; gebruik de OpenAI-compatibele interface van CometAPI wanneer die past bij een bestaande chatclient.
- Bewaar de volledige modelrespons in de multi-turn geschiedenis, inclusief signatures, voordat je een vervolg of toolresultaat retourneert.
- Vergelijk de werkelijke tokenconsumptie en afgeronde taken bij het kiezen van een route; het standaardvoorbeeld met tokenprijs staat in de prijzensectie.
What Is the Gemini 4 Hydrogen API?
Google introduceerde Hydrogen op 12 november 2026. De API accepteert prompts en ondersteunde bestanden en retourneert vervolgens gegenereerde tekst of gestructureerde functieaanroepen die je applicatie afhandelt. Je hoeft het model niet zelf te hosten.
Begin met een puur tekstaandraag en controleer de geretourneerde tekst, de stopreden en het tokengebruik voordat je tools of bestanden toevoegt. Voeg daarna gespreksstatus of een read-only bedrijfstool toe in plaats van meteen de volledige workflow te bouwen.
Gemini 4 Hydrogen API specifications
| Specification | Google-documented model capability |
|---|---|
| Model ID | gemini-4-hydrogen |
| Input | Tekst, afbeeldingen, audio, video en ondersteunde documenten |
| Output | Tekst, met gestructureerde function-call parts wanneer tools worden gebruikt |
| Unified context budget | 1.048.576 tokens over input en output |
| Single foreground output segment | Tot 65.536 tokens, inclusief reasoning en functieaanroepen |
| Application features | Thinking-level control, structured output en function calling |
Dit zijn modelmogelijkheden; niet elke gateway biedt gegarandeerd alle providerfuncties aan. De onderstaande voorbeelden gebruiken standaardaanvraagvelden en korte foregroundgeneraties.
Google Official API vs CometAPI
Beide routes ondersteunen Gemini-aanvragen, maar gebruiken verschillende endpoints, inloggegevens en factureringssystemen. Gebruik Google voor providerspecifieke functies; gebruik CometAPI voor een uniforme gateway of een bestaande compatibele client.
| Decision | Google Gemini Developer API | CometAPI Gemini integration |
|---|---|---|
| Native API host | generativelanguage.googleapis.com | api.cometapi.com |
| API key in this guide | GEMINI_API_KEY | COMETAPI_KEY |
| Account and billing | Beheerd door Google | Beheerd door CometAPI |
| Best starting point | Google-specifieke functies en accountbeheer | Uniforme modeltoegang of een bestaande OpenAI-compatibele client |
Houd dezelfde prompt en hetzelfde outputbudget aan wanneer je de twee routes vergelijkt, zodat de resultaten zinvol zijn. De JavaScript- en OpenAI-compatibele alternatieven zijn expliciet geconfigureerd voor CometAPI.
How to Use Gemini 4 Hydrogen API Step by Step?
Step 1: Create an API key
Maak voor CometAPI een account en genereer een sleutel in de API token console. Voor directe toegang tot Google maak je een Gemini API-sleutel in Google AI Studio. Bevestig modeltoegang en de facturering of beschikbare quota van het geselecteerde account.
Bewaar de sleutel veilig. Een CometAPI-sleutel kan geen verzoek aan Googleโs endpoint authenticeren, en een Google-sleutel kan geen CometAPI-verzoek authenticeren.
Stel de sleutel in voor je gekozen route in Bash; je hebt slechts een van deze opdrachten nodig.
export COMETAPI_KEY="YOUR_COMETAPI_KEY"
# Or, for direct Google access:
export GEMINI_API_KEY="YOUR_GEMINI_API_KEY"
Stel de overeenkomstige sleutel in PowerShell op Windows in.
$env:COMETAPI_KEY = "YOUR_COMETAPI_KEY"
# Or, for direct Google access:
$env:GEMINI_API_KEY = "YOUR_GEMINI_API_KEY"
Step 2: Send a first request with cURL
Stuur een native tekstaandvraag via CometAPI vanuit een Bash-terminal.
curl "https://api.cometapi.com/v1beta/models/gemini-4-hydrogen:generateContent" \
-H "x-goog-api-key: $COMETAPI_KEY" \
-H "Content-Type: application/json" \
-X POST \
-d '{
"contents": [
{
"role": "user",
"parts": [
{
"text": "Explain how an AI coding agent works in five steps."
}
]
}
],
"generationConfig": {
"maxOutputTokens": 4096,
"thinkingConfig": {
"thinkingLevel": "MEDIUM"
}
}
}'
Stuur desgewenst dezelfde native aanvraag rechtstreeks naar Google met een Google API-sleutel.
curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-4-hydrogen:generateContent" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-H "Content-Type: application/json" \
-X POST \
-d '{
"contents": [
{
"role": "user",
"parts": [
{
"text": "Explain how an AI coding agent works in five steps."
}
]
}
],
"generationConfig": {
"maxOutputTokens": 4096,
"thinkingConfig": {
"thinkingLevel": "MEDIUM"
}
}
}'
Controleer na een geslaagde aanvraag drie velden: candidates[0].content.parts voor zichtbare tekst, finishReason voor de afrondingsstatus en usageMetadata voor tokengebruik. Los authenticatie- of aanvraagfouten op voordat je meer applicatiecode toevoegt.
Step 3: Configure the Python Client and Send a Request
Installeer de pakketten die door de Python-voorbeelden worden gebruikt.
python -m pip install requests openai
Sla deze helper op als hydrogen_client.py. Laat PROVIDER ingesteld op cometapi voor CometAPI, of stel het in op google voor directe toegang tot de Gemini Developer API. Latere native voorbeelden importeren dit bestand en behouden zo de gekozen route.
Configureer het geselecteerde endpoint en definieer herbruikbare request- en texthulpfuncties.
import os
import requests
MODEL = "gemini-4-hydrogen"
PROVIDER = "cometapi" # Change to "google" for direct access.
ROUTES = {
"cometapi": ("https://api.cometapi.com", "COMETAPI_KEY"),
"google": ("https://generativelanguage.googleapis.com", "GEMINI_API_KEY"),
}
BASE_URL, KEY_NAME = ROUTES[PROVIDER]
API_KEY = os.environ[KEY_NAME]
URL = f"{BASE_URL}/v1beta/models/{MODEL}:generateContent"
def generate(payload):
response = requests.post(
URL,
headers={"x-goog-api-key": API_KEY},
json=payload,
timeout=120,
)
response.raise_for_status()
return response.json()
def visible_text(data):
candidates = data.get("candidates") or []
if not candidates:
raise ValueError("No candidate returned; inspect promptFeedback.")
candidate = candidates[0]
parts = candidate.get("content", {}).get("parts", [])
text = "".join(
part.get("text", "") for part in parts
if not part.get("thought", False)
)
if not text:
raise ValueError(
f"No visible text; inspect parts and finishReason: "
f"{candidate.get('finishReason')}"
)
return text
Sla het volgende op als hydrogen.py naast de helper. Het script print het antwoord, de afrondingsreden en het gebruik, zodat je een compleet antwoord kunt onderscheiden van een output die bij de tokenlimiet stopte.
Verstuur een tekstaandvraag met de geconfigureerde provider.
from hydrogen_client import generate, visible_text
data = generate({
"contents": [{"role": "user", "parts": [{
"text": "Explain API rate limiting in three sentences."
}]}],
"generationConfig": {
"maxOutputTokens": 4096,
"thinkingConfig": {"thinkingLevel": "MEDIUM"},
},
})
print(visible_text(data))
candidate = data["candidates"][0]
print("Finish reason:", candidate.get("finishReason"))
print("Usage:", data.get("usageMetadata", {}))
Voer het script uit in de terminal waar je de geselecteerde API-sleutel hebt ingesteld.
python hydrogen.py
Lees het antwoord en controleer vervolgens finishReason om te zien waarom de generatie stopte. Controleer in usageMetadata hoeveel tokens de aanvraag gebruikte. MAX_TOKENS betekent dat de respons onvolledig kan zijn, zelfs wanneer het HTTP-verzoek slaagt.
Use JavaScript or an OpenAI-Compatible Client
Kies het voorbeeld dat bij je applicatie past. Het Node.js-voorbeeld verstuurt een native Gemini-aanvraag. Als je al de OpenAI SDK gebruikt, ga dan naar het Python-voorbeeld hieronder.
JavaScript with Node.js
Sla het volgende op als hydrogen.js en voer node hydrogen.js uit. Het verstuurt dezelfde native aanvraagvorm en extraheert alle zichtbare tekstonderdelen.
Verstuur een native GenerateContent-aanvraag vanuit Node.js.
const apiKey = process.env.COMETAPI_KEY;
if (!apiKey) throw new Error("Set COMETAPI_KEY before running this script.");
const baseUrl = "https://api.cometapi.com";
const model = "gemini-4-hydrogen";
async function main() {
const response = await fetch(
`${baseUrl}/v1beta/models/${model}:generateContent`,
{
method: "POST",
headers: {
"Content-Type": "application/json",
"x-goog-api-key": apiKey
},
body: JSON.stringify({
contents: [
{
role: "user",
parts: [
{
text: "Explain how an AI coding agent works."
}
]
}
],
generationConfig: {
maxOutputTokens: 4096,
thinkingConfig: {
thinkingLevel: "MEDIUM"
}
}
})
}
);
if (!response.ok) {
throw new Error(
`API error: ${response.status} ${await response.text()}`
);
}
const data = await response.json();
const candidate = data.candidates?.[0];
const text = (candidate?.content?.parts || [])
.filter(part => !part.thought)
.map(part => part.text || "")
.join("");
if (!text) {
throw new Error(`No visible text; finishReason=${candidate?.finishReason}`);
}
console.log(text);
}
main().catch(console.error);
Python with the OpenAI SDK
Als je applicatie al de OpenAI SDK gebruikt, biedt CometAPI ook POST /v1/chat/completions. De eenvoudigste migratie is het wijzigen van de API-sleutel, de base URL en de model-ID. Gebruik deze route voor gangbare chatworkflows; gebruik het Gemini-native endpoint wanneer je providerspecifieke Gemini-velden nodig hebt.
Maak een Chat Completions-aanvraag via CometAPI.
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["COMETAPI_KEY"],
base_url="https://api.cometapi.com/v1"
)
response = client.chat.completions.create(
model="gemini-4-hydrogen",
messages=[
{
"role": "user",
"content": "Explain how an AI coding agent works."
}
]
)
print(response.choices[0].message.content)
De native voorbeelden gebruiken contents en generationConfig; Chat Completions gebruikt messages en eigen aanvraagvelden. Houd elke aanvraag in รฉรฉn formaat in plaats van native velden te kopiรซren naar een SDK-aanroep die die niet ondersteunt.
Advanced Gemini 4 Hydrogen API Features
De volgende voorbeelden hergebruiken hydrogen_client.py uit de setupsectie en werken dus met de provider die in PROVIDER is geselecteerd. Het streamingvoorbeeld hieronder gebruikt de afzonderlijke CometAPI Chat Completions-client, die past bij een bestaande OpenAI-compatibele applicatie.
Configure reasoning and structured output
Gebruik generationConfig om thinkingConfig.thinkingLevel in te stellen op LOW, MEDIUM, HIGH of XHIGH. Kies een outputbudget dat ruimte laat voor zowel de reasoning als het zichtbare antwoord. Wanneer de applicatie JSON verwacht, gebruik dan responseMimeType en responseSchema in plaats van alleen te vertrouwen op een natuurlijke-taalformattering.
Stel het outputbudget en het reasoningniveau in voor een native aanvraag.
{
"generationConfig": {
"maxOutputTokens": 4096,
"thinkingConfig": {"thinkingLevel": "MEDIUM"}
}
}
Stream responses through CometAPI
Streaming retourneert gegenereerde content stapsgewijs in plaats van te wachten op het complete antwoord. Dit is nuttig voor chatinterfaces, codeassistenten en applicaties waar de waargenomen latentie belangrijk is.
CometAPI documenteert streaming Chat Completions with stream=true. Het Python-voorbeeld verwerkt chunks zonder choices, wat kan voorkomen bij streamingresponses.
Print tekst zodra die binnenkomt via het OpenAI-compatibele endpoint.
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["COMETAPI_KEY"],
base_url="https://api.cometapi.com/v1"
)
stream = client.chat.completions.create(
model="gemini-4-hydrogen",
messages=[
{
"role": "user",
"content": (
"Write a Python function that validates an email "
"address and explain the main checks."
)
}
],
stream=True
)
for chunk in stream:
if not chunk.choices:
continue
delta = chunk.choices[0].delta
if delta and delta.content:
print(delta.content, end="", flush=True)
print()
Voor een native client documenteert CometAPI streamGenerateContent met Server-Sent Events. Die route retourneert GenerateContent-responsobjecten in plaats van Chat Completions-deltaโs. Houd de parser afgestemd op de route; streaminggedrag kan verschillen tussen het native Gemini-endpoint en een OpenAI-compatibele gateway. Test de exacte Hydrogen-route die je applicatie gebruikt voordat je een bestaande streamingclient migreert.
Preserve multi-turn conversation history
Stuur de vorige user- en modelbeurten mee met de volgende aanvraag. Bewaar het volledige contentobject van het model in plaats van het opnieuw op te bouwen uit zichtbare tekst; zo blijven geretourneerde metadata behouden voor de volgende beurt. Sla het voorbeeld op als hydrogen_history.py naast de gedeelde helper.
Doe twee gerelateerde aanvragen terwijl je de volledige eerste modelrespons bewaart.
from hydrogen_client import generate, visible_text
history = [{"role": "user", "parts": [{
"text": "Suggest a simple queue-based background job architecture."
}]}]
config = {
"maxOutputTokens": 4096,
"thinkingConfig": {"thinkingLevel": "MEDIUM"},
}
first = generate({"contents": history, "generationConfig": config})
print(visible_text(first))
candidate = first["candidates"][0]
if candidate.get("finishReason") != "STOP":
raise RuntimeError("The first turn did not finish normally.")
history.append(candidate["content"])
history.append({"role": "user", "parts": [{
"text": "Now identify three failure scenarios in that design."
}]})
second = generate({"contents": history, "generationConfig": config})
print(visible_text(second))
print("Finish reason:", second["candidates"][0].get("finishReason"))
Voer python hydrogen_history.py uit. Het tweede antwoord zou moeten ingaan op het ontwerp uit de eerste beurt. Laat het eerdere gespreksvoorvoegsel in dit voorbeeld ongewijzigd; langlopende applicaties hebben een apart beleid nodig voor compactie en contextlimieten.
Send images and PDFs
Hydrogen ondersteunt beeld- en documentbegrip. Voeg in het Gemini-native aanvraagformaat een inlineData-part toe naast de tekstinstructie. Dit is handig voor schermafdrukanalyse, architectuurdiagrammen, gescande formulieren en rapportextractie.
Sla dit voorbeeld op als analyze_file.py naast hydrogen_client.py. Het verstuurt รฉรฉn lokaal beeld of PDF, zodat je dezelfde code voor beide inputs kunt hergebruiken. Gebruik een klein bestand voor de eerste aanvraag; Base64 vergroot de aanvraaggrootte.
Analyseer een lokaal PNG-, JPEG- of PDF-bestand met de gedeelde native client.
import base64
import sys
from pathlib import Path
from hydrogen_client import generate, visible_text
path = Path(sys.argv[1])
mime_types = {
".png": "image/png", ".jpg": "image/jpeg",
".jpeg": "image/jpeg", ".pdf": "application/pdf",
}
mime_type = mime_types.get(path.suffix.lower())
if mime_type is None:
raise ValueError("Choose a PNG, JPEG, or PDF file.")
data = generate({
"contents": [{"role": "user", "parts": [
{"text": "Summarize this file and identify the key findings."},
{"inlineData": {
"mimeType": mime_type,
"data": base64.b64encode(path.read_bytes()).decode("ascii"),
}},
]}],
"generationConfig": {"maxOutputTokens": 4096},
})
print(visible_text(data))
Voer het bestandsvoorbeeld uit met je eigen document of afbeelding.
python analyze_file.py report.pdf
python analyze_file.py diagram.png
De bestandsbytes moeten overeenkomen met het opgegeven MIME-type. Een hernoemde bestandsextensie converteert het bestand niet. Als een upload wordt geweigerd, bekijk dan de fout op een limiet in grootte of formaat voordat je opnieuw probeert; ga er niet van uit dat een door Google gehoste bestands-URI toegankelijk is via een gateway van derden.
Connect application-controlled tools
Function calling laat het model een bewerking aanvragen die je applicatie uitvoert. Het model retourneert een gestructureerde functieaanroep; je applicatie valideert de argumenten, voert de functie uit en stuurt het resultaat terug.
Dit voorbeeld gebruikt een kleine, fictieve orderdatabase. Sla het op als order_agent.py naast de gedeelde client. Het implementeert de round trip, begrenst de lus op vier aanvragen en bewaart de volledige modelcontentโmet inbegrip van alle geretourneerde signaturesโtussen beurten.
Voer een begrensde functie-aanroep-lus uit tegen een lokale demodatabase.
from hydrogen_client import generate, visible_text
orders = {"DEMO-1001": {"status": "shipped", "carrier": "Example Carrier"}}
tools = [{"functionDeclarations": [{
"name": "lookup_order",
"description": "Retrieve a demonstration order by its order ID.",
"parameters": {
"type": "OBJECT",
"properties": {"order_id": {"type": "STRING"}},
"required": ["order_id"],
},
}]}]
history = [{"role": "user", "parts": [{
"text": "Use lookup_order to check the status of DEMO-1001."
}]}]
for _ in range(4):
data = generate({
"contents": history,
"tools": tools,
"generationConfig": {"maxOutputTokens": 4096},
})
candidates = data.get("candidates") or []
if not candidates or not candidates[0].get("content"):
raise RuntimeError("No model content returned.")
model_content = candidates[0]["content"]
calls = [
part["functionCall"] for part in model_content.get("parts", [])
if "functionCall" in part
]
if not calls:
print(visible_text(data))
break
history.append(model_content) # Preserve all parts and signatures.
results = []
for call in calls:
args = call.get("args", {})
order_id = args.get("order_id") if isinstance(args, dict) else None
if call.get("name") != "lookup_order":
raise ValueError("Unexpected function name.")
if not isinstance(order_id, str) or not order_id:
raise ValueError("order_id must be a non-empty string.")
result = orders.get(order_id, {"error": "Order not found"})
reply = {"name": call["name"], "response": result}
if "id" in call:
reply["id"] = call["id"]
results.append({"functionResponse": reply})
history.append({"role": "user", "parts": results})
else:
raise RuntimeError("Tool-call limit reached before a final answer.")
Voer python order_agent.py uit. Het eindantwoord zou moeten overeenkomen met het lokale record voor DEMO-1001. Autoriseer in een echte service de gebruiker voordat je toegang geeft tot een order; de keuze van een order-ID door het model is geen bewijs van toestemming.
How Much Does Gemini 4 Hydrogen API Cost?
De onderstaande tarieven zijn USD per miljoen tokens, gecontroleerd op 17 november 2026. Ze vergelijken standaard ongecachete input en output, niet batch, priority, cached-input of apart gefactureerd toolgebruik.
| Token type | Google Global Standard | Gemini 4 Hydrogen API in CometAPI |
|---|---|---|
| Input tokens / 1M | $1.50 | $1.20 |
| Output tokens / 1M | $7.50 | $6.00 |
Voor 100.000 inputtokens en 10.000 factureerbare outputtokens is de CometAPI-schatting 0.1 ร $1.20 + 0.01 ร $6.00 = $0.18. Dezelfde volumes tegen de door Google vermelde standaardtarieven kosten $0.225, een verschil van 20%. Neem reasoning-tokens mee in het outputgebruik en controleer het gefactureerde gebruik van je account bij het inschatten van een echte workflow.
How Do You Migrate to Gemini 4 Hydrogen API?
What Changes When Migrating from Gemini 3.8 Flash?
Controleer voordat je de model-ID wijzigt de reasoning-instelling, het contextbudget en de gespreksgeschiedenis die je client met elke aanvraag meestuurt.
| Integration detail | Gemini 3.8 Flash | Gemini 4 Hydrogen |
|---|---|---|
| Default thinking level | MEDIUM | HIGH |
| Context accounting | Aparte input- en outputlimieten | Eรฉn gedeeld input/outputbudget |
| Multi-turn state | Beoordeel de huidige historyafhandeling van de client | Bewaar volledige modelparts en signatures; voor prefix-bewerkingen is speciale handling nodig |
De documented migration changes zijn vooral van belang wanneer je applicatie vertrouwt op defaults, history compact, of meerdere toolbeurten uitvoert. Stel reasoning expliciet in en test een korte bestaande workflow voordat je het productiemodel wijzigt.
Update an existing integration
Maak een testconfiguratie met de nieuwe model-ID terwijl je de sleutel en het endpoint bij elkaar houdt. Voer dezelfde representatieve workflow uit met beide configuraties, zodat je hun gedrag kunt vergelijken.
- Stuur een nieuwe tekstaandvraag en controleer de afrondingsreden en het tokengebruik.
- Speel een multi-turn taak en een tool-roundtrip af met gebruik van complete modelresponsobjecten.
- Verwijder incompatibele besturingen die in de beperkingssectie staan voordat je aanvraagresultaten vergelijkt.
- Oefen je rollbackpad in een nieuw gesprek; ga er niet van uit dat een ander model de in Hydrogen opgeslagen reasoningmetadata accepteert.
Decide whether the migration helps your workload
Neem de nieuwe configuratie over wanneer die voldoet aan de doelstellingen voor kwaliteit en latentie tegen een acceptabele kostprijs per afgeronde taak. Als de huidige client al aan die doelstellingen voldoet, gebruik dan een beperkte pilot om een voordeel vast te stellen voordat je alle aanvragen migreert. Houd de prompts, inputs en beoordelingscriteria consistent tijdens de evaluatie.
Gemini 4 Hydrogen API Limitations
De Hydrogen developer guide beschrijft beperkingen die bestaande clients beรฏnvloeden. Los deze op in de requestconstructie in plaats van dezelfde geweigerde payload te blijven retryen.
- Unsupported fields: verwijder thinkingBudget, thinkingLevel ingesteld op MINIMAL, frequencyPenalty, presencePenalty en candidateCount groter dan รฉรฉn.
- Ignored sampling settings: aangepaste temperature, topP en topK sturen de Hydrogen-output niet aan.
- Caching: expliciete cachedContent wordt niet ondersteund. Stabiele promptprefixen kunnen impliciete caching gebruiken, maar dat zorgt niet voor een gateway-specifieke cachediscount.
- Long output: de voorbeeldclient in deze gids implementeert alleen een synchrone aanvraag. Achtergrond long decode of providerspecifieke continuatieworkflows worden niet behandeld.
- Conversation changes: het wijzigen van eerdere prompts of tooldefinities kan de reasoningstate ongeldig maken. Bewaar het prefix, of implementeer het gedocumenteerde prefix-mismatch-gedrag voor de geselecteerde route.
Common setup checks
| Symptom | First check |
|---|---|
| 401 or 403 | Bevestig dat de inloggegevens bij het endpoint horen en toegang hebben tot het geselecteerde model. |
| 400 | Lees de foutbody; controleer unsupported fields, ongeldige JSON en conversatiemetadata. |
| No visible text | Inspecteer promptFeedback, candidate parts en finishReason; de respons kan geblokkeerd, onvolledig of om een tool vragen. |
| MAX_TOKENS | Behandel de tekst als mogelijk onvolledig en herzie het outputbudget voordat je het accepteert. |
| File request rejected | Verifieer het daadwerkelijke MIME-type en de payloadlimiet van de geselecteerde route. |
Noteer bij onverwachte fouten model, route, status, tijdstip en request-ID indien beschikbaar. Houd API-sleutels en gevoelige bestandsinhoud uit reguliere logs.
FAQ
How should I retry Gemini 4 Hydrogen API rate-limit errors?
Gebruik voor HTTP 429 minder gelijktijdigheid en retry met exponentiรซle backoff en jitter, met een vast maximum aantal pogingen. Bewaar de request-ID wanneer de gateway die verstrekt. Retry ongeldige aanvragen of authenticatiefouten niet ongewijzigd; de error and retry guide van CometAPI onderscheidt die van tijdelijke storingen. Een timeout kan optreden nadat de verwerking is gestart, dus bescherm elke applicatieactie tegen dubbele uitvoering.
Can I call Gemini 4 Hydrogen API directly from a web app?
Leid verzoeken via je eigen backend. Een sleutel die in frontend-JavaScript is ingebed, kan door bezoekers worden geรซxtraheerd, zelfs als de code gebundeld of geminified is. Laat de backend gebruikers authenticeren, gebruikslimieten toepassen en het modelverzoek versturen. Voor streaming kun je de incrementele respons naar de browser doorsturen zonder de upstream API-sleutel bloot te leggen.
How should I handle an interrupted Gemini 4 Hydrogen stream?
Behandel de ontvangen tekst als een gedeeltelijk resultaat totdat de respons voltooid is. Een nieuwe aanvraag start een nieuwe generatie; deze hervat niet automatisch de afgebroken stream op hetzelfde token. Houd gedeeltelijke output gescheiden van een opnieuw geprobeerd antwoord en voer geen acties uit op basis van onvolledige JSON of onvoltooide toolargumenten. Bied een zichtbare retry-actie aan in plaats van twee generaties stilzwijgend te concatenaten.
Conclusion
Gebruik een representatieve taak als eerste acceptatiecheck: de aanvraag moet slagen, de applicatie moet het beoogde resultaat extraheren en het geregistreerde tokengebruik moet binnen je budget passen. Voeg รฉรฉn functie tegelijk toe en houd die check in je integratiesuite. Een kleine, goed observeerbare client is makkelijker uit te breiden dan een grote workflow waarvan fouten lastig te traceren zijn.

