Imágenes

Zabio genera imágenes con POST /v1/images/generations y las edita con POST /v1/images/edits, con los formatos que los SDK de OpenAI ya envían. Cambia base_url y tu key, y deja el resto. Una generación larga también puede ejecutarse en segundo plano y recogerse cuando esté lista.

Para el formato exacto de la petición y la respuesta, con ejemplos en curl, Python y Node, consulta la referencia de la API.

Generar una imagen

Envía un prompt y recibe la imagen en base64. La key necesita el scope chat (las keys lo tienen por defecto).

curl https://api.zabio.ai/v1/images/generations \
  -H "Authorization: Bearer inserta aquí tu key de zabio.ai" \
  -H "Content-Type: application/json" \
  -d '{"model": "auto", "prompt": "Un faro rojo en una costa rocosa al atardecer, ilustración plana", "size": "1024x1024"}'

{
  "created": 1793655000,
  "data": [{"b64_json": "/9j/4AAQ..."}],
  "usage": {"input_tokens": 14, "input_tokens_details": {"text_tokens": 14, "image_tokens": 0}, "output_tokens": 1132, "output_tokens_details": {"image_tokens": 1120, "text_tokens": 12}, "total_tokens": 1146},
  "size": "1024x1024",
  "output_format": "jpeg",
  "zabio": {"call_id": "call_...", "vendor": "google", "model_served": "gemini-3.1-flash-lite-image", "cost_micros": 35389, "units": {"kind": "image", "images": 1, "size": "1024x1024"}}
}

Decodifica data[0].b64_json y escríbelo en un archivo con la extensión de output_format.

Modelos

Modelo	Fabricante	Precio	Tamaños	Calidades	Formatos	Notas
gpt-image-2.5-flare	OpenAI	5.00 por millón de tokens de texto de entrada, 8.00 por millón de tokens de imagen de entrada, 30.00 por millón de tokens de imagen de salida (unos 0.21 por imagen de 1024x1024 con calidad alta, el ejemplo de OpenAI para GPT Image 2)	1024x1024, 1536x1024, 1024x1536 y cualquier ANCHOxALTO dentro de los límites de OpenAI	low, medium, high, xhigh, max	png, jpeg, webp	la elección de OpenAI para la generación rápida de cada día; transmite imágenes parciales; fondos transparentes
gpt-image-2.5-sunburst	OpenAI	igual	igual	igual	igual	la elección de OpenAI cuando la precisión de edición importa más
gpt-image-2	OpenAI	igual	igual	low, medium, high	igual	la generación anterior
gpt-image-1-mini	OpenAI	2.00 texto de entrada, 2.50 imagen de entrada, 8.00 imagen de salida por millón de tokens (unos 0.036 por imagen de 1024x1024 con calidad alta, el ejemplo de OpenAI)	1024x1024, 1536x1024, 1024x1536	low, medium, high	igual	solo por su nombre; se retira el 2026-12-01 (fecha de OpenAI)
gemini-nano-banana-2.1	Google	1.50 por millón de tokens de entrada, 7.50 por millón de tokens de salida de texto y razonamiento, 30.00 por millón de tokens de imagen de salida (0.0336 por imagen 1K, 0.0504 por 2K, 0.113 por 4K, cifras del propio Google)	42 tamaños: 14 relaciones de aspecto en 1K, 2K y 4K	solo acepta auto	jpeg	el modelo de cada día de Google; hasta 4K
gemini-3.1-flash-lite-image	Google	0.25 entrada, 1.50 salida de texto y razonamiento, 30.00 salida de imagen (0.0336 por imagen 1K)	14 tamaños: 14 relaciones de aspecto en 1K	solo acepta auto	jpeg	el modelo más rápido y barato de Google
gemini-3-pro-image	Google	2.00 entrada, 12.00 salida de texto y razonamiento, 120.00 salida de imagen (0.134 por imagen 1K o 2K, 0.24 por 4K)	30 tamaños: 10 relaciones de aspecto en 1K, 2K y 4K	solo acepta auto	jpeg	el modelo premium de Google; razona antes de dibujar
flux-2-dev@deepinfra	Black Forest Labs	0.017858 por imagen de 1024x1024, 0.026786 por imagen de 1536x1024 o 1024x1536	1024x1024, 1536x1024, 1024x1536	solo acepta auto	jpeg	FLUX.2 [dev] servido por DeepInfra; solo genera
grok-imagine-image	xAI	0.02 por imagen en cualquier tamaño; 0.002 por imagen de entrada en una edición	1024x1024, 1248x832, 832x1248	solo acepta auto	jpeg	Grok Imagine; ubicación de procesamiento no garantizada (abajo)
grok-imagine-image-2.0	xAI	0.04 por imagen en low, 0.06 en medium, en cualquier tamaño; 0.01 por imagen de entrada en una edición	igual	low, medium (auto se sirve como low)	jpeg	Grok Imagine 2.0; una imagen medium tarda hasta unos dos minutos; ubicación de procesamiento no garantizada (abajo)

