API Wan 2.7 VideoEdit sur Novita AI : Comment éditer des vidéos avec l'IA

Wan 2.7 VideoEdit sur Novita AI est le bon point de terminaison lorsque vous avez déjà des images et souhaitez que le modèle restyle ou réécrive la scène sans reconstruire le mouvement à partir de zéro. Vous soumettez une vidéo source à POST https://api.novita.ai/v3/async/wan2.7-videoedit, obtenez un task_id, puis interrogez GET /v3/async/task-result jusqu’à ce que le clip édité soit prêt. Ce guide montre la forme exacte de la requête, quand ajouter des images de référence, et les détails d’implémentation qui comptent avant de l’intégrer en production.

Quand Wan 2.7 VideoEdit est le bon outil

Utilisez Wan 2.7 VideoEdit lorsque le timing et le mouvement de la caméra dans votre clip source sont déjà suffisamment bons, et que vous souhaitez que l’IA modifie ce que le spectateur voit plutôt que la manière dont le plan est cadré.

Cas typiques :

• Vous avez un clip en prise de vue réelle et souhaitez le convertir en un rendu anime, cinématographique ou stylisé.
• Vous devez changer la garde-robe, l’environnement, les accessoires ou l’atmosphère tout en préservant l’arc de mouvement original.
• Vous souhaitez appliquer une transformation guidée par une invite à des images et éventuellement ancrer l’apparence avec une image de référence.

Ce n’est pas le bon point de terminaison lorsque :

• Vous avez besoin d’un mouvement entièrement nouveau à partir du seul texte. Utilisez plutôt Wan 2.7 T2V.
• Vous souhaitez animer une image fixe. Utilisez plutôt Wan 2.7 I2V.
• Vous avez besoin d’un jeu de rôle multi-personnage avec des emplacements de référence nommés dans une scène générée. Utilisez plutôt Wan 2.7 R2V.

Cette distinction est importante car VideoEdit part d’un clip d’entrée. Si le mouvement original est mauvais, le modèle ne corrigera pas la chorégraphie pour vous.

Point de terminaison et flux de travail vérifiés

Wan 2.7 VideoEdit sur Novita AI utilise un point de terminaison de soumission et le point de terminaison de résultat de tâche asynchrone partagé :

Champ	Valeur
Point de terminaison de soumission	POST https://api.novita.ai/v3/async/wan2.7-videoedit
Interrogation du résultat	GET https://api.novita.ai/v3/async/task-result?task_id=<id>
En-tête d’autorisation	Authorization: Bearer $NOVITA_API_KEY
Type de contenu	application/json
Documentation officielle	Référence API Wan 2.7 VideoEdit

L’API est asynchrone. Un appel de soumission réussi renvoie un task_id, pas l’URL de la vidéo terminée. Votre application doit conserver cet ID de tâche et construire une logique d’interrogation ou de tâche en arrière-plan autour de celui-ci.

Étape 1 : Obtenir une clé API Novita AI

Créez une clé depuis la gestion des clés Novita AI et conservez-la dans une variable d’environnement :

export NOVITA_API_KEY="votre_cle_api_ici"

Ne codez pas en dur la clé dans le code du navigateur, les applications mobiles ou les fichiers de configuration versionnés.

Étape 2 : Comprendre la forme de la requête

Wan 2.7 VideoEdit utilise un corps JSON plat. La requête n’imbrique pas les champs sous input ou parameters.

Au minimum, envoyez :

• video_url
• prompt

Les champs optionnels documentés dont vous vous soucierez généralement en premier sont :

• reference_image_url pour une référence d’apparence/style
• resolution
• duration
• audio_setting
• prompt_extend
• seed

Étape 3 : Soumettre votre première requête VideoEdit

Voici la requête la plus petite possible :

curl -s -X POST https://api.novita.ai/v3/async/wan2.7-videoedit \
  -H "Authorization: Bearer $NOVITA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "video_url": "https://example.com/source-clip.mp4",
    "prompt": "Transformez cette scène de couloir de bureau en un corridor cyberpunk néon, conservez le mouvement de marche et le chemin de la caméra",
    "resolution": "720P",
    "duration": 5
  }'

