3 soluções para corrigir o erro de duração de vídeo da API Sora 2: parâmetro seconds invalid_value

Ao chamar a API do Sora 2 para gerar vídeos, se o parâmetro seconds receber um valor não suportado, um erro invalid_value será retornado imediatamente. Este artigo analisa detalhadamente a causa raiz do erro Invalid value: '10'. Supported values are: '4', '8', and '12' e fornece uma solução completa de correção.

Valor Principal: Ao ler este artigo, você dominará as diferenças nos parâmetros de duração entre as versões Padrão e Pro do Sora 2 e aprenderá a configurar corretamente o parâmetro seconds, evitando que suas solicitações de geração de vídeo sejam rejeitadas.

Análise da Causa do Erro no Parâmetro seconds da API Sora 2

Ao chamar a API do Sora 2, se você visualizar a seguinte mensagem de erro:

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

Isso significa que o valor passado para o parâmetro seconds (neste exemplo, 10) não está dentro do intervalo permitido pela API.

Mecanismo de Validação Estrita da Duração na API Sora 2

A API do Sora 2 utiliza uma validação de valor fixo para a duração do vídeo, não suportando qualquer número de segundos:

Por que a API do Sora 2 restringe durações fixas?

Na versão preview do Sora 2, a OpenAI restringiu intencionalmente os valores selecionáveis para a duração do vídeo:

1. Otimização de Recursos Computacionais: Durações fixas facilitam a pré-alocação de recursos de GPU.
2. Consistência de Qualidade: As durações predefinidas foram otimizadas para garantir resultados mais estáveis.
3. Controle de Custos: Limitar o comprimento evita que os usuários gerem custos altos inesperadamente.
4. Características do Modelo: O Sora 2 apresenta melhor consistência entre quadros em durações específicas.

🎯 Dica Importante: Os valores de duração suportados pelas versões Padrão e Pro do Sora 2 são completamente diferentes. Você deve escolher o valor correto com base no modelo utilizado.

Comparação de parâmetros de duração: Sora 2 Padrão vs. Versão Pro

Este é o motivo mais comum de erros: confundir os parâmetros das versões Padrão e Pro.

Durações suportadas no Sora 2 Padrão (sora-2)

Durações suportadas no Sora 2 Pro (sora-2-pro)

Tabela comparativa completa de parâmetros

💡 Sugestão de escolha: Se você precisa de um vídeo de 10 segundos, deve usar o modelo sora-2-pro em vez do sora-2. Recomendamos testar diferentes combinações de modelos e durações através da plataforma APIYI (apiyi.com) para encontrar rapidamente a configuração que melhor atende às suas necessidades.

3 soluções para corrigir o erro 'seconds' na API do Sora 2

Solução 1: Use o valor correto de "seconds" (Versão Standard)

Se você estiver usando o modelo sora-2 na versão Standard, deve utilizar obrigatoriamente os valores 4, 8 ou 12:

import openai

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # Usando a interface unificada da APIYI
)

# ✅ Correto: usando um valor de duração suportado pela versão Standard
response = client.videos.create(
    model="sora-2",           # Modelo versão Standard
    prompt="A cat playing with a ball in a sunny garden",
    seconds=8,                # Só pode ser 4, 8 ou 12
    size="1280x720"
)

print(f"Tarefa de geração de vídeo: {response.id}")

🚀 Início Rápido: Recomendamos usar a plataforma APIYI (apiyi.com) para testar rapidamente a API do Sora 2. A plataforma oferece uma interface pronta para uso e suporte para alternar entre os modelos Standard e Pro.

Solução 2: Mude para a versão Pro para durações maiores

Se você precisar de vídeos com 10, 15 ou 25 segundos, deve alternar para o modelo sora-2-pro:

import openai

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # Usando a interface unificada da APIYI
)

# ✅ Correto: use a versão Pro para obter durações maiores
response = client.videos.create(
    model="sora-2-pro",       # Modelo versão Pro
    prompt="A cinematic sunrise over mountains with birds flying",
    seconds=15,               # A versão Pro suporta 10, 15, 25
    size="1792x1024"          # A versão Pro suporta resoluções mais altas
)

print(f"Tarefa de geração de vídeo: {response.id}")

Solução 3: Implementando uma classe utilitária para adaptação inteligente de duração

