ToAPIs
    AccueilToAPIs
    Génération d'imagesGPT Image 2.6, Gemini, FLUX…Génération de vidéosSeedance, Veo, Kling, Sora…Chat et rédactionGPT-5.6, Claude, DeepSeek…Voix et musiqueVoix off, TTS, audio
    Nouvelle sortieSeedance 2.5
    TarifsDocumentation APIMCP
    BlogAlternatives
    Se connecterCommencer gratuitement
    Tous les modèlesTarifsDocumentation APIMCPBlogAlternatives
    Se connecterCommencer gratuitement

    Langue

    Esc
    • Seedance 2.5Génération de vidéos
    • GPT Image 2Génération d'images
    • GPT Image 2.6Génération d'images
    • GPT Image 2.5Génération d'images
    • Veo 3.1 FastGénération de vidéos
    • Kling 3.0 TurboGénération de vidéos
    • Kling V4 FlashGénération de vidéos
    • Grok Video 1.5Génération de vidéos
    • Nano Banana 2Génération d'images
    • Seedream 5.5Génération d'images
    • FLUXGénération d'images
    • Sora 2Génération de vidéos
    • Tous les modèles d'imageCatégorie
    • Tous les modèles vidéoCatégorie
    • GPT-5.6 SolChat et codage
    • Claude Opus 4.8Chat et codage
    • Claude Opus 4.7Chat et codage
    • DeepSeek V4 ProDeepSeek · Texte
    • Gemini Omni 1.1 FlashGoogle · Multimodal
    1. Accueil
    2. Blog
    3. Tutoriel
    4. Construire un pipeline image-vers-vidéo (R2V) automatisé avec l'API MiniMax H3
    Retour à tous les articles
    tutorial2026-11-106 min de lecture

    Construire un pipeline image-vers-vidéo (R2V) automatisé avec l'API MiniMax H3

    Tutoriel d'ingénierie pour un pipeline Reference-to-Video automatisé sur MiniMax H3 : entrées de première image, préparation des actifs, interrogation bornée des tâches et contrat de requête du frontend ToAPIs.

    ToAPIs Engineering & Evaluation Team
    MiniMax H3R2VVideo AutomationPythonTutorial
    TL;DR - Points clés
    • Le R2V en mode image de MiniMax H3 ancre un clip avec first_frame_image (et éventuellement last_frame_image) ; ces deux champs sont des listes d'au plus une image chacun.
    • Ne mélangez pas les entrées de première et de dernière image avec reference_images, reference_videos ou reference_audio dans la même requête.
    • Un worker robuste prépare un actif accessible, envoie POST /v1/videos/generations, puis interroge le point de terminaison de statut avec un backoff exponentiel borné.
    • Confirmez le format de téléversement, le format de réponse et les tarifs actuels de votre compte avant de l'exécuter sans supervision ; ce n'est pas un benchmark de latence ou de prix.

    Construire un pipeline image-vers-vidéo (R2V) automatisé avec l'API MiniMax H3

    Modèle cible : minimax-h3
    Point de terminaison d'inférence : https://api.toapis.com/v1/videos/generations
    Articles liés : Guide de l'API MiniMax H3 · Prompts de mouvement de caméra · Choisir entre H3 et Turbo


    1. Résumé et vue d'ensemble des performances

    • Travail : animer une image fixe en un clip court avec le mode image de MiniMax H3, puis encapsuler l'envoi et l'interrogation dans un worker exécutable sans supervision.
    • Entrées : first_frame_image sous forme de liste à un élément ; last_frame_image facultative sous forme de liste à un élément ; un prompt décrivant le mouvement qui s'éloigne de cette ancre ou tourne autour ; durée entière de 4–15 s sur minimax-h3 de base.
    • Modes : les entrées d'image et le média de référence sont mutuellement exclusifs. Turbo (minimax-h3-max-turbo) rejette le média de référence ; ne copiez pas de champs de référence dans une charge utile Turbo.
    • Worker : préparez un actif accessible, envoyez une seule fois, conservez l'identifiant de tâche, interrogez avec backoff et une échéance ferme, puis stockez l'URL du résultat dans votre propre système.
    • Périmètre : il s'agit d'un guide d'intégration pour le contrat actuel du frontend ToAPIs. Ce n'est pas un benchmark de latence, de disponibilité ou de prix.

    2. Plan du pipeline

    Un worker R2V sans supervision doit découpler la requête HTTP de l'appelant du rendu de longue durée :

    1. Accepter l'image fixe source et le prompt de mouvement depuis votre produit.
    2. Préparer l'image via le flux de téléversement documenté, ou utiliser une URL que vous êtes autorisé à récupérer. Préférez un stockage objet avec un localisateur accessible et de courte durée plutôt qu'un chemin disque privé.
    3. Soumettre une tâche POST /v1/videos/generations avec model, prompt, duration et first_frame_image.
    4. Interroger le point de terminaison de statut documenté avec un backoff exponentiel borné et une échéance globale.
    5. Livrer l'URL de la vidéo obtenue via votre propre canal de notification (file d'attente, e-mail ou webhook produit). Vérifiez l'état de la tâche avant de créer une seconde tâche facturable.

    Pipeline R2V abstrait, d'une image fixe à travers une gateway et une boucle d'interrogation jusqu'aux images de sortie

    Figure 1 : une image fixe est préparée, soumise une seule fois via la gateway de générations ToAPIs, puis interrogée jusqu'à un état final avant que votre service n'émette le clip terminé.

    Contrôles préalables qui évitent la plupart des erreurs 400 :

    • Utilisez l'ID de modèle exact autorisé pour le compte (minimax-h3, minimax-h3-max ou minimax-h3-max-turbo, pas un alias inventé).
    • La durée est un entier : 4–15 s sur H3 de base, 5–15 s sur les ID de la famille Max.
    • first_frame_image et last_frame_image sont des listes d'au plus une image chacune.
    • N'envoyez pas reference_images, reference_videos ni reference_audio dans la même requête que des entrées d'image.
    • Dans le frontend actuel, le mode image force ratio à adaptive. Adaptez la forme de l'image fixe au canevas visé (par exemple 1920×1080 pour un clip panoramique, 1080×1920 pour un clip vertical) pour réduire les recadrages inattendus.
    • Le champ du contrat est ratio, pas aspect_ratio.

    La formulation caméra du prompt s'applique toujours en mode image ; consultez le guide des prompts de mouvement de caméra. Traitez les balises entre crochets comme des aides au prompt, pas comme des commandes natives.


    3. Implémentation en production : cURL et Python

    Étape 1 : requête cURL avec première image

    bash
    curl -X POST "https://api.toapis.com/v1/videos/generations" \
      -H "Authorization: Bearer $TOAPIS_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "model": "minimax-h3",
        "prompt": "[Dolly Forward] Rain falling onto neon asphalt, steam rising from grates, cinematic reflections",
        "duration": 6,
        "ratio": "16:9",
        "first_frame_image": ["https://example.com/starting-frame.jpg"]
      }'
    

    Remplacez l'URL d'exemple par un identifiant d'actif ou une URL issue de votre flux de téléversement documenté. Le contrat H3 publié présente first_frame_image comme un tableau, pas comme une simple chaîne.

    Pour guider aussi une image de fin, ajoutez "last_frame_image": ["https://example.com/ending-frame.jpg"] dans la même requête en mode image. C'est le mode image standard, pas un indicateur expérimental réservé à Turbo.

    Étape 2 : worker Python avec interrogation bornée

    Faites correspondre task_id, status et video_url au schéma de réponse documenté pour votre compte avant de livrer.

    python
    import os
    import time
    import requests
    from typing import Any
    
    API_KEY = os.environ["TOAPIS_API_KEY"]
    BASE_URL = "https://api.toapis.com/v1"
    HEADERS = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json",
    }
    
    
    class MiniMaxR2VPipeline:
        def trigger_r2v(
            self,
            image_ref: str,
            prompt: str,
            duration: int = 6,
            last_frame_ref: str | None = None,
        ) -> str:
            if not 4 <= duration <= 15:
                raise ValueError("Base minimax-h3 accepts integer durations of 4-15 seconds")
            payload: dict[str, Any] = {
                "model": "minimax-h3",
                "prompt": prompt,
                "duration": duration,
                "ratio": "16:9",
                "first_frame_image": [image_ref],
            }
            if last_frame_ref:
                payload["last_frame_image"] = [last_frame_ref]
            res = requests.post(
                f"{BASE_URL}/videos/generations",
                headers=HEADERS,
                json=payload,
                timeout=30,
            )
            res.raise_for_status()
            data = res.json()
            task_id = data.get("task_id") or data.get("id")
            if not task_id:
                raise RuntimeError(f"Unexpected submission envelope: {data}")
            return task_id
    
        def poll_until_complete(self, task_id: str, max_timeout: int = 180) -> dict[str, Any]:
            start = time.time()
            interval = 3.0
            poll_url = f"{BASE_URL}/videos/tasks/{task_id}"
            while time.time() - start < max_timeout:
                res = requests.get(poll_url, headers=HEADERS, timeout=15)
                res.raise_for_status()
                data = res.json()
                status = data.get("status")
                if status in {"succeeded", "success"}:
                    return {
                        "status": "success",
                        "task_id": task_id,
                        "video_url": data.get("video_url"),
                        "elapsed_seconds": round(time.time() - start, 2),
                    }
                if status in {"failed", "error"}:
                    return {
                        "status": "error",
                        "task_id": task_id,
                        "error": data.get("error", "Generation failed"),
                    }
                time.sleep(interval)
                interval = min(interval * 1.1, 6.0)
            return {
                "status": "timeout",
                "task_id": task_id,
                "error": f"Exceeded {max_timeout}s; check task status before retrying",
            }
    
    
    if __name__ == "__main__":
        pipeline = MiniMaxR2VPipeline()
        # Replace with an uploaded asset identifier or a URL you are authorized to fetch.
        image_ref = "https://example.com/starting-frame.jpg"
        prompt = "[Dolly Forward] Rain falling onto neon asphalt, steam rising from grates, cinematic reflections"
        task_id = pipeline.trigger_r2v(image_ref, prompt)
        print("Task:", task_id)
        print("Result:", pipeline.poll_until_complete(task_id))
    

    Une expiration de délai n'est pas un échec confirmé. Journalisez l'identifiant de tâche (jamais la clé API ni les URL de médias privés), inspectez le statut, et décidez seulement ensuite s'il faut resoumettre.


    4. Gestion des erreurs et matrice des statuts

    Les catégories ci-dessous sont des points de départ pour le diagnostic, et non une garantie des codes d'erreur exacts de ToAPIs.

    Statut HTTPCatégorie couranteAction recommandée
    400Champ invalide, média inaccessible ou non pris en charge, ou modes image et référence mélangésVérifiez l'ID de modèle, la durée, first_frame_image comme liste à un élément, et l'absence de champs de référence
    401Clé API absente ou invalideFaites tourner la clé dans le tableau de bord ToAPIs
    429Limite de débit ou de concurrenceReculez avec du jitter et mettez en file d'attente localement
    5xx ou expiration réseauProblème temporaire de gateway ou d'amontRelisez l'état de la tâche avant de créer une autre tâche

    WaitTime=min⁡(MaxWait,BaseInterval×2attempt)+Uniform(0,1)\text{WaitTime} = \min(\text{MaxWait}, \text{BaseInterval} \times 2^{\text{attempt}}) + \text{Uniform}(0, 1)WaitTime=min(MaxWait,BaseInterval×2attempt)+Uniform(0,1)

    Traitez les échecs de téléversement comme un arrêt net : n'envoyez pas de requête de génération sans un identifiant d'actif valide.


    5. Tarifs et retour sur investissement FinOps

    Estimated cost=successful output seconds×current account rate per second\text{Estimated cost} = \text{successful output seconds} \times \text{current account rate per second}Estimated cost=successful output seconds×current account rate per second

    • Citez une source de compte datée. Ne collez pas de prix à la seconde ni de pourcentages de SLA issus de brouillons de planification dans une prévision de production. Les tarifs et la facturation des tâches en échec peuvent varier selon le modèle et la route.
    • Les contrats officiels des fournisseurs peuvent imposer des engagements ou des minimums de prépaiement. Confirmez si votre compte ToAPIs est en paiement à l'usage pur et comment les rendus amont en échec sont facturés.
    • La discipline de pipeline est le levier FinOps concret : une soumission par plan, des vérifications d'état avant les nouvelles tentatives, des modèles de prompt conservés avec la tâche et une durée limitée au clip le plus court qui sert le plan.
    • Besoin de 1080P ? Vérifiez si l'ID canonique exact minimax-h3-max est autorisé. Besoin de Turbo ? Utilisez minimax-h3-max-turbo et omettez les champs de média de référence. Les détails figurent dans le guide de sélection.

    6. Questions fréquentes

    Voir le bloc FAQ du frontmatter. En résumé : adaptez l'image fixe au canevas visé ; le guidage par image de fin relève du mode image standard (au plus une image par champ) ; utilisez le flux de téléversement documenté plutôt qu'un chemin privé ; ce guide interroge l'état au lieu de supposer un webhook ToAPIs.


    7. Liste d'actions

    • Créez une clé sur le portail développeur ToAPIs.
    • Préparez une image fixe via le flux de téléversement documenté et testez rapidement la requête cURL avec première image.
    • Câblez le worker Python avec une échéance d'interrogation de 180 s et une règle de non-duplication des envois en cas d'expiration.
    • Relisez le contrat de requête H3 et le guide des prompts de mouvement de caméra avant de lancer des tâches en lot.

    Découvrir les modèles cités dans cet article

    MiniMaxVIDEO

    minimax-h3

    Tarif actuel : 20.8 credits /second
    Guide du modèleEssayer dans la consoleObtenir une clé d'API
    MiniMaxVIDEO

    minimax-h3-max

    Tarif actuel : 8 credits /second
    Guide du modèleEssayer dans la consoleObtenir une clé d'API
    ToAPIsAI Model

    minimax-h3-max-turbo

    Tarif actuel : Voir les tarifs en direct
    Guide du modèleEssayer dans la consoleObtenir une clé d'API

    Articles associés

    tutorial2026-10-22T09:00:00+08:0012 min de lecture

    Guide de l'API MiniMax H3 : texte vers vidéo et entrées de référence

    Guide pratique pour appeler les modèles vidéo MiniMax H3 via ToAPIs : exemples de requêtes, modes d'entrée pris en charge, limites par modèle et suivi de l'état des tâches.

    TO
    ToAPIs Engineering Team
    #MiniMax H3
    tutorial2026-11-10T10:00:00+08:006 min de lecture

    Guide des prompts MiniMax H3 : composer des mouvements de caméra cinématographiques via l'API

    Guide développeur pour écrire des prompts de mouvements de caméra cinématographiques pour l'API vidéo MiniMax H3 sur ToAPIs : modèles réutilisables, exemples cURL et Python, et contrat de requête actuel du frontend.

    TO
    ToAPIs Engineering & Evaluation Team
    #MiniMax H3
    tutorial2026-11-11T10:00:00+08:007 min de lecture

    Intégration de l'API MiniMax Hailuo 2.3 : générer des mouvements humains complexes en vidéo IA

    Guide développeur de l'API vidéo MiniMax Hailuo 2.3 sur ToAPIs : schémas de prompt pour le mouvement humain, contrat de requête actuel pour les tâches de 6 et 10 secondes en 768P et 1080P, et exemples cURL et Python.

    TO
    ToAPIs Engineering & Evaluation Team
    #MiniMax Hailuo
    ToAPIs
    AccueilToAPIs
    Passerelle d'API d'IA pour l'entreprise. Accédez à GPT-5, Claude, Gemini et plus de 200 modèles via une API unifiée.

    Modèles populaires

    • Seedance 2.5 API
    • Seedance 2.0 API
    • Veo 3.1 Fast API
    • Kling 3.0 Turbo API
    Afficher plusAfficher moins
    • GPT Image 2 API
    • Claude Opus 4.8 API
    • Nano Banana 2 API
    • Seedance 2 Mini API
    • Tous les modèles

    Catégories d'API

    • API image IA
    • API vidéo IA
    • API texte-vers-vidéo
    • API image-vers-vidéo
    Afficher plusAfficher moins
    • API d'édition d'image IA
    • API LLM et raisonnement
    • Tous les outils API →

    Alternatives

    Alternatives
    • Alternative à Kie.ai
    • Alternative à Fal.ai
    • Alternative à OpenRouter
    • Alternative à Replicate
    • Alternative à Wavespeed AI
    • Toutes les comparaisons →

    Guides à la une

    Guides à la une
    • Tarifs de Seedance 2.0 et 2.5
    • Guide de l'API Seedance la moins chère
    • Guide d'intégration de MiniMax H3
    • Clé d'API Seedance 2 gratuite
    • Démarrage rapide de l'API Seedance 2
    • Tous les articles techniques →

    Développeurs et plateforme

    Développeurs et plateforme
    • Documentation API
    • MCP
    • Tarifs
    • Playground de modèles
    • LLMs.txt
    • Contacter le support
    • Annuaire des guides de modèles
    Entité exploitante :
    鯨樞智能科技有限公司
    JINGSHU INTELLIGENT LIMITED
    Siège social :
    ROOM 5042, 5/F, YAU LEE CENTRE, NO.45, HOI YUEN ROAD, KWUN TONG, KOWLOON, HONG KONG
    ConfidentialitéConditionsUsage acceptableSuppression des donnéesConservation des donnéesSous-traitants et régionsFacturation et remboursementsPolitique relative aux cookiesPlan du siteÀ propos

    © 2026 ToAPIs. Tous droits réservés.