Nano Banana 2: guia completo com Python

O Google acaba de lançar a segunda iteração do modelo de geração de imagens, o Nano Banana 2. Quando o Nano Banana foi lançado pela primeira vez, virou sensação no mundo todo e rapidamente se tornou o melhor e mais rápido modelo de geração de imagens com IA.

Neste artigo, vamos explorar a fundo o novo modelo, conhecer seus recursos e aprender a usá-lo pela API com Python.

Se você se interessa por geração de imagens de forma geral, recomendo conferir nossos guias destes modelos:

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

O que é o Nano Banana 2?

Nano Banana 2, também conhecido como Gemini 3.1 Flash Image, é o mais novo modelo de IA de ponta do Google DeepMind para geração e edição de imagens. Ele combina o conhecimento de mundo, a qualidade e a capacidade de raciocínio do Nano Banana Pro com a velocidade relâmpago do Gemini Flash, tornando possível criar com alta fidelidade e iterar rapidamente no mesmo fluxo de trabalho.

Principais capacidades

Veja um panorama dos recursos-chave do Nano Banana 2:

• Mais precisão: Fundamenta as gerações com o conhecimento de mundo do Gemini e sinais de imagens da web em tempo real para representar com mais exatidão assuntos específicos. Ideal para infográficos, diagramas e visualizações de dados.
• Tipografia aprimorada: Gera textos legíveis e corretos dentro das imagens e permite localização e tradução diretamente na imagem.
• Controle criativo: Maior consistência de personagens para narrativas e storyboards. O modelo mantém semelhança de até cinco personagens e fidelidade de até 14 objetos em um único fluxo.
• Confiabilidade: Segue instruções com precisão para captar melhor prompts complexos e com nuances.
• Alta resolução: Especificações prontas para produção, com proporções de tela e resoluções flexíveis de 512 pixels até 4K.
• Qualidade visual: Fidelidade visual aprimorada, com texturas mais ricas, iluminação vibrante e detalhes mais nítidos na velocidade do Flash.

Se você é novo no Nano Banana, talvez valha a pena ler primeiro nosso artigo anterior sobre a primeira iteração, o Nano Banana Pro.

Como acessar o Nano Banana 2

Neste artigo, mostramos como usar o Nano Banana 2 pela API com Python. Mas os novos modelos estão disponíveis em todo o ecossistema Gemini:

• App Gemini: Nano Banana 2 agora é o modelo padrão de imagens nos modos Fast, Thinking e Pro. Assinantes do Google AI Pro e Ultra ainda podem regenerar com o Nano Banana Pro pelo menu de três pontos para tarefas especializadas que exigem máxima precisão factual.
• Busca: Disponível no Modo IA e no Lens no app do Google e em navegadores mobile/desktop, com disponibilidade expandida (incluindo 141 novos países/territórios e mais oito idiomas).
• AI Studio + Gemini API: Disponível em prévia (consulte preços). Também disponível no Google Antigravity.
• Google Cloud: Em prévia via Gemini API no Vertex AI.
• Flow: Agora é o modelo padrão de geração de imagens para todos os usuários do Flow.
• Google Ads: Potencializa sugestões criativas durante a criação de campanhas.

Preços da API

Neste artigo, vamos usar o Nano Banana 2 pela API, ou seja, não precisamos de assinatura: pagamos por cada imagem gerada.

Achei a tabela oficial de preços um pouco difícil de interpretar. Normalmente, modelos de imagem com IA indicam um preço fixo por imagem.

Para simplificar, fiz cálculos estimando o preço esperado conforme o tamanho da imagem. Observe que não são valores exatos, pois podem variar levemente.

O Nano Banana 2 consegue fazer buscas na web para gerar resultados mais precisos. Esse recurso é ótimo, mas também precisa entrar na conta, pois as buscas geram um custo adicional.

As primeiras 5.000 consultas ao Google Search por mês são grátis ao usar grounding com Google Search. Depois disso, custa $14 por 1.000 consultas.

Gerando nossa primeira imagem com o Nano Banana 2

Sem mais demora, vamos começar com o Nano Banana 2.

Gerando a chave de API

Para usar a API, primeiro precisamos gerar uma chave de API. Para isso, faça login no Google AI Studio. Depois, clique no botão Create API Key no canto superior direito.

A chave de API precisa estar vinculada a um projeto do Google Cloud. O Google AI Studio facilita isso permitindo criar um projeto diretamente no processo de geração da chave.

Para usar a chave, o projeto do Google Cloud ao qual ela está vinculada deve ter faturamento habilitado. Se você acabou de criar um projeto, habilite-o clicando em Set up billing ao lado da chave de API.

Por fim, copie a chave de API e cole em um arquivo chamado .env neste formato:

