3 Solusi Perbaikan untuk Mengatasi Kesalahan invalid_value pada Parameter seconds di Sora 2 API

Saat memanggil Sora 2 API untuk menghasilkan video, jika nilai yang dimasukkan pada parameter seconds tidak didukung, sistem akan segera mengembalikan kesalahan invalid_value. Artikel ini akan menganalisis secara mendalam penyebab utama dari kesalahan Invalid value: '10'. Supported values are: '4', '8', and '12' dan memberikan solusi perbaikan yang lengkap.

Nilai Utama: Setelah membaca artikel ini, Anda akan memahami perbedaan parameter durasi antara Sora 2 versi Standar dan Pro, serta belajar cara mengatur parameter seconds dengan benar untuk menghindari penolakan permintaan pembuatan video.

Analisis Penyebab Kesalahan Parameter seconds pada Sora 2 API

Saat Anda memanggil Sora 2 API, jika melihat pesan kesalahan seperti berikut:

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

Ini menandakan bahwa nilai parameter seconds yang Anda masukkan (dalam contoh ini 10) berada di luar rentang yang diizinkan oleh API.

Mekanisme Validasi Ketat Parameter Durasi Sora 2 API

Sora 2 API memiliki validasi nilai tetap untuk durasi video, dan tidak mendukung sembarang jumlah detik:

Mengapa Sora 2 API Membatasi Durasi Tetap?

Dalam versi pratinjau Sora 2, OpenAI sengaja membatasi opsi nilai durasi video karena beberapa alasan:

1. Optimasi Sumber Daya Komputasi: Durasi tetap memudahkan alokasi sumber daya GPU sebelumnya.
2. Konsistensi Kualitas: Durasi prasetel telah dioptimalkan agar hasil generasi lebih stabil.
3. Kontrol Biaya: Membatasi durasi mencegah pengguna secara tidak sengaja menghasilkan biaya tinggi.
4. Karakteristik Model: Sora 2 memiliki konsistensi antar-frame terbaik pada durasi tertentu.

🎯 Catatan Penting: Nilai durasi yang didukung oleh Sora 2 versi Standar dan Pro sangat berbeda, Anda harus memilih nilai parameter yang benar sesuai dengan model yang digunakan.

Perbandingan Parameter Durasi Sora 2 Standar vs Versi Pro

Ini adalah penyebab error yang paling umum: salah membedakan parameter antara versi Standar dan versi Pro.

Durasi yang Didukung Sora 2 Standar (sora-2)

Durasi yang Didukung Sora 2 Pro (sora-2-pro)

Tabel Perbandingan Parameter Lengkap

💡 Saran Pemilihan: Jika Anda membutuhkan video berdurasi 10 detik, Anda harus menggunakan model sora-2-pro, bukan sora-2. Kami menyarankan untuk melakukan pengujian berbagai kombinasi model dan durasi melalui platform APIYI (apiyi.com) untuk menemukan konfigurasi yang paling sesuai dengan kebutuhan Anda.

3 Solusi Perbaikan untuk Error seconds pada Sora 2 API

Solusi 1: Menggunakan Nilai seconds yang Benar (Versi Standar)

Jika kamu menggunakan model sora-2 versi standar, kamu wajib menggunakan nilai 4, 8, atau 12:

import openai

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # Menggunakan interface terpadu APIYI
)

# ✅ Benar: Menggunakan nilai durasi yang didukung versi standar
response = client.videos.create(
    model="sora-2",           # Model versi standar
    prompt="A cat playing with a ball in a sunny garden",
    seconds=8,                # Hanya boleh 4, 8, atau 12
    size="1280x720"
)

print(f"Tugas pembuatan video: {response.id}")

🚀 Mulai Cepat: Direkomendasikan menggunakan platform APIYI (apiyi.com) untuk mencoba Sora 2 API dengan cepat. Platform ini menyediakan interface yang siap pakai dan mendukung perpindahan antara model versi Standar dan Pro.

Solusi 2: Beralih ke Versi Pro untuk Durasi yang Lebih Lama

Jika kamu membutuhkan video berdurasi 10, 15, atau 25 detik, kamu harus beralih ke model sora-2-pro:

import openai

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # Menggunakan interface terpadu APIYI
)

# ✅ Benar: Menggunakan versi Pro untuk durasi yang lebih lama
response = client.videos.create(
    model="sora-2-pro",       # Model versi Pro
    prompt="A cinematic sunrise over mountains with birds flying",
    seconds=15,               # Versi Pro mendukung 10, 15, 25
    size="1792x1024"          # Versi Pro mendukung resolusi yang lebih tinggi
)

print(f"Tugas pembuatan video: {response.id}")

Solusi 3: Implementasi Utility Tool untuk Adaptasi Durasi Cerdas

Berikut adalah utility tool tingkat produksi untuk adaptasi parameter durasi, yang secara otomatis menangani kecocokan antara model dan durasi:

import openai
from typing import Literal, Optional