Edición: los modelos de OpenAI aceptan hasta 16 imágenes de entrada y una máscara; gemini-nano-banana-2.1 y gemini-3-pro-image aceptan hasta 14 imágenes de entrada y ninguna máscara; gemini-3.1-flash-lite-image acepta una imagen de entrada; grok-imagine-image acepta una imagen de entrada y grok-imagine-image-2.0 hasta cinco, sin máscara; flux-2-dev@deepinfra no edita. GET /v1/models da el número como zabio.media.max_input_images.

Los precios son los de lista de los proveedores en USD, por millón de tokens o por imagen; la tarifa del plan se aplica encima (consulta Facturación). En los modelos de OpenAI y Google, las cifras por imagen entre paréntesis son los ejemplos de los propios proveedores y nunca lo que se cobra en una llamada: esas llamadas se cobran según los tokens que informa el proveedor, tokens de imagen de salida incluidos, así que un prompt sobre el que el modelo razona más tiempo cuesta lo que el proveedor cobra por ello. flux-2-dev@deepinfra se cobra por imagen al precio del tamaño producido, que es lo que cobra DeepInfra. Los modelos de xAI se cobran por imagen, más el precio por imagen de entrada del modelo en una edición (0.002 en grok-imagine-image, 0.01 en grok-imagine-image-2.0), que es lo que cobra xAI. GET /v1/models lista cada modelo de imagen con zabio.kind: "image", sus tamaños (zabio.media.sizes, más custom_sizes cuando acepta cualquier ANCHOxALTO), sus calidades y sus formatos, y la página de modelos indica dónde se procesa cada uno.

Los tamaños personalizados de OpenAI: ambos lados múltiplos de 16, una relación de aspecto entre 1:3 y 3:1, ningún lado por encima de 3840 píxeles, entre 655,360 y 8,294,400 píxeles en total (límites de OpenAI, leídos el 2026-11-02). Los tamaños de Google son los píxeles exactos que sus modelos producen para cada relación de aspecto y nivel, por ejemplo 1376x768 para 16:9 en 1K y 2752x1536 en 2K; 1536x1024 es un tamaño de OpenAI, no de Google. Los tamaños de xAI son los píxeles que xAI produce en 1K: 1024x1024 para 1:1, 1248x832 para 3:2 y 832x1248 para 2:3. 1536x1024 y 1024x1536 no son tamaños de xAI, así que una petición con ellos nunca va a un modelo de xAI, ni por su nombre (400 en size) ni con auto.

Los modelos de imagen de xAI funcionan en el endpoint global de xAI, porque xAI no sirve imágenes en ningún otro: xAI puede procesar esas llamadas en cualquiera de sus regiones, así que su ubicación de procesamiento no está garantizada. Los modelos de chat de xAI siguen en su endpoint de Estados Unidos.

auto

model: auto elige el modelo de imagen más barato que produce el tamaño, la calidad y el formato que pides, según las cifras de precio de los propios proveedores para una imagen de ese tamaño y calidad. Todavía no hay listón de calidad, así que auto, auto/cheap, auto/balanced y auto/best eligen el mismo modelo en este endpoint. Sin quality, gana flux-2-dev@deepinfra en 1024x1024 y grok-imagine-image en sus tamaños 1248x832 y 832x1248; una quality con nombre limita la elección a los modelos que la aceptan (low y medium a los modelos de OpenAI y a grok-imagine-image-2.0, las demás a los de OpenAI); un formato png o webp, un fondo transparente o un tamaño personalizado hacen lo mismo. En una edición, auto solo considera los modelos que aceptan el número de imágenes enviado, contando la tarifa por imagen de entrada de cada modelo, y los de OpenAI cuando se envía una máscara; una edición de una imagen sin máscara va a grok-imagine-image. Si el modelo elegido falla, Zabio prueba el siguiente del mismo proveedor, y los de otros proveedores cuando el ajuste de respaldo de la key lo permite. Una llamada auto paga el precio de la elección automática del modelo (como máximo 0.00025 USD) como cualquier otra llamada auto.

