API Wan 2.7 VideoEdit sur Novita AI : modifier des clips existants avec des invites et des images de référence

Wan 2.7 VideoEdit sur Novita AI est le bon endpoint lorsque vous disposez déjà d’une séquence et souhaitez que le modèle restyle ou réécrive la scène sans reconstruire le mouvement de zéro. Vous soumettez une vidéo source à POST https://api.novita.ai/v3/async/wan2.7-videoedit, vous recevez un task_id, puis vous 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.

Pour une comparaison plus complète des modes, consultez Wan 2.7 sur Novita AI : Text-to-Video vs Image-to-Video vs Reference-to-Video.

Quand Wan 2.7 VideoEdit est le bon outil

Utilisez Wan 2.7 VideoEdit lorsque le timing et les mouvements de caméra de votre clip source sont déjà suffisamment bons et que vous souhaitez que l’IA change ce que le spectateur voit plutôt que la façon dont le plan est construit.

Cas d’usage typiques :

• Vous avez un clip en prise de vue réelle et vous souhaitez le convertir en rendu anime, cinématique ou stylisé.
• Vous devez changer les vêtements, l’environnement, les accessoires ou l’atmosphère tout en préservant l’arc de mouvement d’origine.
• Vous souhaitez appliquer une transformation guidée par prompt à une séquence et, éventuellement, ancrer le rendu avec une image de référence.

Ce n’est pas le bon endpoint lorsque :

• Vous avez besoin d’un mouvement entièrement nouveau à partir du texte seul. 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-personnages 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 d’origine est incorrect, le modèle ne corrigera pas la chorégraphie pour vous.

Endpoint et flux de travail vérifiés

Wan 2.7 VideoEdit sur Novita AI utilise un endpoint de soumission et l’endpoint partagé de résultat de tâche asynchrone :

Champ	Valeur
Endpoint 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’authentification	Authorization: Bearer $NOVITA_API_KEY
Type de contenu	application/json
Documentation officielle	Wan 2.7 VideoEdit API reference

L’API est asynchrone. Un appel de soumission réussi renvoie un task_id, et non l’URL de la vidéo finale. Votre application doit conserver cet identifiant de tâche et construire une logique d’interrogation ou de tâche de fond autour de lui.

É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="your_api_key_here"

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

Étape 2 : Comprendre la structure 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 facultatifs documentés auxquels vous penserez généralement en premier sont :

• reference_image_url pour une référence de style/rendu
• resolution
• duration
• audio_setting
• prompt_extend
• seed

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

Voici la requête minimale fonctionnelle :

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": "Turn this office hallway scene into a neon cyberpunk corridor, preserve the walking motion and camera path",
    "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, et non comme une réponse d’édition synchrone.

Étape 4 : Interroger l’endpoint de résultat de tâche

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

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

Structurez votre logique autour de ces états :

Statut	Signification
TASK_STATUS_QUEUED	Acceptée 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 asset rapidement au lieu de considérer 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 particuliers.
• Vous souhaitez orienter la sortie vers une direction artistique précise au lieu de tout laisser au prompt textuel.
• Le mouvement de la vidéo source est correct, mais l’identité de la scène est trop floue avec une simple consigne textuelle.

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": "Transform the performer into the look and color palette of the reference image while keeping the same dance timing",
    "resolution": "1080P",
    "duration": 6,
    "audio_setting": "auto"
  }'

Si votre résultat continue de dériver, la solution habituelle n’est pas un prompt plus long. C’est un prompt plus précis associé à une meilleure image de référence.

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

Paramètre	Type	Requis	Description
video_url	string	Oui	Vidéo source à éditer
prompt	string	Oui	Décrit la transformation cible
reference_image_url	string	Non	Image de référence pour ancrer le style et le rendu
resolution	string	Non	Résolution de sortie, les valeurs documentées incluent 720P et 1080P
duration	integer	Non	Longueur cible de la sortie en secondes ; 0 conserve toute la longueur de la vidéo d’entrée
audio_setting	string	Non	Contrôle le comportement de génération audio
prompt_extend	boolean	Non	Permet au modèle d’étendre automatiquement les prompts courts
seed	integer	Non	Améliore la reproductibilité entre les tentatives

