Wan

Wan (Tongyi Wanxiang) est la famille de génération vidéo d’Alibaba, servie par les canaux DashScope. Les tâches passent par les mêmes endpoints que tout autre modèle vidéo — voir Créer une tâche et Obtenir une tâche. Cette page décrit de bout en bout l’adaptateur Wan 3.0 : les champs de requête qu’il lit, la construction de la requête DashScope, les règles sur les médias, la lecture de l’enregistrement de tâche et le calcul de la facturation à la seconde.

La génération vidéo est asynchrone : soumettez, conservez le task_id, interrogez toutes les 10 à 15 secondes, puis téléchargez lorsque le statut vaut SUCCESS.

Modèles

ID de modèle	Résolutions	Durée	Remarques
`wan3.0-video`	`480P`, `720P`, `1080P`	2 à 30 secondes, ou `-1` (intelligente)	Modèle standard : texte vers vidéo, première/dernière image et matériel de référence multiple
`wan3.0-video-prime`	`480P`, `720P`, `1080P`	2 à 30 secondes, ou `-1` (intelligente)	Variante plus rapide avec les mêmes capacités

Les deux utilisent 1080P et 5 secondes par défaut lorsque la requête les omet. Tous deux prennent en charge le texte vers vidéo, l’image vers vidéo avec première image ou première et dernière image, les images, vidéos et audios de référence, l’édition et l’extension vidéo. Les IDs de modèle sont ceux renvoyés par GET /v1/models ; les modèles auxquels votre compte a accès et leurs prix sont définis dans la console RouteAPI.

Le canal sert aussi les anciens modèles Wan 2.x (wan2.7-i2v, wan2.7-t2v, wan2.5-i2v-preview, wan2.2-*, wanx2.1-*), dont les règles diffèrent et qui ne sont pas couverts ici.

Mapping de l’enveloppe commune

Champ d’enveloppe	Ce que fait l’adaptateur Wan 3.0
`prompt`	Envoyé comme `input.prompt`. Comme toute requête de tâche, un prompt vide est rejeté avant soumission (`400`)
`image` / `images`	La première image est `image` s’il est défini, sinon la première entrée non vide de `images` ; la dernière image est la seconde entrée non vide de `images`. Au-delà de deux images, le reste est ignoré
`input_reference`	Raccourci mono-image : il remplace le tableau `images` par une URL, mais un `image` de premier niveau reste prioritaire pour la première image
`resolution`	Envoyé comme `parameters.resolution`, mis en majuscules et suffixé par `P` si nécessaire
`ratio`	Envoyé comme `parameters.ratio`, mis en minuscules
`size`	Replié dans `resolution` et `ratio`, puis supprimé. `1920x1080` et `19201080` sont acceptés ; une taille au format `` hors table renvoie `400`, tandis qu’un palier simple comme `720p` sert de résolution
`duration`	Envoyé comme `parameters.duration`. Une valeur absente devient 5
`seconds`	Analysé comme durée entière lorsque `duration` est absent
`generate_audio`	Envoyé comme `parameters.audio` ; un `false` explicite est transmis
`metadata`	Fusionné par-dessus la requête construite, donc `metadata.parameters.` et `metadata.input.` priment sur les valeurs mappées

Lorsque les deux sont envoyés, un resolution / ratio explicite prime sur la valeur déduite de size ; size est toujours retiré du corps amont. L’adaptateur envoie ensuite input, parameters et model à l’endpoint de synthèse vidéo de DashScope ; vous n’appelez jamais cet endpoint vous-même.

Le corps utilisant la forme de DashScope, les mêmes valeurs peuvent être fournies dans metadata :

{
  "metadata": {
    "input": { "negative_prompt": "blurry, low quality" },
    "parameters": { "duration": 10, "resolution": "720p", "ratio": "9:16" }
  }
}

metadata ne peut pas changer le modèle : un metadata.model différent du modèle amont résolu est rejeté avec 400.

Paramètres

Ces champs peuvent être écrits à la racine du corps de requête. Les clés spécifiques au modèle vont dans metadata.

