API de Seedance 1.0 Pro: endpoint profesional de generación de video

Si estás incorporando vídeo en un producto, un flujo de trabajo o una canalización, la interfaz web acaba convirtiéndose en un cuello de botella. La API de Seedance 1.0 Pro es el mismo modelo que hay detrás de la interfaz, expuesto como un endpoint REST limpio con autenticación por token bearer, precios predecibles por segundo y sondeo de trabajos sencillo. Esta guía cubre todo lo que necesitas para desplegarlo en producción.

Resumen rápido

• API REST para generación de vídeo nativa a 1080p con Seedance 1.0 Pro
• Autenticación: token bearer desde tu panel de cuenta
• Facturación: por segundo, a aproximadamente $0.12/seg, redondeado hacia arriba al crédito entero
• Flujo: enviar trabajo → sondear estado → descargar MP4
• Ideal para: integraciones SaaS, pipelines por lotes, automatización, productos de marca blanca

Qué ofrece la API

Todo lo que ofrece la interfaz web de Seedance 1.0 Pro, disponible mediante programación:

• Generación de imagen a vídeo con la URL de una imagen de origen
• Prompt de movimiento para dirigir la animación
• Control de duración de 2 a 12 segundos
• Control de fotograma final para transiciones dirigidas
• Bloqueo de cámara activable
• Sondeo de trabajos para obtener el estado y la URL del resultado
• Salida MP4 en 1080p nativo

Úsala para productos SaaS que necesiten generación de vídeo integrada, pipelines internos de agencias, flujos de trabajo de producción por lotes o automatización de tareas de vídeo repetitivas.

Autenticación

Todas las llamadas a la API se autentican con un token bearer. Genera uno desde el panel de tu cuenta de Arteza en arteza.ai.

Authorization: Bearer YOUR_API_KEY

Reglas de seguridad:

• Nunca incluyas claves de API en el control de versiones
• Rota las claves periódicamente
• Usa variables de entorno o un gestor de secretos
• Restringe las claves a orígenes específicos si es posible

Los endpoints principales

Enviar un trabajo de generación

POST /v1/seedance-1-pro/generate

Cuerpo de la solicitud:

{
  "source_image_url": "https://your-cdn.com/source.jpg",
  "prompt": "Slow camera push-in on the subject, warm golden hour light, shallow depth of field",
  "duration_seconds": 6,
  "camera_lock": false,
  "end_frame_url": null
}

Parámetros:

Respuesta:

{
  "job_id": "job_abc123xyz",
  "status": "queued",
  "created_at": "2026-04-10T12:00:00Z",
  "estimated_seconds": 90
}

Consultar el estado del trabajo

GET /v1/seedance-1-pro/status/{job_id}

Respuesta (en curso):

{
  "job_id": "job_abc123xyz",
  "status": "processing",
  "progress": 0.45,
  "created_at": "2026-04-10T12:00:00Z"
}

Respuesta (completado):

{
  "job_id": "job_abc123xyz",
  "status": "completed",
  "video_url": "https://arteza.ai/videos/abc123xyz.mp4",
  "duration_seconds": 6,
  "resolution": "1920x1080",
  "credits_charged": 144
}

Valores de estado posibles: queued, processing, completed, failed

Descargar el resultado

Una vez que el estado sea completed, la video_url apunta a un archivo MP4 a 1080p. Descárgalo de inmediato y almacénalo en tu propia infraestructura: no dependas de que la URL sea válida indefinidamente.

Ejemplo completo en Python

import os
import time
import requests

API_KEY = os.environ["SEEDANCE_API_KEY"]
BASE_URL = "https://api.arteza.ai/v1/seedance-1-pro"
HEADERS = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

def generate_video(source_image_url, prompt, duration=6, camera_lock=False, end_frame=None):
    payload = {
        "source_image_url": source_image_url,
        "prompt": prompt,
        "duration_seconds": duration,
        "camera_lock": camera_lock,
    }
    if end_frame:
        payload["end_frame_url"] = end_frame
    
    response = requests.post(f"{BASE_URL}/generate", headers=HEADERS, json=payload)
    response.raise_for_status()
    return response.json()["job_id"]

