DEV Community: Antoine Laurent

Claude Haiku 5.5 contre GPT-6 Luna

Antoine Laurent — Thu, 08 Oct 2026 04:27:09 +0000

Claude Haiku 5.5 et GPT-6 Luna affichent le même tarif catalogue pour les requêtes Haiku jusqu’à 100K jetons : 0,10 $ par million de jetons d’entrée et 0,50 $ par million de jetons de sortie. Les lectures de cache coûtent 0,01 $ et les écritures de cache 0,125 $ chez les deux fournisseurs. La différence apparaît au seuil tarifaire : Haiku 5.5 passe à 0,50 $/2,50 $ au-delà de 100K jetons, tandis que Luna conserve son tarif de base jusqu’à 272K jetons d’entrée, puis applique 2× sur l’entrée et 1,5× sur la sortie. Dans le tableau de lancement d’Anthropic, Haiku 5.5 obtient un meilleur score sur toutes les lignes partagées. En revanche, les graphiques de coûts d’Anthropic montrent que Luna est moins cher par tâche à chaque niveau d’effort sur GDPval-AA et à quatre niveaux sur cinq sur OSWorld.

Essayez Apidog dès aujourd’hui

Ce guide compare les prix, les spécifications, les benchmarks, le coût par niveau d’effort et le routage par charge de travail. Pour analyser chaque modèle séparément, consultez Claude Haiku 5.5 et GPT-6 Luna. La section pratique montre ensuite comment envoyer la même invite aux deux modèles dans Apidog.

Comparaison des prix

Par million de jetons	Claude Haiku 5.5	GPT-6 Luna
Entrée, niveau de base	0,10 $ (invites jusqu’à 100K jetons)	0,10 $ (jusqu’à 272K jetons d’entrée)
Sortie, niveau de base	0,50 $	0,50 $
Lecture de cache, niveau de base	0,01 $	0,01 $
Écriture de cache, niveau de base	0,125 $ (5 minutes)	0,125 $
Niveau supérieur, entrée / sortie	0,50 $ / 2,50 $ (au-delà de 100K)	0,20 $ / 0,75 $ (au-delà de 272K)
Niveau supérieur, lecture / écriture de cache	0,05 $ / 0,625 $	Tarifs de cache 2×
Lot	0,05 $ / 0,25 $ jusqu’à 100K ; 0,25 $ / 1,25 $ au-delà	50 % des tarifs standards (Batch et Flex)

Sources : documentation tarifaire d’Anthropic et page du modèle GPT-6 Luna d’OpenAI.

OpenAI recalcule le prix de « l’ensemble de la requête » au-delà de 272K jetons. Anthropic indique qu’une invite de plus de 100 000 jetons est facturée au niveau supérieur, selon la longueur de l’invite.

Calculer le coût par requête

Sous 100K jetons, les deux modèles coûtent la même chose. Entre 100K et 272K, Haiku 5.5 est 5× plus cher que Luna pour les jetons d’entrée et de sortie. Au-delà de 272K, les deux passent au niveau supérieur, mais Luna reste moins cher.

Exemples avec les jetons comptés par chaque fournisseur :

Invite de 150K jetons, sortie de 2K jetons
- Haiku 5.5 : 0,15 × 0,50 $ + 0,002 × 2,50 $ = 0,080 $
- Luna : 0,15 × 0,10 $ + 0,002 × 0,50 $ = 0,016 $
Invite de 300K jetons, sortie de 2K jetons
- Haiku 5.5 : 0,30 × 0,50 $ + 0,002 × 2,50 $ = 0,155 $
- Luna : 0,30 × 0,20 $ + 0,002 × 0,75 $ = 0,0615 $

Anthropic indique que les invites jusqu’à 100K jetons représentaient environ 90 % des requêtes Haiku 4.5. Si votre trafic suit ce profil, la majorité des appels coûte donc le même prix chez les deux fournisseurs. Pour détailler les calculs, consultez la tarification de Claude Haiku 5.5.

Les tokeniseurs déplacent le seuil

Un jeton Claude n’est pas nécessairement un jeton GPT. Anthropic indique que le tokeniseur mis à jour de Haiku 5.5 produit environ 30 % de jetons de plus que Haiku 4.5 pour le même texte.

Dans le fil de lancement Hacker News, un commentateur estime que « 100K jetons de Claude moderne équivalent à environ 60-65K jetons GPT modernes ». C’est une estimation communautaire, pas une donnée fournie par les fournisseurs.

En pratique :

Comptez les mêmes corpus et invites dans les deux API.
Enregistrez l’objet usage de chaque réponse.
Comparez les seuils tarifaires avec les volumes réellement tokenisés.
Ne basez pas votre routage sur une conversion théorique entre tokeniseurs.

Spécifications

	Claude Haiku 5.5	GPT-6 Luna
ID du modèle API	`claude-haiku-5-5`	`gpt-6-luna`
Fenêtre de contexte	1M de jetons	1 050 000 jetons
Sortie maximale	128K jetons (300K en lot avec un en-tête bêta)	128 000 jetons
Date de connaissance limite	Juin 2026	18 mai 2026
Niveaux d’effort	bas, moyen, élevé, très élevé, max	aucun, bas, moyen, élevé, très élevé, max
Réflexion désactivée	`thinking: {"type": "disabled"}` à effort élevé ou inférieur	effort de raisonnement `none`
Accès gratuit au chat	Les utilisateurs gratuits de Claude.ai peuvent le sélectionner	Utilisateurs Free et Go dans l’application de bureau ChatGPT

Les deux modèles utilisent le niveau medium par défaut.

Haiku 5.5 : output_config.effort
Luna : reasoning.effort

Les accès gratuits au chat ne fournissent pas de clé API : ils ne peuvent donc pas alimenter un script, une tâche CI ou un agent. Consultez Claude Haiku 5.5 gratuitement et GPT-6 Luna gratuitement.

Impact du cache dans les boucles

La mise en cache peut modifier fortement le coût des agents et des pipelines itératifs :

Avec Haiku 5.5, modifier le niveau d’effort supérieur entre deux requêtes invalide le cache des invites.
OpenAI indique que changer l’effort de raisonnement ne rompt plus le cache sur les modèles GPT-6.

Voir : mise en cache des invites GPT-6.

Benchmarks : scores et provenance des résultats

Les chiffres suivants proviennent du billet de lancement d’Anthropic et de sa carte système. Anthropic a compilé le tableau, mais chaque ligne ne provient pas nécessairement du même exécutant.

Les résultats Haiku 5.5 sont à l’effort maximal, majoritairement calculés comme moyenne sur cinq essais.

Benchmark	Haiku 5.5	GPT-6 Luna	Source de la cellule Luna
GDPval-AA v2.1 (Elo)	1620	1437	Exécuté indépendamment par Artificial Analysis
AA-Briefcase v1.1 (Elo)	1578	1336	Exécuté indépendamment par Artificial Analysis
OSWorld 2.1, sous-ensemble hors ligne	72,4 %	48,9 %	Exécuté par Anthropic sur les mêmes 82 tâches via l’API OpenAI
Terminal-Bench 4.0	39,2 %	16,4 %	Classement public, Codex CLI à effort maximal
FrontierCode 1.1 (Principal)	46,4 %	42,4 %	Exécuté par Cognition
Cartographie, sans outils	46,4 %	29,1 %	Rapporté publiquement par Surge AI

Ces lignes partagent un benchmark, mais pas nécessairement le même environnement d’exécution.

Par exemple :

Terminal-Bench compare Haiku 5.5 dans Claude Code à Luna dans le CLI Codex.
OSWorld est le comparatif le plus proche d’un contrôle : Anthropic a exécuté les deux modèles sur les mêmes tâches.
OSWorld reste toutefois un test exécuté par un fournisseur sur le modèle d’un concurrent.

Aucun comparatif indépendant complet n’existe encore. Au 8 octobre 2026, Artificial Analysis ne dispose pas de page Haiku 5.5, et aucun résultat Haiku 5.5 n’a été trouvé sur Vals, LMArena, SWE-bench ou Aider. Le classement d’Artificial Analysis indiquait alors GPT-6 Luna au niveau max avec un indice d’intelligence de 38 et 129 jetons de sortie par seconde.

Pour les données Haiku 5.5 détaillées, voir Benchmarks de Claude Haiku 5.5.

Coût par tentative selon le niveau d’effort

Le tableau de lancement affiche les modèles au niveau max, mais les courbes d’Anthropic permettent aussi de comparer les niveaux d’effort intermédiaires.

OSWorld 2.1 : score de crédit partiel / coût par tentative

Effort	Haiku 5.5	GPT-6 Luna
Bas	42,0 % / 0,0695 $	19,2 % / 0,038 $
Moyen	53,3 % / 0,1257 $	37,5 % / 0,1261 $
Élevé	61,3 % / 0,1827 $	42,3 % / 0,1435 $
Très élevé	67,6 % / 0,2792 $	44,8 % / 0,1672 $
Max	72,4 % / 0,6111 $	48,9 % / 0,205 $

GDPval-AA v2.1 : Elo / coût par tâche

Effort	Haiku 5.5	GPT-6 Luna
Bas	1125 / 0,01167 $	1036 / 0,0038 $
Moyen	1277 / 0,03042 $	1262 / 0,02 $
Élevé	1420 / 0,08938 $	1344 / 0,03 $
Très élevé	1513 / 0,26725 $	1364 / 0,05 $
Max	1620 / 0,86593 $	1437 / 0,09 $

Comment interpréter ces données

Luna coûte moins cher :

à chaque niveau d’effort sur GDPval-AA ;
aux niveaux bas, élevé, très élevé et max sur OSWorld.

Sur OSWorld au niveau moyen, Haiku 5.5 est marginalement moins cher : 0,1257 $ contre 0,1261 $.

À budget comparable :

OSWorld : Haiku 5.5 au niveau moyen coûte 0,1257 $ et atteint 53,3 %, contre 37,5 % pour Luna au même coût approximatif. Haiku moyen dépasse aussi Luna max (48,9 %) pour moins cher.
GDPval-AA : Luna max atteint 1437 Elo pour 0,09 $, tandis que Haiku 5.5 élevé atteint 1420 Elo pour 0,08938 $. L’écart est de 17 Elo pour une dépense comparable.

Pour les tâches d’automatisation informatique, Haiku 5.5 présente donc un meilleur score par dollar selon les tests d’Anthropic. Pour le travail de connaissance, les deux sont proches à budget équivalent, tandis que le coût plancher inférieur de Luna est intéressant lorsque « suffisamment bon » est l’objectif.

Routage : quel modèle utiliser selon la charge de travail ?

Anthropic positionne Haiku 5.5 pour les « tâches à portée limitée » et recommande Sonnet 5.5 ou Opus 5.5 pour le codage agentique complexe. Les deux modèles comparés ici sont orientés volume.

Charge de travail	Commencer avec	Pourquoi
Classification, routage, extraction sous 100K jetons	L’un ou l’autre ; tester les deux	Prix identique, la précision sur vos données décide
Questions/réponses sur documents de 100K à 272K jetons	GPT-6 Luna	Tarif de base jusqu’à 272K ; Haiku 5.5 est 5× plus cher après 100K
Automatisation navigateur et bureau	Claude Haiku 5.5	Score OSWorld plus élevé à coût comparable
Sous-agents sous Opus 5.5 ou Sonnet 5.5	Claude Haiku 5.5	Frontmatter Claude Code `model: haiku`
Coût minimal par appel	GPT-6 Luna	Coût plancher inférieur sur les graphiques présentés
Rédaction de travaux de connaissance à effort élevé	Tester les deux	Environ 17 Elo d’écart à dépense comparable sur GDPval-AA

Pour aller plus loin :

Claude Haiku 5.5 dans Claude Code pour les sous-agents ;
GPT-6 Luna pour les charges de travail API à fort volume pour les pipelines à QPS élevé ;
Haiku 5.5 vs Haiku 4.5 si vous migrez depuis Haiku 4.5.

Tester les deux côte à côte dans Apidog

Le meilleur comparatif utilise vos propres invites, vos formats de sortie et vos contraintes de latence. Dans Apidog, créez un projet avec une requête par fournisseur et conservez le même jeu de test.

Procédure recommandée

Stockez ANTHROPIC_API_KEY et votre clé OpenAI comme variables d’environnement.
Ajoutez une requête pour Haiku 5.5 et une requête pour Luna.
Utilisez la même invite, le même schéma de sortie et un effort comparable.
Exécutez les deux modèles aux niveaux bas, moyen et élevé.
Enregistrez la latence, les jetons d’entrée, les jetons de sortie, les tokens de raisonnement et la qualité de sortie.
Vérifiez que stop_reason pour Haiku n’est pas "refusal" : il n’existe pas de solution de repli côté serveur.
Contrôlez l’objet usage pour vérifier que chaque exécution reste dans votre budget.

Exemple de requête Haiku 5.5 :

curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-haiku-5-5",
    "max_tokens": 2048,
    "thinking": {"type": "adaptive"},
    "output_config": {"effort": "medium"},
    "messages": [
      {
        "role": "user",
        "content": "Classify this support ticket as billing, bug, or feature request: The export button returns a 500 error since this morning."
      }
    ]
  }'

N’ajoutez pas temperature, top_p ou top_k : des valeurs non par défaut renvoient une erreur 400 sur Haiku 5.5.

Pour une procédure API complète, consultez comment utiliser l’API Claude Haiku 5.5. Pour construire un jeu d’évaluation, consultez tester les applications LLM.

FAQ

Claude Haiku 5.5 et GPT-6 Luna ont-ils le même prix ?

Oui, pour les invites Haiku jusqu’à 100K jetons : 0,10 $/0,50 $, 0,01 $ pour les lectures de cache et 0,125 $ pour les écritures de cache. Au-delà de ce seuil, Haiku 5.5 passe à 0,50 $/2,50 $, alors que Luna maintient son tarif de base jusqu’à 272K jetons.

Quel modèle obtient les meilleurs scores ?

Haiku 5.5 obtient les meilleurs scores sur chaque ligne partagée du tableau de lancement d’Anthropic. Ce tableau a été compilé par Anthropic et aucun comparatif indépendant complet n’existe encore.

Quel modèle coûte le moins cher par tâche ?

Généralement Luna : à chaque niveau d’effort sur GDPval-AA et à quatre niveaux sur cinq sur OSWorld. Sur OSWorld moyen, Haiku 5.5 coûte 0,0004 $ de moins. À budget comparable, Haiku 5.5 est en tête sur OSWorld, tandis que GDPval-AA reste proche.

L’un des deux modèles est-il gratuit ?

Uniquement via les interfaces de chat :

les utilisateurs gratuits de Claude.ai peuvent sélectionner Haiku 5.5 ;
les utilisateurs Free et Go disposent de Luna dans l’application de bureau ChatGPT.

Aucun de ces accès ne fournit une clé API. Voir Claude Haiku 5.5 gratuitement.

Choisir selon la longueur d’invite, puis mesurer

Commencez par analyser la longueur réelle de vos invites :

Sous 100K jetons : prix identique ; choisissez selon la précision, la latence et le comportement sur vos cas réels.
Entre 100K et 272K jetons : Luna est plus économique à chaque appel grâce à son seuil plus élevé.
Au-delà de 272K jetons : Luna reste moins cher selon les tarifs présentés, mais comparez aussi la qualité obtenue et le nombre de tentatives nécessaires.

Ensuite, exécutez les deux modèles sur de vraies requêtes à deux ou trois niveaux d’effort. Téléchargez Apidog, placez les deux requêtes dans le même projet et utilisez les données usage, la latence et la qualité de sortie pour prendre votre décision.

Claude Haiku 5.5 Benchmarks

Antoine Laurent — Thu, 08 Oct 2026 04:25:46 +0000

Claude Haiku 5.5 obtient 72,4 % sur OSWorld 2.1, 1620 sur GDPval-AA v2.1, 46,4 % sur FrontierCode 1.1 et 39,2 % sur Terminal-Bench 4.0. Haiku 4.5 a obtenu 15,7 %, 735 et 0,0 % sur trois de ces benchmarks. Ces résultats utilisent tous l’effort maximal ; avec l’effort medium par défaut, GDPval-AA descend à 1277. Aucun laboratoire indépendant n’a encore publié de résultats pour Haiku 5.5.

Essayez Apidog dès aujourd’hui

Voici les benchmarks de Claude Haiku 5.5, leurs conditions d’exécution, l’impact de l’effort sur le score et le coût, ainsi qu’une méthode pour tester le modèle sur votre trafic dans Apidog. Pour les spécifications et tarifs, consultez d’abord qu’est-ce que Claude Haiku 5.5.

Le tableau de lancement

Les résultats Haiku 5.5 utilisent une réflexion adaptative à effort maximal, généralement moyennée sur cinq essais. Terminal-Bench utilise dix essais par tâche. n/r signifie qu’aucun résultat n’a été publié.

Benchmark	Haiku 5.5	Haiku 4.5	GPT-6 Luna	Sonnet 5.5
GDPval-AA v2.1 (Elo)	1620	735	1437	1840
AA-Briefcase v1.1 (Elo)	1578	614	1336	1824
OSWorld 2.1, sous-ensemble hors ligne	72,4 %	15,7 %	48,9 %	83,9 %
Humanity’s Last Exam, sans outils	45,9 %	10,2 %	n/r	56,9 %
Humanity’s Last Exam, avec outils	57,4 %	18,7 %	n/r	64,5 %
Terminal-Bench 4.0	39,2 %	0,0 %	16,4 %	70,6 %
FrontierCode 1.1 (Main)	46,4 %	n/r	42,4 %	52,1 % (`xhigh`)
Chartography, sans outils	46,4 %	6,4 %	29,1 %	61,6 %

Qui a exécuté chaque benchmark ?

Ne comparez pas uniquement les noms de benchmarks : les fournisseurs peuvent utiliser des harnais, des outils et des niveaux d’effort différents.

Benchmark	Exécuté par	Conditions
GDPval-AA v2.1, AA-Briefcase v1.1	Artificial Analysis, indépendamment	GDPval-AA : 220 tâches, 44 métiers, Elo ancré à DeepSeek V4.1 Flash (`max`) à 1600 ; Briefcase : projets de plusieurs semaines
FrontierCode 1.1	Cognition	Claude dans Claude Code, GPT dans Codex ; Main = 100 tâches les plus difficiles sur 150
Chartography	Anthropic, sur le benchmark de Surge AI	Évaluateur Gemini 3.5 Flash ; score Luna provenant de Surge AI
Terminal-Bench 4.0	Anthropic	Claude Code `--bare`, 66 tâches, 10 essais par tâche, protections activées
OSWorld 2.1	Anthropic	82 tâches sur 108, 1080p, jusqu’à 500 étapes
Humanity’s Last Exam	Anthropic	Budget de 980K tokens par tâche, évaluateur Opus 4.6

Deux résultats GPT-6 Luna nécessitent un contexte :

Anthropic a exécuté OSWorld de Luna via l’API OpenAI sur les mêmes 82 tâches.
Le score Terminal-Bench de Luna, 16,4 %, provient du classement public avec Codex CLI à effort maximal.
Sur Terminal-Bench, les protections ont arrêté 1,8 % des essais Haiku 5.5, soit 12 essais sur 660. Chaque arrêt a été compté comme un échec.

Le piège FrontierCode

Le tableau de lancement compare Haiku 5.5 à effort maximal, 46,4 %, avec Sonnet 5.5 à xhigh, 52,1 %. Ce ne sont pas les mêmes réglages.

La fiche système fournit une comparaison directe :

FrontierCode 1.1	Main	Extended
Haiku 5.5, `max`	46,4 %	58,4 %
Haiku 5.5, `xhigh`	45,8 %	n/r
Sonnet 5.5, `max`	46,2 %	59,1 %
Sonnet 5.5, `xhigh`	52,1 %	64,4 %

À effort maximal identique, Haiku 5.5 devance légèrement Sonnet 5.5 sur Main : 46,4 % contre 46,2 %.

En revanche, au meilleur réglage de chaque modèle, Sonnet 5.5 mène de 5,7 points. Indiquez donc toujours le niveau d’effort lorsque vous citez un score FrontierCode.

Résultats supplémentaires de la fiche système

La fiche système inclut des résultats absents de la publication de lancement. Tous utilisent l’effort maximal, sauf indication contraire.

Benchmark	Haiku 5.5	Haiku 4.5	Sonnet 5.5
SWE-Bench Pro	64,8	n/r	81,3
SWE-bench Multilingual	83,7	67,4	90,3
SWE-bench Multimodal	30,7	19,8	54,3
OSWorld 2.1, taux de réussite strict	37,1 %	n/r	48,8 %
Chartography, avec outils	86,2 %	8,8 %	90,2 %
OfficeQA / OfficeQA Pro	73,5 % / 60,3 %	63,0 % / 47,1 %	76,9 % / 65,6 %
HealthBench Professional, ajusté à la longueur	64,8 %	32,2 %	69,2 %

Deux implications pratiques :

Les 72,4 % d’OSWorld représentent du crédit partiel : seulement 37,1 % des tâches sont totalement réussies.
Chartography passe de 46,4 % sans outils à 86,2 % avec outils. Pour les tâches graphiques, fournissez donc les outils nécessaires à Haiku 5.5.

L’effort par défaut produit des scores inférieurs

Haiku 5.5 utilise medium par défaut dans l’API Claude et Claude Code.

Benchmark	`medium` par défaut	`max`	Note
GDPval-AA v2.1	1277	1620	`medium` utilise environ un dixième des tokens de sortie de `max`
AA-Briefcase v1.1	1372	1578	`medium` utilise moins d’un quart des tokens de sortie de `max`
HealthBench Professional	59,9 %	64,8 %	`low` : 57,9 % ; `high` : 61,3 %

Si vous appelez l’API sans output_config.effort, attendez-vous aux scores de la colonne medium.

La documentation sur l’effort décrit les cinq niveaux disponibles.

Score et coût selon l’effort

Les valeurs suivantes proviennent des graphiques de lancement. Les coûts OSWorld et Terminal-Bench sont par tentative ; ceux de GDPval-AA sont par tâche.

OSWorld 2.1

