Démarrage rapide PixVerse V4.5 pour la génération texte-vers-vidéo et image-vers-vidéo

PixVerse V4.5 est disponible sur Novita AI via deux points d’accès asynchrones : POST https://api.novita.ai/v3/async/pixverse-v4.5-t2v pour le texte-vers-vidéo (T2V) et POST https://api.novita.ai/v3/async/pixverse-v4.5-i2v pour l’image-vers-vidéo (I2V). Les deux suivent le même modèle asynchrone en deux étapes — soumettez une requête de génération, recevez un task_id, puis interrogez GET /v3/async/task-result jusqu’à ce que le statut soit TASK_STATUS_SUCCEED et que l’URL de la vidéo soit disponible. Ce guide vous emmène de zéro à une URL vidéo fonctionnelle pour chaque mode.

Quand utiliser ce guide de démarrage rapide

Utilisez ce guide lorsque vous avez besoin d’une requête fonctionnelle vérifiée avant d’écrire la logique de production autour de PixVerse V4.5.

Le T2V est la bonne option lorsque votre entrée est entièrement textuelle — une description de scène, une légende de storyboard ou un prompt produit. L’I2V est destiné aux cas où vous avez une image de référence et souhaitez que PixVerse l’anime à partir de cette image.

À savoir avant de commencer :

• Les clips durent au maximum 5 secondes en 1080p, ou 8 secondes en 720p et en dessous.
• fast_mode: true accélère la génération et réduit les coûts, mais limite la résolution à 720p.
• Le paramètre de style prédéfini (anime, 3d_animation, clay, comic, cyberpunk) est documenté comme étant réservé à la v3.5 — testez-le avec la V4.5 avant de l’utiliser en production.
• Les images d’entrée I2V doivent être aux formats jpg, jpeg ou png ; taille maximale de 10 Mo ; dimensions minimales de 300×300 px ; et un rapport hauteur/largeur compris entre 1:2,5 et 2,5:1.

Ce guide ne couvre pas l’interface web PixVerse, l’hébergement personnel ou le fine-tuning. Il ne couvre que le chemin de l’API hébergée par Novita AI.

Étape 1 : Obtenez votre clé API Novita

Créez un compte Novita AI et accédez à la gestion des clés API. Générez une clé et exportez-la dans votre environnement :

export NOVITA_API_KEY="your_api_key_here"

Gardez la clé hors du contrôle de version, des bundles côté client et des couches d’image Docker.

Étape 2 : Confirmer les points d’accès

	T2V	I2V
Point d’accès de soumission	POST https://api.novita.ai/v3/async/pixverse-v4.5-t2v	POST https://api.novita.ai/v3/async/pixverse-v4.5-i2v
Point d’accès de résultat	GET https://api.novita.ai/v3/async/task-result?task_id=<id>	GET https://api.novita.ai/v3/async/task-result?task_id=<id>
Référence API	T2V docs	I2V docs

Le point d’accès de résultat est partagé entre toutes les API asynchrones de Novita AI. Une fois que vous comprenez la boucle d’interrogation, elle fonctionne de la même manière pour chaque modèle.

Étape 3 : Envoyer votre première requête T2V

Soumettez une génération avec un prompt et votre rapport hauteur/largeur préféré. Les valeurs par défaut (aspect_ratio: "16:9", resolution: "540p", fast_mode: false) constituent un bon point de départ :

curl -s -X POST https://api.novita.ai/v3/async/pixverse-v4.5-t2v \
  -H "Authorization: Bearer $NOVITA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "A time-lapse of cherry blossoms falling in slow motion, soft morning light, cinematic 4K",
    "aspect_ratio": "16:9",
    "resolution": "720p"
  }'

Une réponse 200 réussie renvoie uniquement :

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

Enregistrez le task_id. Rien d’autre n’est renvoyé à ce stade — la génération de la vidéo s’exécute de manière asynchrone.

Étape 4 : Envoyer votre première requête I2V

L’I2V prend une image de départ et l’anime selon votre prompt. Le champ image_file attend une chaîne encodée en base64 de l’image source :

# Encode your image first
IMAGE_B64=$(base64 -w 0 /path/to/your/image.jpg)

curl -s -X POST https://api.novita.ai/v3/async/pixverse-v4.5-i2v \
  -H "Authorization: Bearer $NOVITA_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{
    \"prompt\": \"Camera slowly pushes forward, light wind moves through the scene\",
    \"image_file\": \"$IMAGE_B64\",
    \"resolution\": \"720p\"
  }"

La réponse a la même forme que pour le T2V :

{
  "task_id": "xyz789..."
}

Contraintes clés de l’image à vérifier avant l’envoi :

• Format : uniquement jpg, jpeg ou png
• Taille du fichier : max 10 Mo (vérifier avant encodage — le base64 augmente la taille d’environ 33 %)
• Dimensions minimales : 300×300 px
• Rapport hauteur/largeur : entre 1:2,5 et 2,5:1 (extrêmes portrait à paysage)

Étape 5 : Interroger pour obtenir les résultats

Interrogez le point d’accès task-result avec le task_id renvoyé par l’étape de soumission :

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

