Coste por imagen aceptada: cómo presupuestar APIs de imágenes con reintentos

El número que aparece en la página de un modelo es el precio de un intento. Lo que tu aplicación paga en realidad es una imagen aceptada. Si un modelo barato necesita dos intentos para dar una imagen utilizable y uno algo más caro acierta a la primera, el precio de lista apenas te dice nada. Esta guía muestra cómo presupuestar la generación de imágenes por coste por imagen aceptada (cost per accepted image) con los precios actuales de seis modelos de Orux AI, y cómo colocarlos detrás de un pequeño cliente asíncrono para mover tráfico entre ellos sin reescribir tu aplicación.

Todos los precios de abajo se leyeron en las páginas de modelos de Orux AI el 2026-11-04. Varios modelos son más baratos que las cifras de nuestro artículo de precios de octubre, así que usa esta tabla y no la anterior. 1 Credit = $0.005.

Por qué el precio de lista es la unidad equivocada

Las solicitudes de imagen en Orux AI se facturan por cada imagen generada con éxito. Una tarea que termina en FAILED o EXPIRED no se cobra. Suena a que solo pagas por lo que funciona, pero "éxito" significa que el modelo devolvió una imagen, no que esa imagen sirva para tu producto. Una imagen con el color de producto equivocado, texto deformado o una composición torpe sigue contando como éxito y sigue consumiendo Credits.

Por eso la fórmula real del presupuesto tiene dos partes:

• Precio de lista por intento: lo ves en la página del modelo.
• Intentos por imagen aceptada: depende de tu prompt, tu criterio de revisión y el modelo, y tienes que medirlo tú.

Coste por imagen aceptada = precio de lista × intentos por imagen aceptada.

Si generas 100 imágenes y aceptas 77, tus intentos por imagen aceptada son 100 ÷ 77 ≈ 1,3. Esa proporción es el número más importante de un presupuesto de imágenes, y casi nadie lo registra.

Precios de lista actuales (verificados el 2026-11-04)

Desliza horizontalmente para ver toda la tabla.

Cómo leerla:

• Tres modelos cuestan entre unos 2,3 y 2,7 Credits por imagen: Nano Banana 2.1, flux-2-pro y GPT Image 2.5 Sunburst. Wan2.7 Image está en medio. Qwen Image 3.0 Pro y Seedream 5.0 Pro cuestan aproximadamente entre 2,5 y 3,3 veces más en 1K, y el doble otra vez en 2K.
• Las imágenes de referencia son gratis en Nano Banana 2.1, GPT Image 2.5 Sunburst y Wan2.7 Image. En Qwen Image 3.0 Pro, una imagen 1K con 3 referencias cuesta 8.267 Cr ($0.0413); en Seedream 5.0 Pro, una imagen 1K con 10 referencias cuesta 12.5 Cr ($0.0625). Si tu flujo es sobre todo de edición, usa esas filas y no el precio sin referencias.
• flux-2-pro es barato pero limitado: en Orux AI ahora mismo solo ofrece 1K y 1:1, sin imágenes de referencia. Si necesitas banners 16:9 o edición, no es una opción por barato que sea.

Ejemplo práctico: coste por imagen aceptada

Los recuentos de intentos de abajo son supuestos ilustrativos, no mediciones. Sustitúyelos por tus propias cifras tras una prueba piloto.

Desliza horizontalmente para ver toda la tabla.

La última columna responde a la pregunta práctica: ¿cuántos intentos puede necesitar un modelo más barato antes de que su coste por imagen aceptada iguale al de Seedream 5.0 Pro aceptado siempre a la primera? Para Nano Banana 2.1 son unos 3,3; para Wan2.7 Image, unos 1,7.

Veamos un escenario concreto. Supón que tu piloto da esto:

• Modelo A: Nano Banana 2.1 en 1K necesita 1,3 intentos por foto de producto aceptada.
• Modelo B: Seedream 5.0 Pro en 1K necesita 1,0.

Para 1.000 imágenes aceptadas:

• Modelo A: 1.000 × 1,3 × 2.281 = 2.965 Credits ($14.83)
• Modelo B: 1.000 × 1,0 × 7.5 = 7.500 Credits ($37.50)

Incluso con un 30 % más de intentos, el modelo A cuesta bastante menos de la mitad. El orden solo se invierte si la proporción del modelo barato supera aproximadamente 3,3, o si las imágenes rechazadas generan costes además de los Credits.

Eso último importa. Cada imagen rechazada lleva tiempo revisarla y, en una aplicación de cara al usuario, cada reintento añade espera. Si una persona revisa cada resultado, el tiempo de revisión puede pesar mucho más que unos pocos Credits. No damos una cifra porque varía según el equipo, pero el código de abajo registra los intentos para que puedas sumarlo tú.