Modèle	Faible	Medium	Élevé	Xhigh	Max
Haiku 5.5	42,0 % (0,07 $)	53,3 % (0,13 $)	61,3 % (0,18 $)	67,6 % (0,28 $)	72,4 % (0,61 $)
Sonnet 5.5	57,9 % (0,68 $)	66,0 % (0,93 $)	73,2 % (1,38 $)	81,1 % (2,22 $)	83,9 % (5,73 $)
GPT-6 Luna	19,2 % (0,04 $)	37,5 % (0,13 $)	42,3 % (0,14 $)	44,8 % (0,17 $)	48,9 % (0,21 $)

GDPval-AA v2.1

Modèle	Faible	Medium	Élevé	Xhigh	Max
Haiku 5.5	1125 (0,012 $)	1277 (0,030 $)	1420 (0,089 $)	1513 (0,27 $)	1620 (0,87 $)
Sonnet 5.5	1179 (0,22 $)	1324 (0,27 $)	1551 (0,62 $)	1731 (1,88 $)	1840 (6,78 $)
GPT-6 Luna	1036 (0,004 $)	1262 (0,02 $)	1344 (0,03 $)	1364 (0,05 $)	1437 (0,09 $)

Terminal-Bench 4.0

Modèle	Faible	Medium	Élevé	Xhigh	Max
Haiku 5.5	12,7 % (0,42 $)	20,3 % (0,68 $)	24,8 % (1,04 $)	31,5 % (1,75 $)	39,2 % (2,64 $)
Sonnet 5.5	20,0 % (0,62 $)	28,8 % (0,68 $)	43,0 % (1,46 $)	61,5 % (4,34 $)	70,6 % (10,44 $)

À retenir :

Le dernier palier vers max est coûteux. Sur GDPval-AA, max coûte environ 28 fois plus que medium pour 343 points Elo supplémentaires. Sur OSWorld, max coûte plus de deux fois xhigh pour seulement 4,8 points.
Haiku 5.5 en medium dépasse Luna en max sur OSWorld : 53,3 % pour 0,13 $, contre 48,9 % pour 0,21 $.
Haiku 5.5 en max dépasse Sonnet 5.5 en medium sur OSWorld : 72,4 % pour 0,61 $, contre 66,0 % pour 0,93 $.
Terminal-Bench est l’exception. Sonnet 5.5 en high, 43,0 % pour 1,46 $, dépasse Haiku 5.5 en max, 39,2 % pour 2,64 $.

Luna est moins cher aux niveaux d’effort correspondants, sauf en medium sur OSWorld où les coûts sont proches. Consultez Haiku 5.5 vs GPT-6 Luna pour le détail.

Les coûts reposent sur les prix catalogue : 0,10 $ / 0,50 $ par million de tokens pour les prompts jusqu’à 100K tokens, avec des tarifs plus élevés au-delà. Voir le détail des prix.

Là où Haiku 5.5 reste en retrait

Sonnet 5.5 est en tête de toutes les lignes du tableau de lancement. Haiku 5.5 ne le dépasse que sur FrontierCode à effort maximal identique.

Les écarts notables sont :

Terminal-Bench 4.0 : 39,2 % pour Haiku 5.5 contre 70,6 % pour Sonnet 5.5.
SWE-Bench Pro : 64,8 contre 81,3.
SWE-bench Multimodal : 30,7 contre 54,3.

Anthropic indique que Sonnet 5.5 et Opus 5.5 restent de meilleurs choix pour les tâches complexes de codage agentique.

Utilisez plutôt Haiku 5.5 pour des charges étroites et répétables :

compaction de contexte ;
résumé ;
classification ;
utilisation de navigateur ;
sous-agents pilotés par un modèle plus puissant.

Le scénario de sous-agent à coût réduit est présenté dans Haiku 5.5 dans Claude Code.

Résultats indépendants : aucun pour l’instant

Au 8 octobre 2026, aucun laboratoire indépendant n’a publié de résultats pour Haiku 5.5.

La page Haiku 5.5 d’Artificial Analysis renvoie une erreur 404, et son classement ne liste que Claude 4.5 Haiku. Vals, LMArena, SWE-bench et Aider n’ont pas non plus publié de résultat.

Il n’existe pas de chiffre de vitesse tiers. Anthropic décrit Haiku 5.5 comme son modèle le plus rapide à vitesse standard, mais plus lent qu’Opus en mode rapide.

Le résultat externe le plus proche vient de Cursor. Sa documentation du modèle indique :

48,4 % sur CursorBench à effort maximal ;
30,9 % à effort faible ;
avec la réflexion désactivée, entre 22,1 % et 26,2 % aux mêmes niveaux où la réflexion activée atteint 30,9 % à 42,3 %.

Ce que les clients rapportent

Les chiffres suivants proviennent de la publication de lancement d’Anthropic et ne sont pas vérifiés indépendamment :

HubSpot : 92,8 % en moyenne sur trois exécutions de sa suite de portail CRM simulée.
AlphaSense : 0,84 contre 0,76 pour Haiku 4.5 sur 400 requêtes « Ask in Document ».
Box : 11 points de plus que Haiku 4.5 avec environ la moitié de la latence lors des premiers tests.
Asana : plus de 30 % de latence en moins pour l’achèvement des tâches par rapport à son modèle actuel.
Cognition : Devin Fusion atteint 66,2 sur FrontierCode avec Haiku 5.5 comme acolyte et Opus 5.5 comme leader. Il s’agit d’un système à deux modèles, pas d’un score Haiku seul.

Exécutez votre propre évaluation

Les benchmarks ne représentent pas forcément votre trafic de production.

Le guide de prompt d’Anthropic recommande d’utiliser xhigh ou max uniquement si vos propres évaluations démontrent un gain. Exécutez aussi les mêmes cas avec Sonnet 5.5.

Procédure dans Apidog

Stockez ANTHROPIC_API_KEY comme variable d’environnement.
Créez une collection de 20 à 50 prompts réels sous forme de requêtes Messages.
Ajoutez des assertions :
- statut HTTP 200 ;
- stop_reason différent de "max_tokens" et "refusal" ;
- présence des éléments attendus dans une réponse correcte.
Exécutez la collection en low, medium et high.
Enregistrez le taux de réussite, usage.input_tokens et usage.output_tokens.
Dupliquez la collection, remplacez le modèle par claude-sonnet-5-5, puis comparez les résultats dans le même projet.

Modifier l’effort invalide le cache des prompts. Le nouveau tokenizer produit aussi environ 30 % de tokens supplémentaires par rapport à Haiku 4.5 pour le même texte.

Exemple de requête Messages :

curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-haiku-5-5",
    "max_tokens": 8000,
    "thinking": {"type": "adaptive"},
    "output_config": {"effort": "medium"},
    "messages": [
      {
        "role": "user",
        "content": "Classify this support ticket as billing, bug or feature request: ..."
      }
    ]
  }'

N’envoyez pas temperature, top_p, top_k ni de préremplissage assistant : chacun provoque une erreur 400 avec Haiku 5.5.

Sélectionnez également les blocs de réponse selon leur champ type, car un bloc thinking peut apparaître avant le bloc de texte final.

Consultez le guide de l’API et le guide sur le test des applications LLM.

FAQ

Claude Haiku 5.5 est-il meilleur que Sonnet 5.5 ?

Pas selon les chiffres d’Anthropic. Sonnet 5.5 mène toutes les lignes du tableau de lancement. Haiku ne le dépasse que sur FrontierCode lorsque les deux modèles utilisent max : 46,4 % contre 46,2 %. Consultez Haiku 5.5 vs Haiku 4.5 pour comparer les générations.

Quel est le score SWE-bench de Haiku 5.5 ?

64,8 sur SWE-Bench Pro, 83,7 sur SWE-bench Multilingual et 30,7 sur SWE-bench Multimodal, tous à effort maximal.

À quel niveau d’effort les benchmarks ont-ils été exécutés ?

À effort maximal, généralement avec une moyenne de cinq essais. Le réglage API par défaut est medium, où GDPval-AA atteint 1277 au lieu de 1620.

Existe-t-il des benchmarks indépendants pour Haiku 5.5 ?

Pas encore. Artificial Analysis a exécuté GDPval-AA et AA-Briefcase indépendamment, mais Anthropic a publié les scores et Artificial Analysis ne dispose pas encore d’une page Haiku 5.5.

GPT-6 Luna est-il moins cher ?

Généralement, oui. Luna coûte moins cher à chaque niveau sur GDPval-AA et OSWorld, sauf au niveau medium où les coûts sont proches. Haiku 5.5 obtient toutefois de meilleurs scores sur ces deux benchmarks.

Étape suivante

Commencez avec medium. N’augmentez l’effort que si le gain de taux de réussite justifie le coût sur vos propres cas d’usage.

Téléchargez Apidog, créez la collection d’évaluation ci-dessus et conservez les résultats dans Apidog, à côté de votre référence Sonnet 5.5, avant de déplacer du trafic de production.

Claude Haiku 5.5 vs Haiku 4.5 : Nouveautés et ruptures à corriger en priorité

Antoine Laurent — Thu, 08 Oct 2026 04:25:40 +0000

Claude Haiku 5.5 (claude-haiku-5-5, sorti le 7 octobre 2026) réduit de 90 % le coût des invites allant jusqu’à 100 000 jetons par rapport à Haiku 4.5 : 0,10 $/0,50 $ par million de jetons d’entrée/sortie, contre 1 $/5 $. Il étend aussi la fenêtre contextuelle de 200 000 à 1 million de jetons et affiche de meilleurs scores sur les benchmarks de lancement communs. En contrepartie, plusieurs requêtes compatibles avec Haiku 4.5 renvoient une erreur 400 sur 5.5, tandis que d’autres changements modifient silencieusement les réponses et les coûts.

Essayez Apidog dès aujourd’hui

Ce guide fournit les différences de requête, les JSON avant/après, les changements silencieux et un plan de test dans Apidog. Consultez aussi la fiche technique : qu’est-ce que Claude Haiku 5.5. Si votre application utilise encore l’ancien modèle, reportez-vous au guide de l’API Claude Haiku 4.5.

Haiku 4.5 vs Haiku 5.5 en un coup d’œil

	Claude Haiku 4.5	Claude Haiku 5.5
ID du modèle (API Claude)	`claude-haiku-4-5-20251001`	`claude-haiku-5-5`
Contexte / sortie max	200K / 64K	1M / 128K
Entrée / sortie par MJetons	1 $ / 5 $	0,10 $ / 0,50 $ jusqu’à 100 000 jetons ; 0,50 $ / 2,50 $ au-delà
Lecture cache / écriture 5 min par MJetons	0,10 $ / 1,25 $	0,01 $ / 0,125 $ jusqu’à 100K ; 0,05 $ / 0,625 $ au-delà
Entrée / sortie par lot par MJetons	0,50 $ / 2,50 $	0,05 $ / 0,25 $ jusqu’à 100K ; 0,25 $ / 1,25 $ au-delà
Réflexion	`budget_tokens` manuel	Adaptative uniquement, activée par défaut
Niveaux d’effort	Aucun	`low`, `medium` (par défaut), `high`, `xhigh`, `max`
Invite minimale cachable	4 096 jetons	512 jetons
Tokeniseur	Ancien	Environ 30 % de jetons en plus pour le même texte
Échantillonnage non par défaut / préremplissage	Accepté	Erreur 400
Niveau de priorité	Pris en charge	Non pris en charge
Statut	Actif, retrait pas avant le 15 oct. 2026	Actif, retrait pas avant le 7 oct. 2027

Haiku 4.5 n’est pas encore obsolète. La page d’obsolescence des modèles le liste comme actif, sans date d’obsolescence. Les limites de débit sont identiques pour les deux modèles.

Les cinq changements majeurs

Les cas suivants fonctionnaient avec Haiku 4.5 mais produisent une erreur 400 avec Haiku 5.5. Référez-vous également au guide de migration Haiku 5.5.

1. Remplacer `budget_tokens` par la réflexion adaptative

Haiku 5.5 rejette un budget de réflexion fixe. Utilisez la réflexion adaptative et pilotez le comportement avec output_config.effort.

// Avant : Haiku 4.5
{
  "model": "claude-haiku-4-5-20251001",
  "max_tokens": 16000,
  "thinking": { "type": "enabled", "budget_tokens": 8000 },
  "messages": [
    { "role": "user", "content": "Classify this ticket." }
  ]
}

// Après : Haiku 5.5
{
  "model": "claude-haiku-5-5",
  "max_tokens": 16000,
  "thinking": { "type": "adaptive" },
  "output_config": { "effort": "medium" },
  "messages": [
    { "role": "user", "content": "Classify this ticket." }
  ]
}

Pour limiter le raisonnement, réduisez l’effort au lieu de définir un budget. Vous pouvez désactiver la réflexion avec thinking: { "type": "disabled" }, mais uniquement avec un effort high ou inférieur. Les niveaux xhigh et max avec réflexion désactivée renvoient une erreur 400.

2. Supprimer les paramètres d’échantillonnage

Supprimez temperature, top_p et top_k de vos requêtes migrées.

Les seules valeurs acceptées sont :

temperature: 1
top_p: 0.99

Toute autre valeur renvoie une erreur 400, y compris top_p: 1, tout top_k, ou l’envoi simultané de temperature et top_p.

// Avant : Haiku 4.5
{
  "model": "claude-haiku-4-5-20251001",
  "max_tokens": 1024,
  "temperature": 0.2,
  "top_k": 40,
  "messages": [
    { "role": "user", "content": "Extract the order ID." }
  ]
}

// Après : Haiku 5.5
{
  "model": "claude-haiku-5-5",
  "max_tokens": 1024,
  "messages": [
    { "role": "user", "content": "Extract the order ID." }
  ]
}

Si vous utilisiez une température faible pour stabiliser le format, explicitez cette contrainte dans votre prompt.

3. Supprimer le préremplissage de l’assistant

Haiku 5.5 rejette un dernier message assistant utilisé pour amorcer ou compléter une réponse. Votre tableau messages doit se terminer par un tour utilisateur.

// Avant : Haiku 4.5
{
  "model": "claude-haiku-4-5-20251001",
  "max_tokens": 1024,
  "messages": [
    { "role": "user", "content": "Return the sentiment as JSON." },
    { "role": "assistant", "content": "{\"sentiment\": \"" }
  ]
}

// Après : Haiku 5.5
{
  "model": "claude-haiku-5-5",
  "max_tokens": 1024,
  "system": "Reply with only a JSON object. No preamble.",
  "messages": [
    { "role": "user", "content": "Return the sentiment as JSON." }
  ]
}

Pour des sorties strictes, utilisez les sorties structurées ou un outil avec des champs d’énumération pour les tâches de classification.

4. Migrer l’utilisation de l’ordinateur vers `computer_toolset_20260801`

Sur l’API Claude et Google Cloud, Haiku 5.5 prend en charge l’utilisation de l’ordinateur via le nouvel ensemble d’outils uniquement.

Actions à appliquer :

Remplacez computer_20250124 par computer_toolset_20260801.
Supprimez l’en-tête bêta computer-use-2025-01-24.
Supprimez fine-grained-tool-streaming-2025-05-14 s’il est présent : il renvoie une erreur 400 avec un ensemble d’outils.

// Avant : Haiku 4.5
// En-tête : anthropic-beta: computer-use-2025-01-24
{
  "model": "claude-haiku-4-5-20251001",
  "max_tokens": 4096,
  "tools": [
    {
      "type": "computer_20250124",
      "name": "computer",
      "display_width_px": 1280,
      "display_height_px": 800
    }
  ],
  "messages": [
    { "role": "user", "content": "Open the settings page." }
  ]
}

// Après : Haiku 5.5
// Aucun en-tête bêta
{
  "model": "claude-haiku-5-5",
  "max_tokens": 4096,
  "tools": [
    { "type": "computer_toolset_20260801" }
  ],
  "messages": [
    { "role": "user", "content": "Open the settings page." }
  ]
}

Mettez également à jour votre boucle d’agent :

dispatchez les appels d’outils avec name et toolset_name de chaque bloc tool_use ;
n’utilisez plus input.action comme clé de routage ;
renvoyez toolset_name dans les résultats d’outil.

Haiku 5.5 ajoute également l’outil de navigateur browser_toolset_20260801, non pris en charge par Haiku 4.5. Consultez l’utilisation de l’ordinateur avec Claude Code pour une vue d’ensemble.

5. Ne modifiez pas l’historique avant un bloc de réflexion

Un bloc de réflexion Haiku 5.5 reste valide uniquement si tout le contenu qui le précède est strictement identique. Modifier system, tools ou un message antérieur, puis renvoyer le bloc de réflexion, produit une erreur 400.

// Incorrect : système modifié + bloc de réflexion rejoué = 400
{
  "model": "claude-haiku-5-5",
  "max_tokens": 4096,
  "system": "You are a billing agent. Be brief.",
  "messages": [
    { "role": "user", "content": "Why was I charged twice?" },
    {
      "role": "assistant",
      "content": [
        {
          "type": "thinking",
          "thinking": "",
          "signature": "<from turn 1>"
        },
        { "type": "text", "text": "Checking." }
      ]
    },
    { "role": "user", "content": "Order 4412." }
  ]
}

// Correct : historique inchangé, instruction ajoutée au nouveau tour
{
  "model": "claude-haiku-5-5",
  "max_tokens": 4096,
  "system": "You are a billing agent.",
  "messages": [
    { "role": "user", "content": "Why was I charged twice?" },
    {
      "role": "assistant",
      "content": [
        {
          "type": "thinking",
          "thinking": "",
          "signature": "<from turn 1>"
        },
        { "type": "text", "text": "Checking." }
      ]
    },
    { "role": "user", "content": "Order 4412. Be brief." }
  ]
}

Pour les comptes créés avant le 31 août 2026 à 00:00 UTC, cette erreur n’apparaît que si la requête définit thinking.block_binding.prefix_mismatch_behavior.

Changements silencieux à tester

Même si la requête renvoie un statut 200, vérifiez les comportements suivants.

Champ thinking vide par défaut : les blocs de réflexion contiennent un champ thinking vide et une signature. Haiku 4.5 renvoyait une réflexion résumée. Pour l’afficher ou l’enregistrer, définissez :

  {
    "thinking": {
      "type": "adaptive",
      "display": "summarized"
    }
  }

La réponse peut commencer par un bloc de réflexion : recherchez les blocs content par leur champ type, jamais par leur position dans le tableau.
Environ 30 % de jetons en plus : recomptez vos prompts. Les jetons de réflexion sont inclus dans max_tokens, ce qui peut provoquer stop_reason: "max_tokens" avant toute sortie texte.
tool_choice forcé ignore la réflexion : any ou un outil nommé fonctionne, mais la réponse débute par un appel d’outil sans bloc thinking. Pour laisser le modèle raisonner avant l’appel, utilisez :

  {
    "tool_choice": { "type": "auto" }
  }

Puis précisez dans le prompt quand l’outil doit être appelé.

Nouveaux refus sans repli automatique : les classificateurs de sécurité cyber, frontier_llm, bio et general_harms peuvent retourner stop_reason: "refusal". Une nouvelle tentative produit généralement le même résultat.
Niveau de priorité supprimé : si vous avez un engagement de priorité pour Haiku 4.5, prévoyez la capacité séparément pour Haiku 5.5.
Blocs de réflexion liés au compte : ils fonctionnent uniquement dans le compte qui les a produits, ou dans un compte lié. Rejouer une conversation depuis un autre compte perd ce raisonnement.
Mise en cache plus accessible : le seuil d’invite cachable descend de 4 096 à 512 jetons. Des prompts système auparavant trop courts peuvent maintenant bénéficier du cache.

Ce qui s’est amélioré

Les chiffres suivants sont rapportés par Anthropic pour Haiku 5.5 avec l’effort maximal. Artificial Analysis a exécuté GDPval-AA et AA-Briefcase indépendamment.

Benchmark	Haiku 4.5	Haiku 5.5
GDPval-AA v2.1 (Elo)	735	1620
AA-Briefcase v1.1 (Elo)	614	1578
OSWorld 2.1, sous-ensemble hors ligne	15,7 %	72,4 %
Le dernier examen de l’humanité, avec outils	18,7 %	57,4 %
Terminal-Bench 4.0	0,0 %	39,2 %
SWE-bench Multilingue	67,4 %	83,7 %
Cartographie, sans outils	6,4 %	46,4 %

L’exécution Terminal-Bench de Haiku 4.5 utilisait un budget de réflexion fixe de 63 999 jetons. Avec l’effort medium par défaut, Haiku 5.5 a obtenu 1277 sur GDPval-AA, toujours bien au-dessus de Haiku 4.5.

Box a rapporté des scores supérieurs de 11 points à ceux de Haiku 4.5 pour environ la moitié de la latence. Consultez les benchmarks de Claude Haiku 5.5 pour les tableaux complets.

Anthropic positionne toujours Sonnet 5.5 et Opus 5.5 comme de meilleurs choix pour le codage agentique complexe. Haiku 5.5 vise notamment :

la classification ;
l’extraction ;
la summarisation ;
la compaction ;
les sous-agents ;
l’utilisation du navigateur.

Côté coût, Anthropic indique que Haiku 5.5 est en moyenne environ 75 % moins cher. Cette estimation combine une baisse de 90 % jusqu’à 100 000 jetons et de 50 % au-delà, tout en tenant compte du nouveau tokeniseur. Le prompt système d’utilisation des outils passe aussi de 496 à 286 jetons avec tool_choice: "auto".

Pour les calculs détaillés, consultez la tarification de Claude Haiku 5.5.

Testez la migration dans Apidog

Dans Apidog, créez trois requêtes enregistrées vers https://api.anthropic.com/v1/messages.

Référence

Utilisez votre corps Haiku 4.5 actuel et vérifiez un statut 200.
Ancien corps, nouveau modèle

Changez uniquement model vers claude-haiku-5-5. Vérifiez un statut 400. Gardez une requête de test par changement majeur détecté.
Requête migrée

Appliquez les corrections nécessaires, puis vérifiez :
- un statut 200 ;
- un stop_reason différent de refusal et max_tokens ;
- la présence d’un bloc texte détecté avec type: "text".

Stockez ANTHROPIC_API_KEY comme variable d’environnement et référencez-la dans l’en-tête x-api-key :

