Mehrere Bilder gleichzeitig in ChatGPT generieren

Das haben Sie am Ende

Sie beginnen mit zwei Dateien:

• products.csv: eine tabellenähnliche Liste der Produkte, die Sie verarbeiten möchten.

• bulk_product_images.py: das Python-Skript aus dieser Anleitung.

Beim Ausführen des Skripts werden automatisch zwei weitere Elemente erstellt:

• generated/: ein Ordner mit Dateien wie MUG-001-01.png.

• manifest.json: ein Protokoll, das zeigt, welche Produkte verarbeitet wurden, fehlgeschlagen sind oder noch überprüft werden müssen.

Der Ablauf ist einfach:

products.csv → Python-Skript → GPT Image 2 API → heruntergeladene Bilder
                         ↘ manifest.json

Beginnen Sie mit den drei Beispielprodukten in dieser Anleitung. Sobald alles funktioniert, ersetzen Sie die Beispielzeilen durch Ihren echten Produktkatalog.

Begriffe für Einsteiger in dieser Anleitung

Der API-Ablauf ähnelt dem Abholen einer Restaurantbestellung. Mit der ersten Anfrage geben Sie die Bestellung auf. Die zurückgegebene Aufgaben-ID ist Ihre Abholnummer. Durch Abfragen prüfen Sie, ob die Bestellung fertig ist. Unter der Ausgabe-URL können Sie das fertige Produkt abrufen. Das Manifest ist Ihr Quittungsbuch.

Kann ChatGPT mehrere Produktbilder auf einmal generieren?

ChatGPT kann im Laufe eines Gesprächs mehrere Bilder erstellen und eignet sich daher gut, um Ideen visuell auszuloten und eine kleine Anzahl manueller Variationen zu erstellen. Als zuverlässige Pipeline für einen Produktkatalog ist es jedoch nicht geeignet: Es gibt keine CSV-Warteschlange, keine stabile Zuordnung von SKUs zu Dateien, keine Parallelitätssteuerung und kein Wiederholungsmanifest.

Die API ist besser geeignet, wenn Sie wissen möchten: „Wie erstelle ich mehrere Produktbilder und erkenne, welche Datei zu welchem Produkt gehört?“

Suchanfragen wie „ChatGPT generate multiple images at once“ vermischen oft zwei unterschiedliche Ziele: mehrere Variationen eines Prompts und viele Bilder für verschiedene Produkte. Diese Unterscheidung ist wichtig, sobald Kosten, Dateizuordnung und erneute Durchläufe ins Spiel kommen.

Was mit „GPT Image 2 API Batch“ gemeint sein kann

Mit „Batch“ sind meist drei unterschiedliche Abläufe gemeint:

1. Mehrere Variationen aus einem Prompt

Legen Sie n auf einen Wert zwischen 1 und 10 fest. Das ist nützlich, wenn ein Designer mehrere Optionen für dasselbe Produkt und dieselbe Komposition haben möchte. Dadurch werden jedoch keine produktspezifischen Prompts für zehn SKUs erstellt.

2. Mehrere unabhängige Anfragen gleichzeitig

Lesen Sie mehrere Produkte aus einer Datei ein und senden Sie pro Zeile eine Anfrage. Ein kleiner ThreadPoolExecutor ermöglicht kontrollierte Parallelität. Diesen Ablauf verwenden wir in dieser Anleitung, da jedes Produkt einen eigenen Namen, eine eigene Farbe, ein eigenes Material sowie einen eigenen Winkel und Hintergrund haben kann.

3. Die asynchrone Batch API von OpenAI

Die direkte Batch API von OpenAI akzeptiert JSONL-Anfragedateien, verwendet einen separaten Ratenbegrenzungs-Pool, bietet 50 % Rabatt und wird innerhalb eines Zeitfensters von 24 Stunden abgeschlossen. Im Leitfaden zur OpenAI Batch API werden /v1/images/generations und /v1/images/edits als unterstützte Endpunkte aufgeführt.

Das ist eine separate OpenAI-Funktion. Gehen Sie nicht davon aus, dass es denselben JSONL-Batch-Endpunkt auch bei GPT Proto gibt. Der folgende GPT Proto-Workflow verwendet den dokumentierten Bild-Endpunkt und die Route für den Vorhersagestatus.

Was Sie benötigen

Sie benötigen einen Computer, Python 3, einen GPT Proto-API-Schlüssel und einen Texteditor. Visual Studio Code ist praktisch, aber jeder Editor, der reine Textdateien speichern kann, ist geeignet.

1. Prüfen, ob Python installiert ist

Öffnen Sie unter macOS oder Linux das Terminal oder unter Windows PowerShell und führen Sie Folgendes aus:

python --version

Wenn Windows meldet, dass python nicht erkannt wird, versuchen Sie Folgendes:

py --version

Ein Ergebnis wie Python 3.11.8 bedeutet, dass Python einsatzbereit ist. Wenn keiner der Befehle funktioniert, installieren Sie eine aktuelle Python-3-Version und aktivieren Sie die Option, Python zum Systempfad hinzuzufügen.

2. Projektordner erstellen

Erstellen Sie einen Ordner mit dem Namen gpt-image-bulk. Erstellen Sie darin diese zwei leeren Dateien:

• bulk_product_images.py

• products.csv

Fügen Sie das vollständige Python-Skript aus dieser Anleitung in die erste Datei ein. Fügen Sie die unten gezeigte Beispiel-CSV in die zweite Datei ein. Beide Dateien müssen sich im selben Ordner befinden, sofern Sie die Pfade im Skript nicht ändern.

3. API-Schlüssel erstellen und speichern

Erstellen Sie ein Konto bei GPT Proto, laden Sie Guthaben auf und generieren Sie einen API-Schlüssel. Behandeln Sie den API-Schlüssel wie ein Passwort. Veröffentlichen Sie ihn nicht in einem Artikel, laden Sie ihn nicht auf GitHub hoch und fügen Sie ihn nicht direkt in die Python-Datei ein.

Speichern Sie den Schlüssel vorübergehend in einer Umgebungsvariablen. Führen Sie unter macOS oder Linux Folgendes aus:

export GPTPROTO_API_KEY="your-key-here"

Führen Sie in der Windows-PowerShell Folgendes aus:

$env:GPTPROTO_API_KEY="your-key-here"

Die Variable bleibt normalerweise bis zum Schließen des aktuellen Terminalfensters bestehen. Wenn Sie das Fenster schließen und ein neues öffnen, müssen Sie sie vor dem Ausführen des Skripts erneut festlegen.

4. Das einzige benötigte Python-Paket installieren

Das Skript verwendet requests, um mit der API zu kommunizieren und Bilder herunterzuladen. Installieren Sie das Paket mit:

python -m pip install requests

Windows-Nutzer, die den Befehl py benötigen, sollten stattdessen py -m pip install requests ausführen.

5. Produkte zur CSV-Datei hinzufügen

CSV bedeutet „Comma-Separated Values“ (durch Kommas getrennte Werte). Es handelt sich um ein einfaches Tabellenformat, das Excel, Google Sheets und die meisten Katalogtools exportieren können. Fügen Sie pro Zeile ein Produkt hinzu:

Erstellen Sie products.csv mit einer Zeile pro Produkt:

sku,name,color,material,angle,background,avoid
MUG-001,Stackable coffee mug,matte navy,stoneware,three-quarter,soft warm gray,steam or hands
BAG-014,Compact crossbody bag,forest green,pebbled leather,front three-quarter,light beige,props or a model
LAMP-207,Portable table lamp,cream,powder-coated aluminum,front,clean white,visible cable or extra objects

Jede Spalte hat eine Aufgabe:

Behalten Sie die Kopfzeile genau wie gezeigt bei, da das Python-Skript nach diesen Spaltennamen sucht. Jede SKU muss eindeutig sein. Wenn ein Produktname oder ein Feld ein Komma enthält, exportieren Sie die Datei aus einem Tabellenprogramm, damit der Wert korrekt in Anführungszeichen gesetzt wird.

Verwenden Sie kurze, sachliche Angaben, statt in jeder Zeile einen anderen langen Prompt zu verfassen. Das Skript kombiniert die Felder mit denselben Fotoregeln, sodass der Katalog ein einheitliches Erscheinungsbild erhält.

Schritt 1: Einen wiederverwendbaren Produkt-Prompt erstellen

Ein Produkt-Prompt sollte veränderliche Angaben zur SKU von Regeln trennen, die für den gesamten Katalog gelten. So lassen sich Änderungen am Prompt zuverlässig bewerten: Ändern Sie die gemeinsame Vorlage einmal, erstellen Sie einen kleinen Testsatz neu und vergleichen Sie ihn mit der vorherigen Version.

def build_prompt(row):
    return f"""Create one catalog product photograph.
Product: {row['name']}
Color: {row['color']}
Material: {row['material']}
View: {row['angle']}
Background: {row['background']}

Keep the product centered with realistic proportions and material texture.
Use soft studio lighting, a natural contact shadow, and generous crop-safe space.
No text, logos, labels, people, or extra objects.
Also avoid: {row.get('avoid', 'none')}.
Return a single product image, not a collage or contact sheet."""

Sie müssen diese Funktion nicht für jedes Produkt bearbeiten. Wenn das Skript die Tassenzeile einliest, wird aus {row['name']} der Wert Stackable coffee mug; beim Einlesen der Taschenzeile wird derselbe Platzhalter zu Compact crossbody bag. Das nennt man eine Vorlage: Die Struktur bleibt gleich, während sich die Produktdaten ändern.

Die Anweisung „ein einzelnes Produktbild“ hilft zu verhindern, dass ein Modell aus einer Anfrage eine Collage macht. Die gemeinsamen Vorgaben zu Kameraperspektive, Bildausschnitt, Beleuchtung, Schatten und Hintergrund sorgen dafür, dass die Produkte wie ein einheitlicher Katalog und nicht wie zusammenhanglose Bilder wirken.

Wenn die ersten Ergebnisse uneinheitlich sind, bearbeiten Sie zuerst die gemeinsamen Regeln. Ersetzen Sie beispielsweise „großzügiger, für den Bildzuschnitt geeigneter Freiraum“ durch „das Produkt sollte etwa 75 % der quadratischen Bildfläche ausfüllen“. Testen Sie diese Änderung mit drei unterschiedlichen Produkttypen, bevor Sie sie auf die gesamte Datei anwenden.

Bei echten Markenprodukten eignet sich Text-zu-Bild am besten für Konzeptaufnahmen oder allgemeine Waren. Wenn exakte Geometrie, Verpackung oder Etikettenposition wichtig sind, verwenden Sie die Bildbearbeitung mit freigegebenen Produktreferenzen. Dieser Ablauf wird später beschrieben.

Schritt 2: Ein Produkt testen, bevor Sie die Warteschlange starten

Beginnen Sie mit einem Produkt, n=1, quality="low" und einer gängigen Größe wie 1024x1024. Eine niedrige Qualität eignet sich, um die Komposition zu prüfen, bevor Sie für Generierungen in endgültiger Qualität bezahlen.

Der folgende cURL-Befehl ist ein kleiner API-Test. cURL ist ein Befehlszeilentool, das eine Webanfrage sendet. Dieser genaue Befehl verwendet Bash-Syntax. Fügen Sie ihn nach dem Festlegen Ihres API-Schlüssels in das Terminal unter macOS oder Linux ein. Einsteiger unter Windows können den manuellen cURL-Test überspringen und später in dieser Anleitung das plattformübergreifende Python-Skript verwenden.

curl --request POST \
  --url "https://gptproto.com/api/v3/openai/gpt-image-2/text-to-image" \
  --header "Authorization: Bearer $GPTPROTO_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "prompt": "A centered matte navy stoneware coffee mug, three-quarter catalog view, soft studio light, warm gray background, natural contact shadow, no text or props",
    "n": 1,
    "quality": "low",
    "size": "1024x1024",
    "enable_sync_mode": false,
    "response_format": "url"
  }'

Hier erfahren Sie, was die wichtigsten Zeilen bedeuten:

Eine erfolgreiche erste Antwort ist ein JSON-Objekt mit einer Prediction-ID in data.id. JSON ist ein strukturiertes Textformat, das von APIs verwendet wird. Es kann etwa so aussehen:

{
  "data": {
    "id": "abc123",
    "status": "created",
    "urls": {
      "get": "https://gptproto.com/api/v3/predictions/abc123/result"
    }
  }
}

Diese Antwort ist nicht das Bild. Sie bestätigt, dass der Auftrag angenommen wurde. Kopieren Sie die tatsächlich zurückgegebene ID und fragen Sie das Ergebnis ab:

curl --request GET \
  --url "https://gptproto.com/api/v3/predictions/abc123/result" \
  --header "Authorization: Bearer $GPTPROTO_API_KEY"

Ersetzen Sie abc123 durch Ihre Aufgaben-ID. Wenn data.status noch created oder processing lautet, warten Sie einige Sekunden und führen Sie den GET-Befehl erneut aus. Sobald der Status completed lautet, enthält data.outputs die generierte Ausgabe. Das vollständige Python-Skript führt diese Prüfungen automatisch aus. Sie müssen diesen manuellen Ablauf also nicht für jedes Produkt wiederholen.

Die aktuellen Anfrage- und Antwortfelder finden Sie in der GPT Proto-Referenz für GPT Image 2 Text-zu-Bild.

Starten Sie die Generierung für den gesamten Katalog erst, wenn ein Produkt diese Prüfungen besteht:

• Der Bildausschnitt lässt genügend Platz für alle Verwendungszwecke im Shop.

• Farbe und Material stimmen für den vorgesehenen Verwendungszweck ausreichend genau.

• Hintergrund und Kontaktschatten passen zum Katalogstil.

• Es erscheinen keine erfundenen Logos, Etiketten, Requisiten oder doppelten Produkte.

• Die Ergebnisroute und der Download-Code funktionieren beide in Ihrer Umgebung.

Wenn der Test 401 Unauthorized zurückgibt, prüfen Sie zuerst den API-Schlüssel und den Authorization-Header. Bei einer Antwort mit 403 prüfen Sie den Modellzugriff und das Kontoguthaben. Fahren Sie erst mit dem gesamten Katalog fort, wenn dieser Test mit einem einzelnen Produkt erfolgreich war.

Schritt 3: Fehler „Size Must Be a Multiple of 16“ vermeiden

GPT Image 2 unterstützt gängige Voreinstellungen und gültige benutzerdefinierte Abmessungen. Bei benutzerdefinierten Größen müssen beide Kanten durch 16 teilbar sein, die längste Kante darf 3.840 Pixel nicht überschreiten, das Seitenverhältnis darf höchstens 3:1 betragen und das Bild muss zwischen 655.360 und 8.294.400 Pixel enthalten. Ausgaben mit einer Gesamtauflösung über 2560×1440 sind in der API-Dokumentation als experimentell gekennzeichnet.

„Beide Kanten müssen durch 16 teilbar sein“ bedeutet, dass sowohl Breite als auch Höhe ohne Rest durch 16 teilbar sein müssen. Zahlen wie 1024, 1200, 1536 und 2048 erfüllen diese Bedingung. 1000 dagegen nicht. Die Regel gilt sowohl für die Breite als auch für die Höhe, nicht nur für die längste Seite.

Validieren Sie die Größe, bevor Sie eine kostenpflichtige Anfrage senden:

def validate_size(size):
    if size == "auto":
        return

    width, height = map(int, size.lower().split("x"))
    pixels = width * height

    if width % 16 or height % 16:
        raise ValueError("GPT Image 2 width and height must be multiples of 16")
    if max(width, height) > 3840:
        raise ValueError("The longest edge cannot exceed 3840 pixels")
    if max(width, height) / min(width, height) > 3:
        raise ValueError("Aspect ratio cannot exceed 3:1")
    if not 655_360 <= pixels <= 8_294_400:
        raise ValueError("Total pixels are outside the supported range")

1200x1200 ist gültig, da beide Seiten durch 16 teilbar sind. 1000x1000 ist es nicht. Wenn Ihr Shop am Ende 1000x1000 benötigt, generieren Sie das Bild mit 1024x1024 und ändern Sie die Größe nach der Freigabe.

Zu den unterstützten Voreinstellungen zählen 1024x1024, 1536x1024, 1024x1536, 2048x2048, 2048x1152, 3840x2160 und 2160x3840.

Schritt 4: Kontrollierte Parallelität statt einer unbegrenzten Schleife verwenden

Parallelität bezeichnet die Anzahl der Produkte, an denen das Skript gleichzeitig arbeitet. Stellen Sie sich die Worker wie Kassen vor: Ein Worker verarbeitet jeweils ein aktives Produkt, drei Worker können bis zu drei Produkte gleichzeitig durch das System schleusen.

Eine Schleife, die Hunderte Worker startet, kann Ratenbegrenzungen auslösen, Speicher verbrauchen und die Fehlerbehebung erschweren. Beginnen Sie mit zwei oder drei. Erhöhen Sie den Wert erst, nachdem Sie das Verhalten des Kontos und die Bearbeitungszeiten geprüft haben.

from concurrent.futures import ThreadPoolExecutor, as_completed

with ThreadPoolExecutor(max_workers=3) as pool:
    futures = [pool.submit(process_product, row) for row in products]
    for future in as_completed(futures):
        print(future.result())

Sie müssen Python-Threads nicht verstehen, um dieses Beispiel zu verwenden. max_workers=3 ist die wichtige Einstellung. Wenn wiederholt 429-Fehler auftreten, reduzieren Sie den Wert auf 2 oder 1. Wenn ein längerer Test ohne Ratenbegrenzungsfehler läuft, können Sie vorsichtig einen höheren Wert ausprobieren.

Die veröffentlichten Ratenbegrenzungen des Modellanbieters entsprechen nicht automatisch denen eines Kontos bei einer vermittelnden API. Behandeln Sie 429 Too Many Requests und den zugehörigen Header Retry-After als maßgeblich für den aktiven GPT Proto-Schlüssel. Halten Sie die Parallelität konfigurierbar, statt einen aggressiven Wert fest im Code zu verankern.

