Does Sora 2 Pro generate synchronized audio with video?

Ja, Sora 2 Pro genererer videobilleder sammen med synkroniseret lyd, inklusive dialog, omgivelseslyd og lydeffekter—ikke produceret separat, men som et samlet output.

What resolution and duration does Sora 2 Pro support?

Sora 2 Pro understøtter op til 1080p opløsning. Den er optimeret til kortere klip i høj kvalitet, typisk i området fra få sekunder til lidt over ti sekunder for maksimal billedtrofasthed.

How does Sora 2 Pro differ from standard Sora 2?

Sora 2 Pro er tunet til højere visuel trofasthed, håndterer sværere optagelser (kompleks bevægelse, okklusion, fysiske interaktioner) og opretholder længere konsistens pr. scene—på bekostning af længere rendertider.

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

Ja, Sora 2 Pro understøtter input_reference-arbejdsgange, hvor JPEG/PNG/WEBP-billeder fungerer som kompositionsankre for at guide den genererede videos startbillede eller stil.

Does Sora 2 Pro support likeness injection (cameos)?

Ja, Sora 2 Pro kan indsætte en brugers optagede lighed i genererede scener. OpenAI har indbyggede samtykke-arbejdsgange og tilbagekaldelsesmekanismer for at adressere privatlivs- og misbrugsrisici.

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

Benchmark-tests viser, at Sora 2 Pro i gennemsnit bruger cirka 2.1 minutter på et 20-sekunders 1080p-klip. Pro prioriterer kvalitet over hastighed, så forvent længere rendertider end med standard Sora 2.

What physics improvements does Sora 2 Pro offer?

Sora 2 Pro forbedrer objektpermanens og bevægelsestrofasthed—momentum, opdrift og fysiske interaktioner fremstår mere realistiske med færre 'teleportering'-artefakter, som var almindelige i tidligere videomodeller.

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

Vælg Sora 2 Pro for integration i OpenAI-økosystemet, likeness-injektion og komplekse fysiske scener. Veo 3 kan tilbyde hurtigere generering og anderledes prissætning—vurder ud fra dine latenstids- og budgetbehov.

Kimi K3 is now live on CometAPI →

Sora 2 Pro

Per Sekund:$0.24

Udgivet:May 31, 2026

Sora 2 Pro er vores mest avancerede og kraftfulde mediegenereringsmodel, der kan generere videoer med synkroniseret lyd. Den kan skabe detaljerede, dynamiske videoklip ud fra naturligt sprog eller billeder.

Kommersiel brug

Playground for Sora 2 Pro

Udforsk Sora 2 Pro's Playground — et interaktivt miljø til at teste modeller og køre forespørgsler i realtid. Prøv prompts, juster parametre og iterer øjeblikkeligt for at fremskynde udvikling og validere use cases.

Nøglefunktioner

Multimodal generering (video + lyd) — Sora-2-Pro genererer videorammer sammen med synkroniseret lyd (dialog, omgivelseslyd, SFX) i stedet for at producere video og lyd separat.
Højere troskab / “Pro”-niveau — tunet til højere visuel troskab, mere krævende optagelser (kompleks bevægelse, okklusion og fysiske interaktioner) og længere konsistens pr. scene end Sora-2 (non-Pro). Det kan tage længere tid at rendere end standardmodellen Sora-2.
Fleksible input — understøtter rene tekstprompter og kan acceptere billedinput-rammer eller referencebilleder til at guide kompositionen (input_reference-workflows).
Cameos / indsættelse af lighed — kan indsætte en brugers optagede lighed i genererede scener med samtykke-workflows i appen.
Fysisk plausibilitet: forbedret objektpermanens og bevægelsestrofaste detaljer (fx momentum, opdrift), hvilket reducerer urealistiske “teleportations”-artefakter, som var almindelige i tidligere systemer.
Kontrollerbarhed: understøtter strukturerede prompter og instruktioner på optagelsesniveau, så skabere kan specificere kamera, lys og sekvenser med flere optagelser.

Tekniske detaljer og integrationsflade

Modelfamilie: Sora 2 (basis) og Sora 2 Pro (variant i høj kvalitet).
Inputmodaliteter: tekstprompter, billedreference samt korte optagede cameo-video/-lyd til lighed.
Outputmodaliteter: kodet video (med lyd) — parametre eksponeres via /v1/videos-endpoints (modelvalg via model: "sora-2-pro"). API-overfladen følger OpenAIs videos-endpointfamilie til create/retrieve/list/delete-operationer.

Træning & arkitektur (offentlig oversigt): OpenAI beskriver Sora 2 som trænet på video i stor skala med eftertræning for at forbedre verdenssimulation; specifikationer (modelstørrelse, præcise datasæt og tokenisering) er ikke offentliggjort linje for linje. Forvent tung beregning, specialiserede videotokenizere/arkitekturer og multimodale alignmentskomponenter.

API-endpoints & workflow: vis en job-baseret workflow: indsend en POST-oprettelsesanmodning (model="sora-2-pro"), modtag et job-id eller en placering, og poll eller vent på fuldførelse og download de resulterende filer. Almindelige parametre i offentliggjorte eksempler omfatter prompt, seconds/duration, size/resolution og input_reference til billedstyrede starter.

