Puntos clave
- Seedream 5.5 es el modelo de imagen más reciente de ByteDance Seed, lanzado el 9 de noviembre de 2026. Un solo modelo cubre texto a imagen, edición de una imagen y edición con varias referencias, con hasta 10 imágenes.
- PoYo ofrece dos ID de modelo.
seedream-5.5genera y edita imágenes;seedream-5.5-layerizedivide una imagen en una imagen base más hasta 99 capas transparentes. - El precio es por imagen. 4 créditos ($0.02) en 1K o 1.5K, 7 créditos ($0.035) en 2K, más 1.6 créditos ($0.008) por cada imagen de referencia. La descomposición en capas se factura por cada imagen devuelta, incluida la imagen base.
- Un PNG transparente está a un parámetro de distancia. Configura
backgroundcomotransparentcon salidapngy obtienes una imagen RGBA, a partir de un prompt o de fotos de referencia RGB normales. - La salida llega hasta 2K (2048×2048 en 1:1, 3136×1344 en 21:9), con una imagen por solicitud.
- Todas las llamadas son asíncronas. Envías la tarea y después consultas el endpoint de estado o pasas una
callback_url. En las pruebas de PoYo, una imagen de Seedream 5.5 tardó unos 24 segundos de media.
Seedream 5.5 API de un vistazo
| Seedream 5.5 en PoYo | |
|---|---|
| Desarrollador | ByteDance Seed (en BytePlus figura como Dola Seedream 5.5) |
| Lanzamiento | 9 de noviembre de 2026 |
| ID de modelo | seedream-5.5, seedream-5.5-layerize |
| Modos | Texto a imagen, edición de imágenes, composición con varias referencias, descomposición en capas |
| Imágenes de referencia | 1–10 (JPEG, PNG o WebP, de hasta 10 MB cada una) |
| Resolución | 1K, 1.5K, 2K (2K por defecto) |
| Relaciones de aspecto | 1:1, 4:3, 3:4, 16:9, 9:16, 3:2, 2:3, 21:9, más auto para ediciones |
| Fondo | auto, transparent, opaque |
| Formato de salida | png (predeterminado) o jpeg |
| Capas | Imagen base + hasta 99 capas, con OCR de texto opcional |
| Precio | 4 créditos ($0.02) en 1K/1.5K, 7 créditos ($0.035) en 2K, +1.6 créditos por imagen de referencia |
Novedades de Seedream 5.5
ByteDance describe Seedream 5.5 como su «modelo de creación de imágenes de nueva generación». El anuncio de lanzamiento y la documentación de la API destacan cuatro mejoras:
- Edición estable en varios turnos. Las zonas no editadas se conservan «a nivel de píxel», con un color uniforme. ByteDance mostró 100 ediciones sucesivas sobre una misma imagen de la misma persona.
- Salida RGBA nativa. El modelo puede «generar directamente imágenes con canal alfa, con transparencia total y parcial», a partir de texto o de hasta 10 imágenes de referencia RGB normales.
- Descomposición en capas más precisa. Una imagen base más hasta 99 capas, un número de imágenes de salida configurable y OCR de texto enriquecido para las capas de texto.
- Texto pequeño más nítido y más realismo. En la evaluación propia de ByteDance, la tasa de deterioro grave del texto bajó al 0.4% y la de deterioro leve al 1.7%, y el realismo en las tareas de imagen a imagen obtuvo un +55.62% de GSB frente a la versión anterior.
ByteDance también indica que «llegará una versión Pro de la serie Seedream 5.5». Para una comparación completa con los modelos anteriores, consulta Seedream 5.5 vs. 5.0 Pro vs. 5.0 Lite.
Qué ID de modelo usar
| Quieres | ID del modelo | Entrada | Salida |
|---|---|---|---|
| Generar una imagen a partir de un prompt | seedream-5.5 | prompt | 1 imagen |
| Editar una imagen o combinar hasta 10 | seedream-5.5 | prompt + image_urls (1–10) | 1 imagen |
| Crear un sticker, un icono o un recorte transparente | seedream-5.5 | prompt (+ image_urls opcional), background: "transparent" | 1 PNG RGBA |
| Dividir una imagen terminada en partes editables | seedream-5.5-layerize | image_urls (exactamente 1) + prompt opcional | Imagen base + capas |
Texto a imagen y edición comparten un mismo ID de modelo: al añadir image_urls, seedream-5.5 pasa al modo de edición.
Parámetros de la solicitud
seedream-5.5
| Parámetro | Tipo | Valores | Predeterminado |
|---|---|---|---|
prompt | string, obligatorio | 5–5.000 caracteres | — |
image_urls | array | 1–10 URL públicas de imágenes; activa el modo de edición | — |
size | string | 1:1, 4:3, 3:4, 16:9, 9:16, 3:2, 2:3, 21:9, auto (ediciones) | 1:1 para texto a imagen, auto para ediciones |
resolution | string | 1K, 1.5K, 2K | 2K |
background | string | auto, transparent (requiere png), opaque | auto |
output_format | string | png, jpeg | png |
enable_safety_checker | boolean | true, false | true |
Con size: "auto", una edición sigue la forma de las imágenes de referencia con aproximadamente el área en píxeles de la resolución elegida.
Tamaños de salida
size | 1K | 1.5K | 2K |
|---|---|---|---|
| 1:1 | 1024×1024 | 1536×1536 | 2048×2048 |
| 4:3 | 1152×864 | 1792×1344 | 2368×1776 |
| 3:4 | 864×1152 | 1344×1792 | 1776×2368 |
| 16:9 | 1424×800 | 2048×1152 | 2816×1584 |
| 9:16 | 800×1424 | 1152×2048 | 1584×2816 |
| 3:2 | 1248×832 | 1872×1248 | 2496×1664 |
| 2:3 | 832×1248 | 1248×1872 | 1664×2496 |
| 21:9 | 1568×672 | 2352×1008 | 3136×1344 |
seedream-5.5-layerize
| Parámetro | Tipo | Valores | Predeterminado |
|---|---|---|---|
image_urls | array, obligatorio | Exactamente 1 JPEG o PNG, de hasta 10 MB, de 512×512 a 6000×6000 px, relación de aspecto de 1:16 a 16:1 | — |
prompt | string | Cómo dividir la imagen, hasta 2.000 caracteres | El modelo elige los elementos principales |
resolution | string | 1K, 1.5K, 2K, auto | auto |
max_images | integer | 2–100, incluida la imagen base | 30 |
text_recognition | boolean | OCR para las capas de texto normales | false |
output_format | string | png, jpeg (solo para la imagen base; las capas son siempre PNG) | png |
enable_safety_checker | boolean | true, false | true |
auto mantiene el tamaño original cuando la entrada está entre 1K y 2K, amplía a 1K las imágenes más pequeñas y reduce a 2K las más grandes.
Precios de Seedream 5.5
PoYo factura Seedream 5.5 por imagen a las mismas tarifas que la API oficial de ByteDance, sin suscripción y con una sola clave de API para todas las versiones de Seedream. $1 = 200 créditos, y los créditos solo se cobran cuando una tarea se completa correctamente.
| Cargo | Créditos | USD |
|---|---|---|
Imagen de seedream-5.5 en 1K o 1.5K | 4 | $0.02 |
Imagen de seedream-5.5 en 2K | 7 | $0.035 |
Cada imagen de referencia en image_urls | 1.6 | $0.008 |
seedream-5.5-layerize, cada imagen devuelta en 1K o 1.5K | 4 | $0.02 |
seedream-5.5-layerize, cada imagen devuelta en 2K o auto | 7 | $0.035 |
Imagen de entrada de seedream-5.5-layerize | 1.6 | $0.008 |
Ejemplos de coste
| Trabajo | Cálculo | Coste |
|---|---|---|
| Un sticker transparente en 1K | 4 | 4 créditos ($0.02) |
| Una foto de producto en 2K a partir de un prompt | 7 | 7 créditos ($0.035) |
| Una edición en 2K de una sola foto | 7 + 1.6 | 8.6 créditos ($0.043) |
| Una composición en 2K a partir de 10 referencias | 7 + 10 × 1.6 | 23 créditos ($0.115) |
| Cinco rondas de edición en varios turnos en 2K, con una referencia cada una | 5 × 8.6 | 43 créditos ($0.215) |
| 1.000 imágenes en 2K, texto a imagen | 1.000 × 7 | 7.000 créditos ($35) |
| División en capas en 1K que devuelve una base + 5 capas (prueba de PoYo) | 6 × 4 + 1.6 | 25.6 créditos ($0.128) |
División en capas en auto que devuelve una base + 32 capas | 33 × 7 + 1.6 | 232.6 créditos ($1.163) |
En la descomposición en capas importan dos detalles. El modelo devuelve tantas capas como necesita la imagen, que pueden ser menos que max_images, y solo pagas por lo que se devuelve. Eso sí, al enviar la tarea tu saldo debe cubrir max_images imágenes: con el valor predeterminado de 30 en auto, son 30 × 7 = 210 créditos.
Inicio rápido: envía una tarea y consulta el resultado
Crea una clave en el panel de claves de API y guárdala en una variable de entorno:
export POYO_API_KEY="your-api-key"
Envía un trabajo al endpoint unificado:
curl --request POST \
--url https://api.poyo.ai/api/generate/submit \
--header "Authorization: Bearer $POYO_API_KEY" \
--header "Content-Type: application/json" \
--data '{
"model": "seedream-5.5",
"input": {
"prompt": "A ceramic pour-over coffee set on a walnut counter, soft morning window light, steam rising from the cup, minimalist product photography",
"size": "16:9",
"resolution": "2K"
}
}'
La respuesta devuelve un task_id:
{
"code": 200,
"data": {
"task_id": "task-unified-1794470400-abcd1234",
"status": "not_started",
"created_time": "2026-11-14T10:30:00"
}
}
Consulta el estado con la misma clave:
curl --request GET \
--url https://api.poyo.ai/api/generate/status/task-unified-1794470400-abcd1234 \
--header "Authorization: Bearer $POYO_API_KEY"
data.status pasa de not_started a running y después a finished (o failed). Cuando el estado es finished, la URL de la imagen está en data.files[].file_url y el cargo en data.credits_amount. También puedes añadir una callback_url de nivel superior a la solicitud de envío y recibir el mismo objeto de tarea por POST cuando la tarea termine o falle.
Para el resto de esta guía, esta función auxiliar de Python envía un trabajo y espera a que termine:
import os
import time
import requests
API = "https://api.poyo.ai/api/generate"
HEADERS = {"Authorization": f"Bearer {os.environ['POYO_API_KEY']}"}
def run(model: str, payload: dict, interval: float = 4, timeout: float = 300) -> dict:
"""Submit a PoYo task and return the finished task data."""
resp = requests.post(
f"{API}/submit",
headers=HEADERS,
json={"model": model, "input": payload},
timeout=30,
)
resp.raise_for_status()
body = resp.json()
if body.get("code") != 200:
raise RuntimeError(body)
task_id = body["data"]["task_id"]
deadline = time.time() + timeout
while time.time() < deadline:
task = requests.get(f"{API}/status/{task_id}", headers=HEADERS, timeout=30).json()["data"]
if task["status"] == "finished":
return task
if task["status"] == "failed":
raise RuntimeError(task.get("error_message"))
time.sleep(interval)
raise TimeoutError(task_id)
Comprueba siempre code en el cuerpo además del estado HTTP: algunos errores de validación devuelven HTTP 200 con code: 400. Otros códigos que conviene gestionar son 401 (clave no válida), 402 (créditos insuficientes) y 429 (límite de frecuencia).
Ejemplo 1: texto a imagen con texto exacto
Seedream 5.5 representa bien el texto denso y pequeño, así que escribe literalmente cada línea que quieras en la imagen. Este es el prompt del póster de la prueba propia de PoYo:
task = run("seedream-5.5", {
"prompt": (
"A vertical exhibition poster for a ceramics show. A realistic photograph of a "
"handmade speckled stoneware vase holding dried pampas grass on a linen-draped plinth, "
"soft side window light and gentle shadows. The poster contains exactly four lines of "
"text and nothing else: the bold serif headline \"CLAY & LIGHT\" at the top, the subtitle "
"\"Handmade Ceramics Exhibition\" under it, and \"March 14 - 30, 2027\" and "
"\"Harbor Gallery, Hall B\" at the bottom. Clean Swiss layout with generous empty space, "
"warm cream background, terracotta accent color."
),
"size": "3:4",
"resolution": "2K",
"output_format": "png",
})
print(task["files"][0]["file_url"]) # 1776×2368 PNG, 7 credits

