Provare a far scrivere “È GIÀ QUI” dentro un’immagine generata dall’AI, fino a poco tempo fa, voleva dire ritrovarsi una E maiuscola nuda, un accento sparato dalla parte sbagliata o una lettera inventata in mezzo alla parola. Per chi scrive in italiano era il motivo numero uno per rinunciare e aprire un editor grafico.
Adesso funziona. Ho generato 19 copertine con Nano Banana e con gpt-image-2 di OpenAI, tutte con testo italiano pieno di accenti, e il testo è uscito giusto in tutte e 19. Sette secondi e quattro centesimi l’una.
Qui sotto trovi cosa riesce a fare davvero, quanto costa in soldi veri, i prompt che ho usato pronti da copiare, le tre cose che continuano a non funzionare e, in fondo, uno script gratis per chi vuole automatizzare la cosa.
Cosa riesce a fare Nano Banana con il testo in italiano
In breve: scrive correttamente titoli, sottotitoli e indirizzi in italiano, accenti compresi. Nelle mie 19 immagini non ho trovato un solo refuso.
Ho alzato l’asticella apposta. In una sola copertina ho chiesto quattro parole accentate diverse (NOVITÀ, È, GIÀ e due volte “più”), un titolo su due righe e un indirizzo web con slash e trattino. Sono le cose che di solito i generatori si mangiano. Non è successo.
Il punto delicato è il testo piccolo in fondo, quello che a schermo pieno nessuno guarda davvero. Prima di pubblicare ingrandiscilo e rileggilo carattere per carattere: è lì che scappa un accento sbagliato o un apostrofo storto, e a dimensione piena non te ne accorgi.
Se la tua idea dei generatori di immagini è ferma a un paio d’anni fa, è quella l’informazione da aggiornare. Il salto era già visibile con Nano Banana Pro, la versione grossa. La novità è che ora regge anche la versione veloce, quella che costa pochi centesimi.
Quanto costa fare un’immagine con Nano Banana
Numeri chiari, senza giri di parole.
| Nano Banana (versione veloce) | gpt-image-2 (qualità alta) | |
|---|---|---|
| Costo per immagine | circa 4 centesimi di dollaro | circa 15-19 centesimi |
| Tempo per immagine | circa 7 secondi | poco più di 2 minuti |
| Dieci copertine | meno di mezzo euro | circa un euro e mezzo |
| Testo italiano corretto | sempre, nel mio test | sempre, nel mio test |
| Riproduce il tuo font | no | no |
Dieci copertine con Nano Banana ti costano meno di mezzo euro e te le fai in due minuti. Le stesse dieci con gpt-image-2 costano circa un euro e mezzo e ti tengono impegnato mezz’ora.
Una precisazione onesta: sono stime prese dai listini pubblici, non da una mia fattura. Il prezzo cambia con la risoluzione e con il livello di qualità che scegli, quindi prendile come ordine di grandezza. L’ordine di grandezza però è quello: parliamo di centesimi, non di euro.
Sulla qualità del testo i due sono pari. Sulla velocità no, e la differenza si sente: con Nano Banana provi cinque varianti mentre l’altro sta ancora facendo la prima. Se ti interessa il confronto sul versante OpenAI ne avevo scritto quando è uscito ChatGPT Images 2.0, e il quadro della famiglia Gemini è nel pezzo su Gemini 3.1 Pro.
I prompt pronti da copiare
Questi sono i prompt che ho usato davvero, quelli che hanno prodotto le immagini che vedi in questa pagina. Copiali, sostituisci il testo dentro le parentesi quadre con il tuo e lascia stare il resto: la parte noiosa in fondo è quella che fa la differenza fra un’immagine giusta e una da buttare.
Non serve niente di tecnico. Sono testo normale: li incolli nella chat di Gemini, di ChatGPT o di qualsiasi app che generi immagini.
Prompt 1: copertina con titolo e sottotitolo
Il caso base. Una copertina quadrata per un articolo o un post.
Crea un'immagine quadrata 1080x1080 per una copertina social.
Sfondo: quasi nero, con un alone di luce arancione dietro al centro.
Stile: pulito, moderno, molto contrastato, nessuna fotografia.
Scrivi ESATTAMENTE questo testo, in italiano:
Riga 1, titolo grande in maiuscolo: [OPUS 5]
Riga 2, titolo grande in maiuscolo: [È ARRIVATO]
Riga 3, sottotitolo piccolo: [stesso prezzo, il doppio del lavoro]
Riga 4, in fondo, piccola e arancione: [francescogruner.it]
Regole da rispettare:
- non tradurre e non riscrivere nessuna riga, copiale così come sono
- mantieni gli accenti italiani identici: È, à, è, ù, ò, ì
- il titolo sta su due righe, spezzato dove ti ho indicato
- lascia almeno 80 pixel di margine vuoto sui quattro lati
- niente testo in più, niente firme, niente watermarkPerché è fatto così. Il testo è elencato riga per riga, quindi il modello non deve indovinare dove va a capo. La frase “non tradurre e non riscrivere” serve davvero: senza, capita che ti ritraduca il sottotitolo in inglese o che lo accorci di testa sua. La richiesta esplicita sugli accenti gli dice che quei segni sono parte del testo, non un errore da correggere. Il margine chiesto in pixel evita che il titolo finisca appiccicato al bordo.
Prompt 2: copertina con il logo di un prodotto
Qui c’è la regola che vale più di tutte le altre messe insieme: se vuoi il logo giusto, allegalo. Scarica il file dal sito ufficiale del prodotto, dalla sua pagina stampa o dalla pagina del marchio, e caricalo insieme al prompt. Non descriverlo a parole.
Ti allego il simbolo del marchio come immagine di riferimento.
Crea un'immagine quadrata 1080x1080 per una copertina social.
Sfondo: quasi nero, con un alone di luce arancione dietro al centro.
Stile: pulito, moderno, molto contrastato, nessuna fotografia.
Usa il simbolo che ti ho allegato ESATTAMENTE com'è, in alto al centro,
sopra al titolo. Non ridisegnarlo, non cambiargli forma, non cambiare
il numero di punte, non aggiungere dettagli. Puoi solo ingrandirlo o
rimpicciolirlo.
Scrivi ESATTAMENTE questo testo, in italiano:
Riga 1, titolo grande in maiuscolo: [OPUS 5]
Riga 2, titolo grande in maiuscolo: [È ARRIVATO]
Riga 3, sottotitolo piccolo: [stesso prezzo, il doppio del lavoro]
Riga 4, in fondo, piccola e arancione: [francescogruner.it]
Regole da rispettare:
- non tradurre e non riscrivere nessuna riga, copiale così come sono
- mantieni gli accenti italiani identici: È, à, è, ù, ò, ì
- lascia almeno 80 pixel di margine vuoto sui quattro lati
- niente testo in più, niente firme, niente watermarkPerché è fatto così. La differenza fra un logo giusto e un logo inventato non sta nel modello che usi, sta nel fatto che tu gliel’abbia mostrato o no. Descritto a parole, il simbolo esce diverso a ogni tentativo. Allegato come immagine, esce quello vero.
Vale anche al contrario: se ti serve il logo della tua azienda, allegalo. E se ti serve identico al pixel, per esempio su materiali ufficiali, l’unica strada sicura resta metterlo sopra all’immagine con un editor. Una riproduzione fedele non è la stessa cosa di una copia esatta, e per un marchio registrato la differenza conta.
Prompt 3: testo lungo e accenti difficili
Quando serve un badge in alto, un titolo su due righe, un sottotitolo lungo e un indirizzo web completo. È il caso che rompeva sempre.
Crea un'immagine quadrata 1080x1080 per una copertina social.
Sfondo: quasi nero, con un alone di luce arancione dietro al centro.
Stile: pulito, moderno, molto contrastato, nessuna fotografia.
Scrivi ESATTAMENTE questo testo, in italiano, dall'alto verso il basso:
Badge in alto, dentro una pillola con il bordo arancione, in maiuscolo:
[NOVITÀ · 25 LUGLIO]
Riga 1, titolo molto grande in maiuscolo: [OPUS 5]
Riga 2, titolo molto grande in maiuscolo: [È GIÀ QUI]
Riga 3, sottotitolo su due righe: [più contesto, più autonomia,]
Riga 4, seguito del sottotitolo: [stesso prezzo di prima]
Riga 5, in fondo, piccola e arancione: [francescogruner.it/blog/opus-5]
Regole da rispettare:
- non tradurre e non riscrivere nessuna riga, copiale così come sono
- mantieni gli accenti italiani identici: NOVITÀ, È, GIÀ, più
- riporta l'indirizzo in fondo carattere per carattere, slash e trattino compresi
- lascia almeno 80 pixel di margine vuoto sui quattro lati
- lascia respiro fra il titolo e la riga sopra, l'accento della È non deve toccarla
- niente testo in più, niente firme, niente watermarkPerché è fatto così. Il sottotitolo è spezzato in due righe da te, non lasciato al caso. L’indirizzo web ha una regola tutta sua perché slash e trattini sono i caratteri che spariscono più spesso. E c’è una riga che chiede spazio sopra al titolo: serve contro il difetto più fastidioso che ho trovato, che ti spiego fra un attimo.
Le regole che fanno la differenza
Se dovessi ridurre tutto a un promemoria da tenere a mente, è questo.
- Elenca il testo riga per riga. Non scrivere “metti il titolo Opus 5 è arrivato con un sottotitolo”. Scrivi Riga 1, Riga 2, Riga 3. Il modello smette di improvvisare.
- Scrivi “non tradurre e non riscrivere”. Sembra superfluo, non lo è. È la frase che impedisce le sorprese in inglese e i tagli non richiesti.
- Chiedi gli accenti esplicitamente. Elencare È, à, ù, ò, ì nel prompt li tratta come contenuto e non come refusi da sistemare.
- Allega il logo, non descriverlo. Vale per il tuo e per quello di prodotti altrui, che va sempre preso dal sito ufficiale.
- Chiedi i margini in pixel. Non li rispetterà sempre, ma li rispetta molto più spesso di quando non glieli chiedi.
- Rigenera invece di litigare. Se il risultato non convince, non stare a riscrivere il prompt per mezz’ora: rilancialo uguale. Costa quattro centesimi e sette secondi, e ogni volta esce un’impaginazione diversa. Alla terza in genere ci sei.
Cosa aspettarti che non funzioni
La parte onesta, quella che negli entusiasmi non trovi mai.
1. L’impaginazione cambia a ogni tentativo
Lo stesso prompt, lanciato più volte, non ti restituisce mai la stessa impaginazione. Il testo è corretto in tutti, la disposizione no. Lo spazio ai lati che ho misurato oscilla quasi del doppio da un’immagine all’altra, anche quando il margine minimo è scritto nero su bianco nella richiesta. In due casi su sei il modello ha semplicemente ignorato il numero che gli avevo dato.
Per una copertina singola non è un problema: rigeneri e scegli. Per un carosello di otto slide che devono somigliarsi fra loro, lo è eccome.
2. L’accento della È che tocca la riga di sopra
Il difetto più subdolo, perché non è un errore di ortografia e quindi rileggendo il testo non lo becchi. Su un titolo grande, l’accento della È maiuscola sale tanto da sfiorare la riga superiore. Mi è capitato in metà delle immagini di una serie.
Rimedio: la riga che trovi nel terzo prompt, quella che chiede respiro sopra al titolo. Se non basta, rigenera.
3. Il tuo font non arriverà mai
Nessuna delle 19 immagini usa il carattere che avevo chiesto. Escono tutte con un carattere generico, pulito e anonimo.
Ha senso: il modello non ha il file del tuo carattere, sta disegnando forme che assomigliano a lettere. Se il tuo brand ha un font preciso e vuoi che si riconosca, per le serie conviene farti generare solo lo sfondo e mettere il testo sopra tu.
4. Il logo, se non glielo dai, se lo inventa
Lo hai visto nel confronto qui sopra. Non è cattiva volontà del modello: semplicemente non ha mai visto quel marchio. Allegarlo risolve, descriverlo no.
Dove usarle davvero
Casi in cui questa roba conviene già oggi, senza forzature.
- Copertine per articoli di blog. Una per pezzo, testo diverso ogni volta, nessun vincolo di coerenza stretta. È il caso perfetto.
- Post social singoli. Facebook, LinkedIn, Instagram. Quattro centesimi e sette secondi contro venti minuti su un editor.
- Miniature per i video. Titolo grosso, poche parole, alto contrasto: esattamente quello che questi strumenti fanno meglio.
- Immagini per la newsletter. Stesso discorso delle copertine.
Dove invece non conviene ancora: caroselli, serie e template che devono essere identici fra loro, e tutto ciò che porta un marchio registrato riprodotto al pixel. Lì il tempo che risparmi generando lo ributti via a sistemare.
Se vuoi automatizzarlo: lo script pronto
Se ti serve una copertina ogni tanto, i prompt qui sopra bastano e avanzano: fermati pure qui, il resto è per chi ne fa venti al mese.
Perché a quel punto aprire la chat, incollare il prompt, aspettare, scaricare e rinominare diventa il lavoro. Allora conviene un file che fa tutto da solo: cambi quattro righe di testo, lanci, e ti ritrovi la copertina nella cartella. È gratis, è un file solo, e usa la tua chiave: non passa da nessun servizio mio.
Il codice sta qui: github.com/francescogruner/copertina-ai. Si scarica e si usa liberamente, licenza MIT: puoi copiarlo, modificarlo e usarlo anche per lavoro.
# tutto il pacchetto, con guida e istruzioni per gli agenti
git clone https://github.com/francescogruner/copertina-ai
# oppure solo il file dello script, se ti basta quello
curl -O https://raw.githubusercontent.com/francescogruner/copertina-ai/main/copertina_ai.pyCosa ti serve
- Python 3 sul tuo computer. Su Mac e Linux c’è già installato. Su Windows si scarica da python.org.
- Una chiave di Google AI Studio, che è il modo per far parlare il tuo computer con Gemini. Si crea in due minuti su aistudio.google.com/apikey con un normale account Google. Le immagini poi le paghi a consumo, quei famosi quattro centesimi.
Nient’altro. Nessuna libreria da installare, nessun abbonamento, nessun account cloud.
Come si lancia, in 5 passi
- Salva il codice qui sotto in un file chiamato
copertina_ai.py. - Apri il Terminale (su Windows si chiama PowerShell) e incolla
export GEMINI_API_KEY="la-tua-chiave", mettendo la tua al posto di quella scritta. Su Windows la riga è$env:GEMINI_API_KEY="la-tua-chiave". - Apri il file con un editor di testo e cambia le righe del testo in cima: titolo, sottotitolo e riga in fondo. Se vuoi un logo, indica il percorso del file PNG nella riga
LOGO. - Lancia
python3 copertina_ai.py. - Dopo circa sette secondi trovi
copertina.pngnella stessa cartella. Se l’impaginazione non ti piace, rilancia lo stesso comando: esce diversa.
Lo script
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
copertina_ai.py: genera una copertina con testo in italiano usando Gemini.
Come si usa:
1. metti la tua chiave in GEMINI_API_KEY (la ottieni su aistudio.google.com)
2. cambia il testo qui sotto
3. lancia: python3 copertina_ai.py
Serve solo Python 3 (versione 3.8 o superiore). Nessuna libreria da installare.
"""
import base64
import json
import os
import sys
import urllib.error
import urllib.request
# --------------------------------------------------------------------------- #
# 1) LA TUA CHIAVE #
# --------------------------------------------------------------------------- #
# Consigliato: esportala come variabile d'ambiente prima di lanciare lo script.
# export GEMINI_API_KEY="la-tua-chiave"
# In alternativa incollala qui fra le virgolette (ma non pubblicare il file).
API_KEY = os.environ.get("GEMINI_API_KEY", "")
# --------------------------------------------------------------------------- #
# 2) IL TESTO DELLA COPERTINA #
# --------------------------------------------------------------------------- #
# Scrivilo con gli accenti giusti: lo script li protegge nel prompt.
TITOLO_RIGA_1 = "OPUS 5"
TITOLO_RIGA_2 = "È ARRIVATO"
SOTTOTITOLO = "stesso prezzo, il doppio del lavoro"
RIGA_IN_FONDO = "francescogruner.it"
# --------------------------------------------------------------------------- #
# 3) IL LOGO (facoltativo, ma se lo vuoi giusto va allegato) #
# --------------------------------------------------------------------------- #
# Percorso di un file PNG o JPG. Lascia "" se non ti serve nessun logo.
LOGO = ""
# --------------------------------------------------------------------------- #
# 4) ASPETTO E FORMATO #
# --------------------------------------------------------------------------- #
SFONDO = "quasi nero, con un alone di luce arancione dietro al centro"
STILE = "pulito, moderno, molto contrastato, nessuna fotografia"
FORMATO = "1:1" # "1:1" quadrata, "16:9" orizzontale, "9:16" verticale
MARGINE_MINIMO_PX = 80 # spazio vuoto richiesto sui quattro lati
FILE_IN_USCITA = "copertina.png"
# Modello di Gemini usato per le immagini. Se Google lo rinomina, cambia qui.
MODELLO = "gemini-3.1-flash-image"
ENDPOINT = "https://generativelanguage.googleapis.com/v1beta/models"
def costruisci_prompt():
"""Il prompt vero e proprio. La parte che fa la differenza è l'elenco
riga per riga più le regole finali: senza, il modello improvvisa."""
blocco_logo = ""
if LOGO:
blocco_logo = (
"Ti allego il simbolo del marchio come immagine di riferimento.\n"
"Usalo ESATTAMENTE com'è, in alto al centro, sopra al titolo.\n"
"Non ridisegnarlo, non cambiargli forma, non cambiare il numero di\n"
"punte, non aggiungere dettagli. Puoi solo ingrandirlo o rimpicciolirlo.\n\n"
)
return (
blocco_logo
+ "Crea un'immagine per una copertina social.\n\n"
+ "Sfondo: " + SFONDO + ".\n"
+ "Stile: " + STILE + ".\n\n"
+ "Scrivi ESATTAMENTE questo testo, in italiano:\n"
+ "Riga 1, titolo grande in maiuscolo: " + TITOLO_RIGA_1 + "\n"
+ "Riga 2, titolo grande in maiuscolo: " + TITOLO_RIGA_2 + "\n"
+ "Riga 3, sottotitolo piccolo: " + SOTTOTITOLO + "\n"
+ "Riga 4, in fondo, piccola e colorata con il colore d'accento: "
+ RIGA_IN_FONDO + "\n\n"
+ "Regole da rispettare:\n"
+ "- non tradurre e non riscrivere nessuna riga, copiale così come sono\n"
+ "- mantieni gli accenti italiani identici: È, à, è, ì, ò, ù\n"
+ "- il titolo sta su due righe, spezzato dove ti ho indicato\n"
+ "- lascia almeno " + str(MARGINE_MINIMO_PX) + " pixel di margine vuoto sui quattro lati\n"
+ "- lascia respiro fra le due righe del titolo: l'accento della È\n"
+ " non deve toccare la riga sopra\n"
+ "- niente testo in più, niente firme, niente watermark\n"
)
def leggi_logo(percorso):
"""Legge il file del logo. Se manca si ferma: meglio un errore chiaro che
una copertina generata senza logo che paghi e butti."""
if not os.path.isfile(percorso):
print("ERRORE: il file del logo non esiste: " + percorso)
print("Correggi il percorso in LOGO, oppure lascialo vuoto.")
sys.exit(1)
with open(percorso, "rb") as f:
dati = f.read()
mime = "image/png" if percorso.lower().endswith(".png") else "image/jpeg"
return {"inline_data": {"mime_type": mime,
"data": base64.b64encode(dati).decode()}}
def genera():
if not API_KEY:
print("ERRORE: manca la chiave API.")
print('Esegui: export GEMINI_API_KEY="la-tua-chiave"')
sys.exit(1)
parti = []
if LOGO:
parti.append(leggi_logo(LOGO)) # il logo va PRIMA del testo
parti.append({"text": costruisci_prompt()})
corpo = json.dumps({
"contents": [{"parts": parti}],
"generationConfig": {
"responseModalities": ["IMAGE"],
"imageConfig": {"aspectRatio": FORMATO},
},
}).encode("utf-8")
richiesta = urllib.request.Request(
ENDPOINT + "/" + MODELLO + ":generateContent",
data=corpo,
method="POST",
headers={"Content-Type": "application/json", "x-goog-api-key": API_KEY},
)
print("Genero la copertina...")
try:
with urllib.request.urlopen(richiesta, timeout=180) as risposta:
dati = json.loads(risposta.read())
except urllib.error.HTTPError as e:
dettaglio = e.read().decode("utf-8", "replace")[:400]
print("ERRORE HTTP " + str(e.code) + ": " + dettaglio)
sys.exit(1)
except Exception as e:
print("ERRORE di rete: " + type(e).__name__ + " " + str(e)[:200])
sys.exit(1)
# L'immagine arriva codificata dentro la risposta: la cerchiamo e la salviamo.
candidati = dati.get("candidates") or []
pezzi = ((candidati[0].get("content") or {}).get("parts") or []) if candidati else []
for p in pezzi:
inline = p.get("inlineData") or p.get("inline_data") or {}
if inline.get("data"):
with open(FILE_IN_USCITA, "wb") as f:
f.write(base64.b64decode(inline["data"]))
print("Fatto: " + FILE_IN_USCITA)
print("Controlla il testo e i margini prima di pubblicarla.")
return
motivo = candidati[0].get("finishReason", "") if candidati else ""
blocco = (dati.get("promptFeedback") or {}).get("blockReason", "")
print("Nessuna immagine nella risposta. " + str(motivo) + " " + str(blocco))
sys.exit(1)
if __name__ == "__main__":
genera()Cosa fa, spiegato in italiano
Meno di quanto sembri, ed è un bene.
- In cima ci sono solo le tue impostazioni. Chiave, testo delle quattro righe, logo, formato, nome del file da salvare. Sono le uniche cose che devi toccare.
- La funzione
costruisci_promptmonta il prompt, che è lo stesso identico del Prompt 1 e del Prompt 2 di questa pagina. Il valore del file sta lì, non nel resto. - Se hai indicato un logo, viene letto e allegato alla richiesta prima del testo. Se il file non esiste, lo script si ferma con un messaggio chiaro invece di generare l’immagine senza logo e farti pagare uno scarto.
- Poi manda tutto a Gemini e salva l’immagine che torna. Se qualcosa va storto stampa un errore leggibile, non un muro di codice rosso.
Il pacchetto completo, con la guida d’uso, la licenza MIT e un file di istruzioni pensato per gli agenti AI, è su GitHub: gratis, riutilizzabile, modificabile. Lo trovi su github.com/francescogruner/copertina-ai.
E se non ci riesci
Ultima cosa, ed è quella che oggi cambia di più la vita a chi non è tecnico. Se il Terminale ti mette a disagio, o se ti si blocca a metà, non serve che impari a programmare: fatti aiutare da un agente.
Apri Claude Code, Cowork, Codex o quello che preferisci, dagli in allegato lo script e il file delle istruzioni, e scrivigli semplicemente “aiutami a lanciare questa cosa”. Ti chiede la chiave, la imposta lui, ti domanda che testo vuoi sulla copertina, lancia il comando al posto tuo e ti mostra il risultato. Se qualcosa non va, lo sistema mentre sei lì.
Nel pacchetto ho messo apposta un file di istruzioni scritto per essere letto da un agente, non da un umano: dice che chi chiede aiuto probabilmente non è tecnico, di andare un passo alla volta, di chiedere la chiave e di verificare che tutto sia a posto prima di lanciare. Non è una scorciatoia per pigri. È il modo in cui si lavora adesso.
Nel repository quel file c’è già: si chiama AGENT.md, e per Claude Code c’è la stessa cosa in CLAUDE.md. Se scarichi la cartella e la apri con un agente, li legge da solo e comincia a guidarti senza che tu debba chiedergli niente.
In pratica
Se scrivi in italiano e ti serve un’immagine con del testo dentro, oggi puoi farla e viene giusta. Copia uno dei tre prompt, cambia il testo fra parentesi, allega il logo se ce n’è uno, e guarda il risultato prima di pubblicarlo. Se l’impaginazione non ti piace, rigenera: costa meno di rileggerla.
Ultima nota di trasparenza. Ho generato 19 immagini con due strumenti in una notte, e i costi che leggi vengono dai listini pubblici, non da una fattura. È un’indicazione solida, non una legge universale: con testi molto più lunghi, lingue mescolate o loghi molto dettagliati potrebbe comportarsi peggio, e non l’ho provato.
Domande frequenti su Nano Banana
Nano Banana scrive correttamente il testo in italiano?
Sì. Nel mio test 19 immagini su 19 avevano il testo italiano corretto, accenti compresi, controllati ingrandendo anche le scritte piccole. Ha retto NOVITÀ, È, GIÀ e due volte “più” nella stessa immagine, oltre a un indirizzo web con slash e trattino. Il campione è piccolo, ma il risultato è netto.
Quanto costa fare un’immagine con Nano Banana?
Circa 4 centesimi di dollaro a immagine, contro i 15-19 centesimi di gpt-image-2. Dieci copertine ti costano meno di mezzo euro. Sono stime prese dai listini pubblici, non da una fattura: il prezzo cambia con la risoluzione e con la qualità che scegli.
Come scrivo un prompt per un’immagine con testo che funzioni?
Tre cose, nell’ordine. Elenca il testo riga per riga invece di descriverlo in una frase. Scrivi “non tradurre e non riscrivere”, altrimenti capita che il modello ti ritraduca o accorci. Chiedi esplicitamente di mantenere gli accenti elencandoli. In questa pagina trovi tre prompt completi già pronti da copiare.
Posso far mettere il logo della mia azienda dentro l’immagine?
Sì, ma devi allegare il file del logo insieme al prompt, non descriverlo a parole. Descritto, il simbolo esce diverso a ogni tentativo. Allegato, esce quello vero. Se ti serve identico al pixel, per esempio su materiali ufficiali, mettilo sopra all’immagine con un editor: una riproduzione fedele non è una copia esatta.
Posso usare il logo di un prodotto che non è mio?
Il file va sempre scaricato dal sito ufficiale del prodotto, dalla sua pagina stampa o dalla pagina del marchio, mai fatto disegnare all’AI. Un simbolo generato che assomiglia a un marchio registrato resta un segno disegnato da te, e per un marchio altrui la differenza conta.
Perché il font del mio brand non viene mai rispettato?
Perché il modello non ha il file del tuo carattere: sta disegnando forme che assomigliano a lettere. Nessuna delle mie 19 immagini usa il font che avevo chiesto. Se il carattere è parte dell’identità del tuo brand, fatti generare solo lo sfondo e aggiungi il testo tu.
Che differenza c’è tra Nano Banana e Nano Banana Pro?
“Nano Banana” è il soprannome con cui in rete si chiamano i modelli di immagini di Gemini, non un nome ufficiale di Google. Pro è la versione più potente e più cara, la versione base è quella veloce ed economica da pochi centesimi. Per le copertine con testo, nel mio test è bastata la versione veloce.
Meglio Nano Banana o gpt-image-2 per le immagini con testo?
Sulla correttezza del testo sono pari: entrambi hanno scritto l’italiano accentato senza errori. La differenza è pratica: Nano Banana costa circa un quarto e impiega circa 7 secondi contro poco più di 2 minuti. Per provare più varianti dello stesso concetto, la velocità cambia il modo in cui lavori.
Serve saper programmare per usare lo script?
No. Devi salvare un file, incollare una riga nel Terminale e cambiare quattro righe di testo. Se anche questo ti sembra troppo, allega lo script a un agente AI come Claude Code, Cowork o Codex e chiedigli di lanciarlo per te: nel pacchetto c’è un file di istruzioni scritto apposta perché l’agente ti guidi passo passo.
Fonti
Per la stesura dell’articolo sono state consultate le pagine ufficiali dei modelli di generazione immagini e i listini pubblici da cui vengono le stime di costo.
Google AI
Gemini, la generazione di immagini
Pagina ufficiale Google sui modelli di immagini di Gemini, quelli che tutti chiamano Nano Banana.
Apri fonteGoogle AI Studio
Dove si crea la chiave
La pagina ufficiale da cui si ottiene la chiave necessaria a far funzionare lo script.
Apri fonteOpenAI
La guida alle immagini di OpenAI
Guida ufficiale OpenAI a gpt-image-2, con i livelli di qualità usati nel confronto.
Apri fonteOpenAI
Listino pubblico OpenAI
Listino da cui viene la stima di costo per immagine di gpt-image-2 citata nell’articolo.
Apri fonteUIBM
Marchi registrati, Ufficio Italiano Brevetti e Marchi
Riferimento istituzionale sul marchio registrato, il motivo per cui un logo altrui si scarica dalla fonte ufficiale.
Apri fonte📬 Se ti servono altri kit come questo, prompt pronti e numeri veri invece di entusiasmi, iscriviti alla newsletter qui su francescogruner.it: una a settimana, gratis. E se provi uno dei prompt o lo script e ti esce qualcosa di strano, portalo nella community Facebook: mi interessa capire dove si rompe davvero.
Nuovo su Google
Aggiungi francescogruner.it come fonte preferita
Se leggi spesso i miei articoli su AI, automazione e tecnologia, ora puoi dire a Google che vuoi vedere più spesso i contenuti di francescogruner.it tra le notizie.