{{ANTHROPIC_API_KEY}}

Ajoutez également l’en-tête :

anthropic-version: 2023-06-01

Comparez usage.input_tokens entre la requête de référence et la requête migrée afin de mesurer l’effet du tokeniseur sur vos prompts réels. Enregistrez ensuite l’ensemble sous forme de scénario de test : si quelqu’un réintroduit temperature, l’exécution échoue avant la production.

Les requêtes de base sont disponibles dans comment utiliser l’API Claude Haiku 5.5.

Si vous utilisez Claude Code, exécutez :

/claude-api migrate this project to claude-haiku-5-5

La commande applique l’échange d’ID de modèle et les corrections de paramètres, puis fournit une liste de contrôle. Notez que l’alias haiku pointe vers Haiku 5.5 uniquement via l’API Anthropic. Consultez Claude Haiku 5.5 dans Claude Code.

FAQ

Claude Haiku 4.5 est-il obsolète ?

Non. Il est listé comme actif, sans date d’obsolescence, et son retrait n’est pas prévu avant le 15 octobre 2026.

Pourquoi ma requête Haiku 4.5 renvoie-t-elle une erreur 400 sur Haiku 5.5 ?

Vérifiez successivement :

budget_tokens ;
temperature, top_p ou top_k ;
un préremplissage de l’assistant ;
computer_20250124 ;
une modification de l’historique précédant un bloc de réflexion.

Ce sont les cinq causes majeures d’erreur 400 lors de la migration.

Haiku 5.5 est-il moins cher que Haiku 4.5 pour les longues invites ?

Oui. Au-delà de 100 000 jetons, Haiku 5.5 coûte 0,50 $/2,50 $ par million de jetons, contre 1 $/5 $ pour Haiku 4.5. Haiku 4.5 ne peut pas traiter des invites dépassant 200 000 jetons.

Dois-je tout migrer vers Haiku 5.5 ?

Pour les charges de classification, d’extraction et de sous-agents, commencez par un test comparatif sur vos propres prompts et jeux de données. Vous pouvez aussi le comparer à son concurrent le plus proche dans Haiku 5.5 vs GPT-6 Luna.

Étape suivante

Enregistrez votre requête Haiku 4.5 et son équivalent Haiku 5.5 côte à côte. Vérifiez d’abord l’erreur 400 avec l’ancien corps, corrigez chaque incompatibilité, puis basculez le trafic une fois les assertions de la requête migrée validées.

Téléchargez Apidog pour construire cette paire de tests.

Claude Haiku 5.5 Tarifs

Antoine Laurent — Thu, 08 Oct 2026 04:21:17 +0000

Claude Haiku 5.5 coûte 0,10 $ par million de jetons d’entrée et 0,50 $ par million de jetons de sortie pour les invites allant jusqu’à 100 000 jetons. Au-delà de 100 000 jetons, les tarifs passent à 0,50 $ en entrée et 2,50 $ en sortie. Les lectures de cache commencent à 0,01 $, l’API Batch divise les tarifs par deux, et Anthropic estime que le modèle coûte « environ 75 % moins cher à exécuter » que Haiku 4.5 en moyenne.

Essayez Apidog dès aujourd’hui

Ce guide détaille les postes de coût, explique l’estimation des 75 %, fournit des exemples pratiques — y compris une requête de plus de 100 000 jetons — et montre comment mesurer vos coûts réels. Si vous découvrez le modèle, commencez par ce qu’est Claude Haiku 5.5. Pour vérifier ces chiffres sur votre trafic, envoyez des requêtes depuis Apidog et lisez le bloc usage de chaque réponse.

Tableau des prix de l’API Claude Haiku 5.5

Prix par million de jetons (MTok), d’après la documentation tarifaire d’Anthropic :

Poste	Invites jusqu’à 100 000 jetons	Invites de plus de 100 000 jetons
Entrée	0,10 $	0,50 $
Sortie	0,50 $	2,50 $
Écriture cache de 5 minutes	0,125 $	0,625 $
Écriture cache d’une heure	0,20 $	1,00 $
Lecture cache (succès et actualisations)	0,01 $	0,05 $
Entrée par lot	0,05 $	0,25 $
Sortie par lot	0,25 $	1,25 $

La règle à automatiser est simple : une invite de plus de 100 000 jetons applique les tarifs élevés à l’appel.

Points à intégrer dans vos estimations :

Inférence uniquement aux États-Unis : le routage avec inference_geo coûte 1,1× plus cher pour chaque catégorie de jetons. Sous 100 000 jetons, cela représente 0,11 $ en entrée et 0,55 $ en sortie.
Nouveau tokeniseur : le même texte produit environ 30 % de jetons en plus qu’avec Haiku 4.5.
Coût des outils réduit : l’invite système pour l’utilisation d’outils est de 286 jetons (auto/aucun), contre 496 avec Haiku 4.5.
Pas de Priority Tier ni de mode rapide.

Formule de coût sans cache

Pour une requête sans cache :

coût = (jetons_entrée × tarif_entrée + jetons_sortie × tarif_sortie) / 1 000 000

Exemple sous le seuil : 4 000 jetons d’entrée et 110 jetons de sortie.

coût = (4 000 × 0,10 + 110 × 0,50) / 1 000 000
      = 0,000455 $

Exemple au-dessus du seuil : 150 000 jetons d’entrée et 2 000 jetons de sortie.

coût = (150 000 × 0,50 + 2 000 × 2,50) / 1 000 000
      = 0,08 $

D’où vient le « environ 75 % de moins »

Haiku 5.5 est tarifé 90 % moins cher que Haiku 4.5 jusqu’à 100 000 jetons et 50 % moins cher au-delà. Anthropic indique que 90 % des requêtes Haiku 4.5 étaient sous 100 000 jetons, tout en tenant compte du nouveau tokeniseur.

Une reconstruction approximative :

Pondérez par nombre de requêtes :

   0,9 × 90 % + 0,1 × 50 % = 86 % de réduction

Ajoutez environ 30 % de jetons supplémentaires avec le nouveau tokeniseur :

   coût restant = 14 % × 1,3 = 18,2 %
   économie estimée = 81,8 %

Le chiffre d’Anthropic est plus prudent : les invites longues représentent probablement une part plus importante des dépenses que du volume de requêtes. Utilisez donc 75 % comme moyenne de référence, puis calculez votre propre valeur à partir de usage.

Coût par tentative selon le niveau d’effort

Haiku 5.5 est le premier Haiku avec des niveaux d’effort, de low à max. La valeur par défaut de l’API est medium.

L’effort peut influencer votre facture davantage que la grille tarifaire. Les chiffres ci-dessous proviennent des graphiques de lancement : Anthropic a exécuté OSWorld et Terminal-Bench, tandis qu’Artificial Analysis a exécuté GDPval-AA.

Effort	OSWorld 2.1 (score, $/tentative)	GDPval-AA v2.1 (Elo, $/tâche)	Terminal-Bench 4.0 (score, $/tentative)
`low`	42,0 %, 0,0695 $	1125, 0,0117 $	12,7 %, 0,424 $
`medium`	53,3 %, 0,1257 $	1277, 0,0304 $	20,3 %, 0,6798 $
`high`	61,3 %, 0,1827 $	1420, 0,0894 $	24,8 %, 1,0372 $
`xhigh`	67,6 %, 0,2792 $	1513, 0,2673 $	31,5 %, 1,7545 $
`max`	72,4 %, 0,6111 $	1620, 0,8659 $	39,2 %, 2,6433 $

Pour choisir un niveau d’effort :

Commencez en low ou medium avec un jeu d’évaluation représentatif.
Comparez le taux de réussite, les jetons de sortie et le coût par tâche.
Passez à high ou max seulement si le gain de qualité justifie la hausse du coût.

À retenir :

max coûte 4,9× plus cher que medium sur OSWorld : 0,6111 ÷ 0,1257.
Sur GDPval-AA, max coûte 28,5× plus cher que medium : 0,86593 ÷ 0,03042.
Les scores mis en avant au lancement correspondent à max. Avec le réglage par défaut medium, GDPval-AA atteint 1277, et non 1620.
Pour le codage agentique complexe, examinez Sonnet. Sur Terminal-Bench, Sonnet 5.5 en low avec des lectures de cache à 0,10 $ atteint 20 % pour 0,6205 $, contre 20,3 % et 0,6798 $ pour Haiku 5.5 en medium.

Notre analyse des benchmarks contient toutes les lignes de comparaison.

Comment Haiku 5.5 se compare en termes de prix

Modèle	Entrée / sortie par MJetons	Lecture cache	Écriture cache 5 min	Règle des invites longues
Claude Haiku 5.5	Jusqu’à 100K : 0,10 $ / 0,50 $	0,01 $	0,125 $	Plus de 100K : 0,50 $ / 2,50 $
GPT-6 Luna	0,10 $ / 0,50 $	0,01 $	0,125 $	Entrée de plus de 272K : 2× entrée et cache, 1,5× sortie (0,20 $ / 0,75 $)
Claude Haiku 4.5	1 $ / 5 $	0,10 $	1,25 $	Tarif unique, contexte 200K
Claude Sonnet 5.5	2 $ / 10 $	0,10 $	2,50 $	Tarif unique sur 1M

GPT-6 Luna correspond à Haiku 5.5 jusqu’à 100 000 jetons, mais son seuil de majoration est différent. Selon la page du modèle d’OpenAI, la majoration Luna commence au-delà de 272 000 jetons et s’applique à la requête entière.

Pour l’exemple à 150 000 jetons d’entrée et 2 000 jetons de sortie :

Luna = (150 000 × 0,10 + 2 000 × 0,50) / 1 000 000
     = 0,016 $

Haiku 5.5 = 0,08 $

Les tokeniseurs diffèrent également : un commentateur de Hacker News a estimé que 100 000 jetons Claude équivalent à environ 60 000 à 65 000 jetons GPT. Sur le graphique OSWorld d’Anthropic, Haiku 5.5 en medium atteint 53,3 % pour 0,1257 $, contre 48,9 % pour Luna en max à 0,205 $.

Consultez aussi Claude Haiku 5.5 vs GPT-6 Luna.

Sonnet 5.5 a réduit ses lectures de cache de 0,20 $ à 0,10 $ le même jour, soit environ 20 % moins cher sur la plupart des tâches agentiques selon Anthropic. Notre guide tarifaire de Sonnet 5.5 est antérieur à cette réduction.

Haiku 4.5 n’est pas obsolète. Consultez Haiku 5.5 vs Haiku 4.5 pour identifier les changements à corriger en priorité.

Crédits API et forfaits consommateurs

Crédits API Max et Team

Max 5× : 100 $ par mois en crédits Claude Platform.
Max 20× : 200 $ par mois.
Team : 20 $ par siège Standard et 100 $ par siège Premium.
Les crédits sont cumulés et plafonnés à 500 $.
Les plans Gratuit, Pro et Enterprise ne sont pas éligibles.

Selon la documentation des crédits API, ces crédits couvrent l’API Claude, mais pas Claude Code ni les services cloud. Ils ne sont pas reportables.

À 0,10 $ par MJetons d’entrée, 100 $ correspondent à 1 milliard de jetons d’entrée, soit environ 220 000 requêtes de l’exemple à 0,000455 $.

Forfaits consommateurs

D’après claude.com/pricing, les utilisateurs des forfaits Gratuit, Pro, Max, Team et Enterprise peuvent sélectionner Haiku 5.5 dans Claude.ai, sur le web, iOS et Android.

Pro coûte 17 $/mois avec facturation annuelle, ou 20 $/mois.
Max commence à 100 $/mois.
Le forfait Gratuit n’inclut pas Claude Code.
Un forfait de chat ne permet pas d’exécuter un script ou un travail d’intégration continue.

Pour les options sans coût, consultez comment utiliser Claude Haiku 5.5 gratuitement.

Clouds

Bedrock, Google Cloud et Foundry facturent Haiku 5.5 selon leurs propres pages tarifaires.

Suivre le coût par requête dans Apidog

Chaque réponse de l’API Messages renvoie un objet usage. Vous pouvez l’utiliser pour calculer le coût de chaque appel dans Apidog.

1. Stockez la clé API

Ajoutez votre clé comme variable d’environnement :

ANTHROPIC_API_KEY=...

2. Créez une requête par niveau d’effort

Conservez la même invite et testez au minimum low, medium et high.

curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-haiku-5-5",
    "max_tokens": 4000,
    "thinking": {"type": "adaptive"},
    "output_config": {"effort": "medium"},
    "messages": [
      {
        "role": "user",
        "content": "Classify this support ticket: ..."
      }
    ]
  }'

3. Ajoutez un post-processeur de coût

Ce script traite input_tokens comme la longueur de l’invite. Il convient aux appels sans mise en cache.

const body = pm.response.json();
const u = body.usage;

const long = u.input_tokens > 100000;
const rateIn = long ? 0.50 : 0.10;
const rateOut = long ? 2.50 : 0.50;

const cost =
  (u.input_tokens * rateIn + u.output_tokens * rateOut) / 1e6;

pm.environment.set("haiku_call_usd", cost.toFixed(6));

pm.test("not a refusal", () => {
  pm.expect(body.stop_reason).to.not.eql("refusal");
});

4. Comparez les résultats

Exécutez chaque requête, puis comparez côte à côte :

input_tokens
output_tokens
le niveau d’effort
haiku_call_usd
le résultat fonctionnel attendu

La vérification des refus est importante : les classificateurs de sécurité de Haiku 5.5 n’ont pas de repli côté serveur. Pour le flux API complet, consultez comment utiliser l’API Claude Haiku 5.5.

FAQ

Combien coûte Claude Haiku 5.5 par million de jetons ?

0,10 $ en entrée et 0,50 $ en sortie jusqu’à 100 000 jetons ; 0,50 $ et 2,50 $ au-delà.

Haiku 5.5 est-il moins cher que Haiku 4.5 ?

Oui. Il coûte 90 % moins cher par jeton jusqu’à 100 000 jetons, 50 % moins cher au-delà et environ 75 % moins cher en moyenne selon Anthropic.

Haiku 5.5 est-il au même prix que GPT-6 Luna ?

Jusqu’à 100 000 jetons, oui. Au-delà, Haiku 5.5 passe à un tarif 5× plus élevé, tandis que Luna reste au tarif de base jusqu’à 272 000 jetons. Consultez aussi cet aperçu de GPT-6 Luna.

Les crédits du forfait Max fonctionnent-ils dans Claude Code ?

Non. Ils couvrent l’API Claude Platform, pas Claude Code. Consultez Claude Haiku 5.5 dans Claude Code pour l’accès via les forfaits.

Étape suivante : estimez le coût de votre charge de travail

Identifiez vos trois types de requêtes les plus fréquents.
Mesurez combien dépassent 100 000 jetons.
Exécutez chaque type avec low et medium.
Récupérez les valeurs usage.
Appliquez les tarifs du tableau pour calculer le coût par appel et le coût mensuel.

Téléchargez Apidog pour centraliser vos requêtes, vos variables d’environnement et votre script de calcul dans un seul projet.

Comment utiliser Claude Haiku 5.5 dans Claude Code (et comme modèle de sous-agent)

Antoine Laurent — Thu, 08 Oct 2026 04:17:56 +0000

Pour utiliser Claude Haiku 5.5 dans Claude Code, mettez à jour vers la version v2.1.293 ou ultérieure avec claude update, puis démarrez une session avec claude --model claude-haiku-5-5 ou exécutez /model claude-haiku-5-5 dans une session active. Pour la plupart des workflows, utilisez-le comme sous-agent : définissez model: haiku dans un fichier de sous-agent et déléguez-lui les recherches, les exécutions de tests et les résumés depuis Sonnet 5.5 ou Opus 5.5. Avec une clé API, le tarif est de 0,10 $/0,50 $ par million de jetons d'entrée/sortie pour les prompts jusqu'à 100K jetons, puis de 0,50 $/2,50 $ au-delà.

Essayez Apidog dès aujourd’hui

Ce guide couvre la configuration, le piège de l'alias haiku, les niveaux d'effort, les fichiers de sous-agent, le palier de prix à 100K jetons et les cas où Sonnet ou Opus doivent rester le modèle principal. Pour comprendre le modèle, lisez ce qu'est Claude Haiku 5.5. Si votre code appelle des API, Apidog contient les scénarios de test qu'un sous-agent Haiku peut exécuter.

Claude Haiku 5.5 dans Claude Code en un coup d'œil

Paramètre	Haiku 5.5
Version minimale	v2.1.293 (`claude update`)
ID du modèle	`claude-haiku-5-5`
Alias `haiku`	Haiku 5.5 sur l'API Anthropic uniquement
Contexte	1M natif sur chaque plan, sans suffixe `[1m]`
Auto-compaction	Environ 967K jetons par défaut
Effort par défaut	`medium` (niveaux de `low` à `max`)
Réflexion (Thinking)	Toujours activée ; ne peut pas être désactivée
Prix API	0,10 $/0,50 $ jusqu'à 100K jetons ; 0,50 $/2,50 $ au-delà
Plans	Pro, Max, Team, Enterprise ou clé API ; pas Gratuit

Étape 1 : mettre à jour Claude Code

Haiku 5.5 nécessite Claude Code v2.1.293 ou une version ultérieure. L'entrée du journal des modifications indique qu'il est désormais le modèle Haiku par défaut sur l'API Anthropic.

claude update

Vérifiez ensuite votre version et démarrez une session :

claude --version
claude --model claude-haiku-5-5

Claude Code n'est pas disponible avec le plan gratuit. Les utilisateurs gratuits peuvent sélectionner Haiku 5.5 dans les applications Claude.ai, mais Claude Code nécessite un plan Pro, Max, Team, Enterprise ou une clé API Anthropic. Selon claude.com/pricing, le plan Pro coûte 17 $ par mois facturé annuellement ou 20 $ par mois, tandis que Max commence à 100 $.

Étape 2 : sélectionner Haiku 5.5 comme modèle principal

Pour lancer directement une session avec Haiku 5.5 :

claude --model claude-haiku-5-5

Dans une session existante, utilisez :

/model claude-haiku-5-5

Si votre paramètre model enregistré vaut haiku, une session précédemment enregistrée sur Haiku 4.5 reprendra sur Haiku 5.5 uniquement via l'API Anthropic.

L'alias `haiku` ne signifie Haiku 5.5 que sur l'API Anthropic

Fournisseur	`haiku` correspond à
API Anthropic	Haiku 5.5
Plateforme Claude sur AWS	Haiku 4.5
Amazon Bedrock, Agent Platform de Google Cloud	Haiku 4.5
Microsoft Foundry	Haiku 4.5

Sur les fournisseurs cloud, /model haiku et model: haiku dans un fichier de sous-agent sélectionnent Haiku 4.5.

Épinglez plutôt l'identifiant complet adapté à votre fournisseur :

Google Cloud et plateforme Claude sur AWS : claude-haiku-5-5
Microsoft Foundry : le nom de votre déploiement
Amazon Bedrock : un ID de profil d'inférence tel que us.anthropic.claude-haiku-5-5

Vous pouvez aussi rediriger l'alias avec ANTHROPIC_DEFAULT_HAIKU_MODEL, présenté à l'étape 5.

Étape 3 : choisir un niveau d'effort

Haiku 5.5 est le premier modèle Haiku avec contrôle de l'effort :

low
medium
high
xhigh
max

Claude Code démarre avec medium par défaut. Pour augmenter l'effort dès le démarrage :

claude --model claude-haiku-5-5 --effort high

Dans une session active :

/effort low

Choisissez le niveau selon la tâche :

low : appels d'outils courts, recherches simples, gros volumes.
medium : travail quotidien et automatisations standard.
high : tâches d'agent plus longues ou diagnostics plus complexes.
xhigh et max : uniquement si vos évaluations montrent un gain mesurable.

La réflexion (Thinking) reste activée dans Claude Code. Les paramètres suivants n'ont aucun effet sur Haiku 5.5 dans Claude Code :

alwaysThinkingEnabled: false
MAX_THINKING_TOKENS=0

Pour réduire les jetons de réflexion, baissez l'effort. L'API Messages brute peut désactiver la réflexion avec un effort high ou inférieur.

Étape 4 : exécuter Haiku 5.5 en tant que sous-agent

Anthropic indique que Haiku 5.5 fonctionne bien avec Opus 5.5 et Sonnet 5.5 comme sous-agent pour les tâches de codage.

Les sous-agents sont des fichiers Markdown avec métadonnées YAML placés dans :

.claude/agents/     # pour le projet courant
~/.claude/agents/   # pour tous vos projets

Seuls name et description sont requis. La documentation des sous-agents accepte sonnet, opus, haiku, fable, un ID complet ou inherit dans le champ model. Notre guide des sous-agents détaille les scopes et les outils.

Remplacer Explore par un explorateur économique

Le sous-agent Explore intégré s'exécute sur le modèle de la conversation principale, pas nécessairement sur Haiku. Dans une session Opus 5.5, chaque recherche Explore peut donc utiliser Opus.

Créez un sous-agent utilisateur ou projet nommé Explore pour le remplacer et conserver un modèle dédié :

---
name: Explore
description: Recherche rapide en lecture seule dans la base de code. Permet de trouver des fichiers, des symboles et des sites d'appel sans rien modifier.
tools: Read, Grep, Glob
model: haiku
effort: low
---

Vous recherchez dans la base de code et rapportez ce que vous trouvez. Retournez les chemins de fichiers avec les numéros de ligne et un court résumé de chaque correspondance. Ne modifiez jamais les fichiers.

Enregistrez ce fichier sous :

.claude/agents/Explore.md

Pendant son exécution, lancez /tasks pour confirmer le modèle utilisé. Sur un fournisseur cloud, remplacez haiku par l'ID complet de Haiku 5.5.

Forcer chaque sous-agent à utiliser Haiku

Pour exécuter tous les sous-agents sur Haiku, y compris Explore, ajoutez ces variables au bloc env de votre fichier de paramètres :

{
  "env": {
    "CLAUDE_CODE_SUBAGENT_MODEL": "haiku",
    "CLAUDE_CODE_SUBAGENT_MODEL_FORCE": "1"
  }
}

CLAUDE_CODE_SUBAGENT_MODEL seul est une valeur par défaut : un champ model défini dans un sous-agent garde la priorité, et Explore ne change pas.

