Coût par image acceptée : budgéter les API d'images en comptant les tentatives

Le chiffre affiché sur la page d'un modèle est le prix d'une tentative. Ce que votre application paie réellement, c'est une image acceptée. Si un modèle bon marché a besoin de deux tentatives pour produire une image exploitable alors qu'un modèle un peu plus cher réussit du premier coup, le prix catalogue ne vous apprend presque rien. Ce guide montre comment budgéter la génération d'images au coût par image acceptée (cost per accepted image) avec les prix actuels de six modèles Orux AI, et comment les placer derrière un petit client asynchrone pour déplacer le trafic de l'un à l'autre sans réécrire votre application.

Tous les prix ci-dessous ont été relevés sur les pages modèles d'Orux AI le 2026-11-04. Plusieurs modèles sont moins chers que les chiffres de notre article tarifaire d'octobre : utilisez ce tableau plutôt que l'ancien. 1 Credit = 0,005 $.

Pourquoi le prix catalogue est la mauvaise unité

Les requêtes d'image sur Orux AI sont facturées par image générée avec succès. Une tâche qui se termine en FAILED ou EXPIRED n'est pas facturée. On a l'impression de ne payer que ce qui fonctionne, mais « succès » signifie que le modèle a renvoyé une image, pas que cette image convient à votre produit. Une image avec la mauvaise couleur de produit, un texte déformé ou une composition maladroite compte quand même comme un succès et consomme quand même des Credits.

La vraie formule budgétaire comporte donc deux éléments :

• Prix catalogue par tentative : visible sur la page du modèle.
• Tentatives par image acceptée : dépend de votre prompt, de vos critères de validation et du modèle, et c'est à vous de le mesurer.

Coût par image acceptée = prix catalogue × tentatives par image acceptée.

Si vous générez 100 images et en acceptez 77, vos tentatives par image acceptée valent 100 ÷ 77 ≈ 1,3. Ce ratio est le chiffre le plus important d'un budget image, et presque personne ne le suit.

Prix catalogue actuels (vérifiés le 2026-11-04)

Faites défiler horizontalement pour voir tout le tableau.

Comment le lire :

• Trois modèles se situent entre environ 2,3 et 2,7 Credits par image : Nano Banana 2.1, flux-2-pro et GPT Image 2.5 Sunburst. Wan2.7 Image est au milieu. Qwen Image 3.0 Pro et Seedream 5.0 Pro coûtent environ 2,5 à 3,3 fois plus en 1K, et encore le double en 2K.
• Les images de référence sont gratuites sur Nano Banana 2.1, GPT Image 2.5 Sunburst et Wan2.7 Image. Sur Qwen Image 3.0 Pro, une image 1K avec 3 références coûte 8.267 Cr (0,0413 $) ; sur Seedream 5.0 Pro, une image 1K avec 10 références coûte 12.5 Cr (0,0625 $). Si votre flux est surtout de l'édition, utilisez ces lignes et non le prix sans référence.
• flux-2-pro est bon marché mais contraint : sur Orux AI, il ne propose actuellement que la 1K et le 1:1, sans image de référence. Si vous avez besoin de bannières 16:9 ou d'édition, ce n'est pas une option, aussi bas soit son prix.

Exemple chiffré : coût par image acceptée

Les nombres de tentatives ci-dessous sont des hypothèses d'illustration, pas des mesures. Remplacez-les par vos propres chiffres après un pilote.

Faites défiler horizontalement pour voir tout le tableau.

La dernière colonne répond à la question pratique : combien de tentatives un modèle moins cher peut-il nécessiter avant que son coût par image acceptée égale celui de Seedream 5.0 Pro accepté à chaque fois du premier coup ? Environ 3,3 pour Nano Banana 2.1, environ 1,7 pour Wan2.7 Image.

Prenons un scénario concret. Supposons que votre pilote donne ceci :

• Modèle A : Nano Banana 2.1 en 1K a besoin de 1,3 tentative par photo produit acceptée.
• Modèle B : Seedream 5.0 Pro en 1K a besoin de 1,0.

Pour 1 000 images acceptées :

• Modèle A : 1 000 × 1,3 × 2.281 = 2 965 Credits (14,83 $)
• Modèle B : 1 000 × 1,0 × 7.5 = 7 500 Credits (37,50 $)

Même avec 30 % de tentatives en plus, le modèle A coûte nettement moins de la moitié. L'ordre ne s'inverse que si le ratio du modèle bon marché dépasse environ 3,3, ou si les images rejetées génèrent des coûts au-delà des Credits.

