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

Pour les étapes d'installation sous Windows, épingler une version précise ou la référence complète des commandes, consulte le Dépôt GitHub de la CLI plutôt que de répéter la configuration ici.

Vérifie l'adéquation et le coût du modèle avant de dépenser quoi que ce soit

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

Passe en revue les modèles disponibles, confirme la prise en charge du texte vers image, et copie l'ID du modèle que tu veux utiliser. Stocke l'ID dans une variable pour réduire les erreurs de saisie dans les commandes suivantes.

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

Lance un prompt représentatif avec le même modèle et les mêmes réglages prévus pour le lot.

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.

Mettre en forme la liste de prompts

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 préserve les antislashs, et le 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 fait que chaque commande revient dès qu'OpenArt accepte la tâche. Sans lui, la boucle attend une image avant de soumettre la suivante et peut attendre jusqu'au délai d'expiration par défaut de cinq minutes pour chaque prompt. La soumission asynchrone permet à la boucle de mettre en file l'ensemble du lot d'abord.

Chaque soumission réussie ajoute un identifiant à job-ids.txt.

job_abc123
job_def456
job_ghi789

La boucle de collection peut consommer ce fichier directement. Les envois échoués génèrent une erreur sur la sortie d'erreur standard et n'ajoutent pas d'entrée invalide au fichier.

Lancer la variante CSV

La boucle CSV découpe chaque ligne en champs et transmet le modèle de la ligne à la commande de génération.

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

Comparée à la boucle en texte brut, IFS=, read -r prompt model divise chaque ligne, et --model "$model" remplace l'ID de modèle fixe. Le tail la commande ignore une ligne d'en-tête telle que prompt,model.

La séparation de champs en Bash n'applique pas toutes les règles de guillemets CSV. Si les prompts contiennent des virgules ou des guillemets échappés, analyse le fichier avec le module de Python csv module ou un autre outil compatible CSV avant de transmettre les champs à la commande OpenArt.

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

Utiliser openart creation wait lorsque le script ne doit se terminer qu'une fois que chaque tâche soumise a atteint un état final. La boucle enregistre chaque création terminée au format JSON et consigne toute tâche qui renvoie une erreur.

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

Chaque fichier JSON contient les données finales de création, y compris les informations sur l'asset retourné. Ton étape de traitement suivante peut lire ces fichiers et télécharger ou déplacer les images générées selon tes besoins.

Utiliser openart creation get quand tu veux un simple contrôle de statut sans blocage. Un check-in manuel ou une tâche de polling programmée peut exécuter la même boucle avec une seule commande modifiée.

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 la boucle marque une pause sur chaque ID, mais elle ne rend pas la génération d'images séquentielle. Chaque tâche a démarré après la soumission asynchrone précédente, donc les tâches suivantes continuent de tourner pendant que la boucle attend la première. En CI, wait offre un point de fin clair. Pour un suivi manuel, get te permet d'inspecter les états actuels et de revenir immédiatement.

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.

Il peut aussi modifier une image que tu as déjà. Indique-lui une photo sur ton ordinateur ou un lien, décris la modification, et récupère une nouvelle version, au lieu de tout générer de zéro. Côté vidéo, il crée une vidéo à partir d'une description ou donne vie à une photo fixe, avec la durée, le format et la résolution sous ton contrôle partout où le modèle choisi le permet.

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 image produit 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).

Murs d'actifs de contenu. 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. Une équipe marketing décline le même concept de base en une série de création publicitaire variantes réparties sur une douzaine de prompts, chacun avec un réglage, un modèle ou un format différent pour un marché ou un canal spécifique, en utilisant la variante CSV pour faire varier ces champs par ligne.

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

Utilise le workflow batch en CLI quand un script doit soumettre des tâches répétables, conserver les identifiants de tâches et récupérer les résultats sans intervention manuelle. Il convient aux exécutions CI planifiées, aux pipelines shell, au traitement de prompts en masse et aux appels d'outils par agents qui exécutent des commandes dans le terminal.

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 intègre la génération conversationnelle dans des agents comme Claude ou ChatGPT, où la conversation pilote la requête à la place d'un script shell.

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.

Choisis l'interface qui correspond à ta façon de travailler. Le dépôt GitHub du CLI couvre l'installation et la référence complète des commandes. L'aperçu MCP ci-dessus couvre la génération par chat, si ça convient mieux à ton workflow que le traitement par lots piloté par fichiers.

FAQ

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

Un job échoué n'annule pas les jobs déjà soumis. Ta boucle de collecte doit enregistrer l'ID du job échoué et continuer, sauf si le script s'arrête sur les erreurs. Inspecte le job échoué avec 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 jusqu'à 15 minutes d'attente. Confirme la valeur prise en charge avec 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é ?

Un nouveau lancement nécessite un enregistrement qui associe chaque prompt à son ID de job soumis. Pendant la collecte, écris les ID échoués et leurs prompts dans un fichier séparé. Réinjecte ce fichier dans la boucle de soumission après avoir corrigé les prompts ou paramètres invalides.

Soumettre des centaines de tâches d'un coup atteint-il une limite de débit ?

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 dans la boucle après chaque envoi, ou garde un compteur et fais une pause de quelques secondes toutes les 20 à 50 requêtes, afin de maintenir un débit régulier plutôt que par rafales.

--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 quand tu passes au vrai lot.

Comment savoir quelle image vient de quel prompt ?

Les identifiants de tâche seuls ne contiennent pas le texte du prompt d'origine. Écris le prompt et son identifiant de tâche sur la même ligne d'un fichier journal au moment de la soumission, par exemple 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 et openart creation get renvoient les métadonnées de la tâche et les URL des actifs en JSON, pas les fichiers image eux-mêmes. Ajoute une étape de téléchargement, comme 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 lance une tâche d'image. Remplace generate image pour generate video dans la boucle de soumission, et le même --json/--async drapeaux plus openart creation wait/openart creation get le modèle de collection doit s'appliquer. Lance openart generate video --help pour confirmer les paramètres propres à la vidéo (comme la durée) avant de scripter un gros lot, puisque les exemples et les tests de ce tutoriel concernent spécifiquement la génération d'images.