Tres lugares donde se esconde el multiplicador de reintentos

Los intentos por imagen aceptada también suben por motivos que no tienen nada que ver con la calidad del modelo:

1. Envíos duplicados. Si un worker agota el tiempo durante el sondeo y vuelve a enviar el mismo trabajo, puedes pagar dos éxitos. Guarda primero el task_id y reanuda el sondeo en lugar de reenviar.
2. Parámetros no admitidos. Pedir una relación de aspecto o resolución que el modelo no ofrece se rechaza antes del envío. No cuesta nada, pero frena tu pipeline. Mantén los límites de cada modelo en la configuración (ver abajo) para que pasar de GPT Image 2.5 Sunburst a flux-2-pro no envíe en silencio un 16:9 a un modelo que solo admite 1:1.
3. Deriva del prompt. Un prompt ajustado para un modelo y reutilizado tal cual en otro más barato puede bajar la tasa de aceptación. Vuelve a hacer un piloto de cada modelo con tus propios prompts antes de mover tráfico real.

Ejemplos públicos existentes de las páginas de modelos

Las cinco imágenes de abajo son ejemplos públicos existentes publicados en las páginas de modelos de Orux AI. No se generaron para este artículo ni son pruebas de calidad. Muestran el tipo de resultado que documenta cada página, con el prompt y los ajustes indicados allí.

*Ejemplo público existente de la página del modelo Nano Banana 2.1: "Still alpine lake perfectly reflecting snow-capped peaks and pine trees at sunrise", 1K, 16:9. Precio de lista con esta configuración: 2.281 Credits.*

*Ejemplo público existente de la página del modelo flux-2-pro: foto minimalista de estudio de un jarrón de cerámica, 1K, 1:1 (el único tamaño que ofrece actualmente). Precio de lista: 2.67 Credits.*

*Ejemplo público existente de la página del modelo GPT Image 2.5 Sunburst: ciudad costera futurista al atardecer, 1K, 16:9. Precio de lista: 2.667 Credits en cualquier resolución.*

*Ejemplo público existente de la página del modelo Qwen Image 3.0 Pro: campo de lavanda al atardecer, 1K, 16:9. Precio de lista: 6.667 Credits sin referencias.*

*Ejemplo público existente de la página del modelo Seedream 5.0 Pro: aurora sobre una cabaña nevada, 1K, 16:9. Precio de lista: 7.5 Credits sin referencias.*

Fíjate en que cuatro de las cinco son 1K y 16:9. Es justo la configuración en la que puedes hacer pruebas A/B entre modelos con un solo cliente. flux-2-pro no puede participar en esa comparación porque solo produce 1:1.

Un cliente asíncrono, modelos en la configuración

Los seis modelos usan el mismo endpoint asíncrono. Envías POST https://orux.top/api/v1/tasks con model y un objeto input, recibes HTTP 202 con un task_id y después sondeas GET https://orux.top/api/v1/tasks/{id} hasta que el estado sea SUCCESS, FAILED o EXPIRED. Entre modelos solo cambian la cadena model y los valores permitidos de input, así que la elección del modelo debe vivir en la configuración, no en el código.

El script de abajo hace cuatro cosas: valida la solicitud contra los límites de cada modelo, envía y sondea, guarda el resultado de inmediato (los enlaces de resultado son temporales) y escribe un registro de intentos con el que calcular el coste por imagen aceptada de cada modelo. Crea una API key, expórtala como ORUX_API_KEY e instala requests.

import json
import os
import sys
import time

import requests

BASE = "https://orux.top/api/v1"
HEADERS = {"Authorization": f"Bearer {os.environ['ORUX_API_KEY']}"}

# List prices in Credits per successful image, read from model pages on 2026-11-04.
# Keys are (resolution, reference_count) where it matters; refs surcharges omitted
# for Qwen/Seedream except the no-reference rows, so keep image_urls empty for them here.
MODELS = {
    "nano-banana-2.1": {"res": {"1K": 2.281, "2K": 2.667, "4K": 2.667},
                        "ratios": {"1:1", "16:9", "9:16", "4:3", "3:4", "3:2", "2:3", "21:9"},
                        "max_refs": 10},
    "flux-2-pro": {"res": {"1K": 2.67}, "ratios": {"1:1"}, "max_refs": 0},
    "gpt-image-2.5-sunburst": {"res": {"1K": 2.667, "2K": 2.667, "4K": 2.667},
                               "ratios": {"1:1", "16:9", "9:16", "4:3", "3:4", "3:2", "2:3", "21:9"},
                               "max_refs": 16},
    "wan2.7-image": {"res": {"1K": 4.333, "2K": 4.333},
                     "ratios": {"1:1", "16:9", "9:16", "4:3", "3:4"}, "max_refs": 9},
    "qwen-image-3.0-pro": {"res": {"1K": 6.667, "2K": 13.33},
                           "ratios": {"1:1", "16:9", "9:16", "4:3", "3:4", "3:2", "2:3"},
                           "max_refs": 0},   # refs add a surcharge; not modelled here
    "seedream-5.0-pro": {"res": {"1K": 7.5, "2K": 15.0},
                         "ratios": {"1:1", "16:9", "9:16", "4:3", "3:4", "3:2", "2:3", "21:9"},
                         "max_refs": 0},     # refs add a surcharge; not modelled here
}