Étape 5 : diriger les tâches de fond vers Haiku 5.5

ANTHROPIC_DEFAULT_HAIKU_MODEL définit le modèle à utiliser pour haiku et les fonctionnalités d'arrière-plan, telles que la synthèse des sessions passées avec claude --resume.

L'ancienne variable ANTHROPIC_SMALL_FAST_MODEL est obsolète selon la référence des variables d'environnement. Remplacez-la si elle existe encore dans votre profil shell.

Sur l'API Anthropic, vous n'avez rien à définir. Sur Google Cloud, les tâches de fond utilisent Sonnet par défaut ; sur Foundry, le modèle principal ; sur Bedrock, Sonnet ou le modèle principal.

Après activation de Haiku 5.5 dans votre compte, épinglez-le explicitement :

# Plateforme d'agents de Google Cloud
export ANTHROPIC_DEFAULT_HAIKU_MODEL=claude-haiku-5-5

# Amazon Bedrock (ID de profil d'inférence)
export ANTHROPIC_DEFAULT_HAIKU_MODEL=us.anthropic.claude-haiku-5-5

Le palier de prix de 100K dans les sessions longues

Le prix de Haiku 5.5 dépend de la longueur du prompt. Claude Code renvoie la conversation comme prompt à chaque tour.

Quand le contexte dépasse 100K jetons, chaque requête passe de :

0,10 $ / 0,50 $

à :

0,50 $ / 2,50 $

C'est cinq fois le tarif des prompts courts. La documentation ne précise pas si les jetons mis en cache comptent pour ce seuil : prévoyez votre budget comme s'ils étaient inclus.

L'auto-compaction ne suffit pas à éviter ce palier : Haiku 5.5 se compacte autour de 967K jetons par défaut. Adoptez plutôt ces deux pratiques :

Compacter plus tôt. Utilisez /autocompact 100k pour rapprocher la compaction de la limite minimale acceptée par Claude Code.
Déplacer le travail volumineux dans des sous-agents. Chaque sous-agent dispose de son propre contexte : les journaux de tests et résultats de recherche ne gonflent pas la conversation principale.

Même après 100K jetons, le tarif de 0,50 $/2,50 $ reste un quart des 2 $/10 $ de Sonnet 5.5. Sur un plan payant, les sessions consomment plutôt vos limites d'utilisation, et Anthropic n'a pas publié le mode de comptabilisation de Haiku 5.5 dans ces limites. Consultez notre répartition des prix de Haiku 5.5 pour l'arithmétique détaillée.

Pour les abonnés Max et Team, les nouveaux crédits API mensuels — 100 $ sur Max 5x, 200 $ sur Max 20x et jusqu'à 500 $ mutualisés sur Team — ne couvrent pas Claude Code interactif, selon la documentation des crédits API d'Anthropic.

Quand garder Sonnet 5.5 ou Opus 5.5 comme modèle principal

Anthropic indique que Sonnet 5.5 et Opus 5.5 restent de meilleurs choix pour les tâches complexes de codage agentique.

Sur Terminal-Bench 4.0, exécuté par Anthropic dans Claude Code avec effort maximal, Haiku 5.5 a obtenu 39,2 %, contre 70,6 % pour Sonnet 5.5.

Effort	Haiku 5.5	Sonnet 5.5
`medium`	20,3 % à 0,68 $	28,8 % à 0,68 $
`high`	24,8 % à 1,04 $	43 % à 1,46 $
`max`	39,2 % à 2,64 $	70,6 % à 10,44 $

À effort medium, les deux modèles coûtent environ le même prix par tentative, mais Sonnet obtient un meilleur score. Le faible prix par jeton de Haiku ne se traduit donc pas automatiquement par un meilleur choix pour les longues sessions de codage difficiles.

L'utilisation d'ordinateur donne un résultat différent. Sur OSWorld 2.1, Haiku 5.5 en medium a atteint 53,3 % à 0,13 $ par tentative, tandis que Sonnet 5.5 en low a atteint 57,9 % à 0,68 $.

Consultez notre analyse des benchmarks de Haiku 5.5 pour les résultats complets, ainsi que le guide Claude Code de Sonnet 5.5 pour configurer le modèle principal.

Une répartition pratique :

Sonnet 5.5 ou Opus 5.5 : modèle principal.
Haiku 5.5 : Explore, exécution de tests, lecture de journaux et récupération de documentation.

Exemple : un sous-agent Haiku qui exécute vos tests Apidog

Les exécutions de tests sont verbeuses et répétitives : c'est un bon cas d'usage pour Haiku. Le CLI Apidog exécute vos scénarios de test enregistrés depuis le terminal. Un sous-agent peut donc lancer ces tests et renvoyer un rapport court sans polluer le contexte du modèle principal.

---
name: api-test-runner
description: Exécute les scénarios de test Apidog du projet avec le CLI Apidog après la modification d'un point de terminaison API, puis rapporte les nombres de succès et d'échecs avec les requêtes en échec.
tools: Bash, Read
model: haiku
effort: low
---

Exécutez la commande de test CLI Apidog documentée dans le README de ce dépôt pour le
scénario qui couvre le point de terminaison modifié. Rapporter les nombres de succès et d'échecs.
Pour chaque échec, donnez le nom de la requête, le résultat attendu et le résultat réel.
Ne modifiez pas le code. Ne réessayez pas une exécution échouée plus d'une fois.

Ajoutez ce fichier dans :

.claude/agents/api-test-runner.md

La configuration du CLI, y compris l'authentification et la commande d'exécution, est disponible dans Apidog CLI dans Claude Code. Téléchargez Apidog pour créer les scénarios que le sous-agent exécutera.

Migrer une application de Haiku 4.5

Si votre application utilise Haiku 4.5 via l'API, demandez à Claude Code de démarrer la migration :

/claude-api migrate this project to claude-haiku-5-5

Attendez-vous à des changements majeurs. Les éléments suivants renvoient une erreur HTTP 400 avec Haiku 5.5 :

réflexion manuelle avec budget_tokens ;
valeur non par défaut pour temperature ;
valeur non par défaut pour top_p ;
tout usage de top_k ;
préremplissage de l'assistant.

Le guide Haiku 5.5 vs Haiku 4.5 liste toutes les corrections à appliquer.

Après la migration :

Enregistrez l'ancienne et la nouvelle requête comme paire dans Apidog.
Stockez ANTHROPIC_API_KEY dans une variable d'environnement.
Ajoutez des assertions sur stop_reason et usage.
Faites échouer le test si un nouveau stop_reason: refusal apparaît ou si l'usage de jetons augmente brutalement.

Ainsi, une régression atteint votre pipeline de test plutôt que la production.

FAQ

Haiku 5.5 est-il le modèle par défaut dans Claude Code ?

Non. C'est le modèle Haiku par défaut sur l'API Anthropic, ce qui signifie que l'alias haiku pointe vers lui. Sélectionnez-le comme modèle principal avec --model ou /model.

Puis-je utiliser Haiku 5.5 dans Claude Code avec le plan gratuit ?

Non. Claude Code nécessite un plan payant ou une clé API. Les utilisateurs gratuits peuvent sélectionner Haiku 5.5 dans les applications Claude.ai. Consultez aussi comment utiliser Claude Haiku 5.5 gratuitement.

Pourquoi model: haiku me donne-t-il Haiku 4.5 ?

Vous utilisez Bedrock, Google Cloud, Foundry ou la plateforme Claude sur AWS, ou votre version de Claude Code est antérieure à v2.1.293. Épinglez l'ID complet ou définissez ANTHROPIC_DEFAULT_HAIKU_MODEL.

Puis-je désactiver la réflexion (thinking) pour économiser des jetons ?

Pas dans Claude Code. Réduisez plutôt l'effort : low est le paramètre le plus économique.

Votre prochaine étape

Exécutez :

claude update

Ajoutez ensuite le remplacement Haiku de Explore et conservez votre modèle principal actuel pendant une semaine. Si votre projet possède des API, ajoutez ensuite le sous-agent d'exécution de tests.

Pour appeler le modèle depuis votre propre code, commencez par le guide API de Haiku 5.5. Apidog est gratuit pour commencer et fournit à ce sous-agent de vrais scénarios de test à exécuter.

Qu'est-ce que Claude Haiku 5.5

Antoine Laurent — Thu, 08 Oct 2026 04:15:02 +0000

Claude Haiku 5.5 est le plus petit et le plus rapide des modèles Anthropic actuels. Lancé le 7 octobre 2026, il utilise l’ID d’API claude-haiku-5-5. Son prix est de 0,10 $ par million de jetons d’entrée et 0,50 $ par million de jetons de sortie pour les invites de moins de 100 000 jetons, puis de 0,50 $ / 2,50 $ au-delà. Dans son article de lancement, Anthropic indique qu’il est « environ 75 % moins cher à exécuter » que Haiku 4.5 en moyenne et le présente comme son modèle le plus rapide à ce jour. C’est également le premier Haiku à proposer un paramètre d’effort et une fenêtre contextuelle de 1 million de jetons.

Essayez Apidog dès aujourd’hui

Ce guide couvre les spécifications, la tarification à deux niveaux, la migration depuis Haiku 4.5, les benchmarks et le déploiement. Pour tester l’API pendant votre lecture, Apidog peut envoyer une requête Messages, stocker votre clé dans une variable d’environnement et afficher la réponse avec son utilisation de jetons.

Spécifications de Claude Haiku 5.5 en un coup d’œil

Spécification	Claude Haiku 5.5
Date de sortie	7 octobre 2026
ID du modèle — API Claude, Google Cloud, Microsoft Foundry, Plateforme Claude sur AWS	`claude-haiku-5-5` — ID fixe, sans suffixe de date
ID du modèle — Amazon Bedrock	`anthropic.claude-haiku-5-5`
Fenêtre contextuelle	1 million de jetons — Haiku 4.5 : 200 000
Sortie maximale	128 000 — Haiku 4.5 : 64 000 ; 300 000 avec l’API Batch et l’en-tête bêta `output-300k-2026-03-24`
Réflexion	Adaptative uniquement
Niveaux d’effort	`low`, `medium` (par défaut), `high`, `xhigh`, `max`
Date limite de connaissance	Juin 2026
Prix par MJetons — invites jusqu’à 100 000 jetons	0,10 $ en entrée, 0,50 $ en sortie
Prix par MJetons — invites de plus de 100 000 jetons	0,50 $ en entrée, 2,50 $ en sortie
Retrait	Pas avant le 7 octobre 2027

Place de Haiku 5.5 dans la gamme Claude

Modèle	Entrée / sortie par MJetons	Effort par défaut	Latence
Claude Fable 5.1	10 $ / 50 $	élevé	Plus lent
Claude Opus 5.5	4 $ / 20 $	moyen	Modérée
Claude Sonnet 5.5	2 $ / 10 $	élevé	Rapide
Claude Haiku 5.5	0,10 $ / 0,50 $ pour les invites jusqu’à 100 000 jetons	moyen	Le plus rapide

Les quatre modèles partagent une fenêtre contextuelle de 1 million de jetons, une sortie maximale de 128 000 jetons et une date limite de connaissance en juin 2026.

Anthropic positionne Haiku 5.5 pour les charges à fort volume et sensibles à la latence :

classification ;
extraction structurée ;
routage ;
résumés ;
support en direct ;
utilisation du navigateur ;
sous-agents pilotés par Opus 5.5 ou Sonnet 5.5.

La mention « le plus rapide » doit être nuancée : elle concerne la vitesse standard de chaque modèle. Haiku 5.5 peut être plus lent qu’Opus exécuté en mode Rapide. Anthropic ne publie pas de mesure en jetons par seconde.

Tarification de Claude Haiku 5.5

Le tarif dépend de la taille de l’invite. Dès qu’une invite dépasse 100 000 jetons, le tarif supérieur s’applique.

Source : Tarification de l’API Claude.

Le chiffre « environ 75 % moins cher » est une moyenne :

90 % moins cher que Haiku 4.5 pour les invites jusqu’à 100 000 jetons ;
50 % moins cher au-delà de ce seuil ;
90 % des requêtes Haiku 4.5 étaient sous ce seuil.

Ce calcul tient déjà compte du nouveau tokenizer, qui génère environ 30 % de jetons supplémentaires pour le même texte.

Points à intégrer dans votre estimation de coût :

l’inférence US uniquement, via inference_geo, coûte 1,1 fois le tarif standard pour chaque catégorie de jetons ;
l’invite minimale pouvant être mise en cache descend à 512 jetons, contre 4 096 pour Haiku 4.5 ;
sous les 100 000 jetons, le prix catalogue est identique à GPT-6 Luna : 0,10 $ en entrée, 0,50 $ en sortie, 0,01 $ en lecture de cache et 0,125 $ en écriture de cache ;
Luna ne facture son supplément qu’au-delà de 272 000 jetons d’entrée.

Consultez la comparaison Haiku 5.5 vs GPT-6 Luna et le guide de tarification Haiku 5.5 pour des exemples de coûts calculés.

Migrer depuis Haiku 4.5

La fenêtre contextuelle est multipliée par cinq, la sortie maximale double et Haiku dispose désormais d’un contrôle d’effort. Cependant, le guide de migration indique que certains appels conçus pour Haiku 4.5 échouent avec une erreur 400.

Corriger les cinq incompatibilités bloquantes

Remplacez les budgets de réflexion manuels

Ceci échoue :

   {
     "thinking": {
       "type": "enabled",
       "budget_tokens": 4096
     }
   }

Utilisez plutôt la réflexion adaptative avec un niveau d’effort :

   {
     "thinking": {
       "type": "adaptive"
     },
     "output_config": {
       "effort": "medium"
     }
   }

Supprimez les paramètres d’échantillonnage

Retirez temperature, top_p et top_k.

Les valeurs non par défaut de temperature ou top_p échouent, de même que tout top_k ou l’utilisation simultanée de temperature et top_p.

Supprimez le préremplissage de l’assistant

Haiku 5.5 rejette les messages d’assistant préremplis, même lorsque la réflexion est désactivée.

Mettez à jour l’outil d’utilisation d’ordinateur

Sur l’API Claude et Google Cloud, utilisez :

   computer_toolset_20260801

L’ancien outil suivant échoue :

   computer_20250124

Conservez un historique en ajout uniquement

Après un bloc de réflexion renvoyé, ne modifiez pas les champs system, tools ou les messages précédents. Ajoutez uniquement de nouveaux messages à la conversation.

Changements qui ne produisent pas forcément d’erreur

Affichage de la réflexion : les blocs de réflexion sont vides par défaut et ne contiennent qu’une signature. Ajoutez "display": "summarized" pour les lire.
Comptage des jetons : le même texte peut produire environ 30 % de jetons en plus. max_tokens inclut également la réflexion.
Forçage d’outil : tool_choice avec any ou un outil nommé fonctionne, mais la réponse ne contient pas de bloc de réflexion.
Refus : les classificateurs de sécurité peuvent répondre avec stop_reason: "refusal". Aucun repli côté serveur n’est appliqué.
Niveau de priorité : il n’est pas pris en charge par Haiku 5.5.

La réflexion peut être désactivée jusqu’au niveau high. Avec xhigh ou max, la désactivation renvoie une erreur 400.

Haiku 4.5 reste actif. Pour des requêtes JSON avant/après, consultez le guide Haiku 5.5 vs Haiku 4.5.

Benchmarks de Claude Haiku 5.5

Les scores de Haiku 5.5 sont mesurés avec l’effort maximal, généralement sur une moyenne de cinq essais. Artificial Analysis a exécuté GDPval-AA et AA-Briefcase, Cognition a exécuté FrontierCode, et Anthropic a évalué Chartography avec sa propre implémentation.

Trois éléments sont particulièrement importants lors de la lecture des résultats :

FrontierCode compare Haiku au niveau max avec Sonnet 5.5 au niveau xhigh. Au niveau max, Sonnet a obtenu 46,2 %, contre 46,4 % pour Haiku.
Anthropic a exécuté le score OSWorld de Luna via l’API OpenAI.
Le score Terminal-Bench de Luna provient du classement public Codex CLI.

Avec l’effort par défaut medium, Haiku 5.5 a obtenu :

1277 sur GDPval-AA ;
1372 sur AA-Briefcase.

Anthropic précise que Sonnet 5.5 et Opus 5.5 restent de meilleurs choix pour les tâches complexes de codage agentique. Au 8 octobre 2026, aucun classement indépendant ne listait Haiku 5.5. Cursor rapporte toutefois 48,4 % sur son propre CursorBench avec l’effort maximal.

L’analyse approfondie des benchmarks détaille les scores et coûts par niveau d’effort.

Où utiliser Claude Haiku 5.5

Surface	Accès	Remarques
API Claude	`claude-haiku-5-5`	Paiement par jeton
Amazon Bedrock	`anthropic.claude-haiku-5-5`	Facturé via AWS Marketplace
Google Cloud, Microsoft Foundry, Plateforme Claude sur AWS	`claude-haiku-5-5`	Même ID que l’API Claude
Claude.ai — web, iOS, Android	Sélecteur de modèle	Les utilisateurs Free, Pro, Max, Team et Enterprise peuvent le sélectionner
Claude Code	`/model claude-haiku-5-5`	Version 2.1.293 ou ultérieure ; forfaits payants
Vercel AI Gateway	`anthropic/claude-haiku-5.5`	À partir de 0,10 $ / 0,50 $
Cursor	`claude-haiku-5-5`	Pool Autres Modèles

Au 8 octobre 2026, Haiku 5.5 n’était pas disponible sur OpenRouter et n’était pas annoncé pour GitHub Copilot.

L’accès au chat sur le forfait gratuit ne fournit pas de clé API. L’API est facturée à l’usage, au-delà du petit crédit gratuit proposé par Anthropic aux nouveaux utilisateurs pour les tests.

Les forfaits Max et Team incluent désormais des crédits API mensuels :

100 $ sur Max 5x ;
200 $ sur Max 20x ;
jusqu’à 500 $ mutualisés sur Team.

Ces crédits ne couvrent pas Claude Code. Le guide d’accès gratuit détaille les options gratuites et payantes.

Dans Claude Code, l’alias haiku désigne Haiku 5.5 uniquement avec l’API Anthropic. Sur les autres surfaces, il désigne encore Haiku 4.5. Consultez Haiku 5.5 dans Claude Code pour les configurations de sous-agents.

Qui devrait passer à Haiku 5.5 ?

Vous utilisez Haiku 4.5 : migrez après avoir corrigé les cinq incompatibilités. Haiku 5.5 dépasse Haiku 4.5 sur chaque ligne comparable du tableau de lancement, avec un prix catalogue inférieur.
Vous utilisez Sonnet ou Opus pour des tâches simples et répétitives : testez Haiku 5.5 pour la classification, l’extraction, les résumés et les sous-agents. Gardez un modèle plus grand pour le codage agentique complexe.
Vos invites dépassent régulièrement 100 000 jetons : calculez les deux niveaux tarifaires avant de migrer. Au-delà du seuil, le coût d’entrée par jeton est multiplié par cinq.
Vous réalisez des tâches liées à la sécurité : les protections cyber de Haiku 5.5 bloquent toujours les tests d’intrusion.

Dans l’article de lancement, Asana indique une latence de réalisation des tâches réduite de plus de 30 %. Box rapporte un score supérieur de 11 points à Haiku 4.5 avec environ la moitié de la latence. Ce sont des déclarations de clients, et non des tests indépendants.

La fiche système indique aussi que le modèle a refusé davantage que tout autre modèle lors de l’audit automatisé d’Anthropic. Mesurez donc le taux de refus sur vos propres invites avant un déploiement en production.

Envoyez votre première requête Haiku 5.5

Utilisez cette requête curl minimale :

curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-haiku-5-5",
    "max_tokens": 4000,
    "thinking": {"type": "adaptive", "display": "summarized"},
    "output_config": {"effort": "low"},
    "messages": [
      {
        "role": "user",
        "content": "Classify this support ticket as billing, bug, or feature request: The export button returns a 500 error."
      }
    ]
  }'

Pour rendre cet appel robuste :

N’envoyez pas de paramètres d’échantillonnage.
N’utilisez pas de préremplissage de l’assistant.
Parcourez les blocs content selon leur champ type, car la réponse peut commencer par un bloc de réflexion.
Vérifiez stop_reason avant de traiter la réponse comme un succès.

Dans Apidog, importez cette commande curl comme nouvelle requête et stockez la clé dans une variable d’environnement ANTHROPIC_API_KEY.

Ajoutez ensuite des assertions pour vérifier que stop_reason n’est ni refusal ni max_tokens. Dupliquez la requête, passez effort à medium, puis comparez l’objet usage pour mesurer le coût de chaque niveau d’effort.

Le guide de l’API Haiku 5.5 couvre la mise en cache, les traitements par lots et le streaming. Si nécessaire, consultez aussi le guide de la clé API Anthropic.

FAQ

Quand Claude Haiku 5.5 a-t-il été lancé ?

Le 7 octobre 2026, neuf jours après Sonnet 5.5.

Claude Haiku 5.5 est-il gratuit ?

Dans l’application de chat Claude.ai, les utilisateurs gratuits peuvent le sélectionner. L’API est payante, à l’exception de petits crédits de test pour les nouveaux utilisateurs. Consultez tous les accès gratuits.

Quelle est la fenêtre contextuelle de Claude Haiku 5.5 ?

1 million de jetons, avec une sortie maximale de 128 000 jetons sur l’API Messages.

Haiku 4.5 est-il retiré ?

Pas encore. Il est toujours listé comme actif, avec un retrait pas avant le 15 octobre 2026.

Étape suivante

Choisissez une tâche à fort volume que vous exécutez déjà, par exemple le triage de tickets ou le résumé de documents.

Exécutez-la avec claude-haiku-5-5 et effort: "low".
Répétez avec effort: "medium".
Vérifiez la qualité de sortie, le taux de refus et stop_reason.
Comparez usage avec votre modèle actuel.
Convertissez les volumes de jetons en coût mensuel.

Téléchargez Apidog pour centraliser vos requêtes et assertions dans un projet, puis utilisez le guide de tarification pour estimer votre facture mensuelle.

Comment utiliser l'API Nano Banana 2.1

