|

Erreur de décodage Base64 sur gemini-3-pro-image-preview : 6 causes principales et guide de réparation complet

ParAPIYI - Stable and affordable AI API

Note de l'auteur : Vous recevez une erreur "Base64 decoding failed 400" lors de l'invocation de gemini-3-pro-image-preview ? Cet article analyse les 6 causes fréquentes à partir du message d'erreur original, fournit des exemples corrects en Python, JavaScript et cURL, et propose un plan de dépannage en 5 étapes.

Vous rencontrez cette erreur 400 lors de l'appel de l'interface gemini-3-pro-image-preview ?

{
  "status_code": 400,
  "error": {
    "message": "Invalid value at 'contents[0].parts[0].inline_data.data' (TYPE_BYTES), Base64 decoding failed for \"/9j/4AAQSkZJ...\" (request id: 2026050117522815159336234238114)",
    "type": "shell_api_error",
    "code": 400
  }
}

Ce n'est pas un problème lié au service API, mais plutôt au fait que les données Base64 dans le champ inline_data.data du corps de la requête ne peuvent pas être correctement décodées par le backend de Gemini. La chaîne /9j/4AAQSkZJ dans le message d'erreur est l'en-tête Base64 standard d'un fichier JPEG (correspondant aux octets binaires FF D8 FF E0), ce qui indique que le début de vos données est valide, mais que la chaîne complète contient des éléments provoquant l'échec du décodage.

Valeur ajoutée : Cet article dissèque les 6 causes courantes de cette erreur, fournit des exemples de code corrects pour Python, JavaScript et cURL, et propose un plan de diagnostic rapide en 5 étapes. Si vous utilisez APIYI (apiyi.com) pour invoquer gemini-3-pro-image-preview, toutes les solutions présentées ici sont également applicables.

gemini-3-pro-image-preview-base64-decoding-failed-fix-fr 图示

I. Analyse approfondie de l'erreur "Base64 decoding failed"

Avant de commencer le dépannage, comprendre la signification de chaque champ de ce message d'erreur vous fera gagner 80 % de temps.

1.1 Analyse champ par champ du message d'erreur

Champ Signification Direction de dépannage
status_code: 400 Erreur client HTTP 400 Problème de format de corps de requête, pas une panne serveur
contents[0].parts[0] Erreur localisée dans la 1ère partie du 1er contenu Vérifier la première partie de l'image
inline_data.data Champ de données en ligne Ce champ doit être une chaîne Base64 pure
(TYPE_BYTES) Le type de champ est un tableau d'octets Le backend Gemini attend des octets après décodage
Base64 decoding failed for "/9j/..." Échec du décodage, le début lu est /9j/ Octets de début valides, problème au milieu ou à la fin
request id: 2026050... ID unique de la requête À fournir lors de la prise de contact avec le support technique

1.2 Pourquoi le début /9j/4AAQSkZJ est-il valide alors que l'opération échoue ?

/9j/4AAQSkZJ est le début standard de l'encodage Base64 d'un fichier JPEG (correspondant aux octets binaires FF D8 FF E0 00 10 4A 46 49 46, c'est-à-dire l'identifiant JPEG SOI + APP0 + "JFIF"). Cela signifie :

  • ✅ Vos données sont bien une image JPEG
  • ✅ Les octets de début sont parfaitement valides
  • ❌ Mais la chaîne complète contient des caractères illégaux ou un problème de structure quelque part

Cette caractéristique exclut l'hypothèse de "données totalement erronées" ; le problème réside probablement dans la partie centrale des données, le remplissage (padding) de fin, ou lors de l'étape de transfert/échappement de la chaîne.

1.3 Quels scénarios déclenchent cette erreur ?

gemini-3-pro-image-preview est le dernier modèle de Google pour la génération et l'édition d'images. Dans les scénarios suivants, vous devez transmettre inline_data :

  • Image vers image : Générer une nouvelle image basée sur une image de référence
  • Édition d'image : Effectuer des modifications locales sur l'image originale
  • Fusion d'images : Combiner plusieurs images de référence pour la génération
  • Transfert de style : Utiliser une image de référence comme modèle de style

