API de Imagen a Video de Seedance 2.0: Anima cualquier imagen con control total

Una sola foto de producto almacenada en su disco duro genera cero interacción. Un video de 10 segundos de ese producto rotando bajo iluminación de estudio, con sonido sincronizado, genera clics, compartidos y ventas. La API de imagen a video de Seedance 2.0 convierte cualquier imagen estática en un video completamente controlable, mediante una sola solicitud POST.

Esta guía cubre tres modos distintos de imagen a video: animación de imagen única, interpolación de primer y último fotograma, y composición multi-imagen con referencias @tag. Cada sección incluye código Python completo y ejecutable, demos reales de salida y los prompts exactos que los generaron.

Qué hace diferente a la imagen a video de Seedance 2.0

Todas las principales plataformas de video con IA ofrecen ahora alguna forma de generación de imagen a video. Sora acepta una sola imagen como fotograma inicial. Kling proporciona animación de imágenes con control básico de movimiento. Veo 2 soporta condicionamiento por imagen para guía de estilo. Todas resuelven el mismo problema superficial: convertir una imagen en píxeles en movimiento.

Seedance 2.0 resuelve un problema completamente diferente. Le ofrece control composicional sobre múltiples imágenes dentro de una sola solicitud de generación, y lo hace a través de un sistema de etiquetado que ninguna otra API iguala actualmente.

Las diferencias fundamentales

El sistema @tag es donde Seedance 2.0 toma la delantera. Cuando sube tres imágenes, puede escribir un prompt como:

@Image1 is the main character. @Image2 is the background environment.
@Image3 is the art style reference. The character walks through the environment
in the style of @Image3.

Cada imagen recibe un rol semántico específico. El modelo no adivina cuál imagen es el personaje y cuál es el fondo: usted se lo indica explícitamente. Para una exploración detallada de este sistema de etiquetado, consulte la Guía de @Tags Multimodales.

Por qué los @Tags importan para los desarrolladores

Si ha trabajado con otras APIs de imagen a video, conoce la frustración: sube múltiples imágenes y espera que el modelo descifre su intención. A veces usa la imagen de fondo como personaje. A veces mezcla todas las imágenes en un resultado incoherente. No hay forma de depurar esto porque no tiene control sobre cómo el modelo interpreta cada entrada.

El sistema @tag elimina esta incertidumbre. Es esencialmente un sistema de vinculación de variables: usted nombra cada entrada y la referencia explícitamente en sus instrucciones. Esto hace que la generación de imagen a video sea determinista y reproducible. Las mismas entradas, las mismas etiquetas, el mismo prompt producen la misma interpretación semántica cada vez.

Para pipelines de producción, esta es la diferencia entre "probar y ver qué pasa" y "configurar y desplegar". Puede crear plantillas, validar salidas e iterar sobre elementos específicos sin que toda la composición cambie de forma impredecible.

El audio nativo cambia el resultado

La mayoría de las herramientas de IA para imagen a video producen clips silenciosos. Luego necesita un paso separado de generación de audio, una llamada API adicional y un paso de edición de video para combinarlos. Seedance 2.0 genera audio sincronizado como parte de la misma solicitud configurando generate_audio: true. Los pasos coinciden con el movimiento al caminar. Los sonidos del viento coinciden con escenas al aire libre. Esto elimina un paso completo de postproducción.

Lo que no hará

Seedance 2.0 no admite rostros humanos realistas en la generación de imagen a video. Si su imagen de entrada contiene un rostro humano fotorrealista, la API rechazará la solicitud automáticamente. Los personajes ilustrados, rostros estilizados, personajes de anime y retratos no fotorrealistas funcionan perfectamente. Esta es una restricción de seguridad deliberada, no una limitación técnica.

Configuración rápida: clave API y entorno

Necesita tres cosas: una cuenta de EvoLink, una clave API y la biblioteca requests. Toda la configuración toma menos de un minuto.

Paso 1: Obtenga su clave API

1. Vaya a evolink.ai y cree una cuenta gratuita
2. Navegue a la sección de Claves API en su panel de control
3. Genere una nueva clave y cópiela

Su clave comienza con sk- y se ve así: sk-XpXn...Ms1N.

Paso 2: Instale las dependencias

pip install requests

Eso es todo. No hay SDK que instalar ni flujos de autenticación complejos. La API usa REST estándar con autenticación Bearer token.

Paso 3: Configure su entorno Python

import requests
import time
import json

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.evolink.ai/v1"
HEADERS = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

Todos los ejemplos de código en esta guía se basan en estas tres variables. Reemplace YOUR_API_KEY con su clave real y estará listo para generar.

Obtenga su clave API gratuita de EvoLink →

La función auxiliar de sondeo

Dado que la generación de video toma entre 60 y 180 segundos, necesita una función para sondear hasta la finalización. Esta función auxiliar funciona en los tres modos de imagen a video:

def wait_for_video(task_id, interval=5, max_wait=300):
    """Poll the task endpoint until the video is ready."""
    url = f"{BASE_URL}/tasks/{task_id}"
    elapsed = 0

    while elapsed < max_wait:
        resp = requests.get(url, headers=HEADERS)
        data = resp.json()
        status = data["status"]

        if status == "completed":
            video_url = data["output"]["video_url"]
            print(f"Video ready: {video_url}")
            return data
        elif status == "failed":
            print(f"Generation failed: {data.get('error', 'Unknown error')}")
            return data

        print(f"Status: {status} ({elapsed}s elapsed)")
        time.sleep(interval)
        elapsed += interval

    print("Timed out waiting for video")
    return None

El estado de la tarea sigue un ciclo de vida simple: pending → processing → completed o failed. Las URLs de video en la respuesta expiran después de 24 horas: descárguelas o sírvelas antes de ese plazo.

Para un recorrido completo de los fundamentos de la API (texto a video, parámetros, manejo de errores), consulte la Guía de Inicio.

Modo 1: Animación de imagen única

