Does Sora 2 Pro generate synchronized audio with video?

Ya, Sora 2 Pro menghasilkan frame video bersamaan dengan audio tersinkron termasuk dialog, suara ambien, dan efek suara—bukan diproduksi secara terpisah melainkan sebagai satu keluaran terpadu.

What resolution and duration does Sora 2 Pro support?

Sora 2 Pro mendukung resolusi hingga 1080p. Sora 2 Pro dioptimalkan untuk klip pendek berkualitas tinggi, biasanya dalam rentang beberapa detik hingga belasan detik untuk fidelitas maksimal.

How does Sora 2 Pro differ from standard Sora 2?

Sora 2 Pro disetel untuk fidelitas visual yang lebih tinggi, mampu menangani pengambilan yang lebih sulit (gerakan kompleks, oklusi, interaksi fisik), dan mempertahankan konsistensi per adegan yang lebih lama—dengan konsekuensi waktu render yang lebih panjang.

Can Sora 2 Pro use reference images to guide video generation?

Ya, Sora 2 Pro mendukung alur kerja input_reference di mana gambar JPEG/PNG/WEBP berfungsi sebagai jangkar komposisi untuk memandu frame awal atau gaya video yang dihasilkan.

Does Sora 2 Pro support likeness injection (cameos)?

Ya, Sora 2 Pro dapat menyisipkan kemiripan pengguna yang telah ditangkap ke dalam adegan yang dihasilkan. OpenAI memiliki alur kerja persetujuan bawaan dan mekanisme pencabutan untuk menangani risiko privasi dan penyalahgunaan.

How long does Sora 2 Pro take to render a video?

Uji tolok ukur menunjukkan Sora 2 Pro rata-rata sekitar 2.1 menit untuk klip 1080p berdurasi 20 detik. Versi Pro memprioritaskan kualitas dibanding kecepatan, jadi harapkan waktu render yang lebih lama daripada Sora 2 standar.

What physics improvements does Sora 2 Pro offer?

Sora 2 Pro meningkatkan permanensi objek dan fidelitas gerak—momentum, daya apung, dan interaksi fisik tampak lebih realistis dengan lebih sedikit artefak 'teleporting' yang umum pada model video sebelumnya.

When should I choose Sora 2 Pro over Google Veo 3?

Pilih Sora 2 Pro untuk integrasi ekosistem OpenAI, penyisipan kemiripan, dan adegan fisik yang kompleks. Veo 3 mungkin menawarkan pembuatan yang lebih cepat dan harga yang berbeda—evaluasilah berdasarkan kebutuhan latensi dan anggaran Anda.

Kimi K3 is now live on CometAPI →

Sora 2 Pro

Per Detik:$0.24

Dirilis:May 31, 2026

Sora 2 Pro adalah model pembuatan media kami yang paling canggih dan kuat, mampu menghasilkan video dengan audio tersinkronisasi. Model ini dapat membuat klip video yang detail dan dinamis dari bahasa alami atau gambar.

Baru

Penggunaan komersial

Playground untuk Sora 2 Pro

Jelajahi Playground Sora 2 Pro — lingkungan interaktif untuk menguji model dan menjalankan kueri secara real-time. Coba prompt, sesuaikan parameter, dan iterasi secara instan untuk mempercepat pengembangan dan memvalidasi kasus penggunaan.

Fitur utama

Generasi multimodal (video + audio) — Sora-2-Pro menghasilkan frame video bersama audio yang tersinkron (dialog, suara latar, SFX) alih-alih memproduksi video dan audio secara terpisah.
Fidelitas lebih tinggi / tingkat “Pro” — dioptimalkan untuk fidelitas visual yang lebih tinggi, bidikan yang lebih sulit (gerak kompleks, oklusi, dan interaksi fisik), serta konsistensi per adegan yang lebih lama dibanding Sora-2 (non-Pro). Proses render mungkin memakan waktu lebih lama daripada model Sora-2 standar.
Fleksibilitas input — mendukung prompt teks murni, dan dapat menerima frame input gambar atau gambar referensi untuk memandu komposisi (alur kerja input_reference).
Cameo / penyisipan kemiripan — dapat menyisipkan kemiripan pengguna yang ditangkap ke dalam adegan yang dihasilkan dengan alur persetujuan di aplikasi.
Plausibilitas fisik: peningkatan kepermanenan objek dan kesetiaan gerak (misalnya momentum, daya apung), mengurangi artefak “teleportasi” yang tidak realistis yang umum pada sistem sebelumnya.
Kontrolabilitas: mendukung prompt terstruktur dan arahan tingkat bidikan sehingga kreator dapat menentukan kamera, pencahayaan, dan urutan multi-bidikan.