Tout scénario nécessitant la transmission de données d'image en entrée peut rencontrer l'erreur "Base64 decoding failed".

💡 Conseil de diagnostic rapide : Si vous utilisez le service proxy API APIYI (apiyi.com) pour gemini-3-pro-image-preview, vous pouvez consulter les journaux de requête complets et le request_id dans la console. Comparer la longueur et le contenu du champ inline_data.data réellement envoyé est beaucoup plus efficace que de dépanner en se connectant directement à l'interface officielle.

二、 6 causes fréquentes de l'erreur "Base64 decoding failed"

Classées par fréquence d'apparition, nous vous conseillons de les vérifier dans cet ordre.

2.1 Cause n°1 : Présence du préfixe data URI (le plus courant, env. 40 % des cas)

C'est l'erreur la plus fréquente. Les développeurs copient souvent directement la chaîne base64 provenant du front-end ou du HTML :

❌ Mauvaise pratique :

{
  "inline_data": {
    "mime_type": "image/jpeg",
    "data": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAA..."
  }
}

✅ Bonne pratique :

{
  "inline_data": {
    "mime_type": "image/jpeg",
    "data": "/9j/4AAQSkZJRgABAQAA..."
  }
}

Le préfixe data:image/jpeg;base64, n'est utilisé que dans les balises <img> du navigateur ou en CSS. Le champ inline_data.data de l'API Gemini n'accepte que des chaînes Base64 pures.

2.2 Cause n°2 : La chaîne contient des sauts de ligne ou des espaces (env. 25 % des cas)

De nombreuses fonctions d'encodage Base64 insèrent automatiquement des sauts de ligne tous les 76 caractères (format PEM), ou vous avez pu introduire des caractères \n ou \r lors de la lecture d'un fichier.

❌ Exemple problématique (Python) :

import base64

# Erreur : l'utilisation de encodebytes() insère des sauts de ligne
with open("photo.jpg", "rb") as f:
    data = base64.encodebytes(f.read()).decode()  # Contient \n

✅ Bonne pratique :

import base64

# Correct : l'utilisation de b64encode() n'insère pas de sauts de ligne
with open("photo.jpg", "rb") as f:
    data = base64.b64encode(f.read()).decode("utf-8")

2.3 Cause n°3 : Remplacement de caractères dû à l'encodage URL (env. 15 % des cas)

Le jeu de caractères Base64 inclut + et /, qui peuvent être encodés en %2B et %2F lors d'un transfert URL. Certains clients HTTP effectuent automatiquement un encodage URL, ce qui fait échouer le décodage côté Gemini.

❌ Symptôme d'erreur :

Original : /9j/4AAQSkZJRg+abc=
Après transfert : %2F9j%2F4AAQSkZJRg%2Babc%3D

✅ Solution :

  • Assurez-vous que le Content-Type est application/json et non application/x-www-form-urlencoded.
  • Transmettez le Base64 dans le corps JSON, pas dans les paramètres de requête URL.
  • Utilisez le paramètre json= de votre client HTTP (comme requests en Python) plutôt que de concaténer manuellement.

2.4 Cause n°4 : La chaîne Base64 est tronquée (env. 10 % des cas)

Si votre image est volumineuse (plusieurs Mo), elle peut être tronquée lors du transfert pour les raisons suivantes :

  • Interruption et retransmission réseau.
  • Limite de longueur de chaîne du client HTTP.
  • Troncation lors de la sérialisation JSON par une limite de champ.
  • Limite de taille du corps (body size) d'un proxy intermédiaire.

Méthode de diagnostic : Calculez la longueur de la chaîne Base64 originale et comparez-la avec la longueur réelle du corps de la requête envoyée. La taille après encodage Base64 est environ 4/3 de la taille du fichier original (un JPEG de 2 Mo pèse environ 2,67 Mo après encodage).

