Custo por imagem aceita: como orçar APIs de imagem contando as tentativas

O número na página de um modelo é o preço de uma tentativa. O que sua aplicação realmente paga é uma imagem aceita. Se um modelo barato precisa de duas tentativas para entregar uma imagem utilizável e um um pouco mais caro acerta de primeira, o preço de tabela quase não diz nada. Este guia mostra como orçar a geração de imagens pelo custo por imagem aceita (cost per accepted image) com os preços atuais de seis modelos da Orux AI, e como colocá-los atrás de um pequeno cliente assíncrono para mover tráfego entre eles sem reescrever sua aplicação.

Todos os preços abaixo foram lidos nas páginas de modelos da Orux AI em 2026-11-04. Vários modelos estão mais baratos do que os números do nosso artigo de preços de outubro, então use esta tabela, não a anterior. 1 Credit = US$ 0,005.

Por que o preço de tabela é a unidade errada

As solicitações de imagem na Orux AI são cobradas por imagem gerada com sucesso. Uma tarefa que termina em FAILED ou EXPIRED não é cobrada. Parece que você só paga pelo que funciona, mas "sucesso" significa que o modelo devolveu uma imagem, não que essa imagem serve para o seu produto. Uma imagem com a cor de produto errada, texto distorcido ou composição desajeitada ainda conta como sucesso e ainda consome Credits.

Por isso a fórmula real do orçamento tem duas partes:

• Preço de tabela por tentativa: aparece na página do modelo.
• Tentativas por imagem aceita: depende do seu prompt, do seu critério de revisão e do modelo, e precisa ser medido por você.

Custo por imagem aceita = preço de tabela × tentativas por imagem aceita.

Se você gera 100 imagens e aceita 77, suas tentativas por imagem aceita são 100 ÷ 77 ≈ 1,3. Essa proporção é o número mais importante de um orçamento de imagens, e quase ninguém a acompanha.

Preços de tabela atuais (verificados em 2026-11-04)

Deslize para os lados para ver toda a tabela.

Como ler:

• Três modelos ficam entre cerca de 2,3 e 2,7 Credits por imagem: Nano Banana 2.1, flux-2-pro e GPT Image 2.5 Sunburst. Wan2.7 Image fica no meio. Qwen Image 3.0 Pro e Seedream 5.0 Pro custam cerca de 2,5 a 3,3 vezes mais em 1K, e o dobro de novo em 2K.
• Imagens de referência são gratuitas no Nano Banana 2.1, no GPT Image 2.5 Sunburst e no Wan2.7 Image. No Qwen Image 3.0 Pro, uma imagem 1K com 3 referências custa 8.267 Cr (US$ 0,0413); no Seedream 5.0 Pro, uma imagem 1K com 10 referências custa 12.5 Cr (US$ 0,0625). Se o seu fluxo é principalmente de edição, use essas linhas, não o preço sem referências.
• O flux-2-pro é barato, mas limitado: na Orux AI ele oferece hoje apenas 1K e 1:1, sem imagens de referência. Se você precisa de banners 16:9 ou de edição, ele não é uma opção, por mais barato que seja.

Exemplo prático: custo por imagem aceita

As contagens de tentativas abaixo são suposições ilustrativas, não medições. Substitua-as pelos seus próprios números depois de um piloto.

Deslize para os lados para ver toda a tabela.

A última coluna responde à pergunta prática: quantas tentativas um modelo mais barato pode precisar antes que seu custo por imagem aceita iguale o do Seedream 5.0 Pro aceito sempre de primeira? Para o Nano Banana 2.1, cerca de 3,3; para o Wan2.7 Image, cerca de 1,7.

Vejamos um cenário concreto. Suponha que seu piloto mostre o seguinte:

• Modelo A: Nano Banana 2.1 em 1K precisa de 1,3 tentativa por foto de produto aceita.
• Modelo B: Seedream 5.0 Pro em 1K precisa de 1,0.

Para 1.000 imagens aceitas:

• Modelo A: 1.000 × 1,3 × 2.281 = 2.965 Credits (US$ 14,83)
• Modelo B: 1.000 × 1,0 × 7.5 = 7.500 Credits (US$ 37,50)

Mesmo com 30% mais tentativas, o modelo A custa bem menos da metade. A ordem só se inverte se a proporção do modelo barato passar de cerca de 3,3, ou se as imagens rejeitadas gerarem custos além dos Credits.

