Tutoriel complet d’appel de l’API Nano Banana Pro : 44 % moins cher que KIE.ai, intégration rapide au format natif Google

Note de l'auteur : Guide détaillé sur la méthode d'appel de l'API Nano Banana Pro, utilisant le format natif Google Gemini. Via la plateforme APIYI, le coût n'est que de 0,05 $ par appel, soit 44 % de moins que KIE.ai, avec une prise en charge des résolutions d'image 1K/2K/4K.

Lors de l'appel de l'API Nano Banana Pro, beaucoup de développeurs se tournent naturellement vers KIE.ai, mais il existe en réalité une option plus économique et plus stable. Cet article vous explique comment appeler Nano Banana Pro en utilisant le format natif de l'API Google Gemini, et comment réduire le coût par appel à 0,05 $ via la plateforme APIYI — soit 44 % de moins que KIE.ai.

Valeur ajoutée : En lisant cet article, vous maîtriserez la méthode d'appel standard de l'API Nano Banana Pro, comprendrez les différences de prix entre les plateformes et pourrez générer des images de qualité professionnelle en 4K au coût le plus bas.

Aperçu des paramètres clés de l'API Nano Banana Pro

Pourquoi Nano Banana Pro utilise-t-il le format natif de Google ?

Nano Banana Pro (nom du modèle gemini-3-pro-image-preview) est un grand modèle de langage spécialisé dans la génération d'images de niveau professionnel lancé par Google DeepMind. Son API est conçue sur le protocole natif Gemini, ce qui présente des différences fondamentales avec le format OpenAI :

• Paramètres de modalité de réponse : Vous devez déclarer responseModalities: ["IMAGE"] dans la generationConfig, au lieu du response_format d'OpenAI.
• Contrôle de la résolution : La résolution est spécifiée via le champ resolution (1K/2K/4K), et non par des dimensions en pixels.
• Ratio d'aspect : Utilisez une chaîne de caractères aspectRatio (par exemple "16:9"), plutôt que des valeurs numériques de largeur et hauteur.

Si vous essayez d'utiliser le SDK OpenAI pour l'appel, vous rencontrerez des erreurs d'analyse de paramètres. La bonne méthode consiste à utiliser le SDK Google Generative AI ou à envoyer directement des requêtes HTTP vers des points de terminaison compatibles.

Que peut générer Nano Banana Pro ?

Ce modèle est particulièrement performant dans les scénarios suivants, surpassant de loin ses concurrents :

• Rendu de texte multilingue : Permet d'insérer précisément du texte en chinois, anglais, japonais, etc., dans les images, avec des polices claires et sans texte illisible.
• Infographies et visualisation de données : Capable de générer des infographies professionnelles incluant des graphiques, des tableaux et des annotations de données.
• Supports marketing : Affiches, photos de produits, bannières publicitaires, avec une mise en page textuelle précise.
• Présentation de produits : Éclairage physique précis, détails des textures et effets de projection réalistes.
• Illustrations pour présentations : Des illustrations de diapositives conformes à une esthétique professionnelle.

Comparatif des prix de l'API Nano Banana Pro selon les plateformes

Avant de choisir votre plateforme d'appel, examinez attentivement les différences de coûts réels entre les prestataires :

💰 Comparaison des coûts : Sur la base d'une génération de 100 images 4K par jour, le coût mensuel officiel de Google est d'environ 720 $, celui de KIE.ai d'environ 360 $, alors qu'avec APIYI (apiyi.com), il n'est que de 150 $, soit une économie mensuelle de plus de 570 $.

Avantages clés d'APIYI par rapport à KIE.ai :

1. Prix plus bas : 0,05 $ / gén. contre 0,09 $ / gén. chez KIE.ai, soit une économie de 44 %.
2. Compatibilité des formats : support direct du format natif de l'API Gemini de Google, aucune conversion de format n'est requise.
3. Vitesse accrue : lignes d'accélération optimisées, avec une stabilité de réponse supérieure lors des tests.
4. Interface unifiée : supporte simultanément les modèles majeurs comme GPT, Claude et Gemini, facilitant le basculement entre les modèles.

Prise en main rapide de l'API Nano Banana Pro

Méthode 1 : Utiliser le SDK Google Generative AI (recommandé)

Installation du SDK :

pip install google-generativeai

Exemple d'appel minimaliste (Texte-vers-image, 10 lignes de code) :

import google.generativeai as genai
import base64

genai.configure(
    api_key="YOUR_API_KEY",
    # 使用 APIYI 端点，价格仅 $0.05/次
    client_options={"api_endpoint": "vip.apiyi.com"}
)

model = genai.GenerativeModel("gemini-3-pro-image-preview")
response = model.generate_content(
    "一只橙色的猫咪坐在向日葵花田中，阳光明媚，写实风格，4K高清",
    generation_config=genai.GenerationConfig(
        response_modalities=["IMAGE"],
        resolution="4K",
        aspect_ratio="16:9"
    )
)

# 保存图像
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("图像已保存: output.png")

