- Quand utiliser Hunyuan Video Fast vs Standard
- Étape 1 : Obtenez votre clé API Novita AI
- Étape 2 : Point de terminaison et ID du modèle
- Étape 3 : Envoyez votre première requête
- Étape 4 : Interrogez le résultat vidéo
- Exemple Python
- Exemple cURL
- Paramètres clés
- Tarification et limites
- Dépannage
- FAQ
- Articles recommandés
Hunyuan Video Fast est disponible sur Novita AI à l’adresse POST https://api.novita.ai/v3/async/hunyuan-video-fast. Il s’agit de la variante optimisée pour la vitesse du modèle fondamental open source Hunyuan Video de Tencent — elle réduit le temps de génération par rapport à la version standard au prix d’une certaine fidélité de mouvement, ce qui la rend pratique pour les pipelines à haut débit, l’itération de prompts et les flux de travail de préproduction où la rapidité d’exécution compte plus que la qualité cinématographique maximale.
Comme toutes les API vidéo asynchrones de Novita, elle renvoie un task_id lors de la soumission et fournit l’URL de la vidéo une fois la tâche terminée. Ce guide couvre le point de terminaison, le format de requête, des exemples Python et cURL fonctionnels, ainsi que la place de la variante rapide par rapport au modèle standard.
Quand utiliser Hunyuan Video Fast vs Standard
La variante rapide est le bon choix lorsque le temps de génération et le volume de requêtes comptent plus que la qualité visuelle maximale. Hunyuan Video standard produit un mouvement plus fidèle et un meilleur respect des prompts par génération. La variante rapide réduit considérablement ce temps — utile pour :
- Itération de prompts — tester de nombreuses variantes à moindre coût avant de s’engager dans un rendu pleine qualité
- Pipelines à haut débit — génération de contenu en lot où la latence par clip affecte directement le débit
- Préproduction et revue interne — obtenir rapidement un résultat partageable, puis passer au standard pour la livraison finale
- Applications à faible latence — flux de travail de production avec des budgets de temps de réponse stricts
Si la qualité de sortie est la contrainte principale — diffusion, livraison finale ou mouvement photoréaliste — utilisez plutôt le point de terminaison standard Hunyuan Video.
Étape 1 : Obtenez votre clé API Novita AI
Créez un compte sur novita.ai et générez une clé API depuis la page de gestion des clés. Les nouveaux comptes reçoivent des crédits gratuits. Stockez la clé comme variable d’environnement — ne la codez jamais en dur dans les fichiers sources.
export NOVITA_API_KEY="your_api_key_here"
Étape 2 : Point de terminaison et ID du modèle
| Champ | Valeur |
|---|---|
| Point de terminaison de soumission | POST https://api.novita.ai/v3/async/hunyuan-video-fast |
| Récupération du résultat | GET https://api.novita.ai/v3/async/task-result?task_id=<id> |
| En-tête d’authentification | Authorization: Bearer $NOVITA_API_KEY |
| Content-Type | application/json |
Référence officielle de l’API : novita.ai/docs/api-reference/model-apis-hunyuan-video-fast
Étape 3 : Envoyez votre première requête
Soumettez une requête de génération avec votre prompt et vos paramètres de sortie :
curl -s -X POST https://api.novita.ai/v3/async/hunyuan-video-fast \
-H "Authorization: Bearer $NOVITA_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"prompt": "A red fox running through a snowy forest at dawn, slow motion, cinematic wide shot",
"negative_prompt": "blurry, low quality, distorted, watermark",
"width": 1280,
"height": 720,
"seed": -1
}'
L’API renvoie immédiatement un task_id :
{
"task_id": "hunyuan-fast-abc123"
}
La vidéo n’est pas dans cette réponse — stockez le task_id et utilisez-le à l’étape suivante.
Étape 4 : Interrogez le résultat vidéo
curl -s "https://api.novita.ai/v3/async/task-result?task_id=hunyuan-fast-abc123" \
-H "Authorization: Bearer $NOVITA_API_KEY"
Continuez d’interroger jusqu’à ce que task_status soit TASK_STATUS_SUCCEED :
{
"task_status": "TASK_STATUS_SUCCEED",
"videos": [
{
"video_url": "https://cdn.novitai.com/output/...",
"video_url_ttl": 3600,
"video_type": "mp4"
}
]
}
Téléchargez ou stockez video_url rapidement — elle expire après video_url_ttl secondes.
Valeurs du statut de la tâche
| Statut | Signification |
|---|---|
TASK_STATUS_QUEUED |
Requête acceptée, en attente d’exécution |
TASK_STATUS_PROCESSING |
Génération en cours |
TASK_STATUS_SUCCEED |
Terminée — URL de la vidéo disponible dans videos[0].video_url |
TASK_STATUS_FAILED |
Échec de la génération — vérifiez la réponse pour connaître la raison de l’échec |
Exemple Python
import os
import time
import requests
API_KEY = os.environ["NOVITA_API_KEY"]
BASE_URL = "https://api.novita.ai"
HEADERS = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json",
}
def submit_video(
prompt: str,
negative_prompt: str = "",
width: int = 1280,
height: int = 720,
seed: int = -1,
) -> str:
payload = {
"prompt": prompt,
"negative_prompt": negative_prompt,
"width": width,
"height": height,
"seed": seed,
}
resp = requests.post(
f"{BASE_URL}/v3/async/hunyuan-video-fast",
headers=HEADERS,
json=payload,
)
resp.raise_for_status()
return resp.json()["task_id"]
def poll_result(task_id: str, interval: int = 5, timeout: int = 300) -> dict:
deadline = time.time() + timeout
while time.time() < deadline:
resp = requests.get(
f"{BASE_URL}/v3/async/task-result",
headers=HEADERS,
params={"task_id": task_id},
)
resp.raise_for_status()
data = resp.json()
status = data.get("task_status", "")
if status == "TASK_STATUS_SUCCEED":
return data
if status == "TASK_STATUS_FAILED":
raise RuntimeError(f"Task failed: {data}")
time.sleep(interval)
raise TimeoutError(f"Task {task_id} did not complete within {timeout}s")
if __name__ == "__main__":
task_id = submit_video(
prompt="A red fox running through a snowy forest at dawn, slow motion, cinematic wide shot",
negative_prompt="blurry, low quality, distorted, watermark",
width=1280,
height=720,
)
print(f"Task submitted: {task_id}")
result = poll_result(task_id)
for video in result.get("videos", []):
print(f"Video URL (expires in {video['video_url_ttl']}s): {video['video_url']}")
Exemple cURL
# Step 1: Submit the generation request
TASK_ID=$(curl -s -X POST https://api.novita.ai/v3/async/hunyuan-video-fast \
-H "Authorization: Bearer $NOVITA_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"prompt": "A timelapse of a city skyline transitioning from dusk to night, cinematic",
"negative_prompt": "blurry, low quality, distorted",
"width": 1280,
"height": 720,
"seed": 42
}' | jq -r '.task_id')
echo "Task ID: $TASK_ID"
# Step 2: Poll until complete
while true; do
RESULT=$(curl -s "https://api.novita.ai/v3/async/task-result?task_id=$TASK_ID" \
-H "Authorization: Bearer $NOVITA_API_KEY")
STATUS=$(echo "$RESULT" | jq -r '.task_status')
if [ "$STATUS" = "TASK_STATUS_SUCCEED" ]; then
echo "$RESULT" | jq -r '.videos[0].video_url'
break
elif [ "$STATUS" = "TASK_STATUS_FAILED" ]; then
echo "Failed: $RESULT"
break
fi
echo "Status: $STATUS — waiting..."
sleep 5
done
Paramètres clés
| Paramètre | Type | Requis | Description |
|---|---|---|---|
prompt |
string | Oui | Texte décrivant la scène, le sujet, le mouvement et le style de la vidéo |
negative_prompt |
string | Non | Éléments à éviter dans la sortie (par ex., « flou, basse qualité ») |
width |
integer | Non | Largeur de sortie en pixels — consultez la documentation API pour les valeurs prises en charge |
height |
integer | Non | Hauteur de sortie en pixels — associée à width pour définir la résolution |
seed |
integer | Non | Définissez un entier fixe pour reproduire la même sortie ; -1 pour aléatoire |
Pour la liste complète des paramètres, y compris les options de durée, les contraintes de résolution maximale et les champs spécifiques au modèle, consultez la référence API Hunyuan Video Fast.
Tarification et limites
Vérifiez la tarification actuelle par vidéo sur la page des modèles Novita AI. La tarification de la génération vidéo est généralement par clip généré et varie selon la résolution et la durée. Consultez la page de tarification avant de construire un modèle de coût pour les charges de travail en production.
Confirmez les limites suivantes dans la documentation officielle avant le déploiement :
- Longueur maximale du prompt en caractères
- Valeurs de résolution prises en charge (combinaisons largeur × hauteur)
- Durée vidéo maximale en secondes
- Limites de débit et plafonds de tâches simultanées par clé API
La variante rapide coûte généralement moins cher par clip que le modèle standard en raison du temps de calcul réduit — vérifiez l’écart actuel sur la page de tarification Novita.
Dépannage
401 Unauthorized — La clé API est manquante, invalide ou expirée. Vérifiez que NOVITA_API_KEY est définie et que la clé est active dans votre tableau de bord Novita AI.
422 Unprocessable Entity — Un paramètre requis est manquant ou une valeur est hors limites. Vérifiez que prompt n’est pas vide et que les valeurs width/height font partie de l’ensemble pris en charge par la documentation API.
La tâche reste en TASK_STATUS_PROCESSING — La génération est toujours en cours. La variante rapide se termine plus vite que la standard, mais les résolutions plus élevées et les durées plus longues prennent plus de temps. Augmentez votre délai d’interrogation pour les sorties volumineuses.
video_url renvoie 403 ou 404 — L’URL a expiré (video_url_ttl écoulé). En production, téléchargez ou transférez la vidéo immédiatement après TASK_STATUS_SUCCEED — ne vous fiez pas à l’URL hébergée comme stockage permanent.
Problèmes de qualité récurrents sur certains types de prompts — Adoptez une approche d’affinement du prompt : décrivez explicitement le sujet, l’action, l’angle de caméra et le style. Ajoutez des entrées negative_prompt pour les artefacts courants. Si la qualité reste insuffisante pour le cas d’usage, évaluez le point de terminaison standard Hunyuan Video.
FAQ
Quel est le point de terminaison Novita AI pour Hunyuan Video Fast ?
POST https://api.novita.ai/v3/async/hunyuan-video-fast. L’API est asynchrone : soumettez une requête, recevez un task_id, puis interrogez GET https://api.novita.ai/v3/async/task-result?task_id=<id> jusqu’à ce que task_status soit TASK_STATUS_SUCCEED.
En quoi Hunyuan Video Fast diffère-t-il du Hunyuan Video standard ?
La variante rapide est optimisée pour la vitesse de génération — elle réduit le temps entre la soumission de la tâche et la vidéo terminée. En contrepartie, la fidélité du mouvement et l’adhérence fine aux prompts sont inférieures à celles du modèle standard. Utilisez la variante rapide pour l’itération de prompts, les traitements par lots à haut débit ou la préproduction ; utilisez le standard pour une sortie de qualité finale.
Puis-je définir une durée vidéo spécifique ?
Consultez la référence API pour les paramètres de durée pris en charge. Certaines API vidéo Novita exposent un champ duration explicite ; d’autres utilisent une valeur par défaut du modèle. Vérifiez avant de présumer une durée de clip par défaut.
Comment reproduire une sortie vidéo spécifique ?
Définissez seed sur un entier fixe. La même combinaison de seed, prompt, width et height devrait produire une sortie cohérente entre les exécutions.
Hunyuan Video Fast prend-il en charge l’image vers vidéo ?
Hunyuan Video Fast sur Novita AI est un modèle texte-vers-vidéo. Pour la génération image-vers-vidéo sur Novita, consultez les modèles I2V disponibles tels que Kling, Vidu ou Wan sur la page des modèles Novita.
Combien coûte Hunyuan Video Fast sur Novita AI ?
Vérifiez la tarification actuelle sur novita.ai/models. La tarification par clip des modèles vidéo peut changer ; consultez toujours la page de tarification avant d’établir des estimations de coûts de production.
Hunyuan Video Fast est-il adapté aux pipelines vidéo de production ?
Oui, avec une gestion appropriée. Concevez votre pipeline autour d’une soumission de tâche asynchrone, stockez le task_id pour le suivi de statut, téléchargez la vidéo immédiatement après la fin (avant l’expiration de video_url_ttl), et gérez TASK_STATUS_FAILED avec une stratégie de nouvelle tentative ou de repli.
