Guía de creación de videos cortos con seedance-2-0: recetas prácticas con la API de hiapi

Vista rápida

• Qué es: una receta reproducible y ejecutable que te enseña a crear videos cortos verticales (TikTok / Reels / Shorts) con seedance-2.0 en hiapi. El video corto incrustado abajo se generó exactamente con el prompt impreso justo encima: no es una demostración ajena.
• Dos modos, un modelo: seedance-2.0 admite texto a video e imagen a video bajo el mismo endpoint: puedes partir de un prompt o animar una imagen estática existente.
• Datos de la API (verificados en la plataforma): seedance-2.0 se ejecuta en el endpoint de tareas asíncrono (/v1/tasks). El objeto input requiere prompt, aspect_ratio (obligatorio; para video corto usa 9:16), resolution (480p / 720p / 1080p) y duration en segundos. El resultado se devuelve como MP4 en output[0].url.
• Precios (por segundo de salida): 480p a $0.136/segundo, 720p a $0.293/segundo, 1080p a $0.729/segundo. Un video corto de 4 segundos en 480p cuesta $0.54. Consulta los precios en tiempo real en la página de precios.
• Cómo ejecutarlo: envía un POST a la API de tareas, consulta hasta que el estado sea success y luego descarga el MP4 desde output[0].url: esa URL es temporal y caduca, así que guarda los bytes de inmediato. Los scripts completos listos para copiar (ambos modos + bucle por lotes) están al final del artículo.

Por qué elegir seedance-2.0 para video corto

Las plataformas de video corto tienen una gramática fija: vertical 9:16, unos pocos segundos de duración, un compás de acción claro. Esa es exactamente la forma para la que nació seedance-2.0. Con solo una marca de relación de aspecto renderiza movimiento cinematográfico, así que no tienes que pelear con el modelo para obtener un encuadre vertical: pide 9:16 y compondrá en ese formato.

La otra razón es el flujo de trabajo: cada video corto es una sola tarea asíncrona. Envías el trabajo, consultas el ID de la tarea y recuperas un MP4 terminado. No hay un socket de streaming que atender ni un timeout de 100 segundos que esquivar: es exactamente el mismo protocolo de tareas que usan todos los demás modelos generativos de hiapi, así que si ya has llamado a los modelos de imagen, el flujo de control aquí es idéntico.

Modo 1: texto a video

Es la vía más rápida para obtener un video corto: describe el plano, elige formato y duración, y envía.

El prompt de abajo es el que ejecuté realmente. Escribe como un director: sujeto, iluminación, movimiento de cámara, no como una lista de palabras clave.

Prompt: Un barista extrae un espresso en una cafetería bañada por el sol, primer plano de la crema arremolinándose en la taza, luz cálida de la mañana, suave vapor que se eleva, poca profundidad de campo, suave acercamiento de cámara en mano.

Ajustes: aspect_ratio: 9:16, resolution: 480p, duration: 4

El video corto tiene formato nativo 9:16 y encaja directamente en la línea de tiempo de Reels/Shorts. El render tardó aproximadamente dos minutos y, con la tarifa actual de 480p, costó unos $0.54: lo bastante barato como para generar varias variantes y quedarte con la mejor.

El cuerpo de la solicitud es pequeño. Un campo que suele pasarse por alto es aspect_ratio: es obligatorio y, si falta, la API rechaza la tarea con missing required field "aspect_ratio".

import os, json, requests

TOKEN = os.environ["HIAPI_TOKEN"]
BASE = "https://api.hiapi.ai/v1/tasks"
HEADERS = {"Authorization": f"Bearer {TOKEN}", "Content-Type": "application/json"}

payload = {
    "model": "seedance-2.0",
    "input": {
        "prompt": (
            "A barista pulls a shot of espresso in a sunlit cafe, close-up on the "
            "crema swirling into the cup, warm morning light, gentle steam rising, "
            "shallow depth of field, smooth handheld camera push-in."
        ),
        "aspect_ratio": "9:16",   # required — 9:16 for short-form
        "resolution": "480p",     # 480p | 720p | 1080p
        "duration": 4,            # seconds
    },
}

r = requests.post(BASE, headers=HEADERS, data=json.dumps(payload), timeout=60)
task_id = r.json()["data"]["taskId"]
print("submitted:", task_id)

Modo 2: imagen a video

El segundo modo consiste en animar una imagen estática que tú aportas, en lugar de crear la escena desde cero. Esto es justo lo que necesita el trabajo de marca: toma (o genera) una imagen de producto limpia y deja que seedance-2.0 añada el compás de movimiento, de modo que tanto la composición como el producto se mantengan fieles a la marca.

La forma de la llamada es la misma que la de una tarea: conserva aspect_ratio, resolution y duration, y tu prompt ahora describe el movimiento que se aplicará a la imagen («acercamiento lento», «la modelo gira hacia la cámara», «el vapor empieza a elevarse»), no toda la escena. Si lo combinas con una imagen estática de los modelos de imagen, tendrás un flujo en dos pasos: genera la pieza visual principal y luego dale movimiento.