Abaixo, apresento uma ferramenta de adaptação de parâmetros de duração de nível de produção, que lida automaticamente com a correspondência entre o modelo e o tempo de vídeo:

import openai
from typing import Literal, Optional

class SoraVideoGenerator:
    """Ferramenta de geração de vídeo da API Sora 2, que adapta automaticamente os parâmetros de duração"""

    # Configurações de duração suportadas por cada 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:
        """Obtém a duração válida mais próxima do valor desejado"""
        if model not in self.MODEL_DURATIONS:
            raise ValueError(f"Modelo não suportado: {model}")

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

        # Se o valor desejado for válido, retorna diretamente
        if desired_seconds in supported:
            return desired_seconds

        # Caso contrário, retorna o valor válido mais próximo
        closest = min(supported, key=lambda x: abs(x - desired_seconds))
        print(f"⚠️ Duração de {desired_seconds}s não suportada, ajustada automaticamente para {closest}s")
        return closest

    def suggest_model(self, desired_seconds: int) -> str:
        """Recomenda o modelo adequado com base na duração desejada"""
        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
    ):
        """
        Cria o vídeo, com suporte para ajuste automático de parâmetros

        Args:
            prompt: comando de descrição do vídeo
            seconds: duração desejada
            model: nome do modelo; se não for especificado, será escolhido automaticamente
            size: resolução
            auto_adjust: se deve ajustar automaticamente parâmetros não suportados
        """
        # Seleção automática de modelo
        if model is None:
            model = self.suggest_model(seconds)
            print(f"📌 Modelo selecionado automaticamente: {model}")

        # Valida e ajusta a duração
        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"O modelo {model} não suporta {seconds}s, "
                f"valores suportados: {supported}"
            )

        # Define a resolução padrão
        if size is None:
            size = self.MODEL_DURATIONS[model]["max_resolution"]

        # Chama a 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
        }

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

# Exemplo 1: Seleção automática de modelo e ajuste de duração
result = generator.create_video(
    prompt="Ocean waves crashing on a beach at sunset",
    seconds=10  # Selecionará automaticamente o sora-2-pro
)
print(f"Resultado da geração: {result}")

# Exemplo 2: Especificando o modelo e ajustando a duração automaticamente
result = generator.create_video(
    prompt="A coffee cup with steam rising",
    seconds=10,          # 10s é inválido para o sora-2
    model="sora-2",      # Especifica a versão Standard
    auto_adjust=True     # Ajustará automaticamente para 12s ou 8s
)
print(f"Resultado da geração: {result}")

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

class SoraModel(Enum):
    """Enumeração de modelos Sora"""
    STANDARD = "sora-2"
    PRO = "sora-2-pro"

@dataclass
class ModelConfig:
    """Configuração do modelo"""
    supported_durations: list[int]
    default_duration: int
    max_resolution: str
    has_audio: bool