Antoine Laurent — Tue, 06 Oct 2026 17:38:53 +0000

Google a lancé Nano Banana 2.1 le 6 octobre 2026, et il est déjà appelable via l’API Gemini sous le nom de gemini-nano-banana-2.1. Il s’agit d’une mise à jour de Nano Banana 2 (Gemini 3.1 Flash Image) avec une meilleure qualité visuelle, une édition de style masque et une cohérence des personnages renforcée à travers les itérations. Il coûte également deux fois moins cher par image que Nano Banana 2 à chaque résolution qu’ils partagent.

Essayez Apidog dès aujourd’hui

Ce guide vous mènera d’un terminal vide à une image enregistrée, puis couvrira les rapports d’aspect, la sortie 2K et 4K, l’édition, les modifications multi-tours, les images de référence, l’ancrage de recherche et le coût. Chaque requête ci-dessous peut être enregistrée et rejouée dans Apidog afin que vous puissiez comparer 2.1 avec le modèle que vous utilisez aujourd’hui.

Vous voulez d’abord le contexte ? Lisez Qu’est-ce que Nano Banana 2.1 pour savoir ce qui a changé et ce que Google n’a pas encore publié.

Ce dont vous avez besoin

Élément	Valeur
URL de base	`https://generativelanguage.googleapis.com/v1beta`
En-tête d’authentification	`x-goog-api-key: $GEMINI_API_KEY`
ID du modèle	`gemini-nano-banana-2.1`
Point d’accès	`POST /v1beta/interactions`
Résolutions	1K (par défaut), 2K, 4K
Entrées	Texte, images (jusqu’à 14 références), vidéo
SDK Python	`pip install google-genai`
SDK JavaScript	`npm install @google/genai`

Tous les exemples utilisent l’API Interactions, celle-là même que les documents de génération d’images de Google utilisent pour la version 2.1.

Étape 1 : Obtenir une clé API Gemini

Ouvrez Google AI Studio et connectez-vous.
Allez dans Obtenir une clé API et créez une clé dans un projet Google Cloud.
Activez la facturation pour ce projet. La page de tarification de Google indique que le niveau gratuit pour Nano Banana 2.1 est « Non disponible », donc les appels API nécessitent un projet payant.
Exportez la clé :

export GEMINI_API_KEY="votre-clé-ici"

Google relie 2.1 à l’environnement de jeu (playground) d’AI Studio, ce qui est pratique pour tester les invites, mais n’a pas publié combien un compte gratuit peut y générer. Notre guide sur comment utiliser Nano Banana 2.1 gratuitement couvre cette voie, et obtenir une clé API Gemini détaille la configuration de la clé.

Étape 2 : Générer votre première image

cURL

curl -s -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-nano-banana-2.1",
    "input": [
      {"type": "text", "text": "Créez une image d'\''un plat de nano-banane dans un restaurant chic avec un thème Gemini"}
    ]
  }'

La réponse est au format JSON. L’image arrive sous forme de données base64 à l’intérieur d’un bloc de contenu d’image, vous voudrez donc un SDK ou un script pour la décoder.

Python

from google import genai
import base64

client = genai.Client()  # lit GEMINI_API_KEY

interaction = client.interactions.create(
    model="gemini-nano-banana-2.1",
    input="Créez une image d'un plat de nano-banane dans un restaurant chic avec un thème Gemini",
)

with open("generated_image.png", "wb") as f:
    f.write(base64.b64decode(interaction.output_image.data))

interaction.output_image renvoie le dernier bloc d’image généré. Son champ data est en base64 : décodez-le avant d’écrire le fichier.

JavaScript

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

const ai = new GoogleGenAI({});

const interaction = await ai.interactions.create({
  model: "gemini-nano-banana-2.1",
  input: "Créez une image d'un plat de nano-banane dans un restaurant chic avec un thème Gemini",
});

const image = interaction.output_image;
if (image) {
  fs.writeFileSync("nano-banana.png", Buffer.from(image.data, "base64"));
}

Les modèles d’image Gemini 3 réfléchissent avant de dessiner. Le modèle peut produire jusqu’à deux « images de pensée » intermédiaires pendant qu’il planifie la composition. Celles-ci ne vous sont pas facturées, et la réflexion ne peut pas être désactivée dans l’API.

Étape 3 : Définir le rapport d’aspect, la résolution et la sortie uniquement d’image

Utilisez response_format pour contrôler la sortie. Définir "type": "image" renvoie uniquement l’image et supprime le texte conversationnel, ce qui réduit la taille des réponses et simplifie l’analyse.

interaction = client.interactions.create(
    model="gemini-nano-banana-2.1",
    input="Une photo de produit d'un moulin à café noir mat sur un comptoir en marbre",
    response_format={
        "type": "image",
        "mime_type": "image/png",
        "aspect_ratio": "16:9",
        "image_size": "2K",
    },
)

À savoir :

image_size accepte 1K, 2K et 4K. Utilisez un K majuscule ; les valeurs en minuscules comme 2k sont rejetées.
La version 2.1 n’a pas de niveau 512px. Celui-ci appartient à Nano Banana 2.
Les rapports pris en charge incluent 1:1, 2:3, 3:2, 3:4, 4:3, 4:5, 5:4, 9:16, 16:9, 21:9, ainsi que les extrêmes 1:4, 4:1, 1:8 et 8:1. Une image 16:9 en 2K est de 2752x1536 ; en 4K elle est de 5504x3072.
Si vous voulez à la fois du texte et une image, passez une liste : response_format=[{"type": "text"}, {"type": "image"}].

Étape 4 : Modifier une image existante

Envoyez votre image sous forme de bloc image en base64 à côté de l’instruction textuelle :

with open("living_room.png", "rb") as f:
    image_b64 = base64.b64encode(f.read()).decode("utf-8")

interaction = client.interactions.create(
    model="gemini-nano-banana-2.1",
    input=[
        {"type": "text", "text": "En utilisant l'image fournie d'un salon, changez uniquement le canapé bleu pour qu'il soit un canapé chesterfield vintage en cuir marron. Gardez le reste de la pièce, y compris les coussins sur le canapé et l'éclairage, inchangé."},
        {"type": "image", "data": image_b64, "mime_type": "image/png"},
    ],
)

Remplissage (inpainting) de style masque sans fichier masque

Il n’y a pas de téléchargement de masque séparé. Vous définissez le masque avec des mots. Modèle de Google :

À l’aide de l’image fournie, modifiez uniquement le [élément spécifique] pour qu’il devienne [nouvel élément/description]. Gardez tout le reste de l’image exactement tel quel, en préservant le style, l’éclairage et la composition d’origine.

Nommez un élément, décrivez le remplacement concrètement et répétez ce qui doit rester fixe. Des invites vagues comme « rendre le canapé plus beau » invitent le modèle à redessiner toute la pièce.

Étape 5 : Itérer avec l’édition multi-tours

L’édition multi-tours est le moyen recommandé par Google pour affiner une image. Transmettez l’id de l’interaction précédente en tant que previous_interaction_id et envoyez uniquement la modification souhaitée :

interaction_2 = client.interactions.create(
    model="gemini-nano-banana-2.1",
    input="Mettez à jour cette infographie pour qu'elle soit en espagnol. Ne modifiez aucun autre élément de l'image.",
    previous_interaction_id=interaction.id,
    response_format={
        "type": "image",
        "mime_type": "image/png",
        "aspect_ratio": "16:9",
        "image_size": "2K",
    },
)

Via REST, le même champ est placé dans le corps :

{
  "previous_interaction_id": "<PREVIOUS_INTERACTION_ID>"
}

C’est là que la cohérence améliorée des personnages multi-tours de la version 2.1 est importante : un personnage ou un produit doit rester reconnaissable à travers plusieurs séries d’éditions.

Étape 6 : Combiner jusqu’à 14 images de référence

Ajoutez d’autres blocs image à la liste input. Pour la version 2.1, Google documente jusqu’à 10 images d’objets haute fidélité et jusqu’à 4 images de personnages, soit 14 au total :

interaction = client.interactions.create(
    model="gemini-nano-banana-2.1",
    input=[
        {"type": "text", "text": "Une photo de groupe au bureau de ces personnes, elles font des grimaces."},
        {"type": "image", "data": person_1_b64, "mime_type": "image/png"},
        {"type": "image", "data": person_2_b64, "mime_type": "image/png"},
        {"type": "image", "data": person_3_b64, "mime_type": "image/png"},
    ],
    response_format={"type": "image", "aspect_ratio": "5:4", "image_size": "2K"},
)

Les images de référence sont des jetons d’entrée, et l’entrée 2.1 coûte trois fois plus cher que Nano Banana 2. Les flux de travail à forte référence réduisent l’écart de prix, alors mesurez avant de passer à 2.1.

Étape 7 : Ancrer les images avec la recherche Google

Pour les images qui dépendent de faits actuels, comme une carte météorologique ou un événement récent, ajoutez l’outil de recherche :

interaction = client.interactions.create(
    model="gemini-nano-banana-2.1",
    input="Une peinture détaillée d'un papillon Timareta posé sur une fleur",
    tools=[{"type": "google_search", "search_types": ["web_search", "image_search"]}],
)

{"type": "google_search"} seul vous donne la recherche web. L’ajout de image_search permet au modèle d’utiliser des images web comme contexte visuel, ce que seuls 2.1 et Nano Banana 2 supportent.

L’ancrage ne peut pas utiliser d’images réelles de personnes provenant de la recherche. Si vous affichez des résultats ancrés aux utilisateurs, Google vous demande d’afficher les search_suggestions renvoyées dans l’étape google_search_result.

Étape 8 : Le tester dans Apidog

Les scripts sont utiles pour la génération. Pour vérifier qu’une invite, une clé et un modèle se comportent toujours correctement, une requête enregistrée est plus rapide. Dans Apidog :

Créez un environnement et ajoutez une variable GEMINI_API_KEY avec votre clé.
Créez une requête : POST https://generativelanguage.googleapis.com/v1beta/interactions.
Ajoutez l’en-tête x-goog-api-key: {{GEMINI_API_KEY}}.
Collez un corps JSON avec model, input et response_format, puis cliquez sur Envoyer.
Ajoutez un script post-réponse avec deux assertions :

pm.test("le statut est 200", () => {
  pm.response.to.have.status(200);
});

pm.test("la réponse contient un bloc d'image", () => {
  const steps = pm.response.json().steps || [];
  const hasImage = steps.some(s =>
    s.type === "model_output" &&
    (s.content || []).some(c => c.type === "image" && c.data)
  );
  pm.expect(hasImage).to.be.true;
});

Dupliquez la requête et remplacez model par gemini-3.1-flash-image. Envoyez les deux avec la même invite.

Vous disposez maintenant d’une comparaison côte à côte de 2.1 et de Nano Banana 2, avec le statut, le temps et la taille de la réponse affichés pour chaque exécution. Pour une comparaison plus large des fonctionnalités, consultez Nano Banana 2.1 vs Nano Banana 2 vs Pro.

Ce que cela coûte

Niveau payant, selon la page de tarification de Google au 7 octobre 2026 :

Modèle	Entrée / 1M	Image 1K	Image 2K	Image 4K	Lot 1K
Nano Banana 2.1	$1.50	$0.0336	$0.0504	$0.0756	$0.0168
Nano Banana 2	$0.50	$0.067	$0.101	$0.151	$0.034
Nano Banana Pro	$2.00	$0.134	$0.134	$0.24	$0.067

La sortie d’image pour la version 2.1 coûte 30 $ par million de jetons. Une image 1K représente 1 120 jetons, 2K 1 680 et 4K 2 520, ce qui explique les prix par image. La sortie de texte et de réflexion coûte 7,50 $ par million.

L’ancrage de recherche inclut 5 000 requêtes gratuites par mois partagées entre les modèles Gemini 3.x, puis 14 $ par 1 000.

Exemple détaillé : 1 000 images de produits en 2K à partir de courtes invites textuelles, soit environ 100 jetons d’entrée chacune.

Sortie : 1 000 x 0,0504 $ = 50,40 $
Entrée : 100 000 jetons x 1,50 $ / 1M = 0,15 $
Total : environ 50,55 $, plus les jetons de texte de réflexion éventuels

Le même travail sur Nano Banana 2 coûte environ 101 $. Grâce à l’API Batch, le prix 2K de la version 2.1 tombe à 0,0252 $, ce qui réduit le coût de la sortie à 25,20 $ si vous pouvez attendre.

Les travaux par lots échangent un délai d’exécution allant jusqu’à 24 heures contre des limites de débit plus élevées. Plus de détails sur la tarification de Nano Banana 2 se trouvent dans notre analyse des prix de l’API Nano Banana 2.

Erreurs courantes

Il s’agit de comportements génériques de l’API Gemini, et non d’erreurs spécifiques à la version 2.1 documentées :

Erreur	Cause probable	Solution
`400 INVALID_ARGUMENT`	`image_size` en minuscules, rapport non pris en charge, `input` malformé	Utilisez `2K` et non `2k` ; vérifiez la liste des rapports
`403 PERMISSION_DENIED`	Clé incorrecte, ou projet sans facturation	Vérifiez la clé et activez la facturation
`404 NOT_FOUND`	Faute de frappe dans l’ID du modèle	Utilisez `gemini-nano-banana-2.1` exactement
`429 RESOURCE_EXHAUSTED`	Limite de débit atteinte	Réessayez plus tard avec un délai, ou utilisez le traitement par lots
`500` / `503`	Problème de serveur temporaire	Réessayez avec un backoff exponentiel
200 mais pas d’image	Invite bloquée ou réponse uniquement textuelle	Définissez `"type": "image"` et reformulez

FAQ

Existe-t-il un niveau gratuit pour l’API Nano Banana 2.1 ? Non. Google indique que le niveau gratuit de l’API est « Non disponible ». L’environnement de jeu (playground) d’AI Studio est lié à 2.1, mais Google n’a pas publié de limite gratuite pour celui-ci.

La version 2.1 est-elle un remplacement direct de Nano Banana 2 ? En grande partie. Remplacez l’ID du modèle par gemini-nano-banana-2.1. Vous perdez le niveau 512px, et les jetons d’entrée coûtent plus cher, donc les éditions à forte référence nécessitent une vérification des coûts.

Les images générées portent-elles un filigrane ? Oui. Toutes les sorties incluent un filigrane SynthID.

Puis-je générer une image à partir d’une vidéo ? Oui. La version 2.1 accepte un bloc d’entrée video, tel qu’une URL YouTube, en plus de votre invite textuelle.

Le guide de l’API Nano Banana 2 est-il toujours d’actualité ? Les concepts s’appliquent. Consultez notre guide de l’API Nano Banana 2 pour le modèle précédent.

Conclusion

Nano Banana 2.1 promet de meilleures images à la moitié du prix par image de Nano Banana 2, avec la même structure d’API Interactions. Obtenez une clé facturée, générez une image, puis enregistrez la requête dans Apidog avec des assertions de statut et d’image.

Dupliquez-la avec l’ancien ID de modèle, et vous saurez en une après-midi si 2.1 justifie le passage pour vos invites.

Comment utiliser Nano Banana 2.1 gratuitement ?

Antoine Laurent — Tue, 06 Oct 2026 17:35:54 +0000

Google a lancé Nano Banana 2.1 le 6 octobre 2026. Le compte Google AI Studio affirme que le modèle d’image « surpasse nos modèles précédents sur tous les fronts » et invite les utilisateurs à l’essayer dans AI Studio. La première question reste la même : est-ce gratuit ?

Essayez Apidog dès aujourd’hui

La réponse courte : partiellement. L’API Gemini ne propose pas de niveau gratuit pour Nano Banana 2.1. Google AI Studio est gratuit, mais Google ne publie pas le quota 2.1 disponible pour les comptes gratuits. L’application Gemini et Google Flow proposent de la génération d’images gratuite, sans toutefois documenter explicitement la version 2.1.

Si vous appelez le modèle depuis du code, testez d’abord vos requêtes sans multiplier les essais payants. Apidog permet d’importer, enregistrer et valider vos requêtes API avant de les intégrer à votre application.

TL;DR : options vérifiées le 7 octobre 2026

Option	Gratuit ?	Limites	Idéal pour
Espace de travail Google AI Studio	AI Studio est gratuit ; l’accès gratuit à la 2.1 n’est pas confirmé	Le plan gratuit bénéficie d’un « quota modeste », sans chiffre publié	Tester des invites avant de payer
Niveau gratuit de l’API Gemini	Non	« Non disponible »	Rien
Application Gemini	Non confirmé pour la 2.1	Nano Banana 2 est disponible pour tous les utilisateurs	Images occasionnelles
Google Flow	Non confirmé pour la 2.1	Nano Banana 2 Lite est gratuit	Images pour projets vidéo
Essai Google Cloud de 300 $ via Vertex AI	Possiblement, non confirmé	90 jours, compte de facturation requis	Nouveaux comptes Google Cloud
Sites tiers	Aucun vérifié	Inconnu	Non recommandé
API Batch payante	Non, mais économique	0,0168 $ par image 1K, jusqu’à 24 h de délai	Génération en masse

Option 1 : Google AI Studio, l’option gratuite la plus probable

Google AI Studio est l’espace de travail web de Google pour les modèles Gemini. C’est l’outil vers lequel Google a redirigé les utilisateurs au lancement, et la fiche tarifaire de Nano Banana 2.1 contient également un lien « Essayez-le dans Google AI Studio ».

Google indique que « l’utilisation de Google AI Studio est gratuite dans toutes les régions disponibles ». La FAQ de facturation ajoute une condition importante : AI Studio reste gratuit tant que vous n’associez pas une clé API payante pour utiliser des fonctionnalités payantes.

Le point bloquant est le quota. Les comptes gratuits disposent d’un « quota modeste » avec des « limites et un accès de base ». Les abonnements Google AI Pro et Ultra donnent accès à des quotas plus élevés, à des modèles premium et à des limites de débit supérieures dans Google AI Studio.

Google ne précise pas si tous les comptes gratuits peuvent exécuter Nano Banana 2.1 ni combien d’images ils peuvent générer.

Vérifier votre accès

Connectez-vous à ai.studio.
Ouvrez l’espace de travail Google AI Studio.
Sélectionnez Gemini Nano Banana 2.1.
Exécutez une invite de test.
Interprétez le résultat :
- si l’image est générée, votre compte dispose d’un accès gratuit dans la limite du quota ;
- si Google demande une mise à niveau ou une clé API payante, l’accès gratuit n’est pas ouvert pour votre compte.

Consultez également ce guide pour utiliser Google AI Studio gratuitement.

Deux précautions à prendre

Les données du niveau gratuit peuvent être utilisées pour améliorer les produits Google. La page tarifaire indique « Utilisées pour améliorer nos produits : Oui » pour le niveau gratuit et « Non » pour le niveau payant. N’envoyez pas de photos clients, de données sensibles ou de visuels produits non publiés.
L’accès à AI Studio ne donne pas accès à l’API. Les avantages des abonnements IA s’appliquent à l’interface web Google AI Studio. Les appels depuis votre code passent par l’API, qui est payante pour Nano Banana 2.1.

Option 2 : le niveau gratuit de l’API Gemini n’existe pas

La page de tarification indique que le niveau gratuit de gemini-nano-banana-2.1 est « Non disponible » pour l’entrée comme pour la sortie.

En pratique :

Une clé API gratuite ne peut pas générer d’images avec Nano Banana 2.1.
Vous devez activer la facturation pour appeler le modèle.
Pour les nouveaux comptes, Google indique qu’une mise à niveau implique un prépaiement minimal de 5 $ de crédits.

Le guide pour obtenir gratuitement une clé API Gemini reste utile pour les modèles texte, mais il ne couvre pas les images Nano Banana 2.1.

Option 3 : l’application Gemini, non confirmée pour la 2.1

La documentation Google liste Nano Banana 2 pour tous les utilisateurs et Nano Banana Pro pour les abonnements Google AI Plus et supérieurs. Elle ne mentionne pas Nano Banana 2.1.

Nokia Power User a rapporté le 6 octobre que Nano Banana 2.1 « a commencé à apparaître directement dans les applications Gemini », mais Google ne l’a pas confirmé.

Si le modèle exact importe peu et que vous avez seulement besoin d’images, l’application Gemini gratuite avec Nano Banana 2 est une option utilisable aujourd’hui. Consultez le guide gratuit Nano Banana 2.

Option 4 : Google Flow, non confirmé pour la 2.1

Flow est le studio créatif IA de Google. Des utilisateurs ont aperçu Nano Banana 2.1 dans son sélecteur de modèles le 5 octobre, avant que Google ne le retire puis ne le lance officiellement le lendemain.

La page d’aide de Flow présente :

Nano Banana 2 Lite comme modèle par défaut disponible gratuitement ;
Nano Banana 2 comme modèle standard ;
Nano Banana Pro comme modèle par défaut des abonnés AI Ultra.

Au 7 octobre, cette page ne mentionne pas Nano Banana 2.1.

Les informations disponibles sont contradictoires :

Nokia Power User indique que les générations 2.1 dans Flow « consomment des crédits d’abonnement standard ».
OrcaRouter a publié une capture d’écran montrant zéro crédit, mais cela semble refléter le forfait de ce compte, pas une tarification officielle.

Avant de générer, ouvrez le sélecteur de modèles Flow et vérifiez le coût en crédits affiché pour Nano Banana 2.1.

Option 5 : crédits d’essai Google Cloud sur Vertex AI, non confirmé

Nano Banana 2.1 dispose également d’une page de modèle sur la plateforme Gemini Enterprise Agent de Google Cloud, anciennement Vertex AI. Cette plateforme propose des options de paiement à l’usage et de débit provisionné.

Les nouveaux clients Google Cloud peuvent recevoir 300 $ de crédits d’essai, valables pendant 90 jours.

Voici ce qui est confirmé :

La FAQ de facturation indique que, depuis mars 2026, les coûts d’utilisation de l’API Gemini sont exclus du programme d’essai gratuit Google Cloud de 300 $.
La page d’essai gratuit, mise à jour le 5 octobre 2026, précise que le crédit ne peut pas payer les coûts de l’API Gemini dans AI Studio.
Le crédit ne peut pas être utilisé pour les modèles partenaires proposés comme API gérées.

