Cómo configurar la generación masiva de imágenes con la CLI de OpenArt

Antes de programar cualquier cosa

Este tutorial da por hecho que el binario está instalado y autenticado. Si no es así, instálalo con un solo comando e inicia sesión desde el navegador.

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

Confirma la cuenta, el plan y el saldo de créditos antes de poner en cola un lote que gaste créditos reales.

openart account

Para los pasos de instalación en Windows, fijar una versión concreta o consultar la referencia completa de comandos, consulta el Repositorio de GitHub de la CLI en lugar de repetir la configuración aquí.

Comprueba la idoneidad y el coste del modelo antes de gastar nada

Elige un modelo que admita la generación de texto a imagen antes de crear el bucle de lotes. La disponibilidad y las capacidades de los modelos pueden cambiar a medida que OpenArt añade nuevas opciones, así que evita fiarte de un nombre recordado o de un valor por defecto implícito.

openart model list

Revisa los modelos disponibles, confirma que admiten texto a imagen y copia el ID del modelo que quieras usar. Guarda el ID en una variable para reducir errores de edición en los comandos posteriores.

Si necesitas confirmar exactamente qué parámetros acepta un modelo antes de añadirlos a un lote, como los campos de ancho, alto o estilo, revisa su formulario.

openart model form "$MODEL_ID" text2image

MODEL_ID="<model-id>"

Comprueba el precio por imagen del modelo antes de enviar cualquier tarea.

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

El model cost el comando solo devuelve un presupuesto. No genera ninguna imagen ni gasta créditos. Ejecútalo sin flags para listar el precio de cada modelo, del más barato al más caro, o acótalo a un modelo y modo como se muestra arriba. Multiplica el coste por imagen del presupuesto por el número de imágenes previstas para estimar el coste del lote. Si tu CSV asigna modelos diferentes a distintas filas, pide un presupuesto para cada modelo y calcula cada grupo por separado.

Previsualiza la petición exacta con --dry-run

Ejecuta un prompt representativo con el mismo modelo y los flags que planeas usar en el lote.

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

El comando imprime la solicitud que enviaría OpenArt, incluido el prompt, el modelo y los parámetros de generación. OpenArt no envía ningún trabajo ni gasta créditos durante una prueba en seco.

La cotización de coste estima el precio de cada imagen. El dry run comprueba la petición en sí. Añade a este comando cualquier parámetro pensado para el lote, inspecciona la salida y corrige valores por defecto inesperados o problemas de comillas antes de leer el archivo de prompts real.

Da formato a la lista de prompts

Usar prompts.txt cuando todos los trabajos comparten el mismo modelo y parámetros. Guarda un prompt completo por línea.

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

Mantén cada prompt en una sola línea física. Un read -r El bucle conserva las barras invertidas, y las comillas "$prompt" pasa los espacios y las comillas como parte del prompt. Omite las líneas en blanco a menos que quieras enviar un prompt vacío.

Usar prompts.csv cuando las filas necesitan modelos o dimensiones diferentes.

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

Los campos CSV que contienen comas deben ir entre comillas dobles. Representa una comilla dentro de un campo entrecomillado con dos comillas. Un bucle de shell basado en IFS=, no puede analizar esos casos correctamente, así que la variante CSV debería usar un analizador que reconozca CSV, como el de Python csv módulo. Mantén estables los nombres de los encabezados, porque el script posterior los lee directamente.

Envía el lote con un bucle while-read

Guarda el siguiente script como submit.sh. Lee un prompt por línea, envía cada generación y añade cada ID de tarea devuelto a 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

Reemplazar replace-with-model-id, haz el script ejecutable y pasa un archivo de prompts distinto si es necesario.

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

El script requiere jq para extraer el ID de cada respuesta JSON. Si tu CLI instalada devuelve el identificador bajo un campo diferente, inspecciona una respuesta y ajusta el .id expresión.

El --json el flag mantiene la salida estándar legible por máquina. OpenArt envía los mensajes de progreso y paginación a la salida de error estándar, por lo que la sustitución de comandos captura solo el JSON que jq necesita. Sin --json, una salida legible para humanos podría entrar en el response variable y provocar que falle el análisis del ID.

El --async hace que cada comando regrese después de que OpenArt acepte el trabajo. Sin él, el bucle espera a una imagen antes de enviar la siguiente y puede esperar hasta el tiempo de espera predeterminado de cinco minutos por cada prompt. El envío asíncrono permite que el bucle ponga en cola primero todo el lote.

Cada envío correcto añade un identificador a job-ids.txt.

