Créer des vidéos courtes avec Seedance-2.0-Fast via l'API hiapi

TL;DR

• C'est quoi : un flux de travail complet pour produire des clips verticaux de style TikTok/Reels avec seedance-2.0-fast via l'API hiapi — de votre premier appel de tâche asynchrone jusqu'au rendu de toute une semaine de publications avec un seul script par lots. Le clip intégré ci-dessous a été généré avec exactement la même requête que celle présentée dans ce guide.
• Pourquoi ce modèle pour les vidéos courtes : sortie native 9:16, durée de 4 à 15 secondes, rendu 720p à 0,1772 $ par seconde — un clip vertical de 5 secondes coûte environ 0,89 $ (tarification en direct). Le niveau brouillon 480p est à 0,0843 $ par seconde, ce qui vous permet d'itérer à moindre coût sur l'accroche d'ouverture avant de valider le rendu final.
• Faits API vérifiés : prompt, resolution (480p | 720p) et duration (entier, 4–15) sont obligatoires. aspect_ratio accepte 1:1, 4:3, 3:4, 16:9, 9:16, 21:9, adaptive. L'image-vers-vidéo se fait en passant une image fixe via image_urls. Tout passe par le point de terminaison asynchrone unifié /v1/tasks — aucun API spécifique à la vidéo à apprendre séparément.
• Flux de travail : produisez d'abord un brouillon en 480p pour verrouiller le concept, puis re-rendez en 720p les versions finales conservées, et comme la soumission des tâches est non bloquante, vous pouvez distribuer plusieurs prompts en parallèle.

Pourquoi seedance-2.0-fast convient au cycle des vidéos courtes

Le contenu court est un jeu d'échelle — vous publiez rarement un seul clip, mais toute une file, en gardant ceux qui fonctionnent. Cela change ce que vous attendez vraiment d'un modèle vidéo : une sortie verticale native, rapide et bon marché, importe plus que la qualité brute. seedance-2.0-fast est justement construit autour de ce compromis :

• La facturation à la seconde rend l'itération maîtrisée. En 480p, un brouillon de 4 secondes coûte environ 0,34 $ ; un clip de 5 secondes comme celui ci-dessous coûte 0,42 $ en 480p et 0,89 $ en 720p. Comme la facturation suit exactement duration × rate, duration est votre seul levier de coût — aucun supplément « qualité » séparé à intégrer à votre budget (vérifié sur la page de tarification en direct).
• 9:16 natif. Vous rendez le vertical directement via aspect_ratio, au lieu de recadrer un clip 16:9 et de perdre la composition décrite par le prompt.
• Le mode vidéo de référence est moins cher, pas plus cher. Passer un clip reference_video_urls pour guider le style/mouvement réduit le tarif à 0,1072 $ par seconde en 720p et 0,0486 $ par seconde en 480p — utile quand vous trouvez un style que vous voulez répliquer sur tout un lot.

Si vous publiez des pièces phares plutôt que du contenu quotidien en volume, le flux de travail ci-dessous s'applique toujours — pour une présentation plus large du modèle, consultez notre article compagnon seedance-2.0-fast pour l'intégration API.

Préparation

Vous avez besoin d'une clé API hiapi — aucun SDK requis :

export HIAPI_API_KEY="sk-..."

Tous les modèles vidéo de hiapi passent par le même point de terminaison de tâche asynchrone : POST https://api.hiapi.ai/v1/tasks renvoie immédiatement un taskId, puis vous interrogez GET /v1/tasks/{taskId} jusqu'à son achèvement. Voir la documentation pour la référence complète.

Votre premier clip vertical

La requête minimale valide nécessite prompt, resolution et duration. Ajoutez aspect_ratio: "9:16" pour le format court :

curl -X POST https://api.hiapi.ai/v1/tasks \
  -H "Authorization: Bearer $HIAPI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedance-2.0-fast",
    "input": {
      "prompt": "Gros plan vertical : deux mains empilent une crêpe dorée sur une haute pile de crêpes, dans un plat en verre posé sur une table en bois rustique dans une cuisine champêtre baignée de soleil, avec de la vapeur qui s'élève. Une lumière chaude du matin arrive depuis la gauche. Puis un filet de miel coule lentement sur la crêpe du dessus, scintillant dans la lumière, la vapeur continuant de monter. Ambiance chaleureuse, naturelle, caméra à la main, faible profondeur de champ, tons chauds. Aucune superposition de texte.",
      "resolution": "720p",
      "aspect_ratio": "9:16",
      "duration": 5
    }
  }'

