3 soluciones para corregir el error de duración de video de Sora 2 API: error invalid_value en el parámetro seconds

Al llamar a la API de Sora 2 para generar videos, si el parámetro seconds recibe un valor no admitido, se devolverá inmediatamente un error de tipo invalid_value. En este artículo analizaremos detalladamente la causa raíz del error Invalid value: '10'. Supported values are: '4', '8', and '12' y proporcionaremos una solución completa para corregirlo.

Valor principal: Al finalizar esta lectura, dominarás las diferencias en los parámetros de duración entre la versión estándar de Sora 2 y la versión Pro, y aprenderás a configurar correctamente el parámetro seconds para evitar que tus solicitudes de generación de video sean rechazadas.

Análisis de la causa del error en el parámetro seconds de la API de Sora 2

Cuando llamas a la API de Sora 2 y ves el siguiente mensaje de error:

{
  "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"
    }
  }
}

Esto indica que el valor proporcionado para el parámetro seconds (en este caso, 10) no se encuentra dentro del rango permitido por la API.

Mecanismo de validación estricta del parámetro de duración en la API de Sora 2

La API de Sora 2 aplica una validación de valores fijos para la duración del video y no admite cualquier cantidad de segundos:

¿Por qué la API de Sora 2 limita la duración a valores fijos?

OpenAI ha limitado intencionalmente los valores opcionales para la duración del video en la versión preliminar de Sora 2 por las siguientes razones:

1. Optimización de recursos de cómputo: Las duraciones fijas facilitan la preasignación de recursos de GPU.
2. Consistencia en la calidad: Las duraciones preestablecidas están optimizadas para que el resultado generado sea más estable.
3. Control de costes: Limitar la longitud evita que los usuarios generen accidentalmente cargos elevados.
4. Características del modelo: Sora 2 ofrece la mejor consistencia entre fotogramas bajo duraciones específicas.

🎯 Nota importante: Los valores de duración admitidos por la versión estándar de Sora 2 y la versión Pro son completamente diferentes. Debes seleccionar el valor correcto según el modelo que estés utilizando.

Comparativa de parámetros de duración: Sora 2 Estándar vs. Pro

Esta es la causa más común de errores: confundir los parámetros de la versión estándar con los de la versión Pro.

Duraciones admitidas en Sora 2 Estándar (sora-2)

Duraciones admitidas en Sora 2 Pro (sora-2-pro)

Tabla comparativa completa de parámetros

💡 Sugerencia: Si necesitas un video de 10 segundos, debes usar el modelo sora-2-pro en lugar de sora-2. Te recomendamos probar diferentes combinaciones de modelos y duraciones a través de la plataforma APIYI apiyi.com para encontrar rápidamente la configuración que mejor se adapte a tus necesidades.

3 soluciones para el error de 'seconds' en la API de Sora 2

Solución 1: Usa el valor de seconds correcto (Versión Estándar)

Si estás usando el modelo estándar sora-2, debes usar 4, 8 o 12:

import openai

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # Usando la interfaz unificada de APIYI
)

# ✅ Correcto: usa un valor de duración compatible con la versión estándar
response = client.videos.create(
    model="sora-2",           # Modelo versión estándar
    prompt="A cat playing with a ball in a sunny garden",
    seconds=8,                # Solo puede ser 4, 8 o 12
    size="1280x720"
)

print(f"Tarea de generación de video: {response.id}")

🚀 Inicio rápido: Te recomendamos usar la plataforma APIYI (apiyi.com) para probar rápidamente la API de Sora 2. Este sitio ofrece una interfaz lista para usar y permite alternar fácilmente entre los modelos Estándar y Pro.

Solución 2: Cambia a la versión Pro para duraciones más largas

Si necesitas videos de 10, 15 o 25 segundos, debes cambiar al modelo sora-2-pro:

import openai

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # Usando la interfaz unificada de APIYI
)

# ✅ Correcto: usa la versión Pro para obtener mayor duración
response = client.videos.create(
    model="sora-2-pro",       # Modelo versión Pro
    prompt="A cinematic sunrise over mountains with birds flying",
    seconds=15,               # La versión Pro admite 10, 15, 25
    size="1792x1024"          # La versión Pro admite resoluciones más altas
)

print(f"Tarea de generación de video: {response.id}")

Solución 3: Implementa una clase de utilidad para la adaptación inteligente de la duración

Aquí tienes una herramienta de adaptación de parámetros de duración de nivel de producción que gestiona automáticamente la coincidencia entre el modelo y la duración:

import openai
from typing import Literal, Optional