Ces pages n’excluent pas explicitement les modèles Google sur Gemini Enterprise Agent. Le crédit pourrait donc couvrir Nano Banana 2.1 sur cette plateforme, mais Google ne le confirme pas.

Pour le vérifier :

Créez un projet Google Cloud avec facturation activée.
Effectuez quelques appels de test sur la plateforme Enterprise Agent.
Consultez le rapport de facturation Cloud.
Vérifiez si les appels sont déduits des crédits d’essai ou facturés séparément.

Option 6 : sites tiers

Des sites tiers utilisant le nom Nano Banana proposent déjà des pages dédiées à la version 2.1, parfois avec des générations gratuites.

Aucun ne constitue un produit Google vérifié. Il est impossible de confirmer de manière fiable :

qu’ils utilisent réellement le modèle Nano Banana 2.1 de Google ;
leurs limites réelles ;
le traitement appliqué aux images envoyées.

Évitez d’y téléverser des images personnelles, des données clients ou des ressources non publiées.

L’option payante la moins chère : l’API Batch à 0,0168 $ par image

La sortie d’image Nano Banana 2.1 coûte 30 $ par million de jetons en mode Standard. Une image 1K correspond à 1 120 jetons de sortie.

L’API Batch réduit ce coût de moitié, avec un délai d’exécution pouvant atteindre 24 heures.

Résolution	Standard	Batch	Images par 1 $ en Batch	Images par 5 $ en Batch
1K	0,0336 $	0,0168 $	environ 59	environ 297
2K	0,0504 $	0,0252 $	environ 39	environ 198
4K	0,0756 $	0,0378 $	environ 26	environ 132

Avec le prépaiement minimal de 5 $, vous pouvez générer environ 297 images 1K au tarif Batch.

Nano Banana 2 coûte 0,067 $ par image 1K en Standard. À résolution égale, Nano Banana 2.1 est donc deux fois moins cher.

Contrôler les coûts

Surveillez ces trois éléments :

Les jetons d’entrée coûtent plus cher. Ils sont facturés 1,50 $ par million de jetons, soit trois fois le coût de Nano Banana 2. Les modifications utilisant plusieurs images de référence, jusqu’à 14, font augmenter ce coût.
La sortie texte et pensée coûte 7,50 $ par million de jetons. Si votre application n’a besoin que de l’image, utilisez un format de réponse uniquement image pour éviter une sortie textuelle inutile.
Le mode Batch n’est pas adapté au temps réel. Google annonce un délai d’exécution allant jusqu’à 24 heures. Utilisez-le pour générer des catalogues, des jeux d’assets ou des lots de visuels.

Pour comparer les modèles, consultez Nano Banana 2.1 vs Nano Banana 2 vs Pro. Pour l’intégration, lisez le guide de l’API Nano Banana 2.1.

Tester l’API sans gaspiller de crédits

Chaque appel Nano Banana 2.1 réussi est facturé. Google indique que les requêtes échouant avec un code 400 ou 500 ne sont pas facturées pour les jetons, mais qu’elles comptent quand même dans le quota.

Commencez avec une requête minimale connue comme valide :

curl -s -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-nano-banana-2.1",
    "input": [
      {
        "type": "text",
        "text": "Create a picture of a nano banana dish in a fancy restaurant with a Gemini theme"
      }
    ]
  }'

Configurer la requête dans Apidog

Importez la commande cURL dans une nouvelle requête Apidog. L’outil récupère l’URL, les en-têtes et le corps JSON. Enregistrez cette requête comme référence valide.
Créez une variable d’environnement nommée GEMINI_API_KEY. Référencez-la dans l’en-tête x-goog-api-key au lieu de coller la clé dans la requête.
Ajoutez des assertions :
- statut HTTP 200 ;
- présence du bloc image dans la réponse.

Après votre premier appel réussi, inspectez le JSON brut pour sélectionner le chemin exact du champ à valider.

Dupliquez la requête pour chaque variante : génération 1K, 2K, 4K et modification avec images de référence.
Comparez les variantes volontairement afin d’identifier celles qui augmentent réellement les coûts.

Apidog ne rend pas les générations gratuites : chaque envoi reste un appel API facturé. En revanche, il réduit l’incertitude en standardisant les requêtes, les variables et les validations.

FAQ

Nano Banana 2.1 est-il gratuit ?

Pas via l’API Gemini : le niveau gratuit y est indiqué comme « Non disponible ». Google AI Studio est gratuit, mais Google n’a pas confirmé le quota gratuit pour la version 2.1.

Nano Banana 2.1 est-il gratuit dans l’application Gemini ?

Ce n’est pas confirmé. Google documente Nano Banana 2 pour tous les utilisateurs, sans mention de Nano Banana 2.1.

Flow facture-t-il des crédits pour Nano Banana 2.1 ?

Google ne l’a pas confirmé. Vérifiez le coût affiché dans le sélecteur de modèles Flow. Nano Banana 2 Lite y est gratuit.

Puis-je utiliser le crédit Google Cloud de 300 $ ?

Pas pour l’API Gemini ni pour AI Studio. Sur Gemini Enterprise Agent, cela pourrait fonctionner, mais ce n’est pas confirmé pour Nano Banana 2.1.

Quelle est l’option la moins chère pour générer beaucoup d’images ?

L’API Batch : 0,0168 $ par image 1K, soit environ 59 images par dollar.

En résumé

Vous pouvez probablement essayer Nano Banana 2.1 gratuitement dans Google AI Studio, qui reste l’option vers laquelle Google oriente les utilisateurs. Ne construisez toutefois pas un workflow de production sur cette hypothèse : Google n’a publié aucun quota gratuit précis, et ses pages de plans IA classent Nano Banana parmi les modèles premium.

L’application Gemini et Google Flow proposent des modèles d’images gratuits, mais Nano Banana 2.1 n’est pas encore documenté officiellement dans ces produits.

Quand le niveau gratuit ne suffit plus, l’API Batch fournit le meilleur coût pour la génération en volume : environ 59 images 1K par dollar. Configurez la requête une fois dans Apidog, stockez la clé dans une variable d’environnement et utilisez des assertions pour détecter les erreurs avant de lancer des lots payants.

Pour comprendre les évolutions du modèle, consultez ce qu’est Nano Banana 2.1.

Comparaison Nano Banana 2.1 vs Nano Banana 2 vs Nano Banana Pro : Lequel choisir ?

Antoine Laurent — Tue, 06 Oct 2026 17:34:57 +0000

Google propose désormais quatre modèles d'images Nano Banana dans l'API Gemini. Le plus récent, Nano Banana 2.1, a été lancé le 6 octobre 2026 à la moitié du prix par image du modèle qu'il remplace. Cela change le choix par défaut pour la plupart des équipes, mais pas pour toutes les charges de travail.

Essayez Apidog dès aujourd’hui

Ce guide compare Nano Banana 2.1, Nano Banana 2 et Nano Banana Pro, avec Nano Banana 2 Lite comme option économique. Chaque prix et limite ci-dessous provient de la documentation de Google sur la génération d'images et de la page de tarification au 7 octobre 2026.

Verdict rapide

Privilégiez Nano Banana 2.1 (gemini-nano-banana-2.1) pour les nouveaux projets. Google le recommande pour les nouveaux projets, et son coût de sortie est deux fois moins élevé que Nano Banana 2 en 1K, 2K et 4K.
Conservez Nano Banana 2 (gemini-3.1-flash-image) si vous devez générer en 0.5K (512 px). Nano Banana 2.1 ne propose pas cette taille.
Utilisez Nano Banana 2 Lite (gemini-3.1-flash-lite-image) pour des images 1K à grand volume, sans contextualisation (grounding) et avec peu d'images de référence. Son prix par image 1K est identique à celui du 2.1, avec une entrée moins chère.
Choisissez Nano Banana Pro (gemini-3-pro-image) lorsque vous avez besoin de la gamme premium présentée par Google pour les actifs professionnels et que vous pouvez payer environ quatre fois plus par image 1K.

Google n'a publié aucun benchmark pour Nano Banana 2.1. Son annonce indique que le modèle « surpasse nos modèles précédents sur tous les plans », sans chiffres comparatifs. Testez les modèles sur vos propres requêtes avant de conclure qu'un modèle est meilleur pour votre cas d'usage.

Spécifications comparatives

	Nano Banana 2.1	Nano Banana 2	Nano Banana Pro
ID du modèle API	`gemini-nano-banana-2.1`	`gemini-3.1-flash-image`	`gemini-3-pro-image`
Positionnement de Google	Cheval de bataille principal haute efficacité	Cheval de bataille de génération précédente	Choix premium pour les tâches visuelles complexes
Résolutions	1K, 2K, 4K	0.5K, 1K, 2K, 4K	1K, 2K, 4K
Prix d'entrée (par 1M de tokens)	$1.50	$0.50	$2.00
Prix de sortie d'image (par 1M de tokens)	$30	$60	$120
Par image en 0.5K	n/a	$0.045	n/a
Par image en 1K	$0.0336	$0.067	$0.134
Par image en 2K	$0.0504	$0.101	$0.134
Par image en 4K	$0.0756	$0.151	$0.24
Lot par image en 1K	$0.0168	$0.034	$0.067
Contextualisation Google Search	Recherche Web + Recherche d'images	Recherche Web + Recherche d'images	Recherche Web
Images de référence	Jusqu'à 14 : 10 objets, 4 personnages	Jusqu'à 14 : 10 objets, 4 personnages	Jusqu'à 14 : 6 objets, 5 personnages
Entrée vidéo	Oui	Oui	Non
Niveau API gratuit	Non, test dans AI Studio	Non	Non

Points à retenir :

Calcul des tokens : une image 1K correspond à 1 120 tokens de sortie, une 2K à 1 680 et une 4K à 2 520, pour Nano Banana 2.1 et Nano Banana 2. Le nombre de tokens est identique, mais Nano Banana 2.1 coûte deux fois moins cher en sortie.
Batch : Nano Banana 2.1 propose aussi des tarifs batch : $0.0252 en 2K et $0.0378 en 4K.
Réflexion : les modèles d'images Gemini 3 réfléchissent par défaut, sans possibilité de désactivation via l'API. Jusqu'à deux images de pensée intermédiaires peuvent être générées sans facturation. Le texte et la sortie de réflexion coûtent $7.50 par 1M de tokens sur 2.1, contre $3 sur Nano Banana 2.
Contextualisation : 5 000 requêtes de recherche gratuites par mois sont partagées entre les modèles Gemini 3.x. Au-delà, le tarif est de $14 pour 1 000 requêtes.

Coût par 1 000 images

Coût de sortie uniquement, API standard hors batch, niveau payant :

Modèle	0.5K	1K	2K	4K
Nano Banana 2.1	n/a	$33.60	$50.40	$75.60
Nano Banana 2	$45.00	$67.00	$101.00	$151.00
Nano Banana 2 Lite	n/a	$33.60	n/a	n/a
Nano Banana Pro	n/a	$134.00	$134.00	$240.00

Avec l'API Batch, Nano Banana 2.1 descend à :

$16.80 pour 1 000 images en 1K ;
$25.20 pour 1 000 images en 2K ;
$37.80 pour 1 000 images en 4K.

Deux comparaisons sont particulièrement utiles pour budgéter :

Une image 4K sur Nano Banana 2.1 ($0.0756) coûte moins qu'une image 1K sur Pro ($0.134).
Une image 1K sur Nano Banana 2.1 ($0.0336) coûte moins qu'une image 512 px sur Nano Banana 2 ($0.045).

Conservez donc Nano Banana 2 en 0.5K uniquement si votre pipeline exige précisément cette taille.

Quand l'édition gourmande en entrées modifie le calcul

Le coût de sortie ne représente qu'une partie de la facture. Nano Banana 2.1 facture $1.50 par million de tokens d'entrée, contre $0.50 pour Nano Banana 2. Les workflows qui envoient de nombreuses images de référence ont donc une entrée plus coûteuse sur 2.1.

Selon la page du modèle Vertex AI de Google, chaque image d'entrée représente 1 120 tokens.

Exemple : un pipeline de photos produit envoie 14 images de référence, un prompt de 500 tokens, puis reçoit une image 1K.

	Nano Banana 2.1	Nano Banana 2
Tokens d'entrée : `14 × 1 120 + 500`	16 180	16 180
Coût d'entrée	$0.0243	$0.0081
Sortie 1K	$0.0336	$0.0670
Total par requête	$0.0579	$0.0751
Par 1 000 requêtes	$57.90	$75.10

Même avec 14 images de référence, Nano Banana 2.1 reste moins cher. En revanche, l'écart passe d'environ 50 % à environ 23 %.

Identifier le point de bascule

Chaque token d'entrée coûte $0.000001 de plus sur Nano Banana 2.1. L'économie de sortie par image est de :

$0.0334 en 1K ;
$0.0506 en 2K ;
$0.0754 en 4K.

Nano Banana 2.1 devient donc plus coûteux lorsqu'une requête dépasse environ :

33 400 tokens d'entrée en 1K ;
50 600 tokens d'entrée en 2K ;
75 400 tokens d'entrée en 4K.

Quatorze images de référence seules n'atteignent pas ces seuils. Deux situations peuvent toutefois vous en rapprocher :

Sessions d'édition multi-tours longues

Si vous enchaînez les modifications avec previous_interaction_id, surveillez les tokens d'entrée dans les données d'utilisation de chaque réponse. Les tours précédents peuvent agrandir le contexte facturé. Une session de dix tours avec des références complètes peut dépasser le seuil en 1K.
Tokens de pensée et de texte

Nano Banana 2.1 facture ces tokens à $7.50 par million, contre $3 sur Nano Banana 2. La réflexion n'est pas désactivable, donc les prompts qui déclenchent davantage de raisonnement réduisent l'avantage de coût.

Pour des modifications 1K avec un historique long, mesurez les deux modèles sur du trafic réel avant la migration.

Où Nano Banana 2 Lite s'insère

Nano Banana 2 Lite est l'option économique. Google le présente comme « le modèle d'image Gemini le plus rapide et le moins cher » :

$0.25 par 1M de tokens d'entrée ;
$0.0336 par image en 1K, soit le même prix de sortie que Nano Banana 2.1.

Ses limites sont importantes :

sortie uniquement en 1K ;
pas de contextualisation Google Search ;
pas optimisé pour plusieurs images de référence ;
pas optimisé pour l'édition multi-tours.

Utilisez Lite pour du texte-à-image 1K simple et volumique. Passez à Nano Banana 2.1 dès que vous avez besoin de 2K, 4K, de contextualisation ou d'édition itérative.

Google recommande aussi Lite pour migrer depuis Nano Banana original (gemini-2.5-flash-image), désormais un modèle hérité. Consultez notre comparaison Nano Banana 1 vs Nano Banana 2 pour ce saut de version.

Quand Nano Banana Pro a encore du sens

Google décrit Pro comme « le choix premium pour les tâches visuelles les plus complexes ». Le modèle est présenté comme optimisé pour les actifs professionnels, la connaissance du monde, la localisation avancée, la cohérence de marque et le contrôle créatif précis. Son guide de prompting recommande aussi Pro pour les actifs professionnels riches en texte.

Ce positionnement n'est pas un benchmark. En l'absence de comparaison publiée entre Pro et 2.1, validez le choix par vos propres tests :

Choisissez Pro si vos workflows répondent déjà aux exigences de ce modèle ou si vous dépendez de sa limite de cohérence de cinq personnages.
Testez Nano Banana 2.1 d'abord si vous utilisez Pro pour des traitements en volume. En 4K, Nano Banana 2.1 coûte environ un tiers du prix de Pro : $0.0756 contre $0.24. En 1K, son coût est environ quatre fois inférieur.
Notez les limites de Pro : pas de contextualisation par recherche d'images et pas d'entrée vidéo.

Pour le format complet des requêtes Pro, consultez le guide API Nano Banana Pro.

Notes de migration

Passer de Nano Banana 2 à Nano Banana 2.1 consiste principalement à changer la chaîne model. L'endpoint, le response_format et l'outil google_search restent identiques.

curl -s -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-nano-banana-2.1",
    "input": [
      {
        "type": "text",
        "text": "A studio product photo of a ceramic mug on a walnut desk"
      }
    ],
    "response_format": {
      "type": "image",
      "mime_type": "image/png",
      "aspect_ratio": "16:9",
      "image_size": "2K"
    }
  }'

Avant de basculer le trafic de production, vérifiez les points suivants :

Taille d'image : si un appel utilise "image_size": "512px" ou 0.5K, gardez gemini-3.1-flash-image. Nano Banana 2.1 ne prend pas en charge cette taille.
K majuscule : "2K" fonctionne ; "2k" est rejeté par tous les modèles.
Recherche d'images : ajoutez "search_types": ["web_search", "image_search"] dans l'outil google_search, puis affichez les suggestions de recherche retournées comme l'exige Google.
Budgets : à trafic identique, le coût des entrées sera approximativement triplé, tandis que le coût des images sera divisé par deux.
Niveau gratuit : aucun de ces modèles ne dispose d'un niveau gratuit dans l'API Gemini. Consultez comment utiliser Nano Banana 2.1 gratuitement.

Pour une implémentation complète incluant l'édition multi-tours et la contextualisation, consultez le guide API Nano Banana 2.1, ainsi que l'aperçu de Nano Banana 2.1.

Comment faire de l'A/B testing sur les trois modèles dans Apidog

Sans benchmarks publiés, la comparaison utile est celle que vous réalisez sur vos propres prompts et données de référence. Apidog permet d'exécuter ce test sans construire un harnais dédié.

Enregistrez une requête Créez une requête :

   POST https://generativelanguage.googleapis.com/v1beta/interactions

Stockez votre clé comme variable d'environnement et ajoutez :

   x-goog-api-key: {{GEMINI_API_KEY}}

Collez le corps JSON précédent. Pour les images de référence, ajoutez des parties telles que :

   {
     "type": "image",
     "mime_type": "image/jpeg",
     "data": "<BASE64>"
   }

Dupliquez la requête deux fois Ne modifiez que le champ model :

   gemini-nano-banana-2.1
   gemini-3.1-flash-image
   gemini-3-pro-image

Conservez exactement le même prompt, les mêmes références, le même ratio et la même image_size. Le modèle doit être votre seule variable.

Envoyez et comparez

Apidog affiche le statut, la latence et la taille de chaque réponse. Décodez les images base64 et examinez-les côte à côte.
Transformez le test en contrôle de régression

Vérifiez un statut 200 et une image non vide. Regroupez ensuite les requêtes dans un scénario de test et réexécutez-le lorsque Google met à jour un modèle.

Exécutez 10 à 20 requêtes représentatives, pas une seule. Multipliez ensuite le prix par image de chaque modèle par votre volume mensuel. Téléchargez Apidog gratuitement pour suivre ce workflow.

FAQ

Nano Banana 2.1 est-il meilleur que Nano Banana 2 ?

Google affirme que le 2.1 « surpasse nos modèles précédents sur tous les plans », notamment sur la conception visuelle, l'édition basée sur des masques, la cohérence du sujet et le naturel des images. Aucun benchmark n'a été publié : vérifiez sur vos propres requêtes.
Nano Banana 2.1 est-il moins cher que Nano Banana 2 ?

Par image, oui : son prix est divisé par deux en 1K, 2K et 4K. Par token d'entrée, non : $1.50 contre $0.50 par million de tokens. Pour la plupart des charges de travail, l'économie sur la sortie compense ce surcoût.
Dois-je remplacer Nano Banana Pro par Nano Banana 2.1 ?

Testez avant de migrer. Nano Banana 2.1 coûte environ un quart du prix de Pro en 1K, mais Google positionne toujours Pro comme son modèle premium.
Puis-je utiliser Nano Banana 2.1 gratuitement ?

Pas via l'API Gemini. La page de tarification ne liste aucun niveau gratuit pour les modèles Nano Banana, mais vous pouvez tester Nano Banana 2.1 dans Google AI Studio.
Combien d'images de référence puis-je envoyer ?

Jusqu'à 14 sur les trois modèles. Nano Banana 2.1 et Nano Banana 2 maintiennent la cohérence de 10 objets et 4 personnages. Pro gère jusqu'à 6 objets et 5 personnages.

Verdict

Nano Banana 2.1 est le choix par défaut pour les nouveaux workloads d'images Gemini : son coût par image est deux fois inférieur à Nano Banana 2, avec les mêmes limites de contextualisation, d'entrée vidéo et d'images de référence.

Conservez Nano Banana 2 uniquement pour la sortie 512 px ou pour les workflows à historique long que vous avez mesurés. Utilisez Lite pour la génération simple d'images 1K à grande échelle. Gardez Pro lorsque son positionnement premium correspond à une exigence mesurable de votre produit, puis confirmez-le par un test comparatif avant de payer jusqu'à quatre fois plus.

Nano Banana 2.1 est disponible : Moitié prix de Nano Banana 2, le texte fonctionne enfin

Antoine Laurent — Tue, 06 Oct 2026 17:31:36 +0000

Google a lancé Nano Banana 2.1 le 6 octobre 2026, en toute discrétion. Il n’y a eu ni article de lancement détaillé ni tableau comparatif. Le modèle est apparu dans le sélecteur de modèles de Google Flow le 5 octobre, a disparu, puis est revenu le lendemain avec un court message de @GoogleAIStudio indiquant qu’il « surpasse nos modèles précédents sur toute la ligne ».

Essayez Apidog dès aujourd’hui

Le point essentiel pour les équipes qui paient la génération d’images est la tarification : Nano Banana 2.1 coûte deux fois moins cher par image que Nano Banana 2 aux résolutions qu’ils partagent. Google cite aussi le « rendu de texte précis » parmi les améliorations. Voici ce qui change, les coûts, les limites et comment le tester dans votre pipeline.

En bref

Modèle : Gemini Nano Banana 2.1, avec l’ID gemini-nano-banana-2.1. Il met à jour Nano Banana 2 (Gemini 3.1 Flash Image).
Améliorations annoncées : conception visuelle, édition sémantique basée sur des masques, cohérence du sujet, images plus naturelles, rendu de texte, cohérence des personnages entre plusieurs tours et ancrage de recherche.
Prix par image : 0,0336 $ en 1K, 0,0504 $ en 2K et 0,0756 $ en 4K.
Limites à évaluer : jetons d’entrée trois fois plus chers que Nano Banana 2, aucune sortie 512 px, aucun niveau gratuit pour l’API Gemini et aucun benchmark publié pour la version 2.1.
Disponibilité : Google AI Studio, API Gemini via Interactions, Vertex AI et Google Flow.