🚀 Démarrage rapide : Après vous être inscrit sur APIYI (apiyi.com), vous obtiendrez une clé API et des crédits de test gratuits. Copiez simplement le code ci-dessus, remplacez YOUR_API_KEY et lancez-le, aucune autre configuration n'est nécessaire.

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


def setup_client(api_key: str):
    """初始化 Nano Banana Pro API 客户端"""
    genai.configure(
        api_key=api_key,
        # 通过 APIYI 调用，价格 $0.05/次，比官方低 79%
        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:
    """
    文生图：根据文字描述生成图像

    Args:
        model: 已初始化的模型实例
        prompt: 图像描述（支持中英文）
        resolution: 输出分辨率 1K/2K/4K
        aspect_ratio: 宽高比
        output_path: 保存路径

    Returns:
        保存的文件路径
    """
    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("API 未返回图像数据，请检查 prompt 是否触发内容过滤")


def image_to_image(
    model,
    prompt: str,
    reference_image_path: str,
    resolution: str = "2K",
    output_path: str = "edited_output.png"
) -> str:
    """
    图生图：基于参考图像进行编辑或风格转换

    Args:
        model: 已初始化的模型实例
        prompt: 编辑指令（如"将背景改为夜晚"）
        reference_image_path: 参考图像路径
        resolution: 输出分辨率
        output_path: 保存路径

    Returns:
        保存的文件路径
    """
    # 读取参考图像
    with open(reference_image_path, "rb") as f:
        image_data = base64.b64encode(f.read()).decode()

    # 检测图像格式
    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("图生图处理失败，请确认参考图像格式正确")


def batch_generate(
    model,
    prompts: List[str],
    resolution: str = "2K",
    output_dir: str = "batch_output"
) -> List[str]:
    """
    批量生成图像

    Args:
        model: 模型实例
        prompts: 提示词列表
        resolution: 分辨率
        output_dir: 输出目录

    Returns:
        生成的文件路径列表
    """
    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)}] 生成成功: {path}")
        except Exception as e:
            print(f"[{i+1}/{len(prompts)}] 生成失败: {e}")
            results.append(None)

    return results


# 使用示例
if __name__ == "__main__":
    # 初始化客户端 - 通过 APIYI apiyi.com 调用，$0.05/次
    model = setup_client("YOUR_APIYI_API_KEY")

    # 文生图示例
    path = text_to_image(
        model,
        prompt="现代简约风格的产品展示图，白色背景，专业摄影棚光效，适合电商使用",
        resolution="4K",
        aspect_ratio="1:1",
        output_path="product_4k.png"
    )
    print(f"4K 产品图已生成: {path}")

    # 图生图示例（修改已有图像）
    edited = image_to_image(
        model,
        prompt="将图中的背景改为户外自然场景，保持主体不变",
        reference_image_path="product_4k.png",
        resolution="4K",
        output_path="product_outdoor.png"
    )
    print(f"编辑后图像: {edited}")

Méthode 2 : Utiliser des requêtes HTTP directes (adapté à tous les langages)

Si vous ne souhaitez pas installer de SDK, vous pouvez également envoyer directement une requête HTTP POST :

import requests
import base64
import json

API_KEY = "YOUR_APIYI_API_KEY"
# APIYI 兼容谷歌原生格式端点
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": "一个充满科技感的数据中心机房，蓝色霓虹灯效果，4K超清，电影质感"
                }
            ]
        }
    ],
    "generationConfig": {
        "responseModalities": ["IMAGE"],
        "resolution": "4K",
        "aspectRatio": "16:9"
    }
}

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

# 提取并保存图像
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("图像生成完成！")

Note : Le code ci-dessus utilise le point de terminaison compatible d'APIYI (apiyi.com). Il est totalement compatible avec le format natif de l'API Gemini de Google, sans aucune conversion nécessaire, pour seulement 0,05 $ par génération.

Détails des paramètres clés de Nano Banana Pro

Tableau complet des résolutions et formats d'image

Formats d'image pris en charge (paramètre aspectRatio) :

Paysage : "16:9"  "4:3"  "3:2"  "21:9"
Carré : "1:1"
Portrait : "9:16"  "3:4"  "2:3"  "9:21"
Personnalisé : "4:5" (Recommandé pour Instagram)

Bonnes pratiques pour les invites (prompts)

Nano Banana Pro est très sensible à la qualité de l'invite. Voici une structure qui a fait ses preuves :

Structure d'une invite de haute qualité : Description du sujet + Définition du style + Éclairage/Texture + Mots-clés de résolution/qualité

✅ Écriture recommandée :
"Une jeune femme portant un Hanfu traditionnel debout dans un jardin classique,
 style peinture Gongbi, lumière naturelle douce, détails riches, ultra-net 4K,
 hautement réaliste"

❌ Écriture à éviter :
"Dessine une fille" (trop vague)

