Gemini 4 Carbon API : tarifs, raisonnement et migration

Pour les tâches de programmation difficiles, commencez avec Gemini 4 Carbon et thinking_level="medium" ; gardez Argon pour le travail interactif courant. Avant de choisir Carbon par défaut, budgétez aux tarifs de décembre : les prix standard par token doublent le 1er décembre 2026. Ne choisissez pas low uniquement pour économiser : dans CursorBench, son coût par tâche dépasse celui de medium.

Au 13 novembre 2026, la documentation Carbon de Google indique que gemini-4-carbon est disponible dans l’offre payante de Gemini API et dans Google AI Studio. Carbon n’est pas disponible dans le Free tier, l’offre gratuite. Son raisonnement plus approfondi consomme davantage de tokens de raisonnement et augmente la latence par tour par rapport à Argon.

Combien coûte Gemini 4 Carbon avant et après le 30 novembre ?

Utilisez les tarifs de décembre pour les budgets récurrents, même si votre évaluation initiale bénéficie des prix de lancement. Voici les tarifs standard de l’API Google, en USD par 1M tokens, vérifiés le 13 novembre 2026 sur sa page de tarification.

Catégorie de tokens	Jusqu’au 30 novembre 2026 inclus	À partir du 1er décembre 2026
Entrée hors cache	$2.00	$4.00
Entrée servie depuis le cache implicite	$0.10	$0.20
Sortie, tokens de raisonnement compris	$10.00	$20.00

Les tokens de raisonnement sont facturés comme de la sortie, même s’ils n’apparaissent pas dans la réponse finale. Avec le grounding, qui ancre les réponses dans des sources externes, Google compte aussi les instructions internes des outils et les déclarations de fonctions. Les outils peuvent entraîner des frais distincts ; la longueur de la réponse ne suffit donc pas à expliquer la facture d’un agent.

Pour estimer le coût des tokens du modèle, séparez les entrées hors cache, les entrées en cache et les sorties facturables. Supposons qu’une tâche d’agent cumule les volumes suivants sur l’ensemble de ses appels :

200,000 tokens d’entrée hors cache.
800,000 tokens d’entrée en cache.
100,000 tokens de sortie facturables, raisonnement compris.

L’estimation aux tarifs de lancement est 0.2 × $2 + 0.8 × $0.10 + 0.1 × $10 = $1.48.

L’estimation aux tarifs de décembre est 0.2 × $4 + 0.8 × $0.20 + 0.1 × $20 = $2.96.

Ces montants estiment uniquement les frais de tokens du modèle, pas une facture complète. Ils excluent les outils, les abonnements et les taxes. La part du cache est une hypothèse, pas un taux de succès prévu. Sans ces lectures en cache, les mêmes volumes d’entrée et de sortie coûteraient $3.00 avant décembre, puis $6.00.

Relevez l’usage réel en incluant les nouvelles tentatives et les tentatives infructueuses. Un faible prix par token ne garantit pas un faible coût par modification de code acceptée.

Quel niveau de raisonnement choisir ?

Commencez par medium, puis ajustez l’effort sur une tâche de programmation reproductible. Google recommande medium pour la plupart des usages, y compris le code complexe et les tâches avec agents. Son guide des niveaux de raisonnement destine low aux tâches simples et high aux raisonnements les plus difficiles.

Les résultats de CursorBench 4.0 au 13 novembre 2026 montrent pourquoi les niveaux d’effort ne constituent pas des plafonds de dépenses :

Modèle et niveau d’effort	Score	Coût publié par tâche	Étapes
Gemini 4 Carbon High	60.4%	$9.22	71
Gemini 4 Carbon Medium	60.1%	$8.49	67
Gemini 4 Carbon Low	58.6%	$11.89	124
Fable 5.2 Max	60.0%	$32.79	218
Opus 5.5 High	56.0%	$3.97	68
Gemini 4 Argon High	52.9%	$4.57	118

