Kosten pro akzeptiertem Bild: Bild-APIs inklusive Wiederholungen budgetieren

Die Zahl auf der Seite eines Modells ist der Preis für einen Versuch. Was Ihre Anwendung tatsächlich bezahlt, ist ein akzeptiertes Bild. Wenn ein günstiges Modell zwei Versuche für ein brauchbares Bild braucht und ein etwas teureres es beim ersten Mal trifft, sagt der Listenpreis fast nichts aus. Dieser Leitfaden zeigt, wie Sie Bildgenerierung nach Kosten pro akzeptiertem Bild (cost per accepted image) budgetieren – mit den aktuellen Preisen von sechs Orux AI Modellen – und wie Sie diese Modelle hinter einen kleinen asynchronen Client stellen, um Traffic zwischen ihnen zu verschieben, ohne Ihre Anwendung umzuschreiben.

Alle Preise unten wurden am 2026-11-04 auf den Orux AI Modellseiten abgelesen. Mehrere Modelle sind günstiger als die Zahlen in unserem Preisartikel vom Oktober. Verwenden Sie also diese Tabelle statt der älteren. 1 Credit = 0,005 $.

Warum der Listenpreis die falsche Einheit ist

Bildanfragen auf Orux AI werden pro erfolgreich erzeugtem Bild abgerechnet. Eine Aufgabe, die mit FAILED oder EXPIRED endet, wird nicht berechnet. Das klingt, als zahle man nur für das, was funktioniert. Doch „Erfolg“ bedeutet, dass das Modell ein Bild zurückgegeben hat, nicht dass das Bild zu Ihrem Produkt passt. Ein Bild mit falscher Produktfarbe, verzerrtem Text oder ungeschickter Komposition zählt trotzdem als Erfolg und verbraucht trotzdem Credits.

Die echte Budgetformel hat deshalb zwei Teile:

• Listenpreis pro Versuch: steht auf der Modellseite.
• Versuche pro akzeptiertem Bild: hängt von Prompt, Prüfkriterien und Modell ab und muss von Ihnen gemessen werden.

Kosten pro akzeptiertem Bild = Listenpreis × Versuche pro akzeptiertem Bild.

Wenn Sie 100 Bilder erzeugen und 77 akzeptieren, liegen Ihre Versuche pro akzeptiertem Bild bei 100 ÷ 77 ≈ 1,3. Dieses Verhältnis ist die wichtigste Zahl in einem Bildbudget, und fast niemand erfasst sie.

Aktuelle Listenpreise (geprüft am 2026-11-04)

Horizontal wischen, um die ganze Tabelle zu sehen.

So lesen Sie die Tabelle:

• Drei Modelle liegen bei etwa 2,3 bis 2,7 Credits pro Bild: Nano Banana 2.1, flux-2-pro und GPT Image 2.5 Sunburst. Wan2.7 Image liegt in der Mitte. Qwen Image 3.0 Pro und Seedream 5.0 Pro kosten bei 1K etwa das 2,5- bis 3,3-Fache und bei 2K noch einmal doppelt so viel.
• Referenzbilder sind bei Nano Banana 2.1, GPT Image 2.5 Sunburst und Wan2.7 Image kostenlos. Bei Qwen Image 3.0 Pro kostet ein 1K-Bild mit 3 Referenzen 8.267 Cr (0,0413 $); bei Seedream 5.0 Pro kostet ein 1K-Bild mit 10 Referenzen 12.5 Cr (0,0625 $). Wenn Ihr Workflow überwiegend aus Bearbeitung besteht, verwenden Sie diese Zeilen und nicht den Preis ohne Referenz.
• flux-2-pro ist günstig, aber eingeschränkt: Auf Orux AI bietet es derzeit nur 1K und 1:1, ohne Referenzbilder. Wenn Sie 16:9-Banner oder Bearbeitung brauchen, ist es keine Option, egal wie günstig.

Rechenbeispiel: Kosten pro akzeptiertem Bild