Esse último ponto importa. Cada imagem rejeitada leva tempo para ser conferida e, em uma aplicação voltada ao usuário, cada nova tentativa aumenta a espera. Se uma pessoa revisa cada resultado, o tempo de revisão pode pesar muito mais do que alguns Credits. Não damos um número porque ele varia de equipe para equipe, mas o código abaixo registra as tentativas para que você possa somá-lo.

Três lugares onde o multiplicador de tentativas se esconde

As tentativas por imagem aceita também sobem por motivos que nada têm a ver com a qualidade do modelo:

1. Envios duplicados. Se um worker estoura o tempo durante o polling e reenvia o mesmo trabalho, você pode pagar por dois sucessos. Salve primeiro o task_id e retome o polling em vez de reenviar.
2. Parâmetros não suportados. Pedir uma proporção ou resolução que o modelo não oferece é rejeitado antes do envio. Não custa nada, mas trava seu pipeline. Mantenha os limites de cada modelo na configuração (veja abaixo) para que trocar o GPT Image 2.5 Sunburst pelo flux-2-pro não envie silenciosamente um 16:9 para um modelo que só aceita 1:1.
3. Deriva de prompt. Um prompt ajustado para um modelo e reutilizado sem mudanças em um modelo mais barato pode reduzir a taxa de aceitação. Refaça o piloto de cada modelo com seus próprios prompts antes de mover tráfego real.

Exemplos públicos existentes das páginas de modelos

As cinco imagens abaixo são exemplos públicos existentes publicados nas páginas de modelos da Orux AI. Elas não foram geradas para este artigo e não são testes de qualidade. Mostram o tipo de resultado que cada página documenta, com o prompt e as configurações informados lá.

*Exemplo público existente da página do modelo Nano Banana 2.1: "Still alpine lake perfectly reflecting snow-capped peaks and pine trees at sunrise", 1K, 16:9. Preço de tabela nesta configuração: 2.281 Credits.*

*Exemplo público existente da página do modelo flux-2-pro: foto minimalista de estúdio de um vaso de cerâmica, 1K, 1:1 (o único tamanho oferecido atualmente). Preço de tabela: 2.67 Credits.*

*Exemplo público existente da página do modelo GPT Image 2.5 Sunburst: cidade costeira futurista ao entardecer, 1K, 16:9. Preço de tabela: 2.667 Credits em qualquer resolução.*

*Exemplo público existente da página do modelo Qwen Image 3.0 Pro: campo de lavanda ao pôr do sol, 1K, 16:9. Preço de tabela: 6.667 Credits sem referências.*

*Exemplo público existente da página do modelo Seedream 5.0 Pro: aurora sobre uma cabana coberta de neve, 1K, 16:9. Preço de tabela: 7.5 Credits sem referências.*

Repare que quatro das cinco são 1K e 16:9. É exatamente a configuração em que você pode fazer testes A/B entre modelos com um único cliente. O flux-2-pro não entra nessa comparação porque só gera 1:1.

Um cliente assíncrono, modelos na configuração

Os seis modelos usam o mesmo endpoint assíncrono. Você envia POST https://orux.top/api/v1/tasks com model e um objeto input, recebe HTTP 202 com um task_id e depois faz polling em GET https://orux.top/api/v1/tasks/{id} até o status ser SUCCESS, FAILED ou EXPIRED. Entre modelos, só mudam a string model e os valores de input permitidos, então a escolha do modelo deve ficar na configuração, não no código.

O script abaixo faz quatro coisas: valida a solicitação contra os limites de cada modelo, envia e faz polling, salva o resultado imediatamente (os links de resultado são temporários) e grava um registro de tentativas com o qual você calcula o custo por imagem aceita de cada modelo. Crie uma API key, exporte-a como ORUX_API_KEY e instale 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 dois modelos com o mesmo briefing, execute uma vez com ORUX_IMAGE_MODEL=nano-banana-2.1 e outra com ORUX_IMAGE_MODEL=gpt-image-2.5-sunburst, e confira o relatório. O registro só conta como cobradas as imagens com sucesso, do mesmo jeito que a Orux AI cobra; tarefas FAILED e EXPIRED são registradas com 0 Credits.

Notas de design:

• A tabela de preços é uma estimativa local. Serve para orçamento, não para cobrança. Os preços podem mudar, então confira a página do modelo e atualize os números antes de uma execução grande.
• Os adicionais por referência do Qwen Image 3.0 Pro e do Seedream 5.0 Pro não foram modelados de propósito. Se você adicionar image_urls nesses modelos, confira na página do modelo o preço por número de referências.
• Fazer polling a cada 5 segundos é suficiente. Tarefas de imagem podem levar minutos, então execute-as em um worker em segundo plano, não dentro de uma requisição web.
• A revisão manual de aceitação é um marcador provisório. Em produção, ela pode ser trocada por verificações automáticas, uma fila de revisão ou o joinha do usuário. O importante é registrar cada aceitação e cada rejeição.

Como escolher um modelo padrão e um de reserva

Quando você conhece suas proporções reais de tentativas, a escolha é quase só aritmética. Trocas honestas com base nas páginas de modelos:

• Nano Banana 2.1 tem o menor preço de tabela em 1K do grupo, referências gratuitas e a maior variedade de proporções. É um padrão sensato para rascunhos em volume.
• GPT Image 2.5 Sunburst custa 2.667 Credits em 1K, 2K e 4K, então é o jeito mais barato de obter 4K neste grupo. Aceita até 16 referências.
• flux-2-pro está na mesma faixa de preço, mas é só texto, 1K e 1:1. Use-o apenas para peças quadradas.
• Wan2.7 Image custa mais por tentativa que os três acima, mas o preço fixo com até 9 referências ajuda pipelines com muita edição.
• Qwen Image 3.0 Pro e Seedream 5.0 Pro são os mais caros por tentativa e cobram adicional por referências. Eles só vencem no custo por imagem aceita quando seu piloto mostra que os modelos mais baratos precisam de muito mais tentativas para o seu caso, como pôsteres que exigem texto exato.

Um padrão razoável: um modelo padrão barato, uma reserva premium para os trabalhos em que o padrão falha repetidamente e uma revisão mensal dos preços de tabela e das suas proporções medidas.

Perguntas frequentes

Q.O que é custo por imagem aceita?

Custo por imagem aceita é o preço de tabela de uma tentativa multiplicado pelo número médio de tentativas necessárias para obter uma imagem que você mantém. Se um modelo custa 2.281 Credits por imagem e você aceita uma a cada 1,3, paga cerca de 2.965 Credits (US$ 0,0148) por imagem aceita.

Q.Tarefas de imagem que falham custam Credits na Orux AI?

Não. Tarefas de imagem só são cobradas quando terminam em SUCCESS; as que terminam em FAILED ou EXPIRED não são cobradas. Porém, uma imagem com sucesso que você rejeita é cobrada, e é por isso que as tentativas por imagem aceita importam.

Q.Qual destes seis modelos é o mais barato por imagem hoje?

Em 2026-11-04, o menor preço de tabela do grupo é o Nano Banana 2.1 em 1K, com 2.281 Credits (US$ 0,0114) por imagem. O flux-2-pro (2.67 Cr) e o GPT Image 2.5 Sunburst (2.667 Cr) vêm logo atrás; em 4K, o GPT Image 2.5 Sunburst e o Nano Banana 2.1 custam ambos 2.667 Credits.

Q.Posso trocar de modelo de imagem sem mudar o código?

Sim, se você mantiver o nome do modelo e seus limites de parâmetros na configuração. Todos os modelos aqui usam o mesmo fluxo POST /api/v1/tasks e GET /api/v1/tasks/{id}; só mudam a string model e as resoluções, proporções e números de referências permitidos.

Q.Quantas imagens de teste preciso para estimar as tentativas por imagem aceita?

Comece com um piloto de algumas dezenas de imagens por modelo usando seus prompts reais e continue registrando em produção. Um piloto pequeno dá uma proporção aproximada, e o registro do script acima a refina com o tempo.

Q.Quando vale a pena usar um modelo mais caro?

Um modelo mais caro vale a pena quando as tentativas medidas no modelo barato passam do ponto de equilíbrio. Tomando como referência o Seedream 5.0 Pro aceito de primeira, o ponto de equilíbrio é de cerca de 3,3 tentativas para o Nano Banana 2.1 e de cerca de 1,7 para o Wan2.7 Image.