Dans cette évaluation, Carbon Low coûtait $3.40 de plus par tâche que Medium. Il nécessitait aussi 124 étapes au lieu de 67. High gagnait 0.3 point de pourcentage sur Medium, pour un surcoût de $0.73.

Ces résultats proviennent du jeu de tâches ambiguës et multifichiers propre à Cursor. Ils ne prédisent ni les résultats sur votre dépôt ni votre facture de décembre. Les données agrégées ne permettent pas d’attribuer l’écart de coût au cache, au raisonnement ou à un autre facteur.

Gardez medium lorsque le résultat passe vos tests. Essayez high si Medium ne respecte pas une exigence difficile ou échoue sur un débogage reproductible. Pour un travail bien délimité, utilisez low seulement après avoir vérifié que les tentatives supplémentaires n’annulent pas l’économie par tour.

Pour comparer avec un modèle hors de la gamme Gemini, le guide de configuration et de tarification de Fable 5.2 propose une évaluation via l’API et Claude Code. Comparez les modifications acceptées avec les mêmes tests. Ne considérez pas les noms des niveaux d’effort de différents fournisseurs comme équivalents.

Envoyer une requête à l’API native de Gemini

Utilisez l’API native de Google pour les exemples Interactions ci-dessous. Activez un projet payant depuis la configuration de la facturation, puis terminez les étapes de paiement requises. Créez ensuite une clé Gemini API. Vérifiez les régions prises en charge par Google avant de prévoir une intégration directe.

La ressource REST native est https://generativelanguage.googleapis.com/v1beta/interactions. Le SDK Python gère la requête et l’authentification.

Au 13 novembre 2026, BetterToken répertorie également gemini-4-carbon. Son URL de base compatible OpenAI est https://www.bettertoken.ai/v1 ; vérifiez séparément les tarifs de la passerelle. Les exemples d’Interactions natives et d’exécution en arrière-plan ci-dessous ne garantissent pas la compatibilité avec cette passerelle.

Dans Bash, installez le SDK et saisissez votre clé sans l’afficher. Collez-la lorsque read attend une saisie, puis appuyez sur Entrée.

python3 -m pip install --upgrade "google-genai>=2.34.0"
read -rs GEMINI_API_KEY && export GEMINI_API_KEY

Enregistrez ce code dans carbon_smoke.py. Il demande une petite correction de code sans fournir au modèle d’outils pour modifier des fichiers ou exécuter du code.

import os
from google import genai

client = genai.Client(api_key=os.environ["GEMINI_API_KEY"])
interaction = client.interactions.create(
    model="gemini-4-carbon",
    input=(
        "Find the bug. Return a corrected function and pytest tests for "
        "cached values 0 and False.\n\n"
        "def cached_value(cache, key, load):\n"
        "    if cache.get(key):\n"
        "        return cache[key]\n"
        "    cache[key] = load()\n"
        "    return cache[key]\n"
    ),
    generation_config={
        "thinking_level": "medium",
        "max_output_tokens": 32768,
    },
    timeout=900.0,
)
if interaction.status != "completed" or not interaction.output_text:
    raise RuntimeError(f"Unexpected result: {interaction.status}")

print(interaction.output_text)
print("Usage:", interaction.usage)

Exécutez-le dans la même session Bash :

python3 carbon_smoke.py

La vérification de base réussit si le script affiche du texte et les données d’usage sans lever d’exception lors du contrôle du résultat. Examinez la réponse : les valeurs 0 et False en cache ne doivent pas déclencher un nouvel appel à load(). Exécutez les tests proposés dans votre environnement habituel avant d’accepter la modification.

L’implémentation du SDK exprime le timeout de chaque appel en secondes. Ici, 900.0 autorise 15 minutes. C’est une limite d’attente, pas une estimation de la durée de cette petite tâche.

Si la requête est rejetée, vérifiez d’abord le projet associé à la clé, l’activation de la facturation payante et l’éligibilité régionale. Si le client n’expose pas interactions, mettez à jour google-genai dans l’environnement Python qui exécute le script.