def wait_for_completion(job_id, poll_interval=5, timeout=300):
    start = time.time()
    while time.time() - start < timeout:
        r = requests.get(f"{BASE_URL}/status/{job_id}", headers=HEADERS)
        r.raise_for_status()
        data = r.json()
        
        if data["status"] == "completed":
            return data["video_url"]
        if data["status"] == "failed":
            raise RuntimeError(f"Job failed: {data.get('error', 'unknown')}")
        
        time.sleep(poll_interval)
    
    raise TimeoutError(f"Job {job_id} did not complete within {timeout}s")

def download_video(url, output_path):
    response = requests.get(url, stream=True)
    response.raise_for_status()
    with open(output_path, "wb") as f:
        for chunk in response.iter_content(chunk_size=8192):
            f.write(chunk)

# Úsalo así
job_id = generate_video(
    source_image_url="https://example.com/product.jpg",
    prompt="Slow camera orbit around the product, studio lighting, 6 seconds",
    duration=6,
    camera_lock=True
)

video_url = wait_for_completion(job_id)
download_video(video_url, "output.mp4")
print(f"Video guardado en output.mp4")

Ejemplo completo en Node.js

import fs from 'fs';
import fetch from 'node-fetch';

const API_KEY = process.env.SEEDANCE_API_KEY;
const BASE_URL = 'https://api.arteza.ai/v1/seedance-1-pro';
const HEADERS = {
  'Authorization': `Bearer ${API_KEY}`,
  'Content-Type': 'application/json'
};

async function generateVideo(opts) {
  const response = await fetch(`${BASE_URL}/generate`, {
    method: 'POST',
    headers: HEADERS,
    body: JSON.stringify(opts)
  });
  if (!response.ok) throw new Error(`HTTP ${response.status}`);
  const data = await response.json();
  return data.job_id;
}

async function waitForCompletion(jobId, { pollInterval = 5000, timeout = 300000 } = {}) {
  const start = Date.now();
  while (Date.now() - start < timeout) {
    const r = await fetch(`${BASE_URL}/status/${jobId}`, { headers: HEADERS });
    const data = await r.json();
    if (data.status === 'completed') return data.video_url;
    if (data.status === 'failed') throw new Error(`Job failed: ${data.error}`);
    await new Promise(res => setTimeout(res, pollInterval));
  }
  throw new Error('Timeout');
}

async function downloadVideo(url, path) {
  const response = await fetch(url);
  const buffer = await response.buffer();
  fs.writeFileSync(path, buffer);
}

// Úsalo así
const jobId = await generateVideo({
  source_image_url: 'https://example.com/product.jpg',
  prompt: 'Slow camera orbit around the product, studio lighting, 6 seconds',
  duration_seconds: 6,
  camera_lock: true
});

const videoUrl = await waitForCompletion(jobId);
await downloadVideo(videoUrl, 'output.mp4');
console.log('Guardado output.mp4');

¿Quieres esta calidad broadcast? Prueba Seedance 1.0 Pro gratis →

Precios y facturación

Tarifa: aproximadamente $0.12 por segundo de vídeo generado, redondeado hacia arriba al crédito entero más cercano

Los créditos se descuentan únicamente en generaciones exitosas. Los trabajos fallidos no consumen créditos.

Los planes son los mismos que en la interfaz web: Starter a $5, Creator a $25, Pro a $50, Studio a $120. Consulta el página de precios.

Límites de velocidad y concurrencia

Las cuentas estándar tienen límites de velocidad adecuados para cargas de trabajo de integración habituales. Para producción de alto volumen, contacta con soporte para aumentar los límites.

Orientación general:

• 5-10 trabajos concurrentes es fiable para la mayoría de las cuentas
• Retroceso exponencial ante respuestas HTTP 429
• Reintentos a nivel de trabajo ante fallos transitorios (hasta 3 intentos)
• Callbacks por webhook disponibles para evitar un sondeo excesivo

Webhooks (opcional)

En lugar de sondear, registra una URL de webhook en la configuración de tu cuenta o por solicitud. Cuando un trabajo se completa, Arteza envía un POST a tu URL:

{
  "event": "job.completed",
  "job_id": "job_abc123xyz",
  "status": "completed",
  "video_url": "https://arteza.ai/videos/abc123xyz.mp4",
  "duration_seconds": 6,
  "credits_charged": 144,
  "timestamp": "2026-04-10T12:02:15Z"
}

Los webhooks están firmados con una firma HMAC en la cabecera X-Seedance-Signature. Verifica la firma antes de confiar en el contenido.

Gestión de errores

La API devuelve códigos de estado HTTP estándar:

Los cuerpos de respuesta de error incluyen un campo error con un mensaje legible por humanos y un campo code para el manejo programático.

{
  "error": "Source image URL could not be fetched",
  "code": "source_image_unreachable"
}

Requisitos de la imagen de entrada

• Formatos: PNG, JPEG, WebP
• Tamaño: hasta 10 MB por imagen
• Resolución: mínimo 512x512; cuanto mayor, mejor (se recomienda 1080p o superior)
• Acceso a la URL: debe ser accesible públicamente por los servidores de Arteza (sin localhost, sin acceso protegido por autenticación)

Para imágenes privadas, súbelas a una URL firmada de S3, CloudFront o similar, y pasa la URL firmada en la solicitud.

Buenas prácticas

1. Almacena las salidas en tu propia infraestructura. No dependas de las URLs de Arteza a largo plazo.
2. Registra todo. IDs de trabajo, prompts, tiempos, transiciones de estado, errores.
3. Reintenta los errores transitorios. Los fallos de red y las respuestas 5xx deben reintentarse con retroceso exponencial.
4. Valida las entradas desde el principio. Comprueba las URLs de imagen y los rangos de parámetros antes de enviar.
5. Monitoriza el saldo de créditos. Lanza alertas cuando baje de un umbral.
6. Usa webhooks en producción. El sondeo está bien para cargas pequeñas, pero es ineficiente a escala.
7. Cachea generaciones idénticas. Si un usuario envía la misma imagen más el mismo prompt dos veces, devuelve la URL en caché.

Pruebas y staging

Comienza cada integración con el plan Starter de $5 (60 créditos al mes). Es suficiente para veinte generaciones de prueba de 2 segundos. Crea y prueba tu integración de extremo a extremo antes de comprometerte con un plan de mayor volumen.

Casos de uso

• Plataformas SaaS: permite que tus usuarios generen vídeo a partir de sus propios recursos
• Comercio electrónico: genera vídeos de movimiento de producto a partir de imágenes del catálogo
• Inmobiliaria: automatiza la producción de vídeos de listado a partir de fotografías
• Automatización de marketing: vídeo personalizado a escala
• Plataformas de contenido: enriquece artículos, listados o publicaciones en redes sociales con vídeo generado
• Herramientas de vídeo de marca blanca: construye tu propio producto de vídeo con IA sobre el backend de Arteza

Lecturas relacionadas

• Flujos de trabajo por lotes
• Guía completa de Seedance 1.0 Pro
• Seedance 1.0 Pro para agencias
• Guía de la API de Seedance 2.0

Preguntas frecuentes

¿Puedo usar la API para aplicaciones comerciales? Sí, todo el contenido generado está autorizado para uso comercial.

¿Qué ocurre si la generación falla? No se cargan créditos en generaciones fallidas.

¿Cuánto tiempo se alojan los vídeos generados? Los vídeos están disponibles para su descarga durante un periodo de tiempo tras la generación. Descárgalos y almacénalos sin demora.

¿Ofrecéis bibliotecas SDK? Hay SDKs de la comunidad disponibles para Python y Node. Consulta la documentación para desarrolladores en arteza.ai.

¿Puedo cancelar un trabajo en curso? Sí, envía DELETE /v1/seedance-1-pro/jobs/{job_id}. Los trabajos cancelados no consumen créditos.

¿Cómo obtengo soporte? Envía un correo al soporte desde el panel de tu cuenta para problemas específicos de la API.

---

La API de Seedance 1.0 Pro es la vía lista para producción para integrar la generación de vídeo con IA a 1080p en tu producto o pipeline.

Obtén tu clave de API y empieza a crear → con 10 créditos gratuitos incluidos al registrarte.