Nano Banana 2: een complete gids met Python

Google heeft zojuist de tweede iteratie van het beeldgeneratiemodel uitgebracht, Nano Banana 2. Toen Nano Banana voor het eerst werd gelanceerd, ging het als een lopend vuurtje de wereld over en werd het al snel het beste en snelste AI‑model voor beeldgeneratie.

In dit artikel duiken we diep in het nieuwe model, verkennen we de nieuwe functies en leer je hoe je het via de API met Python gebruikt.

Als je in het algemeen geïnteresseerd bent in beeldgeneratie, raad ik je aan onze gidsen voor de volgende modellen te bekijken:

• Seedream 4.5
• FLUX.2 Klein
• Qwen Image
• ChatGPT Images 2.0

Wat is Nano Banana 2?

Nano Banana 2, ook bekend als Gemini 3.1 Flash Image, is het nieuwste state‑of‑the‑art AI‑model voor beeldgeneratie en ‑bewerking van Google DeepMind. Het combineert de geavanceerde wereldkennis, kwaliteit en redenering van Nano Banana Pro met de razendsnelle snelheid van Gemini Flash, waardoor creatie met hoge nauwkeurigheid en snelle iteratie in één workflow mogelijk zijn.

Belangrijkste mogelijkheden

Hier is een overzicht van de belangrijkste features van Nano Banana 2:

• Verbeterde nauwkeurigheid: Baseert generaties op Gemini’s real‑world kennis en realtime websignalen van afbeeldingen om specifieke onderwerpen nauwkeuriger weer te geven. Ideaal voor infographics, diagrammen en datavisualisaties.
• Verbeterde typografie: Produceert goed leesbare, nauwkeurige tekst in afbeeldingen en ondersteunt lokalisatie en vertaling direct in de afbeelding.
• Creatieve controle: Verbeterde onderwerpconsistentie voor verhaallijnen en storyboards. Het model houdt gelijkenis vast voor tot vijf personages en getrouwheid voor tot 14 objecten in één workflow.
• Betrouwbaarheid: Nauwkeurige naleving van instructies om complexe, genuanceerde prompts beter te vatten.
• Hoge resolutie: Productierijpe specificaties met flexibele beeldverhoudingen en resoluties van 512 pixels tot 4K.
• Visuele kwaliteit: Verbeterde visuele getrouwheid met rijkere texturen, levendigere belichting en scherper detail op Flash‑snelheid.

Als je nieuw bent met Nano Banana, lees dan eerst ons eerdere artikel over de eerste iteratie van Nano Banana Pro.

Hoe krijg je toegang tot Nano Banana 2

In dit artikel behandelen we hoe je Nano Banana 2 gebruikt via hun API met Python. De nieuwe modellen zijn echter beschikbaar in het hele Gemini‑ecosysteem:

• Gemini‑app: Nano Banana 2 is nu het standaard beeldmodel in de modi Fast, Thinking en Pro. Abonnees van Google AI Pro en Ultra kunnen via het driestippenmenu nog steeds opnieuw genereren met Nano Banana Pro voor gespecialiseerde taken met maximale feitelijke nauwkeurigheid.
• Zoekfunctie: Beschikbaar in AI Mode en Lens in de Google‑app en mobiele/desktopbrowsers, met uitgebreide beschikbaarheid (waaronder 141 nieuwe landen/gebieden en acht extra talen).
• AI Studio + Gemini API: Beschikbaar als preview (zie prijzen). Ook beschikbaar in Google Antigravity.
• Google Cloud: In preview via de Gemini API in Vertex AI.
• Flow: Nu het standaardmodel voor beeldgeneratie voor alle Flow‑gebruikers.
• Google Ads: Stuurt creatieve suggesties tijdens het opzetten van campagnes aan.

API‑prijzen

In dit artikel gebruiken we Nano Banana 2 met de API, wat betekent dat we geen abonnement nodig hebben en in plaats daarvan per gegenereerde afbeelding betalen.

Ik vond de officiële prijzentabel een beetje lastig te begrijpen. Meestal geven AI‑beeldmodellen gewoon een vaste prijs per afbeelding op.

Om het simpeler te maken, heb ik berekeningen gemaakt om de verwachte prijs per beeldgrootte te schatten. Let op: dit zijn geen exacte prijzen; ze kunnen licht variëren.

