API de Seedance 2.0: Una Guía Práctica para Desarrolladores

Última actualización: Marzo 2026

La API de Seedance 2.0 permite a los desarrolladores integrar la generación de video con IA directamente en sus aplicaciones. Esta guía cubre lo que realmente hace la API, cómo se compara con alternativas y cómo empezar.

¿Qué Hace la API de Seedance 2.0?

La API de Seedance 2.0 te da acceso programático para generar videos a partir de texto e imágenes. En lugar de usar la interfaz web, envías trabajos de generación mediante solicitudes HTTP, consultas el estado y recuperas las URLs de los videos.

Capacidades principales:

• Generación de texto a video (modelo Seedance 2.0)
• Generación de imagen a video (animar una imagen de referencia)
• Envío asíncrono de trabajos con consulta de estado
• Salida en formato MP4, 1080p HD
• Hasta ~10 segundos por generación

Lo que no hace:

• No hay salida en tiempo real (la generación toma tiempo)
• No tiene edición de video incorporada
• No genera audio (a diferencia de Google Veo 3)
• Los tiempos de cola de generación varían según la carga

API de Seedance vs APIs Competidoras

Antes de construir, vale la pena comparar tus opciones honestamente.

Cuándo tiene sentido la API de Seedance:

• Quieres buena calidad sin la complejidad de configurar Google Cloud
• Estás construyendo un producto que necesita precios predecibles basados en créditos
• Quieres acceso a múltiples modelos en una sola API (Seedance 1.5 para velocidad, 2.0 para calidad)

Cuándo considerar alternativas:

• Necesitas la máxima calidad posible → Google Veo 3 (Vertex AI)
• Necesitas generación de audio nativa → Google Veo 3
• Necesitas controles de cámara avanzados → Runway API

Primeros Pasos

Paso 1: Obtén tu Clave de API

Regístrate en seedance.tv y navega a la configuración de tu cuenta. El acceso a la API está disponible en planes de pago desde $9.9/mes.

Almacena tu clave de API como una variable de entorno — nunca la codifiques en los archivos fuente:

export SEEDANCE_API_KEY="tu-clave-de-api-aqui"

Paso 2: Envía un Trabajo de Generación

La API utiliza un patrón asíncrono: envías un trabajo y consultas hasta que se complete.

import requests
import time
import os

API_KEY = os.environ["SEEDANCE_API_KEY"]
BASE_URL = "https://api.seedance.tv/v1"

def generate_video(prompt: str, model: str = "seedance-2.0"):
    """Envía un trabajo de generación de texto a video."""
    response = requests.post(
        f"{BASE_URL}/videos",
        headers={
            "Authorization": f"Bearer {API_KEY}",
            "Content-Type": "application/json"
        },
        json={
            "prompt": prompt,
            "model": model,
            "aspect_ratio": "16:9",
            "resolution": "1080p"
        }
    )
    response.raise_for_status()
    return response.json()["job_id"]

Paso 3: Consulta hasta Completar

def wait_for_completion(job_id: str, poll_interval: int = 5, timeout: int = 300):
    """Consulta hasta que la generación del video se complete."""
    start_time = time.time()
    
    while time.time() - start_time < timeout:
        response = requests.get(
            f"{BASE_URL}/videos/{job_id}",
            headers={"Authorization": f"Bearer {API_KEY}"}
        )
        response.raise_for_status()
        data = response.json()
        
        status = data["status"]
        
        if status == "completed":
            return data["output_url"]
        elif status == "failed":
            raise Exception(f"Generación fallida: {data.get('error', 'Error desconocido')}")
        
        # Aún procesando
        print(f"Estado: {status} ({int(time.time() - start_time)}s transcurridos)")
        time.sleep(poll_interval)
    
    raise TimeoutError(f"La generación no se completó en {timeout} segundos")

# Uso
job_id = generate_video("Un lento travelling a través de una calle de Tokio iluminada con neón por la noche, reflejos de lluvia en el pavimento mojado, 1080p cinematográfico")
video_url = wait_for_completion(job_id)
print(f"Video listo: {video_url}")