El póster en 2K de la prueba de Seedream 5.5 de PoYo con el prompt anterior.
Indicar «exactly four lines of text and nothing else» («exactamente cuatro líneas de texto y nada más») mantiene el texto bajo control. En diseños con mucho texto, cuenta con una ejecución adicional para poder elegir el resultado más limpio.
Ejemplo 2: edición con varias referencias
Pasa hasta 10 imágenes y menciónalas por su posición: la primera URL es la imagen 1 y la segunda, la imagen 2. Indica qué aporta cada imagen y qué debe permanecer sin cambios.
{
"model": "seedream-5.5",
"input": {
"prompt": "Place the blue-and-white porcelain vase from image 1 upright at the center of the empty glass display case in image 2. Keep the vase's silhouette, cobalt patterns and glaze, and keep the museum architecture and wooden cabinet unchanged. Match the warm gallery lighting, perspective, scale and a soft contact shadow.",
"image_urls": [
"https://storage.poyo.ai/models/seedream-5-0-flash/examples/museum-input-1.webp",
"https://storage.poyo.ai/models/seedream-5-0-flash/examples/museum-input-2.webp"
],
"size": "4:3",
"resolution": "2K"
}
}
En producción, sustitúyelas por tus propias imágenes públicas HTTPS. Sin size, una edición usa auto por defecto y sigue a las imágenes de referencia. Esta solicitud cuesta 7 + 2 × 1.6 = 10.2 créditos ($0.051).
Ejemplo 3: PNG transparente
Configura background como transparent y mantén output_format en png. Ayuda describir en el prompt un sujeto aislado:
{
"model": "seedream-5.5",
"input": {
"prompt": "A clear glass teapot filled with amber tea and floating chamomile flowers, with a soft natural reflection on the glass, product cutout isolated on a transparent background.",
"size": "1:1",
"resolution": "1K",
"background": "transparent",
"output_format": "png"
}
}
La prueba de PoYo devolvió un PNG RGBA de 1024×1024 en unos 22 segundos por 4 créditos. El vidrio, las sombras suaves y los bordes semitransparentes conservan su transparencia parcial, así que el recorte queda natural sobre cualquier fondo.

