So richtest du die Bulk-Bildgenerierung mit der OpenArt CLI ein

Bevor du irgendetwas scriptest

Dieses Tutorial setzt voraus, dass die Binary installiert und authentifiziert ist. Falls nicht, installiere sie mit einem Befehl und melde dich über den Browser an.

curl -fsSL https://raw.githubusercontent.com/OpenArt-AI/cli/main/install.sh | sh
openart login

Bestätige Account, Plan und Credit-Guthaben, bevor du einen Batch in die Warteschlange stellst, der echte Credits verbraucht.

openart account

Für Windows-Installationsschritte, das Anpinnen einer bestimmten Version oder die vollständige Befehlsreferenz siehe die CLI GitHub-Repo anstatt das Setup hier zu wiederholen.

Prüfe Modelleignung und Kosten, bevor du etwas ausgibst

Wähle ein Modell, das Text-zu-Bild-Generierung unterstützt, bevor du die Batch-Schleife baust. Modellverfügbarkeit und Funktionen können sich ändern, wenn OpenArt neue Optionen hinzufügt – verlass dich also nicht auf einen gemerkten Namen oder einen impliziten Standard.

openart model list

Sieh dir die verfügbaren Modelle an, prüfe die Text-zu-Bild-Unterstützung und kopiere die Modell-ID, die du verwenden möchtest. Speichere die ID in einer Variablen, um Bearbeitungsfehler in späteren Befehlen zu vermeiden.

Wenn du genau prüfen musst, welche Parameter ein Modell akzeptiert, bevor du sie einem Batch hinzufügst – etwa Breite, Höhe oder Stilfelder –, schau dir sein Formular an.

openart model form "$MODEL_ID" text2image

MODEL_ID="<model-id>"

Prüfe den Preis pro Bild des Modells, bevor du Jobs einreichst.

openart model cost \
  --model "$MODEL_ID" \
  --mode text2image

Der model cost Der Befehl gibt nur ein Angebot zurück. Er generiert kein Bild und verbraucht keine Credits. Führe ihn ohne Flags aus, um die Preise aller Modelle vom günstigsten an aufzulisten, oder beschränke ihn wie oben gezeigt auf ein Modell und einen Modus. Multipliziere die angegebenen Kosten pro Bild mit der Anzahl der geplanten Bilder, um die Batch-Kosten zu schätzen. Wenn deine CSV verschiedenen Zeilen verschiedene Modelle zuweist, fordere für jedes Modell ein Angebot an und berechne jede Gruppe separat.

Die exakte Anfrage mit --dry-run vorab ansehen

Führe einen repräsentativen Prompt mit demselben Modell und denselben Flags aus, die für den Batch geplant sind.

MODEL_ID="your-model-id"
openart generate image \
  "A red bicycle leaning against a brick wall at sunset" \
  --model "$MODEL_ID" \
  --json \
  --async \
  --dry-run

Der Befehl gibt die Anfrage aus, die OpenArt senden würde, inklusive Prompt, Modell und Generierungsparametern. OpenArt reicht bei einem Dry-Run keinen Job ein und verbraucht keine Credits.

Die Kostenschätzung ermittelt den Preis für jedes Bild. Der Testlauf prüft die Anfrage selbst. Füge diesem Befehl alle für den Batch vorgesehenen Parameter hinzu, prüfe die Ausgabe und korrigiere unerwartete Standardwerte oder Schätzprobleme, bevor du die eigentliche Prompt-Datei einliest.

Formatiere die Prompt-Liste

Verwenden prompts.txt wenn jeder Job dasselbe Modell und dieselben Parameter teilt. Speichere einen vollständigen Prompt pro Zeile.

A watercolor cabin beside a frozen lake
A studio photo of a red ceramic teapot
An isometric library with warm lighting

Halte jeden Prompt auf einer einzigen physischen Zeile. Eine spätere read -r Schleife bewahrt Backslashes, und Quoting "$prompt" übergibt Leerzeichen und Anführungszeichen als Teil des Prompts. Überspringe leere Zeilen, es sei denn, du willst einen leeren Prompt einreichen.

