---
title: "Nano Banana 2.1 API : ID de modèle, prix, résolutions et limites"
description: "Nano Banana 2.1 API : ID de modèle gemini-nano-banana-2.1, champs, tailles 1K/2K/4K, 14 références, prix et limites."
robots: "index, follow"
canonical: "https://potto.ai/fr/blog/nano-banana-2-1-api"
markdown: "https://potto.ai/fr/blog/nano-banana-2-1-api.md"
author: "Potto AI Team"
category: "AI images"
datePublished: "2026-10-11T00:00:00.000Z"
language: "fr"
dateModified: "2026-10-12T10:46:16.537Z"
---

# Nano Banana 2.1 API : ID de modèle, prix, résolutions et limites

Nano Banana 2.1 API est le modèle `gemini-nano-banana-2.1` de l'API Gemini de Google, un modèle de génération d'images et d'édition conversationnelle à haut rendement que vous appelez avec un prompt texte et, éventuellement, des images de référence. D'après la [page du modèle Nano Banana 2.1](https://ai.google.dev/gemini-api/docs/models/gemini-nano-banana-2.1) de Google, il renvoie des images en 1K (par défaut), 2K ou 4K, accepte jusqu'à 14 images de référence (jusqu'à 10 objets et jusqu'à 4 personnages), et dispose d'un paramètre thinking configurable. Le prix standard de Google est de $0.0336 par image 1K, $0.0504 par image 2K et $0.113 par image 4K, et les tâches batch sont facturées à moitié prix.

Ce guide rassemble les informations d'intégration au même endroit : l'ID de modèle, l'endpoint à appeler, les champs de requête qui comptent, les tailles de sortie, les emplacements d'images de référence, les tarifs, les limites de débit et les tâches batch. Chaque chiffre provient de la documentation officielle de Google, consultée le 2026-10-10. Les prix et les limites changent, alors vérifiez-les sur les pages de Google avant d'établir votre budget ou de lancer.

Potto ne propose pas d'API publique. Pour appeler le modèle depuis votre propre code, utilisez directement l'API Gemini de Google. Si vous voulez seulement les images, la page [Nano Banana 2.1](/fr/nano-banana-2-1) du générateur web de Potto vous permet de créer et de modifier avec le même modèle sans écrire de requête.

## Nano Banana 2.1 API en un coup d'œil

| Élément | Ce que dit la documentation de Google |
| --- | --- |
| ID de modèle | `gemini-nano-banana-2.1` (la version stable utilise le même ID) |
| Entrée | Texte, image, vidéo et PDF |
| Sortie | Image et texte |
| Résolutions de sortie | 1K (par défaut), 2K, 4K ; 512px n'est pas pris en charge sur 2.1 |
| Images de référence | Jusqu'à 14 au total : jusqu'à 10 objets et jusqu'à 4 personnages |
| Niveaux de thinking | `minimal`, `medium` (par défaut), `high` |
| Grounding | Recherche Web et Images de Google |
| Batch API | Pris en charge |
| Non pris en charge | Appel de fonctions, sorties structurées, mise en cache, exécution de code, contexte URL, grounding Maps, Live API, génération audio |
| Offre gratuite | Non disponible |
| Prix standard par image | $0.0336 (1K), $0.0504 (2K), $0.113 (4K) |
| Prix par image en Batch | $0.0168 (1K), $0.0252 (2K), $0.0567 (4K) |

Sources : page du modèle de Google (dernière mise à jour le 2026-10-06 UTC) et page de tarifs, consultées le 2026-10-10.

![Flux de requête de l'API Nano Banana 2.1 : un prompt et des images de référence sont envoyés au modèle d'API Gemini et une image est renvoyée](https://potto.ai/blog/nano-banana-2-1-api/fr/nano-banana-2-1-api-request-flow.webp#1200x675)

## Qu'est-ce que la Nano Banana 2.1 API ?

« Nano Banana » est le nom populaire des modèles de génération et d'édition d'images de Google issus de la famille Gemini, et la « Nano Banana 2.1 API » n'est rien d'autre que le moyen d'accéder à l'un d'eux depuis du code. Il n'y a pas de produit distinct auquel s'inscrire : vous utilisez une clé API Gemini et indiquez l'ID de modèle dans la requête. Le guide de génération d'images de Google recense cinq modèles sous le nom Nano Banana, chacun avec son propre ID :

| Nom | ID de modèle |
| --- | --- |
| Nano Banana 2.1 | `gemini-nano-banana-2.1` |
| Nano Banana 2 Lite | `gemini-3.1-flash-lite-image` |
| Nano Banana 2 | `gemini-3.1-flash-image` |
| Nano Banana Pro | `gemini-3-pro-image` |
| Nano Banana (original) | `gemini-2.5-flash-image` |

Le guide de Google présente 2.1 comme le modèle principal à haut rendement pour la génération d'images et l'édition conversationnelle, et le recommande pour tous les nouveaux projets. Pour une comparaison avec le modèle Pro, consultez le guide [Nano Banana 2.1 vs Nano Banana Pro](/fr/blog/nano-banana-2-1-vs-nano-banana-pro) ; cet article se concentre sur l'intégration de 2.1.

Google cite une meilleure qualité visuelle et un meilleur réalisme en 1K, 2K et 4K, la correction des artefacts de tuilage sur les ratios larges et panoramiques (1:4, 4:1, 1:8 et 8:1) en 2K et 4K, un rendu du texte amélioré et une meilleure précision de mise en page des infographies, ainsi que le grounding avec Google Web et Image Search. La documentation ne publie pas de scores de benchmark : testez donc vos propres prompts avant d'engager un pipeline sur ce modèle.

## Quel endpoint faut-il appeler ?

Appelez l'API Interactions. Le guide de génération d'images de Google l'utilise pour chaque exemple de Nano Banana 2.1 : un `POST` vers `https://generativelanguage.googleapis.com/v1beta/interactions` avec votre clé dans un en-tête `x-goog-api-key`. L'aperçu de l'API Interactions de Google indique que, depuis juin 2026, elle est généralement disponible et recommandée pour tous les nouveaux projets, et que tous les nouveaux modèles, outils et fonctionnalités agentiques y seront lancés. L'ancienne API `generateContent` est décrite comme héritée mais reste entièrement prise en charge.

Les appels SDK (`client.interactions.create`) nécessitent `google-genai` ou `@google/genai` version 2.3.0 ou ultérieure. L'aperçu liste également la Batch API, la mise en cache explicite et les paramètres de sécurité personnalisés comme non encore disponibles sur Interactions, donc les tarifs par lots impliquent d'utiliser `generateContent`, comme l'explique la section sur les lots.

## Envoyez votre première requête Nano Banana 2.1 API

La plus petite requête nomme le modèle et transmet le prompt en tant qu'élément texte. Le guide de Google montre cet appel REST :

```bash
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"}
    ]
  }'
```

Pour choisir la forme du résultat, ajoutez un objet `response_format`. Les mêmes champs apparaissent dans l'exemple Python de Google, où la sortie est lue depuis `interaction.output_image` :

```bash
-d '{
    "model": "gemini-nano-banana-2.1",
    "input": [{"type": "text", "text": "A cedar bottle on a linen cloth, soft window light"}],
    "response_format": {
      "type": "image",
      "mime_type": "image/jpeg",
      "aspect_ratio": "16:9",
      "image_size": "2K"
    },
    "generation_config": {"thinking_level": "medium"}
  }'
```

Les champs en langage clair :

| Champ | Ce qu'il fait |
| --- | --- |
| `input` | Le prompt sous forme d'éléments `{"type": "text", "text": ...}`, plus des éléments `{"type": "image", ...}` pour les images de référence |
| `response_format.mime_type` | `image/jpeg` ou `image/png` dans les exemples de Google |
| `response_format.aspect_ratio` | Par exemple `1:1`, `5:4` ou `16:9` dans les exemples de Google |
| `response_format.image_size` | `1K`, `2K` ou `4K`, avec un K majuscule |
| `generation_config.thinking_level` | `minimal`, `medium` ou `high` |
| `previous_interaction_id` | Continue une interaction précédente pour l'édition multi-tours |

Dans les exemples du SDK, l'image arrive encodée en base64 dans `interaction.output_image.data`, et l'exemple Python la décode avec `base64.b64decode` avant d'écrire le fichier. L'interaction porte également des `steps`, qui peuvent inclure des étapes de réflexion et le `model_output` final. L'exemple REST de Google n'affiche pas de corps de réponse, donc inspectez une réponse réelle avant d'écrire un analyseur pour le JSON brut.

## Tailles de sortie de Nano Banana 2.1 : 1K, 2K et 4K

Avec Nano Banana 2.1 API, le modèle produit trois tailles de sortie : 1K, 2K et 4K, avec 1K par défaut lorsque vous ne définissez pas `image_size`. La page de tarifs de Google répertorie les tokens d’image que chaque taille consomme : 1,120 pour une image 1K, 1,680 pour 2K et 3,780 pour 4K.

![Tailles de sortie de Nano Banana 2.1 en 1K, 2K et 4K montrées sous forme de trois cadres imbriqués](https://potto.ai/blog/nano-banana-2-1-api/fr/nano-banana-2-1-output-sizes.webp#1200x675)

Règles issues du guide de génération d’images qui provoquent de vraies erreurs :

- **K en majuscule uniquement.** Les valeurs en minuscules telles que `1k` sont rejetées.
- **Pas de 512px sur la 2.1.** La taille plus petite 512px (0.5K) appartient à Gemini 3.1 Flash Image, pas à Nano Banana 2.1.
- **Ratios d’aspect.** Les exemples de la 2.1 utilisent `1:1`, `5:4` et `16:9`. La page du modèle de Google nomme `1:4`, `4:1`, `1:8` et `8:1` comme ratios larges et panoramiques où les artefacts de mosaïque ont été corrigés en 2K et 4K. Les pages consultées pour ce guide ne donnent pas de liste complète des ratios pour la 2.1, donc testez le ratio exact dont vous avez besoin avant de construire une mise en page autour de lui.
- **Dimensions en pixels.** Le guide de Google ne publie pas de tableau de pixels pour la 2.1, alors mesurez le fichier renvoyé si votre mise en page nécessite des dimensions fixes.

Chaque image générée par les outils de Google inclut un filigrane SynthID, selon le guide. Prévoyez-le si vous retouchez ou recadrez les sorties.

Affinez vos prompts en 1K, car une taille plus grande ne corrige pas une composition faible ni un mot mal orthographié. Si vous avez déjà une image à conserver et que vous avez seulement besoin de plus de pixels, [Augmenter la résolution d'une image](/fr/image-upscaler) permet de l’agrandir sans nouvelle génération.

## Images de référence : jusqu'à 14 par requête

Nano Banana 2.1 accepte jusqu'à 14 images de référence dans une seule requête, et ce total couvre tous les types confondus. Le guide de Google répartit les emplacements selon le modèle :

| Type de référence | Nano Banana 2.1 |
| --- | --- |
| Objets (haute fidélité dans l'image finale) | Jusqu'à 10 |
| Personnages (cohérence entre les images) | Jusqu'à 4 |
| Total | Jusqu'à 14 |

Chaque référence est un élément supplémentaire dans la liste `input`. Dans l'exemple Python de Google, un élément image porte `"type": "image"`, les octets de l'image en base64 dans `data`, et un `mime_type` tel que `image/png`, placé à côté de l'élément texte qui contient le prompt.

![Nano Banana 2.1 accepte jusqu'à 14 images de référence, présentées sous forme de grille de références d'objets et de personnages](https://potto.ai/blog/nano-banana-2-1-api/fr/nano-banana-2-1-reference-images.webp#1200x675)

Utilisation pratique des emplacements : attribuez une seule fonction à chaque image et précisez-le dans le prompt (la première image correspond à la forme du produit, la deuxième à la palette) ; réutilisez la même image de personnage pour un visage récurrent ; et ajoutez les références une par une, car un plus grand nombre de références ne garantit pas que chaque détail soit conservé.

## Paramètres de thinking et de grounding

Nano Banana 2.1 API prend en charge trois niveaux de thinking, définis avec `generation_config.thinking_level` : `minimal`, `medium` (par défaut) et `high`. Le guide de Google indique que le thinking est activé par défaut pour les modèles d'image Gemini 3 et ne peut pas être désactivé via l'API, que le modèle peut produire jusqu'à deux images de réflexion intermédiaires, et que les tokens de thinking sont facturés par défaut. Les autres modèles Nano Banana listent des niveaux différents (Nano Banana 2 liste `minimal` et `high`), donc ne copiez pas un paramètre d'un modèle à l'autre.

Le grounding permet au modèle d'utiliser Google Search pour des sujets sensibles au temps. Dans l'Interactions API, vous ajoutez `tools` avec `google_search`, et `search_types` avec `["web_search", "image_search"]` demande des résultats web et image ; le grounding Image Search est disponible uniquement sur Nano Banana 2.1 et Gemini 3.1 Flash Image. Google note que les résultats d'Image Search doivent être affichés avec leurs `search_suggestions`, donc intégrez cet affichage dans votre interface.

Le grounding est facturé séparément : la page de tarifs de Google indique 5,000 requêtes de recherche gratuites par mois, partagées entre Gemini 3 et les modèles plus récents, puis $14 par 1,000 requêtes. Vérifiez tout nom, chiffre ou date dans une image groundée avant de publier.

## Édition multi-tours avec previous_interaction_id

Avec la Nano Banana 2.1 API, pour modifier une image que vous avez déjà générée, envoyez une deuxième requête avec `previous_interaction_id` défini sur le `id` de la première interaction et décrivez uniquement la modification. L'exemple de Google traduit le texte d'une infographie en espagnol tout en laissant les autres éléments tels quels. D'après la vue d'ensemble de l'API Interactions, `generation_config`, `tools` et `system_instruction` sont limités à une seule interaction, donc définissez-les à nouveau à chaque tour, et définir `store` sur `false` vous empêche d'utiliser `previous_interaction_id`. Pour les retouches où vous souhaitez peindre sur une zone à la main, [Retouche photo IA](/fr/ai-image-editor) est plus simple que de décrire la modification en mots.

## Prix de la Nano Banana 2.1 API

Google facture Nano Banana 2.1 en tokens, et la sortie d'images a son propre tarif. Voici la liste des prix standard (offre payante) de la page de tarification de l'API Gemini, consultée le 2026-10-10 :

| Élément | Standard | Batch |
| --- | --- | --- |
| Entrée (texte, image, vidéo) | $1.50 par 1M de tokens | $0.75 par 1M de tokens |
| Sortie texte et thinking | $7.50 par 1M de tokens | $3.75 par 1M de tokens |
| Sortie images | $30.00 par 1M de tokens d'image | $15.00 par 1M de tokens d'image |
| Une image 1K | $0.0336 | $0.0168 |
| Une image 2K | $0.0504 | $0.0252 |
| Une image 4K | $0.113 | $0.0567 |
| Grounding avec Google Search | 5,000 requêtes gratuites par mois, puis $14 par 1,000 | Non listé séparément |

Les prix par image correspondent au tarif des tokens d'image appliqué aux nombres de tokens de la section précédente : 1,120 tokens à $30 par million donnent $0.0336. L'offre gratuite est indiquée comme non disponible pour ce modèle, chaque appel nécessite donc un projet facturé.

Pour donner un ordre d'idée, en utilisant les prix de Google pour la sortie d'images uniquement : 1,000 images coûtent $33.60 en 1K, $50.40 en 2K et $113.00 en 4K, ou $25.20 en 2K en mode Batch. Les tokens d'entrée (votre prompt et vos éventuelles images de référence), les tokens de thinking et les requêtes de grounding sont facturés en plus, mesurez donc un échantillon avant d'engager un budget.

## Limites de débit et quotas

La page des limites de débit de Google n'affiche pas de nombre pour Nano Banana 2.1. Elle explique comment fonctionnent les limites et vous renvoie vers Google AI Studio pour les chiffres qui s'appliquent à votre projet et à votre niveau.

Ce que la page indique :

- **Dimensions.** Requêtes par minute (RPM), tokens d'entrée par minute (TPM) et requêtes par jour (RPD) ; les modèles de génération d'images ont également des images par minute (IPM). Dépasser l'une de ces dimensions déclenche une erreur.
- **Portée.** Les limites s'appliquent par projet, et non par clé API, et les quotas quotidiens sont réinitialisés à minuit, heure du Pacifique.
- **Niveaux.** L'offre gratuite nécessite un projet actif, le niveau 1 un compte de facturation lié, le niveau 2 $100 de dépenses payantes cumulées plus 3 jours, et le niveau 3 $1,000 plus 30 jours. Les mises à niveau sont automatiques.
- **Plafonds de dépenses.** Les limites basées sur les dépenses s'appliquent sur une fenêtre glissante de 10 minutes, et atteindre l'une d'elles renvoie une erreur `429 RESOURCE_EXHAUSTED`.

Une boucle qui envoie de nombreuses requêtes parallèles peut atteindre un 429 bien avant que le quota quotidien ne soit utilisé, donc ajoutez une nouvelle tentative avec backoff, limitez la concurrence et envoyez les gros travaux hors ligne via le Batch API.

La page du modèle indique également 131,072 tokens d'entrée et 32,768 tokens de sortie, et ne prend pas en charge l'inférence Flex ou Priority.

## Batch API pour Nano Banana 2.1

Pour la Nano Banana 2.1 API, la page du modèle indique que la Batch API est prise en charge, et la page de tarifs de Google facture la sortie d'images par lots à la moitié du tarif standard : $0.0168 par image 1K, $0.0252 par image 2K et $0.0567 par image 4K. Le guide de la Batch API fixe le délai de traitement cible à 24 heures, même si dans la plupart des cas il est bien plus court. Le compromis est un temps d'attente contre un prix et des limites de débit plus élevées, ce qui convient aux rafraîchissements de catalogue, aux tests de prompts et aux variations en masse plutôt qu'à une interface où une personne attend.

Détails du guide de la Batch API : les requêtes inline doivent totaliser moins de 20 MB, tandis que les tâches plus volumineuses utilisent un fichier JSONL (jusqu'à 2 GB) avec une requête par ligne et une `key` que vous définissez. Les tâches passent par `JOB_STATE_PENDING`, `JOB_STATE_RUNNING` et `JOB_STATE_SUCCEEDED`, ou se terminent en échec, en annulation ou `JOB_STATE_EXPIRED` ; une tâche en attente ou en cours depuis plus de 48 heures expire. La page des limites de débit indique 100 requêtes par lots simultanées et 20 GB de stockage de fichiers, plus des limites de tokens en file d'attente par niveau.

Un piège : le guide indique que le traitement par lots n'est disponible qu'avec l'API `generateContent`, et ses exemples d'images utilisent `responseModalities` défini sur `["TEXT", "IMAGE"]` avec un autre ID de modèle Nano Banana. Il n'a pas d'exemple pour `gemini-nano-banana-2.1`, donc lancez un petit lot de test avec cet ID de modèle avant de soumettre des milliers de requêtes. En pratique, l'édition interactive s'exécute sur l'API Interactions et la génération hors ligne en masse s'exécute sur des lots `generateContent`.

## Migrer vers Nano Banana 2.1 depuis les modèles précédents

La page de tarifs de Google classe le Nano Banana original, `gemini-2.5-flash-image`, comme obsolète avec une date d'arrêt au 2 octobre 2026, et le guide de génération d'images recommande Nano Banana 2.1 pour les nouveaux projets.

Vérifiez ces différences lorsque vous changez l'ID de modèle. 2.1 propose les niveaux de thinking `minimal`, `medium` et `high`, tandis que 3.1 Flash Image propose `minimal` et `high`. Le format 512px existe sur 3.1 Flash Image mais pas sur 2.1 ; demandez donc du 1K et redimensionnez de votre côté. Le grounding Image Search fonctionne sur 2.1 et 3.1 Flash Image, et Flash Lite n'a pas de grounding de recherche. 2.1 ne prend pas en charge l'appel de fonctions ni les sorties structurées ; déplacez donc toute étape produisant du JSON vers un modèle texte. Recalculez votre estimation de coût avec les tarifs 2.1 ci-dessus, puis exécutez vos prompts enregistrés avec le nouveau modèle et comparez les résultats avec les anciens, car un changement de modèle modifie le style et le rendu du texte même avec des prompts identiques.

## Utiliser Nano Banana 2.1 sans l'API

Si votre objectif est une image plutôt qu'une intégration, le navigateur est plus simple. Le [Générateur d'image IA](/fr/ai-image-generator) de Potto propose Nano Banana 2.1 avec une sortie HD, 2K et 4K, jusqu'à 10 images de référence et des fichiers PNG ou JPEG. Comme Potto n'a pas d'API publique, il s'agit uniquement d'un flux web.

Potto facture les images en crédits, affichés sur le bouton Generate avant confirmation. Nano Banana 2.1 coûte 12 crédits par image en HD, 17 en 2K et 38 en 4K, et une requête échouée libère ses crédits. Les crédits sont l'unité propre à Potto, pas une conversion des prix en dollars de Google, donc ne comparez pas les deux comme s'il s'agissait de la même devise. La page [Potto AI tarifs](/fr/pricing) liste les offres, et la page [Modèles d'IA](/fr/ai-models) compare chaque modèle d'image du créateur, y compris Nano Banana et Nano Banana Pro.

Les flux de travail reflètent l'API : [Text to image](/fr/text-to-image) est une requête avec uniquement un élément texte, [Image to image](/fr/image-to-image) ajoute votre propre image comme un élément image dans `input`, le générateur de personnages IA cible des personnages récurrents, et les modèles d'images vous donnent un brief à adapter.

![Nano Banana 2.1 API ou générateur web : une route code et une route navigateur qui mènent toutes deux au même type d'image](https://potto.ai/blog/nano-banana-2-1-api/fr/nano-banana-2-1-api-vs-web-generator.webp#1200x675)

## API ou générateur web : que choisir ?

Utilisez l'API Gemini lorsque les images sont produites au sein de votre propre produit ou selon un calendrier : une boutique en ligne qui génère une variation pour chaque fiche produit, une tâche nocturne aux tarifs par lots, ou une application où les utilisateurs saisissent un prompt. Vous possédez les clés, les tentatives de relance, le stockage et la facture, et vous obtenez l'ensemble complet des paramètres de Google.

Utilisez le générateur web lorsqu'une personne crée les images : une affiche de campagne, des photos de produits, une mascotte pour une présentation. Il n'y a pas de clé à gérer ni de réponse à analyser, et le prix s'affiche avant chaque génération. Vous pouvez également explorer un prompt dans le navigateur et transférer la formulation gagnante dans un appel API plus tard.

## FAQ

### Qu'est-ce que la Nano Banana 2.1 API ?

La Nano Banana 2.1 API permet d'appeler le modèle d'image `gemini-nano-banana-2.1` de Google via l'API Gemini. Elle accepte en entrée du texte, des images, de la vidéo ou des PDF, renvoie des images et du texte, et prend en charge une sortie en 1K, 2K et 4K, jusqu'à 14 images de référence, un paramètre thinking configurable et le grounding Google Search. Ce n'est pas un produit distinct : vous utilisez une clé API Gemini et indiquez l'ID de modèle dans votre requête.

### Quel est l'ID de modèle de Nano Banana 2.1 ?

L'ID de modèle est `gemini-nano-banana-2.1`. La page de modèle de Google indique que la version stable utilise le même ID, donc aucun suffixe de version n'est nécessaire. Les autres modèles Nano Banana ont leurs propres ID, comme `gemini-3.1-flash-image` pour Nano Banana 2 ; vérifiez donc l'ID chaque fois que vous changez de modèle.

### Combien coûte la Nano Banana 2.1 API ?

Aux tarifs standard, Google facture $0.0336 par image 1K, $0.0504 par image 2K et $0.113 par image 4K, plus des frais de tokens pour l'entrée et le thinking. Les jobs Batch coûtent moitié prix : $0.0168, $0.0252 et $0.0567. Ce sont les chiffres de la page de tarifs de l'API Gemini de Google, consultés le 2026-10-10, et l'offre gratuite est indiquée comme non disponible pour ce modèle.

### Combien d'images de référence Nano Banana 2.1 peut-il utiliser ?

Jusqu'à 14 dans une même requête : jusqu'à 10 images d'objet et jusqu'à 4 images de personnage. Google compte le total toutes catégories confondues, donc une requête ne peut pas dépasser 14 même si les deux limites sont utilisées. Donnez à chaque référence un rôle précis dans le prompt et vérifiez dans le résultat les détails qui vous importent.

### Potto propose-t-il une Nano Banana 2.1 API ?

Non. Potto ne propose pas d'API publique. Vous pouvez utiliser Nano Banana 2.1 dans le générateur web de Potto à 12 crédits par image en HD, 17 en 2K et 38 en 4K. Les développeurs qui souhaitent appeler le modèle depuis du code doivent utiliser l'API Gemini de Google avec l'ID de modèle `gemini-nano-banana-2.1`.

### Quelles sont les limites de débit de la Nano Banana 2.1 API ?

Google ne publie pas de chiffre pour ce modèle sur sa page des limites de débit. Les limites sont mesurées en requêtes par minute, tokens d'entrée par minute, requêtes par jour et, pour les modèles d'image, en images par minute ; elles s'appliquent par projet et dépendent de votre niveau d'utilisation. Ouvrez la vue des limites de débit dans Google AI Studio pour connaître les chiffres qui s'appliquent à votre compte.

### Peut-on utiliser la Batch API avec Nano Banana 2.1 ?

Oui. Google indique que la Batch API est prise en charge sur la page du modèle et facture les images en batch à la moitié du tarif standard, avec un délai de traitement cible de 24 heures. Le traitement par lots n'est disponible qu'avec l'API `generateContent`, pas avec l'API Interactions, et les exemples d'images par lots de Google utilisent un autre ID de modèle Nano Banana ; testez donc d'abord un petit lot avec `gemini-nano-banana-2.1`.

## Sources

Toutes les sources ont été consultées le 2026-10-10. Les prix, les limites et les détails des modèles sont ceux de Google et peuvent changer.

- [Page du modèle Gemini Nano Banana 2.1](https://ai.google.dev/gemini-api/docs/models/gemini-nano-banana-2.1), Google AI for Developers.
- [Génération d'images avec Gemini (Nano Banana)](https://ai.google.dev/gemini-api/docs/image-generation), Google AI for Developers.
- [Tarifs de la Gemini Developer API](https://ai.google.dev/gemini-api/docs/pricing), Google AI for Developers.
- [Limites de débit de la Gemini API](https://ai.google.dev/gemini-api/docs/rate-limits), Google AI for Developers.
- [Batch API](https://ai.google.dev/gemini-api/docs/batch-api), Google AI for Developers.
- [Présentation de l'Interactions API](https://ai.google.dev/gemini-api/docs/interactions), Google AI for Developers.