La animación de imagen única es el flujo de trabajo de imagen a video más común. Usted proporciona una imagen y un prompt describiendo el movimiento deseado. El modelo preserva el contenido visual de su imagen mientras añade movimiento realista, movimiento de cámara y efectos ambientales.

Cómo funciona

Cuando pasa exactamente una URL en image_urls, Seedance 2.0 la trata como la referencia visual principal. El modelo ancla el primer fotograma a su imagen y genera movimiento hacia adelante basándose en su prompt. La salida preserva:

• Paleta de colores de la imagen fuente
• Composición y encuadre
• Identidad del sujeto (vestimenta, forma, rasgos)
• Estilo artístico (ilustración, renderizado 3D, fotografía)

Su prompt controla lo que cambia: movimiento, ángulos de cámara, cambios de iluminación y dinámica ambiental.

Código completo: Imagen única a video

import requests
import time

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.evolink.ai/v1"
HEADERS = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

def wait_for_video(task_id, interval=5, max_wait=300):
    url = f"{BASE_URL}/tasks/{task_id}"
    elapsed = 0
    while elapsed < max_wait:
        resp = requests.get(url, headers=HEADERS)
        data = resp.json()
        status = data["status"]
        if status == "completed":
            print(f"Video ready: {data['output']['video_url']}")
            return data
        elif status == "failed":
            print(f"Failed: {data.get('error', 'Unknown error')}")
            return data
        print(f"Status: {status} ({elapsed}s)")
        time.sleep(interval)
        elapsed += interval
    return None

# --- Single Image Animation ---
payload = {
    "model": "seedance-2.0",
    "prompt": (
        "The woman in the painting slowly reaches for a coffee cup on the table, "
        "lifts it to her lips, and takes a quiet sip. Soft morning light filters "
        "through a nearby window. Gentle steam rises from the cup. "
        "Painterly brushstroke texture preserved throughout."
    ),
    "image_urls": [
        "https://example.com/painting-woman.jpg"
    ],
    "duration": 8,
    "quality": "1080p",
    "aspect_ratio": "16:9",
    "generate_audio": True
}

resp = requests.post(
    f"{BASE_URL}/videos/generations",
    headers=HEADERS,
    json=payload
)
result = resp.json()
print(f"Task ID: {result['task_id']}")

# Poll until complete
video_data = wait_for_video(result["task_id"])

Ejecute esto con su propia clave API. Sustituya el valor de image_urls por cualquier URL de imagen accesible públicamente.

Demo: La pintura cobra vida

Prompt utilizado: "The woman in the painting slowly reaches forward, picks up a coffee cup from the table, and takes a quiet sip. Soft indoor lighting. Painterly brushstroke style maintained. Subtle steam rises from the cup."

Esta demo utiliza un único retrato pintado como @Image1 (la referencia del personaje). El modelo preserva la estética de pintura al óleo mientras genera movimiento natural del brazo y física del vapor.

Demo: Animación con transferencia de estilo

Prompt utilizado: "A young girl walks along a winding path through a Van Gogh-style village. Swirling sky with thick brushstrokes. Vibrant yellows and blues. The girl's dress and hair flow in the wind. Camera slowly follows her from behind."

Observe cómo el estilo de pinceladas de Van Gogh de la imagen de entrada se mantiene en cada fotograma: el cielo arremolinado, la textura de impasto en los edificios, las relaciones cromáticas. La animación de imagen única destaca en el movimiento consistente con el estilo.

Mejores prácticas de prompts para el modo de imagen única

Su prompt determina la calidad de la animación. Las descripciones estáticas producen videos estáticos. Los prompts ricos en movimiento producen resultados dinámicos.

Prompt débil:

A cat sitting on a windowsill

Prompt fuerte:

The cat stretches lazily on the windowsill, yawns wide showing tiny teeth,
then curls back into a ball. Afternoon sunlight shifts slowly across the fur.
Dust motes float in the light beam. Camera holds steady, slight depth of field.

La diferencia: el prompt fuerte especifica acciones secuenciales (se estira → bosteza → se acurruca), movimiento ambiental (la luz del sol se desplaza, motas de polvo) y comportamiento de cámara (estable, profundidad de campo).

Principios clave para prompts de imagen única:

Para una referencia completa de ingeniería de prompts, consulte la Guía de Prompts de Seedance 2.0. Para técnicas específicas de cámara, consulte la Guía de Movimientos de Cámara.

Modo 2: Control de primer y último fotograma

El modo de imagen única ancla el inicio de su video. El modo de primer y último fotograma ancla ambos extremos. Usted proporciona dos imágenes, el fotograma de apertura y el de cierre, y Seedance 2.0 genera una transición suave entre ellos.

Cómo funciona

Cuando image_urls contiene exactamente dos URLs, el modelo las interpreta como:

• Primera URL → fotograma inicial
• Segunda URL → fotograma final

El modelo genera entonces fotogramas intermedios que crean una transición natural y físicamente plausible. Su prompt guía el estilo de la transición, ya sea una transformación suave, un viaje narrativo o una transformación dramática.

Casos de uso

El control de primer y último fotograma resuelve problemas que el modo de imagen única no puede:

• Revelaciones antes/después: renovación, cambio de imagen, cambio estacional
• Simulación de time-lapse: del amanecer al atardecer, de habitación vacía a habitación amueblada
• Transiciones de escena: una ubicación transformándose en otra
• Transformación de producto: del empaque cerrado a la exhibición del producto abierto
• Efectos de morphing: un personaje o estilo convirtiéndose en otro

Código completo: Interpolación de primer y último fotograma

import requests
import time

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.evolink.ai/v1"
HEADERS = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

def wait_for_video(task_id, interval=5, max_wait=300):
    url = f"{BASE_URL}/tasks/{task_id}"
    elapsed = 0
    while elapsed < max_wait:
        resp = requests.get(url, headers=HEADERS)
        data = resp.json()
        status = data["status"]
        if status == "completed":
            print(f"Video ready: {data['output']['video_url']}")
            return data
        elif status == "failed":
            print(f"Failed: {data.get('error', 'Unknown error')}")
            return data
        print(f"Status: {status} ({elapsed}s)")
        time.sleep(interval)
        elapsed += interval
    return None

