GPT Image 2: generar PNG y WebP transparentes con la API

Para generar un recurso transparente con gpt-image-2, envía background: "transparent" y elige output_format: "png" o "webp". Después decodifica el campo b64_json y guarda sus bytes sin convertirlos a JPEG. A fecha de 8 de septiembre de 2026, OpenAI documenta esta función en vista previa en su guía de generación de imágenes.

El resultado necesita tres comprobaciones distintas: que el contenido tenga el formato solicitado, que el canal alfa contenga transparencia y que el recorte sirva sobre el fondo de destino. Un PNG puede ser completamente opaco; también puede tener todos sus píxeles transparentes y no mostrar nada. Ninguno de esos archivos resuelve la tarea de obtener un objeto reutilizable.

Antes de empezar, identifica el servicio que utilizas

Los parámetros de esta guía corresponden a la Images API de OpenAI. Si la llamas directamente, puedes comprobar el modelo y el cuerpo de la petición. Si usas una pasarela de terceros, revisa además su documentación: que anuncie compatibilidad con OpenAI o muestre el nombre GPT Image 2 no acredita que su alias admita y aplique background: "transparent".

En ChatGPT, pedir «fondo transparente» es una instrucción en el chat; no equivale a establecer un parámetro de la API. La documentación citada no confirma controles equivalentes en esa interfaz. Descarga la imagen que te entregue y comprueba el archivo antes de concluir que admite transparencia o que ha fallado. Una captura de pantalla del resultado no conserva el canal alfa del archivo original.

Si una guía antigua dice que GPT Image 2 no admite fondos transparentes, contrasta la fecha y el servicio al que se refiere con la documentación vigente. La disponibilidad en vista previa de la API no demuestra el comportamiento de una integración concreta. Esta distinción evita intentar arreglar el código cuando el servicio utilizado no ofrece la misma opción.

Elige el formato antes de enviar la petición

PNG resulta cómodo para intercambiar un recurso con herramientas de edición. WebP también admite transparencia y puede encajar en una entrega web. El formato WebP permite codificación con y sin pérdida, según su documentación técnica, pero eso no convierte cualquier ajuste de la API en una garantía de compresión sin pérdida.

Si eliges WebP, no interpretes output_compression como un porcentaje de reducción del archivo, un descuento en tokens o una promesa de menor coste. La elección del formato tampoco resuelve por sí sola un mal recorte.

Una petición que guarda PNG o WebP sin confundir los bytes

El siguiente programa usa la Images API de OpenAI. Necesitas una clave de API en la variable de entorno OPENAI_API_KEY; no la incluyas en el código ni en un repositorio. Instala las dependencias:

bash
python -m pip install requests Pillow

Guarda este código como generar.py. Puedes ejecutarlo con python generar.py png o python generar.py webp. Cada ejecución envía una petición de generación con la facturación que corresponda a tu cuenta.

python
import base64
import io
import os
import sys
from pathlib import Path

import requests
from PIL import Image


def guardar(datos, formato, destino):
    resultados = datos.get("data") or []
    if not resultados or not resultados[0].get("b64_json"):
        raise ValueError("La respuesta no contiene una imagen base64")
    contenido = base64.b64decode(resultados[0]["b64_json"], validate=True)
    with Image.open(io.BytesIO(contenido)) as imagen:
        real = imagen.format
        imagen.load()
    if real != formato.upper():
        raise ValueError(f"Se pidió {formato}, pero los bytes son {real}")
    Path(destino).write_bytes(contenido)
    print(f"Guardado: {destino} ({len(contenido)} bytes)")


if __name__ == "__main__":
    formato = sys.argv[1] if len(sys.argv) > 1 else "png"
    if formato not in {"png", "webp"}:
        raise SystemExit("Uso: python generar.py png|webp")

    peticion = {
        "model": "gpt-image-2",
        "prompt": (
            "Crea una pegatina de una tetera de cerámica azul, aislada, "
            "con fondo completamente transparente y un contorno limpio. "
            "No incluyas escenario, fondo sólido, cuadrícula ni sombra proyectada."
        ),
        "background": "transparent",
        "output_format": formato,
        "size": "1024x1024",
        "quality": "medium",
    }
    respuesta = requests.post(
        "https://api.openai.com/v1/images/generations",
        headers={"Authorization": f"Bearer {os.environ['OPENAI_API_KEY']}"},
        json=peticion,
        timeout=300,
    )
    respuesta.raise_for_status()
    guardar(respuesta.json(), formato, f"tetera.{formato}")

