Precios de la API de imágenes de OpenAI: modelos GPT Image, calidad y Python

Los precios de la API de imágenes de OpenAI parecen sencillos hasta que llega la primera factura. No hay un precio fijo por imagen. Pagas en tokens, y la cantidad de tokens que usa una imagen depende del modelo, el tamaño y el ajuste quality que pasas en tu llamada de Python. Una imagen de 1024x1024 puede costar $0,006 o $0,211 con exactamente el mismo prompt, una diferencia de unas 35 veces. Este artículo recoge las tarifas actuales, las cifras por imagen para cada nivel de calidad, una configuración de Python que funciona y los hábitos que evitan que un lote de 1.000 imágenes se convierta en una sorpresa.

💡 Lee esto primero: las cifras en dólares de abajo provienen de las tarifas de tokens publicadas por OpenAI ($30 por millón de tokens de salida de imagen en los modelos actuales) y de calculadoras de terceros que aplican esas tarifas. La página de precios de OpenAI enumera tokens y remite a una calculadora, no a una tabla por imagen, así que vuelve a comprobarla antes de fijar un presupuesto.

Qué cobra la API de imágenes

Tokens, no tarifas fijas

Cada solicitud a la API de Images se factura según tres contadores. Tokens de entrada de texto son tu prompt. Tokens de entrada de imagen aparecen solo cuando envías fotos de referencia para una edición. Tokens de salida de imagen son la imagen que recibes de vuelta, y casi siempre son la partida más grande de la factura.

Con las tarifas actuales la fórmula es sencilla: tokens de texto por $5, tokens de entrada de imagen por $8 y tokens de salida de imagen por $30, todo por millón. La longitud del prompt casi no importa. Un prompt de 200 tokens cuesta $0,001, mientras que una sola salida de alta calidad puede superar los 1.700 tokens, unos $0,05 solo por la imagen.

Tarifas actuales de cada modelo GPT Image

Estas son las tarifas de tokens de OpenAI por 1 millón de tokens para cada modelo de la familia:

La entrada en caché es más barata: $1,25 por millón para texto y $2,00 para imágenes en la familia GPT Image 2. Las dos variantes 2.5 comparten exactamente las tarifas de GPT Image 2, así que la lista de precios no te dirá cuál elegir. Lo que decide es el consumo de tokens.

Niveles de calidad y lo que cuestan

Los cinco ajustes de calidad

Los modelos 2.5 aceptan low, medium, high, xhigh, max y auto para el parámetro quality. GPT Image 2 funciona con tres niveles: low, medium y high. Para los modelos 2.5, un desglose de Kanaries enumera los tokens de salida por nivel, y multiplicarlos por $30 por millón da estos precios por imagen:

Dos detalles destacan. Primero, las imágenes rectangulares son más baratas que las cuadradas en todos los niveles, alrededor de un 20 a un 22 por ciento, así que elige horizontal o vertical siempre que el diseño lo permita. Segundo, la curva de precios es empinada: max cuesta unas 36 veces lo que low.

GPT Image 2 aparece en calculadoras como CostGoat a $0,006, $0,053 y $0,211 para low, medium y high a 1024x1024, y $0,005, $0,041 y $0,165 para los rectangulares. Esas cifras en dólares coinciden con las filas 2.5 low, high y max, lo que sugiere que los modelos 2.5 añaden pasos más finos entre ellas. Confirma los recuentos de tokens en tu propia cuenta antes de confiar en esa correspondencia.

Costo de 1.000 imágenes

Los centavos por imagen ocultan el presupuesto real. Multiplicar los recuentos de tokens por un lote de 1.000 da:

Suma unos $0,75 por cada 1.000 imágenes por un prompt de 150 tokens. Esa es toda la factura del prompt. El ajuste de calidad es la verdadera palanca del presupuesto.

Cuándo low es suficiente

Low cuesta aproximadamente una novena parte de high, y muchos trabajos no necesitan más. Miniaturas, tableros de inspiración, pruebas de concepto y pruebas A/B de composición se ven bien con low. Las imágenes principales, las maquetas de envases y cualquier cosa que un cliente vaya a ampliar merecen high o superior.

Empieza con medium. Cuesta unas 2,2 veces low y una cuarta parte de high, y es un valor predeterminado razonable para un flujo que nadie ha medido todavía.

Qué modelo se adapta a tu carga de trabajo

La variante rápida

GPT Image 2.5 Flare está pensado para generar de forma rápida y cotidiana. Una reseña indica una latencia de aproximadamente la mitad de la de GPT Image 2. Esa velocidad importa más en Python que en una ventana de chat: cuando un usuario espera una solicitud web, los segundos cuentan, y las llamadas más rápidas también significan menos conexiones abiertas que gestionar.