Paso 4: Imagen a Video

Para animar una imagen de referencia:

def generate_from_image(image_url: str, prompt: str):
    """Anima una imagen de referencia."""
    response = requests.post(
        f"{BASE_URL}/videos",
        headers={
            "Authorization": f"Bearer {API_KEY}",
            "Content-Type": "application/json"
        },
        json={
            "prompt": prompt,
            "model": "seedance-2.0",
            "image_url": image_url,
            "type": "image-to-video",
            "aspect_ratio": "16:9"
        }
    )
    response.raise_for_status()
    return response.json()["job_id"]

Ingeniería de Prompts para la API

La calidad de tu salida depende en gran medida de la estructura del prompt. Aquí hay patrones que funcionan consistentemente:

Buena estructura de prompt de texto a video:

[Tipo de plano], [Descripción del sujeto], [Acción/movimiento], [Entorno], [Iluminación], [Estilo]

Ejemplo:

Primer plano con seguimiento, mujer caminando por un olivar bañado por el sol, cabello al viento, cálida luz de la tarde a través de las hojas, profundidad de campo reducida cinematográfica

Errores comunes que desperdician créditos de API:

Demasiado vago:

Un video hermoso

Demasiados elementos en competencia:

Un hombre y una mujer y un perro en la playa y también un atardecer y olas y montañas al fondo

Falta descripción de movimiento:

Una taza de café sobre una mesa

Mejor: Una taza de café sobre una mesa de madera, vapor subiendo lentamente, suave luz natural de ventana desde la izquierda, lente macro

Elegir el modelo adecuado:

Flujo de trabajo recomendado: Haz borradores con seedance-1.5, refina el prompt, luego genera el final con seedance-2.0. Esto reduce los costos de API durante la iteración.

Relaciones de Aspecto

ASPECT_RATIOS = {
    "landscape": "16:9",   # YouTube, escritorio, anuncios
    "portrait": "9:16",    # TikTok, Instagram Reels, Shorts
    "square": "1:1",       # Publicaciones de Instagram
    "cinema": "21:9"       # Pantalla ancha cinematográfica
}

Manejo de Errores

def safe_generate(prompt: str, max_retries: int = 3):
    """Genera con lógica de reintento para fallos transitorios."""
    for attempt in range(max_retries):
        try:
            job_id = generate_video(prompt)
            return wait_for_completion(job_id)
        except requests.HTTPError as e:
            if e.response.status_code == 429:
                # Límite de velocidad alcanzado — esperar
                wait = 30 * (attempt + 1)
                print(f"Límite de velocidad alcanzado. Esperando {wait}s...")
                time.sleep(wait)
            elif e.response.status_code == 402:
                raise Exception("Créditos insuficientes. Recarga tu cuenta en seedance.tv")
            else:
                raise
        except TimeoutError:
            if attempt < max_retries - 1:
                print(f"Tiempo de espera agotado en el intento {attempt + 1}, reintentando...")
            else:
                raise
    raise Exception("Se superaron los reintentos máximos")

Límites de Velocidad y Uso de Créditos

• Límite de velocidad: Varía según el plan. Consulta tu panel para los límites actuales.
• Créditos por generación: Depende del modelo, duración y resolución. El panel muestra el saldo de créditos en vivo.
• Mejor práctica para producción: Implementa una cola de trabajos en lugar de enviar muchas solicitudes simultáneas. Las solicitudes escalonadas evitan errores de límite de velocidad y son más rentables.

Casos de Uso para los que Esta API es Adecuada

Automatización de video de productos: Plataformas de comercio electrónico que generan videos a partir de imágenes de productos a escala. Alimenta una imagen de producto + un prompt con la voz de la marca → clips de video automatizados para cada SKU.

Pipelines de redes sociales: Sistemas de contenido programado que generan una semana de contenido de video a partir de una lista de prompts aprobados. Combínalo con una herramienta de cola de video para publicación automática.