# --- First-Last Frame Control ---
payload = {
    "model": "seedance-2.0",
    "prompt": (
        "Smooth cinematic transition. The real-world landscape gradually "
        "transforms into a traditional Chinese ink wash painting. Mountains "
        "dissolve from photorealistic to brushstroke. Water becomes flowing ink. "
        "Sky shifts from blue to rice-paper white. Slow, meditative pace."
    ),
    "image_urls": [
        "https://example.com/real-landscape.jpg",
        "https://example.com/ink-wash-painting.jpg"
    ],
    "duration": 10,
    "quality": "1080p",
    "aspect_ratio": "16:9"
}

resp = requests.post(
    f"{BASE_URL}/videos/generations",
    headers=HEADERS,
    json=payload
)
result = resp.json()
print(f"Task ID: {result['task_id']}")

video_data = wait_for_video(result["task_id"])

Demo: De la realidad a la pintura de tinta

Prompt utilizado: "The real-world mountain landscape gradually transforms into a traditional Chinese ink wash (山水画) painting. Photorealistic textures dissolve into flowing brushstrokes. Colors fade from vivid to monochrome ink tones. Water surfaces become calligraphic ink flows. Slow, contemplative transition."

El primer fotograma es un paisaje montañoso fotorrealista. El último fotograma es una pintura de tinta china tradicional de una escena similar. El modelo crea una transformación sin fisuras donde las texturas fotográficas se disuelven progresivamente en pinceladas, un efecto que tomaría horas lograr manualmente en After Effects.

Consejos para el modo de primer y último fotograma

Haga coincidir la composición entre fotogramas. Si su primer fotograma tiene una montaña a la izquierda, su último fotograma debería tener un elemento estructural similar en la misma posición. El modelo genera mejores transiciones cuando ambos fotogramas comparten aproximadamente la misma disposición.

Describa la transición, no solo los puntos extremos. El modelo ya sabe cómo se ven el inicio y el final, tiene las imágenes. Su prompt debe describir cómo llegar del punto A al punto B.

# Weak: just describes the endpoints
"A sunrise and a sunset"

# Strong: describes the journey
"The golden dawn light gradually warms to midday brightness,
then softens through amber afternoon hues into deep sunset oranges.
Shadows rotate clockwise. Cloud formations shift and reform."

Use duraciones más largas para transiciones complejas. Un simple cambio de color funciona en 4 segundos. Una transformación de estilo (fotorrealista a ilustrado) se beneficia de 8 a 12 segundos. Los cambios abruptos en duraciones cortas se ven bruscos.

Modo 3: Composición multi-imagen con @Tags

Este es el modo de imagen a video más potente de Seedance 2.0, y el que ninguna API competidora ofrece. Usted proporciona hasta 9 imágenes, asigna a cada una un rol semántico usando etiquetas @Image en su prompt, y el modelo las compone en un solo video coherente.

Cómo funcionan los @Tags

Cuando incluye múltiples URLs en image_urls, Seedance 2.0 les asigna etiquetas secuenciales según su posición en el array:

image_urls[0] → @Image1
image_urls[1] → @Image2
image_urls[2] → @Image3
...
image_urls[8] → @Image9

Usted referencia estas etiquetas en su prompt para indicarle al modelo exactamente cómo usar cada imagen:

@Image1 is the main character running through the city.
@Image2 is the city skyline in the background.
@Image3 defines the color grading and visual mood.

Sin etiquetas, el modelo tendría que adivinar cuál imagen es el personaje y cuál es el fondo. Con etiquetas, no hay ambigüedad. Esto es especialmente importante cuando sus imágenes se ven visualmente similares o cuando desea que una imagen específica controle el estilo en lugar del contenido.

Código completo: Composición multi-imagen

import requests
import time

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.evolink.ai/v1"
HEADERS = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

def wait_for_video(task_id, interval=5, max_wait=300):
    url = f"{BASE_URL}/tasks/{task_id}"
    elapsed = 0
    while elapsed < max_wait:
        resp = requests.get(url, headers=HEADERS)
        data = resp.json()
        status = data["status"]
        if status == "completed":
            print(f"Video ready: {data['output']['video_url']}")
            return data
        elif status == "failed":
            print(f"Failed: {data.get('error', 'Unknown error')}")
            return data
        print(f"Status: {status} ({elapsed}s)")
        time.sleep(interval)
        elapsed += interval
    return None

# --- Multi-Image Composition with @Tags ---
payload = {
    "model": "seedance-2.0",
    "prompt": (
        "@Image1 is a parkour runner in dark athletic gear. "
        "@Image2 is a futuristic city rooftop at twilight. "
        "@Image3 is a neon-lit alleyway. "
        "@Image4 is a glass skyscraper facade. "
        "@Image5 provides the cyberpunk color grading reference. "
        "The runner (@Image1) sprints across the rooftop (@Image2), "
        "leaps over the edge, flips through the alleyway (@Image3), "
        "and wall-runs along the skyscraper (@Image4). "
        "Dynamic handheld camera follows the action. "
        "Cyberpunk neon color palette from @Image5 throughout."
    ),
    "image_urls": [
        "https://example.com/runner.jpg",
        "https://example.com/rooftop.jpg",
        "https://example.com/alley.jpg",
        "https://example.com/skyscraper.jpg",
        "https://example.com/cyberpunk-ref.jpg"
    ],
    "duration": 10,
    "quality": "1080p",
    "aspect_ratio": "16:9",
    "generate_audio": True
}

resp = requests.post(
    f"{BASE_URL}/videos/generations",
    headers=HEADERS,
    json=payload
)
result = resp.json()
print(f"Task ID: {result['task_id']}")

video_data = wait_for_video(result["task_id"])

Demo: Parkour urbano con 5 referencias de imagen

