Tutorial completo de chamada da API Nano Banana Pro: 44% mais barato que o KIE.ai, integração rápida no formato nativo do Google

Nota do autor: Explicação detalhada do método de chamada da API Nano Banana Pro, utilizando o formato nativo do Google Gemini; através da plataforma APIYI, custa apenas $0,05/chamada, 44% mais barato que o KIE.ai, com suporte para geração de imagens em resoluções 1K/2K/4K.

Ao chamar a API do Nano Banana Pro, muitos desenvolvedores escolhem o KIE.ai de primeira, mas na verdade existe uma opção mais barata e estável. Este artigo apresentará como usar o formato nativo da API Google Gemini para chamar o Nano Banana Pro e, através da plataforma APIYI, reduzir o custo por chamada para $0,05 — 44% menos que o KIE.ai.

Valor central: Ao ler este artigo, você dominará a forma padrão de chamada da API Nano Banana Pro, entenderá as diferenças de preço entre as plataformas e poderá gerar imagens 4K de nível profissional com o menor custo possível.

Nano Banana Pro API 核心参数一览

为什么 Nano Banana Pro 要用谷歌原生格式？

Nano Banana Pro（模型名 gemini-3-pro-image-preview）是 Google DeepMind 推出的专业级图像生成模型，其 API 设计基于 Gemini 原生协议，与 OpenAI 格式存在本质差异：

• 响应模态参数：需在 generationConfig 中声明 responseModalities: ["IMAGE"]，而非 OpenAI 的 response_format
• 分辨率控制：通过 resolution 字段指定 1K/2K/4K，而非像素尺寸
• 宽高比：使用 aspectRatio 字符串（如 "16:9"），而非宽高数值

如果你尝试用 OpenAI SDK 格式调用，会遇到参数解析错误。正确做法是使用 Google Generative AI SDK 或者直接发送 HTTP 请求到兼容端点。

Nano Banana Pro 能生成什么？

这款模型在以下场景表现尤为突出，远超同类竞品：

• 多语言文字渲染：支持中文、英文、日文等多语言文字精准嵌入图像，字体清晰无乱码
• 信息图与数据可视化：可生成包含图表、表格、数据标注的专业信息图
• 营销素材：海报、产品图、广告横幅，支持文字精准排版
• 产品展示：精确的物理光照、材质细节、投影效果
• 演示文稿配图：符合专业审美的幻灯片插图

Comparação de Preços da API Nano Banana Pro entre Plataformas

Antes de escolher uma plataforma para suas chamadas de API, entenda bem a diferença real de custos entre elas:

💰 Comparação de Custos: Calculando a geração de 100 imagens 4K por dia, o custo mensal no Google oficial seria de aproximadamente $720, na KIE.ai cerca de $360, enquanto através da APIYI (apiyi.com) custa apenas $150 — uma economia mensal superior a $570.

Principais vantagens da APIYI em relação à KIE.ai:

1. Preço mais baixo: $0.05/uso vs $0.09/uso da KIE.ai, uma economia de 44%.
2. Compatibilidade de formato: Suporte direto ao formato nativo da API Gemini do Google, sem necessidade de conversão.
3. Velocidade superior: Rotas de aceleração otimizadas, com resposta mais estável em testes práticos.
4. Interface unificada: Suporte simultâneo aos principais modelos como GPT, Claude e Gemini, facilitando a alternância entre eles.

Guia Rápido da API Nano Banana Pro

Método 1: Usando o SDK do Google Generative AI (Recomendado)

Instale o SDK:

pip install google-generativeai

Exemplo simples de chamada (Texto-para-Imagem, 10 linhas de código):

import google.generativeai as genai
import base64

genai.configure(
    api_key="SUA_CHAVE_API",
    # Usando o endpoint da APIYI, o preço é de apenas $0.05/uso
    client_options={"api_endpoint": "vip.apiyi.com"}
)

model = genai.GenerativeModel("gemini-3-pro-image-preview")
response = model.generate_content(
    "Um gatinho laranja sentado em um campo de girassóis, ensolarado, estilo realista, 4K HD",
    generation_config=genai.GenerationConfig(
        response_modalities=["IMAGE"],
        resolution="4K",
        aspect_ratio="16:9"
    )
)

# Salvar a imagem
for part in response.candidates[0].content.parts:
    if part.inline_data:
        with open("output.png", "wb") as f:
            f.write(base64.b64decode(part.inline_data.data))
        print("Imagem salva: output.png")

🚀 Início Rápido: Após se registrar na APIYI (apiyi.com), você receberá sua API Key e créditos de teste gratuitos. Basta copiar o código acima, substituir SUA_CHAVE_API e rodar, sem necessidade de outras configurações.