Die Versuchszahlen unten sind Annahmen zur Veranschaulichung, keine Messwerte. Ersetzen Sie sie nach einem Pilotlauf durch Ihre eigenen Zahlen.

Horizontal wischen, um die ganze Tabelle zu sehen.

Die letzte Spalte beantwortet die praktische Frage: Wie viele Versuche darf ein günstigeres Modell brauchen, bis seine Kosten pro akzeptiertem Bild denen von Seedream 5.0 Pro entsprechen, das jedes Mal beim ersten Versuch akzeptiert wird? Bei Nano Banana 2.1 sind es etwa 3,3, bei Wan2.7 Image etwa 1,7.

Ein konkretes Szenario. Angenommen, Ihr Pilot ergibt Folgendes:

• Modell A: Nano Banana 2.1 bei 1K braucht 1,3 Versuche pro akzeptiertem Produktfoto.
• Modell B: Seedream 5.0 Pro bei 1K braucht 1,0.

Für 1.000 akzeptierte Bilder:

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

Selbst mit 30 % mehr Versuchen kostet Modell A deutlich weniger als die Hälfte. Die Reihenfolge kehrt sich nur um, wenn das Verhältnis des günstigen Modells über etwa 3,3 steigt oder abgelehnte Bilder Kosten jenseits der Credits verursachen.

Der zweite Punkt ist wichtig. Jedes abgelehnte Bild kostet Prüfzeit, und in einer nutzerseitigen Anwendung verlängert jeder Wiederholungsversuch die Wartezeit. Wenn ein Mensch jedes Ergebnis prüft, kann die Prüfzeit weit mehr wiegen als ein paar Credits. Wir beziffern sie nicht, weil sie je nach Team schwankt, aber der Code unten protokolliert die Versuche, sodass Sie sie selbst einrechnen können.

Drei Stellen, an denen sich der Wiederholungsfaktor versteckt

Die Versuche pro akzeptiertem Bild steigen auch aus Gründen, die nichts mit der Modellqualität zu tun haben:

1. Doppelte Einreichungen. Wenn ein Worker beim Polling in ein Timeout läuft und denselben Auftrag erneut einreicht, zahlen Sie womöglich zwei Erfolge. Speichern Sie zuerst die task_id und setzen Sie das Polling fort, statt neu einzureichen.
2. Nicht unterstützte Parameter. Ein Seitenverhältnis oder eine Auflösung, die das Modell nicht anbietet, wird vor dem Einreichen abgelehnt. Das kostet nichts, hält aber Ihre Pipeline auf. Halten Sie die Grenzen jedes Modells in der Konfiguration fest (siehe unten), damit ein Wechsel von GPT Image 2.5 Sunburst zu flux-2-pro nicht unbemerkt 16:9 an ein reines 1:1-Modell schickt.
3. Prompt-Drift. Ein für ein Modell abgestimmter Prompt, der unverändert bei einem günstigeren Modell verwendet wird, kann die Akzeptanzrate senken. Testen Sie jedes Modell mit Ihren eigenen Prompts erneut, bevor Sie echten Traffic verschieben.

Bestehende öffentliche Beispiele von den Modellseiten

Die fünf Bilder unten sind bestehende öffentliche Beispiele, die auf den Orux AI Modellseiten veröffentlicht sind. Sie wurden nicht für diesen Artikel erzeugt und sind keine Qualitätstests. Sie zeigen die Art von Ergebnis, die jede Modellseite dokumentiert, mit dem dort angegebenen Prompt und den dort angegebenen Einstellungen.

*Bestehendes öffentliches Beispiel von der Modellseite von Nano Banana 2.1: „Still alpine lake perfectly reflecting snow-capped peaks and pine trees at sunrise“, 1K, 16:9. Listenpreis für diese Einstellung: 2.281 Credits.*

*Bestehendes öffentliches Beispiel von der Modellseite von flux-2-pro: minimalistisches Studio-Produktfoto einer Keramikvase, 1K, 1:1 (die einzige derzeit angebotene Größe). Listenpreis: 2.67 Credits.*