Typiske parametre:

model: "sora-2-pro"
prompt: naturligt sprog-beskrivelse af scenen, evt. med dialogangivelser
seconds / duration: målkliplængde (Pro understøtter den højeste kvalitet i de tilgængelige varigheder)
size / resolution: rapporter fra communityet indikerer, at Pro understøtter op til 1080p i mange anvendelser.

Indholdsinput: bilfiler (JPEG/PNG/WEBP) kan leveres som en ramme eller reference; når de bruges, bør billedet matche målopløsningen og fungere som en kompositionsanker.

Renderingsadfærd: Pro er tunet til at prioritere frame-til-frame-koherens og realistisk fysik; dette medfører typisk længere beregningstid og højere omkostninger pr. klip end non-Pro-varianter.

Benchmark-ydelse

Kvalitative styrker: OpenAI har forbedret realisme, fysisk konsistens og synkroniseret lyd** i forhold til tidligere videomodeller. Andre VBench-resultater indikerer, at Sora-2 og afledninger ligger i top blandt samtidige lukkede kilder og temporal koherens.

Uafhængig timing/gennemløb (eksempel-benchmark): Sora-2-Pro havde i gennemsnit ~2,1 minutter for 20-sekunders 1080p-klip i en sammenligning, mens en konkurrent (Runway Gen-3 Alpha Turbo) var hurtigere (~1,7 minutter) på samme opgave — tradeoffs er kvalitet vs. render-latens og platformoptimering.

Begrænsninger (praktiske & sikkerhed)

Ikke perfekt fysik/konsistens — forbedret men ikke fejlfri; artefakter, unaturlig bevægelse eller lydsynkfejl kan stadig forekomme.
Varighed & beregningsbegrænsninger — lange klip er beregningstunge; mange praktiske workflows begrænser klip til korte varigheder (fx enkelte til lave tocifrede sekunder for output i høj kvalitet).
Privatliv/samtykkesrisici — indsættelse af lighed (“cameos”) medfører samtykke- og desinformationsrisici; OpenAI har eksplicitte sikkerhedskontroller og tilbagekaldelsesmekanismer i appen, men ansvarlig integration er påkrævet.
Omkostninger & latens — Pro-kvalitetsrenderinger kan være dyrere og langsommere end lettere modeller eller konkurrenter; indregn fakturering pr. sekund/pr. rendering og køtid.
Sikkerhedsindholdsfiltrering — generering af skadeligt eller copyright-beskyttet indhold er begrænset; modellen og platformen inkluderer sikkerhedslag og moderation.

Typiske og anbefalede anvendelser

Anvendelser:

Marketing- & annonceprototyper — skab hurtigt filmiske proof-of-concepts.
Previsualisering — storyboards, kamerablokering, optagelsesvisualisering.
Kort socialt indhold — stiliserede klip med synkroniseret dialog og SFX.
Sådan får du adgang til Sora 2 Pro API

Trin 1: Tilmeld dig for at få API-nøgle

Log ind på cometapi.com. Hvis du ikke allerede er bruger, skal du først registrere dig. Log ind på din CometAPI-konsol. Hent adgangslegitimationen API-nøgle for interfacet. Klik på “Add Token” under API-token i personligt center, få token-nøglen: sk-xxxxx og indsend.

cometapi-key

Trin 2: Send anmodninger til Sora 2 Pro API

Vælg “sora-2-pro”-endpointet for at sende API-anmodningen og angiv request-body. Anmodningsmetoden og request-body hentes fra vores websteds API-dok. Vores websted tilbyder også Apifox-test for din bekvemmelighed. Erstat <YOUR_API_KEY> med din faktiske CometAPI-nøgle fra din konto. basis-URL er office Opret video

Indsæt dit spørgsmål eller din anmodning i content-feltet—det er dette, modellen svarer på. Behandl API-svaret for at få det genererede svar.

Trin 3: Hent og verificér resultater

Behandl API-svaret for at få det genererede svar. Efter behandlingen svarer API’et med opgavestatus og outputdata.

Intern træning/simulering — generér scenarievisualer til RL- eller robotikforskning (med omtanke).
Kreativ produktion — når det kombineres med menneskelig redigering (samling af korte klip, grading, erstat lyd).

FAQ

Priser for Sora 2 Pro

Udforsk konkurrencedygtige priser for Sora 2 Pro, designet til at passe til forskellige budgetter og brugsbehov. Vores fleksible planer sikrer, at du kun betaler for det, du bruger, hvilket gør det nemt at skalere, efterhånden som dine krav vokser. Opdag hvordan Sora 2 Pro kan forbedre dine projekter, mens omkostningerne holdes håndterbare.

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

Eksempelkode og API til Sora 2 Pro

Sora-2-pro er OpenAIs flagskibsmodel til generering af video og lyd, designet til at skabe korte, meget realistiske videoklip med synkroniseret dialog, lydeffekter og stærkere fysik- og verdenssimulation end tidligere videomodeller. Den er positioneret som den højkvalitets “Pro”-variant, tilgængelig for betalende brugere og via API'et til programmatisk generering. Modellen lægger vægt på kontrollerbarhed, tidslig sammenhæng og lydsynkronisering til filmiske og sociale brugsscenarier.

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);