Réponse attendue :

{
  "task_id": "abc123..."
}

Rien d’autre n’est garanti au moment de la soumission. Considérez la requête comme une étape de mise en file d’attente de tâche, pas comme une réponse d’édition synchrone.

Étape 4 : Interroger le point de terminaison de résultat de tâche

Utilisez le task_id retourné avec l’API de résultat de tâche partagée :

curl -s "https://api.novita.ai/v3/async/task-result?task_id=abc123..." \
  -H "Authorization: Bearer $NOVITA_API_KEY"

Construisez autour de ces états :

Statut	Signification
TASK_STATUS_QUEUED	Accepté et en attente d’exécution
TASK_STATUS_PROCESSING	L’édition est en cours
TASK_STATUS_SUCCEED	La vidéo éditée est prête
TASK_STATUS_FAILED	La tâche a échoué ; inspectez le corps de la réponse

Lorsque la tâche réussit, la réponse inclut un tableau videos avec l’URL de sortie éditée et le TTL de l’URL. Téléchargez ou déplacez cet actif rapidement plutôt que de traiter l’URL hébergée comme un stockage permanent.

Étape 5 : Ajouter une image de référence lorsque vous avez besoin d’un contrôle visuel plus précis

reference_image_url est facultatif, mais il modifie le comportement d’édition de manière utile.

Utilisez-le lorsque :

• Vous souhaitez que le clip final suive un look, un costume ou une palette de personnage particulier.
• Vous souhaitez orienter la sortie vers une direction artistique spécifique au lieu de tout laisser à l’invite textuelle.
• Le mouvement de la vidéo source est correct, mais l’identité de la scène est trop vague avec un guidage uniquement textuel.

Exemple de requête avec une image de référence :

curl -s -X POST https://api.novita.ai/v3/async/wan2.7-videoedit \
  -H "Authorization: Bearer $NOVITA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "video_url": "https://example.com/source-clip.mp4",
    "reference_image_url": "https://example.com/reference-look.png",
    "prompt": "Transformez l interprète selon le look et la palette de couleurs de l image de référence tout en conservant le même timing de danse",
    "resolution": "1080P",
    "duration": 6,
    "audio_setting": "auto"
  }'

Si votre résultat continue de dériver, la solution habituelle n’est pas une invite plus longue. C’est une invite plus précise plus une meilleure image de référence.

Paramètres clés auxquels vous devriez vraiment prêter attention

Paramètre	Type	Requis	Ce qu’il fait
video_url	chaîne	Oui	Vidéo source à éditer
prompt	chaîne	Oui	Décrit la transformation cible
reference_image_url	chaîne	Non	Image de référence pour l’ancrage du look et du style
resolution	chaîne	Non	Résolution de sortie, les valeurs documentées incluent 720P et 1080P
duration	entier	Non	Durée cible de la sortie en secondes ; 0 conserve la durée intégrale de la vidéo d’entrée
audio_setting	chaîne	Non	Contrôle le comportement de génération audio
prompt_extend	booléen	Non	Permet au modèle d’étendre automatiquement les invites courtes
seed	entier	Non	Améliore la reproductibilité entre les tentatives

Consultez la référence officielle des paramètres avant de supposer les valeurs par défaut. Les champs des modèles vidéo changent plus souvent que ceux des modèles de texte, et il est facile de se tromper sur les contraintes de sortie si l’on se fie à la mémoire.

Limites documentées et contraintes pratiques

Au 29 juillet 2026, la documentation officielle de Novita pour Wan 2.7 VideoEdit indique ces limites :

• Résolutions prises en charge : 720P et 1080P
• duration par défaut à 0, ce qui signifie la longueur intégrale de la vidéo d’entrée ; la plage de durée de sortie explicite documentée est de 2 à 10 secondes lorsque vous la définissez
• Formats vidéo d’entrée : mp4 et mov
• Limite de taille vidéo d’entrée : jusqu’à 100 Mo
• Formats d’image de référence : jpg, jpeg, png, webp
• Limite de taille d’image de référence : jusqu’à 20 Mo
• Format vidéo de sortie : mp4