Petición

application/json, como OpenAI.

Campo	Notas
prompt	obligatorio; 32,000 caracteres como máximo
model	un modelo de imagen o auto (por defecto si falta)
n	de 1 a 4 imágenes (1 por defecto)
size	auto (por defecto) o ANCHOxALTO; auto es el valor por defecto del modelo, 1024x1024 en 1K en los modelos de Google
quality	auto (por defecto), low, medium, high, xhigh, max; los modelos de OpenAI, xhigh y max en los modelos 2.5, y low y medium en grok-imagine-image-2.0
output_format	png, jpeg o webp; el valor por defecto del modelo si falta (png en OpenAI, jpeg en Google)
output_compression	de 0 a 100, para jpeg y webp en los modelos de OpenAI
background	auto, transparent u opaque; transparent necesita png o webp y un modelo de OpenAI
moderation	auto o low, el nivel del filtro de contenido de los modelos de OpenAI
stream, partial_images	stream: true con de 0 a 3 imágenes parciales, solo los modelos de OpenAI, una imagen por petición (consulta Streaming)
safety_identifier, user	el identificador de tu usuario final, que se pasa al proveedor
zabio.background	true para ejecutar la generación en segundo plano (consulta Generación en segundo plano); no con stream
zabio.expires_after	en una generación en segundo plano, {"anchor": "created_at", "seconds": N} con N de al menos 3600: cuándo se borran sus imágenes, si es antes que la retención de tu organización

background, moderation y output_compression son ajustes de OpenAI; los demás modelos los ignoran y la respuesta los lista en zabio.ignored. response_format es b64_json (por defecto) o url (ver Imágenes como URL).

Respuesta

El formato de OpenAI: created, data[].b64_json, usage (tokens de entrada con su detalle de texto e imagen, tokens de salida con su detalle de imagen y texto), el size, quality, output_format y background producidos, más el objeto zabio: call_id, vendor, model_served, cost_micros (lo que te costó la llamada, tarifa incluida), units (kind: "image", el número de imágenes, su tamaño y calidad), ignored si hay alguno, y retires_at en un modelo con fecha.

Imágenes como URL

Con "response_format": "url" en una generación o una edición, cada imagen vuelve como un enlace en lugar de base64, como respondían los modelos DALL-E de OpenAI:

{"created": 1793655000, "data": [{"url": "https://api.zabio.ai/v1/images/content/file_...?exp=1793658600&sig=..."}], "usage": {...}, "zabio": {"url_expires_at": 1793658600, ...}}

El enlace funciona durante 60 minutos desde que se crea la imagen, sin tu API key, así que puede ir directo a una etiqueta <img>. zabio.url_expires_at dice cuándo deja de funcionar. Después, o cuando la imagen se borra, el enlace responde 404, igual que cualquier enlace que no sea exactamente uno creado por Zabio. Descarga la imagen dentro de esa hora si quieres conservarla.

El enlace es un enlace al portador: cualquiera que lo tenga puede abrir la imagen hasta que caduque. Compártelo solo donde compartirías la imagen. Zabio guarda cada imagen durante esos 60 minutos, cifrada con la clave de tu organización, como un archivo de propósito image_output que tu key también puede leer en GET /v1/files/{id}/content o borrar al momento con DELETE /v1/files/{id}, lo que también termina el enlace.

En una generación en segundo plano los 60 minutos empiezan cuando se crean las imágenes, no cuando consultas la generación: consúltala dentro de la hora. Borrar la generación borra sus imágenes y termina sus enlaces. Una petición con stream envía solo base64, así que url con stream es un 400. Si Zabio no puede guardar las imágenes después de hecha la llamada, la respuesta las trae como b64_json como siempre e indica zabio.url_unavailable: true, así nunca pierdes una imagen que pagaste. Los enlaces se sirven con Cache-Control: private, no-store: ninguna caché del navegador, proxy o borde los guarda.

Llamadas largas