Rincian teknis & antarmuka integrasi

Model family: Sora 2 (dasar) dan Sora 2 Pro (varian berkualitas tinggi).
Modalitas input: prompt teks, referensi gambar, dan rekaman pendek video/audio cameo untuk kemiripan.
Modalitas output: video terenkode (dengan audio) — parameter tersedia melalui endpoint /v1/videos (pemilihan model via model: "sora-2-pro"). Permukaan API mengikuti keluarga endpoint video OpenAI untuk operasi create/retrieve/list/delete.

Pelatihan & arsitektur (ringkasan publik): OpenAI menggambarkan Sora 2 dilatih pada data video skala besar dengan pascapelatihan untuk meningkatkan simulasi dunia; spesifikasinya (ukuran model, dataset yang tepat, dan tokenisasi) tidak dijabarkan secara publik baris demi baris. Harapkan komputasi berat, tokenizer/arsitektur video khusus, dan komponen penyelarasan multimodal.

Endpoint API & alur kerja: menunjukkan alur kerja berbasis job: ajukan permintaan pembuatan POST (model="sora-2-pro"), terima id job atau lokasi, lalu polling atau tunggu hingga selesai dan unduh berkas hasilnya. Parameter umum dalam contoh yang dipublikasikan mencakup prompt, seconds/duration, size/resolution, dan input_reference untuk permulaan berpandu gambar.

Parameter umum :

model: "sora-2-pro"
prompt: deskripsi adegan dalam bahasa natural, opsional dengan isyarat dialog
seconds / duration: panjang klip target (Pro mendukung kualitas tertinggi dalam durasi yang tersedia)
size / resolution: laporan komunitas menunjukkan Pro mendukung hingga 1080p dalam banyak kasus penggunaan.

Input konten: berkas gambar (JPEG/PNG/WEBP) dapat disuplai sebagai frame atau referensi; saat digunakan, gambar sebaiknya cocok dengan resolusi target dan berfungsi sebagai jangkar komposisi.

Perilaku render: Pro dioptimalkan untuk memprioritaskan koherensi antar frame dan fisika yang realistis; ini biasanya berarti waktu komputasi lebih lama dan biaya per klip lebih tinggi dibanding varian non-Pro.

Kinerja benchmark

Kekuatan kualitatif: OpenAI meningkatkan realisme, konsistensi fisika, dan audio tersinkron** dibanding model video sebelumnya. Hasil VBench lain menunjukkan Sora-2 dan turunannya berada di puncak atau dekat puncak model tertutup kontemporer dan koherensi temporal.

Waktu/throughput independen (contoh uji): Sora-2-Pro rata-rata ~2.1 menit untuk klip 20 detik 1080p dalam satu perbandingan, sementara pesaing (Runway Gen-3 Alpha Turbo) lebih cepat (~1.7 menit) pada tugas yang sama — trade-off antara kualitas vs latensi render dan optimasi platform.

Keterbatasan (praktis & keselamatan)

Fisik/konsistensi tidak sempurna — meningkat tetapi tidak tanpa cacat; artefak, gerakan tidak alami, atau kesalahan sinkronisasi audio masih bisa terjadi.
Batasan durasi & komputasi — klip panjang intensif komputasi; banyak alur kerja praktis membatasi klip ke durasi pendek (mis. detik satu digit hingga belasan detik untuk keluaran berkualitas tinggi).
Risiko privasi / persetujuan — penyisipan kemiripan (“cameo”) meningkatkan risiko persetujuan dan mis-/disinformasi; OpenAI memiliki kontrol keselamatan dan mekanisme pencabutan eksplisit di aplikasi, tetapi integrasi yang bertanggung jawab diperlukan.
Biaya & latensi — render kualitas Pro bisa lebih mahal dan lebih lambat daripada model yang lebih ringan atau pesaing; perhitungkan penagihan per detik/per render dan antrean.
Penyaringan konten keselamatan — pembuatan konten berbahaya atau berhak cipta dibatasi; model dan platform mencakup lapisan keselamatan dan moderasi.

