3 solutions pour résoudre l’erreur de durée vidéo de l’API Sora 2 : erreur invalid_value du paramètre seconds

Lorsque vous appelez l'API Sora 2 pour générer une vidéo, si vous passez une valeur non supportée pour le paramètre seconds, l'API renvoie immédiatement une erreur invalid_value. Cet article analyse en détail la cause profonde de l'erreur Invalid value: '10'. Supported values are: '4', '8', and '12' et propose des solutions complètes.

Valeur ajoutée : En lisant cet article, vous maîtriserez les différences de paramètres de durée entre les versions Standard et Pro de Sora 2, et apprendrez à configurer correctement le paramètre seconds pour éviter que vos requêtes de génération ne soient rejetées.

Analyse de l'erreur du paramètre seconds de l'API Sora 2

Lorsque vous appelez l'API Sora 2, si vous recevez le message d'erreur suivant :

{
  "message": "Invalid value: '10'. Supported values are: '4', '8', and '12'.",
  "data": {
    "error": {
      "code": "invalid_value",
      "message": "Invalid value: '10'. Supported values are: '4', '8', and '12'.",
      "param": "seconds",
      "type": "invalid_request_error"
    }
  }
}

Cela signifie que la valeur transmise pour le paramètre seconds (dans cet exemple 10) ne fait pas partie des options autorisées par l'API.

Mécanisme de validation strict de la durée dans l'API Sora 2

L'API Sora 2 applique une validation par valeurs fixes pour la durée des vidéos ; elle ne supporte pas n'importe quel nombre de secondes :

Pourquoi l'API Sora 2 limite-t-elle les durées à des valeurs fixes ?

Dans la version préliminaire de Sora 2, OpenAI a délibérément restreint les valeurs de durée pour plusieurs raisons :

1. Optimisation des ressources de calcul : Les durées fixes facilitent la pré-allocation des ressources GPU.
2. Cohérence de la qualité : Les durées prédéfinies ont été optimisées pour garantir un rendu vidéo plus stable.
3. Contrôle des coûts : Limiter la longueur permet d'éviter que les utilisateurs ne génèrent accidentellement des frais élevés.
4. Caractéristiques du modèle : Sora 2 offre une meilleure cohérence entre les images (frame consistency) sur ces durées spécifiques.

🎯 Note importante : Les valeurs de durée supportées par les versions Standard et Pro de Sora 2 sont totalement différentes. Vous devez impérativement choisir la valeur correcte en fonction du modèle utilisé.

Sora 2 Standard vs version Pro : Comparaison des paramètres de durée

C'est la cause la plus fréquente d'erreur : confondre les paramètres de la version Standard et de la version Pro.

Durées supportées par Sora 2 Standard (sora-2)

Durées supportées par Sora 2 Pro (sora-2-pro)

Tableau comparatif complet des paramètres

💡 Conseil de sélection : Si vous avez besoin d'une vidéo de 10 secondes, vous devez utiliser le modèle sora-2-pro et non le modèle sora-2. Nous vous suggérons de tester les différentes combinaisons de modèles et de durées sur la plateforme APIYI apiyi.com pour trouver rapidement la configuration la mieux adaptée à vos besoins.

Solution 1 : Utiliser les valeurs de "seconds" correctes (version Standard)

Si vous utilisez le modèle sora-2 version Standard, vous devez impérativement utiliser les valeurs 4, 8 ou 12 :

import openai

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # Utilisation de l'interface unifiée APIYI
)

# ✅ Correct : Utilisation des durées supportées par la version Standard
response = client.videos.create(
    model="sora-2",           # Modèle version Standard
    prompt="A cat playing with a ball in a sunny garden",
    seconds=8,                # Uniquement 4, 8, ou 12
    size="1280x720"
)

print(f"Tâche de génération vidéo : {response.id}")

🚀 Démarrage rapide : Nous vous recommandons d'utiliser la plateforme APIYI (apiyi.com) pour tester rapidement l'API Sora 2. Elle propose une interface prête à l'emploi et prend en charge le basculement entre les modèles Standard et Pro.

Solution 2 : Passer à la version Pro pour des durées plus longues

Si vous avez besoin de vidéos de 10, 15 ou 25 secondes, vous devez passer au modèle sora-2-pro :

import openai

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # Utilisation de l'interface unifiée APIYI
)

# ✅ Correct : Utilisation de la version Pro pour une durée plus longue
response = client.videos.create(
    model="sora-2-pro",       # Modèle version Pro
    prompt="A cinematic sunrise over mountains with birds flying",
    seconds=15,               # La version Pro supporte 10, 15, 25
    size="1792x1024"          # La version Pro supporte des résolutions plus élevées
)

print(f"Tâche de génération vidéo : {response.id}")

Solution 3 : Implémenter une classe utilitaire d'adaptation intelligente de la durée

