---
title: "Nano Banana 2.1 API: model ID, prezzi, risoluzioni e limiti"
description: "Fatti sulla Nano Banana 2.1 API dai doc Google: model ID gemini-nano-banana-2.1, campi della richiesta, 1K/2K/4K, 14 referenze, prezzi e limiti."
robots: "index, follow"
canonical: "https://potto.ai/it/blog/nano-banana-2-1-api"
markdown: "https://potto.ai/it/blog/nano-banana-2-1-api.md"
author: "Potto AI Team"
category: "AI images"
datePublished: "2026-10-11T00:00:00.000Z"
language: "it"
dateModified: "2026-10-12T10:46:16.575Z"
---

# Nano Banana 2.1 API: model ID, prezzi, risoluzioni e limiti

La Nano Banana 2.1 API è il modello `gemini-nano-banana-2.1` dell'API Gemini di Google, un modello di generazione immagini e editing conversazionale ad alta efficienza che puoi chiamare con un prompt testuale e, facoltativamente, immagini di riferimento. Secondo la [pagina del modello Nano Banana 2.1](https://ai.google.dev/gemini-api/docs/models/gemini-nano-banana-2.1) di Google, restituisce immagini 1K (predefinito), 2K o 4K, accetta fino a 14 immagini di riferimento (fino a 10 oggetti e fino a 4 personaggi) e ha livelli di thinking configurabili. Il prezzo standard di Google è $0.0336 per immagine 1K, $0.0504 per immagine 2K e $0.113 per immagine 4K, e i job batch hanno un prezzo pari alla metà.

Questa guida raccoglie in un unico posto i fatti utili all'integrazione: il model ID, quale endpoint chiamare, i campi della richiesta che contano, le dimensioni di output, gli slot per le immagini di riferimento, i prezzi, i limiti di frequenza e i job batch. Ogni numero proviene dalla documentazione ufficiale di Google, consultata il 2026-10-10. I prezzi e i limiti cambiano, quindi verificali sulle pagine di Google prima di definire il budget o lanciare.

Potto non offre un'API pubblica. Per chiamare il modello dal tuo codice, usa direttamente l'API Gemini di Google. Se vuoi solo le immagini, la pagina [Nano Banana 2.1](/it/nano-banana-2-1) nel generatore web di Potto ti consente di creare e modificare con lo stesso modello senza scrivere una richiesta.

## Nano Banana 2.1 API in sintesi

| Voce | Cosa dice la documentazione di Google |
| --- | --- |
| model ID | `gemini-nano-banana-2.1` (la versione stabile usa lo stesso ID) |
| Input | Testo, immagine, video e PDF |
| Output | Immagine e testo |
| Risoluzioni di output | 1K (predefinito), 2K, 4K; 512px non è supportato su 2.1 |
| Immagini di riferimento | Fino a 14 in totale: fino a 10 oggetti e fino a 4 personaggi |
| livelli di thinking | `minimal`, `medium` (predefinito), `high` |
| grounding | Ricerca web e immagini di Google |
| Batch API | Supportata |
| Non supportata | Chiamata di funzioni, output strutturati, caching, esecuzione di codice, contesto URL, grounding di Maps, Live API, generazione audio |
| piano gratuito | Non disponibile |
| Prezzo standard per immagine | $0.0336 (1K), $0.0504 (2K), $0.113 (4K) |
| Prezzo batch per immagine | $0.0168 (1K), $0.0252 (2K), $0.0567 (4K) |

Fonti: pagina del modello di Google (ultimo aggiornamento 2026-10-06 UTC) e pagina dei prezzi, consultate il 2026-10-10.