class SoraVideoGenerator:
    """Alat pembuat video Sora 2 API, mengadaptasi parameter durasi secara otomatis"""

    # Konfigurasi durasi yang didukung model
    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:
        """Mendapatkan durasi valid yang paling mendekati nilai yang diinginkan"""
        if model not in self.MODEL_DURATIONS:
            raise ValueError(f"Model tidak didukung: {model}")

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

        # Jika nilai yang diinginkan valid, langsung kembalikan
        if desired_seconds in supported:
            return desired_seconds

        # Jika tidak, kembalikan nilai valid yang paling mendekati
        closest = min(supported, key=lambda x: abs(x - desired_seconds))
        print(f"⚠️ Durasi {desired_seconds} detik tidak didukung, otomatis disesuaikan menjadi {closest} detik")
        return closest

    def suggest_model(self, desired_seconds: int) -> str:
        """Merekomendasikan model yang sesuai berdasarkan durasi yang diinginkan"""
        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
    ):
        """
        Membuat video, mendukung penyesuaian parameter otomatis

        Args:
            prompt: Petunjuk deskripsi video
            seconds: Durasi yang diinginkan
            model: Nama model, jika tidak ditentukan maka akan dipilih otomatis
            size: Resolusi
            auto_adjust: Apakah akan menyesuaikan parameter yang tidak didukung secara otomatis
        """
        # Pilih model secara otomatis
        if model is None:
            model = self.suggest_model(seconds)
            print(f"📌 Memilih model otomatis: {model}")

        # Validasi dan sesuaikan durasi
        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"Model {model} tidak mendukung {seconds} detik, "
                f"nilai yang didukung: {supported}"
            )

        # Atur resolusi default
        if size is None:
            size = self.MODEL_DURATIONS[model]["max_resolution"]

        # Panggil 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
        }

# Contoh Penggunaan
generator = SoraVideoGenerator(api_key="YOUR_API_KEY")

# Contoh 1: Pilih model otomatis dan sesuaikan durasi
result = generator.create_video(
    prompt="Ocean waves crashing on a beach at sunset",
    seconds=10  # Otomatis memilih sora-2-pro
)
print(f"Hasil pembuatan: {result}")

# Contoh 2: Tentukan model, sesuaikan durasi otomatis
result = generator.create_video(
    prompt="A coffee cup with steam rising",
    seconds=10,          # 10 detik tidak valid untuk sora-2
    model="sora-2",      # Menentukan versi standar
    auto_adjust=True     # Otomatis disesuaikan menjadi 12 detik atau 8 detik
)
print(f"Hasil pembuatan: {result}")

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

class SoraModel(Enum):
    """Enum Model Sora"""
    STANDARD = "sora-2"
    PRO = "sora-2-pro"

@dataclass
class ModelConfig:
    """Konfigurasi Model"""
    supported_durations: list[int]
    default_duration: int
    max_resolution: str
    has_audio: bool