Que faut-il changer lors de la migration ?

Limitez les modifications, mais vérifiez les budgets de tokens et de temps avant de basculer le trafic de production. Google distingue la migration depuis Argon de celle depuis Gemini 3 ou une version antérieure.

Depuis Gemini 4 Argon

Remplacez gemini-4-argon par gemini-4-carbon : Google indique que ce changement ne nécessite aucune modification du schéma de requête. Cela ne garantit pas la même latence ni le même coût pour une requête identique.

Gardez thinking_level sur medium au départ. Vérifiez max_output_tokens et les délais d’attente, car Carbon peut consacrer davantage de tokens au raisonnement. Conservez Argon pour les modifications interactives et les fonctionnalités qui passent déjà vos tests d’acceptation, surtout lorsque le temps de réponse compte.

Pour une intégration Managed Agents existante, conservez agent="antigravity-preview-09-2026". Définissez agent_config={"type":"antigravity","model":"gemini-4-carbon"}. L’identifiant de l’agent reste distinct du modèle choisi.

Depuis Gemini 3 et les versions antérieures

Mettez à jour l’ID du modèle, puis adaptez ces quatre aspects des requêtes :

Supprimez le cache explicite. Carbon ne prend en charge ni cachedContents ni caches.create. Supprimez les requêtes qui créent ou référencent cached_content.
Supprimez les paramètres d’échantillonnage. Carbon ignore temperature, top_p et top_k. Ne comptez pas sur ces réglages pour conserver le comportement antérieur.
Vérifiez le plafond de sortie. Google recommande au moins 32,768 si une application existante utilise une limite inférieure. Le raisonnement consomme une partie de ce budget ; un plafond trop bas peut laisser trop peu de place à la réponse.
Prévoyez une exécution plus longue. Utilisez l’arrière-plan ou un délai d’attente d’au moins 15 minutes pour les requêtes bloquantes. Vérifiez aussi les délais de l’application et du proxy, pas seulement ceux du SDK.

Le cache implicite reste disponible pour les prompts d’au moins 4,096 tokens. Une lecture en cache bénéficie d’une réduction de 95% sur les tokens d’entrée. Répéter du texte ne garantit toutefois pas que le cache sera utilisé.

Le guide actuel du cache de Google ajoute une condition pour les boucles d’agent. Pour mettre en cache toute la requête précédente, la nouvelle doit ajouter au moins 2,050 tokens. Mesurez l’usage du cache renvoyé dans la réponse plutôt que d’appliquer le tarif réduit à tout le contexte répété.

Comment générer plus de 65,536 tokens ?

Utilisez background=True et augmentez max_output_tokens pour les générations longues gérées par le serveur. Carbon possède une fenêtre unique de 1,048,576 tokens, partagée entre l’entrée, le raisonnement et la sortie. Une entrée volumineuse réduit donc le budget restant pour la génération.

Google fixe le budget de sortie par défaut à 65,536 tokens. Ce n’est pas un plafond absolu pour tous les appels au premier plan gérés par le SDK. Le guide de génération longue décrit aussi une continuation côté client avec le SDK Python 2.34.0 ou ultérieur.

L’arrière-plan est utile lorsque l’application doit envoyer une tâche puis récupérer son résultat plus tard. Définir uniquement background=True n’augmente pas le budget de sortie. Définissez explicitement max_output_tokens.

L’exécution en arrière-plan exige également le stockage des interactions. Google documente une erreur 400 lorsque background=True est combiné à store=False. Consultez les règles de stockage et d’exécution en arrière-plan avant d’envoyer des éléments sensibles de votre dépôt.

Enregistrez le code suivant dans carbon_background.py. Placez dans request.txt une description de tâche autorisée à l’envoi et ne contenant aucun secret. Le script peut lancer une tâche ou reprendre les vérifications de statut d’une interaction existante.

import os
import sys
import time
from pathlib import Path
from google import genai