El programa omite la compresión en ambos formatos para facilitar la primera comprobación. Si quieres ajustarla, añade, por ejemplo, peticion["output_compression"] = 80 solo cuando formato == "webp", antes de enviar la petición. Ese número es un ajuste del codificador; no significa «archivo un 80 % más pequeño».

La guía oficial de instrucciones para GPT Image recomienda pedir un sujeto aislado y excluir los elementos que no deban aparecer. Aquí se excluye la sombra porque la pegatina no la necesita. Para otro recurso puedes querer conservarla. La descripción orienta el resultado visual; background establece la salida transparente.

En esta respuesta, el cuerpo HTTP es JSON: su MIME no será el de la imagen. La comprobación PNG/WebP corresponde a los bytes decodificados. Cuando sirvas el archivo desde tu aplicación, usa entonces image/png o image/webp. Cambiar el nombre de tetera.webp a tetera.png no convierte su contenido.

Los ejemplos se basan en los parámetros documentados. Las comprobaciones locales de archivos no demuestran el éxito de una llamada de generación ni la disponibilidad del modelo en una cuenta concreta.

Comprobar el archivo y distinguir transparencia de vacío

Guarda lo siguiente como comprobar.py y ejecútalo con python comprobar.py tetera.png o con la ruta del WebP. El script comprueba el contenido real y la extensión, y clasifica el canal alfa:

python
import sys
from pathlib import Path
from PIL import Image


def comprobar(ruta):
    ruta = Path(ruta)
    with Image.open(ruta) as imagen:
        formato = imagen.format
        esperado = {".png": "PNG", ".webp": "WEBP"}.get(ruta.suffix.lower())
        if esperado is None or formato != esperado:
            raise ValueError(f"Extensión {ruta.suffix}; contenido {formato}")
        rgba = imagen.convert("RGBA")

    histograma = rgba.getchannel("A").histogram()
    transparentes = histograma[0]
    parciales = sum(histograma[1:255])
    opacos = histograma[255]
    total = rgba.width * rgba.height

    if transparentes == total:
        estado = "VACÍO: todos los píxeles son transparentes"
    elif opacos == total:
        estado = "OPACO: no hay transparencia"
    else:
        estado = "CON TRANSPARENCIA: revisa el contorno sobre distintos fondos"

    resultado = {
        "formato": formato,
        "dimensiones": rgba.size,
        "transparentes": transparentes,
        "semitransparentes": parciales,
        "opacos": opacos,
        "estado": estado,
    }
    print(resultado)
    return resultado


if __name__ == "__main__":
    comprobar(sys.argv[1])

Pillow identifica el formato al abrir la imagen y permite inspeccionar el canal alfa. Convertir a RGBA facilita la lectura uniforme, pero no elimina un fondo blanco ni crea un recorte: una imagen opaca convertida a RGBA seguirá teniendo alfa 255 en todos sus píxeles.

Los valores tienen una interpretación concreta:

• 0: el píxel es totalmente transparente.
• 1 a 254: el píxel es parcialmente transparente.
• 255: el píxel es opaco.

Un archivo que contiene solo valores intermedios puede ser válido para humo o cristal. Por eso el script no exige que existan a la vez píxeles con valor 0 y 255. Tampoco establece un porcentaje mínimo universal. Para una pegatina centrada suele tener sentido dejar espacio totalmente transparente alrededor; en materiales translúcidos, la distribución será otra.

El estado «CON TRANSPARENCIA» solo confirma una propiedad de los píxeles. Coloca el resultado sobre blanco, negro y un color intenso para comprobar los bordes. Un halo claro que aparece sobre negro señala contaminación del borde; una cuadrícula que sigue visible sobre todos los fondos puede estar dibujada en el propio recurso. Un visor con fondo blanco, por sí solo, no permite distinguir ninguno de estos casos.

El PNG aparece con fondo negro: ¿se ha perdido la transparencia?

No necesariamente. Un visor necesita mostrar algún color detrás de los píxeles transparentes y puede utilizar negro. El color que ves en pantalla no basta para saber si pertenece a la imagen. No conviertas el archivo ni vuelvas a generarlo solo por esa apariencia.

