# GPT Image 2.6 GIF API: cómo crear GIF animados, límites y coste

> Pon output_format gif en /v1/images/generations y guarda el b64_json como .gif. Con OpenAI directo, no pases de 16 fotogramas: sus dos documentos no coinciden.

- URL: https://blog.laozhang.ai/es/posts/gpt-image-2-6-gif-api
- Published: 2026-11-05
- Updated: 2026-11-05
- Author: LaoZhang AI Team (https://blog.laozhang.ai/es/about)
- Topic: Generación de imágenes con IA
- Tags: GPT Image 2.6, GIF animado, API de OpenAI, Crear GIF con IA, Generación de imágenes

---
Para crear un GIF animado con la API de GPT Image 2.6, añade `output_format: "gif"` a una petición `POST /v1/images/generations` con el modelo `gpt-image-2.6-flare` o `gpt-image-2.6-sunburst`, fija `frame_count` (número de fotogramas), `frame_duration_ms` (duración de cada fotograma) y `size` (tamaño de cada fotograma), y guarda el `b64_json` de la respuesta, decodificado, como archivo `.gif`. OpenAI lanzó la función el 4 de noviembre de 2026 y solo existe en generación: el endpoint de ediciones no devuelve GIF.

Antes de escribir código conviene saber dos cosas. Los dos documentos de OpenAI no coinciden en el máximo: la guía de generación de imágenes admite 2–64 fotogramas y la referencia de la API, 2–16, así que si tu código llama a OpenAI directamente, no pases de 16. Y el coste depende de por dónde envíes la petición: OpenAI cobra por tokens (un GIF de 512×512 con 9 fotogramas en calidad `medium` gastó 2.073 tokens de salida, unos 0,062 \$), mientras que la ruta `gpt-image-2.6-web` de LaoZhang API cobra 0,03 \$ por llamada pero exige fotogramas de al menos 816×816 si son cuadrados.

*Aviso: [laozhang.ai es un servicio propio](https://blog.laozhang.ai/es/about#laozhang). Sus precios son nuestra tarifa, no una comparación independiente.*

A 5 de noviembre de 2026 se pidieron cuatro GIF de 1024×1024 por esa ruta web y los cuatro llegaron con exactamente los fotogramas y la duración solicitados y marcados para repetirse sin fin. Lo que no quedó garantizado es que el último fotograma enlace con el primero: el de 9 fotogramas, pedido con la instrucción de volver a la postura inicial, da un salto visible al reiniciar. Más abajo tienes un script corto para medir ese salto antes de publicar el GIF.

## Crear un GIF con la API de GPT Image 2.6 en curl y Python

El flujo completo son cuatro pasos y una sola llamada: describes el sujeto, el movimiento y el bucle en el prompt, añades los tres campos del GIF, decodificas la respuesta y compruebas el archivo. Los ejemplos usan `gpt-image-2.6-flare` a 512×512, el tamaño del GIF de muestra que publica OpenAI; `gpt-image-2.6-sunburst` acepta la misma petición y, según el [anuncio de Images 2.6 de OpenAI](https://openai.com/index/introducing-images-2-6), da más detalle a cambio de velocidad.

1. Escribe el prompt con el movimiento completo y cómo debe cerrarse: qué hace el sujeto, que vuelva a la postura de partida y si la cámara se mueve o no.
2. Envía la petición a `/v1/images/generations` con `output_format: "gif"`, `frame_count`, `frame_duration_ms` y un `size` explícito.
3. Decodifica `data[0].b64_json` desde base64 y escribe los bytes en un archivo con extensión `.gif`.
4. Comprueba fotogramas, duración y cierre del bucle con el script de la sección sobre el salto al reiniciar.

Con curl y `jq`, la petición y el guardado caben en una orden:

```bash
curl -s https://api.openai.com/v1/images/generations \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-image-2.6-flare",
    "prompt": "Un monito con abrigo verde oliva sostiene un farol de papel ámbar en un bosque nevado al anochecer. Levanta el farol despacio, mira hacia arriba, parpadea y lo baja hasta volver a su postura inicial. Cámara fija. Haz que el movimiento se repita en bucle sin saltos.",
    "size": "512x512",
    "quality": "medium",
    "output_format": "gif",
    "frame_count": 9,
    "frame_duration_ms": 200
  }' \
  | jq -r '.data[0].b64_json' | base64 --decode > monito.gif
```

En Python, los campos del GIF van en `extra_body` para que la petición funcione aunque tu versión del SDK todavía no los reconozca (lo explica la sección de errores). El tiempo de espera de 300 segundos sobra para OpenAI directo, pero es el que pide la ruta web:

```python
import base64
from openai import OpenAI

client = OpenAI(timeout=300)  # lee OPENAI_API_KEY del entorno

result = client.images.generate(
    model="gpt-image-2.6-flare",
    prompt=(
        "Un monito con abrigo verde oliva sostiene un farol de papel ámbar en un bosque "
        "nevado al anochecer. Levanta el farol despacio, mira hacia arriba, parpadea y lo "
        "baja hasta volver a su postura inicial. Cámara fija. Haz que el movimiento se "
        "repita en bucle sin saltos."
    ),
    size="512x512",
    quality="medium",
    output_format="gif",
    extra_body={"frame_count": 9, "frame_duration_ms": 200},
)

with open("monito.gif", "wb") as f:
    f.write(base64.b64decode(result.data[0].b64_json))
```

La animación dura `frame_count` × `frame_duration_ms`: con 9 fotogramas de 200 ms, 1,8 segundos por vuelta. La referencia de la API añade una condición que puede bloquearte antes de cualquier límite: la salida GIF «requiere acceso a la GIF preview del modelo elegido», y OpenAI no publica qué cuentas lo tienen. Si tu organización recibe un rechazo con una petición correcta, ese acceso es lo primero que hay que revisar.

## Límites de frame_count, frame_duration_ms y size en cada documento

El número de fotogramas que puedes pedir depende del documento que leas y de la ruta que uses. A 5 de noviembre de 2026, la [guía de generación de imágenes de OpenAI, apartado de GIF animados](https://developers.openai.com/api/docs/guides/image-generation#generate-animated-gif-output), y la [referencia de images.generate en la API de OpenAI](https://developers.openai.com/api/reference/resources/images/methods/generate) dan rangos distintos, y la ruta web de LaoZhang API tiene los suyos:

*Aviso: [laozhang.ai es un servicio propio](https://blog.laozhang.ai/es/about#laozhang). Sus precios son nuestra tarifa, no una comparación independiente.*

| Campo u opción | Guía de OpenAI | Referencia de la API de OpenAI | Ruta `gpt-image-2.6-web` |
| --- | --- | --- | --- |
| `frame_count` | 2–64, por defecto 9 | 2–16, por defecto 9 | 2–64, por defecto 9; con 65 devuelve 400 |
| `frame_duration_ms` | 20–2000 ms, redondeado a 10 ms, por defecto 200 | mínimo 20, por defecto 200, redondeado a 10 ms; sin tope de 2000 | 20–2000, por defecto 200 |
| `size` | `auto` o `ANCHOxALTO` en múltiplos de 16; es el tamaño de cada fotograma | debe cumplir los límites de tamaño GIF del modelo | mínimo 655.360 píxeles (816×816 en cuadrado); pásalo siempre |
| `n` (número de animaciones) | cuenta para el presupuesto total de píxeles | no lo detalla | solo 1 |
| Streaming, imágenes parciales, `output_compression` | no admitidos, tampoco `prompt_rewriter` | no admitidos, tampoco máscaras | `stream: true` no transmite nada |
| Ediciones (`/v1/images/edits`) | no generan GIF | no lo detalla | no generan GIF |

¿64 fotogramas o 16? Con OpenAI directo no hay una respuesta comprobada. La guía y la referencia se publicaron con el lanzamiento y se contradicen, y las pruebas con clave directa de OpenAI que documentó el equipo de LaoZhang API llegaron como mucho a 9 fotogramas, así que ningún ensayo publicado confirma cuál de los dos topes aplica OpenAI. Si tu código tiene que funcionar contra OpenAI, limita `frame_count` a 16, que cumplen los dos documentos. En la ruta web el rango documentado es 2–64, una petición de 65 fotogramas devolvió 400 el 5 de noviembre de 2026 y el máximo que se generó ese día fue 16.

El tamaño tiene además un techo y un suelo que no aparecen como cifras. Según la guía, el número de fotogramas, su tamaño y `n` deben caber juntos en el presupuesto de píxeles de la petición, y si lo superas tienes que reducir uno de los tres; `size: "auto"` deja que la API elija un tamaño que quepa. Por abajo también hay un mínimo: con clave directa de OpenAI, un GIF de 256×256 con solo 2 fotogramas falló con un error que empieza por `No supported sheet fits`, porque los fotogramas se componen en una sola hoja que tiene un número mínimo de píxeles.

## Cuántos fotogramas y qué tamaño: lo que pesan y tardan los GIF reales

Más fotogramas dan un movimiento más fluido, pero el archivo crece casi en proporción y, a partir de cierto número, cada fotograma pierde nitidez. Los cuatro GIF de esta tabla se generaron el 5 de noviembre de 2026 por la ruta `gpt-image-2.6-web` de LaoZhang API, una vez cada uno, con 1024×1024 por fotograma; la última fila es el GIF de muestra que OpenAI publica en su guía, inspeccionado ese mismo día:

*Aviso: [laozhang.ai es un servicio propio](https://blog.laozhang.ai/es/about#laozhang). Sus precios son nuestra tarifa, no una comparación independiente.*

| GIF | Fotogramas × duración | Tamaño de fotograma | Peso | Tiempo de respuesta |
| --- | --- | --- | --- | --- |
| Ruta web, prompt de bucle de OpenAI | 4 × 300 ms (1,2 s) | 1024×1024 | 2,02 MB | 43,5 s |
| Ruta web, prompt de bucle de OpenAI | 9 × 200 ms (1,8 s) | 1024×1024 | 4,53 MB | 49,3 s |
| Ruta web, prompt vago | 9 × 200 ms (1,8 s) | 1024×1024 | 4,85 MB | 52,1 s |
| Ruta web, prompt de bucle de OpenAI | 16 × 120 ms (1,92 s) | 1024×1024 | 8,20 MB | 49,3 s |
| Muestra de OpenAI, Sunburst en `high` | 9 × 200 ms (1,8 s) | 512×512 | 1,28 MB | sin dato |

En los cuatro casos el GIF trajo exactamente los fotogramas y la duración pedidos, y la bandera de repetición del archivo estaba en 0, es decir, se reproduce en bucle infinito sin que tengas que tocarla. Los tiempos dependen de la carga del momento: la [documentación de GPT Image en LaoZhang API (en inglés)](https://docs.laozhang.ai/en/api-capabilities/gpt-image-2-5) da 35–42 segundos para 4–9 fotogramas a 1024, unos 100 segundos para 16 fotogramas (aquí fueron 49), unos 2 minutos y 18 MB para 64 fotogramas, con imágenes menos nítidas, y unos 54 segundos y 11 MB para 9 fotogramas a 2048. Con clave directa de OpenAI, `gpt-image-2.6-flare` tardó 11–12 segundos en un GIF de 512×512 con 9 fotogramas en `medium`.

Para stickers, GIF de reacción y bucles de producto, 9 fotogramas de 200 ms a 512×512 es el punto de partida que usa la propia OpenAI y deja un archivo de algo más de 1 MB. Sube a 12–16 fotogramas solo si el movimiento se ve entrecortado, y baja a 4–6 para indicadores de carga o gestos simples, como el GIF de 4 fotogramas de 300 ms de la tabla, que pesa menos de la mitad que el de 9. El tamaño de fotograma también cuenta: 1024×1024 son cuatro veces los píxeles de 512×512, así que si el GIF se va a ver pequeño en un chat o una web, 512×512 basta; en la ruta web, eso sí, no puedes bajar de 816×816.

## Qué ruta usar: OpenAI, reenvío oficial, gpt-image-2.6-web o VIP

La ruta se decide por el tamaño de fotograma que necesitas y por cómo prefieres pagar. Si quieres GIF pequeños, como 512×512, necesitas OpenAI directo o el reenvío oficial de LaoZhang API; si tus GIF son de 816×816 o más y prefieres un precio fijo, la ruta `gpt-image-2.6-web` sirve; las variantes VIP no generan GIF. Estas son las condiciones a 5 de noviembre de 2026:

*Aviso: [laozhang.ai es un servicio propio](https://blog.laozhang.ai/es/about#laozhang). Sus precios son nuestra tarifa, no una comparación independiente.*

![Árbol de decisión para pedir un GIF con GPT Image 2.6: las variantes VIP no generan GIF; para 512×512 sirven la API de OpenAI o el reenvío oficial de LaoZhang API, y para 816×816 o más con precio fijo, gpt-image-2.6-web](https://blog.laozhang.ai/posts/es/gpt-image-2-6-gif-api/img/elegir-ruta-gif.webp)

| Ruta | Modelo que pides | GIF | Tamaño mínimo | Fotogramas | Cobro |
| --- | --- | --- | --- | --- | --- |
| API de OpenAI | `gpt-image-2.6-flare` o `-sunburst` | Sí, con acceso a la GIF preview | sin cifra publicada; 256×256 con 2 fotogramas falló | 2–16 según la referencia, 2–64 según la guía | por tokens de salida de imagen |
| LaoZhang API, reenvío oficial (grupo `OpenAI Official`) | `gpt-image-2.6-flare` o `-sunburst` | Sí, mismo cuerpo de petición que OpenAI | 512×512 funciona | los de OpenAI | por tokens a precio de OpenAI; +20 % en el grupo `OpenAI Official Enterprise` |
| LaoZhang API, ruta web (grupo `default`) | `gpt-image-2.6-web` | Sí, sin elegir entre Flare y Sunburst | 655.360 píxeles por fotograma (816×816) | 2–64 documentados, probado hasta 16 | precio fijo por llamada |
| LaoZhang API, VIP | `gpt-image-2.6-flare-vip` o `-sunburst-vip` | No, devuelve 400 | no aplica | no aplica | no aplica para GIF |

Para pasar el código de la sección anterior a LaoZhang API cambias dos cosas: la URL base a `https://api.laozhang.ai/v1` y la clave por una del grupo correspondiente. En el reenvío oficial el modelo y el cuerpo quedan igual; en la ruta web cambias `model` a `gpt-image-2.6-web`, pasas siempre `size` (sin él, el GIF llegó pequeño y con un tamaño irregular, por ejemplo 439×390), dejas `n` en 1 y no pides streaming, porque `stream: true` no transmite fotogramas parciales.

## Cuánto cuesta un GIF de GPT Image 2.6: por tokens o 0,03 \$ por llamada

En OpenAI un GIF se paga como cualquier imagen, por los tokens de salida, a 30 \$ por millón según la [tabla de precios de la API de OpenAI](https://developers.openai.com/api/docs/pricing) (el texto del prompt suma 5 \$ por millón, menos de una milésima de dólar en un prompt normal). El GIF de 512×512 con 9 fotogramas en `medium` hecho con `gpt-image-2.6-flare` gastó 2.073 tokens de salida, así que costó 2.073 × 30 \$ / 1.000.000 = 0,0622 \$; uno de 4 fotogramas en `low` gastó 1.172 tokens, unos 0,035 \$. Son pruebas únicas del equipo de documentación de LaoZhang API con clave directa de OpenAI, a 5 de noviembre de 2026; otro tamaño, otra calidad u otro número de fotogramas cambian los tokens, así que para tu caso lee `usage.output_tokens` en la respuesta y aplica la misma fórmula.

*Aviso: [laozhang.ai es un servicio propio](https://blog.laozhang.ai/es/about#laozhang). Sus precios son nuestra tarifa, no una comparación independiente.*

Como referencia, una imagen fija de 1024×1024 en `medium` gastó 1.449 tokens (0,043 \$) en esas mismas pruebas. El reenvío oficial de LaoZhang API cobra los tokens al precio de OpenAI, de modo que el mismo GIF de 512×512 cuesta lo mismo si gasta los mismos tokens, y en el grupo Enterprise un 20 % más: 0,0622 \$ × 1,2 ≈ 0,075 \$. En la ruta `gpt-image-2.6-web`, en cambio, el precio publicado es de 0,03 \$ por llamada, tenga el GIF 4 fotogramas o 64 y mida 816 o 2048 píxeles de lado; la respuesta trae un bloque `usage`, pero el cobro es el fijo por llamada, y los 429 de las horas de más carga no se cobran.

## Errores al pedir un GIF por API: 400, hoja de fotogramas, 429 y timeout

Casi todos los fallos de GIF se resuelven cambiando un valor de la petición, porque vienen de pasar un límite de la ruta. Las filas marcadas como ruta web se reprodujeron el 5 de noviembre de 2026 con `gpt-image-2.6-web` y `gpt-image-2.6-flare-vip` (respuesta en 1–2 segundos, sin cobro); el error de la hoja viene de las pruebas con clave directa de OpenAI, y los demás, de la documentación de LaoZhang API.

*Aviso: [laozhang.ai es un servicio propio](https://blog.laozhang.ai/es/about#laozhang). Sus precios son nuestra tarifa, no una comparación independiente.*

| Lo que ves | Causa | Qué hacer |
| --- | --- | --- |
| 400 con `code: "invalid_image_request"` y `param` vacío (ruta web, `frame_count: 65`) | fotogramas fuera de 2–64; el mensaje solo dice que el servicio de origen no aceptó la petición | baja a 64 como máximo, o a 16 si el mismo código debe funcionar con OpenAI directo |
| 400 con `param: "size"` y `code: "invalid_value"` (ruta web, `size: "512x512"`) | fotograma por debajo de 655.360 píxeles | usa 816×816 o más, o el reenvío oficial si necesitas 512×512 |
| Error que empieza por `No supported sheet fits` (OpenAI directo, 256×256 con 2 fotogramas) | la hoja donde se componen los fotogramas no llega a su mínimo de píxeles | sube el tamaño de fotograma o el número de fotogramas |
| 400 «GIF and SVG output are not supported on this route» (`gpt-image-2.6-flare-vip`) | las variantes VIP no generan GIF ni SVG | cambia a `gpt-image-2.6-flare` o `-sunburst` en el grupo `OpenAI Official`, o a `gpt-image-2.6-web` |
| 400 con `param: "n"` (ruta web) | `n` mayor que 1 | una animación por llamada; lanza varias llamadas en paralelo si necesitas variantes |
| 429 tras unos 2 minutos (ruta web, GIF grandes o con muchos fotogramas en horas punta) | carga del servicio | no se cobra; reintenta más tarde o reduce fotogramas y tamaño |
| Tu cliente corta la conexión antes de recibir el GIF | tiempo de espera más corto que la generación, que en la ruta web llega a unos 2 minutos | sube el timeout del cliente a 300 segundos o más |

Si el SDK de Python rechaza `frame_count` o `frame_duration_ms` como argumentos desconocidos, el problema está en tu versión del paquete `openai`, no en la API: a 5 de noviembre de 2026 los dos campos figuran en la referencia de la API. La salida que funciona con cualquier versión es la del ejemplo anterior, pasarlos dentro de `extra_body`, que el SDK añade sin validar al cuerpo de la petición. Según una respuesta en el [foro de la comunidad de OpenAI sobre la salida SVG](https://community.openai.com/t/1412920) del 5 de noviembre de 2026, el parámetro `svg`, que llegó con el mismo lanzamiento, está en el SDK desde la 3.46.0, así que actualizar también es una opción, aunque esa respuesta no dice en qué versión entraron los campos del GIF.

## El GIF da un salto al reiniciar: cómo comprobar el bucle

En un GIF hay dos «bucles» distintos. Uno es la bandera del archivo que indica cuántas veces se repite, y GPT Image 2.6 la deja en 0, repetición infinita, tanto en la muestra de OpenAI como en los cuatro GIF de la ruta web. El otro es que el último fotograma enlace con el primero sin un salto visible, y eso no lo garantiza ningún parámetro: depende de lo que dibuje el modelo, así que tienes que medirlo en cada GIF antes de publicarlo.

OpenAI recomienda en su [guía de prompts de imagen, apartado de GIF en bucle](https://developers.openai.com/api/docs/guides/image-prompting#generate-a-looping-gif), dar al sujeto una postura de partida a la que volver y decir si la cámara se mueve. Este script mide si lo consiguió: compara la diferencia media de píxeles entre el último y el primer fotograma con la diferencia media entre fotogramas consecutivos. Necesita Pillow (`pip install pillow`):

```python
# salto_bucle.py — uso: python3 salto_bucle.py animacion.gif
import sys
from PIL import Image, ImageChops, ImageStat


def diferencia(a, b):
    d = ImageChops.difference(a, b)
    return sum(ImageStat.Stat(d).mean) / 3 / 255 * 100  # % de la escala completa


im = Image.open(sys.argv[1])
bucle = im.info.get("loop")
fotogramas, duraciones = [], []
try:
    while True:
        fotogramas.append(im.convert("RGB"))
        duraciones.append(im.info.get("duration"))
        im.seek(im.tell() + 1)
except EOFError:
    pass

pasos = [diferencia(fotogramas[i], fotogramas[i + 1]) for i in range(len(fotogramas) - 1)]
paso_medio = sum(pasos) / len(pasos)
salto = diferencia(fotogramas[-1], fotogramas[0])

print(f"fotogramas: {len(fotogramas)}  duración por fotograma (ms): {sorted(set(duraciones))}")
print(f"bandera de bucle: {bucle}  (0 = se repite sin fin)")
print(f"salto del bucle / paso medio: {salto / paso_medio:.2f}")
```

La última cifra se lee así: hasta 1, el paso del último fotograma al primero no es mayor que un paso normal de la animación y el reinicio pasa desapercibido; por encima de 1, el reinicio se nota más que el movimiento. Con este script, el GIF de 9 fotogramas pedido el 5 de noviembre de 2026 con el prompt de bucle de OpenAI dio 1,38, y a simple vista el farol y la postura saltan al volver al principio; con los mismos ajustes, el prompt vago «A cute monkey with a lantern in the snow, animated.» dio 1,08; el de 4 fotogramas, 0,72, y el de 16, 0,93. La muestra publicada por OpenAI da 0,72, y la de la documentación de LaoZhang API, 0,68.

*Aviso: [laozhang.ai es un servicio propio](https://blog.laozhang.ai/es/about#laozhang). Sus precios son nuestra tarifa, no una comparación independiente.*

![Gráfico de barras del salto al reiniciar dividido entre el paso medio en seis GIF: 1,38 y 1,08 superan el umbral de 1; 0,93, 0,72, 0,72 y 0,68 quedan por debajo](https://blog.laozhang.ai/posts/es/gpt-image-2-6-gif-api/img/salto-bucle-gif.webp)

Con una sola muestra por prompt, esas cifras no demuestran que un prompt vago cierre mejor el bucle; solo muestran que pedir la vuelta a la postura inicial no lo asegura. Si un GIF supera 1, vuelve a generarlo con el mismo prompt antes de reescribirlo, porque el resultado cambia de una llamada a otra, y cada intento cuesta lo mismo que el primero en tu ruta. Las pautas generales para escribir prompts de movimiento y de bucle están en la [guía de prompts de GPT Image 2.6](https://blog.laozhang.ai/es/posts/gpt-image-2-6-prompt-guide).

## Preguntas sobre GIF con GPT Image 2.6: imágenes propias, ChatGPT y SVG

### ¿Puedo convertir en GIF una imagen que ya tengo con la API de GPT Image 2.6?

No de forma documentada. A 5 de noviembre de 2026, la guía de OpenAI dice que el endpoint de ediciones (`/v1/images/edits`) no admite salida GIF, así que el GIF solo sale de una generación a partir de texto, y la ruta `gpt-image-2.6-web` de LaoZhang API tampoco devuelve GIF desde ediciones. Ese mismo día, una edición por el reenvío oficial de LaoZhang API devolvió un GIF una vez, pero OpenAI no lo documenta y puede dejar de funcionar sin aviso, así que no conviene construir un flujo sobre ello. Lo que sí funciona es describir en el prompt la imagen que quieres animar.

*Aviso: [laozhang.ai es un servicio propio](https://blog.laozhang.ai/es/about#laozhang). Sus precios son nuestra tarifa, no una comparación independiente.*

### ¿Cómo hago un GIF en ChatGPT sin programar?

En la app de ChatGPT se pide con un mensaje y se ajusta la velocidad en un menú, que no son parámetros de la API; los pasos están en [Cómo hacer un GIF en ChatGPT con Images 2.6: pasos y fotogramas](https://blog.laozhang.ai/es/posts/how-to-make-a-gif-in-chatgpt).

### ¿Merece la pena pasar de GPT Image 2.5 a 2.6 para tener GIF?

Para los GIF no hay elección, porque solo 2.6 los genera; para el resto de imágenes, el coste por nivel de calidad cambia mucho entre versiones y lo compara [GPT Image 2.6 vs 2.5: diferencias y cuándo cuesta 4 veces más](https://blog.laozhang.ai/es/posts/gpt-image-2-6-vs-2-5).

### ¿La misma API de GPT Image 2.6 genera SVG o ediciones guiadas con marcas?

Sí, los dos modelos de 2.6 también devuelven SVG y aceptan ediciones guiadas con marcas dibujadas sobre la imagen, con peticiones distintas a la del GIF: la [salida SVG de GPT Image 2.6 por API](https://blog.laozhang.ai/es/posts/gpt-image-2-6-svg-output) y las [ediciones con marcas (markup) de GPT Image 2.6 por API](https://blog.laozhang.ai/es/posts/gpt-image-2-6-image-markup-api) tienen sus propias guías.

## Fuentes

Páginas externas que cita esta guía, en el orden en que aparecen. Última actualización: 2026-11-05.

- [anuncio de Images 2.6 de OpenAI](https://openai.com/index/introducing-images-2-6) (openai.com)
- [guía de generación de imágenes de OpenAI, apartado de GIF animados](https://developers.openai.com/api/docs/guides/image-generation) (developers.openai.com)
- [referencia de images.generate en la API de OpenAI](https://developers.openai.com/api/reference/resources/images/methods/generate) (developers.openai.com)
- [tabla de precios de la API de OpenAI](https://developers.openai.com/api/docs/pricing) (developers.openai.com)
- [foro de la comunidad de OpenAI sobre la salida SVG](https://community.openai.com/t/1412920) (community.openai.com)
- [guía de prompts de imagen, apartado de GIF en bucle](https://developers.openai.com/api/docs/guides/image-prompting) (developers.openai.com)