|

Error de decodificación Base64 en la vista previa de imagen de gemini-3-pro: 6 causas principales y guía de reparación completa

PorAPIYI - Stable and affordable AI API

Nota del autor: ¿Recibes un error 400 "Base64 decoding failed" al invocar gemini-3-pro-image-preview? En este artículo, analizamos el mensaje de error original, desglosamos 6 causas comunes y te proporcionamos ejemplos correctos en Python, JavaScript y cURL, junto con un plan de resolución de 5 pasos.

¿Te has topado con este error 400 al llamar a la interfaz de 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
  }
}

Esto no es un problema del servicio API, sino que los datos en Base64 del campo inline_data.data en el cuerpo de la solicitud no pueden ser decodificados correctamente por el backend de Gemini. El fragmento /9j/4AAQSkZJ en el mensaje de error es la cabecera Base64 estándar de un archivo JPEG (que corresponde a los binarios FF D8 FF E0), lo que indica que el inicio de tus datos es válido, pero existen problemas en la cadena completa que impiden la decodificación.

Valor central: Este artículo analiza a fondo las 6 causas comunes de este error, proporciona ejemplos de código correctos para Python, JavaScript y cURL, y ofrece un plan de diagnóstico rápido de 5 pasos. Si estás utilizando APIYI (apiyi.com) para invocar gemini-3-pro-image-preview, todas las soluciones aquí presentadas son igualmente aplicables.

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

I. Análisis profundo del error Base64 decoding failed

Antes de empezar a depurar, entender el significado de cada campo en este mensaje de error te ahorrará el 80% del trabajo.

1.1 Interpretación campo por campo del error

Campo Significado Dirección de búsqueda
status_code: 400 Error de cliente HTTP 400 Problema de formato en el cuerpo, no fallo del servidor
contents[0].parts[0] Error localizado en la parte 1 del contenido 1 Revisar la primera parte de la imagen
inline_data.data Campo de datos en línea Este campo debe ser una cadena Base64 pura
(TYPE_BYTES) El tipo de campo es un array de bytes El backend de Gemini espera bytes tras la decodificación
Base64 decoding failed for "/9j/..." Fallo de decodificación, el inicio leído es /9j/ Bytes iniciales legales, problema en el medio o final
request id: 2026050... ID único de solicitud Proporcionar este ID al contactar con soporte técnico

1.2 Por qué falla si empieza por /9j/4AAQSkZJ

/9j/4AAQSkZJ es el inicio estándar de la codificación Base64 de un archivo JPEG (corresponde a los binarios FF D8 FF E0 00 10 4A 46 49 46, es decir, JPEG SOI + APP0 + identificador "JFIF"). Esto significa que:

  • ✅ Tus datos son efectivamente una imagen JPEG
  • ✅ Los bytes iniciales son completamente legales
  • ❌ Pero la cadena completa presenta caracteres ilegales o problemas de estructura en algún punto.

Esta característica descarta la posibilidad de que los "datos sean totalmente erróneos"; el problema probablemente reside en la parte central de los datos, el relleno (padding) final o en el proceso de transmisión/codificación de la cadena.

1.3 ¿Qué escenarios activan este error?

gemini-3-pro-image-preview es el modelo más reciente de Google para la generación y edición de imágenes. Se requiere pasar inline_data en los siguientes escenarios:

  • Imagen a imagen: Generar una nueva imagen basada en una imagen de referencia.
  • Edición de imágenes: Realizar modificaciones locales en una imagen original.
  • Fusión de imágenes: Combinar varias imágenes de referencia para generar una nueva.
  • Transferencia de estilo: Usar una imagen de referencia como plantilla de estilo.

Cualquier escenario que requiera pasar datos de imagen como entrada puede encontrarse con el error Base64 decoding failed.

💡 Sugerencia de diagnóstico rápido: Si utilizas el servicio proxy de API APIYI (apiyi.com) para gemini-3-pro-image-preview, puedes consultar los registros de solicitud completos y el request_id en la consola. Comparar la longitud y el contenido del inline_data.data enviado realmente es mucho más eficiente que depurar conectando directamente a la interfaz oficial.

二、 6 causas comunes del error "Base64 decoding failed"

Están ordenadas de mayor a menor frecuencia; te recomendamos revisarlas en este orden.