Voici un outil d'adaptation des paramètres de durée de niveau production, qui gère automatiquement la correspondance entre le modèle et la durée :

import openai
from typing import Literal, Optional

class SoraVideoGenerator:
    """Outil de génération de vidéos API Sora 2, adaptant automatiquement les paramètres de durée"""

    # Configuration des durées supportées par modèle
    MODEL_DURATIONS = {
        "sora-2": {
            "supported": [4, 8, 12],
            "default": 4,
            "max_resolution": "1280x720"
        },
        "sora-2-pro": {
            "supported": [10, 15, 25],
            "default": 10,
            "max_resolution": "1792x1024"
        }
    }

    def __init__(self, api_key: str, base_url: str = "https://api.apiyi.com/v1"):
        self.client = openai.OpenAI(api_key=api_key, base_url=base_url)

    def get_valid_duration(self, model: str, desired_seconds: int) -> int:
        """Obtient la durée valide la plus proche de la valeur souhaitée"""
        if model not in self.MODEL_DURATIONS:
            raise ValueError(f"Modèle non supporté : {model}")

        supported = self.MODEL_DURATIONS[model]["supported"]

        # Si la valeur souhaitée est valide, on la renvoie directement
        if desired_seconds in supported:
            return desired_seconds

        # Sinon, on renvoie la valeur valide la plus proche
        closest = min(supported, key=lambda x: abs(x - desired_seconds))
        print(f"⚠️ Durée de {desired_seconds}s non supportée, ajustée automatiquement à {closest}s")
        return closest

    def suggest_model(self, desired_seconds: int) -> str:
        """Recommande le modèle approprié en fonction de la durée souhaitée"""
        if desired_seconds <= 12:
            return "sora-2"
        else:
            return "sora-2-pro"

    def create_video(
        self,
        prompt: str,
        seconds: int,
        model: Optional[str] = None,
        size: Optional[str] = None,
        auto_adjust: bool = True
    ):
        """
        Crée une vidéo, avec support de l'ajustement automatique des paramètres

        Args:
            prompt: Description de la vidéo (invite)
            seconds: Durée souhaitée
            model: Nom du modèle, sélection automatique si non spécifié
            size: Résolution
            auto_adjust: Ajuster automatiquement ou non les paramètres non supportés
        """
        # Sélection automatique du modèle
        if model is None:
            model = self.suggest_model(seconds)
            print(f"📌 Sélection automatique du modèle : {model}")

        # Validation et ajustement de la durée
        if auto_adjust:
            seconds = self.get_valid_duration(model, seconds)
        elif seconds not in self.MODEL_DURATIONS[model]["supported"]:
            supported = self.MODEL_DURATIONS[model]["supported"]
            raise ValueError(
                f"Le modèle {model} ne supporte pas {seconds}s, "
                f"valeurs supportées : {supported}"
            )

        # Définition de la résolution par défaut
        if size is None:
            size = self.MODEL_DURATIONS[model]["max_resolution"]

        # Appel de l'API
        response = self.client.videos.create(
            model=model,
            prompt=prompt,
            seconds=seconds,
            size=size
        )

        return {
            "task_id": response.id,
            "model": model,
            "seconds": seconds,
            "size": size
        }

# Exemples d'utilisation
generator = SoraVideoGenerator(api_key="YOUR_API_KEY")

# Exemple 1 : Sélection automatique du modèle et ajustement de la durée
result = generator.create_video(
    prompt="Ocean waves crashing on a beach at sunset",
    seconds=10  # Sélectionnera automatiquement sora-2-pro
)
print(f"Résultat : {result}")

# Exemple 2 : Spécification du modèle, ajustement automatique de la durée
result = generator.create_video(
    prompt="A coffee cup with steam rising",
    seconds=10,          # 10s est invalide pour sora-2
    model="sora-2",      # Spécification de la version Standard
    auto_adjust=True     # Ajusté automatiquement à 12s ou 8s
)
print(f"Résultat : {result}")

import openai
import asyncio
from typing import Literal, Optional, Dict, Any
from dataclasses import dataclass
from enum import Enum

class SoraModel(Enum):
    """Énumération des modèles Sora"""
    STANDARD = "sora-2"
    PRO = "sora-2-pro"

@dataclass
class ModelConfig:
    """Configuration du modèle"""
    supported_durations: list[int]
    default_duration: int
    max_resolution: str
    has_audio: bool

