Comment Utiliser l'API LTX-2 ?

L'API LTX-2 permet aux développeurs de créer du contenu vidéo captivant grâce à l'intelligence artificielle. Ce service, fourni par Lightricks, permet aux utilisateurs de transformer des descriptions textuelles ou des images statiques en vidéos synchronisées avec de l'audio. Les ingénieurs l'intègrent dans des applications pour des tâches allant de la création de contenu au prototypage d'effets visuels. De plus, l'API prend en charge divers modèles optimisés pour la vitesse ou la qualité, permettant une personnalisation en fonction des besoins du projet.

💡

Pour tester et gérer efficacement les requêtes, les développeurs s'appuient souvent sur des outils spécialisés. Par exemple, Apidog offre une interface conviviale pour construire, envoyer et déboguer les appels d'API. Il gère de manière transparente les en-têtes d'authentification, les charges utiles JSON et l'analyse des réponses.

bouton

Par conséquent, pensez à télécharger Apidog gratuitement pour améliorer votre interaction avec l'API LTX-2 et vous concentrer davantage sur l'innovation plutôt que sur la configuration.

Qu'est-ce que l'API LTX-2 ?

Les développeurs utilisent l'API LTX-2 pour générer des vidéos de manière programmatique. Ce service RESTful s'appuie sur des modèles d'IA avancés pour produire des sorties cinématographiques à partir d'entrées simples. Plus précisément, il offre trois fonctionnalités principales : la génération de texte en vidéo, la transformation d'image en vidéo et la fonctionnalité de reprise pour l'édition de segments vidéo.

L'API s'appuie sur le modèle LTX-2, une fondation basée sur le transformateur de diffusion (DiT) qui crée de l'audio et de la vidéo synchronisés en une seule passe. Les utilisateurs soumettent des invites, et le système rend des vidéos d'une durée maximale de 20 secondes, en fonction du modèle et de la configuration sélectionnés. De plus, il prend en charge des résolutions élevées comme la 4K et des fréquences d'images allant jusqu'à 50 FPS, ce qui le rend adapté aux applications professionnelles.

Lightricks héberge l'API, garantissant l'évolutivité et la fiabilité. Les utilisateurs y accèdent via des points de terminaison HTTPS, les réponses fournissant directement des fichiers MP4. Cette approche synchrone simplifie les flux de travail, car les développeurs reçoivent la vidéo générée dans le corps de la réponse sans avoir à sonder l'état. Cependant, des limites de débit s'appliquent pour éviter la surcharge, les équipes surveillent donc attentivement l'utilisation.

Par rapport aux alternatives open source, l'API LTX-2 hébergée fait abstraction des exigences matérielles. Les développeurs évitent de gérer des GPU ou d'installer des frameworks comme ComfyUI, se concentrant plutôt sur l'intégration. Néanmoins, pour ceux qui préfèrent l'exécution locale, Lightricks fournit le modèle LTX-2 open source sur GitHub, mais ce guide met l'accent sur l'API pour une efficacité basée sur le cloud.

Démarrer avec l'API LTX-2

Les utilisateurs commencent par obtenir des identifiants. Tout d'abord, connectez-vous à la Console Développeur. La plateforme vous guidera dans la création de compte si nécessaire. Une fois connecté, générez une clé API directement depuis le tableau de bord.

Cette clé sert de jeton d'accès. Stockez-la en toute sécurité, car elle authentifie toutes les requêtes. Par exemple, placez-la dans des variables d'environnement pour éviter de la coder en dur dans les scripts. En Bash, exécutez export LTXV_API_KEY="votre_clé_ici". Les développeurs Python la récupèrent avec import os; api_key = os.environ.get("LTXV_API_KEY"). Les utilisateurs de Node.js y accèdent via process.env.LTXV_API_KEY.

Après avoir sécurisé la clé, testez la connectivité avec une simple requête. Utilisez des outils comme curl ou Apidog pour vérifier la configuration. Cette étape confirme l'état de votre compte et vous familiarise avec le format de réponse de l'API. En cas de problèmes, recherchez les erreurs courantes comme les clés invalides, qui renvoient un statut 401.

De plus, examinez les détails de votre plan dans la console. Les différents niveaux offrent des crédits et des limites variables, influençant la fréquence à laquelle vous générez des vidéos. Les équipes mettent à niveau leurs plans si nécessaire pour prendre en charge des volumes plus élevés.

Comment authentifier les requêtes dans l'API LTX-2 ?

L'authentification protège l'accès à l'API. Incluez la clé dans l'en-tête d'autorisation de chaque requête en utilisant le format Bearer. Plus précisément, définissez Authorization: Bearer VOTRE_CLÉ_API.

Par exemple, une commande curl ressemble à ceci :

curl -X POST https://api.ltx.video/v1/text-to-video \
-H "Authorization: Bearer VOTRE_CLÉ_API" \
-H "Content-Type: application/json" \
-d '{"prompt": "Un paysage de montagne serein à l'aube", "model": "ltx-2-pro", "duration": 8, "resolution": "1920x1080"}'

Les implémentations Python utilisent la bibliothèque requests :

