6 dicas e um método prático de duas etapas para melhorar a precisão da renderização de texto em imagens Nano Banana

Ao gerar imagens com Nano Banana, muitos desenvolvedores se deparam com um problema frustrante: as imagens ficam lindas, mas o texto nelas aparece com erros de digitação, borrado ou completamente ilegível (caracteres aleatórios).

A boa notícia é que a documentação oficial do Google oferece uma dica crucial: primeiro, peça ao modelo para gerar o conteúdo do texto, e só depois solicite a geração da imagem que contenha esse texto. Este é o chamado "Método de Duas Etapas" (Two-Step Approach), que pode melhorar significativamente a precisão da renderização de texto.

Este artigo vai analisar a fundo as razões técnicas por trás desse fenômeno e apresentar 6 técnicas de renderização de texto comprovadamente eficazes, para ajudar você a obter textos claros e precisos nas imagens geradas pelo Nano Banana.

Valor Principal: Ao ler este artigo, você entenderá como funciona a renderização de texto no Nano Banana, dominará o Método de Duas Etapas e outras 6 técnicas práticas, elevando a precisão do texto em suas imagens de um nível "aleatório" para um nível controlável.

O Estado da Renderização de Texto com Nano Banana: Poderoso, mas Requer Técnica

Primeiro, a conclusão: a capacidade de renderização de texto dos modelos da série Nano Banana está no nível mais alto no campo da geração de imagens por IA, mas não é algo que "basta escrever um comando qualquer para ter o texto perfeito".

Dados de Precisão da Renderização de Texto do Nano Banana

Como podemos ver, a precisão de 94% do Nano Banana Pro já é o nível mais alto da indústria. No entanto, os 6% restantes de cenários de falha — erros de ortografia, texto borrado, caracteres ausentes — são inaceitáveis para cenários comerciais.

Por que a Renderização de Texto em Imagens Geradas por IA é Tão Difícil

Para entender por que o "método de duas etapas" é necessário, primeiro precisamos compreender as dificuldades da IA em gerar texto em imagens:

1. Requisito de precisão em nível de pixel: O texto em imagens deve ser preciso em nível de pixel; um único traço errado pode transformá-lo em um erro de digitação. Outros conteúdos gerados por IA (paisagens, pessoas) permitem um certo grau de imprecisão.
2. Explosão de combinações de caracteres: 26 letras em inglês, milhares de caracteres chineses, mais maiúsculas/minúsculas, fontes, e arranjos combinatórios, as possibilidades são quase infinitas.
3. Interferência do contexto: Ao gerar a composição geral da imagem, o modelo pode se "distrair" — precisa desenhar bem o fundo e organizar o texto, e as duas tarefas competem pela atenção.
4. Viés nos dados de treinamento: A proporção de imagens com texto perfeito nos dados de treinamento é limitada, e o modelo não aprendeu o suficiente sobre certas fontes e combinações de layout.

🎯 Dica Técnica: Ao entender as dificuldades da renderização de texto, você pode otimizar o comando de forma direcionada. Ao invocar Nano Banana Pro e Nano Banana 2 através da plataforma APIYI apiyi.com, você pode comparar rapidamente os efeitos de renderização de texto dos dois modelos e escolher a solução mais adequada para o seu cenário.

Técnica Essencial Um: Método de Duas Etapas — A Melhor Prática Oficialmente Recomendada para Renderização de Texto

Este é o método explicitamente recomendado pela documentação oficial do Google e é a técnica mais importante deste artigo.

O Princípio do Método de Duas Etapas

Método tradicional de uma etapa (efeito ruim):

"Gerar um pôster com o texto 'SUMMER SALE 50% OFF'"
→ Modelo processa composição e texto simultaneamente → Texto propenso a erros

Método de duas etapas (efeito bom):

Primeira etapa: "Por favor, gere o texto para um pôster: Promoção de Verão 50% de Desconto"
→ Saída do modelo: "SUMMER SALE 50% OFF"

Segunda etapa: "Gerar uma imagem de pôster, exibindo o texto exato 'SUMMER SALE 50% OFF'"
→ Modelo foca em renderizar o texto já definido na imagem → Precisão aumenta drasticamente

Por que o Método de Duas Etapas Funciona — Uma Explicação Técnica

Nano Banana é construído com base no Modelo de Linguagem Grande multimodal Gemini. Quando você usa o método de uma etapa para pedir diretamente "gerar uma imagem contendo certo texto", o modelo precisa completar duas tarefas simultaneamente:

1. Compreender e planejar a composição da imagem — cenário, cores, layout.
2. Renderizar caracteres de texto com precisão — ortografia, fonte, posição.

Essas duas tarefas competem entre si no mecanismo de atenção do modelo. Os "recursos de pensamento" do modelo são limitados, e ao processar duas tarefas de alta precisão ao mesmo tempo, a parte do texto geralmente se torna a sacrificada.

A ideia central do método de duas etapas é a divisão de tarefas:

• A primeira etapa permite que o modelo se concentre na geração e confirmação do conteúdo do texto — neste momento, o modelo está em modo puramente textual, e a precisão ortográfica é extremamente alta.
• A segunda etapa permite que o modelo se concentre em renderizar o texto já definido na imagem — o conteúdo do texto já está fixo, e o modelo só precisa resolver o problema de "como desenhar".

Isso é como pedir a um pintor para primeiro determinar qual texto será escrito no pôster (fase de redação) e depois pintar o pôster (fase de design). Fazer as duas etapas separadamente aumenta a eficiência e a precisão.

Implementação do Código API do Método de Duas Etapas

import openai

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # Interface unificada da APIYI
)

# ========== Etapa Um: Fazer o modelo gerar/confirmar o conteúdo do texto ==========
text_response = client.chat.completions.create(
    model="gemini-3.1-flash-image-preview",
    messages=[{
        "role": "user",
        "content": "Eu preciso de um pôster promocional para uma cafeteria. Por favor, gere o texto em inglês que deve ser exibido no pôster, de forma concisa e poderosa, não excedendo 20 caracteres. Apenas o texto, sem outros conteúdos."
    }]
)

poster_text = text_response.choices[0].message.content.strip()
print(f"Etapa Um - Texto gerado: {poster_text}")
# Exemplo de saída: "BREW YOUR PERFECT DAY"

# ========== Etapa Dois: Usar o texto confirmado para gerar a imagem ==========
image_response = client.chat.completions.create(
    model="gemini-3.1-flash-image-preview",
    messages=[{
        "role": "user",
        "content": f'Generate an image: A warm-toned coffee shop promotional poster. Display the exact text "{poster_text}" in bold serif font, centered at the top. Background shows a cozy cafe interior with warm lighting.'
    }]
)

print("Etapa Dois - Geração da imagem concluída")

Detalhes Chave do Método de Duas Etapas

Técnica Essencial Dois: A Regra de Ouro dos 25 Caracteres

Essa é a restrição mais importante para a renderização de texto do Nano Banana.

Relação entre a Precisão de Renderização de Texto do Nano Banana e o Número de Caracteres

Estratégias para Lidar com Mais de 25 Caracteres

Quando seu texto realmente excede 25 caracteres, há 3 maneiras de lidar com isso:

Estratégia Um: Dividir em Múltiplas Linhas de Texto Curto

# ❌ Renderizar texto longo de uma vez
prompt = 'Generate a poster with text "ANNUAL SUMMER CLEARANCE SALE - UP TO 70% OFF ALL ITEMS"'

# ✅ Dividir em múltiplas linhas de texto curto
prompt = '''Generate a poster with two lines of text:
Line 1 (large, bold): "SUMMER SALE 70% OFF"
Line 2 (smaller, below): "ALL ITEMS INCLUDED"'''

Estratégia Dois: Adicionar Gradualmente em Múltiplas Rodadas de Diálogo

# Rodada 1: Gerar imagem apenas com o título principal
# Rodada 2: Adicionar subtítulo com base no resultado da rodada anterior
# Rodada 3: Adicionar texto explicativo na parte inferior

Estratégia Três: Usar Imagens para Texto Chave e Composição Pós-produção para Texto Longo

Para cenários que realmente exigem muito texto (como infográficos), é recomendado usar o Nano Banana apenas para gerar títulos curtos e chave, e sobrepor parágrafos longos com ferramentas de design na pós-produção.

Técnica Essencial Três: Aspas Duplas + Especificação Explícita de Fonte

A combinação dessas duas pequenas técnicas pode elevar ainda mais a precisão da renderização de texto.

O Papel das Aspas Duplas

As aspas duplas informam ao modelo: o conteúdo entre aspas é um texto que precisa ser renderizado com precisão, caractere por caractere, e não uma descrição geral.

# ❌ Sem aspas, o modelo pode ter liberdade criativa
prompt = "Generate a sign that says Welcome to Tokyo"
# Pode gerar: "WELCOME TO TOKIO" (erro de ortografia) ou um texto completamente diferente