Consejo: mantén breves los videos cortos de imagen a video (4 segundos) y haz que el movimiento sea sutil. El video corto premia un compás limpio y bien definido, no un plano recargado.

Cálculo de costes para lotes de video corto

Como la facturación es por segundo de salida, tu coste es muy fácil de predecir: elige la resolución y multiplícala por la duración del video corto:

Resolución	Precio / segundo	Video de 4 s	Video de 8 s
480p	$0.136	$0.54	$1.09
720p	$0.293	$1.17	$2.34
1080p	$0.729	$2.92	$5.83

Para iterar sobre el gancho una y otra vez, redacta en 480p: cuesta una cuarta parte que 720p y basta para juzgar composición y movimiento. Vuelve a renderizar solo la versión ganadora en 720p o 1080p para la publicación final. Consulta las tarifas actuales de cada modelo en la página de precios.

Script completo: enviar, consultar, descargar

Esta es la versión de extremo a extremo: envía un trabajo de texto a video, consulta la tarea hasta que termine y luego guarda el MP4. El paso de descarga es importante: output[0].url es un enlace temporal que caduca, así que escribe los bytes en disco en cuanto la tarea se complete con éxito.

import os, json, time, requests

TOKEN = os.environ["HIAPI_TOKEN"]
BASE = "https://api.hiapi.ai/v1/tasks"
HEADERS = {"Authorization": f"Bearer {TOKEN}", "Content-Type": "application/json"}


def submit(prompt, aspect_ratio="9:16", resolution="480p", duration=4):
    payload = {
        "model": "seedance-2.0",
        "input": {
            "prompt": prompt,
            "aspect_ratio": aspect_ratio,  # required
            "resolution": resolution,      # 480p | 720p | 1080p
            "duration": duration,          # seconds
        },
    }
    r = requests.post(BASE, headers=HEADERS, data=json.dumps(payload), timeout=60)
    r.raise_for_status()
    return r.json()["data"]["taskId"]


def wait(task_id, timeout_s=600, poll=8):
    deadline = time.time() + timeout_s
    while time.time() < deadline:
        r = requests.get(f"{BASE}/{task_id}", headers=HEADERS, timeout=30)
        data = r.json().get("data", {})
        status = data.get("status")
        if status == "success":
            return data
        if status == "fail":
            raise RuntimeError(f"task failed: {data.get('error')}")
        time.sleep(poll)
    raise TimeoutError(f"task {task_id} did not finish in {timeout_s}s")


def download(task, path):
    out = task["output"][0]
    assert out["type"] == "video", f"unexpected output type: {out['type']}"
    # output[0].url is temporary (see expireAt) — save immediately.
    resp = requests.get(out["url"], timeout=120)
    resp.raise_for_status()
    with open(path, "wb") as f:
        f.write(resp.content)
    return path


if __name__ == "__main__":
    prompt = (
        "A barista pulls a shot of espresso in a sunlit cafe, close-up on the crema "
        "swirling into the cup, warm morning light, gentle steam rising, shallow "
        "depth of field, smooth handheld camera push-in."
    )
    tid = submit(prompt, aspect_ratio="9:16", resolution="480p", duration=4)
    print("submitted:", tid)
    task = wait(tid)
    print("saved:", download(task, "espresso_9x16.mp4"))

Para convertir un gancho en un lote completo, envuelve submit / wait / download en un bucle que recorra los prompts:

HOOKS = {
    "espresso":  "A barista pulls a shot of espresso in a sunlit cafe, close-up on the crema, gentle steam, handheld push-in.",
    "matcha":    "A whisk froths bright green matcha in a ceramic bowl, top-down light, slow spiral motion, calm morning mood.",
    "pour-over": "Hot water spirals over fresh coffee grounds in a dripper, close macro, steam rising, warm backlight.",
}

for name, prompt in HOOKS.items():
    tid = submit(prompt, aspect_ratio="9:16", resolution="480p", duration=4)
    task = wait(tid)
    download(task, f"{name}_9x16.mp4")
    print("done:", name)

Redacta este lote en 480p, elige los ganadores, vuelve a renderizarlos en 1080p y publica. Ese es el ciclo completo de video corto con un solo modelo y un solo endpoint.

Puntos clave

• seedance-2.0 es una sola tarea asíncrona en /v1/tasks que devuelve un MP4: el mismo flujo de control que los modelos de imagen de hiapi.
• aspect_ratio es obligatorio; para TikTok / Reels / Shorts usa 9:16.
• La facturación es por segundo de salida: 480p $0.136/s, 720p $0.293/s, 1080p $0.729/s; así que redacta barato en 480p y termina solo los ganadores en alta resolución.
• La URL de salida es temporal: descarga los bytes en cuanto la tarea informe success.
• La misma llamada sirve tanto para texto a video como para imagen a video; combina imagen a video con imágenes estáticas generadas para obtener movimiento de producto fiel a la marca.