Comment configurer la génération d'images en masse avec OpenArt CLI

Avant de scénariser quoi que ce soit

Ce tutoriel suppose que le binaire est installé et authentifié. Sinon, installe-le avec une seule commande et connecte-toi via le navigateur.

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

Vérifie le compte, le forfait et le solde de crédits avant de lancer un lot qui consomme de vrais crédits.

openart account

For Windows install steps, pinning a specific version, or the full command reference, see the Dépôt GitHub de la CLI plutôt que de répéter la configuration ici.

Check model fit and cost before you spend anything

Choisis un modèle qui prend en charge la génération texte-image avant de construire ta boucle de traitement par lot. La disponibilité et les capacités des modèles peuvent évoluer à mesure qu'OpenArt ajoute de nouvelles options, alors évite de te fier à un nom mémorisé ou à une valeur par défaut implicite.

openart model list

Review the available models, confirm text-to-image support, and copy the model ID you want to use. Store the ID in a variable to reduce editing mistakes in later commands.

Si tu dois vérifier exactement quels paramètres un modèle accepte avant de les ajouter à un batch, comme la largeur, la hauteur ou les champs de style, consulte son formulaire.

openart model form "$MODEL_ID" text2image

MODEL_ID="<model-id>"

Vérifie le prix par image du modèle avant de lancer une tâche.

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

Le model cost cette commande ne renvoie qu'un devis. Elle ne génère pas d'image et ne consomme pas de crédits. Lance-la sans option pour lister le prix de chaque modèle, du moins cher au plus cher, ou limite-la à un modèle et un mode comme indiqué ci-dessus. Multiplie le coût par image indiqué par le nombre d'images prévues pour estimer le coût du lot. Si ton CSV attribue des modèles différents à des lignes différentes, demande un devis pour chaque modèle et calcule chaque groupe séparément.

Prévisualise la requête exacte avec --dry-run

Run one representative prompt with the same model and flags planned for the batch.

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

La commande affiche la requête qu'OpenArt enverrait, y compris le prompt, le modèle et les paramètres de génération. OpenArt ne lance aucune tâche et ne consomme aucun crédit lors d'une simulation.

Le devis de coûts estime le prix de chaque image. Le test à blanc vérifie la requête elle-même. Ajoute tous les paramètres prévus pour le lot à cette commande, inspecte le résultat et corrige les valeurs par défaut inattendues ou les problèmes de devis avant de lire le vrai fichier de prompt.

Format the prompt list

Utiliser prompts.txt quand chaque tâche partage le même modèle et les mêmes paramètres. Stocke un prompt complet par ligne.

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

Garde chaque prompt sur une seule ligne physique. Un ultérieur read -r loop preserves backslashes, and quoting "$prompt" transmet les espaces et les guillemets comme faisant partie du prompt. Ignore les lignes vides sauf si tu comptes soumettre un prompt vide.

Utiliser prompts.csv quand des lignes nécessitent des modèles ou des dimensions différents.

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

Les champs CSV contenant des virgules doivent utiliser des guillemets doubles. Représente un guillemet à l'intérieur d'un champ entre guillemets par deux guillemets. Une boucle shell basée sur IFS=, ne peut pas analyser correctement ces cas, la variante CSV doit donc utiliser un parseur compatible CSV comme celui de Python csv module. Garde les noms d'en-têtes stables car le script ultérieur les lit directement.

Soumets le lot avec une boucle while-read

Enregistre le script suivant sous submit.sh. Il lit un prompt par ligne, soumet chaque génération et ajoute chaque ID de job retourné à 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

Remplacer replace-with-model-id, rends le script exécutable et passe un autre fichier de prompt si besoin.

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

Le script exige jq pour extraire l'ID de chaque réponse JSON. Si ta CLI installée renvoie l'identifiant sous un champ différent, inspecte une réponse et ajuste le .id expression.

Le --json garde la sortie standard lisible par machine. OpenArt envoie les messages de progression et de pagination vers l'erreur standard, ainsi la substitution de commande ne capture que le JSON qui jq besoins. Sans --json, un résultat lisible par l'humain pourrait entrer dans le response variable et faire échouer l'analyse de l'ID.