2.5 Cause n°5 : Encodage Base64 "URL-safe" (env. 5 % des cas)

Les fonctions base64.urlsafe_b64encode() en Python ou Buffer.from(buf).toString('base64url') en Node.js produisent du Base64 "URL-safe", utilisant - et _ au lieu de + et /.

❌ Erreur :

data = base64.urlsafe_b64encode(image_bytes).decode()  # Contient - et _

✅ Correct :

data = base64.b64encode(image_bytes).decode("utf-8")  # Contient + et /

L'API Gemini n'accepte que le Base64 standard (RFC 4648 §4), pas le Base64 "URL-safe" (RFC 4648 §5).

2.6 Cause n°6 : Padding manquant ou superflu (env. 5 % des cas)

La longueur d'une chaîne Base64 doit être un multiple de 4, avec des = ajoutés à la fin si nécessaire. Le "mode strict" de certaines bibliothèques supprime ces = finaux, provoquant l'échec du décodage côté Gemini.

❌ Erreur :

/9j/4AAQSkZJRgABAQAAAQABAAD  ← Longueur 27, pas un multiple de 4

✅ Correct :

/9j/4AAQSkZJRgABAQAAAQABAAD=  ← Padding = ajouté, longueur 28

Si vous utilisez la fonction standard base64.b64encode(), le padding est géré automatiquement.

III. 5 étapes pour diagnostiquer rapidement l'erreur "Base64 decoding failed"

gemini-3-pro-image-preview-base64-decoding-failed-fix-fr 图示

Suivez ces étapes dans l'ordre ; la grande majorité des erreurs "Base64 decoding failed" peuvent être résolues dès les 3 premières étapes.

3.1 Étape 1 : Vérifier le préfixe data URI

Action :

# Exemple Python
if data.startswith("data:"):
    print("⚠️ Préfixe data URI détecté, suppression nécessaire")
    data = data.split(",", 1)[1]  # Supprime data:image/...;base64,

Condition de validation : Le champ data commence par /9j/ (JPEG), iVBORw0KGgo (PNG), R0lGOD (GIF), UklGR (WebP), etc., et ne contient pas le préfixe data:.

3.2 Étape 2 : Nettoyer les sauts de ligne et espaces

Action :

# Supprimer tous les caractères d'espacement
import re
data = re.sub(r"\s+", "", data)

Condition de validation : La chaîne ne contient ni \n, ni \r, ni \t, ni espaces.

3.3 Étape 3 : Vérifier la validité du Base64

Effectuez un décodage local avant d'envoyer la requête. Si le décodage échoue localement, le problème est certain :

import base64
try:
    decoded = base64.b64decode(data, validate=True)
    print(f"✅ Décodage réussi, octets originaux : {len(decoded)}")
except Exception as e:
    print(f"❌ Échec du décodage : {e}")

Si le décodage local réussit mais que l'API renvoie toujours une erreur, passez à l'étape 4.

3.4 Étape 4 : Vérifier la validité du mime_type

Le mime_type doit correspondre au format réel de l'image. Voici les valeurs valides courantes :

Format réel mime_type correct Signature Base64
JPEG image/jpeg /9j/4AAQSkZJ
PNG image/png iVBORw0KGgo
WebP image/webp UklGR
GIF image/gif R0lGOD
HEIC image/heic AAAAFGZ0eXBoZWlj

Si vous déclarez mime_type: image/png alors que les données sont du JPEG (commençant par /9j/), Gemini renverra une erreur.

3.5 Étape 5 : Vérifier les limites de taille d'image

L'API Gemini impose des limites sur la taille totale des requêtes :

  • Taille totale inline_data ≤ 20 Mo (avant encodage).
  • Image unique recommandée ≤ 7 Mo (avant encodage).
  • Images très volumineuses : utilisez l'API File pour les téléverser, puis référencez-les.