GEMINI_API_KEY=<paste_key_here>

Esse arquivo .env deve ser criado na mesma pasta onde vamos escrever os scripts em Python.

Configuração do ambiente

Em seguida, precisamos instalar as dependências do Python para interagir com a Gemini API. Rode o comando abaixo:

pip install google-genai python-dotenv pillow

Ele instala os seguintes pacotes:

• google-genai: O pacote oficial de IA generativa do Google. Usado para criar facilmente um cliente para interagir com a Gemini API.

• python-dotenv: Pacote utilitário para carregar a chave de API do arquivo .env.

• pillow: Biblioteca de imagens que facilita carregar imagens como entrada para o Nano Banana 2.

Gerando uma imagem

Aqui está o código completo em Python para gerar uma imagem:

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")

Veja o resultado:

Proporções e resoluções compatíveis

Na requisição acima, definimos a proporção usando o parâmetro aspect_ratio e a resolução usando o parâmetro image_size.

O Nano Banana 2 oferece uma ampla faixa de proporções e resoluções de 512 pixels até 4K. Veja a lista completa de valores:

• 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 (resolução): "512px", "1K", "2K", "4K"

Mão na massa com o Nano Banana 2

Agora que configuramos tudo e criamos nossa primeira imagem, é hora de colocar os recursos anunciados à prova.

Edição de imagem com consistência de sujeito

Podemos fornecer imagens ao modelo carregando-as com o PIL (instalado pelo pacote pillow) e incluindo-as na lista contents.

Um dos principais recursos do Nano Banana 2 é sua capacidade de preservar os sujeitos ao gerar imagens. Ao testar outros modelos, como a iteração anterior do Nano Banana ou o GPT-Image, muitas vezes eu achava difícil gerar imagens baseadas em sujeitos reais, pois o modelo tendia a alterar a aparência deles.

Na documentação, eles mencionam que o modelo consegue lidar com até cinco personagens e 10 objetos, somando 14 referências. Não definem explicitamente personagens e objetos, mas, de forma intuitiva, significa que o modelo foi treinado para gerar cenas com até 4 sujeitos principais e até 10 objetos secundários com os quais esses sujeitos interagem.

O modelo não fornece parâmetros específicos para enviar imagens de personagens e objetos. Em vez disso, isso é feito no prompt. Analisei o código-fonte de alguns demos para entender como estruturam um prompt que se refere a eles.

O template que encontrei foi este:

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

Por exemplo, com duas personagens chamadas "Alice" e "Bob":

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

Abaixo, um exemplo completo de código que coloca dois pets, um cachorro e um gato, posando juntos em uma foto.

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")

Incorporando objetos

Como mencionado, esse template não faz parte da documentação oficial. O modelo provavelmente consegue entender cada parte a partir do prompt e das imagens. Porém, ao implementar uma aplicação real em que queremos resultados consistentes, é boa prática ser o mais preciso e consistente possível no prompt. Por isso, recomendo usar esse template.

O exemplo deles estende o template para referências de objetos simplesmente trocando "Character" por "Object", para indicar ao modelo que a imagem se refere a um objeto e não ao sujeito principal.

Para demonstrar, vamos fazer o cachorro usar um óculos específico e o gato um boné, fornecendo duas referências de objetos. Este foi o prompt que usei:

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.

Veja o resultado:

Geração de imagens fundamentada em busca

O Nano Banana 2 permite fundamentar a geração de imagens em buscas, deixando os resultados mais fiéis. Isso é especialmente útil ao gerar imagens que precisam ser consistentes com a realidade, como a foto de um local ou de uma espécie específica de animal.

Moro em Taiwan e, recentemente, houve uma trilha organizada em que o organizador usou uma imagem gerada com o Nano Banana para ilustrar o local. Mas a imagem não tinha nada a ver com a realidade, e as pessoas ficaram decepcionadas porque estava totalmente diferente do lugar real.

Isso me deixou curioso para ver se o Nano Banana 2 consegue lidar com isso.

Podemos habilitar busca na web e busca de imagens usando o parâmetro tools na requisição de geração.

Aqui vai um exemplo completo:

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")

Abaixo mostramos os resultados. Primeiro, a imagem real do Google Fotos; depois, a imagem gerada pelo Nano Banana 2 usando busca; e, por fim, a imagem gerada sem busca. Dá para ver que a busca deixa o resultado muito preciso.

A equipe do Gemini criou um demo chamado Window View que usa essa ideia para construir um app que mostra lugares específicos através de uma janela. É um bom exemplo da capacidade do modelo de entender o mundo real.

Combinando consistência de sujeito com entendimento de mundo

Dando ao modelo a capacidade de gerar locais reais com alta precisão, podemos posicionar sujeitos específicos em lugares do mundo real.