job_abc123
job_def456
job_ghi789

El bucle de recopilación puede consumir ese archivo directamente. Los envíos fallidos generan un error en la salida de error estándar y no añaden una entrada inválida al archivo.

Ejecuta la variante CSV

El bucle CSV divide cada fila en campos y pasa el modelo de la fila al comando de generación.

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

En comparación con el bucle de texto plano, IFS=, read -r prompt model divide cada fila, y --model "$model" reemplaza el ID de modelo fijo. El tail el comando omite una fila de encabezado como prompt,model.

El separador de campos de Bash no implementa todas las reglas de comillas de CSV. Si los prompts contienen comas o comillas escapadas, analiza el archivo con el módulo de Python csv módulo u otra herramienta compatible con CSV antes de pasar los campos al comando de OpenArt.

Recopila los resultados una vez enviado todo

Usar openart creation wait cuando el script solo debe terminar después de que cada trabajo enviado alcance un estado terminal. El bucle guarda cada registro de creación completado como JSON y anota cualquier trabajo que devuelva un 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

Cada archivo JSON contiene los datos finales de la creación, incluida la información del recurso devuelto. Tu siguiente paso de procesamiento puede leer esos archivos y descargar o mover las imágenes generadas según necesites.

Usar openart creation get cuando quieras una comprobación de estado sin bloquear. Una comprobación manual o un trabajo de sondeo programado pueden ejecutar el mismo bucle cambiando un solo comando.

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

El wait El bucle se pausa en cada ID, pero no convierte la generación de imágenes en un proceso en serie. Cada trabajo se inició después del envío asíncrono anterior, así que los trabajos posteriores siguen ejecutándose mientras el bucle espera al primero. En CI, wait ofrece un punto de finalización claro. Para la monitorización manual, get te permite inspeccionar los estados actuales y volver de inmediato.

Qué más puede hacer la CLI de OpenArt

Este tutorial se centra en un flujo de trabajo: convertir una lista de prompts de texto en un lote de imágenes. La CLI abarca mucho más que eso, y merece la pena saber qué hay disponible antes de construir herramientas aparte para ello.

También puede modificar una imagen que ya tengas. Indícale una foto de tu ordenador o un enlace, describe la edición y recibe una nueva versión, en lugar de generar solo desde cero. En cuanto al vídeo, crea un vídeo a partir de una descripción o da vida a una foto fija, con la duración, la forma y la resolución bajo tu control siempre que el modelo elegido lo permita.

Más allá de la generación, la CLI te mantiene organizado: cambia entre proyectos y espacios de trabajo, y sube una imagen de referencia una vez para reutilizarla en prompts posteriores en lugar de volver a subir el mismo archivo cada vez. Cada resultado se puede guardar como enlace para compartir o descargar directamente en una carpeta, y puedes revisar todo lo que has creado, comprobar un trabajo que sigue en marcha o esperar a que uno 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 Resumen de la CLI para conocer los comandos detrás de cada uno de estos.

Dónde se usa realmente este flujo de trabajo por lotes

Unos cuantos casos concretos explican por qué los equipos recurren a un lote programado en lugar de la aplicación web.

Variantes del catálogo de productos. Un equipo de comercio electrónico con una hoja de cálculo de 500 SKU genera un imagen de producto por fila introduciendo descripciones de producto a través de la variante CSV, con el modelo y las dimensiones de cada fila ajustados a dónde se mostrará la imagen (cuadrada para una cuadrícula de productos, vertical para un anuncio de historia).

Muros de recursos de contenido. Un equipo de contenido o de crecimiento necesita 50 variaciones de miniaturas para un test A/B antes de comer. Una lista de prompts en un archivo de texto y el bucle while-read envían las 50 en el tiempo que tardas en escribir los prompts, en lugar de hacer 50 clics en la aplicación web.

Conjuntos creativos localizados. Un equipo de marketing convierte el mismo concepto base en un conjunto de creatividad publicitaria variantes a partir de una docena de prompts, cada uno con un ajuste, modelo o relación de aspecto distinto para un mercado o canal concreto, usando la variante CSV para variar esos campos en cada fila.

Pipelines de CI y de agentes. Un trabajo nocturno regenera un conjunto fijo de imágenes de vista previa cada vez que cambian los datos de origen, o un agente que ya ejecuta comandos de shell envía generaciones como parte de un flujo de trabajo de llamadas a herramientas más amplio — el mismo patrón detrás de generar anuncios de productos desde Claude. Ambos necesitan --json salida y códigos de salida no interactivos, no una sesión de navegador.