import requests
import os

api_key = os.environ.get("LTXV_API_KEY")
headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json"
}
payload = {
    "prompt": "Un paysage de montagne serein à l'aube",
    "model": "ltx-2-pro",
    "duration": 8,
    "resolution": "1920x1080"
}
response = requests.post("https://api.ltx.video/v1/text-to-video", headers=headers, json=payload)
if response.status_code == 200:
    with open("video.mp4", "wb") as f:
        f.write(response.content)

Suivez scrupuleusement les pratiques de sécurité. N'exposez jamais les clés dans le code côté client ou les dépôts. Faites-les pivoter périodiquement via la console. De plus, utilisez des variables d'environnement pour le stockage afin d'améliorer la portabilité.

Si l'authentification échoue, l'API répond avec 401 Unauthorized. Le corps inclut des détails tels que "Clé API invalide" ou "En-tête d'autorisation manquant". Résolvez le problème en vérifiant le format et l'expiration de la clé. Les correctifs courants impliquent de regénérer la clé ou de corriger la syntaxe de l'en-tête.

Comprendre les modèles pris en charge dans l'API LTX-2

L'API LTX-2 propose deux modèles principaux : ltx-2-fast et ltx-2-pro. Chacun optimise des priorités différentes.

Le modèle ltx-2-fast privilégie l'efficacité. Il prend en charge des résolutions allant jusqu'à 3840x2160, des FPS de 25 ou 50, et des durées de 6 à 20 secondes dans certaines configurations. Par exemple, à 1920x1080 et 25 FPS, il gère jusqu'à 20 secondes. Ce modèle convient au prototypage rapide où la vitesse compte plus que la perfection.

Inversement, le modèle ltx-2-pro met l'accent sur la qualité. Il limite les durées à 6, 8 ou 10 secondes mais offre des détails et une cohérence supérieurs. Il prend également en charge des résolutions allant jusqu'à 3840x2160 et des FPS de 25 ou 50. Les développeurs le choisissent pour les rendus finaux nécessitant un polish.

Référez-vous à cette matrice de support de modèle pour des combinaisons précises :

Modèle	Résolution	FPS	Durée (secondes)
ltx-2-fast	1920x1080	25	6, 8, 10, 12, 14, 16, 18, 20
	1920x1080	50	6, 8, 10
	2560x1440	25, 50	6, 8, 10
	3840x2160	25, 50	6, 8, 10
ltx-2-pro	1920x1080	25, 50	6, 8, 10
	2560x1440	25, 50	6, 8, 10
	3840x2160	25, 50	6, 8, 10

Sélectionnez les modèles en fonction des exigences. Par exemple, utilisez ltx-2-fast pendant les itérations de développement, puis passez à ltx-2-pro pour la production. Notez que des résolutions et des durées plus élevées consomment plus de crédits.

Maîtriser le point de terminaison Texte-vers-Vidéo dans l'API LTX-2

Les développeurs invoquent le point de terminaison texte-vers-vidéo pour créer des vidéos à partir de descriptions. L'URL est https://api.ltx.video/v1/text-to-video, en utilisant la méthode POST.

Les paramètres requis comprennent :

prompt : Chaîne de caractères, jusqu'à 5000 caractères, décrivant la scène.
model : Énumération, soit "ltx-2-fast" soit "ltx-2-pro".
duration : Entier, en secondes, selon les contraintes du modèle.
resolution : Chaîne de caractères, comme "1920x1080".

Les paramètres optionnels améliorent le contrôle :

fps : Entier, par défaut 25.
camera_motion : Énumération pour des effets comme le panoramique ou le zoom (valeurs spécifiques non détaillées ici, se référer à la documentation).
generate_audio : Booléen, par défaut vrai pour l'audio synchronisé.

La requête attend un contenu JSON. Les réponses réussies renvoient un fichier MP4 dans le corps, avec Content-Type: video/mp4.

Par exemple, générez une vidéo de 8 secondes :

curl -X POST https://api.ltx.video/v1/text-to-video \
-H "Authorization: Bearer VOTRE_CLÉ_API" \
-H "Content-Type: application/json" \
-d '{"prompt": "Un aigle majestueux planant dans les nuages au coucher du soleil", "model": "ltx-2-pro", "duration": 8, "resolution": "1920x1080"}' \
-o video.mp4

L'équivalent Python enregistre le fichier directement. Si des erreurs surviennent, gérez les codes comme 400 pour les paramètres invalides ou 429 pour les limites.

Expérimentez avec les invites pour affiner les sorties. Incluez des détails sur l'action, les personnages et l'audio pour de meilleurs résultats. Ce point de terminaison constitue la base de la création vidéo basée sur du texte.

Explorer le point de terminaison Image-vers-Vidéo dans l'API LTX-2

Le point de terminaison image-vers-vidéo anime les images statiques. Il utilise POST vers https://api.ltx.video/v1/image-to-video.