OpenAI veröffentlicht außerdem nach Tarifen gestaffelte Limits für den direkten Modellzugriff. Diese Angaben bieten einen nützlichen Vergleich, sollten aber nicht als Ratenbegrenzungen von GPT Proto dargestellt werden.

Schritt 5: URL- und Base64-Ergebnisse korrekt speichern

GPT Proto unterstützt für diesen Endpunkt response_format="url" und response_format="b64_json".

Einsteiger sollten zunächst url verwenden. Die API gibt einen normalen Bildlink zurück und das Skript lädt die Datei in den Ordner generated herunter. Laden Sie das Bild sofort herunter, da es sich bei der Ergebnis-URL um einen Übertragungslink und nicht um einen dauerhaften Speicherort für Assets handelt. Speichern Sie freigegebene Dateien in Ihrem eigenen Medienordner für Produkte, DAM oder Objektspeicher.

Base64 ist eine weitere Möglichkeit, dasselbe Bild bereitzustellen: Die Antwort enthält eine sehr lange Textzeichenfolge statt einer URL. Das ist nützlich, wenn alle Daten in JSON bleiben müssen. Der Text muss jedoch wieder in binäre Bilddaten umgewandelt werden, bevor die Datei geöffnet werden kann. Für die erste Version dieses Workflows benötigen Sie kein Base64.

Dekodieren Sie bei einer Base64-Ausgabe die Zeichenfolge in Bytes:

import base64
from pathlib import Path

def save_base64_image(value, destination):
    # Also accepts a data URI such as data:image/png;base64,...
    encoded = value.split(",", 1)[1] if value.startswith("data:") else value
    Path(destination).write_bytes(base64.b64decode(encoded, validate=True))

Ein häufiger Fehler beim Dekodieren von GPT Image 2 Base64 ist, den kodierten Text direkt in eine Datei mit der Endung .png zu schreiben. Eine gültige Bilddatei enthält dekodierte Binärdaten und nicht die von der API zurückgegebene JSON-Zeichenfolge.

Wenn Sie OpenAI direkt statt GPT Proto verwenden, beachten Sie, dass GPT-Bildmodelle b64_json zurückgeben. Laut dem Leitfaden zur Bildgenerierung von OpenAI wird das URL-Antwortformat für GPT-Bildmodelle nicht unterstützt. Dieser Unterschied zwischen Anbietern ist der Grund, warum die Verarbeitung der Antwort zum tatsächlich aufgerufenen Endpunkt passen sollte.

Schritt 6: Erneute Versuche ohne doppelte Bilder

Eine API-Anfrage kann fehlschlagen, weil das Konto zu schnell Aufträge sendet, die Netzwerkverbindung unterbrochen wird oder die Generierung selbst abgelehnt wird. Es ist verlockend, jeden fehlgeschlagenen Befehl erneut auszuführen, doch dabei können doppelte Bilder entstehen.

Wiederholungen sind nicht für jede Anfrage gleichermaßen sicher. POST erstellt eine neue Aufgabe; GET fragt lediglich eine bestehende Aufgabe ab.

• Eine Statusabfrage per GET kann sicher wiederholt werden, da sie kein weiteres Bild erstellt.

• Bei einer POST-Anfrage, die eindeutig mit 429 abgelehnt wird, können Sie bis zum in Retry-After angegebenen Zeitpunkt warten und es erneut versuchen.

• Bei einem Verbindungs-Timeout während einer POST-Anfrage ist der Status unklar. Der Server hat den Auftrag möglicherweise angenommen, obwohl der Client keine Antwort erhalten hat. Eine blinde Wiederholung kann einen kostenpflichtigen Doppelauftrag erzeugen.

• Ein abgeschlossener, fehlgeschlagener oder durch Moderation blockierter Auftrag sollte nicht automatisch erneut gesendet werden.

Das Skript unten schreibt die Aufgaben-ID unmittelbar nach dem Absenden in manifest.json. Beim nächsten Durchlauf fragt es die bestehende Aufgabe ab, statt dieselbe SKU erneut zu senden. Endet die Anfrage mit einem unbekannten Netzwerkstatus und ohne Aufgaben-ID, wird der Eintrag als manual_check markiert. Prüfen Sie den Kontoverlauf, bevor Sie es erneut versuchen.

Verwenden Sie für sichere Wiederholungen exponentielles Backoff mit Jitter. Berücksichtigen Sie Retry-After, wenn die API den Header sendet, begrenzen Sie die Wartezeit und die Anzahl der Versuche. Wiederholte Fehler sollten im Manifest erfasst werden und nicht in einer Endlosschleife landen.

Schritt 7: image_generation_user_error behandeln

image_generation_user_error ist eine Kategorie und keine vollständige Diagnose. Sie bedeutet, dass die Anfrage aufgrund eines Problems mit der Eingabe oder Anfrage nicht generiert werden konnte. Lesen Sie den inneren Fehlercode und die Fehlermeldung, bevor Sie entscheiden, was geändert werden soll.

Typische Maßnahmen sind:

Versuchen Sie nicht, Moderationsfehler zu „beheben“, indem Sie Wörter entfernen, bis die Anfrage durchgeht. Vergewissern Sie sich, dass das Produkt, der vorgesehene Verwendungszweck, die Referenzmaterialien und der Prompt den Richtlinien des Anbieters entsprechen.

Wenn eine Aufgabe fehlschlägt, gehen Einsteiger am besten folgendermaßen vor:

1. SKU in manifest.json suchen.

2. Das Feld error lesen, statt das Produkt sofort erneut zu senden.

3. Wenn in der Meldung eine Größe oder ein Parameter genannt wird, diesen Wert korrigieren.

4. Bei einem 429 den Wert von IMAGE_WORKERS verringern und vor der Fortsetzung warten.

5. Bei Richtlinien- oder Moderationsfehlern Produkt und Prompt manuell prüfen.

6. Bei Status manual_check den Aufgabenverlauf prüfen, bevor der Eintrag gelöscht wird. Die ursprüngliche Anfrage könnte bereits angelegt worden sein.