Nano Banana 2 kan webzoekopdrachten uitvoeren om nauwkeurigere resultaten te genereren. Dat is een erg fijne feature, maar je moet het wel meerekenen in de prijs, omdat zoekacties extra kosten met zich meebrengen.

De eerste 5.000 Google Search‑query’s per maand zijn gratis wanneer je grounding met Google Search gebruikt. Daarna kost het $14 per 1.000 Google Search‑query’s.

Onze eerste Nano Banana 2‑afbeelding genereren

Zonder verdere omhaal: aan de slag met Nano Banana 2.

De API‑sleutel genereren

Om de API te gebruiken, moeten we eerst een API‑sleutel genereren. Meld je daarvoor eerst aan bij Google AI Studio. Klik vervolgens op de knop Create API Key rechtsboven.

De API‑sleutel moet gekoppeld zijn aan een Google Cloud‑project. Google AI Studio maakt dit eenvoudig door ons tijdens het genereren van de sleutel direct een project te laten aanmaken.

Om de API‑sleutel te gebruiken, moet het gekoppelde Google Cloud‑project facturering ingeschakeld hebben. Als je net een nieuw project hebt aangemaakt, moet je dit inschakelen door op de knop Set up billing naast de API‑sleutel te klikken.

Kopieer tot slot de API‑sleutel en plak die in een bestand met de naam .env in het volgende formaat:

GEMINI_API_KEY=<paste_key_here>

Dit .env-bestand moet je aanmaken in dezelfde map als waar we de Python‑scripts schrijven.

Omgeving instellen

Vervolgens moeten we de Python‑afhankelijkheden installeren die nodig zijn om met de Gemini API te communiceren. Voer hiervoor het volgende commando uit:

pip install google-genai python-dotenv pillow

Dit installeert de volgende pakketten:

• google-genai: Het officiële Google‑pakket voor generatieve AI. Hiermee maak je eenvoudig een client om met de Gemini API te werken.

• python-dotenv: Een hulppakket om de API‑sleutel uit het .env‑bestand te laden.

• pillow: Een afbeeldingsbibliotheek om eenvoudig afbeeldingen te laden die je als input aan Nano Banana 2 doorgeeft.

Een afbeelding genereren

Hier is de complete Python‑code om een afbeelding te genereren:

from google import genai
from dotenv import load_dotenv
from google.genai import types
import time

# Load API key
load_dotenv()
client = genai.Client()

prompt = """
Lego version of the empire state building being built.
"""

# Make API request
response = client.models.generate_content(
    model="gemini-3.1-flash-image-preview",
    contents=[prompt],
    config=types.GenerateContentConfig(
        response_modalities=["Image"],
        image_config=types.ImageConfig(
            aspect_ratio="16:9",
            image_size="4K",
        ),
    )
)

# Save the image and display output text if any
for part in response.parts:
    if part.text is not None:
        print(part.text)
    elif part.inline_data is not None:
        image = part.as_image()
        image.save(f"image_{int(time.time())}.png")

Hier is het resultaat:

Ondersteunde beeldverhoudingen en resoluties

In het bovenstaande verzoek hebben we de beeldverhouding opgegeven met de parameter aspect_ratio en de resolutie met de parameter image_size.

Nano Banana 2 ondersteunt een breed scala aan beeldverhoudingen en resoluties van 512 pixels tot 4K. Hier is de volledige lijst met ondersteunde waarden:

• aspect_ratio: "1:1","1:4","1:8","2:3","3:2","3:4","4:1","4:3","4:5","5:4","8:1","9:16","16:9","21:9"

• image_size (resolutie): "512px", "1K", "2K", "4K"

Zelf aan de slag met Nano Banana 2

Nu we alles hebben ingesteld en met succes onze eerste afbeelding hebben gemaakt, is het tijd om de beloofde functies te testen.

Afbeeldingen bewerken met onderwerpconsistentie

We kunnen afbeeldingen aan het model doorgeven door ze te laden met PIL (geïnstalleerd via het pakket pillow) en ze op te nemen in de lijst contents.

Een van de belangrijkste features van Nano Banana 2 is het vermogen om onderwerpen te behouden bij het genereren van afbeeldingen. Bij andere modellen, zoals de vorige iteratie van Nano Banana of GPT‑Image, merkte ik vaak dat het lastig was om afbeeldingen op basis van echte onderwerpen te genereren, omdat het model geneigd was hun uiterlijk te veranderen.