Ejemplo de texto a RGBA de la documentación de Seedream 5.5 de ByteDance, sobre un fondo de cuadros para mostrar el canal alfa.
También puedes crear recursos transparentes a partir de fotos. En el ejemplo de ByteDance, dos pósteres de collage entran como referencias y salen como una sola hoja transparente de pegatinas, con un prompt que pide extraer los elementos de pegatina de la imagen 1 y la imagen 2, eliminar todo el resto del contenido del fondo y colocar las pegatinas «por separado, sin solaparse, con los bordes nítidos e intactos».
Ejemplo 4: edición en varios turnos
Para seguir afinando una misma imagen, usa cada resultado como la siguiente referencia e indica qué cambiar y qué conservar:
image = "https://storage.poyo.ai/models/seedream-5-5/examples/transparent-teapot-2c9bec305560.png"
steps = [
"Place the glass teapot from image 1 on a rustic wooden table by a window in soft morning "
"sunlight. Keep the teapot's shape, glass lid, handle, amber tea and floating chamomile "
"flowers unchanged.",
"Add a white ceramic cup of tea next to the teapot. Keep everything else unchanged.",
"Change the time of day to warm late-afternoon light. Keep the teapot, cup, table and "
"window unchanged.",
]
for prompt in steps:
task = run("seedream-5.5", {
"prompt": prompt,
"image_urls": [image],
"size": "1:1",
"resolution": "2K",
"background": "opaque",
})
image = task["files"][0]["file_url"]
print(image)
Para obtener los resultados más uniformes, ByteDance recomienda entradas RGB y background: "opaque" mientras editas. Cambia a transparent solo para el recorte final. Aquí cada ronda cuesta 8.6 créditos, así que los tres pasos cuestan 25.8 créditos ($0.129).

