3 formas de resolver la salida de imágenes PNG de la API de Nano Banana 2: la verdad sobre cómo reducir imágenes 4K de 30MB a 8MB

Nota del autor: Análisis detallado sobre cómo la API Nano Banana 2 genera imágenes en formato PNG en lugar de JPEG, y las razones técnicas por las que el tamaño de las imágenes 4K en AI Studio se redujo drásticamente de 30 MB a 8 MB, cubriendo las diferencias de control de formato entre Vertex AI y AI Studio.

Muchos desarrolladores se han encontrado con esta confusión al generar imágenes con la API Nano Banana 2: La API devuelve datos en base64, pero ¿se guarda realmente como PNG o JPEG? Lo que resulta aún más desconcertante es que, con la misma resolución 4K, el tamaño de las imágenes generadas por AI Studio ha caído de más de 30 MB a unos 8 MB. En este artículo, analizaremos los mecanismos subyacentes de la API para aclarar la verdad sobre el control de formato y los cambios en el tamaño de archivo.

Valor principal: Al terminar de leer este artículo, dominarás el método correcto para obtener imágenes en formato PNG desde la API Nano Banana 2 y comprenderás la causa fundamental de la reducción del tamaño en imágenes 4K.

Puntos clave del formato de salida de imagen de la API Nano Banana 2

Primero, establezcamos un hecho clave: los datos de imagen devueltos por la API Nano Banana 2 están codificados en base64, pero base64 es solo una forma de codificación de transporte; lo que realmente determina el formato de la imagen son los datos de bytes subyacentes.

Mecanismo subyacente de la salida de imagen de la API Nano Banana 2

Nano Banana 2 (ID del modelo: gemini-3.1-flash-image-preview) devuelve la salida de imagen a través del objeto inlineData, con la siguiente estructura:

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

Existe un error confirmado oficialmente por Google (GitHub Issue #1824): el campo mime_type en la respuesta se declara como image/png, pero los datos de bytes decodificados pueden ser en realidad formato JPEG. Esto significa que no puedes confiar simplemente en el tipo MIME devuelto por la API; debes determinar el formato real a través de los magic bytes de la cabecera del archivo.

El método de detección es sencillo: la cabecera de un archivo JPEG es \xff\xd8, y la de un PNG es \x89PNG\r\n\x1a\n.

title: "3 formas de obtener imágenes en formato PNG con la API de Nano Banana 2"
description: "Guía técnica para asegurar que tus imágenes generadas por Nano Banana 2 se guarden siempre en formato PNG, evitando problemas de compatibilidad."

3 formas de obtener imágenes en formato PNG con la API de Nano Banana 2

Este es el núcleo del artículo: cómo asegurarte de obtener imágenes en formato PNG real.

Método 1: Conversión mediante cliente Python (Recomendado para AI Studio)

Dado que la API de Gemini en AI Studio no admite el control de formato en el lado del servidor, la forma más fiable es realizar la conversión en el cliente:

import base64
from PIL import Image
from io import BytesIO

# Invocar a Nano Banana 2 para generar la imagen
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=["Un gato naranja durmiendo bajo el sol"],
    config=types.GenerateContentConfig(
        response_modalities=["TEXT", "IMAGE"],
        image_config=types.ImageConfig(
            image_size="4K",
            aspect_ratio="1:1"
        ),
    )
)

# Guardar como formato PNG (independientemente del formato que devuelva la API)
for part in response.parts:
    if image := part.as_image():
        image.save("output.png", format="PNG")  # Forzar guardado sin pérdida en PNG