# ✅ Aspas duplas, renderização exata forçada caractere por caractere
prompt = 'Generate a sign that displays the exact text "Welcome to Tokyo"'
# Saída: "Welcome to Tokyo" (com alta probabilidade de precisão)

Especificação Explícita de Fonte

Especificar explicitamente o tipo de fonte pode ajudar o modelo a escolher formas de fonte mais fáceis de renderizar:

💡 Dica Prática: A fonte serif negrito (bold serif) é o tipo de fonte com a maior precisão de renderização de texto. Por ter traços grossos e estrutura clara, o modelo consegue gerá-la com mais precisão. Fontes manuscritas e ornamentadas têm a menor precisão, evite usá-las para textos críticos.

Técnica Essencial Quatro: Tratamento Especial para Renderização de Texto Multilíngue

O Nano Banana se destaca na renderização de texto multilíngue, mas as estratégias de processamento variam para diferentes idiomas.

Desempenho da Renderização de Texto em Diferentes Idiomas

Modelo de Comando para Renderização de Texto Multilíngue

# Inglês — Mais confiável
prompt = 'Generate a poster with bold text "HELLO WORLD" in white serif font'

# Chinês — Especificar idioma + curto
prompt = 'Generate a poster with Chinese text "欢迎光临" in bold Chinese calligraphy style font, centered'

# Japonês — Especificar idioma
prompt = 'Generate a Japanese store sign with text "いらっしゃいませ" in clean sans-serif Japanese font'

# Idiomas mistos — Processar linha por linha
prompt = '''Generate a bilingual poster:
Top line in English: "GRAND OPENING"
Bottom line in Chinese: "盛大开业"
Both in bold, high contrast against dark background'''

🎯 Dica Técnica: Para renderização de texto multilíngue, é recomendável testar e comparar repetidamente através da plataforma APIYI apiyi.com. Os efeitos variam significativamente entre os idiomas, e testes práticos são mais confiáveis do que parâmetros teóricos. A plataforma suporta a troca rápida entre os modelos Nano Banana Pro e Nano Banana 2.

Técnica Essencial Cinco: Modelo de Comando Estruturado (Indispensável na Prática)

Vamos combinar todas as técnicas anteriores em um modelo de comando padronizado, para usar em diferentes cenários.

Modelo Universal de Comando para Renderização de Texto do Nano Banana

Generate an image:
[Descrição da cena, até 100 caracteres].
Display the exact text "[Seu texto, ≤25 caracteres]" in [Estilo da fonte] font,
positioned at [Posição], [Descrição do tamanho].
The text should be [Cor] with high contrast against the background.
Ensure the text is perfectly legible and correctly spelled.

Exemplos Práticos para Diferentes Cenários

Cenário Um: Cartaz Comercial

prompt = '''Gerar uma imagem:
Um vibrante cartaz promocional de liquidação de verão com fundo de praia tropical.
Exibir o texto exato "SUMMER SALE" em fonte serifada branca e negrito,
posicionado no centro superior, grande e proeminente.
Abaixo dele, exibir "50% OFF" em fonte sans-serif amarela e negrito.
O texto deve ter alto contraste contra o fundo.
Garantir que todo o texto seja perfeitamente legível e corretamente escrito.'''

Cenário Dois: Design de Logotipo

prompt = '''Gerar uma imagem:
Um logotipo minimalista de uma empresa de tecnologia em um fundo branco limpo.
Exibir o texto exato "NEXUS" em fonte sans-serif moderna e negrito,
posicionado no centro, de tamanho médio.
O texto deve ser azul marinho escuro (#1a1a2e).
Garantir que o texto seja perfeitamente legível e corretamente escrito.'''

Cenário Três: Imagem para Mídias Sociais

prompt = '''Gerar uma imagem:
Um cartão de citação inspiradora com fundo de gradiente suave (azul para roxo).
Exibir o texto exato "START NOW" em fonte serifada branca e elegante,
posicionado no centro, grande e proeminente.
O texto deve ser branco puro com uma sombra sutil.
Garantir que o texto seja perfeitamente legível e corretamente escrito.'''

Técnica Essencial Seis: Correção Iterativa em Diálogo Multiturno

Mesmo usando as 5 técnicas anteriores, a renderização de texto ainda pode não ser perfeita. Uma grande vantagem do Nano Banana é o suporte à edição em diálogo multiturno — se não estiver satisfeito, você pode corrigir diretamente com base no resultado da rodada anterior.

Fluxo de Diálogo para Correção de Texto

import openai

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"
)