Tres rondas de edición sobre un mismo retrato, de la documentación de Seedream 5.5 de ByteDance.
Ejemplo 5: descomposición en capas
seedream-5.5-layerize recibe exactamente una imagen. Sin prompt, el modelo identifica los elementos principales y coloca cada uno en su propia capa. Esta solicitud divide el póster de cerámica del ejemplo 1:
{
"model": "seedream-5.5-layerize",
"input": {
"image_urls": ["https://storage.poyo.ai/models/seedream-5-5/examples/t2i-clay-and-light-7c708282a2fe.png"],
"resolution": "1K",
"max_images": 6
}
}
Para elegir qué separar, añade un prompt como «Pon cada animal en su propia capa y deja el resto de la escena en la imagen base». En el ejemplo de ByteDance con un prompt de ese tipo, max_images: 40 devolvió 33 imágenes: la imagen base más 32 capas de animales.

Entrada, imagen base y 8 de las 32 capas del ejemplo de descomposición en capas de Seedream 5.5 de ByteDance.
Cuando la tarea termina, data.files incluye un archivo por imagen, con la imagen base en primer lugar. Cada archivo tiene un objeto layer. Este fragmento procede de la prueba de PoYo con el póster anterior, que devolvió una imagen base más 5 capas en unos 30 segundos:
{
"files": [
{
"file_url": "https://storage.poyo.ai/images/task-unified-1794470400-abcd1234/task-unified-1794470400-abcd1234_1.png",
"file_type": "image",
"layer": { "z_index": 0 }
},
{
"file_url": "https://storage.poyo.ai/images/task-unified-1794470400-abcd1234/task-unified-1794470400-abcd1234_2.png",
"file_type": "image",
"layer": {
"z_index": 1,
"name": "Dark brown bold serif main title",
"description": "Dark brown bold serif main title text reading \"CLAY & LIGHT\"",
"bounding_box": {
"absolute": [0, 0, 887, 295],
"normalized": [0, 0, 1000, 250]
}
}
}
]
}
z_indexes 0 para la imagen base y cuenta a partir de 1; las capas más altas quedan encima.bounding_box.absolutees[left, top, right, bottom]en píxeles de la imagen base;normalizedes el mismo cuadro en una escala de 0–1000.nameydescriptionlos redacta el modelo.
Las otras cuatro capas de esa prueba fueron el subtítulo, la mesa cubierta de lino, el jarrón con la hierba de la pampa y el texto con la fecha y el lugar. Para reconstruir la imagen, escala cada capa a su cuadro y apila las capas en el orden de z_index:
from io import BytesIO
import requests
from PIL import Image
def load(url: str) -> Image.Image:
return Image.open(BytesIO(requests.get(url, timeout=60).content)).convert("RGBA")
def rebuild(files: list[dict]) -> Image.Image:
files = sorted(files, key=lambda f: f["layer"]["z_index"])
canvas = load(files[0]["file_url"]) # base image, z_index 0
for f in files[1:]:
left, top, right, bottom = f["layer"]["bounding_box"]["absolute"]
layer = load(f["file_url"]).resize((right - left, bottom - top), Image.LANCZOS)
canvas.alpha_composite(layer, (left, top))
return canvas
Los archivos de capa suelen ser más grandes que su cuadro (la capa del título anterior mide 1775×591 para un cuadro de 887×295), así que redimensiónalos siempre antes de colocarlos. Para colocar las capas en un lienzo de otro tamaño, convierte las coordenadas a partir de normalized.
OCR en las capas de texto
Añade "text_recognition": true y cada capa de texto normal devuelve también layer.text_recognition: el texto completo, cada línea con su cuadro delimitador y fragmentos con estilos aproximados (similar_font_family, foreground_color, bold, italic, underline, strikethrough, shadow, translucent). Las herramientas de diseño pueden aprovecharlo para cambiar el texto, traducir un diseño o reconstruir una plantilla. Las letras artísticas y manuscritas forman parte de las capas de imagen.

