# Fondo transparente en GPT Image: cómo quitar los cuadros grises > Si los cuadros de ChatGPT siguen ahí al poner la imagen sobre un fondo de color, están pintados. En la API se evita con background transparent y PNG o WebP. - URL: https://blog.laozhang.ai/es/posts/gpt-image-transparent-background-checkerboard - Published: 2026-10-02 - Updated: 2026-10-02 - Author: LaoZhang AI Team (https://blog.laozhang.ai/es/about) - Category: Inteligencia artificial - Tags: GPT Image 2.5, ChatGPT Images, Fondo transparente, PNG transparente, Canal alfa --- Pides a ChatGPT o a la API de GPT Image una pegatina, un logo o un producto recortado «con fondo transparente» y lo que llega trae detrás cuadritos grises y blancos, el patrón de ajedrez que los editores muestran donde no hay nada. Ese patrón puede significar dos cosas opuestas. Si lo dibuja el programa con el que miras la imagen, el fondo es transparente de verdad. Si forma parte de los píxeles del archivo, el modelo ha pintado una cuadrícula y el fondo es tan opaco como una pared. La prueba que los separa es inmediata: coloca el archivo guardado sobre un fondo de color vivo. Si ves el color detrás del sujeto, la transparencia es real. Si los cuadros siguen ahí, están pintados y hay que volver a generar o reparar. Lo que cuenta es el archivo guardado, no la vista previa ni la extensión. A partir de ahí, la solución depende de dónde se generó la imagen. En la API, la transparencia se pide con el parámetro `background` en `transparent` y salida en PNG o WebP; escribir «transparente» en el texto de la petición no fija ese parámetro. En ChatGPT no hay ningún interruptor: solo puedes pedirlo con palabras y comprobar después lo que descargas. Sobre el origen de cada dato: lo que hacen ChatGPT y la API procede de la documentación de OpenAI y de testimonios de usuarios, enlazados en cada apartado. Lo único ejecutado para este artículo son los dos scripts de Python de más abajo, en local y sobre archivos sintéticos dibujados con Pillow. No hay aquí ninguna imagen generada en ChatGPT ni ninguna llamada de pago a la API. ## Cuadros grises y blancos: cuándo son transparencia y cuándo están pintados Son transparencia cuando desaparecen al cambiar lo que hay debajo. Un PNG o un WebP pueden guardar, además del color de cada píxel, cuánto deja ver de lo que tiene detrás: ese dato es el canal alfa. Como «nada» no se puede enseñar en pantalla, Photoshop, GIMP, Canva y muchos visores rellenan las zonas transparentes con cuadros grises y blancos. Es una ayuda visual del programa y no está en el archivo. La cuadrícula pintada es otra cosa: el modelo ha generado una imagen opaca cuyo fondo representa ese patrón. Todos los píxeles tienen color, ninguno es transparente, y al colocar la imagen sobre una camiseta, una web o una diapositiva los cuadros viajan con ella. Para saber cuál tienes, abre cualquier editor o una presentación, pon un fondo rojo, azul o verde y arrastra encima el archivo original: | Lo que ves sobre el fondo de color | Qué significa | Qué hacer | | --- | --- | --- | | El color aparece alrededor y por los huecos del sujeto | Transparencia real | Revisa los bordes y úsalo | | Siguen los cuadros grises y blancos | La cuadrícula está pintada en la imagen | Vuelve a generar o repara (más abajo) | | Un rectángulo blanco o negro liso | El archivo no tiene transparencia: se generó opaco o se perdió al guardar, convertir o enviar | Recupera el archivo original o vuelve a exportar en PNG o WebP | Hay tres pistas que no sirven como prueba: - **La vista previa.** La ayuda de OpenAI no documenta qué muestra ChatGPT detrás de una imagen transparente, así que ver o no ver cuadros en el chat no permite concluir nada. - **La extensión.** Un PNG puede ser completamente opaco, y un archivo llamado `.png` puede contener en realidad un JPEG. - **Una captura de pantalla.** Es una imagen nueva y opaca de lo que había en pantalla, con cuadros incluidos si el visor los estaba dibujando. Si lo que te molesta es una trama de cuadrícula o de grano sobre una imagen que no pediste transparente, el problema es distinto y se trata en [ruido, grano o cuadrícula en GPT Image 2.5](https://blog.laozhang.ai/es/posts/gpt-image-2-5-noise-grainy). ## Dónde se estropeó: ChatGPT, la API, un intermediario o al guardar El punto donde se perdió la transparencia depende de por dónde pasó la imagen, y cada punto tiene una comprobación propia. | De dónde viene la imagen | Qué pudo fallar | Cómo comprobarlo | Qué hacer | | --- | --- | --- | --- | | App o web de ChatGPT | El modelo pintó la cuadrícula o un fondo liso; no hay parámetro que lo impida | Fondo de color con el archivo descargado | Pedirlo de nuevo en un chat limpio con una instrucción más explícita, o pasar a un quitafondos | | API de OpenAI | No se envió `background`, vale `auto` y el fondo lo decidió el modelo; o se pidió `jpeg` | Campos `background` y `output_format` de la respuesta | Enviar `background: "transparent"` y `output_format: "png"` o `"webp"` | | API a través de un proveedor de terceros | La vía elegida no admite o no reenvía el parámetro | Documentación de ese modelo en el proveedor y análisis del archivo recibido | Cambiar a un modelo del proveedor que documente la salida transparente | | Automatización (n8n y similares) | El nodo no expone `background` | Configuración del nodo | Llamar a la API con una petición HTTP propia | | Cualquiera de las anteriores, después de guardar | Conversión a JPG, captura de pantalla o recodificación al subir | Analizar el archivo final y compararlo con el original | Volver al archivo original y enviarlo como PNG o WebP | ![Esquema de cinco orígenes de una imagen sin transparencia, con qué falló en cada uno, cómo comprobarlo y qué hacer: ChatGPT, API de OpenAI, proveedor de terceros, automatización y después de guardar](https://blog.laozhang.ai/posts/es/gpt-image-transparent-background-checkerboard/img/diagnostico-por-origen.webp) Las cuatro primeras filas son fallos de generación: el archivo nunca tuvo canal alfa. La última es un fallo de traspaso: el archivo era bueno y dejó de serlo por el camino. Conviene distinguirlos antes de repetir nada, porque regenerar no arregla un problema de exportación. ## En ChatGPT se pide con palabras: qué escribir y qué revisar ChatGPT puede devolver transparencia real, pero no ofrece ningún control que la garantice. La [ayuda de OpenAI sobre imágenes en ChatGPT](https://help.openai.com/en/articles/11084440-images-in-chatgpt) dice que ChatGPT Images puede, siguiendo instrucciones, «make the background transparent». A 2 de octubre de 2026 esa página no describe ningún interruptor de transparencia ni el formato del archivo que se descarga con Guardar. Que a veces falla lo cuentan los propios usuarios. En un [hilo de la comunidad de desarrolladores de OpenAI](https://community.openai.com/t/having-trouble-getting-transparent-backgrounds-in-chatgpt-images/1380143) de mayo y junio de 2026, uno describe que ChatGPT le devolvió una imagen en la que «the checkerboard was baked into the image», es decir, sin canal alfa; otros participantes del mismo hilo obtuvieron transparencia real o parcial. Esos mensajes son anteriores a ChatGPT Images 2.5 y demuestran que el fallo existe, no cada cuánto ocurre hoy. OpenAI no ha explicado por qué el modelo dibuja los cuadros. La explicación más repetida es que en las imágenes con las que aprendió, «transparente» aparece muy a menudo representado como una cuadrícula gris y blanca, y el modelo reproduce ese aspecto. Es una hipótesis razonable, no un dato confirmado. Lo que sí puedes controlar es la instrucción. La [guía de OpenAI para redactar peticiones de imagen](https://developers.openai.com/api/docs/guides/image-prompting) recomienda pedir el sujeto aislado y decir expresamente lo que no debe aparecer. Una versión que puedes copiar y adaptar: ```text Crea una pegatina de un zorro naranja. Sujeto aislado y centrado, con margen alrededor. Fondo totalmente transparente, con canal alfa real, en formato PNG. No dibujes una cuadrícula gris y blanca, ni un fondo liso, ni una escena, ni sombra bajo el sujeto, ni marca de agua. ``` Tres hábitos acompañan a esa instrucción: 1. Descarga con el botón Guardar y prueba ese archivo sobre un fondo de color. No uses una captura. 2. Si después pides un cambio («hazlo más grande», «cambia el color»), repite que el fondo debe seguir siendo transparente. La guía de OpenAI lo indica así para cada edición posterior. 3. Si salió una cuadrícula pintada, empieza de nuevo desde el original o desde un chat limpio. Pedir «quita la cuadrícula» sobre la imagen fallida es otra edición generativa, y la misma guía advierte de que las ediciones repetidas pueden alterar detalles que querías conservar. Para saber en qué parte de ChatGPT se crean y editan las imágenes y qué modelos de la API les corresponden, consulta [ChatGPT Images 2.5: cómo usarlo y elegir Sunburst o Flare en la API](https://blog.laozhang.ai/es/posts/chatgpt-images-2-5). ## En la API: `background` en `transparent` y salida en PNG o WebP En la API la transparencia es un parámetro, no una frase. Según la [referencia de la API de imágenes de OpenAI](https://developers.openai.com/api/reference/resources/images/methods/generate), `background` admite `transparent`, `opaque` y `auto`, y el valor por defecto es `auto`: el modelo elige el fondo que considera mejor. Por eso una petición que dice «fondo transparente» en el texto y no envía el parámetro puede volver con fondo blanco o con cuadros pintados sin que haya ningún error. El cuerpo mínimo de una petición a `POST /v1/images/generations` queda así: ```json { "model": "gpt-image-2.5-flare", "prompt": "Pegatina de un zorro naranja, sujeto aislado y centrado con margen. Fondo totalmente transparente, sin cuadrícula, sin fondo liso, sin escena y sin sombra.", "size": "1024x1024", "background": "transparent", "output_format": "png" } ``` Lo que conviene saber de cada pieza, a 2 de octubre de 2026: - **Modelos.** `gpt-image-2.5-sunburst` y `gpt-image-2.5-flare` admiten fondo transparente; en `gpt-image-2` la función está en vista previa. Si dudas entre los dos primeros, la diferencia está explicada en [GPT Image 2.5 Sunburst vs Flare](https://blog.laozhang.ai/es/posts/gpt-image-2-5-sunburst-vs-flare). - **Formato.** Con `transparent`, la referencia exige `png` o `webp`. `jpeg` no puede guardar canal alfa. - **Compresión.** `output_compression` solo se aplica a JPEG y WebP; con PNG se omite. - **Texto de la petición.** OpenAI recomienda las dos cosas a la vez: el parámetro y una descripción que pida el sujeto aislado sin cuadrícula, fondo liso, escena ni sombra. - **Ediciones.** El punto de conexión `/v1/images/edits` acepta los mismos campos. Hay que enviarlos en cada edición, no solo en la primera. - **Tamaño y calidad.** La referencia no vincula la transparencia a ningún tamaño ni nivel de calidad concretos. ### Los dos campos de la respuesta que delatan el fallo sin abrir la imagen La respuesta informa de lo que se usó realmente. La referencia describe en el objeto devuelto un campo `background`, con valor `transparent` u `opaque`, y un campo `output_format`, con `png`, `webp` o `jpeg`. La imagen llega codificada en Base64 dentro de `data[].b64_json`. Abreviada, la estructura documentada es esta: ```json { "background": "transparent", "output_format": "png", "data": [{ "b64_json": "..." }] } ``` Si tu código registra esos dos campos, sabrás antes de decodificar nada que una respuesta con `opaque` o `jpeg` no puede contener transparencia. El caso contrario no basta como garantía: aunque la respuesta diga `transparent`, la propia guía de OpenAI pide comprobar el canal alfa de la imagen decodificada, incluidos pelo, cristal, sombras y bordes. ### Por qué algunos artículos dicen que GPT Image no hace transparencias Porque eran correctos cuando se escribieron. Antes de agosto de 2026 la documentación de OpenAI indicaba que `gpt-image-2` no admitía fondo transparente; desde agosto de 2026 la función está en vista previa para ese modelo, y los modelos GPT Image 2.5, con versiones fechadas el 8 de septiembre de 2026, la incluyen sin esa etiqueta. Un tutorial anterior a esas fechas que da la transparencia por imposible describe una limitación que ya no existe en la API. ### En n8n y otras automatizaciones, comprueba que el nodo envía `background` Una herramienta intermedia solo sirve si deja pasar el parámetro. El nodo OpenAI integrado en n8n no lo envía, de modo que para fondo transparente hace falta el nodo HTTP Request, como se detalla en [GPT Image 2.5 en n8n: cuándo basta el nodo OpenAI y cuándo no](https://blog.laozhang.ai/es/posts/gpt-image-2-5-n8n). ## Con un proveedor de terceros, el modelo que eliges decide si llega el parámetro Un proveedor de terceros es un servicio que recibe tu petición y la reenvía a OpenAI o a otro canal, normalmente con su propia clave y su propia facturación. El nombre del modelo puede parecerse al oficial y comportarse de forma distinta, porque cada vía del proveedor admite unos parámetros u otros. Si enviaste `background: "transparent"` y recibiste cuadros pintados o fondo blanco, revisa antes que nada qué promete la documentación de ese modelo en concreto. La documentación de laozhang.ai, la plataforma a la que pertenece este blog, sirve de ejemplo porque separa tres casos con claridad. Según su [página de GPT Image 2.5](https://docs.laozhang.ai/en/api-capabilities/gpt-image-2-5), con precios públicos a 24 de septiembre de 2026: | Modelo en laozhang.ai | Facturación | Qué dice la documentación sobre `background` | | --- | --- | --- | | `gpt-image-2.5-flare-vip` y `gpt-image-2.5-sunburst-vip` | USD 0,03 por llamada | Generan imágenes con fondo transparente y quitan el fondo de una imagen subida con `"background": "transparent"` y `"output_format": "png"`. No admiten `mask` | | `gpt-image-2.5-flare` y `gpt-image-2.5-sunburst` (reenvío oficial) | Por tokens | Usan los parámetros de OpenAI | | `gpt-image-2.5-web` | USD 0,03 por llamada | Los parámetros admitidos dependen de la configuración y del resultado real; no hay que dar por hecho que valen las opciones de los modelos `-vip` | La lectura práctica: con la tercera fila puedes enviar `transparent` y no obtener transparencia, sin que eso sea un error del proveedor ni de OpenAI. Si trabajas con pago por llamada y necesitas el canal alfa, los dos modelos `-vip` son la opción documentada; esa documentación indica además que estuvieron sin servicio del 16 al 22 de septiembre de 2026 y que vuelven a estar disponibles. Con cualquier otro proveedor aplica el mismo criterio: busca una mención expresa del parámetro para el modelo que usas y analiza el primer archivo que recibas. Tampoco está garantizado que un intermediario devuelva los campos `background` y `output_format` de la respuesta tal como los envía OpenAI. El coste por imagen de cada vía se calcula en [precio de GPT Image 2.5 Sunburst por imagen, llamada y mes](https://blog.laozhang.ai/es/posts/gpt-image-2-5-api-pricing). ## Comprobar el archivo con Python: real, pintada u opaca Cuando generas muchas imágenes, la prueba del fondo de color no escala. Este script lee el tipo real del archivo y el canal alfa, y dice en qué caso está cada imagen. Solo necesita Python y Pillow (`pip install pillow`). ```python """Distingue la transparencia real de una cuadrícula pintada. Uso: python check_transparency.py imagen.png [más archivos...] Requiere Pillow (pip install pillow). """ import sys from collections import Counter from pathlib import Path from PIL import Image def border_pixels(rgb, ring=0.04): """Píxeles de un marco fino alrededor de la imagen, donde suele estar el fondo.""" w, h = rgb.size t = max(2, int(min(w, h) * ring)) px = rgb.load() for y in range(h): for x in range(w): if x < t or x >= w - t or y < t or y >= h - t: yield px[x, y] def painted_checkerboard(rgb): """True si el marco está hecho de dos tonos claros y neutros que se alternan.""" w, h = rgb.size small = rgb.resize((min(w, 256), min(h, 256)), Image.NEAREST) tones = Counter() total = 0 for r, g, b in border_pixels(small): total += 1 if max(r, g, b) - min(r, g, b) <= 12 and min(r, g, b) >= 150: tones[round((r + g + b) / 3 / 8)] += 1 # grises agrupados de 8 en 8 niveles if total == 0 or sum(tones.values()) / total < 0.85: return False # el marco no es mayoritariamente gris claro o blanco buckets = sorted(tones) light = [b for b in buckets if tones[b] / total >= 0.15] if len(light) < 2 or (max(light) - min(light)) * 8 < 10: return False # un solo tono: fondo blanco o gris liso # Los dos tonos deben alternarse en la fila superior, no formar dos bloques grandes. mid = (max(light) + min(light)) * 8 / 2 row = [sum(small.getpixel((x, 1))) / 3 > mid for x in range(small.width)] flips = sum(1 for a, b in zip(row, row[1:]) if a != b) return flips >= 4 def check(path): with Image.open(path) as im: real_format, mode = im.format, im.mode rgba = im.convert("RGBA") # la transparencia de paleta pasa a ser un canal alfa print(f"{path.name}: {real_format}, modo {mode}, {rgba.width}x{rgba.height}") if real_format not in ("PNG", "WEBP"): print(f" NO ES TRANSPARENTE: los bytes son {real_format}, un formato que no guarda el canal alfa.") return "wrong-format" hist = rgba.getchannel("A").histogram() total = rgba.width * rgba.height clear, solid = hist[0], hist[255] partial = total - clear - solid print(f" alfa: {clear / total:.1%} transparente, {partial / total:.1%} parcial, {solid / total:.1%} opaco") if clear == total: print(" VACÍA: todos los píxeles son transparentes.") return "empty" if clear + partial == 0: if painted_checkerboard(rgba.convert("RGB")): print(" FALSA: no hay píxeles transparentes y el marco es una cuadrícula de dos grises. Los cuadros están pintados.") return "painted-checkerboard" print(" OPACA: no hay píxeles transparentes. El fondo es parte de la imagen.") return "opaque" if clear == 0 and len([v for v in hist if v]) == 1: print(" ATENUADA: el mismo valor de alfa en toda la imagen. Se bajó la opacidad; no se recortó nada.") return "faded" print(" REAL: hay píxeles transparentes. Revisa ahora los bordes sobre un fondo oscuro y otro de color.") return "real" if __name__ == "__main__": if len(sys.argv) < 2: sys.exit(__doc__) for name in sys.argv[1:]: check(Path(name)) ``` Guárdalo como `check_transparency.py` y pásale uno o varios archivos: ```bash python check_transparency.py pegatina.png logo.webp ``` Para una imagen con la cuadrícula pintada, la salida es de este tipo (Python escribe los decimales con punto): ```text painted-checkerboard.png: PNG, modo RGB, 512x512 alfa: 0.0% transparente, 0.0% parcial, 100.0% opaco FALSA: no hay píxeles transparentes y el marco es una cuadrícula de dos grises. Los cuadros están pintados. ``` ### Qué significa cada veredicto | Veredicto | Qué ha encontrado | Siguiente paso | | --- | --- | --- | | REAL | Hay píxeles transparentes | Revisar bordes sobre fondo oscuro y de color | | FALSA | Ningún píxel transparente y un marco de dos grises claros que se alternan | Volver a generar o reparar | | OPACA | Ningún píxel transparente; fondo liso u otro contenido | Volver a generar con el parámetro o quitar el fondo | | NO ES TRANSPARENTE | El contenido no es PNG ni WebP, diga lo que diga la extensión | Recuperar el original o exportar de nuevo | | ATENUADA | Toda la imagen tiene la misma opacidad reducida; nada está recortado | No sirve como recorte | | VACÍA | Todos los píxeles son transparentes | Archivo inservible | El veredicto FALSA exige varias condiciones a la vez: que al menos el 85 % de un marco exterior del 4 % sea gris claro o blanco, que haya dos tonos distintos con al menos un 15 % del marco cada uno y que esos tonos se alternen cuatro veces o más en la fila superior. Así un fondo blanco liso se clasifica como OPACA y no como cuadrícula. ### Resultado sobre diez archivos sintéticos En una ejecución del 2 de octubre de 2026 con Python 3.12.1 y Pillow 12.0.0 en macOS, el script clasificó como se esperaba los diez archivos de prueba: - tres con transparencia real: PNG con canal alfa, WebP con canal alfa y PNG de paleta con un color transparente; - tres con cuadrícula pintada: guardada sin canal alfa, guardada con canal alfa pero todo opaco, y una versión desenfocada, con ruido y pasada por compresión JPEG; - un fondo blanco liso, un JPEG renombrado a `.png`, una imagen con la opacidad rebajada de forma uniforme y una imagen vacía. Esos archivos se dibujaron con Pillow: un círculo rojo con una etiqueta blanca sobre cuadros regulares de 16 píxeles. No son imágenes salidas de ChatGPT ni de la API. Una cuadrícula pintada por un modelo puede tener cuadros desiguales, perspectiva, grises más oscuros o sombreado, y en ese caso el script puede responder OPACA en lugar de FALSA. La conclusión útil se mantiene, porque en ambos casos el archivo no es transparente, pero el nombre exacto del veredicto no está validado con salidas reales del modelo. ## Convertir la cuadrícula pintada en transparencia: cuándo funciona Funciona con sujetos de colores planos y saturados sobre una cuadrícula clara, y falla con sujetos blancos o grises claros y con bordes suaves. El script siguiente parte de los bordes de la imagen y va borrando los píxeles claros y neutros conectados entre sí. Como solo avanza desde fuera, las zonas blancas encerradas dentro del sujeto, como unos ojos o una etiqueta, se quedan. ```python """Convierte una cuadrícula pintada (gris claro y blanco) en transparencia real. Uso: python remove_painted_checkerboard.py falsa.png reparada.png Requiere Pillow (pip install pillow). Rellena desde el borde de la imagen a través de los píxeles claros y neutros. Solo alcanza el fondo que toca el borde, así que las zonas blancas rodeadas por el sujeto (ojos, dientes, una etiqueta) se conservan. No separa un sujeto blanco o gris claro de la cuadrícula y deja un filo claro en los bordes suaves. """ import sys from collections import deque from PIL import Image src, dst = sys.argv[1], sys.argv[2] im = Image.open(src).convert("RGBA") w, h = im.size px = im.load() def is_grid(p): r, g, b, _ = p return max(r, g, b) - min(r, g, b) <= 14 and min(r, g, b) >= 170 seen = bytearray(w * h) queue = deque() for x in range(w): queue.append((x, 0)) queue.append((x, h - 1)) for y in range(h): queue.append((0, y)) queue.append((w - 1, y)) removed = 0 while queue: x, y = queue.popleft() i = y * w + x if seen[i]: continue seen[i] = 1 if not is_grid(px[x, y]): continue px[x, y] = (0, 0, 0, 0) removed += 1 if x > 0: queue.append((x - 1, y)) if x < w - 1: queue.append((x + 1, y)) if y > 0: queue.append((x, y - 1)) if y < h - 1: queue.append((x, y + 1)) im.save(dst) print(f"{removed / (w * h):.1%} de los píxeles pasan a ser transparentes -> {dst}") ``` Se usa con el archivo de entrada y el nombre del archivo de salida, y después conviene pasar el resultado por el primer script: ```bash python remove_painted_checkerboard.py falsa.png reparada.png python check_transparency.py reparada.png ``` ### Lo que midió la prueba y dónde se rompe Sobre los mismos archivos sintéticos, comparando cada resultado con el recorte correcto conocido de antemano: | Archivo de prueba | Fondo convertido en transparente | Píxeles del sujeto perdidos | Etiqueta blanca interior conservada | | --- | --- | --- | --- | | Cuadrícula pintada limpia, sujeto rojo | 100,0 % | 0 % | 100 % | | Cuadrícula con desenfoque, ruido y compresión JPEG, sujeto rojo | 99,63 % | 0 % | 100 % | | Sujeto casi blanco en contacto con la cuadrícula | — | 100 % | — | Los dos primeros archivos reparados pasaron después la comprobación con veredicto REAL. El tercero muestra el límite: un sujeto casi blanco que toca la cuadrícula desaparece entero, porque para el script es indistinguible del fondo. Hay otros tres límites que se deducen del método y del resultado: - **El borde queda duro.** En las imágenes reparadas no hay píxeles semitransparentes: cada píxel es totalmente visible o totalmente invisible. En una pegatina de trazo grueso apenas se nota; en pelo, humo, cristal o sombras suaves el contorno queda dentado o con un filo claro. - **Solo borra tonos claros y neutros.** El umbral es un gris con los tres canales en 170 o más y casi sin diferencia entre ellos. Una cuadrícula con grises más oscuros o con tinte de color se queda donde está. - **Solo borra lo que conecta con el borde de la imagen.** Los huecos de fondo encerrados por el sujeto, como el interior del asa de una taza, conservan sus cuadros. ![Resultados de la reparación sobre archivos sintéticos: el sujeto rojo se conserva sobre cuadrícula limpia o degradada, el sujeto casi blanco desaparece, y tres límites del método: borde duro, solo tonos claros y solo lo que toca el borde](https://blog.laozhang.ai/posts/es/gpt-image-transparent-background-checkerboard/img/limites-reparacion.webp) Con esos límites, la decisión es sencilla. Si el sujeto es de color plano y el contorno nítido, repara y comprueba. Si el sujeto es claro, tiene pelo o transparencias, o no puede cambiar ni un píxel, vuelve a generar desde el original con el parámetro `background`, o usa una herramienta de quitar fondos que trabaje por selección del sujeto; las opciones con Vista Previa, Paint, Office, Canva y webs especializadas están en [cómo hacer un PNG con fondo transparente y comprobar que lo es](https://blog.laozhang.ai/es/posts/transparent-image-maker). Pedirle al modelo que borre los cuadros de la imagen fallida es la peor de las tres vías cuando el sujeto debe quedar idéntico, porque vuelve a dibujarlo todo. ## El fondo era transparente y se volvió blanco al guardar o enviar Si el archivo original pasa la prueba y la copia que llega a su destino no, la transparencia se perdió en un traspaso. Los casos habituales: - **Guardar o convertir a JPG.** JPEG no tiene canal alfa: al convertir, las zonas transparentes se rellenan con un color liso. - **Hacer una captura** en lugar de descargar el archivo. - **Cambiar la extensión a mano.** Renombrar un `.jpg` a `.png` no le añade transparencia. - **Enviar por una app de mensajería o subir a una web.** Algunas plataformas pueden recodificar la imagen al subirla, y si la pasan a JPEG la transparencia desaparece. El comportamiento varía según la plataforma y según se envíe «como foto» o «como archivo»; cuando el resultado importa, envía la imagen como documento adjunto y analiza la copia que recibe la otra persona. En todos estos casos la solución es volver al archivo original, no regenerar la imagen. ## Preguntas frecuentes sobre el fondo transparente en ChatGPT y GPT Image ### ¿ChatGPT puede generar imágenes PNG con fondo transparente? Sí, la ayuda de OpenAI indica que ChatGPT Images puede hacer transparente el fondo siguiendo instrucciones, pero no hay un ajuste que lo fuerce ni está documentado el formato de descarga. La única confirmación válida es probar el archivo guardado sobre un fondo de color o con el script de comprobación. ### ¿Cuál es el fondo transparente, JPG o PNG? PNG. También WebP guarda transparencia. JPG no puede guardarla en ningún caso. Aun así, que un archivo sea PNG no demuestra que tenga fondo transparente: puede ser un PNG completamente opaco, con la cuadrícula pintada incluida. ### ¿Por qué la API devuelve fondo blanco si pedí «transparente»? Porque el texto no fija el parámetro. Sin `background`, el valor es `auto` y el modelo decide el fondo. Envía `background: "transparent"` junto con `output_format: "png"` o `"webp"`, y revisa los campos `background` y `output_format` de la respuesta. ### ¿La cuadrícula pintada depende del tamaño de la imagen, por ejemplo 2K o 4K? La referencia de la API de OpenAI no vincula el fondo transparente a ningún tamaño ni calidad. Circula la afirmación de que los tamaños grandes producen cuadros pintados y los pequeños no, pero no tiene respaldo en la documentación oficial. Si lo sospechas en tu caso, genera la misma petición en dos tamaños y pasa ambos archivos por el script. ### ¿Cómo evito bordes blancos y sombras alrededor del sujeto? Pídelo en la instrucción: sujeto aislado, sin sombra en el suelo y sin fondo liso. Después revisa el archivo sobre un fondo oscuro, que es donde aparece el halo claro. Si el halo procede de una reparación de cuadrícula pintada, no tiene arreglo con ese método, porque deja el borde duro; regenera con el parámetro `background` o usa un quitafondos. ### ¿Se trata igual `gpt-image-2` que GPT Image 2.5? El parámetro es el mismo, pero el estado no. A 2 de octubre de 2026, los dos modelos GPT Image 2.5 admiten fondo transparente y en `gpt-image-2` la función figura como vista previa. En ambos casos el formato de salida debe ser PNG o WebP.