Champ	Type	Valeurs	Remarques
`model`	string	`wan3.0-video`, `wan3.0-video-prime`	Obligatoire
`prompt`	string	—	Obligatoire et non vide. En mode référence, désignez le matériel par « image 1 », « video 1 », « audio 1 »
`resolution`	string	`480P`, `720P`, `1080P`	Insensible à la casse, le `P` final est optionnel. Par défaut `1080P`
`ratio`	string	`adaptive`, `21:9`, `16:9`, `4:3`, `1:1`, `3:4`, `9:16`	Insensible à la casse. En cas d’omission, DashScope applique `adaptive`
`size`	string	`1280*720`, `1280x720` ou `720p`	Replié dans `resolution` et `ratio`, puis supprimé. Seules les tailles du tableau de l’adaptateur sont acceptées
`duration`	integer	2–30	Secondes de sortie. Par défaut 5. Une valeur négative ou supérieure à 3600 est rejetée par la validation commune ; `-1` (durée intelligente) ne fonctionne que dans `metadata.parameters`
`seconds`	string	chaîne entière	Utilisé à la place de `duration` quand celui-ci est absent ou vaut `0`. Une valeur non entière renvoie `400`
`image`	string	URL	Image de première image unique ; elle prime sur `images` pour la première image
`images`	array	URL	1 image = première image ; 2 images = première puis dernière image
`input_reference`	string	URL	Remplace `images` par une seule URL de première image ; un `image` de premier niveau reste prioritaire
`generate_audio`	boolean	`true` / `false`	Envoyé comme `parameters.audio` ; un `false` explicite est transmis comme `false`
`metadata`	object	`input` / `parameters` de DashScope	Écrase les valeurs mappées ; voir ci-dessous

Lorsque size est une paire LARGEUR*HAUTEUR, elle doit figurer dans le tableau de l’adaptateur : 480P accepte 832*480, 480*832, 624*624 ; 720P accepte 1280*720, 720*1280, 960*960, 1088*832, 832*1088 ; 1080P accepte 1920*1080, 1080*1920, 1440*1440, 1632*1248, 1248*1632. Le ratio est réduit à partir de la paire et conservé uniquement s’il correspond à l’une des valeurs prises en charge ; sinon la requête est laissée au ratio par défaut de DashScope.

Paramètres metadata

metadata reprend les objets input et parameters de DashScope. Toutes les clés ci-dessous sont optionnelles.

Clé metadata	Type	Remarques
`input.media`	array	Liste de matériel composée d’éléments `{"type", "url"}`. Si présente, les images de premier niveau ne sont pas utilisées
`input.prompt`	string	Remplace le prompt de premier niveau côté amont, mais la validation commune exige toujours un `prompt` de premier niveau
`input.audio_url`	string	Raccourci pour ajouter un élément `reference_audio`
`input.negative_prompt`	string	Prompt négatif
`input.template`	string	Modèle d’effet DashScope, transmis tel quel
`parameters.resolution`	string	Identique au `resolution` de premier niveau
`parameters.ratio`	string	Identique au `ratio` de premier niveau
`parameters.size`	string	Identique au `size` de premier niveau
`parameters.duration`	integer	`-1` pour la durée intelligente, sinon 2–30
`parameters.audio`	boolean	Identique à `generate_audio`
`parameters.seed`	integer	`-1` ou 0–2147483647. `0` est conservé comme valeur explicite ; une même graine ne garantit pas un résultat identique
`parameters.watermark`	boolean	Filigrane côté fournisseur ; désactivé par défaut
`parameters.prompt_extend`	boolean	Accepté mais sans effet — la réécriture de prompt est toujours active (voir ci-dessous)

Les valeurs de metadata.parameters.* priment sur les équivalents de premier niveau. Les clés inconnues dans metadata sont ignorées, et une clé au mauvais type renvoie 400 avant toute réservation.

prompt_extend ne peut pas être désactivé. Le premier niveau n’a pas ce champ, donc un prompt_extend de premier niveau est purement ignoré ; sous metadata.parameters, l’adaptateur part toujours de true et stocke la valeur dans un booléen non pointeur avec omitempty, si bien que false est supprimé lors de l’envoi à DashScope et la valeur par défaut du fournisseur (activée) s’applique. Ne l’envoyez que pour rappeler la valeur par défaut ; cela ne change rien.

Médias d’entrée

Wan 3.0 reçoit le matériel via input.media, un tableau d’éléments {"type": "...", "url": "..."}. L’adaptateur le construit à partir des champs image de premier niveau et y fusionne ce que vous passez explicitement :