class SoraVideoGenerator:
    """
    Outil de génération de vidéos API Sora 2

    Fonctionnalités :
    - Adaptation automatique de la durée
    - Sélection automatique du modèle
    - Validation des paramètres
    - Mécanisme de tentative (retry)
    """

    MODELS: Dict[str, ModelConfig] = {
        "sora-2": ModelConfig(
            supported_durations=[4, 8, 12],
            default_duration=4,
            max_resolution="1280x720",
            has_audio=False
        ),
        "sora-2-pro": ModelConfig(
            supported_durations=[10, 15, 25],
            default_duration=10,
            max_resolution="1792x1024",
            has_audio=True
        )
    }

    RESOLUTIONS = {
        "720p_landscape": "1280x720",
        "720p_portrait": "720x1280",
        "1080p_landscape": "1792x1024",
        "1080p_portrait": "1024x1792",
    }

    def __init__(
        self,
        api_key: str,
        base_url: str = "https://api.apiyi.com/v1",
        max_retries: int = 3
    ):
        self.client = openai.OpenAI(api_key=api_key, base_url=base_url)
        self.max_retries = max_retries

    def validate_model(self, model: str) -> ModelConfig:
        """Valide le modèle et renvoie la configuration"""
        if model not in self.MODELS:
            available = list(self.MODELS.keys())
            raise ValueError(f"Modèle non supporté : {model}, modèles disponibles : {available}")
        return self.MODELS[model]

    def get_valid_duration(self, model: str, desired: int) -> int:
        """Obtient la durée valide la plus proche de la valeur souhaitée"""
        config = self.validate_model(model)
        supported = config.supported_durations

        if desired in supported:
            return desired

        closest = min(supported, key=lambda x: abs(x - desired))
        return closest

    def suggest_model_for_duration(self, seconds: int) -> str:
        """Recommande un modèle selon la durée souhaitée"""
        # Vérifier si la version Standard le supporte
        if seconds in self.MODELS["sora-2"].supported_durations:
            return "sora-2"
        # Vérifier si la version Pro le supporte
        if seconds in self.MODELS["sora-2-pro"].supported_durations:
            return "sora-2-pro"
        # Par défaut selon la durée
        return "sora-2" if seconds <= 12 else "sora-2-pro"

    def create_video(
        self,
        prompt: str,
        seconds: int,
        model: Optional[str] = None,
        size: Optional[str] = None,
        auto_adjust: bool = True
    ) -> Dict[str, Any]:
        """
        Créer une vidéo

        Args:
            prompt: Invite de description de la vidéo
            seconds: Durée souhaitée (secondes)
            model: Nom du modèle, sélectionné automatiquement si None
            size: Résolution, utilise la valeur par défaut du modèle si None
            auto_adjust: Ajuster automatiquement ou non les paramètres non supportés

        Returns:
            Dictionnaire contenant les informations de la tâche

        Raises:
            ValueError: Si les paramètres sont invalides et auto_adjust=False
        """
        # Sélection automatique du modèle
        if model is None:
            model = self.suggest_model_for_duration(seconds)

        config = self.validate_model(model)

        # Gestion du paramètre de durée
        original_seconds = seconds
        if seconds not in config.supported_durations:
            if auto_adjust:
                seconds = self.get_valid_duration(model, seconds)
                print(f"⚠️ Durée ajustée : {original_seconds}s → {seconds}s")
            else:
                raise ValueError(
                    f"Le modèle {model} ne supporte pas {seconds}s, "
                    f"valeurs supportées : {config.supported_durations}"
                )

        # Définition de la résolution
        if size is None:
            size = config.max_resolution

        # Appel de l'API (avec tentatives)
        last_error = None
        for attempt in range(self.max_retries):
            try:
                response = self.client.videos.create(
                    model=model,
                    prompt=prompt,
                    seconds=seconds,
                    size=size
                )
                return {
                    "success": True,
                    "task_id": response.id,
                    "model": model,
                    "seconds": seconds,
                    "size": size,
                    "has_audio": config.has_audio,
                    "adjusted": original_seconds != seconds
                }
            except Exception as e:
                last_error = e
                if attempt < self.max_retries - 1:
                    wait_time = 2 ** attempt
                    print(f"⏳ Échec de la requête, tentative dans {wait_time}s...")
                    import time
                    time.sleep(wait_time)

        return {
            "success": False,
            "error": str(last_error),
            "model": model,
            "seconds": seconds
        }

    @staticmethod
    def get_duration_info() -> str:
        """Obtient les informations d'aide sur les paramètres de durée"""
        info = ["Description des paramètres de durée de l'API Sora 2 :", ""]
        for model, config in SoraVideoGenerator.MODELS.items():
            durations = ", ".join(map(str, config.supported_durations))
            info.append(f"  {model} : {durations} secondes")
            info.append(f"    Par défaut : {config.default_duration}s")
            info.append(f"    Résolution maximale : {config.max_resolution}")
            info.append(f"    Audio : {'Supporté' if config.has_audio else 'Non supporté'}")
            info.append("")
        return "\n".join(info)