La réponse renvoie immédiatement un ID de tâche :

{"code": 200, "data": {"taskId": "tk-hiapi-..."}, "message": "success"}

Interrogez jusqu'à ce que status soit success, puis téléchargez immédiatement output[0].url — cette URL est à durée limitée. Voici le clip réellement généré par cette requête :

Ce rendu est en 720×1280 (9:16 propre), dure un peu plus de 5 secondes, et a été facturé 0,886 $ — exactement 5 × 0,1772 $, confirmant en pratique la facturation à la seconde, et pas seulement sur la page de tarification.

Schéma d'entrée vérifié contre l'API en direct

Le schéma de seedance-2.0-fast est strict — envoyer un champ non pris en charge renvoie une 400, et non un paramètre silencieusement ignoré :

Champ	Type	Obligatoire	Valeurs
prompt	string	✅	Votre description du plan
resolution	string	✅	480p, 720p
duration	integer	✅	4–15 (secondes)
aspect_ratio	string	facultatif	1:1, 4:3, 3:4, 16:9, 9:16, 21:9, adaptive
image_urls	array	facultatif	Image fixe source pour l'image-vers-vidéo

Omettre un champ obligatoire fait rejeter la tâche avant toute création — une requête mal formée n'est pas facturée. Respectez exactement les noms de champs de ce tableau ; les scripts de vidéos courtes écrits pour d'autres modèles vidéo (avec motion_strength, seed, first_frame_url) renvoient ici une 400 au lieu d'être ignorés.

Fonction Python réutilisable

Soumettre, interroger, télécharger — environ 30 lignes couvrent une boucle de production :

import os, time, requests

API = "https://api.hiapi.ai/v1/tasks"
HEADERS = {"Authorization": f"Bearer {os.environ['HIAPI_API_KEY']}"}

def submit(prompt: str, duration: int = 5, resolution: str = "720p",
           aspect_ratio: str = "9:16", **extra) -> str:
    r = requests.post(API, headers=HEADERS, json={
        "model": "seedance-2.0-fast",
        "input": {"prompt": prompt, "duration": duration,
                  "resolution": resolution, "aspect_ratio": aspect_ratio, **extra},
    }, timeout=60)
    data = r.json()
    task_id = (data.get("data") or {}).get("taskId")
    if not task_id:
        raise RuntimeError(f"submit failed: {data}")
    return task_id

def wait(task_id: str, timeout_s: int = 900) -> dict:
    deadline = time.time() + timeout_s
    while time.time() < deadline:
        task = requests.get(f"{API}/{task_id}", headers=HEADERS, timeout=30).json()["data"]
        if task["status"] == "success":
            return task
        if task["status"] == "fail":
            raise RuntimeError(f"task failed: {task.get('error')}")
        time.sleep(8)
    raise TimeoutError(task_id)

def make_clip(prompt: str, out_path: str, **kw):
    task = wait(submit(prompt, **kw))
    url = task["output"][0]["url"]          # durée limitée — téléchargez immédiatement
    with open(out_path, "wb") as f:
        f.write(requests.get(url, timeout=120).content)

Un rendu 720p de 5 secondes se termine généralement en une à deux minutes ; en charge de pointe, prévoyez jusqu'à environ 10 minutes avant de le considérer comme expiré.

Image-vers-vidéo : partir d'une image fixe

Pour les clips centrés sur un produit ou une marque, la dérive du prompt est le vrai risque — vous voulez que l'image montre votre produit ou assiette, pas l'interprétation qu'en fait le modèle. image_urls résout ce problème : générez ou photographiez une image fixe, puis animez-la.

task_id = submit(
    "La pile de crêpes se stabilise doucement, la vapeur continue de monter, puis le miel commence à couler depuis hors-champ, les premières gouttes tombant sur la crêpe du dessus. Mouvement lent et régulier, caméra à la main, lumière chaude du matin.",
    duration=5, resolution="720p", aspect_ratio="9:16",
    image_urls=["https://your-cdn.example/pancake-still.jpg"],
)

La composition, l'éclairage et la position du sujet sont verrouillés sur votre image fixe de référence — le prompt n'a plus qu'à décrire le mouvement qui suit. Idéal pour tout clip où l'image de départ compte plus que l'intuition du modèle (un plat, une photo produit, un décor de marque).

Générer une journée de clips par lots

Comme /v1/tasks est asynchrone, la production par lots se résume à : tout soumettre, puis tout collecter.