Invites spécifiques pour le rendu de texte (l'atout majeur de Nano Banana Pro) :

"Une affiche d'événement, texte du titre 'Sommet AI 2026',
 bilingue chinois-anglais, style design moderne, fond bleu foncé,
 police du titre blanche, texte clair et lisible"

Cas d'utilisation réels de l'API Nano Banana Pro

Scénario 1 : Génération en masse de photos de produits e-commerce

# Génération en masse d'images de présentation de produits
product_prompts = [
    "Écouteurs Bluetooth sans fil, fond blanc pur, photographie de produit professionnelle, vue de face, 4K",
    "Écouteurs Bluetooth sans fil, fond gris foncé, vue de profil à 45 degrés, détails des écouteurs, 4K",
    "Écouteurs Bluetooth sans fil, scène de vie, porté par un utilisateur, soleil extérieur, 4K"
]

results = batch_generate(
    model,
    product_prompts,
    resolution="4K",
    output_dir="product_images"
)
# 3 images, coût total APIYI : 0,15 $ (contre 0,27 $ chez KIE.ai)

Scénario 2 : Conception de texte pour affiches marketing

L'une des capacités les plus remarquables de Nano Banana Pro est le rendu précis du texte dans les images, ce qui est très difficile pour les modèles similaires :

poster_prompt = """
Concevoir une affiche promotionnelle pour le Double 11 :
- Titre : Grande Promotion Double 11
- Sous-titre : Jusqu'à -50% sur tout le site
- Fond : Dégradé rouge, style festif
- Couleur du texte : Jaune doré, grande police accrocheuse
- Bas de page : Dates de l'événement 11.11-13.11.2026
Exigence : Texte en chinois clair et lisible, mise en page professionnelle
"""

path = text_to_image(model, poster_prompt, resolution="4K", aspect_ratio="9:16")
# Affiche mobile verticale, 0,05 $/image

💡 Conseil d'utilisation : Pour les scénarios nécessitant une génération d'images à grande échelle (comme les photos de produits e-commerce ou les supports marketing), il est recommandé de passer par la plateforme APIYI (apiyi.com). Non seulement le prix est le plus bas, mais elle fournit également des journaux d'appels détaillés et des statistiques d'utilisation pour faciliter le contrôle des coûts.

Scénario 3 : Intégration dans un projet Node.js / TypeScript

Si votre projet utilise JavaScript/TypeScript, vous pouvez l'intégrer directement via des requêtes HTTP :

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

const API_KEY = "VOTRE_CLE_API_APIYI";
// APIYI est compatible avec le format natif de Google, prix : 0,05 $/appel
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;
}

// Exemple d'utilisation
generateImage({
  prompt: "Page de démarrage d'application style moderne et minimaliste, thème sombre, aspect technologique, 4K",
  resolution: "4K",
  aspectRatio: "9:16",
  outputPath: "app_splash.png",
}).then((path) => console.log(`Génération terminée : ${path}`));

Stratégies d'optimisation des coûts

Dans un projet réel, il est crucial de bien contrôler les coûts d'appel de l'API Nano Banana Pro :

🎯 Recommandation : Pour les startups et les développeurs indépendants, il est conseillé de tester d'abord sur la plateforme APIYI (apiyi.com) avec le crédit gratuit. Une fois que la qualité d'image répond à vos besoins, vous pouvez passer à une utilisation à grande échelle. La plateforme propose une facturation à l'usage, sans minimum de consommation.

Questions Fréquemment Posées (FAQ)

Conclusion

Points clés pour l'appel API de Nano Banana Pro :

1. Utilisez le format natif Gemini : Vous devez utiliser le SDK google-generativeai ou des requêtes HTTP natives, car le format du SDK OpenAI est incompatible.
2. APIYI offre le meilleur prix : À 0,05 $ par génération, c'est 44 % moins cher que KIE.ai (0,09 $) et 79 % moins cher que le tarif officiel de Google (0,24 $).
3. 3 paramètres cruciaux : responseModalities: ["IMAGE"], resolution (1K/2K/4K) et aspectRatio.
4. Le rendu de texte est l'avantage majeur : Pour les affiches publicitaires, les infographies ou le contenu bilingue, Nano Banana Pro est actuellement le meilleur choix.

Pour les équipes ayant besoin d'appels en masse ou d'un déploiement en environnement de production, nous recommandons de passer par APIYI (apiyi.com). La plateforme est stable et propose des journaux d'API détaillés ainsi qu'un suivi de la consommation pour vous aider à contrôler précisément vos coûts de génération d'images.

Ressources

1. Documentation de génération d'images de l'API Google Gemini

   • Lien : ai.google.dev/gemini-api/docs/image-generation
   • Description : Spécifications officielles des paramètres de l'API et restrictions d'utilisation pour Nano Banana Pro.

2. SDK Python Google Generative AI

   • Lien : github.com/google-gemini/generative-ai-python
   • Description : Installation du SDK et référence complète de l'API ; le code de cet article est basé sur ce SDK.

3. Documentation d'intégration de Nano Banana Pro sur la plateforme APIYI

   • Lien : docs.apiyi.com
   • Description : Notes de compatibilité d'APIYI avec le format natif de Google et détails sur la tarification.

Auteur : Équipe technique
Échanges techniques : N'hésitez pas à partager vos créations réalisées avec Nano Banana Pro dans l'espace commentaires. Pour plus d'astuces sur la génération d'images par IA, rendez-vous sur la communauté technique d'APIYI (apiyi.com).