class SoraVideoGenerator:
    """Herramienta de generación de video para la API de Sora 2, adapta automáticamente los parámetros de duración"""

    # Configuración de duraciones admitidas por el modelo
    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:
        """Obtiene la duración válida más cercana al valor deseado"""
        if model not in self.MODEL_DURATIONS:
            raise ValueError(f"Modelo no compatible: {model}")

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

        # Si el valor deseado es válido, devolverlo directamente
        if desired_seconds in supported:
            return desired_seconds

        # De lo contrario, devolver el valor válido más cercano
        closest = min(supported, key=lambda x: abs(x - desired_seconds))
        print(f"⚠️ La duración de {desired_seconds}s no es compatible, se ajustó automáticamente a {closest}s")
        return closest

    def suggest_model(self, desired_seconds: int) -> str:
        """Recomienda un modelo adecuado según la duración deseada"""
        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
    ):
        """
        Crea un video, admite el ajuste automático de parámetros

        Args:
            prompt: Descripción del video (indicación)
            seconds: Duración deseada
            model: Nombre del modelo, se selecciona automáticamente si no se especifica
            size: Resolución
            auto_adjust: Si se deben ajustar automáticamente los parámetros no compatibles
        """
        # Selección automática del modelo
        if model is None:
            model = self.suggest_model(seconds)
            print(f"📌 Modelo seleccionado automáticamente: {model}")

        # Validar y ajustar duración
        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"El modelo {model} no admite {seconds}s, "
                f"valores admitidos: {supported}"
            )

        # Establecer resolución por defecto
        if size is None:
            size = self.MODEL_DURATIONS[model]["max_resolution"]

        # Llamar a la 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
        }

# Ejemplo de uso
generator = SoraVideoGenerator(api_key="YOUR_API_KEY")

# Ejemplo 1: Selección automática de modelo y ajuste de duración
result = generator.create_video(
    prompt="Ocean waves crashing on a beach at sunset",
    seconds=10  # Seleccionará automáticamente sora-2-pro
)
print(f"Resultado de generación: {result}")

# Ejemplo 2: Especificar modelo, ajuste automático de duración
result = generator.create_video(
    prompt="A coffee cup with steam rising",
    seconds=10,          # 10s no es válido para sora-2
    model="sora-2",      # Especificar versión estándar
    auto_adjust=True     # Se ajustará automáticamente a 12s u 8s
)
print(f"Resultado de generación: {result}")

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

class SoraModel(Enum):
    """Enumeración de modelos Sora"""
    STANDARD = "sora-2"
    PRO = "sora-2-pro"

@dataclass
class ModelConfig:
    """Configuración del modelo"""
    supported_durations: list[int]
    default_duration: int
    max_resolution: str
    has_audio: bool

class SoraVideoGenerator:
    """
    Herramienta de generación de video para la API de Sora 2

    Funciones:
    - Adaptación automática de parámetros de duración
    - Selección automática de modelo
    - Validación de parámetros
    - Mecanismo de reintento
    """

    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:
        """Valida el modelo y devuelve su configuración"""
        if model not in self.MODELS:
            available = list(self.MODELS.keys())
            raise ValueError(f"Modelo no compatible: {model}. Modelos disponibles: {available}")
        return self.MODELS[model]

    def get_valid_duration(self, model: str, desired: int) -> int:
        """Obtiene la duración válida más cercana al valor deseado"""
        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:
        """Recomienda un modelo según la duración deseada"""
        # Verificar si la versión estándar es compatible
        if seconds in self.MODELS["sora-2"].supported_durations:
            return "sora-2"
        # Verificar si la versión Pro es compatible
        if seconds in self.MODELS["sora-2-pro"].supported_durations:
            return "sora-2-pro"
        # Selección por defecto basada en la duración
        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]:
        """
        Crea un video

        Args:
            prompt: Indicación con la descripción del video
            seconds: Duración deseada del video (en segundos)
            model: Nombre del modelo, None para selección automática
            size: Resolución, None para usar el valor por defecto del modelo
            auto_adjust: Si se deben ajustar automáticamente los parámetros no compatibles

        Returns:
            Diccionario con la información de la tarea

        Raises:
            ValueError: Si los parámetros no son válidos y auto_adjust=False
        """
        # Selección automática del modelo
        if model is None:
            model = self.suggest_model_for_duration(seconds)

        config = self.validate_model(model)

        # Manejo de parámetros de duración
        original_seconds = seconds
        if seconds not in config.supported_durations:
            if auto_adjust:
                seconds = self.get_valid_duration(model, seconds)
                print(f"⚠️ Duración ajustada: {original_seconds}s → {seconds}s")
            else:
                raise ValueError(
                    f"El modelo {model} no admite {seconds}s, "
                    f"valores admitidos: {config.supported_durations}"
                )

        # Establecer resolución
        if size is None:
            size = config.max_resolution

        # Llamada a la API (con reintentos)
        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"⏳ Falló la solicitud, reintentando en {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:
        """Obtiene información de ayuda sobre los parámetros de duración"""
        info = ["Descripción de los parámetros de duración de la API de Sora 2:", ""]
        for model, config in SoraVideoGenerator.MODELS.items():
            durations = ", ".join(map(str, config.supported_durations))
            info.append(f"  {model}: {durations} segundos")
            info.append(f"    Por defecto: {config.default_duration}s")
            info.append(f"    Resolución máxima: {config.max_resolution}")
            info.append(f"    Audio: {'Compatible' if config.has_audio else 'No compatible'}")
            info.append("")
        return "\n".join(info)