Le --async flag makes each command return after OpenArt accepts the job. Without it, the loop waits for one image before submitting the next and may wait until the default five-minute timeout for every prompt. Async submission lets the loop enqueue the full batch first.

Each successful submission adds one identifier to job-ids.txt.

job_abc123
job_def456
job_ghi789

The collection loop can consume that file directly. Failed submissions produce an error on standard error and do not add an invalid entry to the file.

Lancer la variante CSV

The CSV loop splits each row into fields and passes the row's model to the generation command.

#!/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

Compared with the plain-text loop, IFS=, read -r prompt model splits each row, and --model "$model" replaces the fixed model ID. The tail la commande ignore une ligne d'en-tête telle que prompt,model.

Bash field splitting does not implement full CSV quoting rules. If prompts contain commas or escaped quotes, parse the file with Python's csv module or another CSV-aware tool before passing fields to the OpenArt command.

Récupère les résultats une fois tout soumis

Utiliser openart creation wait when the script must finish only after every submitted job reaches a terminal state. The loop saves each completed creation record as JSON and records any jobs that return an error.

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

Each JSON file contains the final creation data, including the returned asset information. Your next processing step can read those files and download or move the generated images as needed.

Utiliser openart creation get when you want one status check without blocking. A manual check-in or scheduled polling job can run the same loop with one command changed.

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

Le wait loop pauses on each ID, but it does not make image generation serial. Every job started after the earlier async submission, so later jobs continue running while the loop waits for the first one. In CI, wait provides a clear completion point. For manual monitoring, get lets you inspect current states and return immediately.

Tout ce que le CLI OpenArt sait faire d'autre

Ce tutoriel se concentre sur un seul workflow : transformer une liste de prompts textuels en un lot d'images. La CLI couvre bien plus que ça, et ça vaut le coup de savoir ce qui existe avant de développer un outil séparé pour ça.

It can also change an image you already have. Point it at a photo on your computer or a link, describe the edit, and get a new version back, instead of only generating from scratch. On the video side, it makes a video from a description, or brings a still photo to life, with the length, shape, and resolution under your control wherever the chosen model allows it.

Au-delà de la génération, la CLI te garde organisé : bascule entre projets et espaces de travail, et charge une image de référence une seule fois pour la réutiliser dans tes prompts suivants au lieu de la re-téléverser à chaque fois. Chaque résultat peut être conservé sous forme de lien partageable ou téléchargé directement dans un dossier, et tu peux revoir tout ce que tu as créé, vérifier une tâche encore en cours ou attendre qu'elle se termine.

None of that changes the batch pattern in this tutorial. It just means the same terminal-first approach extends past plain text-to-image jobs. See OpenArt's Aperçu de la CLI pour les commandes derrière chacun de ces éléments.

Où ce workflow par lots est vraiment utile

Quelques cas concrets expliquent pourquoi les équipes optent pour un traitement par lots scripté plutôt que pour l'app web.

Variantes de catalogue produit. Une équipe e-commerce avec un tableur de 500 références génère un product image par ligne en faisant passer les descriptions produit via la variante CSV, chaque ligne ayant son modèle et ses dimensions adaptés à l'emplacement de l'image (carré pour une grille produit, portrait pour une story).

Content asset walls. Une équipe contenu ou croissance a besoin de 50 variantes de miniatures pour un test A/B avant le déjeuner. Une liste de prompts dans un fichier texte et la boucle while-read soumettent les 50 dans le temps qu'il faut pour écrire les prompts, au lieu de cliquer 50 fois dans l'appli web.

Des sets créatifs localisés. A marketing team turns the same base concept into a set of création publicitaire variants across a dozen prompts, each with a different setting, model, or aspect ratio for a specific market or channel, using the CSV variant to vary those fields per row.