Kasus penggunaan tipikal dan yang direkomendasikan

Kasus penggunaan:

Prototipe pemasaran & iklan — membuat proof-of-concept sinematik dengan cepat.
Previsualisasi — storyboard, pemblokiran kamera, visualisasi bidikan.
Konten sosial pendek — klip bergaya dengan dialog dan SFX tersinkron.
Cara mengakses API Sora 2 Pro

Langkah 1: Daftar untuk Kunci API

Masuk ke cometapi.com. Jika Anda belum menjadi pengguna kami, silakan daftar terlebih dahulu. Masuk ke CometAPI console. Dapatkan kredensial akses kunci API untuk antarmuka. Klik “Add Token” pada API token di pusat pribadi, dapatkan kunci token: sk-xxxxx dan kirimkan.

cometapi-key

Langkah 2: Kirim Permintaan ke Sora 2 Pro API

Pilih endpoint “sora-2-pro” untuk mengirim permintaan API dan setel badan permintaan. Metode permintaan dan badan permintaan diperoleh dari dokumen API situs kami. Situs kami juga menyediakan pengujian Apifox untuk kenyamanan Anda. Ganti <YOUR_API_KEY> dengan kunci CometAPI Anda yang sebenarnya dari akun Anda. base url is office Create video

Masukkan pertanyaan atau permintaan Anda ke kolom content—itulah yang akan direspons oleh model. Proses respons API untuk mendapatkan jawaban yang dihasilkan.

Langkah 3: Ambil dan Verifikasi Hasil

Proses respons API untuk mendapatkan jawaban yang dihasilkan. Setelah diproses, API merespons dengan status tugas dan data keluaran.

Pelatihan internal / simulasi — menghasilkan visual skenario untuk penelitian RL atau robotika (dengan kehati-hatian).
Produksi kreatif — ketika dikombinasikan dengan pengeditan manusia (menjahit klip pendek, grading, mengganti audio).

FAQ

Harga untuk Sora 2 Pro

Jelajahi harga kompetitif untuk Sora 2 Pro, dirancang untuk berbagai anggaran dan kebutuhan penggunaan. Paket fleksibel kami memastikan Anda hanya membayar untuk apa yang Anda gunakan, memudahkan untuk meningkatkan skala seiring berkembangnya kebutuhan Anda. Temukan bagaimana Sora 2 Pro dapat meningkatkan proyek Anda sambil menjaga biaya tetap terkendali.

Model Name	Tags	Orientation	Resolution	Price
sora-2-pro	videos	Portrait	720x1280	$0.24 / sec
sora-2-pro	videos	Landscape	1280x720	$0.24 / sec
sora-2-pro	videos	Portrait (High Res)	1024x1792	$0.40 / sec
sora-2-pro	videos	Landscape (High Res)	1792x1024	$0.40 / sec
sora-2-pro-all	-	Universal / All	-	$0.80000

Kode contoh dan API untuk Sora 2 Pro

Sora-2-pro adalah model generatif video+audio unggulan dari OpenAI yang dirancang untuk membuat klip video pendek yang sangat realistis dengan dialog tersinkron, efek suara, dan simulasi fisika dan dunia yang lebih kuat dibandingkan model video sebelumnya. Model ini diposisikan sebagai varian “Pro” berkualitas lebih tinggi yang tersedia bagi pengguna berbayar dan melalui API untuk pembuatan terprogram. Model ini menekankan kontrolabilitas, koherensi temporal, dan sinkronisasi audio untuk skenario penggunaan sinematik dan sosial.

POST

/v1/videos

# Create a video with sora-2-pro
# Step 1: Submit the video generation request
echo "Submitting video generation request..."
response=$(curl -s https://api.cometapi.com/v1/videos \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -F "model=sora-2-pro" \
  -F "prompt=A calico cat playing a piano on stage")

echo "Response: $response"