# Switch models here (or via env var) without touching the rest of the code.
ACTIVE_MODEL = os.environ.get("ORUX_IMAGE_MODEL", "nano-banana-2.1")
LEDGER = "ledger.jsonl"


def build_input(prompt: str, resolution: str, aspect_ratio: str, refs=None) -> dict:
    spec = MODELS[ACTIVE_MODEL]
    refs = refs or []
    if resolution not in spec["res"]:
        raise ValueError(f"{ACTIVE_MODEL} has no {resolution}; options: {list(spec['res'])}")
    if aspect_ratio not in spec["ratios"]:
        raise ValueError(f"{ACTIVE_MODEL} does not accept {aspect_ratio}")
    if len(refs) > spec["max_refs"]:
        raise ValueError(f"{ACTIVE_MODEL}: too many reference images for this script")
    payload = {"prompt": prompt, "resolution": resolution, "aspect_ratio": aspect_ratio}
    if refs:
        payload["image_urls"] = refs
    return payload


def submit(payload: dict) -> str:
    r = requests.post(f"{BASE}/tasks", headers=HEADERS,
                      json={"model": ACTIVE_MODEL, "input": payload}, timeout=60)
    if r.status_code == 402:
        sys.exit("Insufficient balance: top up your Credits.")
    r.raise_for_status()
    return r.json()["task_id"]


def wait(task_id: str, max_wait: int = 900) -> dict:
    deadline = time.time() + max_wait
    while time.time() < deadline:
        time.sleep(5)
        r = requests.get(f"{BASE}/tasks/{task_id}", headers=HEADERS, timeout=30)
        r.raise_for_status()
        task = r.json()
        if task["status"] in ("SUCCESS", "FAILED", "EXPIRED"):
            return task
    raise TimeoutError(f"{task_id} still running: poll again later, do not resubmit")


def log(row: dict) -> None:
    with open(LEDGER, "a") as f:
        f.write(json.dumps(row) + "\n")


def generate_until_accepted(prompt, resolution="1K", aspect_ratio="1:1", max_attempts=3):
    payload = build_input(prompt, resolution, aspect_ratio)
    price = MODELS[ACTIVE_MODEL]["res"][resolution]
    for attempt in range(1, max_attempts + 1):
        task_id = submit(payload)
        log({"model": ACTIVE_MODEL, "task_id": task_id, "event": "submitted"})
        task = wait(task_id)
        if task["status"] != "SUCCESS":
            log({"model": ACTIVE_MODEL, "task_id": task_id, "event": task["status"], "credits": 0})
            continue
        urls = task.get("result") or []
        path = f"{task_id}.png"
        with open(path, "wb") as f:
            f.write(requests.get(urls[0], timeout=120).content)  # links expire: save now
        ok = input(f"Attempt {attempt}: review {path}. Accept? [y/N] ").strip().lower() == "y"
        log({"model": ACTIVE_MODEL, "task_id": task_id, "event": "accepted" if ok else "rejected",
             "credits": price})
        if ok:
            return path
    return None


def report() -> None:
    stats = {}
    with open(LEDGER) as f:
        for line in f:
            row = json.loads(line)
            s = stats.setdefault(row["model"], {"credits": 0.0, "accepted": 0, "attempts": 0})
            if row["event"] in ("accepted", "rejected"):
                s["attempts"] += 1
                s["credits"] += row["credits"]
                s["accepted"] += row["event"] == "accepted"
    for model, s in stats.items():
        if s["accepted"]:
            per = s["credits"] / s["accepted"]
            print(f"{model}: {s['attempts'] / s['accepted']:.2f} attempts/accepted, "
                  f"{per:.3f} Cr (${per * 0.005:.4f}) per accepted image")


if __name__ == "__main__":
    generate_until_accepted(
        "Minimalist studio product photograph of a matte white ceramic vase on a "
        "travertine plinth, soft window light, warm beige backdrop, no text.",
        resolution="1K", aspect_ratio="1:1")
    report()