Una imagen grande o de alta calidad puede tardar más de dos minutos. Zabio mantiene viva la conexión: tras 90 segundos sin respuesta confirma el 200 y escribe un espacio cada 15 segundos hasta que llega el cuerpo, de modo que ni el borde de Zabio ni un proxy delante de tu cliente la cierran. Los SDK de OpenAI leen la respuesta como siempre. Si la generación falla después de ese punto, el cuerpo es {"created": ..., "data": [], "error": {"message", "type", "code"}} con estado 200: comprueba error antes de leer data. Si tu cliente no puede mantener una conexión tanto tiempo, usa la generación en segundo plano.

Generación en segundo plano

Añade "zabio": {"background": true} a una generación y la respuesta llega enseguida, con estado 202 y un id:

{"id": "img_...", "object": "image.generation", "status": "queued", "created_at": 1793655000, "model": "auto", "expires_at": 1796247000, "zabio": {"background": true}}

Zabio ejecuta la generación por su lado. Recógela con GET /v1/images/generations/{id}: mientras se ejecuta vuelve el mismo objeto con estado queued o in_progress; cuando está completed, la respuesta son las propias imágenes, como las devuelve una llamada directa (data[0].b64_json, usage, zabio), con el id y el status al lado y zabio.file_id, el archivo que las guarda (también legible en GET /v1/files/{id}/content). Una generación que falló vuelve con estado failed y un error con su código y su mensaje. Si las imágenes se produjeron pero no pudieron entregarse, el cargo vuelve a tu saldo y el error lo dice. Consulta cada pocos segundos; la mayoría de las imágenes están listas en uno o dos minutos.

DELETE /v1/images/generations/{id} cancela una generación que sigue en cola, y no se cobra nada; una que ya se está ejecutando responde 409 generation_in_progress, porque está en el proveedor y se cobrará. Cuando ha terminado, DELETE la elimina junto con sus imágenes.

GET /v1/images/generations lista tus generaciones, de la más reciente a la más antigua, como los objetos de estado de arriba (nunca las imágenes: para eso, recoge una por su id). limit (de 1 a 100, 20 por defecto) fija el tamaño de la página, after toma el last_id de la página anterior y status deja un solo estado (queued, in_progress, completed, failed o cancelled). La respuesta es {"object": "list", "data": [...], "first_id", "last_id", "has_more"}. Una key de un proyecto ve las generaciones de su proyecto.

Las imágenes se guardan hasta que se cumple la retención de tu organización. "zabio": {"background": true, "expires_after": {"anchor": "created_at", "seconds": 7200}} las borra antes, aquí dos horas después de la petición; un valor más largo que la retención se acorta a ella, y expires_at en la respuesta es el momento que se aplica.

Estos endpoints y campos son extensiones de Zabio, no forman parte de la API de OpenAI. Valen las reglas de una llamada directa: los mismos modelos, el mismo auto, la misma factura, cobrada cuando se producen las imágenes. La generación en segundo plano necesita saldo en la cuenta, que se comprueba al ponerla en cola y otra vez cuando se ejecuta: una generación cuyo saldo llegó a cero mientras esperaba termina failed con insufficient_credits y no cobra nada. Los SDK de OpenAI envían el objeto zabio con extra_body.

Una edición no puede ejecutarse en segundo plano: Zabio nunca guarda las imágenes que envías para editar, y una edición en cola tendría que guardarlas.

Editar una imagen

POST /v1/images/edits acepta el formulario multipart de OpenAI: uno o más archivos image[], una mask opcional y los campos de una generación como valores del formulario.

curl https://api.zabio.ai/v1/images/edits \
  -H "Authorization: Bearer insert your zabio.ai key here" \
  -F model=auto \
  -F "image[]=@sala.png" \
  -F "image[]=@lampara.png" \
  -F prompt="Pon la lámpara sobre la mesa de la sala"

La misma edición puede enviarse como JSON, la forma de la referencia de la API de OpenAI: images es una lista de {"image_url": "data:image/png;base64,..."} o {"file_id": "file_..."}, mask es uno de los dos y los demás campos son los de una generación.

curl https://api.zabio.ai/v1/images/edits \
  -H "Authorization: Bearer insert your zabio.ai key here" \
  -H "Content-Type: application/json" \
  -d '{"model": "auto", "prompt": "Pon la lámpara sobre la mesa de la sala", "images": [{"image_url": "data:image/png;base64,iVBORw0..."}, {"image_url": "data:image/png;base64,iVBORw0..."}]}'