`type`	Signification	Limite (DashScope)
`first_frame`	Première image de la vidéo	1
`last_frame`	Dernière image de la vidéo ; nécessite une première image	1
`reference_image`	Image de référence pour le sujet ou le style	10
`reference_video`	Vidéo de référence pour la génération, l’édition ou l’extension	5, 15 secondes au total
`reference_audio`	Audio de référence. `input.audio_url` est ajouté sous ce type	5, 15 secondes au total

Un tableau media fourni explicitement dans metadata.input.media est conservé tel quel ; en son absence, l’adaptateur le construit à partir des champs image de premier niveau, dans l’ordre first_frame, last_frame. Ce repli lit aussi les anciennes clés metadata.input.img_url / first_frame_url / last_frame_url, et metadata.input.audio_url ajoute toujours un élément reference_audio. Ces quatre anciens champs sont repliés dans media puis vidés — Wan 3.0 ne comprend que media.

Les nombres et durées ci-dessus sont les règles de DashScope. RouteAPI ne les vérifie pas en amont ; une violation est rejetée par le fournisseur et remboursée — soit sous forme d’erreur fail_to_fetch_task, soit de tâche FAILURE — et non de 400 local.

Règles sur le matériel :

Les URL de matériel doivent être des adresses http(s) publiques téléchargeables sans connexion. Les images peuvent aussi être envoyées en data:image/png;base64,....
Limites par élément : images JPEG / JPG / PNG (sans alpha) / BMP / WEBP, 240 à 8000 px par côté, ratio d’aspect au plus 8:1, au plus 20 Mo ; vidéos mp4 / mov, 1 à 15 secondes chacune, au moins 16 fps, 240 à 4096 px par côté, au plus 100 Mo ; audio wav / mp3, 1 à 15 secondes chacun, au plus 15 Mo.
Le mode première/dernière image et le mode matériel de référence sont exclusifs. Mélanger des images de cadrage avec des éléments reference_* dans un même tableau media est rejeté par le fournisseur : la tâche est remboursée.
reference_image, reference_video et reference_audio se combinent librement.
Dans le prompt, désignez le matériel par son rang — « image 1 », « video 1 », « audio 1 » — compté par type dans l’ordre des éléments de media.

Deux règles sont appliquées localement, avant soumission : ni le fournisseur ni le solde ne sont sollicités.

metadata.input.audio_url avec un élément first_frame ou last_frame est rejeté avec 400 et le message wan3 does not support audio_url together with first/last frame images. La vérification ne porte que sur input.audio_url ; un élément reference_audio placé directement dans media à côté d’une image de cadrage est intercepté par DashScope (tâche FAILURE, remboursée).
Après la fusion de metadata, une requête avec un prompt vide et un tableau media vide est rejetée avec 400 (wan3 requires prompt or input.media). En pratique la validation commune rejette déjà un prompt vide, donc un prompt est toujours requis.

Texte vers vidéo

Seulement un prompt et les paramètres vidéo :

curl https://api.routeapi.ai/v1/video/generations \
  -H "Authorization: Bearer $ROUTEAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan3.0-video",
    "prompt": "An orange cat walking on a rooftop, cinematic lighting",
    "resolution": "480P",
    "ratio": "16:9",
    "duration": 2
  }'

Première et dernière image

Placez les images dans le tableau images de premier niveau : une image est la première, deux images sont la première puis la dernière, dans cet ordre.

curl https://api.routeapi.ai/v1/video/generations \
  -H "Authorization: Bearer $ROUTEAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan3.0-video",
    "prompt": "The scene shifts naturally from morning to sunset while the camera moves smoothly",
    "images": [
      "https://cdn.example.com/first.jpg",
      "https://cdn.example.com/last.jpg"
    ],
    "resolution": "720P",
    "ratio": "adaptive",
    "duration": 5
  }'

Vous pouvez aussi écrire les images de cadrage dans metadata.input.media avec un type explicite ; un last_frame doit toujours être envoyé avec un first_frame.

Image + vidéo + audio de référence

Pour du matériel de référence, écrivez chaque élément dans metadata.input.media. Dès que media est présent, les champs image de premier niveau sont ignorés.