*Bestehendes öffentliches Beispiel von der Modellseite von GPT Image 2.5 Sunburst: futuristische Küstenstadt in der Abenddämmerung, 1K, 16:9. Listenpreis: 2.667 Credits bei jeder Auflösung.*

*Bestehendes öffentliches Beispiel von der Modellseite von Qwen Image 3.0 Pro: Lavendelfeld bei Sonnenuntergang, 1K, 16:9. Listenpreis: 6.667 Credits ohne Referenz.*

*Bestehendes öffentliches Beispiel von der Modellseite von Seedream 5.0 Pro: Polarlicht über einer verschneiten Hütte, 1K, 16:9. Listenpreis: 7.5 Credits ohne Referenz.*

Beachten Sie, dass vier der fünf Bilder 1K und 16:9 sind. Genau mit dieser Einstellung können Sie Modelle mit einem einzigen Client per A/B-Test vergleichen. flux-2-pro kann an diesem Vergleich nicht teilnehmen, weil es nur 1:1 ausgibt.

Ein asynchroner Client, Modelle in der Konfiguration

Alle sechs Modelle nutzen denselben asynchronen Endpoint. Sie senden POST https://orux.top/api/v1/tasks mit model und einem input-Objekt, erhalten HTTP 202 mit einer task_id und pollen dann GET https://orux.top/api/v1/tasks/{id}, bis der Status SUCCESS, FAILED oder EXPIRED ist. Zwischen den Modellen ändern sich nur der model-String und die erlaubten input-Werte. Die Modellwahl gehört deshalb in die Konfiguration, nicht in den Code.

Das Skript unten erledigt vier Dinge: Es prüft die Anfrage gegen die Grenzen jedes Modells, reicht ein und pollt, speichert das Ergebnis sofort (Ergebnislinks sind temporär) und schreibt ein Versuchsprotokoll, aus dem Sie die Kosten pro akzeptiertem Bild je Modell berechnen können. Erstellen Sie einen API Key, exportieren Sie ihn als ORUX_API_KEY und installieren Sie 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()

Um zwei Modelle mit demselben Auftrag zu vergleichen, führen Sie das Skript einmal mit ORUX_IMAGE_MODEL=nano-banana-2.1 und einmal mit ORUX_IMAGE_MODEL=gpt-image-2.5-sunburst aus und prüfen den Bericht. Das Protokoll zählt nur erfolgreiche Bilder als abgerechnet, genau wie Orux AI abrechnet; FAILED- und EXPIRED-Aufgaben werden mit 0 Credits erfasst.

Hinweise zum Design:

• Die Preistabelle ist eine lokale Schätzung. Sie dient der Budgetierung, nicht der Abrechnung. Preise können sich ändern. Prüfen Sie daher vor einem großen Lauf die Modellseite und aktualisieren Sie die Zahlen.
• Die Referenzaufpreise von Qwen Image 3.0 Pro und Seedream 5.0 Pro sind bewusst nicht modelliert. Wenn Sie bei diesen Modellen image_urls hinzufügen, prüfen Sie auf der Modellseite den Preis je Anzahl der Referenzen.
• Polling alle 5 Sekunden reicht aus. Bildaufgaben können Minuten dauern. Führen Sie sie daher in einem Hintergrund-Worker aus, nicht innerhalb einer Web-Anfrage.
• Die manuelle Abnahme ist ein Platzhalter. In der Produktion lässt sie sich durch automatische Prüfungen, eine Prüfwarteschlange oder ein Daumen-hoch des Nutzers ersetzen. Wichtig ist, jede Annahme und jede Ablehnung zu protokollieren.

Standard- und Ausweichmodell wählen

Sobald Sie Ihre tatsächlichen Versuchsverhältnisse kennen, ist die Wahl größtenteils Rechnen. Ehrliche Abwägungen auf Basis der Modellseiten:

• Nano Banana 2.1 hat den niedrigsten 1K-Listenpreis der Gruppe, kostenlose Referenzen und die größte Auswahl an Seitenverhältnissen. Ein vernünftiges Standardmodell für Entwürfe in großer Menge.
• GPT Image 2.5 Sunburst kostet bei 1K, 2K und 4K jeweils 2.667 Credits und ist damit der günstigste Weg zu 4K in dieser Gruppe. Es akzeptiert bis zu 16 Referenzen.
• flux-2-pro liegt in derselben Preisklasse, ist aber nur Text, 1K und 1:1. Verwenden Sie es nur für quadratische Motive.
• Wan2.7 Image kostet pro Versuch mehr als die drei oben, aber der Pauschalpreis mit bis zu 9 Referenzen hilft bearbeitungslastigen Pipelines.
• Qwen Image 3.0 Pro und Seedream 5.0 Pro sind pro Versuch am teuersten und berechnen Aufpreise für Referenzen. Sie gewinnen bei den Kosten pro akzeptiertem Bild nur, wenn Ihr Pilot zeigt, dass die günstigeren Modelle für Ihren Anwendungsfall deutlich mehr Wiederholungen brauchen, etwa bei Postern mit exaktem Text.

Ein sinnvolles Muster: ein günstiges Standardmodell, ein Premium-Ausweichmodell für Aufträge, bei denen das Standardmodell immer wieder scheitert, und eine monatliche Überprüfung von Listenpreisen und gemessenen Verhältnissen.

FAQ

Q.Was sind die Kosten pro akzeptiertem Bild?

Die Kosten pro akzeptiertem Bild sind der Listenpreis eines Versuchs multipliziert mit der durchschnittlichen Zahl von Versuchen, die Sie für ein Bild brauchen, das Sie behalten. Kostet ein Modell 2.281 Credits pro Bild und akzeptieren Sie eines von 1,3, zahlen Sie etwa 2.965 Credits (0,0148 $) pro akzeptiertem Bild.

Q.Kosten fehlgeschlagene Bildaufgaben auf Orux AI Credits?

Nein. Bildaufgaben werden nur abgerechnet, wenn sie mit SUCCESS enden; Aufgaben, die mit FAILED oder EXPIRED enden, werden nicht berechnet. Ein erfolgreiches Bild, das Sie ablehnen, wird jedoch abgerechnet – deshalb zählen die Versuche pro akzeptiertem Bild.

Q.Welches dieser sechs Modelle ist derzeit pro Bild am günstigsten?

Stand 2026-11-04 hat Nano Banana 2.1 bei 1K mit 2.281 Credits (0,0114 $) pro Bild den niedrigsten Listenpreis der Gruppe. flux-2-pro (2.67 Cr) und GPT Image 2.5 Sunburst (2.667 Cr) folgen knapp dahinter; bei 4K kosten GPT Image 2.5 Sunburst und Nano Banana 2.1 beide 2.667 Credits.

Q.Kann ich das Bildmodell wechseln, ohne den Code zu ändern?

Ja, wenn Sie den Modellnamen und seine Parametergrenzen in der Konfiguration halten. Alle Modelle hier nutzen denselben Ablauf mit POST /api/v1/tasks und GET /api/v1/tasks/{id}; es ändern sich nur der model-String sowie die erlaubten Auflösungen, Seitenverhältnisse und Referenzanzahlen.

Q.Wie viele Testbilder brauche ich, um die Versuche pro akzeptiertem Bild zu schätzen?

Beginnen Sie mit einem Pilot von einigen Dutzend Bildern pro Modell mit Ihren echten Prompts und protokollieren Sie danach in der Produktion weiter. Ein kleiner Pilot liefert ein grobes Verhältnis, und das Protokoll des Skripts oben verfeinert es mit der Zeit.

Q.Wann lohnt sich ein teureres Modell?

Ein teureres Modell lohnt sich, wenn die gemessenen Wiederholungen beim günstigen Modell die Gewinnschwelle überschreiten. Gemessen an Seedream 5.0 Pro, das beim ersten Versuch akzeptiert wird, liegt die Schwelle bei etwa 3,3 Versuchen für Nano Banana 2.1 und bei etwa 1,7 für Wan2.7 Image.