Schritt 8: Ein teamfreundliches Generierungsmanifest führen

Das Manifest ist keine API-Funktion, die Sie konfigurieren müssen. Es ist eine JSON-Datei, die das Skript auf Ihrem Computer erstellt. Betrachten Sie sie als Generierungsprotokoll.

Für ein Team oder Unternehmen reicht der Bilderordner allein nicht aus. Ein Manifest verknüpft jedes Asset mit SKU, Prompt, Einstellungen, Aufgaben-ID, Status, Ausgabepfad und Fehler.

Beispieleintrag:

{
  "MUG-001": {
    "sku": "MUG-001",
    "status": "completed",
    "task_id": "prediction-id",
    "quality": "low",
    "size": "1024x1024",
    "prompt": "Create one catalog product photograph...",
    "files": ["generated/MUG-001-01.png"],
    "error": null
  }
}

In diesem Eintrag bedeutet completed, dass das Bild generiert und heruntergeladen wurde. task_id ist die Empfangsnummer der API. files gibt an, wo das Bild gespeichert wurde. Wenn die Generierung fehlschlägt, enthält error die Informationen, anhand derer entschieden werden kann, ob die SKU korrigiert, erneut versucht oder überprüft werden soll.

So erhält die prüfende Person eine verlässliche Übergabe. Außerdem lassen sich nur abgelehnte Elemente neu generieren, Prompt-Versionen vergleichen und Assets bis zu ihrer ursprünglichen Anfrage zurückverfolgen. Bei größeren Teams können dieselben Felder in einer Datenbank gespeichert und um prüfende Person, Freigabestatus, Prompt-Version, Kampagne und Rechtehinweise ergänzt werden.

Vollständiges Python-Skript für die Produktgenerierung in großen Mengen

Das folgende Skript vereint den Workflow. Es verwendet den aktuellen GPT Proto-v3-Endpunkt für Text-zu-Bild und die Route für Vorhersageergebnisse, sendet pro SKU n=1 und verwendet standardmäßig drei Worker. Bekannte Aufgaben werden anhand von manifest.json fortgesetzt.

Der Code ist länger als ein einfaches API-Beispiel, da er mehrere Sicherheitsaufgaben für Sie übernimmt:

• Prüft die Bildabmessungen, bevor eine Anfrage gesendet wird.

• Speichert die Aufgaben-ID, sobald die API ein Produkt annimmt.

• Wartet auf jedes Bild, ohne dass Sie GET-Befehle manuell ausführen müssen.

• Lädt URL-Ergebnisse herunter und dekodiert Base64-Ergebnisse.

• Begrenzt die Anzahl der gleichzeitig verarbeiteten Produkte.

• Protokolliert Fehler und setzt bekannte Aufgaben nach einem Neustart fort.

Kopieren Sie das Skript bei der ersten Ausführung, ohne seine Funktionen zu ändern. Sie müssen nur products.csv und den API-Schlüssel bereitstellen. Die Einstellungen im oberen Bereich – SIZE, QUALITY, WORKERS und POLL_TIMEOUT – können später angepasst werden.

import base64
import csv
import json
import os
import random
import re
import threading
import time
from concurrent.futures import ThreadPoolExecutor, as_completed
from pathlib import Path
from urllib.parse import urlparse

import requests

API_ROOT = "https://gptproto.com/api/v3"
SUBMIT_URL = f"{API_ROOT}/openai/gpt-image-2/text-to-image"
RESULT_URL = f"{API_ROOT}/predictions/{{task_id}}/result"

CSV_PATH = Path(os.getenv("PRODUCTS_CSV", "products.csv"))
OUTPUT_DIR = Path(os.getenv("IMAGE_OUTPUT_DIR", "generated"))
MANIFEST_PATH = Path(os.getenv("IMAGE_MANIFEST", "manifest.json"))

SIZE = os.getenv("IMAGE_SIZE", "1024x1024")
QUALITY = os.getenv("IMAGE_QUALITY", "low")
WORKERS = int(os.getenv("IMAGE_WORKERS", "3"))
POLL_TIMEOUT = int(os.getenv("IMAGE_POLL_TIMEOUT", "900"))

API_KEY = os.environ["GPTPROTO_API_KEY"]
HEADERS = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

manifest_lock = threading.Lock()


class SubmissionStateUnknown(RuntimeError):
    """The POST may have reached the server, but no task ID was received."""


def validate_size(size):
    if size == "auto":
        return
    if not re.fullmatch(r"\d+x\d+", size.lower()):
        raise ValueError("Size must look like 1024x1024 or be 'auto'")

    width, height = map(int, size.lower().split("x"))
    pixels = width * height
    if width % 16 or height % 16:
        raise ValueError("GPT Image 2 width and height must be multiples of 16")
    if max(width, height) > 3840:
        raise ValueError("The longest edge cannot exceed 3840 pixels")
    if max(width, height) / min(width, height) > 3:
        raise ValueError("Aspect ratio cannot exceed 3:1")
    if not 655_360 <= pixels <= 8_294_400:
        raise ValueError("Total pixels are outside the supported range")


def build_prompt(row):
    return f"""Create one catalog product photograph.
Product: {row['name']}
Color: {row['color']}
Material: {row['material']}
View: {row['angle']}
Background: {row['background']}

Keep the product centered with realistic proportions and material texture.
Use soft studio lighting, a natural contact shadow, and generous crop-safe space.
No text, logos, labels, people, or extra objects.
Also avoid: {row.get('avoid', 'none')}.
Return a single product image, not a collage or contact sheet."""


def load_manifest():
    if not MANIFEST_PATH.exists():
        return {}
    return json.loads(MANIFEST_PATH.read_text(encoding="utf-8"))


manifest = load_manifest()


def save_record(sku, **changes):
    with manifest_lock:
        record = manifest.setdefault(sku, {"sku": sku})
        record.update(changes)
        temporary = MANIFEST_PATH.with_suffix(".json.tmp")
        temporary.write_text(
            json.dumps(manifest, indent=2, ensure_ascii=False),
            encoding="utf-8",
        )
        temporary.replace(MANIFEST_PATH)