Pipelines CI et agents. Une tâche nocturne régénère un ensemble fixe d'images de prévisualisation chaque fois que les données source changent, ou un agent qui exécute déjà des commandes shell soumet des générations dans le cadre d'un workflow d'appel d'outils plus large — le même schéma derrière générer des pubs produit depuis Claude. Les deux nécessitent --json une sortie et des codes de sortie non interactifs, pas une session de navigateur.

Quand privilégier le workflow batch en CLI plutôt que l'appli web ou MCP

Use the CLI batch workflow when a script needs to submit repeatable jobs, preserve job IDs, and collect results without manual input. It fits scheduled CI runs, shell pipelines, bulk prompt processing, and agent tool calls that execute terminal commands.

Utiliser OpenArt pour les sessions créatives ponctuelles où tu veux ajuster les prompts et les réglages tout en examinant chaque résultat. OpenArt MCP fits conversational generation inside agents such as Claude or ChatGPT, where the conversation controls the request instead of a shell script.

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.

Choose the interface that matches how you work. The CLI GitHub repo covers installation and the full command reference. The MCP overview above covers chat-based generation, if that fits your workflow better than file-driven batch processing.

FAQ

Que se passe-t-il si une tâche échoue en plein batch ?

A failed job does not cancel jobs already submitted. Your collection loop should record the failed job ID and continue unless the script exits on errors. Inspect the failed job with openart creation get <job-id>.

Comment définir un délai d'attente plus long sans --async ?

Le --timeout <seconds> prolonge la durée d'attente d'une commande de génération synchrone. Par exemple, ajoute --timeout 900 to wait up to 15 minutes. Confirm the supported value with openart generate image --help.

Puis-je utiliser --async avec -o ou --output ?

La soumission asynchrone renvoie un ID de tâche avant que l'image n'existe, donc la commande generate ne peut pas enregistrer l'image finie immédiatement. Stocke plutôt l'ID de tâche lors de la soumission. Utilise openart creation wait <job-id> ensuite pour récupérer le résultat et gérer sa sortie.

Comment relancer uniquement les prompts qui ont échoué ?

A rerun requires a record that maps each prompt to its submitted job ID. During collection, write failed IDs and their prompts to a separate file. Feed that file back into the submission loop after correcting any invalid prompts or parameters.

Will submitting hundreds of jobs at once hit a rate limit?

La boucle telle qu'écrite soumet aussi vite que le shell peut itérer, ce qui peut dépasser une limite de débit sur un gros batch. Ajoute un court sleep 0.5 inside the loop after each submission, or track a counter and pause for a few seconds every 20 to 50 prompts, to keep the request rate steady instead of bursting.

--dry-run fonctionne-t-il avec --async ?

Oui. Les combiner permet de prévisualiser la requête exacte d'un job qui s'exécuterait autrement en asynchrone, sans le soumettre ni dépenser de crédits. Garde les deux options sur la commande d'exemple pendant tes tests, puis retire uniquement --dry-run when you move to the real batch.

How do I keep track of which image came from which prompt?

Job IDs alone do not carry the original prompt text. Write the prompt and its job ID to the same line of a log file at submission time, for example printf '%s\t%s\n' "$job_id" "$prompt" >> submissions.tsv, pour qu'une étape ultérieure puisse relier une image finie au prompt qui l'a produite.

Où atterrissent les images terminées ?

openart creation wait and openart creation get return job metadata and asset URLs in JSON, not the image files themselves. Add a download step, such as curl -o "results/${job_id}.png" "$url" en utilisant l'URL de ce JSON, si le workflow a besoin de fichiers sur disque plutôt que de liens.

Ce workflow par lots fonctionne-t-il aussi pour la génération de vidéos ?

Oui. Le CLI reproduit les commandes image pour la vidéo : openart generate video "<prompt>" --model kling-3-omni soumet une tâche vidéo de la même façon openart generate image submits an image job. Swap generate image for generate video dans la boucle de soumission, et le même --json/--async flags plus openart creation wait/openart creation get collection pattern should apply. Run openart generate video --help to confirm any video-specific flags (such as duration) before scripting a large batch, since this tutorial's examples and testing cover image generation specifically.