messages = []

# Rodada 1: Gerar imagem inicial
messages.append({
    "role": "user",
    "content": 'Generate an image: A coffee shop menu board with text "TODAY\'S SPECIAL" in chalk-style white font on dark background'
})

response_1 = client.chat.completions.create(
    model="gemini-3.1-flash-image-preview",
    messages=messages
)
messages.append({"role": "assistant", "content": response_1.choices[0].message.content})

# Rodada 2: Verificar e corrigir texto
messages.append({
    "role": "user",
    "content": 'The text is slightly blurry. Please regenerate with the text "TODAY\'S SPECIAL" rendered more sharply and clearly. Make the font bolder and increase the contrast.'
})

response_2 = client.chat.completions.create(
    model="gemini-3.1-flash-image-preview",
    messages=messages
)

Comandos de Correção Comuns

🚀 Comece Rápido: A edição em diálogo multiturno é ideal para cenários que exigem alta qualidade no efeito do texto. Ao invocar o Nano Banana através da plataforma APIYI apiyi.com, cada rodada de edição custa cerca de $0.02, e 3-4 iterações podem levar a um resultado satisfatório.

Fluxo de Trabalho Completo para Renderização de Texto com Nano Banana

Vamos integrar as 6 técnicas em um fluxo de trabalho padronizado:

Passo Um: Planejar o Conteúdo do Texto

• Definir o texto a ser renderizado (≤25 caracteres)
• Se exceder 25 caracteres, dividir em várias linhas
• Confirmar a ortografia correta

Passo Dois: Geração em Duas Etapas

• Primeiro, permitir que o modelo confirme/otimize o conteúdo do texto
• Em seguida, usar o texto confirmado para gerar a imagem

Passo Três: Otimização do Comando

• Envolver o texto com aspas duplas
• Especificar explicitamente o estilo da fonte
• Usar um modelo estruturado
• Adicionar a restrição "Ensure text is perfectly legible"

Passo Quatro: Verificação e Iteração

• Verificar se o texto do resultado gerado está correto
• Se não estiver satisfeito, corrigir com diálogo multiturno
• Geralmente, 1-3 rodadas são suficientes para um resultado satisfatório

#!/usr/bin/env python3
"""
Fluxo de trabalho de otimização de renderização de texto do Nano Banana
Implementação completa do método de duas etapas + 6 técnicas principais
"""

import openai
import base64
import re
from datetime import datetime

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.apiyi.com/v1"

client = openai.OpenAI(api_key=API_KEY, base_url=BASE_URL)

def render_text_in_image(
    scene_description: str,
    desired_text: str,
    font_style: str = "bold serif",
    text_color: str = "white",
    text_position: str = "centered",
    model: str = "gemini-3.1-flash-image-preview",
    max_fix_rounds: int = 2
):
    """
    Gera uma imagem com texto preciso usando o método de duas etapas

    Args:
        scene_description: Descrição da cena (sem requisitos de texto)
        desired_text: Texto a ser renderizado (sugestão: ≤25 caracteres)
        font_style: Estilo da fonte
        text_color: Cor do texto
        text_position: Posição do texto
        model: Modelo a ser usado
        max_fix_rounds: Número máximo de rodadas de correção
    """
    # Verificar comprimento do texto
    if len(desired_text) > 25:
        print(f"⚠️ O comprimento do texto {len(desired_text)} excede 25 caracteres, a precisão pode diminuir")

    # ===== Passo Um: Confirmar conteúdo do texto =====
    print(f"📝 Passo Um: Confirmar conteúdo do texto → '{desired_text}'")

    text_check = client.chat.completions.create(
        model=model,
        messages=[{
            "role": "user",
            "content": f"Please verify this text is correctly spelled and formatted: '{desired_text}'. Only reply with the verified text, nothing else."
        }]
    )
    verified_text = text_check.choices[0].message.content.strip().strip("'\"")
    print(f"✅ Texto confirmado: '{verified_text}'")

    # ===== Passo Dois: Gerar imagem com texto =====
    print(f"🎨 Passo Dois: Gerando imagem...")

    image_prompt = f'''Generate an image:
{scene_description}.
Display the exact text "{verified_text}" in {font_style} font,
positioned at {text_position}, with {text_color} color.
The text should have high contrast against the background.
Ensure the text is perfectly legible and correctly spelled.'''

    messages = [{"role": "user", "content": image_prompt}]

    response = client.chat.completions.create(
        model=model,
        messages=messages
    )

    content = response.choices[0].message.content
    print(f"✅ Geração de imagem concluída")

    # Salvar imagem
    save_image(content, f"text_render_{datetime.now().strftime('%H%M%S')}.png")
    return content