El punto clave es especificar explícitamente format="PNG" dentro de image.save("output.png", format="PNG"). Si no se especifica el parámetro format, Pillow lo deducirá a partir de la extensión del archivo; esto suele funcionar, pero declararlo explícitamente es mucho más 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 el formato real de una imagen en base64 y la convierte/guarda

    Args:
        base64_data: Datos de la imagen codificados en base64
        output_path: Ruta del archivo de salida
        target_format: Formato objetivo (PNG/JPEG/WEBP)
    """
    image_bytes = base64.b64decode(base64_data)

    # Detectar formato real mediante 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 = "Desconocido"

    print(f"Formato real devuelto por la API: {actual_format}")
    print(f"Tamaño de datos original: {len(image_bytes) / 1024 / 1024:.2f} MB")

    # Abrir con Pillow y convertir al formato objetivo
    img = Image.open(BytesIO(image_bytes))
    print(f"Dimensiones de la imagen: {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"Tamaño del archivo tras guardar: {saved_size:.2f} MB ({target_format})")

Método 2: Control de formato en el lado del servidor con Vertex AI

Si utilizas Vertex AI para invocar a Nano Banana 2, puedes especificar el formato de salida directamente en la solicitud. Esta es la única forma que admite control de formato en el 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=["Un gato naranja durmiendo bajo el sol"],
    config=types.GenerateContentConfig(
        response_modalities=["TEXT", "IMAGE"],
        image_config=types.ImageConfig(
            image_size="4K",
            aspect_ratio="1:1",
            output_mime_type="image/png",         # Especificar salida PNG
            # compression_quality=75,             # Solo válido para JPEG, 0-100
        ),
    )
)

Método 3: Procesamiento unificado a través del servicio proxy de API de APIYI

Al realizar la invocación a través del servicio proxy de API de APIYI, la plataforma gestiona automáticamente los problemas de compatibilidad 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": "Un gato naranja durmiendo bajo el sol"}
    ]
)

🎯 Consejo sobre formatos: Elige PNG si necesitas calidad sin pérdida, o JPEG si buscas un tamaño reducido (una calidad de 95 es casi indistinguible de la original).
Recomendamos realizar pruebas a través de la plataforma APIYI (apiyi.com), ya que gestiona la compatibilidad de formatos de forma unificada, evitándote la molestia de decodificar base64 y detectar formatos manualmente.

Comparativa de capacidades de control de formato de la API de Nano Banana 2

Este es un punto donde muchos desarrolladores suelen confundirse: las capacidades de control de formato entre AI Studio y Vertex AI son completamente diferentes.

Comparativa de parámetros de formato en la API de Nano Banana 2

Esto significa que, si utilizas AI Studio para invocar a Nano Banana 2, no podrás controlar en el servidor si la salida es PNG o JPEG. El formato que devuelva la API dependerá del comportamiento predeterminado del servidor de Google, el cual actualmente presenta un error (puede afirmar que es PNG cuando en realidad es JPEG).

Comparativa de tamaño según el formato en la API de Nano Banana 2

Para una misma imagen generada por IA en 4K (4096×4096), la diferencia de tamaño según el formato es enorme:

PNG es un formato sin pérdida; el tamaño del archivo refleja directamente la complejidad de la información (entropía) de la imagen. Cuanto más ricos sean los detalles y más compleja la textura, mayor será el archivo PNG. Esta es la base fundamental para entender los cambios de tamaño en imágenes 4K.

Nota: Si tu caso de uso no requiere un canal de transparencia, un JPEG con calidad 95 es visualmente casi indistinguible de un PNG, pero ocupa entre 1/4 y 1/3 del tamaño. A través de APIYI (apiyi.com) puedes comparar rápidamente las diferencias de rendimiento entre ambos formatos en escenarios reales.

La verdad sobre la reducción del tamaño de las imágenes 4K de la API de Nano Banana 2

Esta es la pregunta que más preocupa a muchos usuarios: ¿por qué, manteniendo la misma resolución 4K, las imágenes de Nano Banana 2 generadas en AI Studio han pasado de más de 30 MB a unos 8 MB?

El cambio en el tamaño de las imágenes de la API de Nano Banana 2 no es un problema de formato

Primero, descartemos un malentendido común: esto no se debe a que el formato PNG se haya convertido a JPEG. Si compruebas los magic bytes, verás que el formato de los datos devueltos no ha cambiado.

La verdadera razón es que Google ha ajustado los parámetros de cálculo del modelo en el servidor, lo que ha reducido la complejidad de la información (valor de entropía) de la imagen generada. Existen tres mecanismos específicos:

Razón 1: Reducción de los pasos de inferencia (causa principal)

Cuando un modelo de difusión genera una imagen, debe pasar por múltiples rondas de iteración de eliminación de ruido (denoising). El número de pasos de eliminación de ruido determina directamente la riqueza de los detalles de la imagen:

• Antes: Se utilizaban posiblemente entre 50 y 100 iteraciones, lo que generaba imágenes con texturas ricas y detalles finos.
• Ahora: Es posible que se haya reducido a 20-40 pasos; la imagen es clara en su conjunto, pero la complejidad de los detalles locales y las texturas ha disminuido.

Menos pasos de eliminación de ruido → menos detalles de textura → menor entropía de información → menor tamaño tras la compresión sin pérdida PNG.

No es tan simple como decir que "la calidad de imagen ha empeorado": a simple vista, la composición general y los colores pueden no diferir mucho, pero si amplías a nivel de píxel, notarás que las microtexturas y los degradados de color no son tan delicados como antes.

Razón 2: Optimización del preprocesamiento en el servidor

Es posible que Google, tras finalizar la generación y antes de codificar en PNG, haya añadido un ligero procesamiento de reducción de ruido y simplificación de color:

• La supresión tenue de ruido reduce los detalles de alta frecuencia.
• La reducción de los niveles de degradado de color disminuye la finura de las transiciones cromáticas.
• Estos procesos hacen que la compresión PNG sea más eficiente (hay más píxeles similares, por lo que la tasa de compresión es mayor).

Razón 3: Ajuste de la precisión de punto flotante

La inferencia del modelo podría haber cambiado de FP32 (punto flotante de 32 bits) a FP16 (punto flotante de 16 bits):

• La precisión de cálculo de FP16 es la mitad que la de FP32, y el uso de la GPU también se reduce drásticamente.
• La menor precisión provoca que los degradados de color no sean tan suaves como antes, lo que finalmente se refleja en una reducción del tamaño del archivo PNG.

Cronología del cambio de tamaño de las imágenes de la API de Nano Banana 2

Conclusión clave: Este es un compromiso que Google ha tomado para equilibrar el volumen de usuarios y la calidad del servicio durante el periodo de escasez de capacidad de TPU. La resolución (número de píxeles) se mantiene, pero la densidad de información (la cantidad de información única que porta cada píxel) ha disminuido. Los usuarios no pueden restaurar la calidad de 30 MB mediante parámetros de la API.

🎯 Sugerencia: Si requieres una calidad de detalle extremadamente alta, puedes intentar: 1) usar el parámetro compressionQuality=100 de Vertex AI; 2) enfatizar los requisitos de detalle y textura en la indicación; 3) generar en 2K y luego usar un modelo de superresolución para escalar a 4K.
A través de APIYI (apiyi.com) puedes probar simultáneamente los efectos de diferentes combinaciones de parámetros para encontrar el equilibrio óptimo entre calidad y tamaño.

Preguntas frecuentes

Resumen

Puntos clave para el control del formato de salida de imágenes en la API de Nano Banana 2:

1. AI Studio no admite control de formato en el servidor: Es necesario decodificar el base64 en el cliente y guardarlo explícitamente como PNG usando Pillow. Asegúrate de verificar los magic bytes para confirmar el formato real.
2. Vertex AI admite outputMimeType: Puedes especificar directamente image/png o image/jpeg en la solicitud, además de configurar la calidad de compresión JPEG.
3. La reducción de tamaño en 4K es un ajuste de potencia de cómputo: Pasar de 30 MB a 8 MB no se debe a un cambio de formato, sino a que Google reduce los pasos de inferencia y la precisión de punto flotante, lo que disminuye la entropía de la información. El usuario no puede recuperar esto mediante parámetros.

Al comprender estos mecanismos subyacentes, podrás elegir la estrategia de guardado de formato más adecuada según tus necesidades reales.

Te recomendamos usar APIYI (apiyi.com) para verificar rápidamente los efectos de diferentes formatos y parámetros. La plataforma ofrece cuotas gratuitas, una interfaz unificada y es compatible con múltiples formas de invocación del modelo para Nano Banana 2.

📚 Referencias

1. Documentación de desarrollo de generación de imágenes de Gemini: Referencia oficial de la API, incluye la descripción de los parámetros de ImageConfig.

   • Enlace: ai.google.dev/gemini-api/docs/image-generation
   • Descripción: Aprende sobre los parámetros y limitaciones al realizar llamadas a través de AI Studio.

2. Referencia de ImageOutputOptions en Vertex AI: Documentación completa de los parámetros de control de formato en Vertex AI.

   • Enlace: docs.cloud.google.com/vertex-ai/generative-ai/docs/reference/rest/Shared.Types/ImageOutputOptions
   • Descripción: Incluye explicaciones detalladas sobre mimeType y compressionQuality.

3. GitHub Issue #1824 – Desajuste de tipo MIME: Informe de error donde la API indica PNG pero devuelve JPEG.

   • Enlace: github.com/googleapis/python-genai/issues/1824
   • Descripción: Conoce los detalles técnicos y las soluciones temporales para este problema conocido.

4. Centro de documentación de APIYI: Guía de control de formato para invocar Nano Banana 2 a través de una interfaz unificada.

   • Enlace: docs.apiyi.com
   • Descripción: Ideal para desarrolladores que necesitan simplificar el proceso de manejo de formatos.

Autor: Equipo técnico de APIYI
Intercambio técnico: Te invitamos a debatir en la sección de comentarios. Para más información, visita el centro de documentación de APIYI en docs.apiyi.com.