Ces contraintes sont faciles à manquer lorsque vous construisez un pipeline média générique. L’échec d’intégration le plus courant est d’envoyer un fichier source plus long ou plus volumineux que ce que le point de terminaison accepte.

Deux implications pratiques :

1. Si vous souhaitez que le clip édité conserve la longueur de la source, omettez duration ou définissez-le sur 0 plutôt que de forcer un recadrage de 2 à 10 secondes.
2. Si vous testez rapidement des invites, utilisez d’abord 720P et passez à 1080P uniquement lorsque la transformation fonctionne.

Exemple Python : Soumettre et interroger

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_edit(
    video_url: str,
    prompt: str,
    reference_image_url: str | None = None,
    resolution: str = "720P",
    duration: int = 0,
    audio_setting: str = "auto",
    prompt_extend: bool = True,
    seed: int | None = None,
) -> str:
    payload = {
        "video_url": video_url,
        "prompt": prompt,
        "resolution": resolution,
        "duration": duration,
        "audio_setting": audio_setting,
        "prompt_extend": prompt_extend,
    }
    if reference_image_url:
        payload["reference_image_url"] = reference_image_url
    if seed is not None:
        payload["seed"] = seed

    resp = requests.post(
        f"{BASE_URL}/v3/async/wan2.7-videoedit",
        headers=HEADERS,
        json=payload,
        timeout=60,
    )
    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},
            timeout=60,
        )
        resp.raise_for_status()
        data = resp.json()
        status = data.get("task", {}).get("status")

        if status == "TASK_STATUS_SUCCEED":
            return data
        if status == "TASK_STATUS_FAILED":
            reason = data.get("task", {}).get("reason", "unknown")
            raise RuntimeError(f"La tâche {task_id} a échoué : {reason}")

        time.sleep(interval)

    raise TimeoutError(f"La tâche {task_id} ne s'est pas terminée dans les {timeout}s")


if __name__ == "__main__":
    task_id = submit_video_edit(
        video_url="https://example.com/source-clip.mp4",
        prompt="Changez la scène de rue en une ville rétro-futuriste pluvieuse la nuit, conservez le plan de suivi original",
        reference_image_url="https://example.com/reference-frame.png",
        resolution="720P",
        duration=0,
        seed=42,
    )
    print(f"Tâche soumise : {task_id}")

    result = poll_result(task_id)
    video = result["videos"][0]
    print("URL de la vidéo éditée :", video["video_url"])
    print("TTL de l'URL :", video["video_url_ttl"])

Exemple cURL avec interrogation en shell

TASK_ID=$(curl -s -X POST https://api.novita.ai/v3/async/wan2.7-videoedit \
  -H "Authorization: Bearer $NOVITA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "video_url": "https://example.com/source-clip.mp4",
    "prompt": "Convertissez le clip en une scène de ville anime dessinée à la main, conservez le mouvement de course",
    "resolution": "720P",
    "duration": 0,
    "prompt_extend": true
  }' | jq -r '.task_id')

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
  fi

  if [ "$STATUS" = "TASK_STATUS_FAILED" ]; then
    echo "$RESULT"
    break
  fi

  sleep 5
done

Si vous intégrez depuis un service backend, encapsulez cette boucle d’interrogation dans un worker plutôt que de maintenir une requête utilisateur ouverte pendant toute la fenêtre de génération.

Tarification, crédits et ce qu’il faut vérifier avant d’estimer les coûts

Novita AI expose les tarifs des modèles vidéo sur ses pages de modèles et de tarification, mais ces chiffres peuvent changer. Pour Wan 2.7 VideoEdit, vérifiez les tarifs actuels directement depuis la page de tarification Novita AI et l’entrée du modèle liée depuis la documentation officielle avant de publier des estimations de coûts destinées aux clients.

Pour la planification technique, l’hypothèse la plus sûre est :