Le champ task.status parcourt ces états :

Statut	Signification
TASK_STATUS_QUEUED	La tâche est en attente dans la file
TASK_STATUS_PROCESSING	La génération est en cours
TASK_STATUS_SUCCEED	La vidéo est prête ; l’URL est dans la réponse
TASK_STATUS_FAILED	La génération a échoué ; vérifiez task.reason

Interrogez toutes les 5 à 10 secondes. Lorsque TASK_STATUS_SUCCEED apparaît, l’URL de la vidéo se trouvera dans le corps de la réponse. Le champ task.eta fournit un temps estimé de finalisation en secondes, que vous pouvez utiliser pour planifier votre première interrogation.

Étape 6 : Vérifier les tarifs et les limites

Le tarif publié par Novita AI pour PixVerse V4.5 est de 0,70 $ par clip de 5 secondes (vérifié sur les pages produit PixVerse de Novita AI en juillet 2026). Vérifiez le tarif actuel sur la page de tarification de Novita AI avant d’établir une estimation des coûts.

fast_mode: true génère des vidéos plus rapidement et à moindre coût, mais la résolution est limitée à 720p. C’est utile pour le prototypage ou la génération d’aperçus par lots lorsque la qualité est secondaire.

Les limites de débit varient selon le niveau du compte. Consultez la documentation sur les limites de débit de Novita AI pour connaître les seuils actuels par niveau.

Paramètres clés

Paramètres T2V

Paramètre	Type	Défaut	Remarques
prompt	string	—	Obligatoire. Max 2048 caractères.
aspect_ratio	string	16:9	16:9, 4:3, 1:1, 3:4, 9:16
resolution	string	540p	360p, 540p, 720p, 1080p. 1080p nécessite fast_mode: false.
negative_prompt	string	—	Max 2048 caractères. Décrivez ce qu’il faut éviter.
fast_mode	boolean	false	Plus rapide et moins cher ; limite à 720p.
style	string	—	anime, 3d_animation, clay, comic, cyberpunk. Étiqueté réservé à la v3.5 — testez avant utilisation en production.
seed	integer	—	Défini pour la reproductibilité ; les sorties peuvent encore varier après les mises à jour du modèle.

Paramètres I2V

Paramètre	Type	Défaut	Remarques
prompt	string	—	Obligatoire. Max 2048 caractères.
image_file	string	—	Obligatoire. jpg/jpeg/png encodé en base64. Max 10 Mo, min 300×300 px, rapport hauteur/largeur 1:2,5 à 2,5:1.
resolution	string	540p	Mêmes options que pour T2V.
negative_prompt	string	—	Max 2048 caractères.
fast_mode	boolean	false	Identique à T2V.
style	string	—	Identique à T2V.
seed	integer	—	Identique à T2V.

Note : I2V n’accepte pas de paramètre aspect_ratio — le rapport hauteur/largeur de sortie est dérivé de l’image d’entrée.

Exemple Python — Workflow asynchrone complet

Cet exemple couvre la soumission T2V et I2V ainsi que la boucle d’interrogation dans un seul script :

import os
import time
import base64
import requests

API_KEY = os.environ["NOVITA_API_KEY"]
BASE_URL = "https://api.novita.ai/v3/async"

HEADERS = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}


def submit_t2v(prompt: str, aspect_ratio: str = "16:9", resolution: str = "720p") -> str:
    resp = requests.post(
        f"{BASE_URL}/pixverse-v4.5-t2v",
        headers=HEADERS,
        json={
            "prompt": prompt,
            "aspect_ratio": aspect_ratio,
            "resolution": resolution,
        },
    )
    resp.raise_for_status()
    return resp.json()["task_id"]


def submit_i2v(prompt: str, image_path: str, resolution: str = "720p") -> str:
    with open(image_path, "rb") as f:
        image_b64 = base64.b64encode(f.read()).decode("utf-8")
    resp = requests.post(
        f"{BASE_URL}/pixverse-v4.5-i2v",
        headers=HEADERS,
        json={
            "prompt": prompt,
            "image_file": image_b64,
            "resolution": resolution,
        },
    )
    resp.raise_for_status()
    return resp.json()["task_id"]


def poll_result(task_id: str, interval: int = 8, timeout: int = 300) -> dict:
    deadline = time.time() + timeout
    while time.time() < deadline:
        resp = requests.get(
            f"{BASE_URL}/task-result",
            headers=HEADERS,
            params={"task_id": task_id},
        )
        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__":
    # Text-to-video
    t2v_task = submit_t2v(
        prompt="A lone lighthouse on a rocky coast at dusk, waves crashing, golden sky",
        aspect_ratio="16:9",
        resolution="720p",
    )
    print(f"T2V task submitted: {t2v_task}")
    t2v_result = poll_result(t2v_task)
    print("T2V result:", t2v_result)

    # Image-to-video — replace with a real image path
    # i2v_task = submit_i2v(
    #     prompt="Gentle wind moves through the scene, slow camera pull-back",
    #     image_path="./reference.jpg",
    #     resolution="720p",
    # )
    # print(f"I2V task submitted: {i2v_task}")
    # i2v_result = poll_result(i2v_task)
    # print("I2V result:", i2v_result)