Volgens de documentatie kan het model tot vijf personages en 10 objecten ondersteunen, voor in totaal 14 referenties. Ze definiëren personages en objecten niet expliciet, maar intuïtief betekent het dat het model is getraind om scènes te genereren met tot 4 hoofdonderwerpen en tot 10 secundaire objecten waarmee deze onderwerpen interacteren.

Het model biedt geen expliciete parameters om afbeeldingen van personages en objecten in te dienen. In plaats daarvan gebeurt dit in de prompt. Ik heb de broncode van enkele demo’s bekeken om te begrijpen hoe ze een prompt structureren om hiernaar te verwijzen.

De template die ik vond, was als volgt:

<subject_name> (<Character #number>) = Image <#index>

Bijvoorbeeld, met twee personages genaamd "Alice" en "Bob" wordt het:

Subjects: Alice (Character 1) = Image 0, Bob (Character 2) = Image 1

Hieronder staat een volledig codevoorbeeld dat laat zien hoe je twee huisdieren, een hond en een kat, samen op een foto poseert.

from google import genai
from dotenv import load_dotenv
from google.genai import types
import time
from PIL import Image
# Load API key
load_dotenv()
client = genai.Client()
prompt = """
Goldie and Wiskers are posing together.
Subjects: Goldie (Character 1) = Image 0, Wiskers (Character 2) = Image 1
Maintain strict subject consistency for characters.
Adjust the subject composition/pose as appropriate for the scene.
"""
dog = Image.open("dog.png")
cat = Image.open("cat.png")
# Make API request
response = client.models.generate_content(
    model="gemini-3.1-flash-image-preview",
    contents=[prompt, dog, cat],
    config=types.GenerateContentConfig(
        response_modalities=["Image"],
        image_config=types.ImageConfig(
            aspect_ratio="9:16",
        ),
    )
)
# Save the image and display output text if any
for part in response.parts:
    if part.text is not None:
        print(part.text)
    elif part.inline_data is not None:
        image = part.as_image()
        image.save(f"image_{int(time.time())}.png")

Objecten toevoegen

Zoals hierboven vermeld, maakt deze template geen deel uit van de officiële documentatie. Het model kan waarschijnlijk elk onderdeel uit de prompt en de afbeeldingen afleiden. Maar als je een echte applicatie bouwt waarin je consistente resultaten wilt, is het best practice om zo precies en consistent mogelijk te zijn in de prompt. Daarom raad ik aan deze template te gebruiken.

Hun voorbeeld breidt de template uit naar objectreferenties door simpelweg "Character" te vervangen door "Object" om het model te laten weten dat de afbeelding naar een object verwijst en niet naar het hoofdonderwerp.

Om dit te laten zien, laten we de hond specifieke zonnebrillen dragen en de kat een hoed, door twee objectreferenties te geven. Dit is de prompt die ik gebruikte:

Goldie and Wiskers are posing together. Goldie is wearing the Glasses, and Wiskers is wearing the Hat.
Subjects: Goldie (Pet 1) = Image 0, Wiskers (Pet 2) = Image 1, Glasses (Object 1) = Image 3, Hat (Object 2) = Image 4.
Maintain strict subject consistency for characters and objects.
Adjust the subject composition/pose as appropriate for the scene.

Hier is het resultaat:

Beeldgeneratie gronden met zoekfunctie

Nano Banana 2 maakt het mogelijk om beeldgeneratie te gronden op zoekresultaten, zodat de uitkomsten accurater zijn. Dit is vooral nuttig bij het genereren van beelden die consistent moeten zijn met de werkelijkheid, zoals afbeeldingen van een locatie of een specifieke diersoort.

Ik woon in Taiwan en onlangs was er een georganiseerde hike waarbij de organisator een met Nano Banana gegenereerde afbeelding gebruikte om de wandelbestemming te tonen. De afbeelding bleek echter helemaal niet accuraat, en mensen waren teleurgesteld omdat het er totaal anders uitzag dan in het echt.

Dit maakte me nieuwsgierig om te testen of Nano Banana 2 dit wel aankan.

We kunnen zowel web‑ als afbeeldingszoekopdracht inschakelen met de parameter tools in het generatieverzoek.

Hier is een volledig voorbeeld:

from google import genai
from dotenv import load_dotenv
from google.genai import types
import time
# Load API key
load_dotenv()
client = genai.Client()
prompt = """
Create an image of the Yinhe Cave (銀河洞) in Taiwan at golden hour.
- Use Image Search to search for an image of the specified place.
- Keep the location and the view as close to the real reference as possible.
"""
# Make API request
response = client.models.generate_content(
    model="gemini-3.1-flash-image-preview",
    contents=[prompt],
    config=types.GenerateContentConfig(
        response_modalities=["Image"],
        image_config=types.ImageConfig(
            aspect_ratio="9:16",
        ),
        tools=[
            types.Tool(google_search=types.GoogleSearch(
                search_types=types.SearchTypes(
                    web_search=types.WebSearch(), # Enables web search
                    image_search=types.ImageSearch() # Enables image search
                )
            ))
        ]
        
    )
)
# Save the image and display output text if any
for part in response.parts:
    if part.text is not None:
        print(part.text)
    elif part.inline_data is not None:
        image = part.as_image()
        image.save(f"image_{int(time.time())}.png")

Hieronder tonen we de resultaten. Eerst de echte foto van Google Photos, dan de afbeelding die Nano Banana 2 met zoekfunctie genereerde, en tot slot de afbeelding zonder zoekfunctie. Je ziet dat zoeken de resultaten erg accuraat maakt.

Het Gemini‑team bouwde een demo genaamd Window View die dit idee gebruikt om een kleine app te maken die specifieke plekken door een raam toont. Het is een goede showcase van het vermogen van het model om de echte wereld te begrijpen.

Onderwerpconsistentie combineren met wereldkennis

Doordat het model echte locaties met hoge precisie kan genereren, kunnen we specifieke onderwerpen in echte omgevingen plaatsen.

Laten we proberen Goldie en Wiskers op een locatie in Taiwan te plaatsen. Ik koos deze plek omdat ik wilde zien of het model ook minder wereldberoemde locaties aankan.

Dit was de prompt:

Goldie and Wiskers are traveling across the Sanxiantai Arch Bridge in Taiwan.
Subjects: Goldie (Pet 1) = Image 0, Wiskers (Pet 2) = Image 1
Use image search to find visual references of the location.
Maintain strict subject consistency for characters and objects.
Adjust the subject composition/pose as appropriate for the scene.

Let op dat de prompt het model expliciet vraagt om een afbeeldingszoekopdracht uit te voeren. Ik heb gemerkt dat het, wanneer je tools gebruikt, altijd beter is om het model in de prompt expliciet te vragen ze te gebruiken.

Hier is een afbeelding van onze twee personages die samen reizen:

Om nog een stap verder te gaan, probeerde ik zelfs de locatie te specificeren met breedte‑ en lengtegraad, en dat werkte!

Goldie and Wiskers are at the location with a latitude of 17.0621186 and a longitude of -96.7255102.

Subjects: Goldie (Pet 1) = Image 0, Wiskers (Pet 2) = Image 1

Use image search to find visual references of the location.
Maintain strict subject consistency for characters and objects.
Adjust the subject composition/pose as appropriate for the scene.

Zelfs als de plek niet exact dezelfde breedte‑ en lengtegraad is, komen de elementen in de afbeelding overeen met wat we op die locatie zien, wat naar mijn mening behoorlijk indrukwekkend is.

Tekstlokalisatie

Nano Banana 2 bouwt voort op eerdere Flash‑gebaseerde beeldmodellen met consistentere en betrouwbaardere tekstrendering.

Tekst kan nu net zo scherp en accuraat verschijnen als de omringende graphics. Nano Banana 2 maakt ook lokalisatie in de afbeelding mogelijk, zodat je tekst direct in de gegenereerde afbeelding kunt maken of vertalen naar meerdere talen.

Ik testte lokalisatie door een poster te genereren voor een fictief merk VR‑headsets genaamd "Beyond Reality". Vervolgens gebruikte ik simpelweg een prompt zoals:

Change the language of the poster to Japanese.

Hier zijn de resultaten nadat ik de taal van de postertekst veranderde naar Frans en daarna naar Japans:

Interessant is dat het model slim genoeg was om de merknaam niet te vertalen, hoewel dit niet in de prompt was gespecificeerd.

Gespreksmodus

De laatste feature die we verkennen is de gespreksmodus. De vorige voorbeelden zijn niet interactief. We sturen een verzoek naar de API en krijgen een resultaat. Als we op dat resultaat willen itereren, moeten we een nieuw verzoek opbouwen met die afbeelding en de gewenste wijzigingen.

Een betere manier is om chatmodus te gebruiken. In chatmodus maken we een chat aan met de functie client.chats.create() en sturen we berichten heen en weer met de functie client.send_message(). Hiermee kunnen we een chat‑editworkflow implementeren:

1. Gebruiker stuurt een prompt
2. Nano Banana 2 genereert een afbeelding op basis van de prompt en de vorige afbeelding (als die bestaat)
3. De afbeelding wordt aan de gebruiker getoond
4. Gebruiker stuurt een bewerkprompt en gaat terug naar stap 2.

Hier is een volledig script dat deze flow implementeert:

from google import genai
from google.genai import types
from dotenv import load_dotenv
from PIL import Image
import time
load_dotenv()
client = genai.Client()
# Initialize the chat session
chat = client.chats.create(
    model="gemini-3.1-flash-image-preview",
    config=types.GenerateContentConfig(
        response_modalities=['TEXT', 'IMAGE'],
        tools=[{"google_search": {}}]
    )
)
# We keep track of the latest image object to send back as context
latest_image = None
while True:
    user_input = input("\nPrompt: ")
if user_input.lower() in ['quit', 'exit', 'q']:
        break
# Construct the message content
    # If we have a previous image, we include it so the model knows what to edit
    content = [user_input]
    if latest_image:
        content.append(latest_image)
    try:
        response = chat.send_message(content)
        
        for part in response.parts:
            # Handle Text Response
            if part.text:
                print(f"\nAI: {part.text}")
            
            elif part.inline_data is not None:
                image = part.as_image()
                filename = f"image_{int(time.time())}.png"
                image.save(filename)
                print("Saved image", filename)
                latest_image = Image.open(filename)
                latest_image.show()
                    
    except Exception as e:
        print(f"An error occurred: {e}")
print("Session ended.")

Wanneer we dit script draaien, kunnen we iteratief een afbeelding bewerken, direct in de terminal, zoals hier:

Hier zijn de resultaten van deze interactie:

Nano Banana vs. Nano Banana 2

De onderstaande tabel benadrukt de belangrijkste verschillen tussen de Nano Banana‑modellen. Zoals eerder vermeld, brengt de nieuwe versie aanzienlijke verbeteringen in nauwkeurigheid, consistentie en resolutie, terwijl hij slechts iets langzamer draait dan de eerste iteratie.  

De tabel is overigens door Nano Banana 2 zelf gegenereerd op basis van de aangeleverde data.

Wanneer gebruik je Nano Banana Pro

Hoewel Nano Banana 2 de nieuwe standaard is, blijft Nano Banana Pro beschikbaar voor "Thinking" en gespecialiseerde taken. Je kunt nog steeds voor Pro kiezen bij:

• Extreme realisme: Pro heeft nog een kleine voorsprong in lichtfysica en huidtexturen.
• Complexe redenering: Pro is beter in het “doordenken” van ruimtelijke instructies (bijv. "de persoon achter de tweede pilaar links").

Conclusie

Nano Banana 2 voelt als een echte opvolger omdat het “drift” tussen iteraties drastisch vermindert, zodat je een look kunt vastzetten en die betrouwbaar kunt doorvoeren in scènes, formaten en talen. 

Tussen sterkere onderwerppersistentie, strakkere opvolging van instructies, op zoekactie gegronde realiteit en conversationele edits die bijstellen in plaats van hertekenen, is het een stuk eenvoudiger om identiteit, lay‑out en stijl intact te houden terwijl je variaties verkent.

Productierijpe tekstrendering houdt brandelementen consistent, en de flexibele beeldverhoudingen maken het schaalbaar maken van een campagne over banners, posters en mobiele stories naadloos. Voor teams die storyboards, productshots of meertalige creaties bouwen, levert het herhaalbaarheid zonder snelheid of getrouwheid op te offeren.

Nano Banana 2 overbrugt precies het gat tussen Nano Banana en Nano Banana Pro: de snelheid zit effectief op Nano Banana’s bijna onmiddellijke Flash‑tempo, terwijl de mogelijkheden, visuele getrouwheid, precieze opvolging van instructies, onderwerpconsistentie en op zoekactie gegronde realiteit vaak dicht bij Nano Banana Pro uitkomen.

Wil je meer leren over de concepten achter tools zoals Nano Banana 2, volg dan onze cursus Generative AI Concepts.