Vamos tentar colocar Goldie e Wiskers em um local em Taiwan. Escolhi esse lugar porque queria ver se o modelo lida bem com locais que não são mundialmente famosos.

Este foi o 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.

Repare que o prompt pede explicitamente que o modelo faça busca de imagens. Descobri que, ao usar ferramentas, é sempre melhor pedir explicitamente no prompt que o modelo as utilize.

Aqui está a imagem dos nossos dois personagens viajando juntos:

Para ir além, testei até especificar o local pelas coordenadas de latitude e longitude — e funcionou!

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.

Mesmo que o ponto não seja exatamente as mesmas coordenadas, os elementos da imagem correspondem ao que vemos naquele lugar — o que é bem impressionante, na minha opinião.

Localização de texto

O Nano Banana 2 melhora os modelos anteriores baseados em Flash ao oferecer renderização de texto mais consistente e confiável.

Agora, o texto pode aparecer tão nítido e preciso quanto os elementos gráficos ao redor. O Nano Banana 2 também permite localização dentro da imagem, possibilitando criar ou traduzir textos para vários idiomas diretamente na imagem gerada.

Testei a localização gerando um cartaz para uma marca fictícia de headset de realidade virtual chamada "Beyond Reality". Em seguida, usei um prompt simples como:

Change the language of the poster to Japanese.

Veja os resultados após mudar o idioma do texto do cartaz para francês e depois para japonês:

Interessante notar que o modelo foi esperto o suficiente para não traduzir o nome da marca, mesmo sem isso estar no prompt.

Modo de conversa

O último recurso que vamos explorar é o modo de conversa. Os exemplos anteriores não são interativos: enviamos uma requisição para a API e recebemos um resultado. Se quisermos iterar naquele resultado, precisamos montar uma nova requisição com a imagem e as mudanças desejadas.

Uma forma melhor é usar o modo chat. Nele, criamos um chat com a função client.chats.create() e enviamos mensagens com a função client.send_message(). Assim, dá para implementar um fluxo de edição via chat:

1. O usuário envia um prompt
2. O Nano Banana 2 gera uma imagem com base no prompt e na imagem anterior (se houver)
3. A imagem é exibida para o usuário
4. O usuário envia um prompt de edição, voltando ao passo 2.

Aqui está um script completo implementando esse fluxo:

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.")

Ao rodar esse script, dá para editar uma imagem de forma iterativa direto no terminal, assim:

Aqui estão os resultados dessa interação:

Nano Banana vs. Nano Banana 2

A tabela abaixo destaca as principais diferenças entre os modelos Nano Banana. Como já comentamos, a nova versão traz melhorias significativas em precisão, consistência e resolução, rodando apenas um pouco mais devagar que a primeira iteração.  

A tabela foi gerada pelo próprio Nano Banana 2 a partir dos dados fornecidos.

Quando usar o Nano Banana Pro

Embora o Nano Banana 2 seja o novo padrão, o Nano Banana Pro continua disponível para tarefas de “Thinking” e casos especializados. Você ainda pode optar pelo Pro quando precisar de:

• Realismo extremo: O Pro ainda tem leve vantagem em física de iluminação e texturas de pele.
• Raciocínio complexo: O Pro é melhor em “pensar” sobre instruções espaciais (por exemplo, “a pessoa atrás do segundo pilar à esquerda”).

Conclusão

O Nano Banana 2 parece um verdadeiro sucessor porque reduz drasticamente o “desvio” entre iterações, permitindo fixar um visual e mantê-lo de forma confiável em cenas, formatos e idiomas. 

Entre a maior persistência de sujeitos, instruções seguidas com mais rigor, realismo fundamentado em busca e edições conversacionais que ajustam em vez de redesenhar, ficou muito mais fácil manter identidade, layout e estilo intactos enquanto você explora variações.

A renderização de texto em nível de produção ajuda a manter elementos de marca consistentes, e as proporções flexíveis tornam o escalonamento de uma campanha entre banners, pôsteres e stories mobile algo fluido. Para times que criam storyboards, fotos de produto ou criativos multilíngues, ele entrega repetibilidade sem abrir mão de velocidade nem fidelidade.

O Nano Banana 2 preenche a lacuna entre Nano Banana e Nano Banana Pro: sua velocidade é praticamente a do ritmo quase instantâneo do Flash do Nano Banana, enquanto suas capacidades, fidelidade visual, precisão no seguimento de instruções, consistência de sujeito e realismo fundamentado em busca frequentemente chegam perto do Nano Banana Pro.

Se você quer aprender mais sobre os conceitos por trás de ferramentas como o Nano Banana 2, recomendo nosso curso Generative AI Concepts.