Exemples cURL

T2V avec mode rapide :

curl -s -X POST https://api.novita.ai/v3/async/pixverse-v4.5-t2v \
  -H "Authorization: Bearer $NOVITA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "A hyperrealistic ocean wave cresting and breaking on shore, slow motion, golden hour",
    "aspect_ratio": "9:16",
    "resolution": "720p",
    "fast_mode": true,
    "negative_prompt": "blurry, low quality, watermark"
  }'

T2V avec seed pour la reproductibilité :

curl -s -X POST https://api.novita.ai/v3/async/pixverse-v4.5-t2v \
  -H "Authorization: Bearer $NOVITA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Neon-lit cyberpunk street at night, rain reflections, hovering vehicles",
    "aspect_ratio": "16:9",
    "resolution": "1080p",
    "seed": 42
  }'

Interroger pour obtenir le résultat :

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

Dépannage

400 Bad Request lors de la soumission I2V

Vérifiez d’abord les contraintes de l’image : le format doit être jpg/jpeg/png, la taille doit être inférieure à 10 Mo avant l’encodage base64 (la charge utile encodée sera environ 33 % plus grande), dimensions minimales de 300×300 px, et rapport hauteur/largeur entre 1:2,5 et 2,5:1. Les extrêmes paysagers (images très larges ou très hautes) seront rejetés.

La tâche reste longtemps dans TASK_STATUS_QUEUED

C’est normal en cas de charge élevée de la plateforme. Le champ task.eta donne une estimation ; interrogez en conséquence plutôt que de marteler le point d’accès. Si une tâche n’a pas progressé après 10 minutes, consultez la page de statut de Novita AI ou réessayez la soumission.

TASK_STATUS_FAILED sans raison utile

Réessayez avec un prompt plus court et plus simple. Les prompts avec des instructions de mouvement ambiguës, des descriptions de scène contradictoires ou des personnages effectuant des mouvements impossibles ont tendance à échouer. Les prompts négatifs peuvent également entrer en conflit avec le prompt principal s’ils sont trop larges.

1080p non disponible en mode rapide

fast_mode: true limite la résolution à 720p. Si vous avez besoin de 1080p, supprimez fast_mode ou définissez-le sur false.

Le paramètre style n’a aucun effet visible

Le paramètre style est documenté comme étant réservé à la v3.5. Dans les requêtes V4.5, il peut être silencieusement ignoré ou produire des résultats incohérents. Ne vous y fiez pas sans tester votre cas d’utilisation spécifique.

FAQ

Quelle est la différence entre T2V et I2V pour PixVerse V4.5 ?

Le T2V génère un clip vidéo entièrement à partir d’un prompt textuel — aucune image d’entrée n’est nécessaire. L’I2V prend une image de départ et l’anime vers l’avant selon le prompt textuel, en utilisant l’image comme première image. Utilisez le T2V pour des scènes entièrement générées ; utilisez l’I2V lorsque vous avez un point de départ visuel spécifique que vous souhaitez animer.

Quelles sont les longueurs de vidéo produites par PixVerse V4.5 ?

Les clips durent 5 secondes en 1080p et jusqu’à 8 secondes pour les résolutions de 720p et inférieures. Il n’y a pas de paramètre duration dans l’API — la durée du clip est déterminée par la résolution que vous sélectionnez.

Le point d’accès I2V déduit-il le rapport hauteur/largeur de l’image ?

Oui. I2V n’a pas de paramètre aspect_ratio. Le rapport hauteur/largeur de sortie correspond à celui de l’image d’entrée. Assurez-vous que votre image est recadrée au rapport de sortie souhaité avant de la soumettre.

Puis-je soumettre des requêtes T2V et I2V en parallèle ?

Oui. Chaque requête renvoie son propre task_id indépendant. Vous pouvez soumettre plusieurs requêtes simultanément et les interroger en parallèle — pas besoin d’attendre la fin d’une requête avant d’en soumettre une autre.

Comment obtenir des sorties cohérentes entre les exécutions ?

Définissez le paramètre seed sur le même entier. Gardez à l’esprit que la reproductibilité basée sur le seed n’est pas garantie entre les mises à jour de version du modèle — stockez l’URL de la vidéo et les paramètres de génération ensemble si vous devez auditer les résultats ultérieurement.

fast_mode est-il adapté à une utilisation en production ?

Cela dépend de votre niveau de qualité. fast_mode: true génère des vidéos plus rapidement et coûte moins cher, mais la résolution est limitée à 720p et la qualité est inférieure au mode standard. Il est bien adapté à la génération d’aperçus, à l’évaluation par lots et au prototypage ; utilisez le mode standard lorsque la qualité de sortie est le facteur déterminant.

Articles recommandés

• PixVerse V4.5 T2V sur Novita AI : Le moyen le moins cher de créer des vidéos AI cinématographiques
• PixVerse V4.5 I2V sur Novita AI : Vidéo AI rapide, flexible et rentable
• Kling 3.0 maintenant sur Novita AI : Génération de vidéos AI cinématographiques à grande échelle