# GPT Image 2: cómo resolver invalid size y obtener una imagen de 1024×576

> 1024×576 tiene la proporción correcta, pero no alcanza el mínimo de píxeles de GPT Image 2. Genera en 1280×720 y reduce a las dimensiones exactas.

- Source: https://www.aifreeapi.com/es/posts/gpt-image-2-invalid-size
- Language: es
- Published: 2026-09-08
- Updated: 2026-09-08
- Publisher: AI Free API (https://www.aifreeapi.com)

Una imagen de **1024×576 es 16:9**, pero ese tamaño no cumple los requisitos de generación de `gpt-image-2` en la API directa de OpenAI. Sus **589 824 píxeles** quedan por debajo del mínimo de **655 360**. Es posible que ambos lados sean múltiplos de 16 y que, aun así, la solicitud devuelva `invalid size`.

Si necesitas entregar un archivo de exactamente 1024×576, la solución es **generar en 1280×720 y reducir después al 80 %**. Se mantiene la relación de aspecto, no se recorta la escena y el archivo final tendrá las dimensiones solicitadas. El límite de generación no impide redimensionar la imagen una vez descargada.

Las reglas siguientes corresponden a la documentación de OpenAI consultada el 8 de septiembre de 2026. Los tamaños se han comprobado mediante cálculo; no representan una prueba de llamadas a la API.

## Por qué falla un tamaño que sí es 16:9

La [documentación de tamaños de GPT Image 2](https://developers.openai.com/api/docs/guides/image-generation#customize-image-output) establece varias condiciones simultáneas para el valor de `size`:

- El ancho y el alto deben ser positivos y múltiplos de 16.
- Ningún lado puede superar los 3840 píxeles.
- El lado largo no puede medir más de tres veces el corto.
- El área total debe estar entre 655 360 y 8 294 400 píxeles, ambos incluidos.

En 1024×576, el ancho equivale a 64 bloques de 16 y el alto a 36. La relación entre ambos lados es aproximadamente 1,78, por debajo del máximo de 3. Lo que falla es la multiplicación:

```text
1024 × 576 = 589 824 píxeles
655 360 − 589 824 = 65 536 píxeles por debajo del mínimo
```

Añadir «16:9» al texto de la petición no corrige esa cifra. La descripción de la imagen y el parámetro que fija su tamaño cumplen funciones distintas: aunque el encuadre pedido sea horizontal, el servidor sigue recibiendo un valor numérico inválido.

![Comparación visual de dos lienzos horizontales con la misma proporción y diferente área total](https://www.aifreeapi.com/posts/es/gpt-image-2-invalid-size/img/proporcion-y-area.webp)

Tampoco basta con elegir cualquier resolución habitual de vídeo. **1920×1080 no cumple estas reglas**, porque 1080 no es múltiplo de 16. La etiqueta «Full HD» no garantiza que un generador acepte las dimensiones.

## Qué tamaño enviar en su lugar

Para obtener un resultado horizontal que puedas reducir a 1024×576 sin deformarlo, utiliza otro tamaño 16:9 que cumpla todas las condiciones.

| Dimensiones solicitadas | Píxeles totales | Relación | Resultado según las reglas documentadas |
| --- | ---: | --- | --- |
| 1024×576 | 589 824 | 16:9 | No válido: área insuficiente |
| 1024×640 | 655 360 | 8:5 | Válido, pero cambia la proporción |
| 1280×720 | 921 600 | 16:9 | Válido; menor tamaño 16:9 exacto permitido |
| 1536×864 | 1 327 104 | 16:9 | Válido |
| 1920×1080 | 2 073 600 | 16:9 | No válido: el alto no es múltiplo de 16 |
| 2048×1152 | 2 359 296 | 16:9 | Válido |

¿Por qué el mínimo exacto es 1280×720 y no un tamaño intermedio? Si ambos lados son múltiplos de 16 y su proporción es exactamente 16:9, las dimensiones posibles tienen la forma **256k × 144k**, con un número entero positivo para k. El valor 4 da 1024×576 y se queda corto; el siguiente, 5, da 1280×720 y ya cumple el mínimo. No hay otro tamaño 16:9 exacto entre ambos que satisfaga la divisibilidad exigida.

Para una entrega de 1024×576, 1280×720 es un punto de partida suficiente en cuanto a dimensiones. Elegir 1536×864 o 2048×1152 permite conservar un original mayor, pero estas cuentas por sí solas no demuestran cuál será más barato, más rápido o visualmente mejor.

## Corregir la petición y guardar el archivo exacto

En la API directa, `size` es una cadena con ancho y alto separados por una **x minúscula**, como `"1280x720"`. El signo tipográfico × que usamos para leer las dimensiones no debe copiarse dentro del parámetro.

Esta petición ilustra el cambio para el endpoint de generación de OpenAI. Requiere una clave válida y su ejecución realiza una llamada facturable:

```bash
curl --fail-with-body https://api.openai.com/v1/images/generations \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-image-2",
    "prompt": "Una bicicleta junto a una cafetería al amanecer, encuadre horizontal",
    "size": "1280x720",
    "output_format": "png"
  }' \
  -o respuesta.json
```

La [guía de generación de imágenes](https://developers.openai.com/api/docs/guides/image-generation) describe la devolución de la imagen como datos codificados en base64. Después de una respuesta correcta, puedes extraerla y redimensionarla con Python y Pillow. El siguiente paso procesa archivos locales y no envía otra petición al modelo:

```bash
python -m pip install Pillow
```

```python
import base64
import io
import json
from pathlib import Path
from PIL import Image

respuesta = json.loads(Path("respuesta.json").read_text())
if "error" in respuesta:
    raise RuntimeError(respuesta["error"])

contenido = base64.b64decode(respuesta["data"][0]["b64_json"])
Path("original.png").write_bytes(contenido)

with Image.open(io.BytesIO(contenido)) as imagen:
    ancho, alto = imagen.size
    if ancho * 9 != alto * 16:
        raise ValueError(
            f"El original mide {ancho}x{alto}; no es 16:9 exacto. "
            "Revisa la respuesta antes de decidir un recorte."
        )
    final = imagen.resize((1024, 576), Image.Resampling.LANCZOS)
    final.save("imagen-1024x576.png")

with Image.open("imagen-1024x576.png") as comprobacion:
    assert comprobacion.size == (1024, 576)
    print("Archivo final:", comprobacion.size)
```

La comprobación de la proporción evita estirar inadvertidamente una respuesta con otras dimensiones. El remuestreo reduce el número de píxeles, pero conserva el encuadre cuando el original es 16:9. Guarda el original si vas a necesitar nuevas versiones; reducirlo y volverlo a ampliar no recupera el detalle descartado.

Para preparar la autenticación o revisar el flujo completo de generación, consulta la [guía de la API de GPT Image 2](/es/topics/gpt-image).

## Si 1280×720 también devuelve un error

Que un tamaño cumpla la documentación de OpenAI no garantiza que una aplicación o un proveedor intermedio lo admita. Antes de volver a generar, compara estos datos de la solicitud que realmente sale del cliente:

| Dato | Qué revisar |
| --- | --- |
| URL de destino | Si llamas a `api.openai.com` o a un servicio con su propia API |
| Modelo enviado | Que sea `gpt-image-2`, sin asumir que otro modelo tiene los mismos límites |
| Cuerpo JSON | Que `size` llegue como `"1280x720"`, sin espacios, signo × ni una sustitución automática |
| Respuesta de error | Qué parámetro identifica y si enumera tamaños admitidos |

Si tu SDK rechaza el valor antes de enviar la petición, revisa sus tipos o su lista de tamaños permitidos. Puede estar validando un conjunto de opciones que no coincide con la documentación del modelo. Si el rechazo llega del servidor, conserva el estado HTTP y el cuerpo del error para contrastarlos con las reglas del endpoint utilizado. Oculta la clave de API y otros datos privados al compartir el diagnóstico.

Un ejemplo de contrato distinto es [Venice](https://docs.venice.ai/es/api-reference/endpoint/image/generate): su endpoint `/image/generate` documenta para GPT Image 2 campos como `aspect_ratio` y `resolution`. Allí una relación `"16:9"` y un nivel de resolución tienen un significado propio. **No traslades esos campos a la API directa de OpenAI**, ni presupongas que otro proveedor acepta sus mismos parámetros.

Si el cliente solo ofrece tamaños predefinidos, consulta si permite dimensiones personalizadas o utiliza una integración que exponga el parámetro documentado. Cambiar únicamente el texto descriptivo no modifica una validación local ni el JSON que se envía.

## ¿Y si ya tengo una imagen de 1024×640?

![Una escena de cafetería y bicicleta ilustra la diferencia entre reducir proporcionalmente y recortar los bordes](https://www.aifreeapi.com/posts/es/gpt-image-2-invalid-size/img/reducir-o-recortar.webp)

Ese tamaño alcanza justo el mínimo de píxeles, pero tiene proporción 8:5. Hay dos formas diferentes de convertirlo a 1024×576:

- **Recortar 64 píxeles de altura.** Un recorte centrado elimina 32 por arriba y 32 por abajo. Conserva las proporciones de los objetos, aunque puedes perder contenido en los bordes.
- **Cambiar directamente sus dimensiones.** Reduce la altura sin cambiar el ancho y deforma los objetos. No es la opción adecuada si quieres mantener la escena intacta.

Si todavía no has generado la imagen, pedir 1280×720 evita esa decisión: después solo tienes que reducirla proporcionalmente. Si ya tienes un original 8:5 que quieres conservar completo, también puedes colocarlo dentro de un lienzo 16:9 con márgenes laterales; el resultado tendrá el tamaño correcto, pero ya no llenará todo el encuadre con la imagen original.