Qu’est-ce que Nano Banana 2.1 ?

Nano Banana est le nom de Google pour les modèles d’image de la famille Gemini.

Le Nano Banana original (gemini-2.5-flash-image) est désormais hérité.
Nano Banana 2 (gemini-3.1-flash-image) est devenu le modèle rapide par défaut.
Nano Banana 2 Lite vise les charges de travail à bas coût.
Nano Banana Pro (gemini-3-pro-image) cible la production d’actifs professionnels.

Nano Banana 2.1 est une mise à jour directe de Nano Banana 2. La documentation Google sur la génération d’images le décrit comme un modèle conçu pour la génération d’images à haute efficacité et l’édition conversationnelle, avec une qualité visuelle améliorée, une cohérence des personnages sur plusieurs tours, un rendu de texte précis et une génération ancrée sur la recherche.

Caractéristique	Nano Banana 2.1
ID du modèle	`gemini-nano-banana-2.1`
Résolutions de sortie	1K, 2K, 4K
Entrées	Texte, image, vidéo — pas d’audio
Images de référence	Jusqu’à 14
Réflexion	Activée par défaut, non désactivable dans l’API
Images intermédiaires de réflexion	Jusqu’à deux, non facturées
Ancrage de recherche	Recherche Web Google et Recherche d’images Google
Filigrane	SynthID sur chaque sortie

Ce que Google déclare avoir amélioré

Google mentionne une meilleure conception visuelle, l’édition basée sur des masques, la cohérence du sujet et des images plus naturelles. La documentation ajoute la cohérence des personnages sur plusieurs tours, le rendu de texte précis et l’ancrage via Google Images.

Rendu de texte

Google affirme que Nano Banana 2.1 améliore le rendu du texte pour les infographies, menus, diagrammes et supports marketing.

Il s’agit d’une affirmation de Google, pas d’un résultat mesuré : aucun benchmark de précision de texte n’a été publié pour la version 2.1.

Pour valider le modèle dans votre produit :

Constituez un jeu de requêtes contenant vos vrais textes : prix, libellés, CTA, tableaux, menus ou écrans d’interface.
Générez les mêmes images avec Nano Banana 2 et 2.1.
Mesurez les erreurs de caractères, les omissions, les problèmes d’alignement et la lisibilité à la taille d’affichage réelle.
Ne basculez le trafic de production qu’après validation sur vos propres cas d’usage.

Édition basée sur des masques

Google appelle cette fonctionnalité le masquage sémantique. Au lieu de dessiner un masque, décrivez précisément la zone à modifier.

Exemple de requête :

En utilisant l’image fournie, changez uniquement la couleur de la veste en bleu foncé.
Gardez tout le reste exactement pareil.

Le modèle déduit la région à modifier et tente de préserver le reste de l’image.

Cohérence du sujet et des personnages

Pour conserver un personnage, un produit ou une mascotte au fil des modifications, chaînez les interactions avec previous_interaction_id. Vous pouvez également fournir jusqu’à 14 images de référence.

Le flux recommandé est :

Créez l’image de départ.
Conservez l’identifiant de l’interaction.
Envoyez chaque instruction d’édition avec previous_interaction_id.
Vérifiez la cohérence visuelle après chaque tour avant de poursuivre la chaîne.

Ancrage de la recherche

Nano Banana 2.1 et 3.1 Flash Image peuvent s’ancrer sur la recherche Web Google et la recherche d’images Google. Cela peut être utile pour des événements récents, des cartes météorologiques ou des graphiques boursiers.

Limite importante : l’ancrage ne peut pas utiliser des images réelles de personnes récupérées depuis la recherche web.

Prix : moitié prix par image par rapport à Nano Banana 2

Voici les prix de l’API Gemini pour les niveaux payants, selon la page de tarification Google, au 7 octobre 2026, en tarification standard hors traitement par lot.

Modèle	Entrée, pour 1 M	Sortie image, pour 1 M	0,5K	1K	2K	4K
Nano Banana 2.1	1,50 $	30 $	n/a	0,0336 $	0,0504 $	0,0756 $
Nano Banana 2	0,50 $	60 $	0,045 $	0,067 $	0,101 $	0,151 $
Nano Banana 2 Lite	0,25 $	30 $	n/a	0,0336 $	n/a	n/a
Nano Banana Pro	2,00 $	120 $	n/a	0,134 $	0,134 $	0,24 $

Points pratiques à retenir :

Coût par image divisé par deux : le prix des jetons de sortie image passe de 60 $ à 30 $ par million.
Même nombre de jetons image : 1 120 jetons en 1K, 1 680 en 2K et 2 520 en 4K pour Nano Banana 2 et 2.1.
Exemple : 1 000 images 1K coûtent 33,60 $ avec Nano Banana 2.1, contre 67 $ avec Nano Banana 2.
Prix de Lite avec plus de résolutions : en 1K, Nano Banana 2.1 coûte autant que Nano Banana 2 Lite, tout en ajoutant le 2K et le 4K.
Environ un quart du prix de Pro en 1K : 0,0336 $ contre 0,134 $.
Traitement par lot : 0,0168 $ en 1K, 0,0252 $ en 2K et 0,0378 $ en 4K.

L’ancrage de recherche est facturé séparément : 5 000 requêtes gratuites par mois, partagées entre les modèles Gemini 3.x, puis 14 $ par tranche de 1 000 requêtes.

Pour le détail des coûts de l’ancien modèle, consultez le guide de tarification Nano Banana 2.

Les limites à prendre en compte

Coûts d’entrée trois fois plus élevés

Les jetons d’entrée passent de 0,50 $ à 1,50 $ par million. Les sorties de texte et de réflexion passent de 3 $ à 7,50 $ par million.

Pour un simple flux texte-vers-image, l’impact est généralement faible. En revanche, il devient significatif si vos requêtes contiennent de nombreuses images de référence.

Estimation rapide :

Nano Banana 2.1 coûte 1 $ supplémentaire par million de jetons d’entrée.
En 1K, il économise environ 0,033 $ par image.
Le seuil de rentabilité est donc d’environ 33 000 jetons d’entrée par requête.
En 4K, l’économie atteint environ 0,075 $ par image, ce qui déplace le seuil vers environ 75 000 jetons d’entrée.

Vérifiez les valeurs d’usage réelles dans vos réponses API, en particulier si vous utilisez la réflexion ou plusieurs références visuelles.

Pas de niveau 512 px

Nano Banana 2 proposait une sortie 0,5K, soit 512 px, à 0,045 $. Cette taille n’est pas prise en charge par Nano Banana 2.1.

Pour des miniatures, le 1K de Nano Banana 2.1 reste moins cher à 0,0336 $, mais produit des fichiers plus volumineux. Si la taille de fichier compte, prévoyez un redimensionnement et une optimisation après génération.

Pas de niveau gratuit sur l’API

La page de tarification Google indique que le niveau gratuit de l’API Gemini est indisponible pour Nano Banana 2.1, Nano Banana 2, Lite et Pro.

Google renvoie vers le playground d’AI Studio, mais ne précise pas le volume gratuit disponible pour la version 2.1. Le code qui appelle l’API nécessite une clé payante.

Consultez comment utiliser Nano Banana 2.1 gratuitement pour les options disponibles.

Aucun benchmark publié

L’affirmation selon laquelle Nano Banana 2.1 « surpasse nos modèles précédents sur toute la ligne » n’est accompagnée ni de chiffres publiés ni d’un article de lancement technique détaillé.

Considérez les gains de qualité comme plausibles, mais non prouvés, jusqu’à ce que vous les confirmiez avec vos propres jeux de test.

Déploiement discret

Le modèle est apparu dans Google Flow avant l’annonce de l’API. Des rapports tiers indiquent sa disponibilité dans Flow avec des crédits d’abonnement et son apparition progressive dans les applications Gemini, mais Google n’a pas confirmé le déploiement dans ces applications.

Qui devrait migrer ?

Migrez maintenant si :

Vous utilisez Nano Banana 2 en 1K, 2K ou 4K pour du texte-vers-image.
Vous utilisez Nano Banana 2 Lite et avez besoin de sorties 2K ou 4K.
Vos images contiennent du texte réel : étiquettes produit, menus, diapositives ou interfaces.
Votre pipeline n’est pas dépendant de la sortie 512 px.

Attendez ou testez davantage si :

Votre pipeline dépend d’images 512 px.
Vos requêtes comprennent beaucoup de références et sont coûteuses en jetons d’entrée.
Vous avez besoin du niveau de qualité Pro pour des assets marketing finaux.

Pour comparer les options, consultez la comparaison Nano Banana 2.1 vs Nano Banana 2 vs Pro.

Tester Nano Banana 2.1 via l’API

Nano Banana 2.1 fonctionne avec l’API Gemini Interactions.

Requête minimale avec cURL

curl -s -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-nano-banana-2.1",
    "input": [
      {
        "type": "text",
        "text": "A ripe banana wearing tiny sunglasses on a beach towel, bold hand-lettered sign that reads OPEN"
      }
    ]
  }'

L’image est renvoyée sous forme de données Base64.

Générer et enregistrer l’image avec Python

from google import genai
import base64

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-nano-banana-2.1",
    input="A ripe banana wearing tiny sunglasses on a beach towel",
    response_format={
        "type": "image",
        "mime_type": "image/png",
        "aspect_ratio": "16:9",
        "image_size": "2K",
    },
)

with open("banana.png", "wb") as f:
    f.write(base64.b64decode(interaction.output_image.data))

Définir type sur image renvoie uniquement une image, sans texte de réponse.

Enchaîner une édition

Pour une édition de suivi, réutilisez l’identifiant de l’interaction précédente :

edited = client.interactions.create(
    model="gemini-nano-banana-2.1",
    input="Change uniquement les lunettes en rouge. Garde tout le reste identique.",
    previous_interaction_id=interaction.id,
)

Ajouter l’ancrage de recherche

Ajoutez l’outil de recherche à votre requête :

tools=[{"type": "google_search"}]

Avant de l’utiliser en production, vérifiez que votre cas d’usage respecte les limites liées aux images réelles de personnes.

Comparer Nano Banana 2 et 2.1 sans script

Vous pouvez utiliser Apidog pour comparer les modèles avec les mêmes requêtes et conserver les résultats dans votre suite de tests.

Enregistrez la requête. Créez un POST vers l’endpoint Interactions et stockez la clé dans une variable d’environnement :

   x-goog-api-key: {{GEMINI_API_KEY}}

Clonez la requête par modèle. Dupliquez-la et remplacez uniquement :

   "model": "gemini-nano-banana-2.1"

par :

   "model": "gemini-3.1-flash-image"

Envoyez exactement le même prompt. Comparez les images générées, la latence et l’utilisation des jetons.
Ajoutez des assertions. Vérifiez un statut 200 et la présence d’un bloc de sortie image dans la réponse.
Transformez la comparaison en test de régression. Réexécutez le scénario à chaque mise à jour de modèle ou modification de prompt.

Le guide complet, incluant l’édition d’images, les chaînes multi-tours et le suivi des coûts, est disponible dans le guide de l’API Nano Banana 2.1. Si vous avez besoin d’une clé, consultez d’abord comment obtenir une clé API Gemini.

FAQ

Quel est l’ID du modèle Nano Banana 2.1 ?

gemini-nano-banana-2.1. Le nom officiel est Gemini Nano Banana 2.1.

Nano Banana 2.1 est-il moins cher que Nano Banana 2 ?

Par image, oui : il coûte environ deux fois moins cher en 1K, 2K et 4K. Les jetons d’entrée coûtent toutefois trois fois plus cher, ce qui peut réduire l’écart pour les requêtes riches en références.

Nano Banana 2.1 rend-il correctement le texte ?

Google annonce un « rendu de texte précis », mais n’a pas publié de benchmark pour étayer cette affirmation. Testez vos propres prompts riches en texte avant de migrer.

Nano Banana 2.1 est-il gratuit ?

Pas via l’API Gemini : le niveau gratuit est indiqué comme indisponible. Google le lie au playground AI Studio, sans publier de limite gratuite spécifique pour la version 2.1.

Conclusion

Nano Banana 2.1 est avant tout une baisse de prix importante pour les développeurs qui génèrent des images : même volume de jetons image que Nano Banana 2, moitié moins cher en sortie, et accès au 2K et au 4K au prix 1K de Nano Banana 2 Lite.

Google annonce des améliorations pour le rendu de texte, l’édition et la cohérence, mais ces gains restent à vérifier faute de benchmarks publics. Surveillez surtout le coût d’entrée trois fois plus élevé lorsque vous envoyez beaucoup d’images de référence, ainsi que l’absence de sortie 512 px.

Exécutez les mêmes prompts sur les deux modèles dans Apidog, mesurez qualité, latence et coûts, puis basculez uniquement le trafic pour lequel Nano Banana 2.1 apporte un gain mesurable.

Mistral est de retour : Le Chonk bat GPT-6 Astra et Claude

Antoine Laurent — Tue, 06 Oct 2026 16:20:55 +0000

Mistral s'était fait discret sur le segment haut de gamme. Après Mistral Large 3, lancé en décembre 2025, les discussions autour des modèles open-weight de frontière se sont surtout concentrées sur Kimi, DeepSeek, GLM et Qwen. Le 6 octobre 2026, Mistral a répondu avec Mistral Large 4, un modèle de 1 000 milliards de paramètres surnommé « Le Chonk » par l'équipe.

Essayez Apidog dès aujourd'hui

Le chiffre le plus commenté est un benchmark de cybersécurité : Large 4 y atteint 82 %, tandis que Claude Opus 5.5 et GPT-6 Astra obtiennent un score proche de zéro. Ce résultat demande toutefois du contexte : les modèles fermés refusent la tâche, plutôt que de l'échouer. Voici les spécifications, les coûts, les limites et une méthode pour le tester contre vos propres API.

En bref

Modèle : mixture-of-experts de 1,05 T de paramètres, dont 49 milliards actifs, avec un encodeur de vision de 1,6 milliard de paramètres.
Entrées : texte et images, avec une fenêtre de contexte de 1 million de tokens.
Disponibilité : API Mistral en prévisualisation publique sous l'ID mistral-large-4. Les poids sont annoncés avant la fin octobre 2026.
Prix : 1,36 $/M tokens en entrée et 4,18 $/M en sortie au tarif catalogue ; 0,68 $/M et 2,09 $/M pendant la prévisualisation. Les entrées mises en cache coûtent 0,07 $/M.
Cybersécurité : 82 % au test de reproduction de vulnérabilités de l'indice AA Cyber. Les scores proches de zéro d'Opus 5.5 et Astra sont liés à leurs refus.
Codage : Large 4 obtient 3,74/5 dans une évaluation humaine, contre 4,22/5 pour Claude Opus 5.

Pourquoi le retour de Mistral est crédible

Pendant une grande partie de 2026, les modèles open-weight les plus performants venaient principalement de Chine. Mistral a publié Medium 3.5, Devstral 2 et Small 4, mais aucun ne rivalisait directement avec les modèles fermés de pointe.

Large 4 repositionne Mistral sur ce terrain. L'entreprise affirme qu'il « surpasse significativement tout modèle open-weight développé aux États-Unis ou en Europe ». Le modèle a été entraîné de zéro sur 3 800 GPU NVIDIA Grace Blackwell dans les centres de données européens de Mistral. Il couvre plus de 160 langues, dont toutes les langues officielles de l'Union européenne.

Le calendrier est également notable : Large 4 est arrivé peu après l'annonce de Beam par Reflection. La course aux modèles open-weight compte donc un troisième acteur sérieux, aux côtés des modèles américains et chinois.

Le benchmark cyber : ce qu'il mesure réellement

L'indice Cyber d'Artificial Analysis inclut un test où le modèle doit reproduire une vulnérabilité réelle dans un projet open source, puis proposer un correctif. Mistral annonce un score de 82 % pour Large 4.

La nuance est importante. Mistral précise que Claude Opus 5.5 et GPT-6 Astra obtiennent un score proche de zéro parce qu'ils refusent d'effectuer la tâche.

Affirmation	Interprétation correcte
« Large 4 bat Astra et Opus 5.5 en cybersécurité »	Sur ce test, les modèles fermés refusent la demande. Large 4 répond et réussit souvent la reproduction.
« Large 4 est le meilleur modèle de piratage »	Non établi. Le refus est une décision de politique, pas une mesure directe de capacité.
« Large 4 est dangereux »	Non établi également. Mistral indique un taux de refus moyen élevé sur les requêtes cyber de JailbreakBench, StrongREJECT et AgentHarm, comparé aux autres modèles open-weight.

Mistral rapporte aussi :

93 % sur Cybench, un ensemble de 40 exercices de capture du drapeau ;
93,3 % de résistance aux attaques sur le benchmark de sécurité des agents B3.

Pour une équipe sécurité, le cas d'usage pratique est défensif : reproduire une CVE dans votre propre environnement de staging, analyser un correctif ou examiner une surface d'attaque sans dépendre du filtre de politique d'un fournisseur tiers.

Performances hors cybersécurité

Les résultats les plus utiles face à GPT-6 Astra sont ceux où les deux modèles exécutent réellement la tâche.

Benchmark	Mistral Large 4	GPT-6 Astra	Lecture
Dense 200, ancrage visuel	42 %	41 %	Avantage réel, mais limité à un point.
Finance Agent v2 (vals.ai)	Devant	Derrière	Mistral publie le classement, pas les scores.
Benchmark juridique Harvey	Meilleur modèle ouvert	Listé	Aucun score de comparaison directe n'est publié.

Face aux autres modèles open-weight, l'écart rapporté est plus marqué :

Benchmark	Mistral Large 4	Référence battue
AutomationBench, 657 workflows	59,9 %	Kimi K3, DeepSeek V4 Pro
AA-Briefcase, travail de connaissance	1 393 Elo	DeepSeek V4 Pro
DeepSWE v1.1, codage	61,7 %	Leader open-weight
SWE-Atlas-QnA	59,4 %	—
Terminal-Bench 4.0	28,3 %	—

Ces chiffres proviennent de Mistral et portent sur un modèle en prévisualisation. Aucun laboratoire indépendant ne les a encore reproduits. Utilisez-les comme un signal pour lancer vos tests, pas comme un verdict de production.

Là où Large 4 reste derrière

Mistral publie aussi une comparaison où un modèle fermé conserve une avance nette. Dans une évaluation humaine de qualité de code menée par Surge AI, Large 4 Preview arrive deuxième.

Modèle	Score humain de codage, sur 5
Claude Opus 5	4,22
Mistral Large 4 Preview	3,74
GLM-5.3	3,60
Kimi K3	3,59
GLM-5.2	3,40

Large 4 dépasse les modèles open-weight chinois inclus dans cette comparaison, mais reste à environ un demi-point de Claude Opus 5. La formulation de Mistral — « combler l'écart » avec les modèles de pointe en codage — est donc raisonnable.

Les documents de lancement ne contiennent pas de comparaison avec Claude Fable 5.1 ou GPT-6 Sol. Si vous voyez une affirmation sur ce point, demandez le benchmark, le prompt et la configuration d'inférence.

Spécifications à intégrer

Spécification	Mistral Large 4
ID API	`mistral-large-4`, alias `mistral-large-4-0`
Version	26.10, prévisualisation publique
Architecture	Mixture-of-experts, hybride instructif + raisonnement
Paramètres	1,05 T au total, 49 milliards actifs, encodeur vision de 1,6 milliard
Fenêtre de contexte	1 million de tokens
Entrées	Texte et images
Raisonnement	`reasoning_effort` : `"high"` ou `"none"`
Outils	Appel de fonctions, sorties structurées, outils d'agent intégrés
Endpoints	`/v1/chat/completions`, `/v1/conversations`, `/v1/agents`, `/v1/batch`
Poids	Annoncés avant fin octobre 2026 ; licence non publiée

Prix : calculez avec le tarif catalogue

La page de tarification Mistral affiche un tarif de prévisualisation réduit de moitié.

Modèle	Entrée / 1M tokens	Sortie / 1M tokens	Poids ouverts
Mistral Large 4, prévisualisation	0,68 $	2,09 $	Oui, fin octobre
Mistral Large 4, catalogue	1,36 $	4,18 $	Oui, fin octobre
Claude Opus 5.5	4,00 $	20,00 $	Non
GPT-6 Astra	10,00 $	50,00 $	Non

Au tarif de prévisualisation, la sortie de Large 4 coûte environ un vingt-quatrième de celle d'Astra. Même au tarif catalogue, elle reste environ douze fois moins chère en sortie.

Le tarif des entrées mises en cache, 0,07 $/M tokens, est particulièrement pertinent pour les agents. Si vous réutilisez à chaque tour une instruction système longue, un schéma OpenAPI ou des définitions d'outils, activez et mesurez le cache dans vos tests.

Mistral n'a pas indiqué de date de fin pour la réduction de prévisualisation. Construisez donc votre budget sur le prix catalogue.

Décider si vous devez le tester

Testez Large 4 dès maintenant si :

vous exécutez des agents ou des workflows d'automatisation et souhaitez réduire vos coûts ;
vous avez besoin de sorties multilingues ou d'une inférence hébergée dans l'Union européenne ;
vous réalisez des travaux de sécurité défensive et rencontrez des refus sur des scénarios légitimes de reproduction de vulnérabilités ;
vous souhaitez évaluer un modèle que vous pourrez potentiellement auto-héberger.

Attendez avant de migrer en production si :

la qualité de code évaluée par des humains est votre métrique principale ;
vous devez défendre vos choix sur la base de benchmarks indépendants ;
vous utilisez déjà Large 3 en production et avez besoin d'un ID de modèle versionné stable.

Tester Large 4 contre vos propres API avec Apidog

Les benchmarks publics ne reflètent pas nécessairement vos prompts, vos outils, vos données ou vos contraintes de latence. La méthode la plus utile consiste à exécuter le même jeu de requêtes avec Large 4 et votre modèle actuel.