Capas de texto y sus resultados de OCR, de la documentación de Seedream 5.5 de ByteDance.
Consejos prácticos
- Elige la resolución según el uso. 1K y 1.5K cuestan lo mismo, 4 créditos, así que usa 1.5K en lugar de 1K para cualquier cosa que puedas llegar a publicar. Pasa a 2K para impresión, imágenes principales y texto fino.
- Vigila el recargo por referencias. Cada imagen de referencia añade 1.6 créditos. Envía solo las imágenes que necesita la edición; una sola referencia bien elegida suele funcionar mejor que cinco poco precisas.
- Redacta las ediciones como cambio + conservación. «Sustituye X por Y. Mantén A, B y C sin cambios» marca al modelo un límite claro y hace más estable la edición en varios turnos.
- Menciona las referencias por su posición. Di «imagen 1», «imagen 2» en el orden de
image_urls. - Mantén
pngpara la transparencia.transparentva conoutput_format: "png", el formato que conserva el canal alfa. - Ajusta
max_imagesal trabajo. Una foto de producto sencilla necesita unas pocas capas; una ilustración cargada se beneficia de 30–60. Los valores más bajos también reducen el saldo que necesitas al enviar la tarea. - Guarda los resultados. Descarga cada
file_urlen tu propio almacenamiento en cuanto termine la tarea. - Usa callbacks a gran escala. Una
callback_urlevita consultar cientos de tareas; haz que el controlador sea idempotente, ya que un evento de finalización puede llegar más de una vez.
Seedream 5.5 frente a otras API de Seedream en PoYo
| Modelo | Ideal para | Resolución máxima en PoYo | Precio por imagen en PoYo |
|---|---|---|---|
| Seedream 5.5 | Ediciones repetidas, PNG transparentes, archivos por capas | 2K | 4 créditos (1K/1.5K) o 7 créditos (2K), +1.6 por referencia |
| Seedream 5.0 Pro | Diseños densos, infografías, texto multilingüe | 2K | 15 créditos |
| Seedream 5.0 Lite | Salida en 3K, tamaños personalizados, series de hasta 15 imágenes | 3K | 5 créditos |
| Seedream 5.0 Flash | Borradores de bajo coste y ediciones con varias referencias | 2K | 4 créditos |
Para comparar en paralelo capacidades, precios y pasos de migración, lee Seedream 5.5 vs. 5.0 Pro vs. 5.0 Lite. Las guías anteriores tratan la API de Seedream 5.0 Pro, las funciones de Seedream 5.0 Pro y Seedream 5.0 Flash.
Preguntas frecuentes
¿Qué es Seedream 5.5?
Seedream 5.5 es el modelo de creación de imágenes de ByteDance Seed, lanzado el 9 de noviembre de 2026. Es el mismo modelo que BytePlus ofrece como Dola Seedream 5.5. Cubre texto a imagen, edición con hasta 10 imágenes de referencia, PNG transparentes nativos y descomposición en una imagen base más hasta 99 capas.
¿Cuánto cuesta la API de Seedream 5.5?
En PoYo, seedream-5.5 cuesta 4 créditos ($0.02) por imagen en 1K o 1.5K y 7 créditos ($0.035) en 2K, más 1.6 créditos ($0.008) por imagen de referencia. seedream-5.5-layerize cobra la misma tarifa por imagen por cada imagen devuelta, incluida la imagen base, más 1.6 créditos por la imagen de entrada; la resolución auto se factura a la tarifa de 2K.
¿Hay una API gratuita de Seedream 5.5?
Seedream 5.5 en PoYo funciona con pago por uso: pagas por cada imagen generada correctamente, sin suscripción ni mínimo, desde $0.02. Una sola clave de API cubre todas las versiones de Seedream, y puedes probar prompts en el Playground de la página del modelo Seedream 5.5 antes de escribir código.
¿Existe Seedream 5.5 Pro?
ByteDance ha anunciado que «llegará una versión Pro de la serie Seedream 5.5». La versión actual es Seedream 5.5, disponible en PoYo como seedream-5.5 y seedream-5.5-layerize.
¿Admite Seedream 5.5 la resolución 4K?
Seedream 5.5 genera en 1K, 1.5K o 2K. Los tamaños más grandes son 2048×2048 en 1:1, 2816×1584 en 16:9 y 3136×1344 en 21:9. Para salida en 3K, usa Seedream 5.0 Lite.
¿Cuántas imágenes de referencia puedo usar?
Hasta 10 por solicitud, como URL públicas JPEG, PNG o WebP de hasta 10 MB cada una. Cada imagen de referencia añade 1.6 créditos. La descomposición en capas recibe exactamente una imagen de entrada.
¿Cómo consigo un fondo transparente?
Configura background como transparent y output_format como png. Funciona tanto en texto a imagen como en ediciones, y las imágenes de referencia pueden ser fotos RGB normales.
¿Cuántas capas puede crear Seedream 5.5?
Hasta 99 capas más la imagen base. Configura max_images entre 2 y 100 (30 por defecto); el modelo devuelve tantas capas como necesita la imagen, hasta ese límite, y solo se facturan las imágenes devueltas.
¿Cuánto tarda una solicitud de Seedream 5.5?
En las pruebas de PoYo de noviembre de 2026, una imagen de seedream-5.5 tardó unos 24 segundos de media y unos 29 segundos en el percentil 90. Las solicitudes de descomposición en capas que devolvieron de 3 a 13 imágenes tardaron entre 18 y 47 segundos aproximadamente.
¿Puede Seedream 5.5 generar varias imágenes en una solicitud?
Cada solicitud de seedream-5.5 devuelve una imagen. Para obtener variaciones, envía solicitudes en paralelo y sigue cada task_id. La descomposición en capas es la excepción: una solicitud devuelve la imagen base y todas sus capas.