Prompt utilizado: "@Image1 is the parkour runner. @Image2 is the rooftop environment. @Image3 is the neon alley. @Image4 is the glass building. @Image5 is the color palette reference. The runner (@Image1) sprints across the rooftop (@Image2), leaps, flips through the alley (@Image3), wall-runs along the building (@Image4). Dynamic tracking camera. Cyberpunk color grading from @Image5."

Cinco imágenes separadas, un personaje, tres entornos y una referencia de estilo, se combinan en una sola secuencia de acción continua. Cada etiqueta @Image le da al modelo instrucciones precisas sobre qué elemento visual controla qué parte de la escena.

Asignaciones comunes de roles con @Tag

El sistema @tag es flexible. Estos son los patrones más efectivos:

Demo: Personaje con referencia de estilo

Prompt utilizado: "@Image1 is the character — a mysterious figure in a red coat. The character runs through rain-soaked city streets at night. Neon reflections on wet pavement. Camera tracks alongside at medium distance. Cinematic atmosphere, shallow depth of field."

Una sola imagen de referencia de personaje controla la identidad mientras el prompt dirige el entorno y la acción. El abrigo rojo, las proporciones corporales y el estilo de movimiento derivan todos de @Image1.

Para la referencia completa de @tag, incluyendo etiquetas de video y audio, combinaciones de medios mixtos y patrones avanzados de roles, consulte la Guía de @Tags Multimodales.

Mantener la consistencia de personajes entre tomas

Un solo clip generado es útil. Una secuencia de clips con el mismo personaje en diferentes escenas es una historia. La consistencia de personajes es el problema más difícil en la generación de video con IA, y el sistema @tag de Seedance 2.0 proporciona la solución más fiable disponible a través de una API.

El patrón de bloqueo de personaje

Para mantener el mismo personaje en múltiples tomas, use la misma imagen de referencia de personaje como @Image1 en cada solicitud de generación. Cambie únicamente el prompt y las imágenes de fondo/entorno.

CHARACTER_IMAGE = "https://example.com/my-character.jpg"

shots = [
    {
        "prompt": (
            "@Image1 is the main character. She walks into a cozy library, "
            "looks around with wonder, and reaches for a book on the top shelf. "
            "Warm golden lighting. Camera at eye level, slow push in."
        ),
        "extra_images": [],
        "duration": 8
    },
    {
        "prompt": (
            "@Image1 is the main character. She sits at a wooden reading table, "
            "opens the book, and pages start glowing with magical light. "
            "Dust particles float in warm lamplight. Camera orbits slowly around her."
        ),
        "extra_images": [],
        "duration": 10
    },
    {
        "prompt": (
            "@Image1 is the main character. She steps out of the library into "
            "a fantastical world that matches the book's illustrations. "
            "Vibrant colors replace the muted library tones. "
            "Camera pulls back to reveal the vast landscape. Wide shot."
        ),
        "extra_images": [],
        "duration": 10
    },
]

def generate_shot(shot):
    image_urls = [CHARACTER_IMAGE] + shot["extra_images"]
    payload = {
        "model": "seedance-2.0",
        "prompt": shot["prompt"],
        "image_urls": image_urls,
        "duration": shot["duration"],
        "quality": "1080p",
        "aspect_ratio": "16:9"
    }
    resp = requests.post(
        f"{BASE_URL}/videos/generations",
        headers=HEADERS,
        json=payload
    )
    return resp.json()["task_id"]

# Generate all shots
task_ids = [generate_shot(shot) for shot in shots]
print(f"Submitted {len(task_ids)} shots: {task_ids}")

# Poll each shot
for i, task_id in enumerate(task_ids):
    print(f"\nWaiting for Shot {i+1}...")
    wait_for_video(task_id)

Demo: Secuencia narrativa en la biblioteca

Prompt utilizado: "@Image1 is a young girl with braids. She enters a grand old library, runs her fingers along the spines of ancient books, pulls one out, and opens it. Golden dust motes swirl in shaft of light from a high window. Warm, magical atmosphere. Camera follows her at child's eye level."

El personaje, una niña con trenzas, se mantiene visualmente consistente porque la misma imagen de referencia ancla cada toma. El modelo preserva sus proporciones, vestimenta y características visuales mientras genera diferentes acciones y entornos.

Consejos de consistencia

Use una referencia de personaje clara y bien iluminada. El modelo extrae rasgos de identidad de su imagen de referencia. Una imagen borrosa, mal iluminada o muy ocluida le da al modelo menos información con la que trabajar. Las tomas frontales, de cuerpo completo o de medio cuerpo con fondos limpios producen la mejor consistencia.

Mantenga la descripción del personaje al mínimo en los prompts. Si @Image1 ya muestra a una chica con vestido azul, no escriba "una chica con vestido rojo" en el prompt. Las descripciones contradictorias obligan al modelo a elegir entre su imagen y su texto, reduciendo la consistencia.

Mantenga la misma relación de aspecto en todas las tomas. Cambiar de 16:9 a 9:16 a mitad de secuencia fuerza un encuadre diferente, lo que puede alterar cómo aparece el personaje. Elija una relación y manténgala.

Añada imágenes de entorno como @tags separados. En lugar de describir el fondo completamente en texto, proporcione una imagen de referencia de fondo como @Image2. Esto le da control preciso sobre el personaje y el entorno manteniéndolos visualmente separados.

# Shot 1: Character in library
"image_urls": [CHARACTER_IMAGE, "https://example.com/library.jpg"]
# Prompt: "@Image1 is the character. @Image2 is the library environment."

# Shot 2: Character in forest
"image_urls": [CHARACTER_IMAGE, "https://example.com/forest.jpg"]
# Prompt: "@Image1 is the character. @Image2 is the forest environment."

Este patrón, @Image1 fijo para el personaje, @Image2 variable para el entorno, es el flujo de trabajo multi-toma más fiable disponible a través de cualquier API de video con IA actual.

Avanzado: Pipeline narrativo multi-toma

Para narrativas más largas (más de 30 segundos), necesita generar múltiples clips y unirlos. Aquí tiene un enfoque estructurado que gestiona el pipeline completo: definición de lista de tomas, generación paralela y salida ordenada:

import concurrent.futures
import requests
import time
import json

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.evolink.ai/v1"
HEADERS = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

CHARACTER_REF = "https://example.com/story-character.jpg"

SHOT_LIST = [
    {
        "shot_id": "01_entrance",
        "prompt": (
            "@Image1 is the main character. "
            "She pushes open a heavy wooden door and steps into a dimly lit room. "
            "Dust swirls in the doorway light. "
            "Camera follows her from behind, over-the-shoulder angle."
        ),
        "env_images": [],
        "duration": 6
    },
    {
        "shot_id": "02_discovery",
        "prompt": (
            "@Image1 is the main character. @Image2 is the room interior. "
            "She walks to the center of the room and discovers a glowing object on a pedestal. "
            "Her face shows surprise. Blue light illuminates her features. "
            "Camera pushes in from medium shot to close-up on her expression."
        ),
        "env_images": ["https://example.com/mysterious-room.jpg"],
        "duration": 8
    },
    {
        "shot_id": "03_transformation",
        "prompt": (
            "@Image1 is the main character. "
            "She reaches out and touches the glowing object. "
            "Light radiates outward from the point of contact. "
            "The room transforms — walls dissolve into a starfield. "
            "Camera rapidly pulls back to extreme wide shot."
        ),
        "env_images": [],
        "duration": 10
    },
]

def submit_shot(shot):
    """Submit a single shot for generation."""
    image_urls = [CHARACTER_REF] + shot["env_images"]
    payload = {
        "model": "seedance-2.0",
        "prompt": shot["prompt"],
        "image_urls": image_urls,
        "duration": shot["duration"],
        "quality": "1080p",
        "aspect_ratio": "16:9",
        "generate_audio": True
    }
    resp = requests.post(f"{BASE_URL}/videos/generations", headers=HEADERS, json=payload)
    task_id = resp.json()["task_id"]
    return {"shot_id": shot["shot_id"], "task_id": task_id}

def poll_until_done(task_id, max_wait=300):
    """Block until task completes or fails."""
    url = f"{BASE_URL}/tasks/{task_id}"
    elapsed = 0
    while elapsed < max_wait:
        data = requests.get(url, headers=HEADERS).json()
        if data["status"] in ("completed", "failed"):
            return data
        time.sleep(5)
        elapsed += 5
    return None

# Submit all shots in parallel
results = []
for shot in SHOT_LIST:
    result = submit_shot(shot)
    results.append(result)
    print(f"Submitted {result['shot_id']} → {result['task_id']}")
    time.sleep(0.5)

# Collect results in order
final_videos = []
for r in results:
    print(f"\nPolling {r['shot_id']}...")
    data = poll_until_done(r["task_id"])
    if data and data["status"] == "completed":
        video_url = data["output"]["video_url"]
        final_videos.append({"shot_id": r["shot_id"], "url": video_url})
        print(f"  Done: {r['shot_id']}: {video_url}")
    else:
        print(f"  Failed: {r['shot_id']}: generation failed")

# Output the ordered shot list
print("\n=== Final Shot List ===")
for v in final_videos:
    print(f"{v['shot_id']}: {v['url']}")

Este pipeline produce una lista ordenada de URLs de video que puede alimentar a cualquier editor de video o herramienta de ensamblaje automatizado (FFmpeg, MoviePy, etc.) para montar la secuencia narrativa final. El personaje se mantiene consistente en todas las tomas porque cada solicitud usa el mismo CHARACTER_REF como @Image1.

Manejo de casos extremos de consistencia

Incluso con la misma imagen de referencia, pueden aparecer ligeras variaciones entre tomas: el color de la ropa de un personaje podría cambiar unos tonos, o las proporciones podrían cambiar ligeramente en planos generales extremos. Estas son estrategias para minimizar estas variaciones:

Reafirme los detalles del personaje en cada prompt. Si su personaje lleva un atuendo específico, menciónelo brevemente: "@Image1 is the main character wearing a blue denim jacket." Esto refuerza el anclaje visual de la imagen de referencia.

Evite cambios extremos de ángulo entre tomas. Un plano medio frontal seguido de un plano general cenital extremo introduce la mayor variación. Haga la transición gradualmente: plano medio → plano ligeramente más amplio → plano general.

Use la misma calidad y relación de aspecto. Mezclar 720p y 1080p entre tomas puede introducir diferencias sutiles de renderizado. Estandarice todos los parámetros en su lista de tomas.

Video de producto para e-commerce: flujo de trabajo completo

La fotografía de producto es costosa. La videografía de producto es aún más costosa: un estudio, una plataforma giratoria, iluminación adecuada, un camarógrafo, tiempo de edición. La API de imagen a video de Seedance 2.0 reemplaza la mayor parte de ese pipeline con una sola llamada API.

El problema del video de producto

Las plataformas de e-commerce favorecen cada vez más el contenido de video. Amazon reporta que los listados de productos con video tienen tasas de conversión más altas. Instagram y TikTok son plataformas que priorizan el video. Pero producir incluso un simple video de rotación de producto de 10 segundos tradicionalmente requiere:

1. Una plataforma giratoria física
2. Equipo de iluminación adecuado
3. Un videógrafo (o un trabajo cuidadoso por cuenta propia)
4. Edición y corrección de color
5. Exportación y carga

Con Seedance 2.0, el pipeline se reduce a:

1. Tomar una foto de producto (ya la tiene)
2. Hacer una llamada API
3. Descargar el video

Producto individual: Anuncio de reloj

Aquí tiene un flujo de trabajo completo para generar un video de presentación de producto a partir de una sola imagen de producto:

import requests
import time

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.evolink.ai/v1"
HEADERS = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

def wait_for_video(task_id, interval=5, max_wait=300):
    url = f"{BASE_URL}/tasks/{task_id}"
    elapsed = 0
    while elapsed < max_wait:
        resp = requests.get(url, headers=HEADERS)
        data = resp.json()
        status = data["status"]
        if status == "completed":
            print(f"Video ready: {data['output']['video_url']}")
            return data
        elif status == "failed":
            print(f"Failed: {data.get('error', 'Unknown error')}")
            return data
        print(f"Status: {status} ({elapsed}s)")
        time.sleep(interval)
        elapsed += interval
    return None