import google.generativeai as genai
import base64
import os
from pathlib import Path
from typing import Optional, List


def setup_client(api_key: str):
    """Inicializa o cliente da API Nano Banana Pro"""
    genai.configure(
        api_key=api_key,
        # Chamada via APIYI, preço de $0.05/uso, 79% mais barato que o oficial
        client_options={"api_endpoint": "vip.apiyi.com"}
    )
    return genai.GenerativeModel("gemini-3-pro-image-preview")


def text_to_image(
    model,
    prompt: str,
    resolution: str = "2K",       # 1K / 2K / 4K
    aspect_ratio: str = "1:1",    # 1:1 / 16:9 / 9:16 / 4:3 / 3:4
    output_path: str = "output.png"
) -> str:
    """
    Texto-para-Imagem: Gera uma imagem baseada na descrição textual

    Args:
        model: Instância do modelo inicializada
        prompt: Comando de descrição da imagem (suporta vários idiomas)
        resolution: Resolução de saída 1K/2K/4K
        aspect_ratio: Proporção da imagem
        output_path: Caminho para salvar o arquivo

    Returns:
        Caminho do arquivo salvo
    """
    response = model.generate_content(
        prompt,
        generation_config=genai.GenerationConfig(
            response_modalities=["IMAGE"],
            resolution=resolution,
            aspect_ratio=aspect_ratio
        )
    )

    for part in response.candidates[0].content.parts:
        if part.inline_data and part.inline_data.mime_type.startswith("image/"):
            with open(output_path, "wb") as f:
                f.write(base64.b64decode(part.inline_data.data))
            return output_path

    raise ValueError("A API não retornou dados de imagem. Verifique se o comando acionou filtros de conteúdo.")


def image_to_image(
    model,
    prompt: str,
    reference_image_path: str,
    resolution: str = "2K",
    output_path: str = "edited_output.png"
) -> str:
    """
    Imagem-para-Imagem: Edição ou transferência de estilo baseada em uma imagem de referência

    Args:
        model: Instância do modelo inicializada
        prompt: Comando de edição (ex: 'mude o fundo para uma cena noturna')
        reference_image_path: Caminho da imagem de referência
        resolution: Resolução de saída
        output_path: Caminho para salvar o arquivo

    Returns:
        Caminho do arquivo salvo
    """
    # Ler imagem de referência
    with open(reference_image_path, "rb") as f:
        image_data = base64.b64encode(f.read()).decode()

    # Detectar formato da imagem
    ext = Path(reference_image_path).suffix.lower()
    mime_map = {".jpg": "image/jpeg", ".jpeg": "image/jpeg",
                ".png": "image/png", ".webp": "image/webp"}
    mime_type = mime_map.get(ext, "image/png")

    response = model.generate_content(
        [
            {"inline_data": {"mime_type": mime_type, "data": image_data}},
            prompt
        ],
        generation_config=genai.GenerationConfig(
            response_modalities=["IMAGE"],
            resolution=resolution
        )
    )

    for part in response.candidates[0].content.parts:
        if part.inline_data and part.inline_data.mime_type.startswith("image/"):
            with open(output_path, "wb") as f:
                f.write(base64.b64decode(part.inline_data.data))
            return output_path

    raise ValueError("Falha no processamento Imagem-para-Imagem. Verifique se o formato da imagem de referência está correto.")


def batch_generate(
    model,
    prompts: List[str],
    resolution: str = "2K",
    output_dir: str = "batch_output"
) -> List[str]:
    """
    Geração de imagens em lote

    Args:
        model: Instância do modelo
        prompts: Lista de comandos (prompts)
        resolution: Resolução
        output_dir: Diretório de saída

    Returns:
        Lista de caminhos dos arquivos gerados
    """
    os.makedirs(output_dir, exist_ok=True)
    results = []

    for i, prompt in enumerate(prompts):
        output_path = f"{output_dir}/image_{i+1:03d}.png"
        try:
            path = text_to_image(model, prompt, resolution, output_path=output_path)
            results.append(path)
            print(f"[{i+1}/{len(prompts)}] Gerada com sucesso: {path}")
        except Exception as e:
            print(f"[{i+1}/{len(prompts)}] Falha na geração: {e}")
            results.append(None)

    return results