![Flusso di una richiesta tramite Nano Banana 2.1 API: un prompt e immagini di riferimento arrivano al modello Gemini API e viene restituita un'immagine](https://potto.ai/blog/nano-banana-2-1-api/it/nano-banana-2-1-api-request-flow.webp#1200x675)

## Che cos'è la Nano Banana 2.1 API?

"Nano Banana" è il nome popolare dei modelli di generazione e modifica di immagini di Google della famiglia Gemini, e la "Nano Banana 2.1 API" è semplicemente il modo per raggiungerne uno dal codice. Non c'è un prodotto separato a cui registrarsi: usi una chiave API di Gemini e indichi il model ID nella richiesta. La guida alla generazione di immagini di Google elenca cinque modelli con il nome Nano Banana, ciascuno con il proprio ID:

| Nome | Model ID |
| --- | --- |
| 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` |

La guida di Google definisce 2.1 il modello principale ad alta efficienza per la generazione di immagini e la modifica conversazionale, e lo consiglia per tutti i nuovi progetti. Per un confronto con il modello Pro, leggi la guida [Nano Banana 2.1 vs Nano Banana Pro](/it/blog/nano-banana-2-1-vs-nano-banana-pro); questo articolo resta sull'integrazione di 2.1.

Google elenca una migliore qualità visiva e realismo a 1K, 2K e 4K, artefatti di tassellatura risolti su proporzioni ampie e panoramiche (1:4, 4:1, 1:8 e 8:1) a 2K e 4K, rendering del testo e accuratezza del layout delle infografiche migliorati, e grounding con Google Web e Image Search. La documentazione non pubblica punteggi di benchmark, quindi prova i tuoi prompt prima di affidare una pipeline al modello.

## Quale endpoint conviene chiamare?

Chiama l'Interactions API. La guida di Google alla generazione di immagini la usa per ogni esempio della Nano Banana 2.1 API: una `POST` a `https://generativelanguage.googleapis.com/v1beta/interactions` con la tua chiave in un header `x-goog-api-key`. La panoramica dell'Interactions API di Google afferma che, a partire da giugno 2026, è disponibile a livello generale e consigliata per tutti i nuovi progetti, e che tutti i nuovi modelli, strumenti e funzionalità agentiche saranno lanciati lì. La precedente API `generateContent` è descritta come legacy ma resta pienamente supportata.

Le chiamate SDK (`client.interactions.create`) richiedono `google-genai` o `@google/genai` versione 2.3.0 o successiva. La panoramica elenca inoltre la Batch API, la cache esplicita e le impostazioni di sicurezza personalizzate come non ancora disponibili su Interactions, quindi i prezzi batch implicano l'uso di `generateContent`, come spiegato nella sezione relativa al batch.

## Invia la tua prima richiesta alla Nano Banana 2.1 API

La richiesta più semplice indica il modello e passa il prompt come elemento di testo. La guida di Google mostra questa chiamata 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"}
    ]
  }'
```

Per scegliere la forma del risultato, aggiungi un oggetto `response_format`. Gli stessi campi compaiono nell'esempio Python di Google, dove l'output viene letto da `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"}
  }'