if len(sys.argv) != 3 or sys.argv[1] not in ("start", "resume"):
    raise SystemExit(
        "Usage: python3 carbon_background.py start request.txt\n"
        "   or: python3 carbon_background.py resume INTERACTION_ID"
    )

client = genai.Client(api_key=os.environ["GEMINI_API_KEY"])
mode, value = sys.argv[1:]

if mode == "resume":
    job = client.interactions.get(id=value)
else:
    prompt = Path(value).read_text(encoding="utf-8")
    if not prompt.strip():
        raise SystemExit("Request file is empty.")
    job = client.interactions.create(
        model="gemini-4-carbon",
        input=prompt,
        background=True,
        store=True,
        generation_config={
            "thinking_level": "medium",
            "max_output_tokens": 131072,
        },
    )

print("Interaction ID:", job.id, flush=True)

try:
    while job.status in ("queued", "in_progress"):
        time.sleep(5)
        job = client.interactions.get(id=job.id)
except KeyboardInterrupt:
    client.interactions.cancel(id=job.id)
    raise SystemExit("Cancellation requested.")

if job.status != "completed":
    raise RuntimeError(f"Interaction {job.id} stopped: {job.status}")

text = "".join(
    block.text
    for step in (job.steps or [])
    if step.type == "model_output"
    for block in (step.content or [])
    if block.type == "text" and block.text
)
if not text:
    raise RuntimeError("Completed without text; inspect the interaction steps.")

print(text)
print("Usage:", job.usage)

Lancez-le dans la même session Bash que celle contenant votre clé API :

python3 carbon_background.py start request.txt

Conservez l’ID d’interaction affiché. Après une panne réseau, exécutez python3 carbon_background.py resume suivi de cet ID pour récupérer la tâche existante. Ne créez pas automatiquement une autre tâche payante simplement parce qu’une vérification de statut a échoué.

Le script réunit le texte de toutes les étapes model_output. Une génération longue peut comporter plusieurs étapes de continuation. Lire seulement la dernière peut faire perdre le début de la sortie.

Ctrl+C demande l’annulation de la tâche, au lieu de simplement arrêter les vérifications de statut. resume ne relance pas une tâche annulée. Pour tout autre statut terminal, examinez l’interaction avant de modifier le prompt ou d’augmenter le budget.

Le plafond 131072 est un maximum, pas la longueur attendue de la réponse. Vérifiez que le résultat est complet et passe vos tests avant de l’accepter.

En quoi les frais diffèrent-ils entre Cursor et Copilot ?

Vérifiez séparément le choix du modèle et la manière dont l’abonnement comptabilise son usage. L’accès à Carbon dans un éditeur ne rend pas son utilisation gratuite.

Dans Cursor, sélectionnez Gemini 4 Carbon et commencez au niveau Medium. La page du modèle chez Cursor précise que Carbon est exclu de l’usage compris dans les forfaits Cursor. Avec The X Subscription, les frais sont déduits du crédit prépayé. Sur les anciens forfaits, ils sont prélevés sur l’enveloppe Other Models. Cursor indique également les tarifs par token plus élevés à partir du 1er décembre.

Dans GitHub Copilot, Carbon est disponible pour les utilisateurs Pro+, Max, Business et Enterprise. L’annonce du 10 novembre mentionne le choix du modèle dans des clients comme VS Code et Copilot CLI. Le déploiement est progressif et les politiques de modèles de l’organisation peuvent affecter l’accès.

Copilot facture Carbon au tarif catalogue du fournisseur, selon l’usage. N’appliquez pas à Copilot la règle d’enveloppe incluse de Cursor : la documentation de facturation GitHub détaille le calcul selon le forfait. Pour comparer avec le modèle propre à Copilot, consultez les niveaux d’effort et la facturation de Copilot Fusion.

Avant de lancer un long travail d’agent dans l’éditeur, demandez une modification bien délimitée et examinez l’usage facturé. Ne choisissez un modèle par défaut qu’après avoir vérifié le taux de modifications acceptées, la latence et le budget aux tarifs de décembre.