Pruebas de creatividades publicitarias: Herramientas de marketing que generan múltiples interpretaciones visuales del mismo concepto para pruebas A/B. Genera 5 variaciones de un concepto de anuncio en un solo lote.

Generación de prototipos: Equipos de diseño y producto que generan videos conceptuales antes de comprometerse con la producción. Mucho más barato que la producción tradicional para la visualización en etapas tempranas.

Construyendo un Pipeline Simple de Generación de Video

import json
from pathlib import Path

def batch_generate(prompts: list[dict], output_dir: str = "./videos"):
    """Genera múltiples videos a partir de una lista de configuraciones de prompt."""
    Path(output_dir).mkdir(exist_ok=True)
    results = []
    
    for i, config in enumerate(prompts):
        print(f"Generando {i+1}/{len(prompts)}: {config['name']}")
        
        try:
            # Usa modelo rápido para borradores, premium para finales
            model = "seedance-2.0" if config.get("final") else "seedance-1.5"
            job_id = generate_video(config["prompt"], model=model)
            url = wait_for_completion(job_id)
            
            results.append({
                "name": config["name"],
                "url": url,
                "status": "success"
            })
            print(f"  ✓ {url}")
            
        except Exception as e:
            results.append({
                "name": config["name"],
                "error": str(e),
                "status": "failed"
            })
            print(f"  ✗ Falló: {e}")
        
        # Pequeña pausa entre envíos
        time.sleep(2)
    
    # Guardar resultados
    with open(f"{output_dir}/results.json", "w") as f:
        json.dump(results, f, indent=2)
    
    return results

# Ejemplo de uso
prompts = [
    {"name": "hero-shot", "prompt": "...", "final": True},
    {"name": "product-demo", "prompt": "...", "final": False},
]
results = batch_generate(prompts)

Preguntas Frecuentes

¿Seedance 2.0 tiene una API pública oficial?

Seedance ofrece acceso a la API como parte de los planes de pago. Consulta la documentación para desarrolladores en seedance.tv para obtener detalles actuales de acceso y especificaciones de endpoints.

¿Cómo funciona el precio?

El uso de la API consume tu saldo de créditos. Diferentes modelos cuestan diferentes cantidades de créditos por generación. Consulta tu panel para las tasas de crédito actuales por modelo.

¿Cuál es el tiempo de generación por video?

Normalmente de 30 segundos a 3 minutos dependiendo de la complejidad del modelo y la carga de la cola. Seedance 1.5 es más rápido; Seedance 2.0 tarda más pero produce mayor calidad.

¿Puedo generar videos de más de 10 segundos?

No con una sola llamada a la API actualmente. Para contenido más largo, genera múltiples clips y únelos en tu aplicación usando una biblioteca de procesamiento de video como moviepy o ffmpeg.

¿La salida es adecuada para uso comercial?

Consulta los términos de servicio actuales en seedance.tv para obtener detalles sobre licencias comerciales. Generalmente, el contenido generado en planes de pago tiene licencia para uso comercial.

¿Cómo se compara la API de Seedance con la API de Runway?

La API de Runway ($0.05-0.10/segundo) ofrece controles de cámara más avanzados y el modelo Gen-3 Alpha. La API de Seedance utiliza precios basados en créditos, lo que es más predecible para la planificación presupuestaria. Runway gana en pulido cinematográfico y control de cámara; Seedance gana en variedad de modelos y claridad de precios. Para la mayoría de los desarrolladores, prueba ambas en tu caso de uso específico: los resultados varían significativamente según el tipo de contenido.

---

Empieza a Construir

¿Listo para integrar video con IA en tu aplicación?

Regístrate en Seedance → — obtén créditos gratis para probar la API, planes de pago desde $9.9/mes.

• Playground de texto a video — prueba prompts antes de construir
• Playground de imagen a video — prueba animación de imágenes
• Detalles del modelo Seedance 2.0 — benchmarks de calidad y especificaciones