# Exemplo de uso
if __name__ == "__main__":
    # Inicializar cliente - Chamada via APIYI (apiyi.com), $0.05/uso
    model = setup_client("SUA_CHAVE_API_APIYI")

    # Exemplo de Texto-para-Imagem
    path = text_to_image(
        model,
        prompt="Foto de exibição de produto em estilo minimalista moderno, fundo branco, iluminação de estúdio profissional, ideal para e-commerce",
        resolution="4K",
        aspect_ratio="1:1",
        output_path="produto_4k.png"
    )
    print(f"Imagem de produto 4K gerada: {path}")

    # Exemplo de Imagem-para-Imagem (modificar imagem existente)
    edited = image_to_image(
        model,
        prompt="Mude o fundo da imagem para um cenário natural ao ar livre, mantendo o objeto principal inalterado",
        reference_image_path="produto_4k.png",
        resolution="4K",
        output_path="produto_outdoor.png"
    )
    print(f"Imagem editada: {edited}")

Método 2: Usando requisição HTTP direta (Ideal para qualquer linguagem)

Se você preferir não instalar o SDK, pode enviar uma requisição HTTP POST diretamente:

import requests
import base64
import json

API_KEY = "SUA_CHAVE_API_APIYI"
# Endpoint da APIYI compatível com o formato nativo do Google
BASE_URL = "https://vip.apiyi.com/v1beta/models/gemini-3-pro-image-preview:generateContent"

headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {API_KEY}"
}

payload = {
    "contents": [
        {
            "role": "user",
            "parts": [
                {
                    "text": "Um data center futurista e tecnológico, efeito de luzes neon azuis, 4K ultra HD, qualidade cinematográfica"
                }
            ]
        }
    ],
    "generationConfig": {
        "responseModalities": ["IMAGE"],
        "resolution": "4K",
        "aspectRatio": "16:9"
    }
}

response = requests.post(BASE_URL, headers=headers, json=payload)
data = response.json()

# Extrair e salvar a imagem
image_data = data["candidates"][0]["content"]["parts"][0]["inlineData"]["data"]
with open("datacenter_4k.png", "wb") as f:
    f.write(base64.b64decode(image_data))
print("Geração de imagem concluída!")

Nota: O código acima utiliza o endpoint compatível da APIYI (apiyi.com), que é totalmente compatível com o formato original da API Gemini do Google, sem necessidade de conversões, por apenas $0.05/uso.

Detalhes dos Parâmetros Principais do Nano Banana Pro

Tabela Completa de Parâmetros de Resolução e Proporção

Proporções suportadas (valor do parâmetro aspectRatio):

Horizontal: "16:9"  "4:3"  "3:2"  "21:9"
Quadrado: "1:1"
Vertical: "9:16"  "3:4"  "2:3"  "9:21"
Personalizado: "4:5" (Recomendado para Instagram)

Melhores Práticas de Comandos

O Nano Banana Pro é bem sensível à qualidade dos comandos. Aqui estão alguns padrões de escrita que funcionam bem:

Estrutura de um comando de alta qualidade: Descrição do assunto + Definição de estilo + Iluminação/Textura + Resolução/Palavras de qualidade

✅ Forma recomendada:
"Uma jovem vestindo um Hanfu tradicional em pé em um jardim clássico,
 estilo de pintura Gongbi, luz natural suave, rica em detalhes, 4K ultra-nítido,
 altamente realista"

❌ O que evitar:
"Desenhe uma garota" (muito vago)

Comandos específicos para renderização de texto (A principal vantagem do Nano Banana Pro):

"Um pôster de evento, título '2026 AI Summit',
 bilíngue (chinês e inglês), estilo de design moderno, fundo azul marinho,
 fonte do título em branco, texto claro e legível"

Cenários Reais de Uso da API Nano Banana Pro

Cenário 1: Geração em lote de imagens de produtos para e-commerce

# Geração em lote de imagens de exibição para e-commerce
product_prompts = [
    "Fones de ouvido Bluetooth sem fio, fundo branco puro, fotografia profissional de produto, visão frontal, 4K",
    "Fones de ouvido Bluetooth sem fio, fundo cinza escuro, ângulo de 45 graus, detalhes do fone, 4K",
    "Fones de ouvido Bluetooth sem fio, estilo de vida, foto de uso, luz solar externa, 4K"
]

results = batch_generate(
    model,
    product_prompts,
    resolution="4K",
    output_dir="product_images"
)
# 3 imagens, custo total na APIYI: $0.15 (na KIE.ai seria $0.27)

Cenário 2: Design de texto em pôsteres de marketing

Uma das capacidades mais marcantes do Nano Banana Pro é a renderização precisa de texto em imagens, algo que modelos similares têm dificuldade em fazer:

poster_prompt = """
Crie um pôster promocional para a Grande Promoção 11.11:
- Título: Grande Promoção 11.11
- Subtítulo: Tudo com até 50% de desconto
- Fundo: Degradê vermelho, estilo festivo e alegre
- Cor do texto: Dourado, fonte grande e chamativa
- Rodapé: Data do evento 11.11.2026 - 13.11.2026
Requisitos: Texto claro e legível, layout profissional
"""