class SoraVideoGenerator:
    """
    Alat Pembuat Video Sora 2 API

    Fitur:
    - Adaptasi parameter durasi otomatis
    - Pemilihan model otomatis
    - Validasi parameter
    - Mekanisme 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:
        """Validasi model dan kembalikan konfigurasi"""
        if model not in self.MODELS:
            available = list(self.MODELS.keys())
            raise ValueError(f"Model tidak didukung: {model}, model tersedia: {available}")
        return self.MODELS[model]

    def get_valid_duration(self, model: str, desired: int) -> int:
        """Mendapatkan durasi valid yang paling mendekati nilai yang diinginkan"""
        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:
        """Merekomendasikan model berdasarkan durasi yang diinginkan"""
        # Cek apakah versi standar mendukung
        if seconds in self.MODELS["sora-2"].supported_durations:
            return "sora-2"
        # Cek apakah versi Pro mendukung
        if seconds in self.MODELS["sora-2-pro"].supported_durations:
            return "sora-2-pro"
        # Default pilih berdasarkan durasi
        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]:
        """
        Membuat video

        Args:
            prompt: Petunjuk deskripsi video
            seconds: Durasi video yang diinginkan (detik)
            model: Nama model, jika None maka akan dipilih otomatis
            size: Resolusi, jika None maka gunakan nilai default model
            auto_adjust: Apakah akan menyesuaikan parameter yang tidak didukung secara otomatis

        Returns:
            Dictionary berisi informasi tugas

        Raises:
            ValueError: Parameter tidak valid dan auto_adjust=False
        """
        # Pilih model secara otomatis
        if model is None:
            model = self.suggest_model_for_duration(seconds)

        config = self.validate_model(model)

        # Menangani parameter durasi
        original_seconds = seconds
        if seconds not in config.supported_durations:
            if auto_adjust:
                seconds = self.get_valid_duration(model, seconds)
                print(f"⚠️ Durasi telah disesuaikan: {original_seconds} detik → {seconds} detik")
            else:
                raise ValueError(
                    f"Model {model} tidak mendukung {seconds} detik, "
                    f"nilai yang didukung: {config.supported_durations}"
                )

        # Mengatur resolusi
        if size is None:
            size = config.max_resolution

        # Memanggil API (dengan retry)
        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"⏳ Permintaan gagal, mencoba lagi dalam {wait_time} detik...")
                    import time
                    time.sleep(wait_time)

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

    @staticmethod
    def get_duration_info() -> str:
        """Mendapatkan informasi bantuan parameter durasi"""
        info = ["Keterangan parameter durasi Sora 2 API:", ""]
        for model, config in SoraVideoGenerator.MODELS.items():
            durations = ", ".join(map(str, config.supported_durations))
            info.append(f"  {model}: {durations} detik")
            info.append(f"    Default: {config.default_duration} detik")
            info.append(f"    Resolusi Maksimum: {config.max_resolution}")
            info.append(f"    Audio: {'Mendukung' if config.has_audio else 'Tidak Mendukung'}")
            info.append("")
        return "\n".join(info)


# Contoh Penggunaan
if __name__ == "__main__":
    # Cetak informasi bantuan
    print(SoraVideoGenerator.get_duration_info())

    # Inisialisasi generator
    generator = SoraVideoGenerator(api_key="YOUR_API_KEY")

    # Contoh 1: Biarkan tool memilih konfigurasi terbaik secara otomatis
    result = generator.create_video(
        prompt="A serene lake reflecting autumn trees",
        seconds=10
    )
    print(f"Hasil: {result}")

    # Contoh 2: Paksa menggunakan model tertentu
    result = generator.create_video(
        prompt="Quick product showcase",
        seconds=5,
        model="sora-2",
        auto_adjust=True  # 5 detik akan disesuaikan menjadi 4 detik
    )
    print(f"Hasil: {result}")

Praktik Terbaik Parameter Durasi Sora 2 API

Memilih Durasi yang Tepat Berdasarkan Skenario

Hubungan Antara Durasi dan Kualitas Generasi

Berdasarkan saran resmi OpenAI dan pengalaman pengujian langsung:

💰 Optimasi Biaya: Untuk proyek yang sensitif terhadap anggaran, disarankan untuk menguji efek petunjuk dengan durasi 4 detik terlebih dahulu. Setelah merasa puas, barulah generate versi yang lebih panjang. Melalui platform APIYI apiyi.com, Anda bisa mendapatkan harga panggilan API yang lebih terjangkau.

Solusi Alternatif untuk Video Berdurasi Panjang

Jika Anda membutuhkan video lebih dari 25 detik, Anda dapat menggunakan strategi berikut:

def create_long_video_segments(generator, prompt_segments, model="sora-2"):
    """
    Membuat skema pembuatan video panjang secara bertahap

    Args:
        generator: Instance SoraVideoGenerator
        prompt_segments: Daftar petunjuk tiap segmen
        model: Model yang digunakan
    """
    results = []
    config = generator.MODELS[model]
    max_duration = max(config.supported_durations)

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

    return results

# Contoh penggunaan: Menghasilkan video 36 detik (3 x 12 detik)
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)
# Selanjutnya gunakan FFmpeg untuk menggabungkan segmen

Tanya Jawab Masalah Error Durasi Sora 2 API

# ✅ Benar: Menggunakan integer
seconds=8

# ❌ Salah: Menggunakan 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"Durasi yang didukung {model}: {valid}")
    return True

Lembar Referensi Cepat Parameter seconds API Sora 2

Untuk memudahkan pencarian cepat, berikut adalah lembar referensi lengkap untuk parameter durasi:

Nilai Kesalahan Umum dan Saran Perbaikan

📌 Tips: Platform yang tersedia mencakup APIYI (apiyi.com), API resmi OpenAI, dll. Disarankan untuk menggunakan platform dengan harga yang lebih terjangkau selama tahap pengembangan dan pengujian.

Kesimpulan

Error pada parameter seconds di API Sora 2 adalah masalah yang sering ditemui pengembang. Ide solusi utamanya adalah:

1. Bedakan model: sora-2 mendukung 4/8/12 detik, sedangkan sora-2-pro mendukung 10/15/25 detik.
2. Cocokkan parameter: Pilih nilai durasi yang tepat sesuai dengan model yang Anda gunakan.
3. Validasi parameter: Verifikasi validitas parameter sebelum melakukan pemanggilan API.
4. Adaptasi otomatis: Gunakan kelas utilitas (utility class) untuk menangani pencocokan model dan durasi secara otomatis.

Direkomendasikan untuk mencoba melalui APIYI (apiyi.com) guna menguji berbagai kombinasi model dan durasi dengan cepat demi menemukan konfigurasi terbaik.

Penulis: APIYI Team | Untuk tips pengembangan AI lainnya, silakan kunjungi apiyi.com

Referensi:

1. Dokumentasi API OpenAI Sora: Penjelasan Parameter Pembuatan Video
   • Tautan: platform.openai.com/docs/api-reference/videos
2. Penjelasan Model OpenAI Sora 2: Spesifikasi dan Batasan Model
   • Tautan: platform.openai.com/docs/models/sora-2
3. Panduan Kode Error OpenAI: Penanganan Error API
   • Tautan: platform.openai.com/docs/guides/error-codes