# Ejemplo de uso
if __name__ == "__main__":
    # Imprimir información de ayuda
    print(SoraVideoGenerator.get_duration_info())

    # Inicializar el generador
    generator = SoraVideoGenerator(api_key="YOUR_API_KEY")

    # Ejemplo 1: Dejar que la herramienta elija la mejor configuración
    result = generator.create_video(
        prompt="A serene lake reflecting autumn trees",
        seconds=10
    )
    print(f"Resultado: {result}")

    # Ejemplo 2: Forzar el uso de un modelo específico
    result = generator.create_video(
        prompt="Quick product showcase",
        seconds=5,
        model="sora-2",
        auto_adjust=True  # 5s se ajustará a 4s
    )
    print(f"Resultado: {result}")

Mejores prácticas para el parámetro de duración de la API de Sora 2

Elegir la duración adecuada según el escenario

Relación entre la duración y la calidad de generación

Según las sugerencias oficiales de OpenAI y la experiencia práctica:

💰 Optimización de costos: Para proyectos con presupuesto limitado, se recomienda probar primero el efecto de la indicación con una duración de 4 segundos y, una vez satisfecho, generar la versión más larga. A través de la plataforma APIYI (apiyi.com) puedes obtener precios de llamada más económicos.

Alternativas para videos largos

Si necesitas un video que supere los 25 segundos, puedes adoptar la siguiente estrategia:

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 拼接片段

Preguntas frecuentes sobre errores de duración en la API de Sora 2

# ✅ Correcto: usar entero
seconds=8

# ❌ Incorrecto: usar string
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"{model} 支持的时长: {valid}")
    return True

Tabla de referencia rápida de parámetros seconds en la API de Sora 2

Para facilitar una consulta rápida, aquí tienes la tabla completa de parámetros de duración:

Valores de error comunes y sugerencias de corrección

📌 Consejo: Las plataformas disponibles incluyen APIYI (apiyi.com), la API oficial de OpenAI, entre otras. Se recomienda utilizar plataformas con precios más competitivos durante la fase de desarrollo y pruebas.

Resumen

El error en el parámetro seconds de la API de Sora 2 es un problema frecuente para los desarrolladores. La estrategia principal para solucionarlo consiste en:

1. Diferenciar los modelos: sora-2 admite 4, 8 o 12 segundos, mientras que sora-2-pro admite 10, 15 o 25 segundos.
2. Hacer coincidir los parámetros: selecciona el valor de duración correcto basándote en el modelo que estés utilizando.
3. Validación de parámetros: verifica que los parámetros sean válidos antes de realizar la llamada a la API.
4. Adaptación automática: implementa clases de utilidad o funciones que gestionen automáticamente la compatibilidad entre el modelo y la duración seleccionada.

Te recomendamos utilizar APIYI (apiyi.com) para probar rápidamente diferentes combinaciones de modelos y duraciones hasta encontrar la configuración que mejor se adapte a tus necesidades.

Autor: Equipo de APIYI | Para más trucos sobre desarrollo con IA, visita apiyi.com

Referencias:

1. Documentación de la API de OpenAI Sora: Descripción de los parámetros de generación de vídeo.
   • Enlace: platform.openai.com/docs/api-reference/videos
2. Especificaciones del modelo OpenAI Sora 2: Detalles y limitaciones del modelo.
   • Enlace: platform.openai.com/docs/models/sora-2
3. Guía de códigos de error de OpenAI: Manejo de errores de la API.
   • Enlace: platform.openai.com/docs/guides/error-codes