```

I campi in linguaggio semplice:

| Campo | Cosa fa |
| --- | --- |
| `input` | Il prompt come elementi `{"type": "text", "text": ...}`, più elementi `{"type": "image", ...}` per le immagini di riferimento |
| `response_format.mime_type` | `image/jpeg` o `image/png` negli esempi di Google |
| `response_format.aspect_ratio` | Ad esempio `1:1`, `5:4` o `16:9` negli esempi di Google |
| `response_format.image_size` | `1K`, `2K` o `4K`, con la K maiuscola |
| `generation_config.thinking_level` | `minimal`, `medium` o `high` |
| `previous_interaction_id` | Continua un'interazione precedente per la modifica multi-turn |

Negli esempi SDK l'immagine arriva codificata in base64 in `interaction.output_image.data`, e l'esempio Python la decodifica con `base64.b64decode` prima di scrivere il file. L'interazione contiene anche `steps`, che possono includere passaggi di pensiero e il `model_output` finale. L'esempio REST di Google non stampa un corpo di risposta, quindi esamina una risposta reale prima di scrivere un parser per il JSON non elaborato.

## Dimensioni di output della Nano Banana 2.1 API: 1K, 2K e 4K

Nano Banana 2.1 produce tre dimensioni di output: 1K, 2K e 4K, con 1K come predefinita quando non imposti `image_size`. La pagina dei prezzi di Google elenca i token immagine consumati da ogni dimensione: 1,120 per un'immagine 1K, 1,680 per 2K e 3,780 per 4K.

![Dimensioni di output di Nano Banana 2.1 a 1K, 2K e 4K mostrate come tre cornici annidate](https://potto.ai/blog/nano-banana-2-1-api/it/nano-banana-2-1-output-sizes.webp#1200x675)

Regole dalla guida alla generazione di immagini che causano errori reali:

- **Solo K maiuscola.** Valori in minuscolo come `1k` vengono rifiutati.
- **Nessun 512px su 2.1.** La dimensione più piccola 512px (0.5K) appartiene a Gemini 3.1 Flash Image, non a Nano Banana 2.1.
- **Proporzioni.** Gli esempi di 2.1 usano `1:1`, `5:4` e `16:9`. La pagina del modello di Google indica `1:4`, `4:1`, `1:8` e `8:1` come proporzioni wide e panoramiche in cui gli artefatti di tiling sono stati corretti a 2K e 4K. Le pagine consultate per questa guida non riportano un elenco completo di proporzioni per 2.1, quindi testa la proporzione esatta di cui hai bisogno prima di costruire un layout su di essa.
- **Dimensioni in pixel.** La guida di Google non pubblica una tabella in pixel per 2.1, quindi misura il file restituito se il tuo layout richiede dimensioni fisse.

Ogni immagine generata dagli strumenti di Google include un watermark SynthID, secondo la guida. Tienine conto se post-processi o ritagli gli output.

Ottimizza i prompt a 1K, perché una dimensione più grande non corregge una composizione debole o una parola scritta male. Se hai già un'immagine che va bene e ti servono solo più pixel, l'[image upscaler](/it/image-upscaler) la ingrandisce senza una nuova generazione.

## Immagini di riferimento: fino a 14 per richiesta

Nano Banana 2.1 accetta fino a 14 immagini di riferimento in una richiesta, e il conteggio è un totale tra i tipi. La guida di Google suddivide gli slot per modello:

| Tipo di riferimento | Nano Banana 2.1 |
| --- | --- |
| Oggetti (alta fedeltà nell'immagine finale) | Fino a 10 |
| Personaggi (coerenza tra le immagini) | Fino a 4 |
| Totale | Fino a 14 |

Ogni riferimento è un altro elemento nella lista `input`. Nell'esempio Python di Google, un elemento immagine contiene `"type": "image"`, i byte dell'immagine come base64 in `data`, e un `mime_type` come `image/png`, posizionato accanto all'elemento di testo che contiene il prompt.

![Nano Banana 2.1 accetta fino a 14 immagini di riferimento, mostrate come una griglia di riferimenti di oggetti e personaggi](https://potto.ai/blog/nano-banana-2-1-api/it/nano-banana-2-1-reference-images.webp#1200x675)

Uso pratico degli slot: assegna a ogni immagine un compito e indicalo nel prompt (la prima immagine è la forma del prodotto, la seconda la palette); riutilizza la stessa immagine del personaggio per un volto ricorrente; e aggiungi i riferimenti uno alla volta, perché più riferimenti non garantiscono che ogni dettaglio sopravviva.

## Impostazioni di thinking e grounding

Nano Banana 2.1 supporta tre livelli di thinking, impostati con `generation_config.thinking_level`: `minimal`, `medium` (predefinito) e `high`. La guida di Google afferma che il thinking è attivo per impostazione predefinita per i modelli immagine Gemini 3 e non può essere disabilitato tramite l'API, che il modello può produrre fino a due immagini di pensiero intermedie e che i token di thinking vengono fatturati per impostazione predefinita. Altri modelli Nano Banana elencano livelli diversi (Nano Banana 2 elenca `minimal` e `high`), quindi non copiare un'impostazione da un modello all'altro.

Il grounding consente al modello di usare Google Search per argomenti sensibili al tempo. Nell'Interactions API si aggiunge `tools` con `google_search`, e `search_types` di `["web_search", "image_search"]` richiede risultati web e immagini; il grounding di Image Search è disponibile solo su Nano Banana 2.1 e Gemini 3.1 Flash Image. Google osserva che i risultati di Image Search devono essere mostrati con i loro `search_suggestions`, quindi integra quella visualizzazione nella tua interfaccia.

Il grounding viene fatturato separatamente: la pagina dei prezzi di Google prevede 5,000 richieste di ricerca gratuite al mese, condivise tra Gemini 3 e i modelli più recenti, poi $14 per 1,000 richieste. Verifica nomi, cifre o date in un'immagine con grounding prima di pubblicarla.

## Editing multi-turn con previous_interaction_id

Per modificare un'immagine che hai già generato con la Nano Banana 2.1 API, invia una seconda richiesta con `previous_interaction_id` impostato sull'`id` della prima interazione e descrivi solo la modifica. L'esempio di Google traduce il testo di un'infografica in spagnolo lasciando invariati gli altri elementi. Secondo la panoramica dell'Interactions API, `generation_config`, `tools` e `system_instruction` sono limitati a una singola interazione, quindi impostali di nuovo a ogni turno; inoltre, impostare `store` su `false` ti impedisce di usare `previous_interaction_id`. Per le modifiche in cui vuoi dipingere manualmente su una regione, l'[AI photo editor](/it/ai-image-editor) è più semplice che descriverla a parole.

## Prezzi della Nano Banana 2.1 API

Google fattura Nano Banana 2.1 in base ai token, e l'output delle immagini ha una tariffa propria. Questo è il listino standard (livello a pagamento) dalla pagina dei prezzi dell'API Gemini, consultato il 2026-10-10:

| Voce | Standard | Batch |
| --- | --- | --- |
| Input (testo, immagine, video) | $1.50 per 1M token | $0.75 per 1M token |
| Testo e thinking in output | $7.50 per 1M token | $3.75 per 1M token |
| Immagini in output | $30.00 per 1M token immagine | $15.00 per 1M token immagine |
| Un'immagine 1K | $0.0336 | $0.0168 |
| Un'immagine 2K | $0.0504 | $0.0252 |
| Un'immagine 4K | $0.113 | $0.0567 |
| Grounding con Google Search | 5,000 richieste gratuite al mese, poi $14 per 1,000 | Non indicato separatamente |

I prezzi per immagine sono la tariffa dei token immagine applicata ai conteggi di token nella sezione precedente: 1,120 token a $30 per milione fanno $0.0336. Il piano gratuito è indicato come non disponibile per questo modello, quindi ogni chiamata richiede un progetto con fatturazione.

Per dare un'idea, usando i prezzi di Google per il solo output delle immagini: 1,000 immagini costano $33.60 a 1K, $50.40 a 2K e $113.00 a 4K, oppure $25.20 a 2K come batch. I token di input (il tuo prompt e le eventuali immagini di riferimento), i token di thinking e le richieste di grounding vengono fatturati in aggiunta, quindi misura una esecuzione di esempio prima di impegnare un budget.

## Limiti di frequenza e quote

La pagina dei limiti di frequenza di Google non riporta un numero per Nano Banana 2.1. Spiega come funzionano i limiti e rimanda a Google AI Studio per i valori che si applicano al tuo progetto e al tuo livello.

Ecco cosa specifica invece la pagina:

- **Dimensioni.** Richieste al minuto (RPM), token di input al minuto (TPM) e richieste al giorno (RPD); i modelli che generano immagini hanno anche immagini al minuto (IPM). Superare una qualsiasi di queste dimensioni genera un errore.
- **Ambito.** I limiti si applicano per progetto, non per API key, e le quote giornaliere si azzerano a mezzanotte ora del Pacifico.
- **Livelli.** Il piano gratuito richiede un progetto attivo, il Tier 1 un account di fatturazione collegato, il Tier 2 $100 di spesa pagata cumulativa più 3 giorni, e il Tier 3 $1,000 più 30 giorni. Gli upgrade sono automatici.
- **Limiti di spesa.** I limiti basati sulla spesa si applicano su una finestra mobile di 10 minuti, e raggiungerne uno restituisce un errore `429 RESOURCE_EXHAUSTED`.

Un loop che invia molte richieste in parallelo può incontrare un 429 molto prima che la quota giornaliera venga utilizzata, quindi aggiungi retry con backoff, limita la concorrenza e invia i grandi job offline tramite la Batch API.

La pagina del modello elenca anche 131,072 token di input e 32,768 token di output, e non supporta l'inferenza Flex o Priority.

## Batch API per Nano Banana 2.1

La pagina del modello di Nano Banana 2.1 API elenca la Batch API come supportata, e la pagina dei prezzi di Google fissa l'output immagini batch a metà della tariffa standard: $0.0168 per 1K immagini, $0.0252 per 2K immagini e $0.0567 per 4K immagini. La guida alla Batch API indica un tempo di elaborazione target di 24 ore, anche se nella maggior parte dei casi è molto più breve. Il compromesso è tempo di attesa in cambio di prezzo e limiti di frequenza più alti, adatto ad aggiornamenti del catalogo, test di prompt e varianti in blocco più che a un'interfaccia in cui una persona è in attesa. Dettagli dalla guida alla Batch API: le richieste inline devono avere un totale inferiore a 20 MB, mentre i job più grandi usano un file JSONL (fino a 2 GB) con una richiesta per riga e una `key` definita da te. I job passano attraverso `JOB_STATE_PENDING`, `JOB_STATE_RUNNING` e `JOB_STATE_SUCCEEDED`, oppure terminano come non riusciti, annullati o `JOB_STATE_EXPIRED`; un job in attesa o in esecuzione per più di 48 ore scade. La pagina dei limiti di frequenza elenca 100 richieste batch concorrenti e 20 GB di spazio di archiviazione file, più limiti di token in coda per livello. Un punto critico: la guida afferma che l'elaborazione batch è disponibile solo con l'API `generateContent`, e i suoi esempi di immagini usano `responseModalities` impostato su `["TEXT", "IMAGE"]` con un diverso model ID di Nano Banana. Non contiene alcun esempio per `gemini-nano-banana-2.1`, quindi esegui un piccolo batch di test con questo model ID prima di inviare migliaia di richieste. In pratica, la modifica interattiva viene eseguita sull'Interactions API e la generazione offline in blocco viene eseguita su batch `generateContent`.

## Migrare a Nano Banana 2.1 dai modelli precedenti

La pagina prezzi di Google contrassegna la versione originale di Nano Banana, `gemini-2.5-flash-image`, come deprecata con data di dismissione il 2 ottobre 2026, e la guida alla generazione di immagini consiglia Nano Banana 2.1 per i nuovi progetti.

Controlla queste differenze quando cambi il model ID per passare a Nano Banana 2.1 API. La 2.1 elenca i livelli di thinking `minimal`, `medium` e `high`, mentre 3.1 Flash Image elenca `minimal` e `high`. La dimensione 512px esiste su 3.1 Flash Image ma non su 2.1, quindi richiedi 1K e ridimensiona dalla tua parte. Il grounding di Image Search funziona su 2.1 e 3.1 Flash Image, e Flash Lite non ha grounding di ricerca. La 2.1 non supporta function calling o output strutturati, quindi sposta qualsiasi passaggio che produce JSON a un modello di testo. Ricalcola la tua stima dei costi con le tariffe 2.1 sopra, poi esegui i prompt salvati con il nuovo modello e confronta i risultati con quelli vecchi, perché un cambio di modello modifica stile e rendering del testo anche con prompt identici.

## Usare Nano Banana 2.1 senza API

Se il tuo obiettivo è un'immagine e non un'integrazione, il browser è più semplice. L'[AI image generator](/it/ai-image-generator) di Potto offre Nano Banana 2.1 con output HD, 2K e 4K, fino a 10 immagini di riferimento e file PNG o JPEG. Poiché Potto non ha un'API pubblica, si tratta solo di un flusso di lavoro web.

Potto prezza le immagini in crediti, mostrati sul pulsante Generate prima della conferma. Nano Banana 2.1 costa 12 crediti per immagine in HD, 17 in 2K e 38 in 4K, e una richiesta non riuscita rilascia i suoi crediti. I crediti sono un'unità propria di Potto, non una conversione dei prezzi in dollari di Google, quindi non confrontare i due come se fossero la stessa valuta. La pagina [Potto AI prezzi](/it/pricing) elenca i piani, e la pagina [Modelli AI per immagini](/it/ai-models) confronta ogni modello di immagini nel creator, inclusi Nano Banana e Nano Banana Pro.

I flussi di lavoro rispecchiano l'API: [Text to image](/it/text-to-image) è una richiesta con solo un elemento di testo, [Image to image](/it/image-to-image) aggiunge la tua immagine come elemento immagine in `input`, il generatore di personaggi AI è pensato per personaggi ricorrenti, e i template di immagini ti forniscono un brief da adattare.

![Nano Banana 2.1 API o generatore web: un percorso via codice e un percorso via browser che portano allo stesso tipo di immagine](https://potto.ai/blog/nano-banana-2-1-api/it/nano-banana-2-1-api-vs-web-generator.webp#1200x675)

## Nano Banana 2.1 API o generatore web: quale scegliere?

Usa la Gemini API quando le immagini vengono prodotte all'interno del tuo prodotto o secondo una pianificazione: una vetrina che genera una variazione per ogni annuncio, un processo notturno a tariffe batch, o un'app in cui gli utenti digitano un prompt. Le chiavi, i retry, l'archiviazione e la fatturazione sono a tuo carico, e ottieni il set completo di parametri di Google.

Usa il generatore web quando è una persona a creare le immagini: un poster per una campagna, scatti di prodotto, una mascotte per una presentazione. Non c'è nessuna chiave da gestire né risposta da analizzare, e il prezzo viene mostrato prima di ogni generazione. Puoi anche esplorare un prompt nel browser e spostare la formulazione vincente in una chiamata API in un secondo momento.

## FAQ

### Che cos'è la Nano Banana 2.1 API?

La Nano Banana 2.1 API è il modo per chiamare il modello di immagini `gemini-nano-banana-2.1` di Google tramite la Gemini API. Accetta input di testo, immagini, video o PDF, restituisce immagini e testo e supporta dimensioni di output 1K, 2K e 4K, fino a 14 immagini di riferimento, thinking configurabile e grounding con Google Search. Non è un prodotto separato: usi una chiave della Gemini API e indichi il model ID nella tua richiesta.

### Qual è il model ID di Nano Banana 2.1?

Il model ID è `gemini-nano-banana-2.1`. La pagina del modello di Google indica che la versione stabile usa lo stesso ID, quindi non serve alcun suffisso di versione. Altri modelli Nano Banana hanno ID propri, come `gemini-3.1-flash-image` per Nano Banana 2, quindi controlla l'ID ogni volta che cambi modello.

### Quanto costa la Nano Banana 2.1 API?

Ai prezzi standard, Google applica $0.0336 per immagine 1K, $0.0504 per immagine 2K e $0.113 per immagine 4K, più costi in token per input e thinking. I job batch costano la metà: $0.0168, $0.0252 e $0.0567. Sono cifre dalla pagina dei prezzi della Gemini API di Google lette il 2026-10-10, e il piano gratuito è indicato come non disponibile per questo modello.

### Quante immagini di riferimento può usare Nano Banana 2.1?

Fino a 14 in una richiesta: fino a 10 immagini di oggetti e fino a 4 immagini di personaggi. Google conta il totale tra i tipi, quindi una richiesta non può superare 14 anche se entrambi i limiti vengono usati. Assegna a ogni riferimento un compito nel prompt e controlla nel risultato i dettagli che ti interessano.

### Potto ha una Nano Banana 2.1 API?

No. Potto non offre un'API pubblica. Puoi usare Nano Banana 2.1 nel generatore web di Potto a 12 crediti per immagine in HD, 17 in 2K e 38 in 4K. Gli sviluppatori che vogliono chiamare il modello dal codice dovrebbero usare la Gemini API di Google con il model ID `gemini-nano-banana-2.1`.

### Quali sono i limiti di frequenza della Nano Banana 2.1 API?

Google non pubblica un numero per questo modello sulla sua pagina dei limiti di frequenza. I limiti sono misurati in richieste al minuto, token di input al minuto, richieste al giorno e, per i modelli di immagini, immagini al minuto, e si applicano per progetto e dipendono dal tuo livello di utilizzo. Apri la vista dei limiti di frequenza in Google AI Studio per le cifre che si applicano al tuo account.

### Posso usare la Batch API con Nano Banana 2.1?

Sì. Google elenca la Batch API come supportata nella pagina del modello e applica alle immagini batch un prezzo pari alla metà della tariffa standard, con un tempo di elaborazione target di 24 ore. L'elaborazione batch è disponibile solo con l'API `generateContent`, non con l'Interactions API, e gli esempi batch di immagini di Google usano un model ID Nano Banana diverso, quindi prova prima un piccolo batch con `gemini-nano-banana-2.1`.

## Fonti

Tutte le fonti sono state consultate il 2026-10-10. Prezzi, limiti e dettagli dei modelli sono di Google e possono cambiare.

- [Pagina del modello Gemini Nano Banana 2.1](https://ai.google.dev/gemini-api/docs/models/gemini-nano-banana-2.1), Google AI for Developers.
- [Generazione di immagini con Gemini (Nano Banana)](https://ai.google.dev/gemini-api/docs/image-generation), Google AI for Developers.
- [Prezzi della Gemini Developer API](https://ai.google.dev/gemini-api/docs/pricing), Google AI for Developers.
- [Limiti di frequenza della 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.
- [Panoramica della Interactions API](https://ai.google.dev/gemini-api/docs/interactions), Google AI for Developers.