• Le coût évolue en fonction des paramètres du clip généré, pas seulement avec des frais de demande forfaitaires.
• Les exécutions en 1080P sont la mauvaise base de référence pour l’itération.
• Les clips plus courts sont plus faciles à valider et moins chers à déboguer.

Si vous construisez des outils internes, traitez la consultation des tarifs comme une préoccupation de configuration, pas comme une constante codée dans le code.

Erreurs d’intégration courantes

Envoyer des téléchargements bruts au lieu d’une URL accessible. La forme de requête documentée attend des entrées média basées sur des URL. Assurez-vous que votre clip source est déjà disponible à une URL stable que votre serveur peut référencer.

Utiliser VideoEdit pour les changements de mouvement. VideoEdit est un point de terminaison de transformation, pas un point de terminaison de chorégraphie. Si le mouvement original est mauvais, régénérez avec T2V ou I2V.

Confondre les limites de la vidéo source et de l’image de référence. La vidéo source est l’actif le plus volumineux : mp4/mov, jusqu’à 100 Mo. La limite plus petite de 20 Mo s’applique à reference_image_url, pas à video_url.

Interroger de manière trop agressive. Frapper le point de terminaison de résultat de tâche chaque seconde est inutile pour des tâches vidéo de plusieurs secondes. Un intervalle de 5 à 10 secondes est généralement un meilleur point de départ.

Ignorer le TTL de l’URL. L’URL de résultat est temporaire. Persistez l’actif rapidement si le clip édité est important en aval.

Omettre la spécificité de l’invite. “Fais-le mieux” n’est pas une invite d’édition. Décrivez le style cible, l’environnement, le traitement du sujet et quel mouvement doit rester inchangé.

Quel point de terminaison Wan 2.7 devriez-vous choisir ?

Utilisez cette règle rapide :

• Choisissez VideoEdit lorsque vous avez déjà une vidéo source.
• Choisissez I2V lorsque vous avez une image source ou souhaitez une continuation à partir d’un flux de travail basé sur une image fixe.
• Choisissez T2V lorsque vous n’avez que du texte.
• Choisissez R2V lorsque la cohérence d’identité et le contrôle des personnages de référence sont plus importants que l’édition d’un clip existant.

Cette séparation est ce qui maintient votre intégration simple. Les équipes utilisent souvent trop la text-to-video pour des tâches qui sont en réalité des problèmes d’édition basée sur des invites.

FAQ

Quel est le point de terminaison Novita AI pour Wan 2.7 VideoEdit ?

POST https://api.novita.ai/v3/async/wan2.7-videoedit. Il renvoie un task_id, puis vous interrogez GET https://api.novita.ai/v3/async/task-result?task_id=<id> pour l’achèvement.

Puis-je fournir une image de référence avec la vidéo source ?

Oui. La forme de requête documentée prend en charge un reference_image_url facultatif aux côtés de video_url et prompt, ce qui est utile pour orienter plus précisément le rendu final.

Quelle longueur de vidéo Wan 2.7 VideoEdit prend-il en charge sur Novita AI ?

Comme documenté le 29 juillet 2026, duration par défaut à 0, ce qui signifie la longueur intégrale de la vidéo d’entrée. Si vous définissez explicitement duration, la plage documentée est de 2 à 10 secondes.

Wan 2.7 VideoEdit accepte-t-il de grandes vidéos sources ?

Oui, dans la limite documentée. La documentation officielle répertorie une entrée mp4/mov jusqu’à 100 Mo. La limite distincte de 20 Mo s’applique à l’image de référence facultative.

Dois-je utiliser Wan 2.7 VideoEdit ou Wan 2.7 I2V ?

Utilisez VideoEdit si vous avez déjà un clip et souhaitez le transformer. Utilisez I2V si votre point de départ est une image fixe ou un flux de travail basé sur une image.

Articles recommandés

• Wan 2.7 sur Novita AI : Text-to-Video vs Image-to-Video vs Reference-to-Video
• Kling O1 sur Novita AI : Modes T2V, I2V, Ref2V et Video Edit
• Guide de démarrage rapide PixVerse V4.5 pour la génération Text-to-Video et Image-to-Video