Un image_url tiene que ser una data URL en base64: Zabio no descarga imágenes de direcciones web en este endpoint (400 unsupported_value). Un file_id tiene que ser un archivo con propósito user_data que tu key pueda leer; Zabio lo lee y no lo copia. POST /v1/files solo acepta hoy el propósito batch, así que envía data URLs o el formulario multipart. En JSON el base64 cuenta para el tamaño de la petición, así que la petición lleva unos 75 MB de imágenes.

Las imágenes son png, jpeg o webp, de 50 MB cada una como máximo y 100 MB para toda la petición. La máscara es un png con canal alfa, del tamaño de la primera imagen, a la que se aplica; solo los modelos de OpenAI la aceptan. Los modelos de Google aceptan unos 14 MB de imágenes de entrada en total, el límite que Google fija para las imágenes enviadas en la propia petición. La respuesta, la llamada larga y la factura son las de una generación; una edición en stream envía eventos image_edit.partial_image y image_edit.completed. input_fidelity y markup no se admiten.

Streaming

Con stream: true en un modelo de imagen de OpenAI, las imágenes parciales llegan según se dibujan y el resultado al final:

event: image_generation.partial_image
data: {"type": "image_generation.partial_image", "b64_json": "...", "partial_image_index": 0, "output_format": "png", "created_at": 1793655000}

event: image_generation.completed
data: {"type": "image_generation.completed", "b64_json": "...", "usage": {...}, "size": "1024x1024", "quality": "high", "output_format": "png", "background": "opaque", "zabio": {...}}

partial_images (de 0 a 3) es cuántas imágenes parciales quieres antes de la final; cada una añade 100 tokens de imagen de salida en OpenAI. Una línea de comentario mantiene vivo el stream mientras el modelo calla. Un fallo después de abrirse el stream es un evento error. Solo los modelos de OpenAI transmiten; stream: true en uno de ellos, o con auto cuando ningún modelo que transmite puede atender la petición, es un 400 unsupported_value en stream.

Qué se cobra

En los modelos de OpenAI y Google, los tokens que informa el proveedor, a los precios del modelo: tokens de texto de entrada, tokens de imagen de entrada (las imágenes que envías para editar), tokens de imagen de salida, y tokens de salida de texto o razonamiento en los modelos de Google. En flux-2-dev@deepinfra, el precio de cada imagen del tamaño producido. En los modelos de xAI, el precio de cada imagen en la calidad producida, más el precio por imagen de entrada del modelo en una edición. La tarifa del plan se aplica encima, y la tarifa de auto cuando auto eligió el modelo. Una llamada fallida no cobra nada; una que falló después de confirmarse su 200 tampoco. Un bloqueo de moderación no cobra nada, salvo cuando el proveedor lo cobra: xAI cobra por una imagen que su moderación rechaza (0.02 USD en grok-imagine-image cuando Zabio lo probó el 2026-11-04), así que una petición rechazada en un modelo de xAI se cobra lo que cobró xAI más la tarifa del plan, y su mensaje de error dice cuánto.

Qué se guarda

En una generación o edición directa, nada. El prompt y las imágenes que envías van al proveedor que responde y las imágenes vuelven a ti; Zabio no guarda ninguno de ellos, y ninguno aparece en ningún log. Con response_format: url, las imágenes creadas se guardan durante 60 minutos, cifradas con la clave de tu organización, y cualquiera que tenga un enlace puede abrir su imagen hasta que caduque (ver Imágenes como URL); las imágenes que envías para editar siguen sin guardarse nunca. Con el registro de cuerpos por key activado, el prompt y una referencia a las imágenes (número, tipo, bytes, tamaño) se guardan bajo la retención de tu organización, nunca los bytes de la imagen.

Una generación en segundo plano se guarda: la petición (el prompt incluido) hasta que la generación termina, y las imágenes hasta que las borras o se cumple la retención de tu organización, ambas cifradas con la clave de tu organización. Las vistas de uso cuentan las imágenes (units.images) y la pestaña Uso muestra “N imágenes generadas”.

Las imágenes de Google llevan una marca de agua invisible SynthID. Di a tus usuarios que las imágenes son generadas por IA donde las muestres, como exigen los términos de los proveedores.

Límites y errores