Apidog permet de mettre en place ce test sans écrire de couche intermédiaire.

1. Créez la requête de base

Configurez une requête :

POST https://api.mistral.ai/v1/chat/completions
Authorization: Bearer {{MISTRAL_API_KEY}}
Content-Type: application/json

Placez la clé dans une variable d'environnement plutôt que dans la collection ou le corps de la requête.

Exemple minimal :

{
  "model": "mistral-large-4",
  "messages": [
    {
      "role": "user",
      "content": "Résume cette spécification OpenAPI et identifie les opérations à risque."
    }
  ],
  "reasoning_effort": "high"
}

2. Dupliquez la requête pour chaque modèle

Clonez la requête et modifiez uniquement le champ model. Gardez identiques :

le prompt ;
la température et les autres paramètres ;
les outils et les schémas de sortie ;
les données de test.

Comparez ensuite la réponse, le statut HTTP, la latence, la taille de réponse et le bloc usage. Cela vous permet de calculer le coût réel à partir des tokens consommés, plutôt que de comparer uniquement le prix catalogue.

3. Ajoutez des assertions de régression

Pour une sortie structurée, vérifiez au minimum :

un statut HTTP 200 ;
une réponse non vide ;
la présence des champs attendus ;
la conformité au schéma JSON ;
l'absence de contenu interdit ou hors périmètre.

Exemple de critères à automatiser :

status == 200
choices[0].message.content != ""
response respecte le schéma attendu
usage.total_tokens > 0

Vous transformez ainsi une comparaison ponctuelle en suite de régression réutilisable.

4. Réexécutez le scénario à chaque mise à jour

Regroupez les requêtes dans un scénario de test. Relancez-le lorsque Mistral met à jour la prévisualisation ou publie les poids. Surveillez notamment :

la variation de qualité ;
les taux d'échec ;
la latence p50 et p95 ;
le volume de tokens ;
le coût par tâche réussie.

Les fonctions d'appel et les sorties structurées de Large 4 sont adaptées aux workflows API. Vous pouvez par exemple convertir une spécification OpenAPI conçue dans Apidog en définitions d'outils utilisables par un agent.

Pour aller plus loin, consultez le guide API Mistral Large 4, qui couvre les clés, les blocs de raisonnement, les images, l'appel de fonctions et le calcul des coûts.

Pour les cas de sécurité défensive, utilisez Large 4 comme second relecteur lors de vos tests de sécurité API, par exemple pour analyser un contournement d'authentification dans une API de staging.

Si vous migrez depuis un ancien modèle Mistral, les bases de l'API Mistral AI et le guide API Mistral Medium 3.5 restent applicables : même URL de base, même authentification, nouvel ID de modèle.

FAQ

Mistral Large 4 est-il open source ?

Il est annoncé comme open-weight. Mistral prévoit de publier les poids avant fin octobre 2026. La licence n'est pas encore publiée : ne supposez pas qu'elle sera identique à l'Apache 2.0 de Large 3.

Mistral Large 4 bat-il vraiment GPT-6 Astra ?

Selon les chiffres de Mistral, oui sur l'ancrage visuel, avec 42 % contre 41 %, et sur Finance Agent v2. Sur le test de reproduction de vulnérabilités, Astra refuse la tâche : ce n'est donc pas une comparaison directe de capacité.

Bat-il Claude ?

Pas sur l'évaluation humaine de codage publiée : Claude Opus 5 obtient 4,22/5, contre 3,74/5 pour Large 4 Preview. Claude Opus 5.5 refuse également la tâche de reproduction cyber utilisée dans le benchmark mentionné plus haut.

Que signifie « Le Chonk » ?

C'est le surnom officieux donné au modèle par Mistral, en référence à sa taille. Son nom officiel est Mistral Large 4, ou ML4.

Puis-je l'utiliser gratuitement ?

Le plan gratuit de Mistral inclut 10 $ mensuels de crédits API et l'accès aux modèles récents dans Le Chat et Vibe. Au prix de prévisualisation annoncé, 10 $ correspondent à environ 4,8 millions de tokens de sortie sur Large 4.

En résumé

Mistral revient dans la conversation des modèles de pointe avec un modèle open-weight à très grande échelle, une fenêtre de contexte de 1 million de tokens et des prix API agressifs.

Le signal cyber est intéressant, mais doit être interprété correctement : les modèles fermés obtiennent un score faible parce qu'ils refusent la tâche. En codage évalué par des humains, Large 4 arrive derrière Claude Opus 5.

La décision pratique est simple : testez Large 4 sur vos propres prompts, outils et API pendant la période de prévisualisation, mesurez la qualité, la latence et le coût par tâche réussie, puis attendez des benchmarks indépendants avant une migration de production.

Comment utiliser l'API Mistral Large 4

Antoine Laurent — Tue, 06 Oct 2026 16:17:25 +0000

Mistral Large 4 a été mis en ligne sur l’API Mistral le 6 octobre 2026, trois semaines avant la publication de ses poids ouverts. Si vous souhaitez essayer dès maintenant le modèle « Le Chonk » de 1 000 milliards de paramètres, l’API est le seul moyen d’y accéder — et actuellement le moins cher : Mistral le propose à 0,68 $ par million de jetons d’entrée et 2,09 $ par million de jetons de sortie pendant l’aperçu public, soit la moitié du prix catalogue de 1,36 $ / 4,18 $.

Essayez Apidog dès aujourd’hui

Ce guide vous fait passer de zéro à un premier appel fonctionnel en environ cinq minutes. Il couvre ensuite les points d’intégration qui demandent le plus d’attention : blocs de raisonnement, images, appels de fonctions, sortie JSON et coût. Enregistrez et rejouez vos requêtes dans Apidog pour comparer Large 4 au modèle que vous utilisez déjà.

Nouveau sur ce modèle ? Commencez par Mistral est de retour : Le Chonk bat GPT-6 Astra et Claude en cybersécurité pour les benchmarks et le contexte derrière le titre cyber.

Ce dont vous avez besoin

Élément	Valeur
Base URL	`https://api.mistral.ai/v1`
Auth	`Authorization: Bearer $MISTRAL_API_KEY`
Model ID	`mistral-large-4` (alias `mistral-large-4-0`)
Endpoint principal	`POST /v1/chat/completions`
Fenêtre de contexte	1M tokens
Types d’entrée	Texte, images
SDK Python	`pip install mistralai`
SDK TypeScript	`npm install @mistralai/mistralai`

Étape 1 : obtenir une clé API

Connectez-vous à Mistral Studio — anciennement La Plateforme.
Ouvrez Clés API, puis créez une clé.
Donnez-lui un nom explicite, par exemple local-dev ou ci-staging.
Copiez la clé immédiatement : elle ne sera plus affichée.
Exportez-la dans votre shell :

export MISTRAL_API_KEY="your-key-here"

Ne placez pas cette clé dans votre dépôt Git. Si vous l’utilisez dans plusieurs outils ou environnements, consultez ces bonnes pratiques de gestion des clés API pour la rotation et la portée des clés.

Étape 2 : effectuer votre premier appel

Commencez avec curl pour isoler les problèmes d’authentification ou de SDK :

curl https://api.mistral.ai/v1/chat/completions \
  -H "Authorization: Bearer $MISTRAL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-large-4",
    "messages": [
      {
        "role": "user",
        "content": "Give me three edge cases to test on a pagination API."
      }
    ]
  }'

Une réponse réussie contient notamment :

choices[0].message.content : la réponse du modèle ;
usage.prompt_tokens : les jetons d’entrée ;
usage.completion_tokens : les jetons de sortie ;
usage.total_tokens : le total facturé.

Diagnostic rapide :

401 Unauthorized : clé incorrecte, absente ou non exportée ;
404 sur le modèle : vérifiez l’ID mistral-large-4 ;
422 Unprocessable Entity : le JSON envoyé ne respecte pas le format attendu.

Le même appel en Python

Installez le SDK :

pip install mistralai

Puis exécutez :

import os
from mistralai import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

response = client.chat.complete(
    model="mistral-large-4",
    messages=[
        {
            "role": "user",
            "content": "Give me three edge cases to test on a pagination API.",
        }
    ],
)

print(response.choices[0].message.content)

Le même appel en TypeScript

Installez le SDK :

npm install @mistralai/mistralai

Puis appelez le modèle :

import { Mistral } from "@mistralai/mistralai";

const client = new Mistral({ apiKey: process.env.MISTRAL_API_KEY });

const response = await client.chat.complete({
  model: "mistral-large-4",
  messages: [
    {
      role: "user",
      content: "Give me three edge cases to test on a pagination API.",
    },
  ],
});

console.log(response.choices[0].message.content);

Étape 3 : enregistrer la requête dans Apidog

Dès que vous comparez plusieurs modèles, les commandes curl deviennent difficiles à maintenir. Configurez une requête réutilisable dans Apidog :

Créez une requête HTTP : POST https://api.mistral.ai/v1/chat/completions.
Ajoutez une variable d’environnement MISTRAL_API_KEY.
Ajoutez l’en-tête :

   Authorization: Bearer {{MISTRAL_API_KEY}}

Collez le corps JSON de l’étape précédente.
Cliquez sur Envoyer.
Dupliquez la requête, remplacez model par votre modèle actuel — par exemple mistral-medium-3-5 — puis exécutez les deux requêtes avec le même prompt.

Vous obtenez ainsi deux requêtes comparables. Apidog affiche le statut, le corps de réponse, le temps d’exécution et la taille de chaque réponse.

Ajoutez aussi une assertion post-réponse pour vérifier que choices[0].message.content n’est pas vide. Vous aurez alors un test de validation simple à réexécuter lorsque Mistral met à jour l’aperçu.

Étape 4 : activer ou désactiver le raisonnement

Large 4 est un modèle hybride : le même modèle peut répondre rapidement ou produire un raisonnement étape par étape. Contrôlez ce comportement avec reasoning_effort.

Valeur	Comportement	Cas d’usage
`"none"`	Pensée minimale, sans bloc de raisonnement dans la réponse	Chat, extraction, classification, flux sensibles à la latence
`"high"`	Bloc de raisonnement complet avant la réponse finale	Débogage, planification multi-étapes, mathématiques, revue de code

Exemple avec raisonnement élevé :

curl https://api.mistral.ai/v1/chat/completions \
  -H "Authorization: Bearer $MISTRAL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-large-4",
    "messages": [
      {
        "role": "user",
        "content": "Our API returns 200 with an empty body under load. List likely causes in order of probability."
      }
    ],
    "reasoning_effort": "high"
  }'

Avec reasoning_effort: "high", message.content n’est plus nécessairement une chaîne. Il devient une liste de blocs :

un bloc thinking pour la trace de raisonnement ;
un bloc text pour la réponse finale.

Ne supposez donc pas que response.choices[0].message.content peut toujours être affiché directement. Extrayez explicitement le texte final :

response = client.chat.complete(
    model="mistral-large-4",
    messages=[
        {
            "role": "user",
            "content": "Why would a 200 response have an empty body?",
        }
    ],
    reasoning_effort="high",
)

content = response.choices[0].message.content

if isinstance(content, str):
    answer = content
else:
    answer = "".join(block.text for block in content if block.type == "text")

print(answer)

Les jetons de réflexion sont facturés comme des jetons de sortie. Utilisez "none" par défaut, puis passez à "high" uniquement pour les requêtes qui exigent un raisonnement approfondi.

Étape 5 : envoyer une image

Large 4 est nativement multimodal, avec un encodeur de vision de 1,6 milliard de paramètres. Envoyez une image sous forme de partie de contenu, à côté du texte :

curl https://api.mistral.ai/v1/chat/completions \
  -H "Authorization: Bearer $MISTRAL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-large-4",
    "messages": [
      {
        "role": "user",
        "content": [
          {
            "type": "text",
            "text": "This is a screenshot of our API error dashboard. Which endpoint is failing most and what is the error code?"
          },
          {
            "type": "image_url",
            "image_url": "https://example.com/dashboard.png"
          }
        ]
      }
    ]
  }'

Pour un fichier local, utilisez une URL de données base64 :

{
  "type": "image_url",
  "image_url": "data:image/png;base64,<encoded>"
}

Mistral indique que Large 4 atteint 42 % au benchmark de mise à la terre visuelle Dense 200, devant les 41 % de GPT-6 Astra. Les captures de tableaux de bord, graphiques et états d’interface sont donc des cas d’usage pertinents.

Étape 6 : utiliser l’appel de fonction

L’appel de fonction permet au modèle de choisir un outil, puis à votre application d’exécuter réellement l’opération. C’est là que les benchmarks d’agent de Large 4 — 59,9 % sur AutomationBench — deviennent utiles.

Définissez d’abord vos outils :

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_order_status",
            "description": "Look up the status of an order by its ID.",
            "parameters": {
                "type": "object",
                "properties": {
                    "order_id": {
                        "type": "string",
                        "description": "The order ID, e.g. ORD-1042",
                    }
                },
                "required": ["order_id"],
            },
        },
    }
]

messages = [
    {
        "role": "user",
        "content": "Where is order ORD-1042?",
    }
]

response = client.chat.complete(
    model="mistral-large-4",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)

tool_call = response.choices[0].message.tool_calls[0]

print(tool_call.function.name)
print(tool_call.function.arguments)

Exécutez ensuite vous-même la fonction demandée, puis renvoyez son résultat au modèle avec le même tool_call_id :

import json

result = {
    "order_id": "ORD-1042",
    "status": "shipped",
    "eta": "2026-10-09",
}

messages.append(response.choices[0].message)

messages.append(
    {
        "role": "tool",
        "name": "get_order_status",
        "content": json.dumps(result),
        "tool_call_id": tool_call.id,
    }
)

final = client.chat.complete(
    model="mistral-large-4",
    messages=messages,
    tools=tools,
)

print(final.choices[0].message.content)

Le schéma d’outil est un JSON Schema. Si votre API possède déjà une spécification OpenAPI, réutilisez le schéma de requête de chaque opération dans parameters.

Concevoir et maintenir la spécification dans Apidog permet de garder les définitions d’outils et votre API réelle synchronisées.

Étape 7 : obtenir du JSON en sortie

Pour une sortie exploitable par une machine, définissez response_format :

curl https://api.mistral.ai/v1/chat/completions \
  -H "Authorization: Bearer $MISTRAL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-large-4",
    "messages": [
      {
        "role": "user",
        "content": "Extract method, path and status code from: GET /v1/users/42 returned 404. Reply in JSON."
      }
    ],
    "response_format": {
      "type": "json_object"
    }
  }'

Mentionnez explicitement JSON dans le prompt et ajoutez response_format.

Pour une structure stricte, Mistral prend également en charge :

{
  "type": "json_schema",
  "json_schema": {
    "...": "votre schéma complet"
  }
}

Dans Apidog, ajoutez une assertion de schéma JSON sur la réponse. Une réponse qui diverge du contrat échouera immédiatement, plutôt que de casser silencieusement un service en aval.

Ce que ça coûte

Utilisation	Prix d’aperçu	Prix catalogue
Entrée, par 1M de jetons	$0.68	$1.36
Entrée en cache, par 1M de jetons	$0.07	$0.14
Sortie, par 1M de jetons	$2.09	$4.18

Exemple : un agent effectue 10 000 appels par jour, avec 3 000 jetons d’entrée et 500 jetons de sortie par appel.

Entrée : 30M de jetons par jour. Si 2 500 des 3 000 jetons sont en cache, cela représente 25M de jetons mis en cache à 0,07 $ et 5M de jetons frais à 0,68 $, soit environ 5,15 $/jour.
Sortie : 5M de jetons à 2,09 $, soit environ 10,45 $/jour.
Total : environ 15,60 $/jour au tarif d’aperçu, contre environ 31 $ au tarif catalogue.

La même charge de travail sur GPT-6 Astra — 10 $ / 50 $ par million avant les remises de mise en cache — coûterait plusieurs centaines de dollars par jour. Mistral n’a pas précisé quand la tarification d’aperçu prendra fin : budgétez donc selon le prix catalogue.

Erreurs courantes

Erreur	Cause probable	Solution
`401 Unauthorized`	Clé manquante ou incorrecte	Vérifiez `echo $MISTRAL_API_KEY` et le préfixe `Bearer`
`404` / modèle invalide	Faute de frappe dans l’ID	Utilisez exactement `mistral-large-4`
`422 Unprocessable Entity`	Corps mal formé, souvent un schéma `tools` invalide	Validez le JSON Schema dans `parameters` pour chaque outil
`429 Too Many Requests`	Limite de débit liée à votre niveau d’espace de travail	Attendez, réessayez ou augmentez les limites dans Studio
La réponse s’affiche comme une liste	`reasoning_effort: "high"` retourne des blocs	Extrayez le bloc `text` comme indiqué à l’étape 4

FAQ

Mistral Large 4 est-il compatible avec OpenAI ?

La forme de la requête est très proche : model, messages, tools, tool_choice et response_format fonctionnent comme attendu. Utilisez les SDK Mistral ou HTTP directement pour plus de sécurité. La sortie de raisonnement utilise toutefois le format de blocs propre à Mistral.

Quand pourrai-je l’exécuter localement ?

Mistral annonce que les poids seront livrés d’ici fin octobre 2026. Avec un total de 1,05 milliard de paramètres, il nécessite du matériel serveur multi-GPU. En attendant, ce guide sur l’exécution de Mistral 3 en local couvre les outils adaptés aux modèles plus petits.

L’aperçu est-il suffisamment stable pour la production ?

Pas encore. Le modèle est étiqueté « aperçu public » et peut changer avant la publication des poids. Épinglez vos tests, réexécutez-les lors des mises à jour du modèle et gardez un modèle de secours configuré.

Puis-je utiliser Large 4 avec mon code Mistral existant ?

Oui. L’URL de base, l’authentification et les SDK sont les mêmes. Changez simplement la valeur de model pour mistral-large-4. Si vous migrez depuis Medium 3.5, consultez ce guide API Mistral Medium 3.5 pour les parties transférables.

Conclusion

Vous pouvez obtenir un premier appel fonctionnel en cinq minutes. Ensuite, consacrez votre temps à exécuter vos prompts réels sur Large 4 et sur votre modèle actuel, côte à côte.

Enregistrez les deux requêtes dans Apidog, ajoutez des assertions sur le statut et la structure de réponse, puis comparez qualité, latence et consommation de jetons. Vous saurez rapidement si Le Chonk mérite une place dans votre pile technologique tant que le prix d’aperçu reste à moitié prix.

DEV Community: Antoine Laurent

Claude Haiku 5.5 contre GPT-6 Luna

Comparaison des prix

Calculer le coût par requête

Les tokeniseurs déplacent le seuil

Spécifications

Impact du cache dans les boucles

Benchmarks : scores et provenance des résultats

Coût par tentative selon le niveau d’effort

OSWorld 2.1 : score de crédit partiel / coût par tentative

GDPval-AA v2.1 : Elo / coût par tâche

Comment interpréter ces données

Routage : quel modèle utiliser selon la charge de travail ?

Tester les deux côte à côte dans Apidog

Procédure recommandée

FAQ

Claude Haiku 5.5 et GPT-6 Luna ont-ils le même prix ?

Quel modèle obtient les meilleurs scores ?

Quel modèle coûte le moins cher par tâche ?

L’un des deux modèles est-il gratuit ?

Choisir selon la longueur d’invite, puis mesurer

Claude Haiku 5.5 Benchmarks

Le tableau de lancement

Qui a exécuté chaque benchmark ?

Le piège FrontierCode

Résultats supplémentaires de la fiche système

L’effort par défaut produit des scores inférieurs

Score et coût selon l’effort

OSWorld 2.1

GDPval-AA v2.1

Terminal-Bench 4.0

Là où Haiku 5.5 reste en retrait

Résultats indépendants : aucun pour l’instant

Ce que les clients rapportent

Exécutez votre propre évaluation

Procédure dans Apidog

FAQ

Étape suivante

Claude Haiku 5.5 vs Haiku 4.5 : Nouveautés et ruptures à corriger en priorité

Haiku 4.5 vs Haiku 5.5 en un coup d’œil

Les cinq changements majeurs

1. Remplacer budget_tokens par la réflexion adaptative

2. Supprimer les paramètres d’échantillonnage

3. Supprimer le préremplissage de l’assistant

4. Migrer l’utilisation de l’ordinateur vers computer_toolset_20260801

5. Ne modifiez pas l’historique avant un bloc de réflexion

Changements silencieux à tester

Ce qui s’est amélioré

Testez la migration dans Apidog

FAQ

Claude Haiku 4.5 est-il obsolète ?

Pourquoi ma requête Haiku 4.5 renvoie-t-elle une erreur 400 sur Haiku 5.5 ?

Haiku 5.5 est-il moins cher que Haiku 4.5 pour les longues invites ?

Dois-je tout migrer vers Haiku 5.5 ?

Étape suivante

Claude Haiku 5.5 Tarifs

Tableau des prix de l’API Claude Haiku 5.5

Formule de coût sans cache

D’où vient le « environ 75 % de moins »

Coût par tentative selon le niveau d’effort

Comment Haiku 5.5 se compare en termes de prix

Crédits API et forfaits consommateurs

Crédits API Max et Team

Forfaits consommateurs

Clouds

Suivre le coût par requête dans Apidog

1. Stockez la clé API

2. Créez une requête par niveau d’effort

3. Ajoutez un post-processeur de coût

4. Comparez les résultats

FAQ

Étape suivante : estimez le coût de votre charge de travail

Comment utiliser Claude Haiku 5.5 dans Claude Code (et comme modèle de sous-agent)

Claude Haiku 5.5 dans Claude Code en un coup d'œil

Étape 1 : mettre à jour Claude Code

Étape 2 : sélectionner Haiku 5.5 comme modèle principal

L'alias haiku ne signifie Haiku 5.5 que sur l'API Anthropic

Étape 3 : choisir un niveau d'effort

Étape 4 : exécuter Haiku 5.5 en tant que sous-agent

Remplacer Explore par un explorateur économique

1. Remplacer `budget_tokens` par la réflexion adaptative

4. Migrer l’utilisation de l’ordinateur vers `computer_toolset_20260801`

L'alias `haiku` ne signifie Haiku 5.5 que sur l'API Anthropic