curl https://api.routeapi.ai/v1/video/generations \
  -H "Authorization: Bearer $ROUTEAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan3.0-video",
    "prompt": "The character in image 1 performs the motion from video 1, dancing to the rhythm of audio 1",
    "resolution": "720P",
    "ratio": "adaptive",
    "duration": 8,
    "metadata": {
      "input": {
        "media": [
          { "type": "reference_image", "url": "https://cdn.example.com/character.jpg" },
          { "type": "reference_video", "url": "https://cdn.example.com/motion.mp4" },
          { "type": "reference_audio", "url": "https://cdn.example.com/music.mp3" }
        ]
      }
    }
  }'

Une requête contenant un élément reference_video réserve 30 secondes à la soumission, quelle que soit la durée demandée, car la longueur finale de sortie est alors inconnue — voir Facturation.

Édition et extension vidéo

Les deux modes passent la vidéo source comme reference_video et expriment l’intention dans le prompt.

Édition — par exemple « convertir entièrement la video 1 en style pâte à modeler ». Envoyez ratio: "adaptive" pour que la sortie conserve le ratio de la source.
Extension — par exemple « prolonger la video 1 vers l’avant en conservant le mouvement des personnages et le style de caméra ». ratio doit valoir adaptive. Réglez duration sur la longueur de la source plus l’extension : prolonger une vidéo de 5 secondes de 2 secondes donne 7. Vous pouvez aussi utiliser -1 et laisser le modèle décider.

Avec une vidéo en entrée, la longueur de la source plus la longueur de sortie ne peut pas dépasser 30 secondes. Cette limite est appliquée par DashScope ; une requête qui la dépasse échoue et est remboursée.

curl https://api.routeapi.ai/v1/video/generations \
  -H "Authorization: Bearer $ROUTEAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan3.0-video",
    "prompt": "Convert video 1 entirely into a claymation style",
    "resolution": "480P",
    "ratio": "adaptive",
    "duration": 2,
    "metadata": {
      "input": {
        "media": [ { "type": "reference_video", "url": "https://cdn.example.com/input.mp4" } ]
      }
    }
  }'

Pour prolonger ce même clip de 5 secondes de 2 secondes, changez le prompt et la durée :

curl https://api.routeapi.ai/v1/video/generations \
  -H "Authorization: Bearer $ROUTEAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan3.0-video",
    "prompt": "Extend video 1 forward by two seconds, keeping the character motion and camera style consistent",
    "resolution": "480P",
    "ratio": "adaptive",
    "duration": 7,
    "metadata": {
      "input": {
        "media": [ { "type": "reference_video", "url": "https://cdn.example.com/input.mp4" } ]
      }
    }
  }'

Durée intelligente

Avec la durée intelligente, le modèle choisit la longueur. Envoyez -1 dans metadata.parameters.duration ; un duration négatif de premier niveau est rejeté par la validation commune avec invalid_seconds.

curl https://api.routeapi.ai/v1/video/generations \
  -H "Authorization: Bearer $ROUTEAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan3.0-video",
    "prompt": "An orange cat walking on a rooftop, cinematic lighting",
    "resolution": "480P",
    "ratio": "16:9",
    "metadata": { "parameters": { "duration": -1 } }
  }'

Une tâche à durée intelligente réserve 30 secondes à la soumission et se règle sur la longueur réelle à la fin.

Interroger la tâche

curl https://api.routeapi.ai/v1/video/generations/task_FQvcRkHE9wjSWwyISDcrWCKoqCPNdkCx \
  -H "Authorization: Bearer $ROUTEAPI_KEY"

{
  "code": "success",
  "message": "",
  "data": {
    "id": 4512,
    "created_at": 1792412645,
    "updated_at": 1792412780,
    "task_id": "task_FQvcRkHE9wjSWwyISDcrWCKoqCPNdkCx",
    "platform": "17",
    "user_id": 1024,
    "group": "default",
    "channel_id": 18,
    "quota": 50000,
    "action": "textGenerate",
    "status": "SUCCESS",
    "progress": "100%",
    "fail_reason": "",
    "result_url": "https://dashscope-result.oss.example/video.mp4",
    "submit_time": 1792412645,
    "start_time": 1792412650,
    "finish_time": 1792412780,
    "properties": {
      "input": "",
      "origin_model_name": "wan3.0-video",
      "upstream_model_name": "wan3.0-video"
    },
    "data": {
      "request_id": "42a9c287-db7b-9edb-b613-xxxxxxxx",
      "output": {
        "task_id": "dd40fcb4-34f4-4292-a9e0-xxxxxxxx",
        "task_status": "SUCCEEDED",
        "video_url": "https://dashscope-result.oss.example/video.mp4",
        "orig_prompt": "An orange cat walking on a rooftop, cinematic lighting"
      },
      "usage": {
        "video_count": 1,
        "duration": 2,
        "input_video_duration": 0,
        "output_video_duration": 2,
        "fps": 30,
        "SR": 480,
        "ratio": "16:9"
      }
    }
  }
}