Cuándo recurrir al flujo de trabajo por lotes de la CLI en lugar de la aplicación web o MCP

Usa el flujo de trabajo por lotes de la CLI cuando un script necesite enviar trabajos repetibles, conservar los IDs de trabajo y recopilar resultados sin intervención manual. Es ideal para ejecuciones de CI programadas, pipelines de shell, procesamiento masivo de prompts y llamadas a herramientas de agentes que ejecutan comandos de terminal.

Usar OpenArt para sesiones creativas puntuales en las que quieres ajustar prompts y ajustes mientras revisas cada resultado. OpenArt MCP integra la generación conversacional dentro de agentes como Claude o ChatGPT, donde la conversación controla la solicitud en lugar de un script de 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.

Elige la interfaz que se ajuste a tu forma de trabajar. El repositorio de GitHub de la CLI cubre la instalación y la referencia completa de comandos. La visión general de MCP anterior cubre la generación basada en chat, si eso encaja mejor con tu flujo de trabajo que el procesamiento por lotes basado en archivos.

Preguntas frecuentes

¿Qué pasa si un trabajo falla a mitad de lote?

Un trabajo fallido no cancela los trabajos ya enviados. Tu bucle de recopilación debería registrar el ID del trabajo fallido y continuar, a menos que el script se detenga con los errores. Inspecciona el trabajo fallido con openart creation get <job-id>.

¿Cómo configuro un tiempo de espera más largo sin --async?

El --timeout <seconds> la opción amplía cuánto espera un comando de generación síncrono. Por ejemplo, añade --timeout 900 para esperar hasta 15 minutos. Confirma el valor admitido con openart generate image --help.

¿Puedo usar --async con -o o --output?

El envío asíncrono devuelve un ID de tarea antes de que la imagen exista, por lo que el comando generate no puede guardar la imagen terminada de inmediato. En su lugar, guarda el ID de tarea durante el envío. Usa openart creation wait <job-id> después para recopilar el resultado y gestionar su salida.

¿Cómo vuelvo a ejecutar solo los prompts fallidos?

Una nueva ejecución requiere un registro que asocie cada prompt con el ID del trabajo enviado. Durante la recopilación, escribe los IDs fallidos y sus prompts en un archivo aparte. Vuelve a introducir ese archivo en el bucle de envío después de corregir cualquier prompt o parámetro no válido.

¿Enviar cientos de trabajos a la vez alcanzará un límite de frecuencia?

El bucle tal cual está escrito envía tan rápido como el shell pueda iterar, lo que puede superar un límite de tasa en un lote grande. Añade un breve sleep 0.5 dentro del bucle después de cada envío, o lleva un contador y haz una pausa de unos segundos cada 20 o 50 prompts, para mantener una frecuencia de solicitudes estable en lugar de enviarlas en ráfagas.

¿--dry-run funciona junto con --async?

Sí. Combinarlos previsualiza la petición exacta de una tarea que de otro modo se ejecutaría de forma asíncrona, sin enviarla ni gastar créditos. Mantén ambos flags en el comando de ejemplo mientras pruebas y luego quita solo --dry-run cuando pases al lote real.

¿Cómo llevo el control de qué imagen procede de qué prompt?

Los IDs de trabajo por sí solos no contienen el texto original del prompt. Escribe el prompt y su ID de trabajo en la misma línea de un archivo de registro en el momento del envío, por ejemplo printf '%s\t%s\n' "$job_id" "$prompt" >> submissions.tsv, para que un paso posterior pueda hacer coincidir una imagen terminada con el prompt que la produjo.

¿Dónde acaban las imágenes terminadas?

openart creation wait y openart creation get devuelve los metadatos del trabajo y las URLs de los recursos en JSON, no los archivos de imagen en sí. Añade un paso de descarga, como curl -o "results/${job_id}.png" "$url" usando la URL de ese JSON, si el flujo de trabajo necesita archivos en disco en lugar de enlaces.

¿Este flujo de trabajo por lotes funciona también para la generación de vídeo?

Sí. La CLI refleja los comandos de imagen para vídeo: openart generate video "<prompt>" --model kling-3-omni envía un trabajo de vídeo de la misma forma openart generate image envía un trabajo de imagen. Cambia generate image para generate video en el bucle de envío, y el mismo --json/--async flags más openart creation wait/openart creation get debería aplicarse el patrón de recopilación. Ejecuta openart generate video --help para confirmar cualquier flag específico de vídeo (como la duración) antes de programar un lote grande, ya que los ejemplos y las pruebas de este tutorial cubren específicamente la generación de imágenes.