2.1 Causa 1: Incluir el prefijo data URI (la más común, ~40% de los casos)

Este es el error más frecuente. A menudo, los desarrolladores copian directamente la cadena base64 desde HTML o el frontend:

❌ Forma incorrecta:

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

✅ Forma correcta:

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

El prefijo data:image/jpeg;base64, solo se usa en etiquetas <img> del navegador o en CSS background; el campo inline_data.data de la API de Gemini solo acepta cadenas Base64 puras.

2.2 Causa 2: La cadena contiene saltos de línea o espacios en blanco (~25% de los casos)

Muchas funciones de codificación Base64 insertan saltos de línea automáticamente cada 76 caracteres (formato PEM), o quizás los caracteres \n o \r se introdujeron al leer un archivo.

❌ Ejemplo de problema (Python):

import base64

# Error: usar encodebytes() insertará saltos de línea
with open("photo.jpg", "rb") as f:
    data = base64.encodebytes(f.read()).decode()  # Contiene \n

✅ Forma correcta:

import base64

# Correcto: usar b64encode() no insertará saltos de línea
with open("photo.jpg", "rb") as f:
    data = base64.b64encode(f.read()).decode("utf-8")

2.3 Causa 3: Sustitución de caracteres por codificación URL (~15% de los casos)

El conjunto de caracteres Base64 incluye + y /, que pueden codificarse como %2B y %2F durante la transmisión URL. Algunos clientes HTTP realizan esta codificación automáticamente, provocando que el backend de Gemini falle al decodificar.

❌ Fenómeno de error:

Original: /9j/4AAQSkZJRg+abc=
Tras transmisión: %2F9j%2F4AAQSkZJRg%2Babc%3D

✅ Solución:

  • Asegúrate de que el Content-Type sea application/json y no application/x-www-form-urlencoded.
  • Transmite Base64 en el cuerpo JSON, no como parámetros de consulta URL.
  • Usa el parámetro json= del cliente HTTP (como en requests de Python) en lugar de concatenar manualmente.

2.4 Causa 4: La cadena Base64 está truncada (~10% de los casos)

Si tu imagen es pesada (varios MB), puede truncarse durante la transmisión debido a:

  • Reintentos por interrupción de red.
  • Límites de longitud de cadena del cliente HTTP.
  • Truncamiento por límites de campo durante la serialización JSON.
  • Límites de tamaño de cuerpo en proxies intermedios.

Método de diagnóstico: Calcula la longitud de la cadena Base64 original y compárala con la longitud del cuerpo de la solicitud enviada. Tras la codificación, el tamaño es aproximadamente 4/3 del archivo original; un JPEG de 2MB pesará unos 2.67MB una vez codificado.

2.5 Causa 5: Codificación Base64 "URL-safe" (~5% de los casos)

Funciones como base64.urlsafe_b64encode() de Python o Buffer.from(buf).toString('base64url') de Node.js generan Base64 "seguro para URL", usando - y _ en lugar de + y /.

❌ Error:

data = base64.urlsafe_b64encode(image_bytes).decode()  # Contiene - y _

✅ Correcto:

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

La API de Gemini solo acepta Base64 estándar (RFC 4648 §4), no la versión "URL-safe" (RFC 4648 §5).

2.6 Causa 6: Padding faltante o sobrante (~5% de los casos)

La longitud de una cadena Base64 debe ser múltiplo de 4, rellenándose con = al final. Algunos "modos estrictos" de ciertas librerías eliminan el = final, causando errores en el backend de Gemini.

❌ Error:

/9j/4AAQSkZJRgABAQAAAQABAAD  ← Longitud 27, no es múltiplo de 4

✅ Correcto:

/9j/4AAQSkZJRgABAQAAAQABAAD=  ← Relleno con =, longitud 28

Si usas la función estándar base64.b64encode(), el padding se maneja automáticamente y no necesitas añadirlo manualmente.

Tres: 5 pasos para diagnosticar rápidamente el error "Base64 decoding failed"

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

Sigue este orden de verificación; la gran mayoría de errores de "Base64 decoding failed" se pueden localizar en los primeros 3 pasos.

3.1 Paso 1: Comprobar el prefijo data URI

Acción de verificación:

# Ejemplo en Python
if data.startswith("data:"):
    print("⚠️ Contiene prefijo data URI, debe eliminarse")
    data = data.split(",", 1)[1]  # Elimina data:image/...;base64,

Condición de éxito: El campo data comienza con /9j/ (JPEG), iVBORw0KGgo (PNG), R0lGOD (GIF), UklGR (WebP), etc., y no contiene el prefijo data:.

3.2 Paso 2: Limpiar saltos de línea y espacios en blanco

Acción de verificación:

# Eliminar todos los caracteres de espacio en blanco
import re
data = re.sub(r"\s+", "", data)

Condición de éxito: La cadena no contiene \n, \r, \t ni espacios.

3.3 Paso 3: Validar la legitimidad del Base64

Decodifica localmente una vez antes de enviar la solicitud. Si falla localmente, definitivamente hay un problema:

import base64
try:
    decoded = base64.b64decode(data, validate=True)
    print(f"✅ Decodificación exitosa, bytes originales: {len(decoded)}")
except Exception as e:
    print(f"❌ Fallo en la decodificación: {e}")

Si la decodificación local es exitosa pero la interfaz sigue dando error, pasa al cuarto paso.

3.4 Paso 4: Verificar la corrección del mime_type

El mime_type debe coincidir con el formato real de la imagen. Valores legales comunes:

Formato real mime_type correcto Característica de cabecera Base64
JPEG image/jpeg /9j/4AAQSkZJ
PNG image/png iVBORw0KGgo
WebP image/webp UklGR
GIF image/gif R0lGOD
HEIC image/heic AAAAFGZ0eXBoZWlj

Si declaras mime_type: image/png pero los datos son JPEG (comienzan con /9j/), Gemini también mostrará un error.

3.5 Paso 5: Comprobar los límites de tamaño de imagen

La API de Gemini tiene límites en el tamaño total por solicitud:

  • Tamaño total de inline_data ≤ 20MB (antes de codificar).
  • Imagen individual se recomienda ≤ 7MB (antes de codificar).
  • Imágenes muy grandes deben subirse mediante la File API y luego referenciarlas.

Si la imagen es demasiado grande, se recomienda comprimirla o redimensionarla antes de transmitirla.

🎯 Truco de diagnóstico: Si realizas la invocación del modelo gemini-3-pro-image-preview a través de APIYI (apiyi.com), puedes usar el request_id en la consola para consultar el cuerpo completo de la solicitud y los registros de respuesta. Es mucho más fácil localizar problemas que conectando directamente con la oficial. Los registros del servicio proxy de API mostrarán el tamaño real del cuerpo de la solicitud y dónde se truncó.

四、Ejemplos de invocación correcta de gemini-3-pro-image-preview en varios lenguajes

A continuación, presento los ejemplos más sencillos y verificados para que puedas copiar y usar directamente.

4.1 Ejemplo completo en Python (se recomienda usar la librería requests)

import base64
import requests

# 1. Leer y codificar la imagen
def encode_image(image_path):
    with open(image_path, "rb") as f:
        return base64.b64encode(f.read()).decode("utf-8")

# 2. Construir la solicitud
api_key = "sk-your-apiyi-key"  # Reemplaza con tu clave API real
base_url = "https://vip.apiyi.com/gemini"  # Dirección del servicio proxy de API de APIYI
model = "gemini-3-pro-image-preview"

image_b64 = encode_image("input.jpg")

payload = {
    "contents": [{
        "parts": [
            {
                "inline_data": {
                    "mime_type": "image/jpeg",  # Debe coincidir con el formato real
                    "data": image_b64  # Base64 puro, sin prefijo
                }
            },
            {
                "text": "Cambia esta imagen al estilo de La noche estrellada de Van Gogh"
            }
        ]
    }]
}

# 3. Realizar la solicitud
response = requests.post(
    f"{base_url}/v1beta/models/{model}:generateContent",
    headers={
        "x-goog-api-key": api_key,
        "Content-Type": "application/json"  # Clave: formato JSON
    },
    json=payload  # Clave: usar json= en lugar de data=
)

print(response.json())

4.2 Ejemplo completo en JavaScript / Node.js

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