Les champs externes sont ceux de RouteAPI. Fiez-vous à data.status ; data.progress n’est pour Wan qu’un marqueur d’étape grossier (20% en file, 30% en génération, 100% terminé), pas un pourcentage du fournisseur. data.quota est le montant facturé jusqu’ici — après une tâche réussie, il reflète le montant réglé. data.action vaut generate lorsque la requête contenait un champ image de premier niveau (image, images ou input_reference), sinon textGenerate.

data.data est la charge utile de tâche de DashScope, stockée telle que renvoyée. Les champs utiles :

Champ	Signification
`data.data.output.task_id`	ID de tâche DashScope, différent du `data.task_id` externe
`data.data.output.video_url`	URL vidéo du fournisseur ; même valeur que le `data.result_url` externe
`data.data.output.orig_prompt`	Prompt reçu par DashScope
`data.data.usage.output_video_duration`	Secondes de sortie réelles — c’est la quantité facturée
`data.data.usage.input_video_duration`	Secondes de vidéo d’entrée ; gratuites. `0` pour le texte vers vidéo
`data.data.usage.duration`	Secondes d’entrée + sortie ; informatif uniquement, jamais utilisé au règlement
`data.data.usage.SR`	Palier de résolution de sortie effectif (480, 720, 1080) ; utilisé au règlement
`data.data.usage.fps`	Fréquence d’images de sortie, 30 pour ces modèles
`data.data.usage.ratio`	Ratio d’aspect réel. Avec `adaptive`, c’est le ratio de la source, par exemple `427:240`

data.data peut être incomplet tant que la tâche n’est pas terminée ; jugez l’achèvement par data.status, pas par la présence de usage.

Statuts : NOT_START et QUEUED signifient continuer à interroger, IN_PROGRESS génération en cours, SUCCESS téléchargement, FAILURE lire fail_reason — le montant réservé a déjà été remboursé.

Télécharger la vidéo

data.result_url pointe vers le fichier hébergé par Alibaba. Cette URL est temporaire — Alibaba la fait expirer selon son propre calendrier, téléchargez donc rapidement — ou diffusez via RouteAPI, qui ne dépend pas de sa durée de vie restante :

curl -L -o out.mp4 \
  https://api.routeapi.ai/v1/videos/task_FQvcRkHE9wjSWwyISDcrWCKoqCPNdkCx/content \
  -H "Authorization: Bearer $ROUTEAPI_KEY"

L’endpoint de contenu ne sert que les tâches terminées appartenant à l’appelant : une tâche non terminée renvoie 400 avec le statut courant dans le message, un task_id inconnu ou étranger renvoie 404, et un échec de récupération chez le fournisseur renvoie 502. Voir Obtenir une tâche pour la liste complète. Un result_url encore valide peut aussi être réutilisé directement comme reference_video ou reference_image de la requête suivante.

Mapping des statuts

Statut DashScope	Statut de l’enregistrement
`PENDING`	`QUEUED`
`RUNNING`	`IN_PROGRESS`
`SUCCEEDED`	`SUCCESS`
`FAILED`, `CANCELED`, `UNKNOWN`	`FAILURE`

Facturation

Wan 3.0 est facturé à la seconde de sortie, modulé par la résolution. Le prix de la console est le prix à la seconde pour 480P ; les autres paliers valent ce prix multiplié par le ratio de résolution du modèle, 1 : 2 : 4 pour 480P : 720P : 1080P par défaut.

La réservation et le débit final suivent la même forme :

base quota        = model price (per 480P second) × group ratio
reserved quota    = base quota × reserved seconds × resolution ratio
settled quota     = min(base quota × output seconds × effective ratio, reserved quota)

Le ratio effectif est celui du palier demandé ou, si DashScope rapporte un SR inférieur, celui du palier inférieur. Il n’est jamais relevé au-dessus du palier demandé.

Réservation et règlement :