Verwenden prompts.csv wenn Zeilen unterschiedliche Modelle oder Dimensionen brauchen.

prompt,model,width,height
"A cabin beside a lake","model-id-a",1024,1024
"A teapot, red ceramic","model-id-b",768,1024
"A sign reading ""OPEN""","model-id-a",1024,768

CSV-Felder mit Kommas müssen in doppelte Anführungszeichen gesetzt werden. Ein Anführungszeichen innerhalb eines Feldes stellst du durch zwei Anführungszeichen dar. Eine Shell-Schleife basierend auf IFS=, kann diese Fälle nicht korrekt parsen, daher sollte die CSV-Variante einen CSV-fähigen Parser wie Pythons csv Modul. Halte die Header-Namen stabil, da das spätere Skript sie direkt ausliest.

Den Batch mit einer while-read-Schleife einreichen

Speichere das folgende Skript als submit.sh. Es liest einen Prompt pro Zeile, reicht jede Generierung ein und hängt jede zurückgegebene Job-ID an job-ids.txt.

#!/usr/bin/env bash
set -uo pipefail
MODEL_ID="replace-with-model-id"
PROMPT_FILE="${1:-prompts.txt}"
JOB_FILE="${2:-job-ids.txt}"
printf '' > "$JOB_FILE"
while IFS= read -r prompt || [[ -n "$prompt" ]]; do
  [[ -z "$prompt" ]] && continue
  if ! response=$(openart generate image "$prompt" \
    --model "$MODEL_ID" \
    --json \
    --async); then
    printf 'Submission failed for prompt %s\n' "$prompt" >&2
    continue
  fi
  if ! job_id=$(jq -er '.id' <<&2
    continue
  fi
  printf '%s\n' "$job_id" >> "$JOB_FILE"
  printf 'Submitted %s\n' "$job_id" >&2
done &2

Ersetzen replace-with-model-id, mach das Skript ausführbar und übergib bei Bedarf eine andere Prompt-Datei.

chmod +x submit.sh
./submit.sh prompts.txt

Das Skript erfordert jq um die ID aus jeder JSON-Antwort zu extrahieren. Falls deine installierte CLI den Identifier unter einem anderen Feld zurückgibt, sieh dir eine Antwort an und passe das .id Ausdruck.

Der --json Flag hält die Standardausgabe maschinenlesbar. OpenArt sendet Fortschritts- und Paginierungsmeldungen an die Standardfehlerausgabe, sodass die Befehlssubstitution nur das JSON erfasst, das jq benötigt. Ohne --json, menschenlesbare Ausgabe könnte in die response Variable und dazu führen, dass das Parsen der ID fehlschlägt.

Der --async Flag sorgt dafür, dass jeder Befehl zurückkehrt, sobald OpenArt den Job annimmt. Ohne sie wartet die Schleife auf ein Bild, bevor sie das nächste absendet, und wartet für jeden Prompt möglicherweise bis zum standardmäßigen Fünf-Minuten-Timeout. Das asynchrone Absenden lässt die Schleife zuerst den kompletten Batch einreihen.

Jedes erfolgreiche Absenden fügt eine Kennung hinzu zu job-ids.txt.

job_abc123
job_def456
job_ghi789

Die Sammelschleife kann diese Datei direkt verarbeiten. Fehlgeschlagene Einreichungen erzeugen einen Fehler auf der Standardfehlerausgabe und fügen der Datei keinen ungültigen Eintrag hinzu.

Die CSV-Variante ausführen

Die CSV-Schleife teilt jede Zeile in Felder auf und übergibt das Modell der Zeile an den Generierungsbefehl.

#!/usr/bin/env bash
> job-ids.txt
tail -n +2 prompts.csv |
while IFS=, read -r prompt model
do
  model=${model%$'\r'}
  [ -z "$prompt" ] && continue
  response=$(
    openart generate image "$prompt" \
      --model "$model" \
      --json \
      --async
  ) || continue
  printf '%s\n' "$response" |
    jq -r '.id' >> job-ids.txt
done

Verglichen mit der Klartext-Schleife, IFS=, read -r prompt model teilt jede Zeile auf, und --model "$model" ersetzt die feste Modell-ID. Die tail überspringt eine Kopfzeile wie zum Beispiel prompt,model.

Bash-Feldaufteilung setzt keine vollständigen CSV-Quoting-Regeln um. Wenn Prompts Kommas oder maskierte Anführungszeichen enthalten, parse die Datei mit Pythons csv Modul oder einem anderen CSV-fähigen Tool, bevor du Felder an den OpenArt-Befehl übergibst.

Ergebnisse einsammeln, sobald alles eingereicht ist

Verwenden openart creation wait wenn das Skript erst fertig sein darf, nachdem jeder abgesendete Job einen Endzustand erreicht hat. Die Schleife speichert jeden abgeschlossenen Erstellungsdatensatz als JSON und erfasst alle Jobs, die einen Fehler zurückgeben.

mkdir -p results
: > failed_job_ids.txt
while IFS= read -r job_id; do
  [ -z "$job_id" ] && continue
  if openart creation wait "$job_id" --json \
    > "results/${job_id}.json"; then
    printf 'Completed %s\n' "$job_id"
  else
    printf '%s\n' "$job_id" >> failed_job_ids.txt
    printf 'Failed %s\n' "$job_id" >&2
  fi
done < job_ids.txt

Jede JSON-Datei enthält die finalen Erstellungsdaten, einschließlich der zurückgegebenen Asset-Informationen. Dein nächster Verarbeitungsschritt kann diese Dateien lesen und die generierten Bilder nach Bedarf herunterladen oder verschieben.

Verwenden openart creation get wenn du eine einzelne Statusabfrage ohne Blockieren möchtest. Ein manuelles Check-in oder ein geplanter Polling-Job kann dieselbe Schleife mit einem geänderten Befehl ausführen.

mkdir -p status
while IFS= read -r job_id; do
  [ -z "$job_id" ] && continue
  openart creation get "$job_id" --json \
    > "status/${job_id}.json"
done < job_ids.txt

Der wait Schleife pausiert bei jeder ID, macht die Bildgenerierung aber nicht seriell. Jeder Job wurde nach dem früheren asynchronen Absenden gestartet, sodass spätere Jobs weiterlaufen, während die Schleife auf den ersten wartet. In CI, wait liefert einen klaren Abschlusspunkt. Für manuelles Monitoring get ermöglicht es dir, aktuelle Zustände zu prüfen und sofort zurückzukehren.

Was die OpenArt CLI sonst noch kann

Dieses Tutorial konzentriert sich auf einen Workflow: eine Liste von Text-Prompts in einen Batch von Bildern zu verwandeln. Die CLI kann noch viel mehr, und es lohnt sich zu wissen, was möglich ist, bevor du dafür separate Tools baust.

Es kann auch ein Bild ändern, das du bereits hast. Verweise auf ein Foto auf deinem Computer oder einen Link, beschreibe die Bearbeitung und erhalte eine neue Version zurück, statt nur von Grund auf zu generieren. Auf der Videoseite erstellt es ein Video aus einer Beschreibung oder erweckt ein Standbild zum Leben – mit Länge, Format und Auflösung unter deiner Kontrolle, wo immer das gewählte Modell es zulässt.

Über die Generierung hinaus hält dich die CLI organisiert: wechsle zwischen Projekten und Workspaces und lade ein Referenzbild einmal hoch, um es in späteren Prompts wiederzuverwenden, statt dieselbe Datei jedes Mal neu hochzuladen. Jedes Ergebnis kannst du als teilbaren Link behalten oder direkt in einen Ordner herunterladen, und du kannst alles Erstellte noch einmal ansehen, einen noch laufenden Job prüfen oder auf dessen Fertigstellung warten.

Nichts davon ändert das Batch-Muster in diesem Tutorial. Es bedeutet nur, dass sich derselbe Terminal-First-Ansatz über einfache Text-zu-Bild-Jobs hinaus erweitert. Siehe OpenArts CLI-Übersicht für die Befehle hinter jedem davon.

Wo dieser Batch-Workflow tatsächlich zum Einsatz kommt

Ein paar konkrete Fälle erklären, warum Teams statt der Web-App zu einem gescripteten Batch greifen.

Produktkatalog-Varianten. Ein E-Commerce-Team mit einer Tabelle von 500 SKUs generiert ein Produktbild pro Zeile, indem du Produktbeschreibungen durch die CSV-Variante schleust, wobei Modell und Abmessungen jeder Zeile darauf abgestimmt sind, wo das Bild eingesetzt wird (quadratisch für ein Produktraster, Hochformat für eine Story-Anzeige).

Content-Asset-Wände. Ein Content- oder Growth-Team braucht 50 Thumbnail-Varianten für einen A/B-Test vor der Mittagspause. Eine Prompt-Liste als Textdatei und die while-read-Schleife reichen alle 50 in der Zeit ein, die du zum Schreiben der Prompts brauchst – statt 50 Mal durch die Web-App zu klicken.

Lokalisierte Kreativsets. Ein Marketing-Team verwandelt dasselbe Grundkonzept in ein Set von Werbe-Creative Varianten über ein Dutzend Prompts hinweg, jede mit einer anderen Einstellung, einem anderen Modell oder Seitenverhältnis für einen bestimmten Markt oder Kanal, wobei die CSV-Variante diese Felder pro Zeile variiert.

CI- und Agent-Pipelines. Ein nächtlicher Job generiert einen festen Satz von Vorschaubildern neu, sobald sich Quelldaten ändern, oder ein Agent, der ohnehin Shell-Befehle ausführt, reicht Generierungen als Teil eines größeren Tool-Calling-Workflows ein – dasselbe Muster hinter Produktanzeigen aus Claude generieren. Beide benötigen --json Ausgabe und nicht-interaktive Exit-Codes, keine Browser-Session.

Wann du statt Web-App oder MCP zum CLI-Batch-Workflow greifen solltest

Nutze den CLI-Batch-Workflow, wenn ein Skript wiederholbare Jobs einreichen, Job-IDs bewahren und Ergebnisse ohne manuelle Eingabe sammeln muss. Er eignet sich für geplante CI-Läufe, Shell-Pipelines, die Massenverarbeitung von Prompts und Agent-Tool-Aufrufe, die Terminalbefehle ausführen.

Verwenden OpenArt für einmalige Kreativsessions, bei denen du Prompts und Einstellungen anpassen willst, während du jedes Ergebnis prüfst. OpenArt MCP passt konversationelle Generierung in Agenten wie Claude oder ChatGPT ein, wo das Gespräch die Anfrage steuert statt eines Shell-Skripts.

If the goal is not just generating images but also routing each result somewhere else automatically, such as posting a finished image to Telegram, Slack, or Discord, that behavior belongs to an agent, not to this batch script. An agent framework that already supports tool calling can call OpenArt MCP to generate the image, then call a separate messaging tool to deliver it. The while-read loop in this tutorial submits jobs and writes results to disk. It does not send anything anywhere, so a delivery step still needs its own script or agent on top of it.

Wähle die Oberfläche, die zu deiner Arbeitsweise passt. Das CLI-GitHub-Repo behandelt Installation und die vollständige Befehlsreferenz. Der MCP-Überblick oben behandelt chatbasierte Generierung, falls das besser zu deinem Workflow passt als dateibasierte Batch-Verarbeitung.

FAQs

Was passiert, wenn ein Job mitten im Batch fehlschlägt?

Ein fehlgeschlagener Job bricht bereits abgesendete Jobs nicht ab. Deine Sammelschleife sollte die ID des fehlgeschlagenen Jobs festhalten und weiterlaufen, sofern das Skript nicht bei Fehlern beendet wird. Untersuche den fehlgeschlagenen Job mit openart creation get <job-id>.

Wie stelle ich ein längeres Timeout ohne --async ein?

Der --timeout <seconds> Option verlängert, wie lange ein synchroner Generierungsbefehl wartet. Füge zum Beispiel --timeout 900 bis zu 15 Minuten zu warten. Bestätige den unterstützten Wert mit openart generate image --help.

Kann ich --async mit -o oder --output verwenden?

Die asynchrone Einreichung gibt eine Job-ID zurück, bevor das Bild existiert, daher kann der generate-Befehl das fertige Bild nicht sofort speichern. Speichere stattdessen die Job-ID während der Einreichung. Nutze openart creation wait <job-id> danach, um das Ergebnis abzurufen und seine Ausgabe zu verarbeiten.

Wie starte ich nur die fehlgeschlagenen Prompts erneut?

Ein erneuter Durchlauf erfordert einen Datensatz, der jeden Prompt seiner eingereichten Job-ID zuordnet. Schreibe während des Sammelns fehlgeschlagene IDs und ihre Prompts in eine separate Datei. Speise diese Datei nach dem Korrigieren ungültiger Prompts oder Parameter wieder in die Einreichungsschleife ein.

Stößt das Absenden Hunderter Jobs auf einmal an ein Ratenlimit?

Die Schleife im gezeigten Zustand sendet Anfragen so schnell, wie die Shell iterieren kann, was bei einem großen Batch ein Rate Limit überschreiten kann. Füge eine kurze sleep 0.5 innerhalb der Schleife nach jedem Absenden, oder verfolge einen Zähler und pausiere alle 20 bis 50 Prompts für ein paar Sekunden, um die Anfragerate gleichmäßig zu halten, statt in Schüben zu senden.

Funktioniert --dry-run zusammen mit --async?

Ja. Kombiniert man sie, wird die exakte Anfrage für einen Job vorab angezeigt, der sonst asynchron laufen würde – ohne ihn einzureichen oder Credits auszugeben. Behalte beide Flags am Beispielbefehl beim Testen und entferne dann nur --dry-run wenn du zum eigentlichen Batch übergehst.

Wie behalte ich den Überblick, welches Bild aus welchem Prompt stammt?

Job-IDs allein enthalten nicht den ursprünglichen Prompt-Text. Schreibe den Prompt und seine Job-ID beim Einreichen in dieselbe Zeile einer Logdatei, zum Beispiel printf '%s\t%s\n' "$job_id" "$prompt" >> submissions.tsv, damit ein späterer Schritt ein fertiges Bild wieder dem Prompt zuordnen kann, der es erzeugt hat.

Wo landen die fertigen Bilder?

openart creation wait und openart creation get geben Job-Metadaten und Asset-URLs als JSON zurück, nicht die Bilddateien selbst. Füge einen Download-Schritt hinzu, etwa curl -o "results/${job_id}.png" "$url" mit der URL aus diesem JSON, falls der Workflow Dateien auf der Festplatte statt Links benötigt.

Funktioniert dieser Batch-Workflow auch für die Videogenerierung?

Ja. Die CLI spiegelt die Bildbefehle für Video: openart generate video "<prompt>" --model kling-3-omni reicht einen Video-Job auf dieselbe Weise ein openart generate image sendet einen Bild-Job ab. Tausche generate image für generate video in der Einreichungsschleife, und dasselbe --json/--async Flags plus openart creation wait/openart creation get Sammelmuster sollte angewendet werden. Ausführen openart generate video --help um vor dem Skripten eines großen Batches videospezifische Flags (wie die Dauer) zu bestätigen, da sich die Beispiele und Tests dieses Tutorials speziell auf die Bilderzeugung beziehen.