Primero ejecuta comprobar.py sobre el archivo descargado. Si indica que es opaco, el negro —o cualquier otro fondo— forma parte del contenido visible; compara ese archivo con la primera salida decodificada para localizar dónde se perdió la transparencia. Si indica que está vacío, falta un sujeto visible, aunque el visor muestre un rectángulo negro.

Si el script encuentra transparencia, abre el archivo en un editor que admita capas y coloca una capa de color debajo del recurso. Cambia esa capa de negro a blanco y después a un color intenso. Si el área alrededor del sujeto deja ver esos colores, la transparencia funciona. Si queda un rectángulo negro fijo, esa zona es opaca, aunque haya transparencia en otros píxeles del archivo.

Puedes hacer la misma comparación en la aplicación de destino cambiando el fondo del contenedor. Si funciona en el editor pero falla en tu web, descarga la imagen que entrega la web y comprueba esa copia: una miniatura o una exportación puede haber perdido el alfa. Así separas el fondo del visor, el contenido del archivo y una transformación posterior sin repetir una generación innecesariamente.

Quitar el fondo de una imagen existente

Para partir de una foto, envía una edición a /v1/images/edits. Este ejemplo reutiliza la función guardar de generar.py; guárdalo junto a ese archivo y coloca tu imagen de entrada en producto.png:

python
import os
import requests
from generar import guardar

with open("producto.png", "rb") as entrada:
    respuesta = requests.post(
        "https://api.openai.com/v1/images/edits",
        headers={"Authorization": f"Bearer {os.environ['OPENAI_API_KEY']}"},
        data={
            "model": "gpt-image-2",
            "prompt": (
                "Retira el fondo y aísla el producto sobre transparencia real. "
                "Conserva su forma, proporciones, colores y texto de la etiqueta. "
                "No añadas escena, cuadrícula, fondo sólido ni sombra nueva. "
                "Mantén los bordes sin halos."
            ),
            "background": "transparent",
            "output_format": "png",
        },
        files={"image": ("producto.png", entrada, "image/png")},
        timeout=300,
    )
respuesta.raise_for_status()
guardar(respuesta.json(), "png", "producto-sin-fondo.png")

La petición expresa qué debe conservarse, pero no garantiza identidad píxel a píxel ni fidelidad absoluta del texto. Si trabajas con envases de marca o un catálogo, compara el producto y su etiqueta con el original, además de comprobar el alfa. Para pelo, cristal o resplandores, no confundas los bordes semitransparentes necesarios con un fallo.

Repite background: "transparent" y la indicación de conservar la transparencia en cada edición posterior. Una corrección de color o de un detalle produce una nueva salida y necesita su propia comprobación. Si la fidelidad es imprescindible y la edición altera el objeto, utiliza una máscara o una herramienta específica de eliminación de fondos sobre el original.

Pasar de PNG a WebP conservando el alfa

Si ya tienes un PNG correcto, no necesitas volver a generar el objeto para cambiar el formato. Puedes hacer la conversión local:

python
from PIL import Image

with Image.open("tetera.png") as original:
    rgba = original.convert("RGBA")
    rgba.save("tetera.webp", format="WEBP", lossless=True, exact=True)

En el codificador WebP de Pillow, lossless=True selecciona compresión sin pérdida y exact=True conserva los valores RGB de los píxeles transparentes, según su documentación de formatos. Son opciones de esta conversión local; no son equivalentes a output_compression de la API ni prometen un tamaño de archivo concreto.

Ejecuta de nuevo comprobar.py sobre el WebP. Evita convertir antes a RGB o exportar a JPEG: se perdería el canal alfa. Si necesitas una versión JPEG, compón expresamente la imagen sobre el color elegido y conserva también el original transparente.

Si falla, localiza primero en qué paso

Conserva el identificador de petición, el servicio utilizado, el modelo solicitado, los parámetros enviados y el archivo original para poder comparar o comunicar el problema al proveedor. Un HTTP 200 o la presencia de la palabra PNG no demuestra que el servicio haya conservado el fondo transparente.

Si necesitas decidir qué interfaz integrar antes de escribir el código, consulta la guía de GPT Image 2 API. Cuando ya tengas el recurso, la última comprobación debe hacerse sobre el archivo que recibe tu usuario: la generación puede haber conservado la transparencia y una transformación posterior haberla eliminado.