Controlar los costes de las API de imagen y vídeo con IA: niveles, procesamiento por lotes y selección de modelos

Nadie agota un presupuesto de medios de IA con una sola llamada dramática a la API. El gasto se filtra silenciosamente a través de tres hábitos: pagar de más por borradores desechables, no saber con claridad en qué unidad se factura realmente y iterar en serie sobre modelos caros porque el flujo de trabajo nunca se configuró para generar primero variantes amplias y baratas.

Esta guía desglosa las palancas de coste que realmente importan al generar imágenes y vídeo con hiapi: la unidad de facturación, los niveles de calidad, la duración del vídeo, el flujo de trabajo de borrador primero y escalado después, y el procesamiento por lotes mediante la API de tareas asíncronas. Todos los precios siguientes provienen de la página de precios en vivo de julio de 2026; considérelos una instantánea y consulte los precios actuales antes de elaborar cualquier presupuesto.

Tenga claro por qué unidad paga exactamente

hiapi factura los modelos de medios por unidad de salida fija, sin ningún cálculo de tokens que haya que deducir a la inversa:

• Los modelos de imagen se cobran por imagen, sin importar lo complejo que sea el prompt.
• Los modelos de vídeo se cobran por segundo de salida generada.
• Los modelos de audio (por ejemplo, elevenlabs/text-to-dialogue-v3) se cobran por cada 1.000 caracteres de texto de entrada.

A continuación, el panorama de precios por imagen de la línea de texto a imagen:

Modelo	Precio por imagen
flux-schnell/text-to-image	$0.005
gpt-image-2/text-to-image@ext	$0.007
z-image	$0.008
gpt-image-2/text-to-image@beta	$0.02
qwen-image-2.0	$0.025
gpt-image-2/text-to-image	$0.03
nano-banana	$0.05
flux-1.1-pro	$0.05
flux-2/text-to-image	$0.05
nano-banana-2	$0.051
wan2.7-image/text-to-image	$0.08
nano-banana-pro	$0.17

Y los precios por segundo de vídeo:

Modelo	Precio por segundo
grok-imagine (texto a vídeo / imagen a vídeo)	$0.0114
kling-3.0-omni (texto a vídeo / imagen a vídeo)	$0.129
seedance-2.0	$0.136
seedance-2.0-mini	$0.147
wan2.7-video@pro (texto a vídeo / imagen a vídeo)	$0.167
happyhorse-1.0	$0.168
happyhorse-1.1 (todos los endpoints)	$0.21
seedance-2.0-fast	$0.2357
veo-3.1-fast	$0.25
veo-3.1	$0.57

Hay dos cifras que conviene recordar: la línea de imagen abarca un factor de 34 veces del más barato al más caro ($0.005 → $0.17) y el vídeo un factor de 50 veces ($0.0114 → $0.57 por segundo). La elección de modelo no es un ajuste fino: es la mayor decisión presupuestaria individual que tomará.

Una advertencia: no deduzca el precio a partir del nombre del modelo. En la familia Veo, la variante -fast es el nivel más barato ($0.25/s frente a $0.57/s), pero seedance-2.0-fast es un nivel premium acelerado cuyo coste por segundo es superior al de la versión base seedance-2.0 ($0.2357 frente a $0.136). Lea la tabla de precios; no dé nada por supuesto.

Trate los niveles de precio como una funcionalidad, no como letra pequeña

La mayoría de las familias de modelos se publican por niveles, y los niveles existen precisamente para que no tenga que pagar el precio de gama alta por cada trabajo:

• Nivel de borrador ($0.005–$0.008): flux-schnell, z-image y el canal @ext de gpt-image-2. Para iterar prompts, probar composiciones y cualquier contenido que una persona vaya a mirar solo un segundo antes de descartarlo.
• Nivel estándar ($0.02–$0.05): gpt-image-2/text-to-image, qwen-image-2.0, nano-banana, flux-2. Calidad de producción para portadas de blog, imágenes de producto y recursos de UI.
• Nivel premium ($0.08–$0.17): wan2.7-image y nano-banana-pro. Reservados para los recursos visuales clave finales en los que el detalle y el seguimiento de instrucciones son críticos.