def parse_json(response):
    try:
        return response.json()
    except ValueError:
        return {"raw_response": response.text[:1000]}


def api_error(response):
    payload = parse_json(response)
    return RuntimeError(
        f"HTTP {response.status_code}: {json.dumps(payload, ensure_ascii=False)}"
    )


def submit(prompt):
    payload = {
        "prompt": prompt,
        "n": 1,
        "quality": QUALITY,
        "size": SIZE,
        "enable_sync_mode": False,
        "response_format": "url",
    }

    # Retry only a definite 429 rejection. A connection failure is ambiguous:
    # the job may exist even though this client did not receive its ID.
    for attempt in range(5):
        try:
            response = requests.post(
                SUBMIT_URL,
                headers=HEADERS,
                json=payload,
                timeout=(10, 180),
            )
        except requests.RequestException as exc:
            raise SubmissionStateUnknown(str(exc)) from exc

        if response.status_code != 429:
            if response.status_code >= 400:
                raise api_error(response)
            body = parse_json(response)
            data = body.get("data", body)
            task_id = data.get("id")
            if not task_id:
                raise RuntimeError(f"Submission returned no data.id: {body}")
            return task_id

        if attempt == 4:
            raise api_error(response)
        retry_after = response.headers.get("Retry-After")
        delay = float(retry_after) if retry_after and retry_after.isdigit() else 2**attempt
        time.sleep(min(30, delay) + random.random())

    raise RuntimeError("Submission retry loop ended unexpectedly")


def get_result(task_id):
    deadline = time.monotonic() + POLL_TIMEOUT
    delay = 2.0

    while time.monotonic() < deadline:
        try:
            response = requests.get(
                RESULT_URL.format(task_id=task_id),
                headers=HEADERS,
                timeout=(10, 60),
            )
        except requests.RequestException:
            time.sleep(delay + random.random())
            delay = min(10, delay * 1.5)
            continue

        if response.status_code == 429 or response.status_code >= 500:
            retry_after = response.headers.get("Retry-After")
            wait = float(retry_after) if retry_after and retry_after.isdigit() else delay
            time.sleep(min(30, wait) + random.random())
            delay = min(10, delay * 1.5)
            continue
        if response.status_code >= 400:
            raise api_error(response)

        body = parse_json(response)
        data = body.get("data", body)
        status = str(data.get("status", "")).lower()

        if status in {"completed", "succeeded"}:
            outputs = data.get("outputs") or []
            if not outputs:
                raise RuntimeError(f"Completed task returned no outputs: {body}")
            return outputs
        if status in {"failed", "canceled", "cancelled"}:
            raise RuntimeError(json.dumps(data.get("error") or body, ensure_ascii=False))

        time.sleep(delay)
        delay = min(10, delay * 1.25)

    raise TimeoutError(f"Task {task_id} exceeded {POLL_TIMEOUT} seconds")


def filename_part(value):
    cleaned = re.sub(r"[^A-Za-z0-9._-]+", "-", value.strip())
    return cleaned.strip("-._") or "product"


def extension_from_response(response, url):
    content_type = response.headers.get("Content-Type", "").split(";", 1)[0]
    by_type = {"image/png": ".png", "image/jpeg": ".jpg", "image/webp": ".webp"}
    if content_type in by_type:
        return by_type[content_type]
    suffix = Path(urlparse(url).path).suffix.lower()
    return suffix if suffix in {".png", ".jpg", ".jpeg", ".webp"} else ".png"


def save_output(output, sku, index):
    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
    stem = f"{filename_part(sku)}-{index:02d}"

    if isinstance(output, dict):
        output = output.get("url") or output.get("b64_json") or output.get("data")
    if not isinstance(output, str):
        raise TypeError(f"Unsupported output value: {output!r}")

    if output.startswith(("http://", "https://")):
        response = requests.get(output, timeout=(10, 180))
        response.raise_for_status()
        destination = OUTPUT_DIR / f"{stem}{extension_from_response(response, output)}"
        destination.write_bytes(response.content)
        return str(destination)

    encoded = output.split(",", 1)[1] if output.startswith("data:") else output
    destination = OUTPUT_DIR / f"{stem}.png"
    destination.write_bytes(base64.b64decode(encoded, validate=True))
    return str(destination)


def process_product(row):
    sku = row["sku"].strip()
    prompt = build_prompt(row)
    previous = manifest.get(sku, {})

    if previous.get("status") == "completed":
        return sku, "skipped: already completed"
    if previous.get("status") == "manual_check" and not previous.get("task_id"):
        return sku, "skipped: verify task history before resubmitting"
    if previous.get("status") == "failed":
        return sku, "skipped: review the recorded error before retrying"

    task_id = previous.get("task_id")

    try:
        if not task_id:
            task_id = submit(prompt)
            save_record(
                sku,
                status="submitted",
                task_id=task_id,
                quality=QUALITY,
                size=SIZE,
                prompt=prompt,
                files=[],
                error=None,
            )

        save_record(sku, status="processing")
        outputs = get_result(task_id)
        files = [save_output(value, sku, i) for i, value in enumerate(outputs, 1)]
        save_record(sku, status="completed", files=files, error=None)
        return sku, f"completed: {', '.join(files)}"

    except SubmissionStateUnknown as exc:
        save_record(
            sku,
            status="manual_check",
            task_id=None,
            quality=QUALITY,
            size=SIZE,
            prompt=prompt,
            files=[],
            error=f"Submission state unknown: {exc}",
        )
        return sku, "manual check required"
    except TimeoutError as exc:
        # Keep the task ID. The next run will poll this job instead of submitting
        # the SKU again, so a slow generation does not become a duplicate.
        save_record(sku, status="poll_timeout", task_id=task_id, error=str(exc))
        return sku, f"poll timed out; resume task {task_id} on the next run"
    except Exception as exc:
        save_record(sku, status="failed", task_id=task_id, error=str(exc))
        return sku, f"failed: {exc}"