Ce dernier point compte. Chaque image rejetée prend du temps à vérifier, et dans une application grand public chaque nouvelle tentative ajoute de l'attente. Si une personne valide chaque résultat, le temps de revue peut peser bien plus que quelques Credits. Nous ne le chiffrons pas, car il varie d'une équipe à l'autre, mais le code ci-dessous enregistre les tentatives pour que vous puissiez l'ajouter vous-même.

Trois endroits où se cache le multiplicateur de tentatives

Les tentatives par image acceptée augmentent aussi pour des raisons sans rapport avec la qualité du modèle :

1. Soumissions en double. Si un worker expire pendant l'interrogation et resoumet la même tâche, vous pouvez payer deux succès. Enregistrez d'abord le task_id et reprenez l'interrogation au lieu de resoumettre.
2. Paramètres non pris en charge. Demander un format ou une résolution que le modèle ne propose pas est refusé avant la soumission. Cela ne coûte rien, mais bloque votre pipeline. Gardez les limites de chaque modèle dans la configuration (voir plus bas) pour que passer de GPT Image 2.5 Sunburst à flux-2-pro n'envoie pas discrètement du 16:9 à un modèle limité au 1:1.
3. Dérive du prompt. Un prompt réglé pour un modèle puis réutilisé tel quel sur un modèle moins cher peut faire baisser le taux d'acceptation. Refaites un pilote de chaque modèle avec vos propres prompts avant de déplacer du trafic réel.

Exemples publics existants des pages modèles

Les cinq images ci-dessous sont des exemples publics existants publiés sur les pages modèles d'Orux AI. Elles n'ont pas été générées pour cet article et ne constituent pas des tests de qualité. Elles montrent le type de résultat documenté par chaque page, avec le prompt et les réglages qui y sont indiqués.

*Exemple public existant de la page du modèle Nano Banana 2.1 : « Still alpine lake perfectly reflecting snow-capped peaks and pine trees at sunrise », 1K, 16:9. Prix catalogue pour ce réglage : 2.281 Credits.*

*Exemple public existant de la page du modèle flux-2-pro : photo produit minimaliste en studio d'un vase en céramique, 1K, 1:1 (la seule taille proposée actuellement). Prix catalogue : 2.67 Credits.*

*Exemple public existant de la page du modèle GPT Image 2.5 Sunburst : ville côtière futuriste au crépuscule, 1K, 16:9. Prix catalogue : 2.667 Credits quelle que soit la résolution.*

*Exemple public existant de la page du modèle Qwen Image 3.0 Pro : champ de lavande au coucher du soleil, 1K, 16:9. Prix catalogue : 6.667 Credits sans référence.*

*Exemple public existant de la page du modèle Seedream 5.0 Pro : aurore au-dessus d'une cabane enneigée, 1K, 16:9. Prix catalogue : 7.5 Credits sans référence.*

Notez que quatre des cinq sont en 1K et 16:9. C'est précisément le réglage avec lequel vous pouvez faire des tests A/B entre modèles avec un seul client. flux-2-pro ne peut pas entrer dans cette comparaison, car il ne produit que du 1:1.

Un seul client asynchrone, les modèles dans la configuration

Les six modèles utilisent le même endpoint asynchrone. Vous envoyez POST https://orux.top/api/v1/tasks avec model et un objet input, vous recevez un HTTP 202 avec un task_id, puis vous interrogez GET https://orux.top/api/v1/tasks/{id} jusqu'à ce que le statut soit SUCCESS, FAILED ou EXPIRED. D'un modèle à l'autre, seuls changent la chaîne model et les valeurs input autorisées : le choix du modèle doit donc vivre dans la configuration, pas dans le code.

Le script ci-dessous fait quatre choses : il valide la requête par rapport aux limites de chaque modèle, soumet et interroge, enregistre immédiatement le résultat (les liens de résultat sont temporaires) et écrit un journal des tentatives qui permet de calculer le coût par image acceptée pour chaque modèle. Créez une clé API, exportez-la sous le nom ORUX_API_KEY et installez 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()

Pour comparer deux modèles sur le même brief, lancez-le une fois avec ORUX_IMAGE_MODEL=nano-banana-2.1 et une fois avec ORUX_IMAGE_MODEL=gpt-image-2.5-sunburst, puis consultez le rapport. Le journal ne compte comme facturées que les images réussies, comme Orux AI ; les tâches FAILED et EXPIRED sont enregistrées à 0 Credit.

Remarques de conception :