La misma lógica se aplica a las variantes de canal: la página de precios lista las versiones @beta y @ext de gpt-image-2/text-to-image a $0.02 y $0.007 respectivamente, frente a $0.03 del canal estándar. Si su carga de trabajo tolera los términos de los canales de vista previa, eso supone un ahorro del 20 % al 77 % sobre los mismos prompts. En la API de generación de imágenes más barata: cómo comparar el coste real por imagen profundizamos en la interacción entre el coste por imagen, la resolución y la tasa de reintentos.

En vídeo, la duración es un multiplicador

El coste de vídeo es simplemente tarifa × segundos, lo que significa que cada valor predeterminado que no cuestione se amplifica. El mismo clip de 8 segundos cuesta:

Modelo	Clip de 8 segundos
grok-imagine/text-to-video	$0.09
kling-3.0-omni/text-to-video	$1.03
veo-3.1-fast/text-to-video	$2.00
veo-3.1/text-to-video	$4.56

De ahí se derivan directamente dos hábitos:

1. Solicite la duración más corta que satisfaga el plano. Recortar un clip de veo-3.1 de 8 a 5 segundos ahorra $1.71, por clip y cada vez.
2. Itere en modelos baratos y renderice en los caros. Seis iteraciones de borrador de 4 segundos en grok-imagine cuestan en total unos $0.27, menos de lo que cuesta medio segundo de salida de veo-3.1. Agote ahí su experimentación con prompts y luego gaste $4.56 una sola vez.

Borradores baratos, finalización premium

El cambio de flujo de trabajo con mayor impacto es separar la exploración de la entrega. Ejemplo práctico con una imagen de producto:

• 20 iteraciones de borrador en z-image a $0.008 cada una = $0.16
• 3 renders finales en nano-banana-pro a $0.17 cada uno = $0.51
• Total: $0.67

Ejecutar las 23 generaciones en nano-banana-pro costaría $3.91. El mismo número de llamadas a la API, el mismo recurso final y aproximadamente un 83 % menos de gasto, y además el bucle de borradores es más rápido, porque los modelos del nivel de borrador responden en segundos.

La única salvedad: los prompts no se trasladan perfectamente entre familias. Mantenga el bucle de borradores en el modelo que usará para la finalización durante las últimas una o dos iteraciones, para detectar las peculiaridades propias de la familia antes de comprometer el presupuesto premium.

Procesamiento por lotes mediante la API de tareas asíncronas

Todos los modelos de medios de hiapi funcionan mediante un endpoint de tareas asíncronas: POST /v1/tasks devuelve un ID de tarea de inmediato y luego se consultan los resultados. El procesamiento por lotes no ofrece descuento por solicitud; el beneficio es arquitectónico. Como el envío y la finalización están desacoplados, puede distribuir todo un lote de borradores de una vez en lugar de esperar en serie a cada generación, que es justo lo que hace práctico el ciclo de borrador primero y escalado después:

import requests, time

API = "https://api.hiapi.ai/v1/tasks"
HEADERS = {"Authorization": "Bearer YOUR_API_KEY"}

def create_task(model: str, prompt: str) -> str:
    r = requests.post(API, headers=HEADERS, json={
        "model": model,
        "input": {"prompt": prompt, "aspect_ratio": "1:1"},
    })
    r.raise_for_status()
    return r.json()["data"]["taskId"]

def wait_task(task_id: str, timeout: int = 600) -> str:
    deadline = time.time() + timeout
    while time.time() < deadline:
        task = requests.get(f"{API}/{task_id}", headers=HEADERS).json()["data"]
        if task["status"] == "success":
            return task["output"][0]["url"]  # expiring URL — download it now
        if task["status"] == "fail":
            raise RuntimeError(task.get("error"))
        time.sleep(5)
    raise TimeoutError(task_id)