class SoraVideoGenerator:
    """
    Ferramenta de geração de vídeo da API Sora 2

    Funcionalidades:
    - Adaptação automática de parâmetros de duração
    - Seleção automática de modelo
    - Validação de parâmetros
    - Mecanismo de tentativa (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:
        """Valida o modelo e retorna a configuração"""
        if model not in self.MODELS:
            available = list(self.MODELS.keys())
            raise ValueError(f"Modelo não suportado: {model}. Modelos disponíveis: {available}")
        return self.MODELS[model]

    def get_valid_duration(self, model: str, desired: int) -> int:
        """Obtém a duração válida mais próxima da desejada"""
        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:
        """Recomenda o modelo com base na duração desejada"""
        # Verifica se a versão Standard suporta
        if seconds in self.MODELS["sora-2"].supported_durations:
            return "sora-2"
        # Verifica se a versão Pro suporta
        if seconds in self.MODELS["sora-2-pro"].supported_durations:
            return "sora-2-pro"
        # Seleção padrão baseada no tempo
        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]:
        """
        Cria o vídeo

        Args:
            prompt: comando de descrição do vídeo
            seconds: duração desejada do vídeo (em segundos)
            model: nome do modelo; None para escolha automática
            size: resolução; None para usar o padrão do modelo
            auto_adjust: se deve ajustar automaticamente parâmetros não suportados

        Returns:
            Dicionário contendo as informações da tarefa

        Raises:
            ValueError: Se os parâmetros forem inválidos e auto_adjust=False
        """
        # Seleção automática de modelo
        if model is None:
            model = self.suggest_model_for_duration(seconds)

        config = self.validate_model(model)

        # Trata os parâmetros de duração
        original_seconds = seconds
        if seconds not in config.supported_durations:
            if auto_adjust:
                seconds = self.get_valid_duration(model, seconds)
                print(f"⚠️ Duração ajustada: {original_seconds}s → {seconds}s")
            else:
                raise ValueError(
                    f"O modelo {model} não suporta {seconds}s. "
                    f"Valores suportados: {config.supported_durations}"
                )

        # Define a resolução
        if size is None:
            size = config.max_resolution

        # Chama a API (com tentativas de repetição)
        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"⏳ Falha na requisição, tentando novamente em {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:
        """Obtém informações de ajuda sobre os parâmetros de duração"""
        info = ["Explicação dos parâmetros de duração da API 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"    Padrão: {config.default_duration}s")
            info.append(f"    Resolução Máxima: {config.max_resolution}")
            info.append(f"    Áudio: {'Suportado' if config.has_audio else 'Não suportado'}")
            info.append("")
        return "\n".join(info)


# Exemplo de uso
if __name__ == "__main__":
    # Imprime informações de ajuda
    print(SoraVideoGenerator.get_duration_info())

    # Inicializa o gerador
    generator = SoraVideoGenerator(api_key="YOUR_API_KEY")

    # Exemplo 1: Permite que a ferramenta escolha a melhor configuração
    result = generator.create_video(
        prompt="A serene lake reflecting autumn trees",
        seconds=10
    )
    print(f"Resultado: {result}")

    # Exemplo 2: Força o uso de um modelo específico
    result = generator.create_video(
        prompt="Quick product showcase",
        seconds=5,
        model="sora-2",
        auto_adjust=True  # 5s será ajustado para 4s
    )
    print(f"Resultado: {result}")

Melhores práticas para o parâmetro de duração da API Sora 2

Escolhendo a duração certa para cada cenário

Relação entre duração e qualidade de geração

De acordo com as recomendações oficiais da OpenAI e experiência prática:

💰 Otimização de custos: Para projetos com orçamento limitado, sugerimos testar o efeito do comando primeiro com uma duração de 4 segundos e gerar versões mais longas somente após a confirmação do resultado. Através da plataforma APIYI (apiyi.com), você pode obter preços mais vantajosos para as chamadas.

Alternativas para vídeos longos

Se você precisar de vídeos com mais de 25 segundos, pode adotar a seguinte estratégia:

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

Perguntas frequentes sobre erros de duração na API Sora 2

# ✅ Correto: usando inteiro
seconds=8

# ❌ Incorreto: usando 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

Tabela de Referência Rápida do Parâmetro seconds na API do Sora 2

Para facilitar a sua consulta rápida, aqui está a tabela completa com os parâmetros de duração:

Erros Comuns e Sugestões de Correção

📌 Dica: As plataformas disponíveis incluem a APIYI (apiyi.com), API oficial da OpenAI, entre outras. Recomendamos usar plataformas com preços mais acessíveis durante a fase de desenvolvimento e testes.

Resumo

O erro no parâmetro seconds da API do Sora 2 é um problema comum que os desenvolvedores enfrentam. A lógica principal para resolver isso é:

1. Distinguir os modelos: O sora-2 suporta 4/8/12 segundos, enquanto o sora-2-pro suporta 10/15/25 segundos.
2. Corresponder os parâmetros: Escolha o valor de duração correto de acordo com o modelo que você está utilizando.
3. Validação de parâmetros: Valide se o parâmetro é válido antes de realizar a chamada da API.
4. Adaptação automática: Use classes utilitárias para lidar automaticamente com a correspondência entre modelo e duração.

Recomendamos testar rapidamente diferentes combinações de modelos e durações através da APIYI (apiyi.com) para encontrar a melhor configuração para o seu projeto.

Autor: APIYI Team | Para mais dicas de desenvolvimento de IA, visite apiyi.com

Referências:

1. Documentação da API OpenAI Sora: Explicação dos parâmetros de geração de vídeo
   • Link: platform.openai.com/docs/api-reference/videos
2. Descrição do Modelo OpenAI Sora 2: Especificações e limitações do modelo
   • Link: platform.openai.com/docs/models/sora-2
3. Guia de Códigos de Erro da OpenAI: Tratamento de erros da API
   • Link: platform.openai.com/docs/guides/error-codes