Les paramètres clés reflètent ceux du texte-vers-vidéo mais ajoutent image_uri : Chaîne de caractères, une URL vers l'image d'entrée (HTTPS, jusqu'à 32 Mo, formats comme JPG).

Exemple de requête :

curl -X POST https://api.ltx.video/v1/image-to-video \
-H "Authorization: Bearer VOTRE_CLÉ_API" \
-H "Content-Type: application/json" \
-d '{"image_uri": "https://example.com/sunset.jpg", "prompt": "Des nuages dérivant dans le ciel tandis que le soleil se couche lentement", "model": "ltx-2-pro", "duration": 8, "resolution": "1920x1080"}' \
-o video.mp4

Les réponses livrent le MP4 animé. Utilisez ceci pour donner vie à des photos, par exemple dans les applications marketing ou éducatives. Assurez-vous que les images correspondent aux invites pour un mouvement cohérent.

Les contraintes correspondent aux modèles : validez la durée et la résolution. Si la récupération de l'image échoue, attendez-vous à des erreurs 400.

Utiliser la fonction de reprise dans l'API LTX-2

La capacité de reprise édite des sections vidéo sans régénération complète. Elle cible des moments spécifiques, remplaçant l'audio, la vidéo ou les deux via l'IA.

Bien que les spécifications détaillées du point de terminaison évoluent, il utilise probablement POST vers un chemin comme /v1/retake. Les paramètres incluent video_uri pour l'original, start_time et end_time en secondes, et prompt pour les modifications.

Par exemple, réécrivez un segment de dialogue. Cela économise des ressources par rapport à la recréation de vidéos entières. Les développeurs l'appliquent pour des raffinements itératifs dans les flux de travail de post-production.

Surveillez les mises à jour dans la documentation pour les paramètres complets. Actuellement, elle réécrit les moments efficacement, en maintenant la synchronisation.

Gérer les erreurs dans l'API LTX-2

L'API standardise les réponses d'erreur :

{
  "type": "error",
  "error": {
    "type": "type_erreur",
    "message": "Description"
  }
}

Codes courants :

400 : Requête invalide, par exemple, prompt manquant.
401 : Problème d'authentification.
402 : Crédits insuffisants.
413 : Charge utile trop volumineuse.
422 : Contenu filtré.
429 : Limite de débit ou de concurrence.
500 : Erreur serveur.
503 : Indisponible.

Gérez avec élégance : Réessayez en cas de 429 avec l'en-tête Retry-After. Vérifiez les soldes pour 402. Enregistrez les messages pour le débogage.

Bonnes pratiques : Validez les entrées côté client, implémentez une reprise exponentielle pour les nouvelles tentatives.

Gérer les limites de débit dans l'API LTX-2

Les limites de débit empêchent les abus. Elles incluent la concurrence (requêtes simultanées) et le débit (requêtes par fenêtre), variant selon le plan.

Le dépassement déclenche un 429 avec Retry-After. Types d'erreurs : rate_limit_error ou concurrency_limit_error.

Surveillez via les en-têtes. Optimisez en regroupant si possible, en utilisant des résolutions plus faibles pour les tests et en mettant à niveau les plans.

Contactez le support pour des augmentations.

Meilleures pratiques pour intégrer l'API LTX-2

Implémentez une gestion robuste des erreurs et la journalisation. Utilisez un traitement asynchrone si vous mettez à l'échelle.

Sécurisez les clés avec des coffres-forts. Testez les invites de manière approfondie.

Pour la production, calculez les coûts : les vidéos plus longues utilisent plus de crédits.

Intégrez-vous aux flux de travail : Générez des miniatures à partir d'images, puis des vidéos complètes.

Utiliser Apidog avec l'API LTX-2

Apidog rationalise les tests. Importez les points de terminaison, définissez les en-têtes et envoyez les requêtes visuellement.

Créez des collections pour les appels d'API LTX-2. Déboguez les réponses, y compris les MP4 binaires.

Il prend en charge les environnements pour les clés, facilitant les commutations.

Téléchargez Apidog gratuitement pour améliorer votre productivité.

Exemples avancés avec l'API LTX-2

En Python, construisez un wrapper :

import requests
import os

class LTX2API:
    def __init__(self):
        self.api_key = os.environ.get("LTXV_API_KEY")
        self.base_url = "https://api.ltx.video/v1"

    def generate_text_to_video(self, prompt, model="ltx-2-pro", duration=8, resolution="1920x1080"):
        headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
        payload = {"prompt": prompt, "model": model, "duration": duration, "resolution": resolution}
        response = requests.post(f"{self.base_url}/text-to-video", headers=headers, json=payload)
        if response.status_code == 200:
            return response.content
        else:
            raise Exception(response.json()["error"]["message"])

# Utilisation
api = LTX2API()
video_data = api.generate_text_to_video("Un paysage urbain futuriste la nuit")
with open("output.mp4", "wb") as f:
    f.write(video_data)

Étendez-le pour l'image-vers-vidéo. Utilisez-le dans les applications web via Flask ou Django.

Conclusion

L'API LTX-2 transforme la création vidéo. En suivant ce guide, les développeurs exploitent sa puissance efficacement. Commencez par les bases, affinez les invites et adaptez les intégrations. Des outils comme Apidog simplifient le processus, assurant un développement fluide.

bouton