# --- Product Video: Luxury Watch ---
payload = {
    "model": "seedance-2.0",
    "prompt": (
        "@Image1 is a luxury wristwatch. "
        "The watch rotates slowly on a dark marble surface. "
        "Dramatic side lighting highlights the metal bracelet and crystal face. "
        "Light reflections move across the polished surfaces as the watch turns. "
        "Subtle lens flare. Extreme close-up with shallow depth of field. "
        "Premium product advertisement aesthetic."
    ),
    "image_urls": [
        "https://example.com/watch-product.jpg"
    ],
    "duration": 8,
    "quality": "1080p",
    "aspect_ratio": "16:9",
    "generate_audio": False
}

resp = requests.post(
    f"{BASE_URL}/videos/generations",
    headers=HEADERS,
    json=payload
)
result = resp.json()
print(f"Task ID: {result['task_id']}")

video_data = wait_for_video(result["task_id"])

Demo: Video de producto de reloj

Prompt utilizado: "@Image1 is a luxury wristwatch. The watch rotates slowly under dramatic studio lighting on a dark reflective surface. Light catches the polished metal case and sapphire crystal. Slow cinematic rotation. Premium advertisement quality."

A partir de una sola foto de producto, la API genera un video de presentación con rotación e iluminación de calidad de estudio. Los detalles de diseño del reloj, las marcas del dial, los eslabones de la pulsera, la forma de la caja, provienen todos de la imagen de referencia.

Variantes de producto multicolor

Muchos productos vienen en múltiples combinaciones de colores. En lugar de fotografiar cada variante por separado, puede usar el sistema @tag para presentar todas las variantes en un solo video:

# --- Multi-Color Product: Headphones ---
payload = {
    "model": "seedance-2.0",
    "prompt": (
        "@Image1 shows premium over-ear headphones in four different colors "
        "arranged on a clean surface. The camera slowly pans across all four "
        "variants. Each headphone catches the studio light differently. "
        "Smooth dolly movement from left to right. "
        "Clean white background with subtle shadows. "
        "Product catalog video style."
    ),
    "image_urls": [
        "https://example.com/headphones-all-colors.jpg"
    ],
    "duration": 10,
    "quality": "1080p",
    "aspect_ratio": "16:9"
}

resp = requests.post(
    f"{BASE_URL}/videos/generations",
    headers=HEADERS,
    json=payload
)
result = resp.json()
print(f"Task ID: {result['task_id']}")
video_data = wait_for_video(result["task_id"])

Demo: Variantes de color de auriculares

Prompt utilizado: "@Image1 shows over-ear headphones in four color variants. The camera pans smoothly across each variant under clean studio lighting. Soft reflections on the ear cups. Minimal white background. Product showcase cinematography."

Una sola foto de línea de productos se convierte en un video de presentación con paneo suave. Cada combinación de colores obtiene tiempo en pantalla, y la estética de iluminación de estudio iguala la videografía profesional de productos.

Generación por lotes para catálogos de productos

Si tiene decenas o cientos de productos, envuelva la lógica de generación en un procesador por lotes:

import csv
import time
import requests

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.evolink.ai/v1"
HEADERS = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

def generate_product_video(product_name, image_url, style="premium"):
    """Generate a product video from a single product image."""
    style_prompts = {
        "premium": (
            f"@Image1 is a {product_name}. "
            "The product rotates slowly under dramatic studio lighting "
            "on a dark reflective surface. Cinematic close-up. "
            "Light reveals surface details and textures. "
            "Premium advertisement quality."
        ),
        "lifestyle": (
            f"@Image1 is a {product_name}. "
            "The product is shown in a lifestyle setting — "
            "a modern living space with natural light. "
            "Camera slowly pushes in to reveal product details. "
            "Warm, inviting atmosphere."
        ),
        "minimal": (
            f"@Image1 is a {product_name}. "
            "Clean white background. The product rotates 360 degrees. "
            "Even, shadowless lighting. E-commerce product spin."
        ),
    }

    payload = {
        "model": "seedance-2.0",
        "prompt": style_prompts[style],
        "image_urls": [image_url],
        "duration": 8,
        "quality": "1080p",
        "aspect_ratio": "1:1"
    }

    resp = requests.post(
        f"{BASE_URL}/videos/generations",
        headers=HEADERS,
        json=payload
    )
    data = resp.json()
    return data["task_id"]


# Example: process a CSV product catalog
# CSV format: product_name, image_url, style
products = [
    ("Wireless Earbuds", "https://example.com/earbuds.jpg", "premium"),
    ("Leather Wallet", "https://example.com/wallet.jpg", "lifestyle"),
    ("Running Shoes", "https://example.com/shoes.jpg", "minimal"),
]

tasks = []
for name, url, style in products:
    task_id = generate_product_video(name, url, style)
    tasks.append((name, task_id))
    print(f"Submitted: {name} → {task_id}")
    time.sleep(1)  # Rate limiting courtesy

print(f"\nSubmitted {len(tasks)} product videos")
print("Poll each task_id to retrieve the completed video URLs")

Este patrón de procesamiento por lotes escala a cualquier tamaño de catálogo. Puede extenderlo con URLs de callback (parámetro callback_url) en lugar de sondeo, lo cual es más eficiente para lotes grandes: la API envía un POST a su endpoint cuando cada video se completa.

Plantillas de prompts para videos de producto

Aquí tiene plantillas de prompts probadas en el campo para necesidades comunes de video de e-commerce:

PRODUCT_TEMPLATES = {
    "rotation_360": (
        "@Image1 is the product. "
        "Full 360-degree rotation on a clean background. "
        "Consistent studio lighting throughout the rotation. "
        "Smooth, steady turntable motion. "
        "Product catalog photography style."
    ),
    "unboxing_reveal": (
        "@Image1 is the product. "
        "The product emerges from soft tissue paper inside a premium box. "
        "Hands carefully lift it into view. "
        "Camera slowly pushes in as the product is revealed. "
        "Luxury unboxing experience. Warm lighting."
    ),
    "hero_shot": (
        "@Image1 is the product. "
        "Dramatic hero shot. The product rises into frame against a dark background. "
        "Volumetric light beams hit the product from the side. "
        "Slow motion. Particles float in the light. "
        "Epic product launch trailer aesthetic."
    ),
    "in_use": (
        "@Image1 is the product. "
        "Someone picks up the product and uses it naturally. "
        "Lifestyle setting with soft natural window light. "
        "Medium close-up. The camera follows the interaction. "
        "Authentic, relatable product usage."
    ),
}

Errores comunes y cómo solucionarlos

Después de cientos de llamadas API, surgen patrones claros sobre lo que funciona y lo que falla. Estos son los errores más comunes y sus soluciones.

Error 1: Usar fotos de rostros humanos realistas

Qué ocurre: La API devuelve un error 400 o un estado de tarea failed.

Por qué: Seedance 2.0 bloquea la generación de imagen a video a partir de imágenes de rostros humanos fotorrealistas. Esta es una política de seguridad, no un error.

Solución: Use imágenes de personajes ilustrados, estilizados o de estilo caricatura en su lugar. Los personajes de anime, retratos al óleo, personajes renderizados en 3D y siluetas funcionan perfectamente. Si su flujo de trabajo requiere personajes humanos, genérelos primero usando un modelo de texto a imagen con un estilo no fotorrealista.

# Will be rejected
"image_urls": ["https://example.com/real-person-photo.jpg"]

# Works fine
"image_urls": ["https://example.com/illustrated-character.png"]
"image_urls": ["https://example.com/3d-rendered-character.jpg"]
"image_urls": ["https://example.com/anime-character.png"]

Error 2: Prompts estáticos que solo describen la apariencia

Qué ocurre: El video generado muestra un movimiento mínimo o nulo. El sujeto permanece inmóvil, o solo ocurre una ligera deriva de cámara.

Por qué: El modelo toma su prompt literalmente. Si describe una escena estática ("a cat on a windowsill"), obtiene un video casi estático.

Solución: Incluya siempre verbos de movimiento, acciones secuenciales y dinámica ambiental.

# Static: produces near-still video
"prompt": "A beautiful sunset over the ocean with golden light"

# Dynamic: produces engaging video
"prompt": (
    "Waves crash against rocky coastline during golden sunset. "
    "Water sprays upward, catching the warm light. "
    "Camera slowly descends from sky level to water level. "
    "Seabirds glide across the frame. "
    "Light shifts from golden to deep amber."
)

Error 3: Duración incorrecta para el contenido

Qué ocurre: Las acciones simples se sienten estiradas e incómodas, o las secuencias complejas se sienten apresuradas y entrecortadas.

Por qué: La duración debe coincidir con la complejidad de su prompt. Una simple rotación de producto no necesita 15 segundos. Una secuencia de personaje con múltiples acciones no funciona en 4 segundos.

Solución: Haga coincidir la duración con la complejidad del prompt:

Error 4: Problemas con las URLs de imagen

Qué ocurre: La API devuelve errores sobre imágenes inválidas, o la tarea falla durante el procesamiento.

Por qué: Varios problemas comunes de URL:

• La URL requiere autenticación (no es accesible públicamente)
• La URL apunta a una página web, no a un archivo de imagen directo
• El formato de imagen no es compatible (WebP a veces falla)
• La imagen es demasiado grande (archivos de muy alta resolución pueden agotar el tiempo)
• La URL ha expirado (URLs prefirmadas con límites de tiempo)

Solución: Asegúrese de que sus URLs de imagen sean:

1. Accesibles públicamente - sin encabezados de autenticación necesarios para descargar
2. Enlaces directos de imagen - que terminen en .jpg, .png o similar (no una página HTML)
3. Formatos estándar - JPEG y PNG son los más seguros
4. Tamaño razonable - menos de 10MB por imagen
5. Persistentes - que no expiren durante el procesamiento

# Problem URLs
"https://drive.google.com/file/d/abc123/view"  # Requires auth
"https://example.com/product-page"              # HTML page, not image
"https://storage.com/image.jpg?token=abc&exp=1h" # Might expire

# Good URLs
"https://cdn.example.com/images/product.jpg"     # Direct CDN link
"https://i.imgur.com/abc123.png"                  # Public image host

Error 5: No usar @Tags con múltiples imágenes

Qué ocurre: Cuando pasa más de 3 imágenes sin usar etiquetas @Image en su prompt, el modelo adivina qué imagen cumple qué propósito. Los resultados son impredecibles: a veces la imagen de fondo se usa como personaje, o la referencia de estilo se trata como un elemento de la escena.

Solución: Use siempre etiquetas @Image cuando pase más de una imagen. Sea explícito sobre el rol de cada imagen.

# Ambiguous: model guesses roles
"prompt": "A character walks through a forest in watercolor style"
"image_urls": [character.jpg, forest.jpg, watercolor_ref.jpg]

# Explicit: model knows each role
"prompt": (
    "@Image1 is the character. @Image2 is the forest environment. "
    "@Image3 defines the watercolor art style. "
    "The character (@Image1) walks through the forest (@Image2) "
    "rendered in the watercolor style of @Image3."
)
"image_urls": [character.jpg, forest.jpg, watercolor_ref.jpg]

Error 6: Olvidar la expiración de URLs de video

Qué ocurre: Genera un video, guarda la URL, intenta acceder al día siguiente y obtiene un 403 o 404.

Por qué: Las URLs de video generadas expiran después de 24 horas.

Solución: Descargue el archivo de video inmediatamente después de que se complete la generación. Añada un paso de descarga a su función de sondeo:

import os

def download_video(video_url, output_path):
    """Download a video before the URL expires."""
    resp = requests.get(video_url, stream=True)
    resp.raise_for_status()
    with open(output_path, "wb") as f:
        for chunk in resp.iter_content(chunk_size=8192):
            f.write(chunk)
    print(f"Saved to {output_path}")

