3 maneiras de resolver a saída de imagens PNG da API Nano Banana 2: reduzindo imagens 4K de 30MB para 8MB

title: "Desvendando o Nano Banana 2 API: Formatos de Imagem e Otimização de 4K"
description: "Entenda por que o Nano Banana 2 API retorna imagens com formato inconsistente e descubra o motivo técnico por trás da redução de 30MB para 8MB em imagens 4K."

Nota do autor: Detalhamento sobre como o Nano Banana 2 API gera imagens em formato PNG em vez de JPEG, análise técnica da redução de volume de 30MB para 8MB em imagens 4K no AI Studio, e as diferenças de controle de formato entre Vertex AI e AI Studio.

Muitos desenvolvedores que utilizam o Nano Banana 2 API para geração de imagens se deparam com esta dúvida: A API retorna dados em base64, mas o arquivo resultante é PNG ou JPEG? O que é ainda mais intrigante é que, na mesma resolução 4K, o volume das imagens geradas pelo AI Studio caiu drasticamente de mais de 30MB para cerca de 8MB. Este artigo analisa os mecanismos subjacentes da API para esclarecer a verdade sobre o controle de formato e a variação de volume.

Valor central: Ao terminar de ler este artigo, você dominará a forma correta de obter saídas em formato PNG pelo Nano Banana 2 API e entenderá a causa fundamental da redução no volume das imagens 4K.

Pontos principais sobre o formato de saída de imagem do Nano Banana 2 API

Primeiro, vamos esclarecer um fato crucial: os dados de imagem retornados pelo Nano Banana 2 API são codificados em base64, mas o base64 é apenas uma codificação de transporte; o que realmente determina o formato da imagem são os dados de bytes subjacentes.

Mecanismos subjacentes da saída de imagem do Nano Banana 2 API

O Nano Banana 2 (ID do modelo: gemini-3.1-flash-image-preview) retorna a saída de imagem através do objeto inlineData, com a seguinte estrutura:

{
  "candidates": [{
    "content": {
      "parts": [{
        "inlineData": {
          "mime_type": "image/png",
          "data": "<BASE64_IMAGE_DATA>"
        }
      }]
    }
  }]
}