path = text_to_image(model, poster_prompt, resolution="4K", aspect_ratio="9:16")
# Pôster vertical para celular, $0.05/imagem

💡 Sugestão de cenário: Para casos que exigem geração de imagens em larga escala (como fotos de produtos ou materiais de marketing), recomendamos a chamada através da plataforma APIYI (apiyi.com). Além do menor preço, ela oferece logs detalhados e estatísticas de uso, facilitando o controle de custos.

Cenário 3: Integração em projetos Node.js / TypeScript

Se o seu projeto utiliza JavaScript/TypeScript, você pode integrar diretamente via requisição HTTP:

import axios from "axios";
import * as fs from "fs";

const API_KEY = "SUA_CHAVE_API_APIYI";
// APIYI compatível com o formato nativo do Google, preço $0.05/chamada
const BASE_URL = "https://vip.apiyi.com/v1beta/models/gemini-3-pro-image-preview:generateContent";

interface GenerateImageOptions {
  prompt: string;
  resolution?: "1K" | "2K" | "4K";
  aspectRatio?: string;
  outputPath?: string;
}

async function generateImage({
  prompt,
  resolution = "2K",
  aspectRatio = "1:1",
  outputPath = "output.png",
}: GenerateImageOptions): Promise<string> {
  const response = await axios.post(
    BASE_URL,
    {
      contents: [{ role: "user", parts: [{ text: prompt }] }],
      generationConfig: {
        responseModalities: ["IMAGE"],
        resolution,
        aspectRatio,
      },
    },
    {
      headers: {
        "Content-Type": "application/json",
        Authorization: `Bearer ${API_KEY}`,
      },
    }
  );

  const imageData =
    response.data.candidates[0].content.parts[0].inlineData.data;
  fs.writeFileSync(outputPath, Buffer.from(imageData, "base64"));
  return outputPath;
}

// Exemplo de uso
generateImage({
  prompt: "Tela de abertura de App em estilo moderno e minimalista, tema escuro, alta tecnologia, 4K",
  resolution: "4K",
  aspectRatio: "9:16",
  outputPath: "app_splash.png",
}).then((path) => console.log(`Geração concluída: ${path}`));

Estratégias de Otimização de Custos

Em projetos reais, é fundamental controlar o custo das chamadas da API do Nano Banana Pro:

🎯 Recomendação de escolha: Para equipes de startups e desenvolvedores independentes, recomendamos começar testando com a cota gratuita na plataforma APIYI (apiyi.com). Após validar que a qualidade da imagem atende às necessidades, você pode escalar as chamadas. A plataforma oferece pagamento por uso (pay-as-you-go), sem exigência de consumo mínimo.

Perguntas Frequentes

Resumo

Pontos essenciais para a chamada da API do Nano Banana Pro:

1. Use o formato nativo da Google: É obrigatório usar o SDK google-generativeai ou requisições HTTP nativas; o formato do SDK da OpenAI não é compatível.
2. Melhor preço na APIYI: $0,05 por geração, o que é 44% mais barato que a KIE.ai ($0,09) e 79% mais barato que o preço oficial da Google ($0,24).
3. 3 parâmetros cruciais: responseModalities: ["IMAGE"], resolution (1K/2K/4K) e aspectRatio.
4. Renderização de texto é a maior vantagem: Para pôsteres de marketing, infográficos e conteúdos bilíngues, o Nano Banana Pro é a melhor escolha atual.

Para equipes que precisam de chamadas em lote ou implantação em ambiente de produção, recomendamos a integração via APIYI (apiyi.com). A plataforma é estável e oferece logs detalhados da API e monitoramento de uso, ajudando você a controlar com precisão os custos de geração de imagens.

Referências

1. Documentação de Geração de Imagens da API Google Gemini

   • Link: ai.google.dev/gemini-api/docs/image-generation
   • Descrição: Descrição oficial dos parâmetros da API e restrições de uso do Nano Banana Pro

2. Google Generative AI Python SDK

   • Link: github.com/google-gemini/generative-ai-python
   • Descrição: Instalação do SDK e referência completa da API; o código deste artigo é baseado neste SDK

3. Documentação de Integração do Nano Banana Pro na plataforma APIYI

   • Link: docs.apiyi.com
   • Descrição: Instruções de compatibilidade da APIYI com o formato nativo do Google e detalhes de preços

Autor: Equipe Técnica
Comunidade Técnica: Sinta-se à vontade para compartilhar nos comentários as obras que você criou com o Nano Banana Pro. Para mais dicas de geração de imagens com IA, visite a comunidade técnica da APIYI em apiyi.com