Si l'image est trop grande, nous vous recommandons de la compresser ou de la redimensionner avant le transfert.

🎯 Astuce de diagnostic : Si vous utilisez le service proxy API APIYI (apiyi.com) pour invoquer gemini-3-pro-image-preview, vous pouvez utiliser le request_id dans la console pour inspecter le corps complet de la requête et les journaux de réponse. C'est beaucoup plus simple pour localiser le problème que via l'API officielle. Les journaux du service proxy affichent la taille réelle du corps de la requête et l'endroit exact où elle a été tronquée.

IV. Exemples d'invocation corrects pour gemini-3-pro-image-preview par langage

Voici les exemples les plus simples et vérifiés pour commencer. Copiez-les et utilisez-les directement.

4.1 Exemple complet en Python (bibliothèque requests recommandée)

import base64
import requests

# 1. Lire et encoder l'image
def encode_image(image_path):
    with open(image_path, "rb") as f:
        return base64.b64encode(f.read()).decode("utf-8")

# 2. Construire la requête
api_key = "sk-your-apiyi-key"  # Remplacez par votre clé API réelle
base_url = "https://vip.apiyi.com/gemini"  # Adresse du service proxy API APIYI
model = "gemini-3-pro-image-preview"

image_b64 = encode_image("input.jpg")

payload = {
    "contents": [{
        "parts": [
            {
                "inline_data": {
                    "mime_type": "image/jpeg",  # Doit correspondre au format réel
                    "data": image_b64  # Base64 pur, sans préfixe
                }
            },
            {
                "text": "Transforme cette image dans le style de la Nuit étoilée de Van Gogh"
            }
        ]
    }]
}

# 3. Lancer la requête
response = requests.post(
    f"{base_url}/v1beta/models/{model}:generateContent",
    headers={
        "x-goog-api-key": api_key,
        "Content-Type": "application/json"  # Crucial : format JSON
    },
    json=payload  # Crucial : utilisez json= au lieu de data=
)

print(response.json())

4.2 Exemple complet en JavaScript / Node.js

const fs = require('fs');
const fetch = require('node-fetch');