# Fan out 12 draft variations on a $0.008 model: ~$0.10 for the whole batch
variations = [f"studio product shot of a ceramic mug, camera angle {i}" for i in range(12)]
task_ids = [create_task("z-image", p) for p in variations]
urls = [wait_task(t) for t in task_ids]

Envie las doce primero y luego consulte: las tareas se generan en paralelo en el lado de la plataforma mientras su código espera una sola vez. Los campos de entrada distintos de prompt varían según el modelo (algunos aceptan resolution, otros solo aspect_ratio), así que consulte la tabla de parámetros del modelo antes de procesar por lotes; el tutorial de gpt-image-2 muestra este patrón de principio a fin.

Cuando amplíe la distribución, respete los límites de concurrencia de la plataforma: una ráfaga que provoca un 429 solo añade latencia por reintentos. Límites de velocidad de la API de generación de imágenes explicados describe cómo se comportan los límites y cómo retroceder de forma limpia.

Diez líneas de guarda presupuestaria convierten «vigilaremos el gasto» en una invariante real:

PRICES = {"z-image": 0.008, "gpt-image-2/text-to-image": 0.03, "nano-banana-pro": 0.17}
BUDGET_USD = 5.00
spent = 0.0

def spend(model: str, images: int = 1) -> None:
    global spent
    cost = PRICES[model] * images
    if spent + cost > BUDGET_USD:
        raise RuntimeError(f"budget cap: ${spent + cost:.2f} would exceed ${BUDGET_USD:.2f}")
    spent += cost

Llámela antes de cada create_task y un bucle descontrolado fallará de forma ruidosa al llegar a $5, en lugar de aparecer en la factura del mes siguiente.

No pague dos veces por el mismo resultado

La fuga de costes más insidiosa es la regeneración: pagar el precio completo por un resultado que ya tenía:

• Descargue los resultados de inmediato. Las URL de salida de las tareas tienen caducidad. Si guarda enlaces directos en lugar de archivos y el enlace caduca, la única solución es pagar por regenerar. Detalles y patrones de descarga aquí.
• Distinga entre «la tarea ha fallado» y «mi consulta se rindió». Una tarea que tiene éxito después de que el cliente agote el tiempo de espera es dinero gastado en un resultado que nadie recoge. Configure el tiempo de espera de la consulta muy por encima del tiempo real de finalización del modelo; antes de asumir un fallo, aquí se explica cómo diagnosticar tareas colgadas.
• Reutilice su propia biblioteca. Antes de generar por quinta vez «una foto limpia de estudio sobre fondo blanco», revise los recursos por los que ya pagó. Un bucket compartido con prompts con capacidad de búsqueda es el modelo más barato de su stack.

Lista de verificación del control de costes

1. Presupueste según la unidad nativa de cada modelo: por imagen, por segundo, por cada 1.000 caracteres.
2. Elija un modelo de nivel de borrador y otro de nivel de entrega para cada tipo de medio; enrute según la fase del trabajo.
3. En vídeo, cuestione cada valor predeterminado de duración: los segundos son un multiplicador.
4. Distribuya los borradores a través de /v1/tasks; promueva solo las ganadoras a render premium.
5. Aplique límites de gasto estrictos en el código, no en un panel que revisa cada semana.
6. Descargue cada resultado de inmediato; nunca almacene URL que caducan.

Los precios de los modelos cambian a medida que se publican nuevas versiones, así que empiece por la página de precios en vivo, elija su nivel de borrador y su nivel de entrega en el catálogo de modelos e integre los patrones de distribución anteriores en su pipeline: los primeros lotes de tareas que ejecute le dirán exactamente el coste real de cada recurso utilizable.