def save_image(content, filename):
    """Extrai e salva a imagem da resposta"""
    patterns = [
        r'data:image/[^;]+;base64,([A-Za-z0-9+/=]+)',
        r'([A-Za-z0-9+/=]{1000,})'
    ]
    for pattern in patterns:
        match = re.search(pattern, content)
        if match:
            data = base64.b64decode(match.group(1))
            with open(filename, 'wb') as f:
                f.write(data)
            print(f"💾 Salvo em: {filename} ({len(data):,} bytes)")
            return True
    print("⚠️ Dados da imagem não encontrados")
    return False


# ===== Exemplos de Uso =====
if __name__ == "__main__":
    # Exemplo 1: Cartaz comercial
    render_text_in_image(
        scene_description="A vibrant promotional poster with tropical beach background, summer vibes",
        desired_text="SUMMER SALE",
        font_style="bold white serif",
        text_position="top center, large and prominent"
    )

    # Exemplo 2: Logotipo
    render_text_in_image(
        scene_description="A minimalist tech company logo on clean white background",
        desired_text="NEXUS",
        font_style="modern bold sans-serif",
        text_color="dark navy blue",
        text_position="centered"
    )

    # Exemplo 3: Chinês
    render_text_in_image(
        scene_description="A traditional Chinese restaurant sign with red and gold decorations",
        desired_text="福满楼",
        font_style="bold Chinese calligraphy",
        text_color="gold",
        text_position="centered, large"
    )

Comparação da Renderização de Texto entre Nano Banana Pro e Nano Banana 2

Os dois modelos têm focos diferentes na renderização de texto:

Recomendações para Escolha do Modelo de Renderização de Texto

• Pôsteres comerciais/Materiais de marca: Escolha Nano Banana Pro — 94% de precisão + mais estilos de fonte
• Imagens para redes sociais/Protótipos rápidos: Escolha Nano Banana 2 — Rápido + excelente custo-benefício
• Cenários que exigem iterações frequentes: Escolha Nano Banana 2 — A velocidade significa baixo custo de iteração
• Texto multilíngue: A diferença entre os dois é pequena, escolha com base na necessidade de velocidade/custo

Perguntas Frequentes

Resumo

A capacidade de renderização de texto do Nano Banana já é de alto nível no campo da geração de imagens por IA (Pro 94%, Banana 2 87%), mas para utilizar essa capacidade de forma estável, é preciso dominar as técnicas corretas.

6 técnicas essenciais, ordenadas por importância:

1. Método de Duas Etapas — Primeiro gere o texto, depois gere a imagem. É a abordagem recomendada oficialmente e a que oferece os resultados mais significativos.
2. Regra dos 25 Caracteres — Controle o comprimento do texto; textos muito longos devem ser divididos.
3. Aspas Duplas + Especificação de Fonte — Força a renderização letra por letra + escolha fontes com alta precisão.
4. Tratamento Especial para Múltiplas Línguas — Use estratégias diferentes para idiomas diferentes.
5. Modelo de Comando Estruturado — Padronize para aumentar a estabilidade.
6. Correção por Diálogo Multiturno — Se não estiver satisfeito, itere e otimize.

Dominando essas técnicas, a renderização de texto do Nano Banana deixa de ser uma questão de "sorte" e se torna uma capacidade controlável e previsível. Recomendo começar a testar rapidamente através da APIYI (apiyi.com) para encontrar a combinação de parâmetros mais adequada para o seu cenário.

Referências

1. Documentação Oficial do Google – Geração de Imagens com Nano Banana

   • Link: ai.google.dev/gemini-api/docs/image-generation
   • Descrição: Contém a recomendação oficial de "primeiro gerar o texto, depois gerar a imagem".

2. Blog do Google Developers – Dicas de Comando para Nano Banana Pro

   • Link: blog.google/products/gemini/prompting-tips-nano-banana-pro/
   • Descrição: Dicas oficiais de otimização de comando.

3. Blog do Google Developers – Como Criar Comandos para Geração de Imagens com Gemini 2.5 Flash

   • Link: developers.googleblog.com/how-to-prompt-gemini-2-5-flash-image-generation-for-the-best-results/
   • Descrição: Estratégias de otimização para geração de imagens com modelos da série Flash.

📝 Autor: Equipe APIYI | Para intercâmbio técnico e integração de API, visite apiyi.com