# Exemple d'utilisation
if __name__ == "__main__":
    # Affichage des informations d'aide
    print(SoraVideoGenerator.get_duration_info())

    # Initialisation du générateur
    generator = SoraVideoGenerator(api_key="YOUR_API_KEY")

    # Exemple 1 : Laisser l'outil choisir la meilleure configuration
    result = generator.create_video(
        prompt="A serene lake reflecting autumn trees",
        seconds=10
    )
    print(f"Résultat : {result}")

    # Exemple 2 : Forcer l'utilisation d'un modèle spécifique
    result = generator.create_video(
        prompt="Quick product showcase",
        seconds=5,
        model="sora-2",
        auto_adjust=True  # 5s sera ajusté à 4s
    )
    print(f"Résultat : {result}")

Meilleures pratiques pour les paramètres de durée de l'API Sora 2

Choisir la durée adaptée selon le scénario

Relation entre la durée et la qualité de génération

Selon les recommandations officielles d'OpenAI et les tests pratiques :

💰 Optimisation des coûts : Pour les projets à budget limité, il est conseillé de tester d'abord l'effet de l'invite avec une durée de 4 secondes. Une fois que le résultat vous convient, générez une version plus longue. Vous pouvez obtenir des tarifs de consommation plus avantageux via la plateforme APIYI (apiyi.com).

Alternatives pour les vidéos longues

Si vous avez besoin d'une vidéo dépassant les 25 secondes, vous pouvez adopter la stratégie suivante :

def create_long_video_segments(generator, prompt_segments, model="sora-2"):
    """
    创建长视频的分段生成方案

    Args:
        generator: SoraVideoGenerator 实例
        prompt_segments: 分段提示词列表
        model: 使用的模型
    """
    results = []
    config = generator.MODELS[model]
    max_duration = max(config.supported_durations)

    for i, segment_prompt in enumerate(prompt_segments):
        print(f"生成片段 {i+1}/{len(prompt_segments)}...")
        result = generator.create_video(
            prompt=segment_prompt,
            seconds=max_duration,
            model=model
        )
        results.append(result)

    return results

# 使用示例：生成 36 秒视频 (3 x 12秒)
prompt_segments = [
    "Opening shot: A sunrise over a mountain range, golden light spreading",
    "Middle shot: Birds taking flight from the trees, camera follows",
    "Closing shot: The sun fully risen, peaceful valley below"
]

generator = SoraVideoGenerator(api_key="YOUR_API_KEY")
segments = create_long_video_segments(generator, prompt_segments)
# 后续使用 FFmpeg 拼接片段

FAQ : Erreurs courantes sur la durée avec l'API Sora 2

# ✅ Correct : utilisation d'un entier
seconds=8

# ❌ Incorrect : utilisation d'une chaîne de caractères
seconds="8"

VALID_DURATIONS = {
    "sora-2": [4, 8, 12],
    "sora-2-pro": [10, 15, 25]
}

def validate_seconds(model, seconds):
    valid = VALID_DURATIONS.get(model, [])
    if seconds not in valid:
        raise ValueError(f"Durées supportées par {model} : {valid}")
    return True

Aide-mémoire des paramètres seconds de l'API Sora 2

Pour faciliter vos recherches rapides, voici le tableau complet des paramètres de durée :

Valeurs erronées fréquentes et suggestions de correction

📌 Astuce : Les plateformes disponibles incluent APIYI (apiyi.com), l'API officielle d'OpenAI, etc. Il est recommandé d'utiliser des plateformes aux tarifs plus avantageux durant la phase de développement et de test.

Conclusion

L'erreur du paramètre seconds de l'API Sora 2 est un problème classique pour les développeurs. La logique de résolution repose sur ces points clés :

1. Distinguer le modèle : sora-2 supporte 4/8/12 secondes, tandis que sora-2-pro supporte 10/15/25 secondes.
2. Faire correspondre les paramètres : choisissez la bonne durée en fonction du modèle utilisé.
3. Validation des paramètres : vérifiez la validité des paramètres avant l'appel API.
4. Adaptation automatique : utilisez des classes utilitaires pour gérer automatiquement la correspondance entre le modèle et la durée.

Nous vous recommandons d'utiliser APIYI (apiyi.com) pour tester rapidement différentes combinaisons de modèles et de durées afin de trouver la configuration optimale.

Auteur : APIYI Team | Pour plus d'astuces sur le développement IA, visitez apiyi.com

Références :

1. Documentation de l'API OpenAI Sora : Description des paramètres de génération vidéo
   • Lien : platform.openai.com/docs/api-reference/videos
2. Spécifications du modèle OpenAI Sora 2 : Caractéristiques et limitations du modèle
   • Lien : platform.openai.com/docs/models/sora-2
3. Guide des codes d'erreur OpenAI : Gestion des erreurs API
   • Lien : platform.openai.com/docs/guides/error-codes