Para comparar dos modelos con el mismo encargo, ejecútalo una vez con ORUX_IMAGE_MODEL=nano-banana-2.1 y otra con ORUX_IMAGE_MODEL=gpt-image-2.5-sunburst, y revisa el informe. El registro solo cuenta como facturadas las imágenes con éxito, igual que cobra Orux AI; las tareas FAILED y EXPIRED se registran con 0 Credits.

Notas de diseño:

• La tabla de precios es una estimación local. Sirve para presupuestar, no para facturar. Los precios pueden cambiar, así que revisa la página del modelo y actualiza las cifras antes de una ejecución grande.
• Los recargos por referencias de Qwen Image 3.0 Pro y Seedream 5.0 Pro no se modelan a propósito. Si añades image_urls en esos modelos, consulta en la página del modelo el precio según el número de referencias.
• Sondear cada 5 segundos es suficiente. Las tareas de imagen pueden tardar minutos, así que ejecútalas en un worker en segundo plano, no dentro de una petición web.
• La revisión manual de aceptación es un marcador de posición. En producción puede sustituirse por comprobaciones automáticas, una cola de revisión o el pulgar arriba del usuario. Lo importante es registrar cada aceptación y cada rechazo.

Cómo elegir un modelo por defecto y uno de respaldo

Cuando conoces tus proporciones reales de intentos, la elección es casi aritmética. Compensaciones honestas según las páginas de modelos:

• Nano Banana 2.1 tiene el precio de lista más bajo en 1K del grupo, referencias gratuitas y la mayor variedad de relaciones de aspecto. Es un buen modelo por defecto para borradores en volumen.
• GPT Image 2.5 Sunburst cuesta 2.667 Credits en 1K, 2K y 4K, así que es la forma más barata del grupo de obtener 4K. Admite hasta 16 referencias.
• flux-2-pro está en la misma franja de precio, pero es solo texto, 1K y 1:1. Úsalo solo para recursos cuadrados.
• Wan2.7 Image cuesta más por intento que los tres anteriores, pero su precio fijo con hasta 9 referencias ayuda en pipelines con mucha edición.
• Qwen Image 3.0 Pro y Seedream 5.0 Pro son los más caros por intento y cobran recargo por referencias. Solo ganan en coste por imagen aceptada cuando tu piloto demuestra que los modelos baratos necesitan muchos más reintentos para tu caso, por ejemplo pósteres que requieren texto exacto.

Un patrón sensato: un modelo barato por defecto, un respaldo premium para los trabajos en los que el primero falla una y otra vez, y una revisión mensual de los precios de lista y de tus proporciones medidas.

Preguntas frecuentes

Q.¿Qué es el coste por imagen aceptada?

El coste por imagen aceptada es el precio de lista de un intento multiplicado por el número medio de intentos que necesitas para obtener una imagen que te quedas. Si un modelo cuesta 2.281 Credits por imagen y aceptas una de cada 1,3, pagas unos 2.965 Credits ($0.0148) por imagen aceptada.

Q.¿Las tareas de imagen fallidas cuestan Credits en Orux AI?

No. Las tareas de imagen solo se facturan cuando terminan en SUCCESS; las que terminan en FAILED o EXPIRED no se cobran. Sin embargo, una imagen con éxito que rechazas sí se factura, y por eso importan los intentos por imagen aceptada.

Q.¿Cuál de estos seis modelos es ahora el más barato por imagen?

A fecha de 2026-11-04, el precio de lista más bajo del grupo es Nano Banana 2.1 en 1K, con 2.281 Credits ($0.0114) por imagen. Le siguen muy de cerca flux-2-pro (2.67 Cr) y GPT Image 2.5 Sunburst (2.667 Cr); en 4K, GPT Image 2.5 Sunburst y Nano Banana 2.1 cuestan ambos 2.667 Credits.

Q.¿Puedo cambiar de modelo de imagen sin cambiar el código?

Sí, si guardas el nombre del modelo y sus límites de parámetros en la configuración. Todos los modelos de aquí usan el mismo flujo POST /api/v1/tasks y GET /api/v1/tasks/{id}; solo cambian la cadena model y las resoluciones, relaciones de aspecto y número de referencias permitidos.

Q.¿Cuántas imágenes de prueba necesito para estimar los intentos por imagen aceptada?

Empieza con un piloto de unas decenas de imágenes por modelo con tus prompts reales y sigue registrando en producción. Un piloto pequeño te da una proporción aproximada, y el registro del script de arriba la afina con el tiempo.

Q.¿Cuándo merece la pena un modelo más caro?

Un modelo más caro merece la pena cuando los reintentos que mides en el modelo barato superan el punto de equilibrio. Tomando como referencia Seedream 5.0 Pro aceptado a la primera, el punto de equilibrio es de unos 3,3 intentos para Nano Banana 2.1 y de unos 1,7 para Wan2.7 Image.