async function callGemini() {
  // 1. Lire et encoder l'image (Base64 standard, pas base64url)
  const imageBuffer = fs.readFileSync('input.jpg');
  const imageB64 = imageBuffer.toString('base64'); // ✅ Ne pas utiliser 'base64url'

  // 2. Construire la requête
  const apiKey = 'sk-your-apiyi-key';
  const baseUrl = 'https://vip.apiyi.com/gemini'; // Service proxy API APIYI
  const model = 'gemini-3-pro-image-preview';

  const payload = {
    contents: [{
      parts: [
        {
          inline_data: {
            mime_type: 'image/jpeg',
            data: imageB64  // Base64 pur
          }
        },
        { text: 'Transforme cette image dans le style de la Nuit étoilée de Van Gogh' }
      ]
    }]
  };

  // 3. Lancer la requête
  const response = await fetch(
    `${baseUrl}/v1beta/models/${model}:generateContent`,
    {
      method: 'POST',
      headers: {
        'x-goog-api-key': apiKey,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(payload)
    }
  );

  console.log(await response.json());
}

callGemini();

4.3 Exemple en ligne de commande (curl)

# 1. Encoder l'image et l'enregistrer dans un fichier (pour éviter les limites de longueur de ligne)
base64 -i input.jpg -o input.b64
# Ou sur macOS : base64 -w 0 input.jpg > input.b64

# 2. Construire le payload JSON
cat > payload.json <<EOF
{
  "contents": [{
    "parts": [
      {
        "inline_data": {
          "mime_type": "image/jpeg",
          "data": "$(cat input.b64)"
        }
      },
      { "text": "Transforme cette image dans le style de la Nuit étoilée de Van Gogh" }
    ]
  }]
}
EOF

# 3. Lancer la requête
curl -X POST \
  "https://vip.apiyi.com/gemini/v1beta/models/gemini-3-pro-image-preview:generateContent" \
  -H "x-goog-api-key: sk-your-apiyi-key" \
  -H "Content-Type: application/json" \
  -d @payload.json

⚠️ Note sur curl : Par défaut, curl -d "$(base64 input.jpg)" sur macOS insère des sauts de ligne. Assurez-vous d'utiliser base64 -w 0 (Linux) ou base64 -i ... | tr -d '\n' (macOS) pour supprimer les retours à la ligne.

V. Requête erronée vs Requête correcte : Comparaison complète

gemini-3-pro-image-preview-base64-decoding-failed-fix-fr 图示

Vérification Exemple erroné Exemple correct
Début du champ data data:image/jpeg;base64,/9j/... /9j/4AAQSkZJ...
Gestion des retours à la ligne Inclut \n tous les 76 caractères Chaîne continue sur une ligne
Jeu de caractères Inclut - _ (URL-safe) Inclut + / (standard)
Padding final Pas de = ou = en trop Padding correct automatique
mime_type Ne correspond pas au format réel Correspond strictement au format
En-tête HTTP application/x-www-form-urlencoded application/json
Mode de transmission Paramètres de requête URL Champ du corps JSON
Taille de l'image > 20 Mo par image ≤ 7 Mo par image

VI. Avantages de l'utilisation d'APIYI pour appeler gemini-3-pro-image-preview

Si vous n'arrivez toujours pas à résoudre votre problème, passer par le service proxy API APIYI (apiyi.com) pour appeler gemini-3-pro-image-preview offre plusieurs avantages pratiques :

Avantage Description
Journaux de requêtes complets Visualisez la requête/réponse complète associée au request_id dans la console
Diagnostic rapide des erreurs Identifiez la cause de l'échec en un clic via le request_id
Compatibilité native Aucune modification de code nécessaire, remplacez simplement la base_url
Concurrence illimitée Pas de limitation de débit pour les scénarios d'édition d'images en masse
Offres de recharge 100 $ rechargés = 10 % offerts (≈ 15 % de réduction par rapport au site officiel)
Paiement en RMB Paiement direct via WeChat/Alipay

L'intégration d'APIYI pour appeler gemini-3-pro-image-preview ne nécessite que la modification de deux variables :

# Interface officielle
base_url = "https://generativelanguage.googleapis.com"

# Remplacer par le service proxy APIYI (le reste du code est inchangé)
base_url = "https://vip.apiyi.com/gemini"

VII. FAQ : Problèmes courants liés à "Base64 decoding failed"

Q1 : Pourquoi mon base64.b64decode() local fonctionne-t-il, mais l'appel API échoue-t-il ?

La cause la plus probable est un problème lors du transfert. Situations fréquentes :

  • Le client HTTP encode le + en %2B (utilisez application/json au lieu de form-urlencoded)
  • La chaîne est tronquée lors de la sérialisation JSON (vérifiez les limites de taille du corps de la requête)
  • Un proxy ou une passerelle intermédiaire impose une limite de taille (ex: client_max_body_size de nginx)

Si vous suspectez un problème réseau, utilisez le service proxy APIYI (apiyi.com) ; les journaux de la console afficheront le contenu réel de la requête à son arrivée sur le serveur proxy, facilitant ainsi le débogage.

Q2 : Quels formats d'image sont supportés par gemini-3-pro-image-preview ?

Les mime_type supportés incluent :

  • image/jpeg (recommandé, fichier le plus léger)
  • image/png (pour les scénarios avec transparence)
  • image/webp (bon compromis qualité/poids)
  • image/gif (seule la première image est extraite)
  • image/heic / image/heif (format natif iPhone)

Les formats BMP, TIFF, SVG, etc., ne sont pas supportés et doivent être convertis au préalable.

Q3 : Combien d'images puis-je transmettre dans une seule requête ?

Pour une requête unique, gemini-3-pro-image-preview supporte au maximum :

  • Parts inline_data : 3 à 5 images (selon la taille totale)
  • Volume total de données : ≤ 20 Mo (somme de tous les inline_data avant encodage)
  • Recommandation : Si vous avez besoin de plus de 5 images de référence, utilisez l'API File pour les télécharger, puis référencez-les via file_data.

Q4 : Pourquoi l'erreur "Base64 decoding failed" apparaît-elle alors que d'autres modèles (ex: gemini-2.5-flash) fonctionnent ?

Cette situation survient généralement parce que gemini-3-pro-image-preview est plus strict sur le format des images. La validation des entrées est plus rigoureuse sur les nouveaux modèles :

  • Les anciens modèles pouvaient tolérer certains préfixes ou sauts de ligne
  • Le nouveau modèle vérifie strictement la conformité à la norme RFC 4648 §4
  • Il est conseillé de réécrire votre code en suivant l'exemple minimal correct de la section 4.1 et de vérifier chaque point.

Q5 : Quelle base_url utiliser avec APIYI (apiyi.com) ?

La base_url standard pour appeler gemini-3-pro-image-preview via APIYI est :

https://vip.apiyi.com/gemini

Le chemin complet du point de terminaison est :

https://vip.apiyi.com/gemini/v1beta/models/gemini-3-pro-image-preview:generateContent

La clé API est transmise via l'en-tête x-goog-api-key, exactement comme avec Google.

Q6 : À quoi sert le request_id ?

Le request_id (ex: 2026050117522815159336234238114) est l'identifiant unique de votre requête :

  • À fournir au support technique pour localiser rapidement un problème
  • À citer pour reproduire un bug, permettant à l'équipe technique de consulter les journaux complets
  • Pour analyser les modèles d'erreurs, si plusieurs request_id présentent la même erreur, il s'agit d'un problème systémique

Si vous utilisez le service proxy APIYI (apiyi.com), vous pouvez rechercher directement le request_id dans la console pour voir les détails sans contacter le support.

Q7 : Comment compresser une image trop volumineuse ?

Il est recommandé d'utiliser Pillow pour compresser l'image côté client :

from PIL import Image
import io
import base64

def compress_image(path, max_size_kb=2048):
    img = Image.open(path)
    # Redimensionner le côté le plus long à 1568 (recommandé par Gemini)
    img.thumbnail((1568, 1568))
    buffer = io.BytesIO()
    img.save(buffer, format="JPEG", quality=85, optimize=True)
    return base64.b64encode(buffer.getvalue()).decode("utf-8")

La compression permet de maintenir une bonne qualité visuelle tout en réduisant considérablement le poids du fichier, évitant ainsi de dépasser la limite de 20 Mo.

Q8 : Que signifie l'erreur (TYPE_BYTES) ?

TYPE_BYTES est un identifiant de type de champ des Google Protocol Buffers, indiquant que le backend Gemini attend un tableau d'octets (bytes) décodé. Lorsque le décodage Base64 échoue, les octets ne peuvent pas être obtenus, ce qui déclenche cette erreur. Il s'agit d'une notification de validation protobuf de bas niveau, et non d'un problème de configuration.

VIII. Points clés à retenir

  • ✅ Nature de l'erreur : La chaîne Base64 du champ inline_data.data ne peut pas être décodée par le backend de Gemini.
  • ✅ 6 causes fréquentes (par fréquence) : Préfixe data URI / sauts de ligne / encodage URL / troncature / caractères non compatibles URL / erreur de padding.
  • ✅ Processus de dépannage en 5 étapes : Suppression du préfixe → nettoyage des espaces → vérification locale → vérification du mime_type → vérification de la taille.
  • ✅ Recommandation Python : base64.b64encode() + paramètre json= de la bibliothèque requests.
  • ✅ Recommandation JavaScript : Buffer.toString('base64') (et non 'base64url').
  • ✅ Recommandation curl : Écrire d'abord le Base64 dans un fichier, puis l'utiliser avec -d @file.json.
  • ✅ Avantages d'APIYI : Compatibilité native des formats, logs consultables via request_id dans la console, et concurrence illimitée.
  • ✅ Support technique : Conservez votre request_id pour une résolution rapide.

IX. Conclusion

L'erreur « Base64 decoding failed » avec gemini-3-pro-image-preview provient, dans 99 % des cas, d'une mauvaise construction de la requête côté client plutôt que d'une défaillance du serveur. Le message d'erreur commençant par /9j/4AAQSkZJ confirme que les octets initiaux correspondent bien à un JPEG en Base64 ; le problème se situe donc dans le traitement intermédiaire des données : pollution par un préfixe, sauts de ligne, encodage URL, caractères non sécurisés ou troncature.

En suivant les 5 étapes de dépannage décrites au chapitre 3, la majorité des problèmes sont identifiés en moins de 5 minutes. Pour les scénarios complexes (images volumineuses après compression, combinaisons d'images, encodages spécifiques), vous pouvez vous référer aux exemples complets en trois langages du chapitre 4, prêts à l'emploi.

Si vous recherchez une solution stable pour intégrer gemini-3-pro-image-preview dans vos projets multimodaux, APIYI (apiyi.com) propose un service proxy API complet pour la gamme Gemini. Il offre une compatibilité native à 100 % (il suffit de remplacer la base_url), une concurrence illimitée (idéal pour l'édition d'images par lots), des bonus de recharge (100 $ rechargés offrent 10 % de crédit supplémentaire, soit une réduction de 15 % par rapport au site officiel), des paiements en yuans (pas besoin de carte bancaire internationale) et un accès aux logs complets via request_id dans la console, ce qui réduit considérablement les coûts de maintenance.

🎯 Prochaine étape suggérée : Suivez scrupuleusement les 5 étapes de dépannage du chapitre 3. Si le problème persiste, notez votre request_id et contactez le support technique d'APIYI (apiyi.com) en joignant votre corps de requête (après avoir masqué les informations sensibles). Une solution précise vous sera généralement fournie en moins d'une heure.

Références

  1. Documentation officielle de l'API Google Gemini : Compréhension et génération d'images

    • Lien : ai.google.dev/gemini-api/docs/image-generation
    • Description : Spécifications des champs inline_data / file_data, liste des mime_type

  2. Guide du développeur Gemini 3 : Guide de migration vers les nouveaux modèles

    • Lien : ai.google.dev/gemini-api/docs/gemini-3
    • Description : Différences entre gemini-3-pro-image-preview et les anciens modèles

  3. RFC 4648 – Encodages de données Base16, Base32 et Base64 : Spécification standard Base64

    • Lien : datatracker.ietf.org/doc/html/rfc4648
    • Description : Différences entre le standard Base64 (§4) et le Base64 URL-safe (§5)

  4. Site officiel APIYI : Service proxy API pour les gammes complètes Gemini / Claude / OpenAI

    • Lien : apiyi.com
    • Description : Compatibilité avec les formats natifs, concurrence illimitée, rechargement en RMB, 10 % offerts pour tout rechargement de 100 USD

Auteur : Équipe technique
Dernière mise à jour : 02/05/2026
À propos d'APIYI : APIYI (apiyi.com) est un fournisseur professionnel de service proxy API pour les grands modèles de langage. Nous proposons un accès stable à une gamme complète de modèles, dont gemini-3-pro-image-preview, Claude Sonnet 4.5, Claude Opus 4.7 et la série GPT. Nos services sont entièrement compatibles avec les formats natifs Gemini/OpenAI/Anthropic. La console permet une vérification croisée des journaux de requêtes complets via request_id. Profitez de 10 % offerts pour tout rechargement de 100 USD (équivalent à une réduction de 15 % par rapport au site officiel), sans limite de concurrence et avec un support technique réactif.

Try AI Large Model https://api.apiyi.com for free
Stable and reliable AI LM API aggregation service, Get 300 Millions Tokens for Free~

Publications similaires