Existe um bug confirmado oficialmente pelo Google (GitHub Issue #1824): o campo mime_type na resposta é declarado como image/png, mas os dados de bytes decodificados podem, na verdade, estar no formato JPEG. Isso significa que você não pode confiar apenas no tipo MIME retornado pela API; é necessário determinar o formato real através dos magic bytes do cabeçalho do arquivo.

O método de verificação é simples: o cabeçalho do arquivo JPEG é \xff\xd8, e o cabeçalho do PNG é \x89PNG\r\n\x1a\n.

3 métodos para obter imagens em formato PNG da API Nano Banana 2

Este é o ponto central deste artigo: como garantir que você receba imagens realmente no formato PNG.

Método 1: Conversão via cliente Python (Recomendado para AI Studio)

Como a Gemini API do AI Studio não oferece suporte ao controle de formato no lado do servidor, a maneira mais confiável é realizar a conversão no lado do cliente:

import base64
from PIL import Image
from io import BytesIO

# Invocar o Nano Banana 2 para gerar a imagem
from google import genai
from google.genai import types

client = genai.Client(api_key="YOUR_API_KEY")

response = client.models.generate_content(
    model="gemini-3.1-flash-image-preview",
    contents=["Um gato laranja cochilando sob o sol"],
    config=types.GenerateContentConfig(
        response_modalities=["TEXT", "IMAGE"],
        image_config=types.ImageConfig(
            image_size="4K",
            aspect_ratio="1:1"
        ),
    )
)

# Salvar no formato PNG (independentemente do formato retornado pela API)
for part in response.parts:
    if image := part.as_image():
        image.save("output.png", format="PNG")  # Força o salvamento sem perdas em PNG

O ponto crucial aqui é especificar explicitamente format="PNG" dentro de image.save("output.png", format="PNG"). Se você não definir o parâmetro format, o Pillow tentará inferir o formato com base na extensão do arquivo — o que funciona na maioria das vezes, mas declarar explicitamente é muito mais seguro.

import base64
from PIL import Image
from io import BytesIO

def detect_and_save(base64_data: str, output_path: str, target_format: str = "PNG"):
    """
    Detecta o formato real da imagem base64 e converte para salvamento

    Args:
        base64_data: dados da imagem codificados em base64
        output_path: caminho do arquivo de saída
        target_format: formato alvo (PNG/JPEG/WEBP)
    """
    image_bytes = base64.b64decode(base64_data)

    # Detecta o formato real através dos magic bytes
    if image_bytes[:2] == b'\xff\xd8':
        actual_format = "JPEG"
    elif image_bytes[:8] == b'\x89PNG\r\n\x1a\n':
        actual_format = "PNG"
    elif image_bytes[:4] == b'RIFF':
        actual_format = "WEBP"
    else:
        actual_format = "Desconhecido"

    print(f"Formato real retornado pela API: {actual_format}")
    print(f"Tamanho dos dados originais: {len(image_bytes) / 1024 / 1024:.2f} MB")

    # Abre com Pillow e converte para o formato alvo
    img = Image.open(BytesIO(image_bytes))
    print(f"Dimensões da imagem: {img.size[0]}x{img.size[1]}")

    if target_format == "PNG":
        img.save(output_path, format="PNG", optimize=True)
    elif target_format == "JPEG":
        img.save(output_path, format="JPEG", quality=95)
    elif target_format == "WEBP":
        img.save(output_path, format="WEBP", quality=90)

    import os
    saved_size = os.path.getsize(output_path) / 1024 / 1024
    print(f"Tamanho do arquivo após salvar: {saved_size:.2f} MB ({target_format})")

Método 2: Controle de formato no servidor via Vertex AI

Se você utiliza o Vertex AI para invocar o Nano Banana 2, pode especificar o formato de saída diretamente na requisição. Esta é a única forma que suporta controle de formato no lado do servidor:

import os
from google import genai
from google.genai import types
from google.genai.types import HttpOptions

os.environ["GOOGLE_CLOUD_PROJECT"] = "your-project-id"
os.environ["GOOGLE_CLOUD_LOCATION"] = "global"
os.environ["GOOGLE_GENAI_USE_VERTEXAI"] = "True"

client = genai.Client(http_options=HttpOptions(api_version="v1"))

response = client.models.generate_content(
    model="gemini-3.1-flash-image-preview",
    contents=["Um gato laranja cochilando sob o sol"],
    config=types.GenerateContentConfig(
        response_modalities=["TEXT", "IMAGE"],
        image_config=types.ImageConfig(
            image_size="4K",
            aspect_ratio="1:1",
            output_mime_type="image/png",         # Especifica a saída PNG
            # compression_quality=75,             # Válido apenas para JPEG, 0-100
        ),
    )
)

Método 3: Processamento unificado via serviço proxy de API da APIYI

Ao realizar a invocação através do serviço proxy de API da APIYI, a plataforma lida automaticamente com problemas de compatibilidade de formato:

import openai

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

response = client.chat.completions.create(
    model="gemini-3.1-flash-image-preview",
    messages=[
        {"role": "user", "content": "Um gato laranja cochilando sob o sol"}
    ]
)

🎯 Sugestão de escolha de formato: Escolha PNG para qualidade sem perdas e JPEG para tamanhos menores (quality=95 é quase sem perdas).
Recomendamos realizar testes através da plataforma APIYI apiyi.com, pois ela unifica o tratamento da compatibilidade de formatos, evitando o trabalho manual de decodificação base64 e detecção de formato.

Comparação da capacidade de controle de formato da API Nano Banana 2

Este é um ponto onde muitos desenvolvedores se confundem: as capacidades de controle de formato entre o AI Studio e o Vertex AI são completamente diferentes.

Comparação de suporte a parâmetros de formato da API Nano Banana 2

Isso significa que: se você invocar o Nano Banana 2 usando o AI Studio, não conseguirá controlar no servidor se a saída será PNG ou JPEG. O formato retornado pela API depende do comportamento padrão do servidor do Google — e esse comportamento padrão atualmente possui um bug (afirma ser PNG, mas na verdade pode ser JPEG).

Comparação de tamanho entre diferentes formatos da API Nano Banana 2

Para a mesma imagem 4K (4096×4096) gerada por IA, a diferença de tamanho entre os formatos é enorme:

O PNG é um formato sem perdas, e o tamanho do arquivo reflete diretamente a complexidade das informações da imagem (valor de entropia). Quanto mais ricos os detalhes e mais complexas as texturas, maior será o arquivo PNG. Esta é a base fundamental para entender a mudança no tamanho das imagens 4K na próxima seção.

Dica: Se o seu cenário de aplicação não exige canal de transparência, o JPEG quality=95 é visualmente quase indistinguível do PNG, mas o tamanho é apenas 1/4 a 1/3 do PNG. Através da APIYI apiyi.com, você pode comparar rapidamente a diferença de efeito entre os dois formatos em cenários reais.

A verdade sobre a redução do tamanho das imagens 4K da API Nano Banana 2

Esta é a dúvida que mais preocupa os usuários: por que, mantendo a mesma resolução 4K, as imagens geradas pelo Nano Banana 2 no AI Studio caíram de mais de 30 MB para cerca de 8 MB?

A mudança no tamanho das imagens da API Nano Banana 2 não é um problema de formato

Primeiro, vamos eliminar um equívoco comum: a redução não aconteceu porque o formato mudou de PNG para JPEG. Se você verificar os magic bytes, notará que o formato dos dados retornados permanece o mesmo.

O verdadeiro motivo é que o Google ajustou os parâmetros de computação do modelo no servidor, o que reduziu a complexidade da informação (valor de entropia) da imagem gerada. Existem três mecanismos específicos:

Motivo 1: Redução nas etapas de inferência (principal motivo)

Ao gerar imagens, os modelos de difusão passam por várias rodadas de iteração de remoção de ruído (denoising). O número de etapas de remoção de ruído determina diretamente o nível de detalhamento da imagem:

• Antes: Provavelmente usava de 50 a 100 etapas, gerando imagens com texturas ricas e detalhes refinados.
• Agora: Pode ter sido reduzido para 20 a 40 etapas, resultando em uma imagem clara, mas com perda de detalhes locais e complexidade de textura.

Menos etapas de remoção de ruído → menos detalhes de textura → menor entropia de informação → tamanho menor após a compressão sem perdas do PNG.

Isso não é apenas uma "queda na qualidade da imagem" — a olho nu, a composição geral e as cores podem parecer semelhantes, mas, ao ampliar no nível de pixel, você notará que as microtexturas e os gradientes de cor não são tão delicados quanto antes.

Motivo 2: Otimização de pré-processamento no servidor

Após a geração e antes da codificação em PNG, o Google pode ter adicionado um leve processamento de redução de ruído e simplificação de cores:

• A supressão sutil de ruído reduz detalhes de alta frequência.
• A redução nos níveis de gradiente de cor diminui a precisão das transições de cores.
• Esses processamentos tornam a compressão PNG mais eficiente (mais pixels semelhantes, maior taxa de compressão).

Motivo 3: Ajuste na precisão de ponto flutuante

A inferência do modelo pode ter mudado de FP32 (ponto flutuante de 32 bits) para FP16 (ponto flutuante de 16 bits):

• A precisão de cálculo do FP16 é metade da do FP32, e o uso da GPU também é drasticamente reduzido.
• A redução na precisão faz com que os gradientes de cor não sejam tão suaves quanto antes, o que acaba se refletindo na redução do tamanho do arquivo PNG.

Linha do tempo da mudança no tamanho das imagens da API Nano Banana 2

Conclusão principal: Este é um compromisso que o Google fez para equilibrar o volume de usuários e a qualidade do serviço durante o período de escassez de capacidade de TPU. A resolução (número de pixels) permanece a mesma, mas a densidade de informação (a quantidade de informação única que cada pixel carrega) diminuiu. Os usuários não conseguem restaurar a qualidade anterior de 30 MB através dos parâmetros da API.

🎯 Sugestões de ação: Se você precisa de uma qualidade de detalhes extremamente alta, tente: 1) Usar o parâmetro compressionQuality=100 do Vertex AI; 2) Enfatizar requisitos de detalhes e texturas no seu comando; 3) Gerar em 2K e usar um modelo de super-resolução para ampliar para 4K.
Através da APIYI (apiyi.com), você pode testar simultaneamente os efeitos de diferentes combinações de parâmetros para encontrar o melhor equilíbrio entre qualidade e tamanho.