async function callGemini() {
  // 1. Leer y codificar la imagen (Base64 estándar, no base64url)
  const imageBuffer = fs.readFileSync('input.jpg');
  const imageB64 = imageBuffer.toString('base64'); // ✅ No uses 'base64url'

  // 2. Construir la solicitud
  const apiKey = 'sk-your-apiyi-key';
  const baseUrl = 'https://vip.apiyi.com/gemini'; // Proxy de APIYI
  const model = 'gemini-3-pro-image-preview';

  const payload = {
    contents: [{
      parts: [
        {
          inline_data: {
            mime_type: 'image/jpeg',
            data: imageB64  // Base64 puro
          }
        },
        { text: 'Cambia esta imagen al estilo de La noche estrellada de Van Gogh' }
      ]
    }]
  };

  // 3. Realizar la solicitud
  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 Ejemplo de línea de comandos con curl

# 1. Codificar la imagen y guardarla en un archivo (para evitar límites de longitud en la línea de comandos)
base64 -i input.jpg -o input.b64
# O en macOS: base64 -w 0 input.jpg > input.b64

# 2. Construir el payload JSON
cat > payload.json <<EOF
{
  "contents": [{
    "parts": [
      {
        "inline_data": {
          "mime_type": "image/jpeg",
          "data": "$(cat input.b64)"
        }
      },
      { "text": "Cambia esta imagen al estilo de La noche estrellada de Van Gogh" }
    ]
  }]
}
EOF

# 3. Realizar la solicitud
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

⚠️ Notas sobre curl: Al usar curl -d "$(base64 input.jpg)" directamente en macOS, se insertarán saltos de línea por defecto. Asegúrate de usar base64 -w 0 (Linux) o base64 -i ... | tr -d '\n' (macOS) para eliminar los saltos de línea.

V. Solicitud errónea vs. Solicitud correcta: Comparativa completa

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

Elemento a verificar Ejemplo erróneo Ejemplo correcto
Inicio del campo data data:image/jpeg;base64,/9j/... /9j/4AAQSkZJ...
Manejo de saltos de línea Incluye \n cada 76 caracteres Cadena continua en una sola línea
Juego de caracteres Contiene - _ (URL-safe) Contiene + / (estándar)
Padding final Sin = o = extra Padding correcto automático
mime_type No coincide con el formato real Coincidencia estricta con el formato
Cabecera HTTP application/x-www-form-urlencoded application/json
Método de transmisión Parámetros de consulta URL Campo en el cuerpo JSON
Tamaño de imagen > 20MB por imagen ≤ 7MB por imagen

VI. Ventajas de usar APIYI para invocar gemini-3-pro-image-preview

Si después de revisar sigues sin poder localizar el problema, utilizar el servicio proxy de API APIYI (apiyi.com) para gemini-3-pro-image-preview ofrece varias ventajas claras:

Ventaja Descripción
Registros de solicitud completos El panel de control permite ver la solicitud/respuesta completa asociada al request_id
Revisión rápida de errores Localiza la causa del fallo con un solo clic mediante el request_id
Compatibilidad con formato nativo No es necesario modificar el código, basta con reemplazar la base_url
Sin límite de concurrencia No se aplicarán límites de tasa en escenarios de edición de imágenes por lotes
Descuentos por recarga Recarga 100 USD y obtén un 10% extra (aprox. un 15% de ahorro frente al precio oficial)
Recarga en moneda local Pago directo mediante WeChat/Alipay

Para integrar APIYI y llamar a gemini-3-pro-image-preview, solo necesitas modificar dos variables:

# Interfaz oficial
base_url = "https://generativelanguage.googleapis.com"

# Cambiar al servicio proxy de APIYI (el resto del código permanece igual)
base_url = "https://vip.apiyi.com/gemini"

VII. Preguntas frecuentes sobre el error "Base64 decoding failed"

P1: ¿Por qué mi base64.b64decode() local funciona bien, pero la llamada a la API devuelve error?

La causa más probable es un problema en la transmisión. Situaciones comunes:

  • El cliente HTTP codifica el signo + como %2B (deberías usar application/json en lugar de form-urlencoded).
  • La cadena se trunca durante la serialización JSON (verifica los límites de tamaño del cuerpo).
  • El proxy intermedio o la puerta de enlace tiene límites de tamaño de cuerpo (como client_max_body_size en nginx).

Si sospechas que el problema está en la red, puedes usar el servicio proxy de APIYI (apiyi.com); los registros del panel mostrarán el contenido real de la solicitud tal como llega al servidor, facilitando la depuración.

P2: ¿Qué formatos de imagen admite gemini-3-pro-image-preview?

Los mime_types admitidos incluyen:

  • image/jpeg (recomendado, el archivo más pequeño)
  • image/png (para escenarios con canales de transparencia)
  • image/webp (equilibrio entre calidad y tamaño)
  • image/gif (solo toma el primer fotograma)
  • image/heic / image/heif (formato de captura de iPhone)

No se admiten formatos como BMP, TIFF o SVG; debes convertirlos previamente.

P3: ¿Cuántas imágenes puedo enviar en una solicitud?

Una sola solicitud a gemini-3-pro-image-preview admite:

  • Partes inline_data: 3-5 imágenes (dependiendo del tamaño total).
  • Volumen total de datos: ≤ 20 MB (suma de todos los inline_data antes de la codificación).
  • Combinación sugerida: Si necesitas más de 5 imágenes de referencia, utiliza la API de archivos (File API) para subirlas y luego haz referencia a ellas mediante file_data.

P4: Recibo "Base64 decoding failed" pero otros modelos (como gemini-2.5-flash) funcionan bien.

Esto suele ocurrir porque gemini-3-pro-image-preview es más estricto con el formato de imagen. La validación de entrada en los nuevos modelos es más rigurosa:

  • Los modelos antiguos podían tolerar ciertos prefijos o saltos de línea.
  • Los nuevos modelos validan estrictamente según la norma RFC 4648 §4.
  • Se recomienda reescribir el código siguiendo el ejemplo correcto y simplificado de la sección 4.1 de este artículo y verificar cada punto.

P5: Al usar APIYI (apiyi.com), ¿qué base_url debo utilizar?

La base_url estándar para invocar gemini-3-pro-image-preview a través de APIYI es:

https://vip.apiyi.com/gemini

La ruta completa del endpoint es:

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

La clave API se pasa a través de la cabecera x-goog-api-key, exactamente igual que en la versión oficial de Google.

P6: ¿Para qué sirve el request_id?

El request_id (por ejemplo, 2026050117522815159336234238114) es el identificador único de tu solicitud y sirve para:

  • Proporcionarlo al contactar con soporte técnico, permitiendo localizar el problema rápidamente.
  • Referenciarlo al reproducir errores, para que el equipo técnico pueda consultar el registro completo.
  • Analizar patrones de error, ya que si múltiples request_id presentan el mismo fallo, indica un problema sistémico.

Si usas el servicio proxy de APIYI (apiyi.com), puedes buscar el request_id directamente en el panel de control para ver los detalles sin necesidad de contactar a soporte.

P7: ¿Cómo puedo comprimir imágenes demasiado grandes?

Se recomienda usar Pillow en el cliente para realizar una precompresión:

from PIL import Image
import io
import base64

def compress_image(path, max_size_kb=2048):
    img = Image.open(path)
    # Redimensionar el lado más largo a 1568 (recomendado por 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")

Tras la compresión, generalmente se mantiene la calidad visual mientras se reduce drásticamente el tamaño, evitando superar el límite de 20 MB.

P8: ¿Qué significa el mensaje de error (TYPE_BYTES)?

TYPE_BYTES es el identificador de tipo de campo de Google Protocol Buffers, que indica que el backend de Gemini espera recibir un arreglo de bytes decodificados. Cuando la decodificación Base64 falla, no se pueden obtener los bytes, lo que provoca este error. Es una advertencia de la validación interna de protobuf, no un problema de configuración.

VIII. Puntos clave

  • ✅ Naturaleza del error: La cadena Base64 en el campo inline_data.data no puede ser decodificada por el backend de Gemini.
  • ✅ 6 causas comunes (por frecuencia): prefijo data URI / saltos de línea / codificación URL / truncamiento / caracteres URL-safe / errores de padding.
  • ✅ Proceso de resolución de 5 pasos: eliminar prefijo → limpiar espacios en blanco → validación local → verificar mime_type → verificar tamaño.
  • ✅ Recomendación en Python: base64.b64encode() + parámetro json= en requests.
  • ✅ Recomendación en JavaScript: Buffer.toString('base64') (no 'base64url').
  • ✅ Recomendación en curl: escribir primero el Base64 en un archivo y luego referenciarlo con -d @file.json.
  • ✅ Ventajas de APIYI: compatibilidad con formatos nativos, logs de consulta mediante request_id en la consola y concurrencia ilimitada.
  • ✅ Contacto de soporte: conserve el request_id para una localización rápida de problemas.

IX. Conclusión

Cuando gemini-3-pro-image-preview arroja un error de "Base64 decoding failed", en el 99% de los casos se trata de un problema en la construcción de la solicitud del cliente, no de un fallo del servidor. El mensaje de error que incluye /9j/4AAQSkZJ ya nos indica que los bytes iniciales son un JPEG Base64 válido; el problema reside en los pasos intermedios de los datos: posiblemente contaminación por prefijos, saltos de línea, codificación URL, caracteres URL-safe o truncamiento.

Si sigues el proceso de resolución de 5 pasos del tercer capítulo de este artículo, podrás localizar la mayoría de los problemas en menos de 5 minutos. Para escenarios complejos (como archivos que siguen siendo demasiado grandes tras la compresión, combinación de múltiples imágenes o codificaciones especiales), puedes consultar los ejemplos completos en los tres lenguajes del cuarto capítulo, los cuales están listos para copiar y ejecutar.

Si estás buscando una solución de acceso estable para gemini-3-pro-image-preview en tus proyectos multimodales, APIYI (apiyi.com) ofrece un servicio proxy de API completo para la serie de modelos Gemini, con compatibilidad 100% nativa (solo necesitas reemplazar la base_url), concurrencia ilimitada (ideal para escenarios de edición de imágenes por lotes), bonificación del 10% en recargas de 100 USD (equivalente a un 15% de descuento sobre el sitio oficial), recargas en moneda local (sin necesidad de tarjetas de crédito internacionales) y logs completos consultables mediante request_id en la consola (lo que reduce drásticamente los costos de depuración).

🎯 Sugerencia de acción: Sigue paso a paso el proceso de resolución de 5 puntos del tercer capítulo. Si después de esto el problema persiste, registra el request_id y envíalo al soporte técnico de APIYI (apiyi.com) junto con el cuerpo de tu solicitud (omitiendo información sensible); generalmente, podremos darte una solución precisa en menos de una hora.

Referencias

  1. Documentación oficial de la API de Google Gemini: Comprensión y generación de imágenes

    • Enlace: ai.google.dev/gemini-api/docs/image-generation
    • Descripción: Especificaciones de los campos inline_data / file_data, lista de mime_type

  2. Guía para desarrolladores de Gemini 3: Guía de migración a nuevos modelos

    • Enlace: ai.google.dev/gemini-api/docs/gemini-3
    • Descripción: Diferencias entre gemini-3-pro-image-preview y modelos anteriores

  3. RFC 4648 – Codificaciones de datos Base16, Base32 y Base64: Especificación estándar de Base64

    • Enlace: datatracker.ietf.org/doc/html/rfc4648
    • Descripción: Diferencias entre el estándar Base64 (§4) y Base64 seguro para URL (§5)

  4. Sitio web oficial de APIYI: Servicio proxy de API para toda la serie de Gemini / Claude / OpenAI

    • Enlace: apiyi.com
    • Descripción: Compatibilidad con formatos nativos, concurrencia ilimitada, recargas en moneda local (RMB), obtén un 10% adicional al recargar 100 USD

Autor: Equipo técnico
Última actualización: 02-05-2026
Sobre APIYI: APIYI (apiyi.com) es un proveedor profesional de servicios proxy de API para Modelos de Lenguaje Grande, que ofrece acceso estable a modelos como gemini-3-pro-image-preview, Claude Sonnet 4.5, Claude Opus 4.7, la serie GPT y más. Es totalmente compatible con los formatos nativos de Gemini, OpenAI y Anthropic. Su consola permite la búsqueda inversa de registros de solicitudes completos mediante request_id. Ofrecen un 10% de bonificación al recargar 100 USD (equivalente a un 15% de descuento respecto al sitio oficial), sin límites de concurrencia y con un soporte técnico de respuesta rápida.

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

Publicaciones Similares