Requête	Réservé à la soumission	À la fin
Durée explicite, sans `reference_video`	les secondes demandées	secondes de sortie réelles
Contient un élément `reference_video`	30 secondes	secondes de sortie réelles, différence remboursée
`metadata.parameters.duration: -1` (durée intelligente)	30 secondes	secondes de sortie réelles, différence remboursée

Règles de règlement vérifiées dans l’adaptateur :

Seul usage.output_video_duration est facturé. Les secondes de vidéo d’entrée, les images et audios de référence ainsi que les images de cadrage sont gratuits, et générer de l’audio ne change pas le prix.
Le prix unitaire est celui figé à la soumission. Un changement de prix dans la console pendant l’exécution n’affecte pas la tâche ; la réservation reste telle que facturée.
Le règlement ne fait que rembourser. Une tâche qui rapporte plus de secondes que réservé, un SR plus élevé ou un usage mal formé conserve la réservation au lieu de facturer davantage ; un usage absent sur une tâche réussie conserve aussi la réservation.
Une tâche en échec — rejet de modération, délai du fournisseur, annulation — rembourse la réservation. Un 400 est rejeté avant soumission et ne facture jamais.
Les requêtes qui réservent 30 secondes ont besoin d’un solde ou d’un quota de Key suffisant pour couvrir cette réservation, sinon la soumission est rejetée avec 403 insufficient_user_quota.

La réponse de soumission porte un en-tête X-New-Api-Other-Ratios avec les multiplicateurs appliqués, par exemple {"resolution-1080P":4,"seconds":5} pour une requête 1080P de 5 secondes. Pour une requête avec vidéo de référence ou durée intelligente, seconds vaut 30.

Exemple concret (prix hypothétiques ; utilisez la console pour les vrais). Supposons le modèle à 0,05 $ par seconde en 480P, donc 720P à 0,10 $ et 1080P à 0,20 $ avec la table 1 : 2 : 4 par défaut, et un ratio de groupe de 1 :

Requête 1080P, duration: 5. Réservé : 0,20 × 5 = 1,00 $.
DashScope rapporte usage.SR: 720 et output_video_duration: 5 : la sortie est un palier plus bas. Réglé : 0,10 × 5 = 0,50 $, et 0,50 $ sont remboursés.
S’il avait rapporté SR: 1080 pour 5 secondes, le débit serait resté à 1,00 $ — le règlement ne facture jamais au-delà de la réservation.

Second exemple : 480P avec une vidéo source de 2 secondes, duration: 2. Comme un reference_video est présent, la réservation est de 30 × 0,05 $ = 1,50 $ ; la sortie réelle fait 2 secondes, le débit se règle à 2 × 0,05 $ = 0,10 $ et 1,40 $ sont remboursés.

Limites et erreurs

Les erreurs de paramètres sont interceptées avant soumission : elles renvoient 400, ne sont pas envoyées en amont et ne coûtent rien.

Statut	Code	Signification
400	`invalid_request`	`prompt` absent ou vide (`prompt is required`) ; `audio_url` combiné à une première/dernière image (`wan3 does not support audio_url together with first/last frame images`) ; prompt et media vides ; champ `metadata` au mauvais type ; `metadata.model` différent du modèle résolu (`can't change model with metadata`)
400	`invalid_request`	Échecs de validation des paramètres — voir le tableau des messages ci-dessous
400	`invalid_json`	Le corps ne peut pas être analysé
400	`invalid_seconds`	`duration` / `seconds` de premier niveau négatif ou supérieur à 3600 (`seconds must be between 1 and 3600`)
400	`missing_model`	Aucun `model` dans le corps (`model field is required`)
400	`task_not_exist`	Le `task_id` est inconnu ou appartient à un autre compte
403	`insufficient_user_quota`	Le solde ou le quota de Key ne couvre pas la réservation ; rien n’est soumis
429	—	Capacité amont épuisée ; le message est remplacé par `Upstream load is saturated, please try again later`
500	`build_request_failed`, `do_request_failed`, `invalid_response`	Conversion échouée, amont injoignable, ou DashScope n’a renvoyé aucun ID de tâche
statut amont	`ali_api_error`	DashScope a renvoyé un code et un message d’erreur dans le corps
statut amont	`fail_to_fetch_task`	DashScope a rejeté la soumission ; le statut HTTP est celui de DashScope