La variante precisa

GPT Image 2.5 Sunburst está orientado a flujos de trabajo en los que la precisión de la edición es lo más importante, como conservar el detalle fino mientras cambias un solo elemento. Es más lento y se factura a las mismas tarifas por token que Flare. Si tu flujo de trabajo edita sobre todo fotos de productos, prueba primero Sunburst. Si crea sobre todo imágenes nuevas, empieza con Flare.

Modelos anteriores que aún merecen la pena

GPT Image 1 Mini llega como máximo a $0,052, aproximadamente una cuarta parte de los $0,211 del modelo insignia, lo que lo convierte en la opción económica para trabajos masivos que toleran menor fidelidad. GPT Image 1 es el que hay que vigilar: CostGoat indica un cierre el 23 de octubre de 2026, así que confirma la fecha en la página de obsolescencias de OpenAI y evita empezar nada nuevo con él.

Configuración de Python paso a paso

Tu primera solicitud

Instala el SDK con pip install openai y configura tus credenciales en el entorno. El cliente las lee automáticamente, así que nada sensible queda en tu código.

import base64
from pathlib import Path
from openai import OpenAI

client = OpenAI(timeout=180)

result = client.images.generate(
    model="gpt-image-2.5-flare",
    prompt="Studio photo of a cobalt-blue ceramic mug on a pale gray backdrop, soft light from the left",
    size="1536x1024",
    quality="medium",
)

Path("mug.png").write_bytes(base64.b64decode(result.data[0].b64_json))

Copiar prompt

La imagen llega en base64 dentro de b64_json, así que decodifícala y escribe los bytes. OpenAI indica que los prompts complejos pueden tardar hasta dos minutos, por lo que el cliente de arriba fija un tiempo de espera explícito de 180 segundos. Así, una solicitud bloqueada falla a los tres minutos en lugar de dejar colgado un proceso.

Registrar el costo real

No te fíes de una tabla, incluidas las de arriba. Registra lo que realmente usa cada llamada y conviértelo a dólares:

TEXT_IN = 5.00 / 1_000_000
IMAGE_IN = 8.00 / 1_000_000
IMAGE_OUT = 30.00 / 1_000_000

def cost_of(result):
    usage = result.usage
    details = usage.input_tokens_details
    return (
        details.text_tokens * TEXT_IN
        + details.image_tokens * IMAGE_IN
        + usage.output_tokens * IMAGE_OUT
    )

print(f"${cost_of(result):.4f}")

Copiar prompt

💡 Consejo: estos nombres de campo siguen el objeto de uso de la API de Images. Imprime result.usage una vez con tu versión del SDK para confirmarlos antes de construir informes encima.

Borrador en low, acabado en high

Un bucle de borradores baratos se amortiza en unas pocas imágenes. Genera cuatro borradores en low, elige la redacción del prompt que funcione y luego gasta una sola vez en un render en high:

PROMPT = "Studio photo of a cobalt-blue ceramic mug on a pale gray backdrop, soft light from the left"
MODEL = "gpt-image-2.5-flare"

drafts = [
    client.images.generate(model=MODEL, prompt=PROMPT, size="1536x1024", quality="low")
    for _ in range(4)
]
# Review the drafts, adjust PROMPT, then pay for one final render.
final = client.images.generate(model=MODEL, prompt=PROMPT, size="1536x1024", quality="high")

Copiar prompt

Las cuentas a 1536x1024: cuatro borradores a $0,0047 más un acabado a $0,0412 suman unos $0,060. Tres intentos a ciegas en high cuestan unos $0,123. Una advertencia: el render final no coincidirá píxel a píxel con un borrador, así que el bucle de borradores sirve para elegir el prompt, no la imagen.

Costos que sorprenden a los equipos

Las ediciones cuestan más

Las imágenes de referencia se facturan como entrada de imagen a $8 por millón de tokens. En un desglose modelado de Omid Saffari, una generación nueva con 200 tokens de texto y 2.000 tokens de salida cuesta $0,061. Si añades una imagen de referencia de 6.000 tokens, la misma solicitud cuesta $0,109. Guardar en caché la entrada repetida la baja a unos $0,072. Son ilustraciones con supuestos declarados, no facturas típicas, pero muestran la dirección: los flujos de edición cuestan más que la generación.

Reintentos y tasa de aceptación

La cifra que importa es el costo por imagen aceptada: el costo de un intento dividido entre la proporción de intentos que conservas.

• High a $0,0527 con 60 % aceptadas: unos $0,088 por cada imagen conservada.
• Medium a $0,0132 con 40 % aceptadas: unos $0,033 por cada imagen conservada.
• Low a $0,0059 con 15 % aceptadas: unos $0,039 por cada imagen conservada.