# Extract video_id from response (handle JSON with spaces like "id": "xxx")
video_id=$(echo "$response" | tr -d '
' | sed 's/.*"id"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/')
echo "Video ID: $video_id"

# Step 2: Poll for progress until 100%
echo ""
echo "Checking video generation progress..."
while true; do
  status_response=$(curl -s "https://api.cometapi.com/v1/videos/$video_id" \
    -H "Authorization: Bearer $COMETAPI_KEY")

  # Parse progress from "progress": "0%" format
  progress=$(echo "$status_response" | grep -o '"progress":"[^"]*"' | head -1 | sed 's/"progress":"//;s/"$//')
  # Parse status from the outer level
  status=$(echo "$status_response" | grep -o '"status":"[^"]*"' | head -1 | sed 's/"status":"//;s/"$//')

  echo "Progress: $progress, Status: $status"

  if [ "$progress" = "100%" ]; then
    echo "Video generation completed!"
    break
  fi

  if [ "$status" = "FAILURE" ] || [ "$status" = "failed" ]; then
    echo "Video generation failed!"
    echo "$status_response"
    exit 1
  fi

  sleep 10
done

# Step 3: Download the video to output directory
echo ""
echo "Downloading video to ./output/$video_id.mp4..."
mkdir -p ./output
curl -s "https://api.cometapi.com/v1/videos/$video_id/content" \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -o "./output/$video_id.mp4"

if [ -f "./output/$video_id.mp4" ]; then
  echo "Video saved to ./output/$video_id.mp4"
  ls -la "./output/$video_id.mp4"
else
  echo "Failed to download video"
  exit 1
fi

Curl Code Example

# Create a video with sora-2-pro
# Step 1: Submit the video generation request
echo "Submitting video generation request..."
response=$(curl -s https://api.cometapi.com/v1/videos \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -F "model=sora-2-pro" \
  -F "prompt=A calico cat playing a piano on stage")

echo "Response: $response"

# Extract video_id from response (handle JSON with spaces like "id": "xxx")
video_id=$(echo "$response" | tr -d '\n' | sed 's/.*"id"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/')
echo "Video ID: $video_id"

# Step 2: Poll for progress until 100%
echo ""
echo "Checking video generation progress..."
while true; do
  status_response=$(curl -s "https://api.cometapi.com/v1/videos/$video_id" \
    -H "Authorization: Bearer $COMETAPI_KEY")
  
  # Parse progress from "progress": "0%" format
  progress=$(echo "$status_response" | grep -o '"progress":"[^"]*"' | head -1 | sed 's/"progress":"//;s/"$//')
  # Parse status from the outer level
  status=$(echo "$status_response" | grep -o '"status":"[^"]*"' | head -1 | sed 's/"status":"//;s/"$//')
  
  echo "Progress: $progress, Status: $status"
  
  if [ "$progress" = "100%" ]; then
    echo "Video generation completed!"
    break
  fi
  
  if [ "$status" = "FAILURE" ] || [ "$status" = "failed" ]; then
    echo "Video generation failed!"
    echo "$status_response"
    exit 1
  fi
  
  sleep 10
done

# Step 3: Download the video to output directory
echo ""
echo "Downloading video to ./output/$video_id.mp4..."
mkdir -p ./output
curl -s "https://api.cometapi.com/v1/videos/$video_id/content" \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -o "./output/$video_id.mp4"

if [ -f "./output/$video_id.mp4" ]; then
  echo "Video saved to ./output/$video_id.mp4"
  ls -la "./output/$video_id.mp4"
else
  echo "Failed to download video"
  exit 1
fi

Python Code Example

# Create a video with sora-2-pro using raw HTTP requests
import os
import time
import requests

api_key = os.environ.get("COMETAPI_KEY")
base_url = "https://api.cometapi.com/v1"

headers = {"Authorization": f"Bearer {api_key}"}

# Step 1: Submit the video generation request
print("Submitting video generation request...")
response = requests.post(
    f"{base_url}/videos",
    headers=headers,
    files={
        "model": (None, "sora-2-pro"),
        "prompt": (None, "A calico cat playing a piano on stage"),
    },
)

result = response.json()
print(f"Response: {result}")

video_id = result.get("id")
print(f"Video ID: {video_id}")

# Step 2: Poll for progress until 100%
print("\nChecking video generation progress...")
while True:
    try:
        status_response = requests.get(f"{base_url}/videos/{video_id}", headers=headers)
        status_result = status_response.json()

        # Parse progress and status from response
        data = status_result.get("data", {})
        if data is None:
            data = {}
        progress = data.get("progress", "0%")
        status = data.get("status", "unknown")

        print(f"Progress: {progress}, Status: {status}")

        if status in ["FAILURE", "failed"]:
            print("Video generation failed!")
            print(status_result)
            exit(1)

        if progress == "100%":
            print("Video generation completed!")
            break
    except Exception as e:
        print(f"Temporary error: {e}, retrying...")

    time.sleep(10)

# Step 3: Download the video to output directory
print(f"\nDownloading video to ./output/{video_id}.mp4...")
os.makedirs("./output", exist_ok=True)

video_response = requests.get(f"{base_url}/videos/{video_id}/content", headers=headers)

output_path = f"./output/{video_id}.mp4"
with open(output_path, "wb") as f:
    f.write(video_response.content)

if os.path.exists(output_path):
    file_size = os.path.getsize(output_path)
    print(f"Video saved to {output_path}")
    print(f"File size: {file_size} bytes")
else:
    print("Failed to download video")
    exit(1)

JavaScript Code Example

// Create a video with sora-2-pro using raw HTTP requests
import fs from "fs";
import path from "path";

const apiKey = process.env.COMETAPI_KEY;
const baseUrl = "https://api.cometapi.com/v1";

async function sleep(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

async function main() {
  // Step 1: Submit the video generation request
  console.log("Submitting video generation request...");

  const formData = new FormData();
  formData.append("model", "sora-2-pro");
  formData.append("prompt", "A calico cat playing a piano on stage");

  const submitResponse = await fetch(`${baseUrl}/videos`, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${apiKey}`,
    },
    body: formData,
  });

  const result = await submitResponse.json();
  console.log("Response:", JSON.stringify(result, null, 2));

  const videoId = result.id;
  console.log("Video ID:", videoId);

  // Step 2: Poll for progress until 100%
  console.log("\nChecking video generation progress...");

  while (true) {
    try {
      const statusResponse = await fetch(`${baseUrl}/videos/${videoId}`, {
        headers: {
          Authorization: `Bearer ${apiKey}`,
        },
      });

      const text = await statusResponse.text();
      if (text.startsWith("<")) {
        console.log("Temporary server error, retrying...");
        await sleep(10000);
        continue;
      }

      const statusResult = JSON.parse(text);

      // Parse progress and status from response
      const data = statusResult.data || {};
      const progress = data.progress || "0%";
      const status = data.status || "unknown";

      console.log(`Progress: ${progress}, Status: ${status}`);

      if (status === "FAILURE" || status === "failed") {
        console.log("Video generation failed!");
        console.log(JSON.stringify(statusResult, null, 2));
        process.exit(1);
      }

      if (progress === "100%") {
        console.log("Video generation completed!");
        break;
      }
    } catch (e) {
      console.log(`Temporary error: ${e.message}, retrying...`);
    }

    await sleep(10000);
  }

  // Step 3: Download the video to output directory
  console.log(`\nDownloading video to ./output/${videoId}.mp4...`);

  const outputDir = "./output";
  if (!fs.existsSync(outputDir)) {
    fs.mkdirSync(outputDir, { recursive: true });
  }

  const videoResponse = await fetch(`${baseUrl}/videos/${videoId}/content`, {
    headers: {
      Authorization: `Bearer ${apiKey}`,
    },
  });

  const outputPath = path.join(outputDir, `${videoId}.mp4`);
  const videoBuffer = Buffer.from(await videoResponse.arrayBuffer());
  fs.writeFileSync(outputPath, videoBuffer);

  if (fs.existsSync(outputPath)) {
    const stats = fs.statSync(outputPath);
    console.log(`Video saved to ${outputPath}`);
    console.log(`File size: ${stats.size} bytes`);
  } else {
    console.log("Failed to download video");
    process.exit(1);
  }
}

main().catch(console.error);