Messages 400 courants de la validation Wan 3.0, exactement tels que renvoyés :

`message`	Cause
`invalid duration: 40, wan3 supports -1 or 2-30`	Durée hors 2–30 et différente de `-1`
`invalid resolution: 4KP, wan3 supports 480P, 720P, 1080P`	Résolution hors des paliers pris en charge (affichée après majuscules et ajout de `P`)
`invalid ratio: 1:2, wan3 supports adaptive, 21:9, 16:9, 4:3, 1:1, 3:4, 9:16`	Ratio hors de la liste prise en charge
`invalid seed: 3000000000, wan3 supports -1 or 0-2147483647`	Graine hors `-1` ou 0–2147483647
`invalid size: 1000*1000`	Une taille `LARGEUR*HAUTEUR` absente du tableau
`wan3 does not support audio_url together with first/last frame images`	Images de cadrage plus audio de référence via `input.audio_url`
`wan3 requires prompt or input.media`	Ni prompt ni media après la fusion de metadata
`can't change model with metadata`	`metadata.model` diffère du modèle amont résolu
`convert seconds to int failed: ...`	`seconds` n’est pas une chaîne entière
`seconds must be between 1 and 3600`	Durée de premier niveau négative ou trop grande ; utilisez `metadata.parameters.duration` pour `-1`

Les échecs après soumission — modération, matériel non téléchargeable, combinaison de matériel invalide, entrée + sortie de plus de 30 secondes — ne remontent pas en erreur HTTP. Ils apparaissent sur l’enregistrement en FAILURE avec un fail_reason, et le montant réservé est remboursé.

Différences avec l’API DashScope

L’endpoint diffère. RouteAPI n’expose pas /api/v1/services/aigc/video-generation/video-synthesis ; pointer le SDK DashScope vers notre URL de base ne fonctionne pas.
Les objets natifs input / parameters de DashScope vont sous metadata.input / metadata.parameters. Les paramètres communs (prompt, resolution, ratio, size, duration, images, generate_audio) peuvent aussi être envoyés à la racine et sont mappés automatiquement.
Le task_id renvoyé est celui de RouteAPI, pas celui de DashScope. Celui de DashScope se trouve dans data.data.output.task_id.
La réécriture de prompt (prompt_extend) est toujours active et ne peut pas être désactivée.
Les anciens champs image par modèle (img_url, first_frame_url, last_frame_url, audio_url) sont supprimés ; seul input.media atteint le fournisseur.
La notification par callback n’est pas prise en charge — interrogez l’endpoint de tâche.
La facturation se fait à la seconde de sortie avec le ratio de résolution ; la facturation par requête ou par palier du fournisseur ne s’applique pas.

Script complet

Nécessite bash, curl et jq.

#!/usr/bin/env bash
set -euo pipefail
: "${ROUTEAPI_KEY:?set ROUTEAPI_KEY first}"
BASE="${ROUTEAPI_BASE:-https://api.routeapi.ai}"
AUTH="Authorization: Bearer $ROUTEAPI_KEY"

TASK_ID=$(curl -sS -X POST "$BASE/v1/video/generations" \
  -H "$AUTH" -H "Content-Type: application/json" \
  -d '{"model":"wan3.0-video","prompt":"An orange cat walking on a rooftop, cinematic lighting","resolution":"480P","ratio":"16:9","duration":2}' \
  | jq -er .task_id)

echo "task: $TASK_ID"

for _ in $(seq 1 60); do
  RESP=$(curl -sS "$BASE/v1/video/generations/$TASK_ID" -H "$AUTH")
  STATUS=$(printf '%s' "$RESP" | jq -r .data.status)
  echo "status: $STATUS $(printf '%s' "$RESP" | jq -r .data.progress)"

  case "$STATUS" in
    SUCCESS)
      echo "billed seconds: $(printf '%s' "$RESP" | jq -r .data.data.usage.output_video_duration)"
      curl -sSL -o "$TASK_ID.mp4" "$BASE/v1/videos/$TASK_ID/content" -H "$AUTH"
      echo "saved $TASK_ID.mp4"
      exit 0
      ;;
    FAILURE)
      echo "failed: $(printf '%s' "$RESP" | jq -r .data.fail_reason)"
      exit 1
      ;;
  esac

  sleep 15
done

echo "timed out waiting for the task"
exit 1