Consultez la référence des paramètres officielle avant de supposer les valeurs par défaut. Les champs des modèles vidéo changent plus souvent que ceux des modèles texte, et les contraintes de sortie sont faciles à mal évaluer si vous vous fiez à votre mémoire.

Limites documentées et contraintes pratiques

En date du 29 juillet 2026, la documentation officielle de Novita pour Wan 2.7 VideoEdit documente ces limites :

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

Ces contraintes sont faciles à oublier lorsque vous construisez un pipeline média générique. L’échec d’intégration le plus courant est l’envoi d’un fichier source plus long ou plus volumineux que ce que l’endpoint accepte.

Deux implications pratiques :

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

Exemple Python : soumission et interrogation

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"Task {task_id} failed: {reason}")

        time.sleep(interval)

    raise TimeoutError(f"Task {task_id} did not complete within {timeout}s")


if __name__ == "__main__":
    task_id = submit_video_edit(
        video_url="https://example.com/source-clip.mp4",
        prompt="Change the street scene into a rainy retro-futurist city at night, preserve the original tracking shot",
        reference_image_url="https://example.com/reference-frame.png",
        resolution="720P",
        duration=0,
        seed=42,
    )
    print(f"Submitted task: {task_id}")

    result = poll_result(task_id)
    video = result["videos"][0]
    print("Edited video URL:", video["video_url"])
    print("URL TTL:", 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": "Convert the clip into a hand-drawn anime city scene, preserve the running motion",
    "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 ouverte une requête utilisateur pendant toute la fenêtre de génération.

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

Novita AI affiche les tarifs des modèles vidéo sur ses pages de modèles et de tarifs, mais ces chiffres peuvent changer. Pour Wan 2.7 VideoEdit, vérifiez les tarifs actuels directement sur la page de tarifs Novita AI et sur 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 varie en fonction des réglages du clip généré, et pas seulement selon un tarif fixe par requête.
• Les exécutions en 1080P ne sont pas une bonne base pour itérer.
• Les clips plus courts sont plus faciles à valider et moins coûteux à déboguer.

Si vous construisez des outils internes, traitez la consultation des tarifs comme un élément de configuration, pas comme une constante codée en dur.

Erreurs d’intégration courantes

Envoyer des téléversements 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 modifier le mouvement. VideoEdit est un endpoint de transformation, pas un endpoint de chorégraphie. Si le mouvement d’origine est incorrect, 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’asset le plus volumineux : mp4/mov, jusqu’à 100 Mo. La limite plus petite de 20 Mo s’applique à reference_image_url, pas à video_url.

Interroger trop agressivement. Solliciter l’endpoint 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’asset rapidement si le clip édité compte pour la suite.

Négliger la spécificité du prompt. « Améliore-le » n’est pas un prompt d’édition. Décrivez le style cible, l’environnement, le traitement du sujet et le mouvement qui doit rester inchangé.

Quel endpoint Wan 2.7 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 piloté par 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 comptent plus que l’édition d’un clip existant.

Cette séparation est ce qui garde 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 guidés par prompt.

Si vous mettez en place une orchestration autour de cet endpoint, comparez Macaron V1 Tall Quick Start sur Novita AI et Qwen3.8-Max sur Novita AI pour des modèles à plus fort poids.

FAQ

Quel est l’endpoint 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 connaître la fin de la tâche.

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

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

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

Comme documenté le 29 juillet 2026, duration est défini par défaut sur 0, ce qui correspond à toute la longueur 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 les vidéos sources volumineuses ?

Oui, dans la limite documentée. La documentation officielle liste 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 piloté par 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 édition vidéo
• Démarrage rapide avec PixVerse V4.5 pour la génération text-to-video et image-to-video