Estado	code	Cuándo
400	invalid_value	un campo fuera de rango (n por encima de 4, un prompt por encima de 32,000 caracteres, un size que no es ANCHOxALTO, una quality o un output_format fuera de la lista), o un modelo con nombre no produce el size ni acepta la quality; param indica cuál
400	invalid_value	zabio.expires_after sin zabio.background, con otro anchor que created_at, o por debajo de 3600 segundos; en la lista, un limit, after o status fuera de sus valores; en una edición JSON, un image_url que no es una data URL en base64, o un file_id que tu key no puede leer o que no tiene propósito user_data
400	unsupported_value	ningún modelo, o el modelo nombrado, produce el output_format, un fondo transparente o un stream para esta petición; o response_format: url en un servidor sin las URL de imagen activadas
400	invalid_value	un response_format distinto de b64_json o url, o url con stream
400	unsupported_value	en una edición: una máscara en un modelo que no la acepta, zabio.background, o un image_url que es una dirección web; en una generación, zabio.background en el plan gratuito
400	unsupported_parameter	style (un campo heredado); en una edición, input_fidelity o markup
400	missing_file, missing_field, invalid_multipart, invalid_json	una edición sin archivo image[] ni lista images, o un cuerpo que no es multipart ni JSON
400	moderation_blocked	el sistema de seguridad del proveedor rechazó el prompt o retuvo la imagen; el mensaje lleva las categorías del proveedor cuando nombra alguna y la fase (entrada o salida), nunca su texto; en los modelos de xAI dice además lo que se cobró por la petición rechazada, porque xAI la cobra
400	unsupported_for_model	el modelo nombrado no es un modelo de imagen
402	insufficient_credits	no queda saldo; en una generación en segundo plano, también el error de una cuyo saldo llegó a cero antes de ejecutarse
404	model_not_found	no es un modelo, no está permitido para la key, o está retirado
404	not_found	un enlace de imagen caducado, modificado, o cuya imagen se borró
409	generation_in_progress	DELETE sobre una generación en segundo plano que se está ejecutando
410	expired	una generación en segundo plano completada cuyas imágenes se borraron o caducaron
413	payload_too_large	el cuerpo JSON supera los 256 KiB
413	media_too_large	una imagen de una edición de más de 50 MB, su cuerpo de más de 100 MB, o sus imágenes por encima del límite del modelo nombrado
503	no_provider_available	el proveedor de este modelo no está configurado, o todavía no ha habilitado la cuenta de Zabio para él
503	background_unavailable	la generación en segundo plano no está disponible en este servidor

Se aplica el límite de peticiones por minuto de la key; el límite de tokens no cuenta los tokens de imagen.

Python

import base64
from openai import OpenAI

client = OpenAI(base_url="https://api.zabio.ai/v1", api_key="inserta aquí tu key de zabio.ai")
res = client.images.generate(model="auto", prompt="Un faro rojo en una costa rocosa al atardecer, ilustración plana", size="1024x1024")
with open("faro.jpg", "wb") as f:
    f.write(base64.b64decode(res.data[0].b64_json))
print(res.model_extra["zabio"]["model_served"], res.model_extra["zabio"]["cost_micros"])

# Una edición
res = client.images.edit(model="auto", image=[open("sala.png", "rb"), open("lampara.png", "rb")], prompt="Pon la lámpara sobre la mesa de la sala")

# Tus generaciones en segundo plano, de la más reciente a la más antigua
page = client.get("/images/generations", options={"params": {"limit": 10, "status": "completed"}}, cast_to=dict)

# En segundo plano
import time
job = client.post("/images/generations", body={"model": "auto", "prompt": "Una ciudad de noche, detallada, 4K", "size": "4096x4096", "zabio": {"background": True}}, cast_to=dict)
while (got := client.get(f"/images/generations/{job['id']}", cast_to=dict))["status"] in ("queued", "in_progress"):
    time.sleep(5)
image = base64.b64decode(got["data"][0]["b64_json"])

CLI

zabio image -o faro.jpg "Un faro rojo en una costa rocosa al atardecer"
zabio image -o cartel.png --model gpt-image-2.5-flare --size 1024x1536 --quality high --format png "Un cartel para una noche de jazz"
zabio image edit -o sala-con-lampara.png "Pon la lámpara sobre la mesa de la sala" sala.png lampara.png
zabio image edit -o sombrero.png --mask mascara.png "Añade un sombrero rojo" retrato.png
zabio image --background --size 4096x4096 "Una ciudad de noche, detallada, 4K"   # imprime img_...
zabio image status img_...
zabio image get -o ciudad.png img_...