Perguntas frequentes

Resumo

Pontos principais sobre o controle de formato de saída de imagem da API Nano Banana 2:

1. O AI Studio não suporta controle de formato no lado do servidor: É necessário decodificar o base64 no lado do cliente e usar a biblioteca Pillow para salvar explicitamente como PNG, atentando-se à verificação dos magic bytes para confirmar o formato real.
2. O Vertex AI suporta outputMimeType: Você pode especificar diretamente image/png ou image/jpeg na requisição, além de definir a qualidade de compressão JPEG.
3. A redução de tamanho em 4K é um ajuste de poder computacional: A queda de 30MB para 8MB não se deve a uma mudança de formato, mas sim à redução de passos de inferência e precisão de ponto flutuante feita pelo Google, o que diminui a entropia da informação; os usuários não conseguem restaurar isso via parâmetros.

Ao compreender esses mecanismos subjacentes, você poderá escolher a estratégia de salvamento de formato mais adequada para suas necessidades reais.

Recomendamos utilizar a APIYI (apiyi.com) para validar rapidamente os efeitos de diferentes formatos e parâmetros. A plataforma oferece créditos gratuitos e uma interface unificada, suportando diversas formas de invocação do Nano Banana 2.

📚 Referências

1. Documentação de desenvolvimento de geração de imagens do Gemini: Referência oficial da API, incluindo a descrição dos parâmetros ImageConfig.

   • Link: ai.google.dev/gemini-api/docs/image-generation
   • Nota: Entenda os parâmetros e limitações ao chamar via AI Studio.

2. Referência do ImageOutputOptions no Vertex AI: Documentação completa dos parâmetros de controle de formato do Vertex AI.

   • Link: docs.cloud.google.com/vertex-ai/generative-ai/docs/reference/rest/Shared.Types/ImageOutputOptions
   • Nota: Contém explicações detalhadas sobre mimeType e compressionQuality.

3. GitHub Issue #1824 – Incompatibilidade de tipo MIME: Relatório de bug onde a API declara PNG, mas retorna JPEG.

   • Link: github.com/googleapis/python-genai/issues/1824
   • Nota: Entenda os detalhes técnicos e as soluções temporárias para este problema conhecido.

4. Central de Documentação da APIYI: Guia de controle de formato para invocar o Nano Banana 2 via interface unificada.

   • Link: docs.apiyi.com
   • Nota: Ideal para desenvolvedores que precisam simplificar o fluxo de processamento de formatos.

Autor: Equipe Técnica da APIYI
Troca técnica: Sinta-se à vontade para discutir na seção de comentários. Para mais materiais, visite a central de documentação da APIYI em docs.apiyi.com.