def main():
    validate_size(SIZE)
    if WORKERS < 1:
        raise ValueError("IMAGE_WORKERS must be at least 1")

    with CSV_PATH.open(newline="", encoding="utf-8-sig") as handle:
        products = list(csv.DictReader(handle))

    required = {"sku", "name", "color", "material", "angle", "background"}
    missing = required - set(products[0]) if products else required
    if missing:
        raise ValueError(f"CSV is missing columns: {sorted(missing)}")

    skus = [row["sku"].strip() for row in products]
    if not all(skus):
        raise ValueError("Every CSV row must have a non-empty SKU")
    if len(skus) != len(set(skus)):
        raise ValueError("CSV contains duplicate SKUs; make each SKU unique before running")

    with ThreadPoolExecutor(max_workers=WORKERS) as pool:
        futures = [pool.submit(process_product, row) for row in products]
        for future in as_completed(futures):
            sku, message = future.result()
            print(f"[{sku}] {message}")


if __name__ == "__main__":
    main()

Skript ausführen: Eine Anleitung für Einsteiger

1. Die beiden Eingabedateien überprüfen

Öffnen Sie Ihren Ordner gpt-image-bulk und vergewissern Sie sich, dass er Folgendes enthält:

• bulk_product_images.py, mit dem vollständigen Python-Code.

• products.csv, mit der Kopfzeile und mindestens einer Produktzeile.

Speichern Sie das Skript nicht als bulk_product_images.py.txt. Wenn Ihr Editor Dateierweiterungen ausblendet, prüfen Sie vor dem Fortfahren den Dateityp.

2. Terminal in diesem Ordner öffnen

Das Terminal muss sich im selben Ordner wie die beiden Dateien befinden. Sie können cd gefolgt vom Ordnerpfad verwenden, zum Beispiel:

cd path/to/gpt-image-bulk

Den aktuellen Ordner können Sie unter macOS/Linux mit pwd oder in PowerShell mit Get-Location überprüfen.

3. API-Schlüssel festlegen und requests installieren

Legen Sie GPTPROTO_API_KEY mit dem im Einrichtungsabschnitt gezeigten Befehl fest. Installieren Sie anschließend requests, falls noch nicht geschehen:

python -m pip install requests

4. Datei ausführen

Unter macOS, Linux und den meisten Python-Installationen:

python bulk_product_images.py

Verwenden Sie unter Windows den folgenden Befehl, wenn Ihr Python-Befehl py lautet:

py bulk_product_images.py

Die Verarbeitung des ersten Produkts kann eine Weile dauern. Das Terminal ist während der Generierung durch die API nicht unbedingt eingefroren. Nach Abschluss der Aufgaben sollten ähnliche Zeilen angezeigt werden:

[MUG-001] completed: generated/MUG-001-01.png
[BAG-014] completed: generated/BAG-014-01.png
[LAMP-207] completed: generated/LAMP-207-01.png

Der Ordner enthält nun generated/ und manifest.json. Öffnen Sie die generierten Bilder und vergleichen Sie jedes mit der zugehörigen CSV-Zeile. Öffnen Sie anschließend manifest.json in einem Texteditor und vergewissern Sie sich, dass bei jeder erfolgreich verarbeiteten SKU "status": "completed" steht.

5. Verstehen, was bei einer erneuten Ausführung passiert

Das Skript liest manifest.json, bevor es neue Anfragen sendet. Abgeschlossene SKUs werden übersprungen. Bei einer Aufgabe, die zuvor während der Statusabfrage unterbrochen wurde, bleibt die Aufgaben-ID erhalten und wird erneut geprüft. Ein als manual_check oder failed markierter Eintrag wird nicht automatisch erneut gesendet.

Das ist Absicht. So wird verhindert, dass „Befehl erneut ausführen“ bedeutet: „Für jedes erfolgreiche Bild erneut bezahlen“. Wenn ein fehlgeschlagener Eintrag gefahrlos erneut versucht werden kann, löschen Sie nach Prüfung des Fehlers nur den Eintrag dieser SKU aus manifest.json. Löschen Sie nicht das gesamte Manifest, es sei denn, Sie möchten den ganzen Katalog bewusst erneut einreichen.

6. Von Entwürfen zu finalen Bildern wechseln

Verwenden Sie für den ersten Durchlauf IMAGE_QUALITY=low und IMAGE_WORKERS=2 oder 3. Prüfen Sie die Entwürfe und kopieren Sie nur freigegebene Produktzeilen in eine neue Datei namens products-final.csv.

Verwenden Sie für einen separaten finalen Durchlauf unter macOS oder Linux neue Namen für Ausgabe und Manifest, damit die Entwurfsdateien unverändert bleiben:

PRODUCTS_CSV=products-final.csv \
IMAGE_OUTPUT_DIR=generated-final \
IMAGE_MANIFEST=manifest-final.json \
IMAGE_QUALITY=high \
python bulk_product_images.py

Legen Sie in Windows PowerShell zunächst dieselben Werte fest und führen Sie anschließend das Skript aus:

$env:PRODUCTS_CSV="products-final.csv"
$env:IMAGE_OUTPUT_DIR="generated-final"
$env:IMAGE_MANIFEST="manifest-final.json"
$env:IMAGE_QUALITY="high"
py bulk_product_images.py

Die finalen Bilder werden im Ordner generated-final/ gespeichert. Die Entwurfsbilder und das Entwurfsmanifest bleiben dabei zum Vergleich erhalten.

Preise für GPT Image 2 bei umfangreichen Aufträgen

Die Preise für GPT Image 2 basieren auf Tokens. Deshalb gibt es keinen allgemeingültigen, verlässlichen „Preis pro Produktbild“. Texteingabe, Eingabe von Referenzbildern, Ausgabegröße, Qualität und Anzahl der Ergebnisse wirken sich auf die Gesamtkosten aus.

Für Einsteiger ist „pro eine Million Tokens“ eine Abrechnungseinheit und weder ein monatliches Abonnement noch die Pflicht, im Voraus eine Million Tokens zu kaufen. Ihr Prompt wird als Texteingabe-Tokens abgerechnet. Ein für die Bildbearbeitung verwendetes Produkt-Referenzfoto wird als Bild-Eingabe-Tokens abgerechnet. Das generierte Bild wird als Bild-Ausgabe-Tokens abgerechnet. Bei einer Text-zu-Bild-Anfrage fallen keine Kosten für die Eingabe eines Referenzbilds an, da kein Ausgangsbild hochgeladen wurde.