briefs = [
    ("hook-pancakes", "Gros plan vertical : deux mains empilent une crêpe dorée..."),
    ("hook-latte",    "Plan vertical : la vapeur s'élève d'un latte fraîchement préparé pendant qu'on verse le lait..."),
    ("hook-citrus",   "Plan macro vertical : un couteau tranche un agrume..."),
]

tasks = {name: submit(p, duration=5) for name, p in briefs}   # distribution parallèle
for name, tid in tasks.items():                                # collecte des résultats
    result = wait(tid)
    url = result["output"][0]["url"]
    open(f"{name}.mp4", "wb").write(requests.get(url, timeout=120).content)

Le coût reste prévisible, car la facturation suit strictement duration × rate :

Scénario	Spécifications	Coût
1 itération de brouillon	4 secondes · 480p	environ 0,34 $
1 clip publiable	5 secondes · 720p	environ 0,89 $
5 clips (un lot quotidien)	5 × 5 secondes · 720p	environ 4,43 $
Lot assorti au style	5 secondes · 720p avec reference_video_urls	environ 0,54 $ par clip

Un flux de travail qui tient en pratique : produisez un brouillon en 480p pour chaque idée, gardez celles qui méritent d'être publiées, et ne re-rendez que celles-là en 720p. Une fois que vous trouvez un style qui vaut la peine d'être répété, reference_video_urls verrouille ce style à un tarif par seconde inférieur à celui d'un rendu 720p tout neuf.

Astuces de prompt pour le fil

Ce qui façonne réellement le résultat dans les rendus de test, en particulier pour les vidéos courtes :

• Décrivez l'image comme verticale, et réglez aspect_ratio: "9:16" en conséquence. Un prompt écrit pour une scène 16:9 sera recadré au centre quand il est forcé en 9:16 ; décrire dès le départ une composition verticale rapprochée (comme le clip de crêpes ci-dessus) permet au sujet de remplir l'image.
• Commencez par le mouvement, pas par le décor. L'instant d'ouverture d'un clip de fil doit déjà montrer de l'action — une main qui empile déjà, du miel qui coule déjà — et non un lent plan d'établissement avant la récompense.
• Gardez une action claire par clip. Le rendu de 5 secondes ci-dessus fait précisément deux choses dans l'ordre (empiler, puis verser), ce qui se lit clairement ; entasser trois actions sans rapport dans un seul clip les rend souvent toutes floues.
• Précisez la lumière et les matières. « lumière chaude du matin », « vapeur qui s'élève », « qui scintille » — les détails sensoriels concrets sont ce qui distingue un rendu précis et appétissant d'un rendu générique.

FAQ

seedance-2.0-fast est-il particulièrement adapté à TikTok et Reels ? Oui — la prise en charge native du 9:16 et la facturation à la seconde (plutôt qu'un tarif fixe par clip) en font un choix idéal pour un rythme de publication où vous rendez plusieurs options courtes et gardez la meilleure.

Combien coûte un seul clip court ? En 720p, le coût est durée (secondes) × 0,1772 $. Un clip de 5 secondes coûte 0,886 $ ; un clip de 10 secondes coûte 1,772 $. En 480p, le tarif descend à 0,0843 $ par seconde. Avant de budgétiser tout un lot, vérifiez toujours les tarifs en vigueur sur la page de tarification.

Puis-je animer une image fixe plutôt que générer uniquement à partir de texte ? Oui, via image_urls dans la requête — voir la section image-vers-vidéo ci-dessus. C'est la voie la plus fiable quand un produit, une assiette ou un décor précis doit apparaître exactement comme à la prise de vue.

Quelle est la durée minimale et maximale de clip que je peux générer ? duration accepte des entiers de 4 à 15 secondes. Les fractions de seconde ne sont pas prises en charge.

La résolution affecte-t-elle autre chose que la taille en pixels et le prix ? Pas dans le schéma lui-même — resolution ne contrôle que la taille de sortie et le tarif par seconde. La composition et le mouvement sont entièrement pilotés par le prompt et aspect_ratio.

En résumé

Faire des vidéos courtes avec seedance-2.0-fast se résume à un point de terminaison asynchrone, trois champs obligatoires, et une facturation à la seconde qui encourage à itérer avant de valider : produisez des brouillons verticaux en 480p, verrouillez l'image d'ouverture du gagnant avec image_urls si un produit ou sujet précis doit apparaître exactement, puis re-rendez en 720p les versions finales conservées. Obtenez une clé API, commencez par la requête en haut de ce guide — la page du modèle seedance-2.0-fast contient la référence complète des paramètres et la tarification actuelle pour aller plus loin.