• La table des prix est une estimation locale. Elle sert au budget, pas à la facturation. Les prix peuvent changer : revérifiez la page du modèle et mettez à jour les chiffres avant un gros lot.
• Les suppléments de référence de Qwen Image 3.0 Pro et Seedream 5.0 Pro ne sont volontairement pas modélisés. Si vous ajoutez image_urls sur ces modèles, consultez sur la page du modèle le prix selon le nombre de références.
• Interroger toutes les 5 secondes suffit. Les tâches d'image peuvent prendre plusieurs minutes : exécutez-les dans un worker en arrière-plan, pas dans une requête web.
• La validation manuelle est un exemple provisoire. En production, remplacez-la par des contrôles automatiques, une file de revue ou le pouce levé d'un utilisateur. L'essentiel est d'enregistrer chaque acceptation et chaque rejet.

Choisir un modèle par défaut et un modèle de secours

Une fois vos ratios réels connus, le choix relève surtout de l'arithmétique. Les compromis honnêtes, d'après les pages modèles :

• Nano Banana 2.1 a le prix catalogue 1K le plus bas du groupe, des références gratuites et le plus grand choix de formats. C'est un bon choix par défaut pour des brouillons en volume.
• GPT Image 2.5 Sunburst coûte 2.667 Credits en 1K, 2K et 4K : c'est le moyen le moins cher du groupe d'obtenir de la 4K. Il accepte jusqu'à 16 références.
• flux-2-pro est dans la même gamme de prix, mais en texte seul, 1K et 1:1. Réservez-le aux visuels carrés.
• Wan2.7 Image coûte plus cher par tentative que les trois précédents, mais son prix fixe jusqu'à 9 références aide les pipelines riches en édition.
• Qwen Image 3.0 Pro et Seedream 5.0 Pro sont les plus chers par tentative et facturent un supplément pour les références. Ils ne l'emportent au coût par image acceptée que si votre pilote montre que les modèles moins chers exigent beaucoup plus de tentatives pour votre usage, par exemple des affiches au texte exact.

Un schéma raisonnable : un modèle par défaut bon marché, un modèle premium de secours pour les tâches où le premier échoue sans cesse, et une revue mensuelle des prix catalogue et de vos ratios mesurés.

FAQ

Q.Qu'est-ce que le coût par image acceptée ?

Le coût par image acceptée est le prix catalogue d'une tentative multiplié par le nombre moyen de tentatives nécessaires pour obtenir une image que vous gardez. Si un modèle coûte 2.281 Credits par image et que vous en acceptez une sur 1,3, vous payez environ 2.965 Credits (0,0148 $) par image acceptée.

Q.Les tâches d'image échouées coûtent-elles des Credits sur Orux AI ?

Non. Les tâches d'image ne sont facturées que lorsqu'elles se terminent en SUCCESS ; celles qui se terminent en FAILED ou EXPIRED ne sont pas facturées. En revanche, une image réussie que vous rejetez est facturée, et c'est pourquoi les tentatives par image acceptée comptent.

Q.Lequel de ces six modèles est actuellement le moins cher par image ?

Au 2026-11-04, le prix catalogue le plus bas du groupe est Nano Banana 2.1 en 1K, à 2.281 Credits (0,0114 $) par image. flux-2-pro (2.67 Cr) et GPT Image 2.5 Sunburst (2.667 Cr) suivent de très près ; en 4K, GPT Image 2.5 Sunburst et Nano Banana 2.1 coûtent tous deux 2.667 Credits.

Q.Puis-je changer de modèle d'image sans modifier le code ?

Oui, si vous gardez le nom du modèle et ses limites de paramètres dans la configuration. Tous les modèles présentés utilisent le même flux POST /api/v1/tasks et GET /api/v1/tasks/{id} ; seuls changent la chaîne model et les résolutions, formats et nombres de références autorisés.

Q.Combien d'images de test faut-il pour estimer les tentatives par image acceptée ?

Commencez par un pilote de quelques dizaines d'images par modèle avec vos vrais prompts, puis continuez à enregistrer en production. Un petit pilote donne un ratio approximatif, et le journal du script ci-dessus l'affine au fil du temps.

Q.Quand un modèle plus cher en vaut-il la peine ?

Un modèle plus cher en vaut la peine quand les tentatives mesurées sur le modèle bon marché dépassent le seuil de rentabilité. Par rapport à Seedream 5.0 Pro accepté du premier coup, ce seuil est d'environ 3,3 tentatives pour Nano Banana 2.1 et d'environ 1,7 pour Wan2.7 Image.