Un nivel más barato puede seguir siendo la mejor opción aunque descartes más resultados de él. Mide tu propia tasa de aceptación durante una semana antes de elegir un valor predeterminado.

Límites de velocidad por nivel

El rendimiento está limitado por tu nivel de uso. Estos son los límites que OpenAI indica para GPT Image 2:

En el nivel 1, cinco imágenes por minuto significan como máximo 300 por hora. En el nivel 3, 1.000 imágenes se completan en 20 minutos. Envuelve tu bucle en un semáforo sencillo o en un reintento con backoff para que una ráfaga de errores 429 no se convierta en una ráfaga de reintentos desperdiciados.

Formas de reducir la factura

• Usa la Batch API cuando puedas esperar. Se informa de que GPT Image 2 ejecuta Batch a la mitad de las tarifas estándar de tokens en trabajos que toleran hasta 24 horas. Los mismos informes indican que ninguna de las dos variantes 2.5 lo admite.
• Elige horizontal o vertical. Unos 20 por ciento más baratas que las cuadradas en todos los niveles.
• Haz borradores en low y termina una vez. El bucle de arriba cuesta alrededor de la mitad de tres intentos a ciegas en high.
• Limita los intentos. Pon un límite estricto de reintentos por prompt y registra cada fallo.
• Envía una referencia, no cinco. Los tokens de entrada de imagen se acumulan en cada edición.
• Redacta los prompts con un modelo de lenguaje. GPT 5.6 Luna es un modelo rápido para escribir variantes de prompt, y GPT 5 Structured devuelve JSON limpio que tu script de Python puede convertir en prompt, tamaño y calidad por fila. Limítalo a una llamada al modelo de lenguaje por lote de prompts, ya que esa llamada tiene su propia tarifa.

Revisa los borradores uno al lado del otro antes de cualquier pasada en high. Una hoja de contactos con 12 borradores de bajo costo permite a un diseñador marcar los dos que merecen terminarse, y esa revisión lleva minutos.

Cómo usar Flare en PicassoIA

Antes de conectar una llamada a la API en un script, puedes probar el mismo modelo en el navegador. GPT Image 2.5 Flare está en PicassoIA, y sus parámetros reflejan los de la API, lo que lo convierte en un buen entorno de pruebas para decidir qué nivel llamar desde Python.

1. Abre la página del modelo. Ve a GPT Image 2.5 Flare en PicassoIA.
2. Escribe el prompt. Es el único campo obligatorio. Describe el sujeto, la luz y el encuadre en una o dos frases, como en el ejemplo de Python.
3. Elige quality. El valor predeterminado es auto. Usa un ajuste bajo para los borradores y uno alto cuando la composición sea definitiva. La página indica que una calidad mayor tarda más y cuesta más.
4. Ajusta aspect_ratio. El valor predeterminado es 1:1. Prueba una relación horizontal, ya que es la forma más barata en la API.
5. Ajusta los extras. number_of_images acepta de 1 a 10 para comparar opciones con un mismo prompt. output_format tiene webp como valor predeterminado, output_compression 90 y background puede ponerse en transparente para recortes. input_images acepta fotos de referencia para ediciones.
6. Genera y descarga. Guarda el mejor resultado y anota qué ajustes lo produjeron.

💡 Consejo: ejecuta un mismo prompt en low y high en GPT Image 2.5 Flare, luego compara la salida con GPT Image 2 y GPT Image 1 Mini antes de comprometer cualquiera de ellos en un flujo.

PicassoIA también ofrece una API para desarrolladores al estilo de Replicate en api.picassoia.com/v1, con autenticación mediante token Bearer, predicciones asíncronas de crear y luego consultar, y un límite de cinco predicciones simultáneas por cuenta. Sirve, entre otros, a PicassoIA Image y PicassoIA Image Editor Pro. Consulta picassoia.com/en/api para conocer las condiciones de acceso y los precios vigentes, ya que este artículo no los detalla.

Haz tu propia prueba de precios

Las tablas de precios solo llegan hasta cierto punto. La mejor cifra es la que mides con tus propios prompts, tu propia tasa de aceptación y tus propios tamaños. Elige tres prompts de tu carga de trabajo real, genera cada uno en low, medium y high, y registra el costo con la función auxiliar de arriba. Luego decide qué nivel merece quedarse.

Si quieres ver la diferencia de calidad antes de gastar un céntimo en la API, abre GPT Image 2.5 Flare o GPT Image 2.5 Sunburst en PicassoIA y genera tu propio conjunto. Prueba una foto de producto, un retrato y un cartel con texto corto, luego compáralos con distintos ajustes. Tu primera imagen de prueba está a un clic.