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

Antes de escribir cualquier script

Este tutorial asume que el binario está instalado y autenticado. Si no, 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 específica o la referencia completa de comandos, consulta el Repositorio de GitHub de la CLI en lugar de repetir la configuración aquí.

Verifica la idoneidad y el costo del modelo antes de gastar nada

Elige un modelo que admita la generación de texto a imagen antes de crear el bucle del lote. La disponibilidad y las capacidades de los modelos pueden cambiar a medida que OpenArt agrega nuevas opciones, así que evita depender de un nombre que recuerdes o de un valor predeterminado implícito.

openart model list

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

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

openart model form "$MODEL_ID" text2image

MODEL_ID="<model-id>"

Revisa el precio por imagen del modelo antes de enviar cualquier trabajo.

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

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

Previsualiza la solicitud exacta con --dry-run

Ejecuta un prompt representativo con el mismo modelo y las mismas banderas planeadas para 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 OpenArt enviaría, incluyendo el prompt, el modelo y los parámetros de generación. OpenArt no envía un trabajo ni gasta créditos durante una prueba en seco.

La cotización de costos estima el precio de cada imagen. El dry run verifica la solicitud en sí. Agrega a este comando cualquier parámetro destinado al lote, inspecciona la salida y corrige valores predeterminados inesperados o problemas de cotización antes de leer el archivo de prompts real.

Da formato a la lista de prompts

Usar prompts.txt cuando cada trabajo comparte el mismo modelo y los mismos 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 salto posterior 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 distintos.

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 usar comillas dobles. Representa una comilla dentro de un campo entre comillas con dos comillas. Un bucle de shell basado en IFS=, no puede procesar esos casos correctamente, así que la variante CSV debería usar un analizador compatible con CSV como el de Python csv módulo. Mantén los nombres de los encabezados estables 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 agrega cada ID de trabajo 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 que el script sea 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 en un campo distinto, inspecciona una respuesta y ajusta el .id expresión.

El --json bandera 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, así 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 y provocar que falle el análisis del ID.

El --async hace que cada comando regrese después de que OpenArt acepta el trabajo. Sin ella, el bucle espera 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 exitoso agrega un identificador a job-ids.txt.

job_abc123
job_def456
job_ghi789

El bucle de recolección puede consumir ese archivo directamente. Los envíos fallidos producen un error en la salida de error estándar y no agregan 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.

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

Recopila los resultados una vez que todo esté enviado

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 registra 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 creación, incluida la información del recurso devuelta. Tu siguiente paso de procesamiento puede leer esos archivos y descargar o mover las imágenes generadas según sea necesario.

Usar openart creation get cuando quieras una verificación de estado sin bloqueo. Una revisión manual o un trabajo de sondeo programado puede ejecutar el mismo bucle con un solo comando cambiado.

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 hace que la generación de imágenes sea en serie. Cada trabajo comenzó después del envío asíncrono anterior, así que los trabajos posteriores siguen ejecutándose mientras el bucle espera el primero. En CI, wait ofrece un punto de finalización claro. Para el monitoreo 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 solo flujo de trabajo: convertir una lista de prompts de texto en un lote de imágenes. La CLI abarca más que eso, y vale la pena saber qué hay disponible antes de crear herramientas separadas para ello.

También puede modificar una imagen que ya tengas. Apúntalo a una foto de tu computadora o a un enlace, describe la edición y obtén una nueva versión, en lugar de generar solo desde cero. En el lado del video, crea un video 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 puede guardarse como un enlace para compartir o descargarse directamente a una carpeta, y puedes revisar todo lo que has creado, verificar un trabajo que aún se está ejecutando 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 Descripción general de la CLI para los comandos detrás de cada uno de estos.

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

Algunos casos concretos explican por qué los equipos recurren a un lote con script en lugar de la app web.

Variantes de 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 alimentando descripciones de productos a través de la variante CSV, con el modelo y las dimensiones de cada fila ajustados a dónde se mostrará la imagen (cuadrado 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 una prueba A/B antes del almuerzo. Una lista de prompts en archivo de texto y el bucle while-read envían los 50 en el tiempo que toma escribir los prompts, en vez de hacer clic 50 veces en la app web.

Conjuntos creativos localizados. Un equipo de marketing convierte el mismo concepto base en un conjunto de creatividad publicitaria variantes a lo largo de una docena de prompts, cada uno con una configuración, modelo o relación de aspecto diferente para un mercado o canal específico, usando la variante CSV para variar esos campos por 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 más grande con llamadas a herramientas: 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 app web o MCP

Usa el flujo de trabajo por lotes del CLI cuando un script necesita enviar trabajos repetibles, conservar los IDs de trabajo y recolectar resultados sin intervención manual. Encaja en ejecuciones de CI programadas, canalizaciones de shell, procesamiento masivo de prompts y llamadas de herramientas de agentes que ejecutan comandos de terminal.

Usar OpenArt para sesiones creativas puntuales en las que quieres ajustar prompts y configuraciones mientras revisas cada resultado. OpenArt MCP encaja 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 del CLI cubre la instalación y la referencia completa de comandos. La descripción general de MCP de arriba 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 del lote?

Un trabajo fallido no cancela los trabajos ya enviados. Tu bucle de recolección debe registrar el ID del trabajo fallido y continuar, a menos que el script se detenga por 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> opción amplía cuánto tiempo espera un comando de generación síncrona. Por ejemplo, agrega --timeout 900 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 trabajo antes de que exista la imagen, así que el comando generate no puede guardar la imagen terminada de inmediato. En su lugar, almacena el ID de trabajo durante el envío. Usa openart creation wait <job-id> después para recopilar el resultado y manejar su salida.

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

Una nueva ejecución requiere un registro que asigne cada prompt a su ID de trabajo enviado. Durante la recolección, escribe los IDs fallidos y sus prompts en un archivo separado. Vuelve a introducir ese archivo en el bucle de envío después de corregir cualquier prompt o parámetro inválido.

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

El bucle tal como 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. Agrega una breve sleep 0.5 dentro del bucle después de cada envío, o lleva un contador y pausa unos segundos cada 20 a 50 prompts, para mantener la tasa de solicitudes estable en lugar de ráfagas.

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

Sí. Combinarlos previsualiza la solicitud exacta de un trabajo que de otro modo se ejecutaría de forma asíncrona, sin enviarlo ni gastar créditos. Mantén ambas banderas en el comando de muestra mientras pruebas, luego quita solo --dry-run cuando pases al lote real.

¿Cómo llevo el registro de qué imagen salió de qué prompt?

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

¿Dónde terminan las imágenes finalizadas?

openart creation wait y openart creation get devuelven los metadatos del trabajo y las URL de los recursos en JSON, no los archivos de imagen en sí. Agrega 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 también funciona para la generación de video?

Sí. La CLI replica los comandos de imagen para video: openart generate video "<prompt>" --model kling-3-omni envía un trabajo de video de la misma manera 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 banderas más openart creation wait/openart creation get el patrón de recolección debería aplicarse. Ejecuta openart generate video --help para confirmar cualquier bandera específica de video (como la duración) antes de crear el script de un lote grande, ya que los ejemplos y las pruebas de este tutorial cubren específicamente la generación de imágenes.