# After generation completes:
video_url = video_data["output"]["video_url"]
download_video(video_url, "output/my-product-video.mp4")

Error 7: Conflicto entre el prompt y el contenido de la imagen

Qué ocurre: El video de salida se ve confuso: los elementos de la imagen y los elementos del prompt compiten por el dominio, produciendo artefactos visuales o escenas incoherentes.

Por qué: Describió algo en el prompt que contradice directamente la imagen de referencia. Por ejemplo, su imagen muestra un auto rojo, pero su prompt dice "a blue sports car races down the highway."

Solución: Su prompt debe complementar la imagen, no contradecirla. Describa acciones, movimientos de cámara y cambios ambientales, no la apariencia de elementos ya definidos por sus imágenes de referencia.

# Contradicts image (image shows red car)
"prompt": "A blue sports car races down the highway at sunset"

# Complements image (lets the image define appearance)
"prompt": (
    "@Image1 is the car. The car accelerates down an open highway. "
    "Camera tracks alongside at speed. Sunset light reflects off the hood. "
    "Road stretches to the horizon. Motion blur on the asphalt."
)

Referencia de parámetros de la API

Aquí tiene todos los parámetros relevantes para la generación de imagen a video en una sola tabla de referencia:

Límites: Máximo 9 imágenes + 3 videos + 3 archivos de audio por solicitud. El total de todos los tipos de medios no puede exceder 12. Las etiquetas se asignan por posición en el array: image_urls[0] → @Image1, video_urls[0] → @Video1, audio_urls[0] → @Audio1.

Preguntas frecuentes

¿Puedo usar cualquier formato de imagen con la API de imagen a video de Seedance 2.0?

JPEG y PNG son totalmente compatibles y recomendados. GIF (solo el primer fotograma), BMP y TIFF generalmente funcionan pero están menos probados. El soporte de WebP es inconsistente: convierta a JPEG o PNG para resultados fiables. Todas las imágenes deben ser accesibles a través de una URL pública sin autenticación.

¿Cuánto tiempo toma la generación de imagen a video?

Los tiempos de generación típicos van de 60 a 180 segundos dependiendo de la duración, la configuración de calidad y la carga actual del servidor. Un clip de 4 segundos a 480p se genera más rápido que un clip de 15 segundos a 1080p. Use el endpoint de sondeo (GET /v1/tasks/{task_id}) o configure un callback_url para recibir una notificación cuando el procesamiento se complete.

¿Cuál es el número máximo de imágenes que puedo usar en una sola solicitud?

Puede incluir hasta 9 imágenes en image_urls. El conteo total de archivos en todos los tipos de medios (imágenes + videos + audio) tiene un límite de 12 por solicitud. Así que si está usando 9 imágenes, aún puede agregar hasta 3 referencias de video o audio.

¿Puedo combinar imagen a video con generación de audio?

Sí. Configure generate_audio: true en el payload de su solicitud junto con image_urls. El modelo genera audio sincronizado que coincide con el contenido visual: pasos para escenas de caminata, sonidos ambientales para escenas de naturaleza, sonidos mecánicos para rotaciones de productos. También puede proporcionar su propio audio a través de audio_urls y referenciarlo con @Audio1 en su prompt.

¿Cómo manejo la expiración de URLs de video en producción?

Las URLs de video generadas expiran después de 24 horas. Para sistemas de producción, implemente un paso de descarga inmediata en su pipeline. Después de que el estado de la tarea cambie a completed, descargue el archivo de video a su propio almacenamiento (S3, GCS o disco local) antes de devolver la URL a su aplicación. Nunca almacene la URL generada por la API como referencia permanente. Si está usando callback_url, su manejador de webhook debe incluir el paso de descarga como parte de su lógica de procesamiento.

¿Puedo usar imagen a video de Seedance 2.0 para logos animados o intros de marca?

Sí, y este es uno de los casos de uso más sólidos. Suba su logo o marca como @Image1 y escriba el prompt para el estilo de animación que desea: ensamblaje de partículas, revelación líquida, rotación 3D, etc. Dado que los logos son elementos gráficos (no rostros fotorrealistas), funcionan perfectamente con el pipeline de imagen a video. Configure generate_audio: true para agregar un efecto de sonido sincronizado para la revelación.

¿Por qué fue rechazada mi solicitud de imagen a video?

La razón de rechazo más común es un rostro humano fotorrealista en la imagen de entrada. Seedance 2.0 detecta y bloquea automáticamente imágenes de rostros realistas por razones de seguridad. Otras causas de rechazo incluyen: URLs de imagen inaccesibles, formatos de archivo no compatibles, exceder el límite de 9 imágenes o que el conteo total de archivos multimedia exceda 12. Consulte el mensaje de error en la respuesta de tarea failed para obtener detalles específicos.

Comience a animar sus imágenes

Ahora dispone de tres métodos distintos para convertir imágenes estáticas en video a través de la API de Seedance 2.0: animación de imagen única para movimiento rápido de personajes o escenas, control de primer y último fotograma para transiciones precisas de inicio a fin, y composición multi-imagen con @tags para escenas complejas con roles asignados.

Los ejemplos de código a lo largo de esta guía son completos y ejecutables. Copie cualquiera de ellos, inserte su clave API, apunte a sus propias imágenes y tendrá un video generado en minutos.

Para equipos de producto, el flujo de trabajo de generación por lotes convierte un catálogo completo de productos en activos de video sin un estudio. Para equipos creativos, el patrón de consistencia de personajes permite la narración multi-toma a partir de una sola referencia de personaje. Para desarrolladores, el sistema @tag proporciona un nivel de control composicional que ninguna otra API de video con IA ofrece actualmente.

Comience a animar sus imágenes. Regístrese gratis en EvoLink →

Esta guía es parte de la serie de tutoriales de Seedance 2.0. Anteriormente: Guía de Prompts de Seedance 2.0, Guía de Inicio, Guía de @Tags Multimodales y Guía de Movimientos de Cámara.