Zum Zeitpunkt der Veröffentlichung sind auf der GPT Proto-Modellseite folgende Preise pro eine Million Tokens angegeben:

Das liegt 20 % unter den angegebenen OpenAI-Standardpreisen pro Token. Preise können sich ändern. Prüfen Sie daher die aktuelle GPT Image 2-Modellseite, bevor Sie einen Preis veröffentlichen oder einen umfangreichen Durchlauf starten.

Die Preisübersicht von OpenAI enthält außerdem hilfreiche Beispiele für die reinen Ausgabekosten bei gängigen Größen. Für ein Bild mit 1024x1024 werden bei niedriger Qualität etwa 0,006 $, bei mittlerer 0,053 $ und bei hoher Qualität 0,211 $ angegeben. Ein Bild mit 1536x1024 oder 1024x1536 kostet etwa 0,005 $, 0,041 $ beziehungsweise 0,165 $. Eingabe-Tokens kommen hinzu. Maßgeblich ist die aktuelle OpenAI-API-Preisseite; behandeln Sie diese Werte nicht als dauerhaft.

Für eine Kostenschätzung des Katalogs sollten Sie einen Pilotlauf mit 20 Artikeln durchführen, der die tatsächliche Produktmischung widerspiegelt. Erfassen Sie die tatsächlichen Ausgaben, den Anteil freigegebener Bilder und die Regenerierungsrate. Berechnen Sie anschließend:

geschätzte Katalogkosten =
  durchschnittliche API-Kosten pro Versuch
  × durchschnittliche Anzahl Versuche pro freigegebenem Bild
  × Anzahl der Produkte

Die Regenerierungsrate wird leicht übersehen. Ein günstiger Entwurf, für den vier Versuche nötig sind, kann mehr kosten als ein besser kontrollierter Auftrag mit mittlerer Qualität, der beim ersten oder zweiten Versuch freigegeben wird.

Wann Sie Referenzbilder statt Text-zu-Bild verwenden sollten

Reines Text-zu-Bild eignet sich, wenn das Produkt allgemein gehalten ist, das Bild konzeptionell sein soll oder die genaue Verpackung nicht einem verkäuflichen Artikel entsprechen muss. Für die exakte Darstellung einer SKU sollte es nicht die Standardeinstellung sein.

Verwenden Sie den Bildbearbeitungs-Endpunkt von GPT Image 2, wenn Form, Farben, Verpackung oder Designsprache eines bestehenden Produkts erhalten bleiben müssen. GPT Image 2 akzeptiert laut Dokumentation im offiziellen Format bis zu 16 PNG-, WebP- oder JPEG-Referenzbilder mit jeweils weniger als 50 MB und verwendet automatisch eine hohe Eingabetreue. Der Endpunkt im Anbieterformat von GPT Proto akzeptiert Bild-URLs oder Base64-Daten-URIs. Siehe die GPT Image 2-Referenz zur Bildbearbeitung.

Geeignete Referenzsammlungen enthalten:

• Ein sauberes Produktfoto von vorn oder aus einer Dreiviertelperspektive.

• Eine zweite Perspektive, wenn die Form nicht eindeutig ist.

• Eine Nahaufnahme wichtiger Materialstrukturen oder Bedienelemente.

• Eine separate Stilreferenz für Beleuchtung und Hintergrund, die im Prompt eindeutig gekennzeichnet ist.

Referenzbilder verbessern die Kontrolle, garantieren jedoch keine pixelgenauen Etiketten, kleinen Texte oder Produktabmessungen. Vor der Veröffentlichung sollte eine Person die generierten Assets mit dem Originalprodukt vergleichen.

Produktions-Checkliste für Unternehmen und Teams

Bevor Sie von einem Pilotlauf zur Massengenerierung übergehen:

• Eine Prompt-Version festlegen und im Manifest speichern.

• Eine unveränderliche SKU als primären Asset-Schlüssel verwenden.

• Entwürfe mit niedriger Qualität generieren und nur freigegebene Kompositionen mit der endgültigen Einstellung rendern.

• Die Anzahl der Worker konfigurierbar halten und nach wiederholten 429-Antworten reduzieren.

• Aufgaben-IDs vor dem Abfragen speichern.

• Jede temporäre Ergebnis-URL sofort herunterladen.

• Die Statuswerte failed, manual_check und completed getrennt behandeln.

• Moderations-, Berechtigungs- oder Guthabenfehler niemals unverändert erneut versuchen.

• Beispielergebnisse auf Geometrie, Farbe, Etiketten, Schatten, Bildausschnitt und doppelte Objekte prüfen.

• Rechte an Quell- und Referenzmaterialien sichern und die Prüfungsfreigabe dokumentieren.

• API-Schlüssel in einem Secret-Manager oder einer Umgebungsvariablen speichern, nicht in einer CSV-Datei oder einem Repository.

Zur Entwicklung von Prompts, bevor Sie den Katalog automatisieren, können die GPT Image 2-Promptbeispiele dabei helfen, eine visuelle Richtung festzulegen. Überführen Sie diese Richtung in strukturierte Felder, bevor Sie den Ablauf auf große Mengen ausweiten.

Mit einem kleinen Katalogausschnitt beginnen

Der API-Aufruf ist der einfache Teil. Zuverlässige Massengenerierung entsteht dadurch, dass einzelne Produkte von einzelnen Variationen getrennt, Parallelität begrenzt, Eingaben validiert, Prediction-IDs gespeichert und alle Durchläufe fortsetzbar gemacht werden.

Beginnen Sie mit 10 bis 20 repräsentativen SKUs und niedriger Qualität. Messen Sie Freigabe- und Regenerierungsraten, korrigieren Sie den gemeinsamen Prompt und erweitern Sie erst danach die Warteschlange. Die aktuellen Parameter und Preise finden Sie auf der GPT Image 2-Modellseite. Wenn Sie das Skript ausführen möchten, können Sie über die GPT Proto-Startseite ein Konto erstellen.