Does Sora 2 Pro generate synchronized audio with video?

Ja, Sora 2 Pro genererer videobilder sammen med synkronisert lyd, inkludert dialog, omgivelseslyd og lydeffekter—ikke produsert separat, men som en samlet helhet.

What resolution and duration does Sora 2 Pro support?

Sora 2 Pro støtter opptil 1080p-oppløsning. Den er optimalisert for kortklipp i høy kvalitet, vanligvis i ensifret til lav tosifret antall sekunder for maksimal kvalitet.

How does Sora 2 Pro differ from standard Sora 2?

Sora 2 Pro er finjustert for høyere visuell troskap, håndterer vanskeligere opptak (kompleks bevegelse, okklusjon, fysiske interaksjoner) og opprettholder lengre konsistens per scene—på bekostning av lengre renderingstider.

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

Ja, Sora 2 Pro støtter input_reference-arbeidsflyter der JPEG/PNG/WEBP-bilder fungerer som komposisjonsankre for å styre startbildet eller stilen til den genererte videoen.

Does Sora 2 Pro support likeness injection (cameos)?

Ja, Sora 2 Pro kan sette inn en brukers utseende i genererte scener. OpenAI har innebygde samtykkearbeidsflyter og tilbakekallingsmekanismer for å håndtere personvern- og misbruksrisiko.

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

Benchmark-tester viser at Sora 2 Pro i snitt bruker omtrent 2.1 minutter for et 20-sekunders 1080p-klipp. Pro prioriterer kvalitet fremfor hastighet, så forvent lengre renderingstider enn standard Sora 2.

What physics improvements does Sora 2 Pro offer?

Sora 2 Pro forbedrer objektpermanens og bevegelsestrohet—moment, oppdrift og fysiske interaksjoner fremstår mer realistiske, med færre 'teleportering'-artefakter som var vanlige i tidligere videomodeller.

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

Velg Sora 2 Pro for integrasjon i OpenAI-økosystemet, innsetting av utseende og komplekse fysiske scener. Veo 3 kan tilby raskere generering og annen prissetting—vurder basert på dine latens- og budsjettbehov.

Kimi K3 is now live on CometAPI →

Sora 2 Pro

Per sekund:$0.24

Utgitt:May 31, 2026

Sora 2 Pro er vår mest avanserte og kraftigste mediegenereringsmodell, som kan generere videoer med synkronisert lyd. Den kan skape detaljerte, dynamiske videoklipp fra naturlig språk eller bilder.

Kommersiell bruk

Playground for Sora 2 Pro

Utforsk Sora 2 Pro's Playground — et interaktivt miljø for å teste modeller og kjøre spørringer i sanntid. Prøv prompts, juster parametere og iterer umiddelbart for å akselerere utvikling og validere brukstilfeller.

Nøkkelfunksjoner

Multimodal generering (video + lyd) — Sora-2-Pro genererer videorammer sammen med synkronisert lyd (dialog, omgivelseslyd, SFX) i stedet for å produsere video og lyd separat.
Høyere troskap / “Pro”-nivå — finjustert for høyere visuell troskap, mer krevende opptak (kompleks bevegelse, okklusjon og fysiske interaksjoner) og lengre konsistens per scene enn Sora-2 (ikke-Pro). Det kan ta lengre tid å rendre enn den standard Sora-2-modellen.
Fleksible inndata — støtter rene tekstprompter, og kan ta imot bilde-inndatarammer eller referansebilder for å styre komposisjon (input_reference-arbeidsflyter).
Cameos / likhetsinnsetting — kan sette inn en brukers innfangede likhet i genererte scener med samtykke-arbeidsflyter i appen.
Fysisk plausibilitet: forbedret objektpermanens og bevegelsestrohet (f.eks. moment, oppdrift), som reduserer urealistiske “teleportering”-artefakter som var vanlige i tidligere systemer.
Kontrollerbarhet: støtter strukturerte prompter og instruksjoner på opptaksnivå slik at skapere kan spesifisere kamera, lyssetting og multishot-sekvenser.

Tekniske detaljer og integrasjonsflate

Modellfamilie: Sora 2 (base) og Sora 2 Pro (variant av høy kvalitet).
Inndatamodaliteter: tekstprompter, bildereferanse og kort opptak av cameo-video/lyd for likhet.
Utdata-modaliteter: kodet video (med lyd) — parametere eksponert via /v1/videos-endepunkter (modellvalg via model: "sora-2-pro"). API-overflaten følger OpenAIs videos-endepunktfamilie for create/retrieve/list/delete-operasjoner.

Trening og arkitektur (offentlig sammendrag): OpenAI beskriver Sora 2 som trent på storskala videodata med ettertrening for å forbedre verdenssimulering; spesifikke detaljer (modellstørrelse, eksakte datasett og tokenisering) er ikke offentliggjort linje for linje. Forvent tung beregning, spesialiserte videotokenizere/-arkitekturer og multimodal tilpasningskomponenter.

API-endepunkter og arbeidsflyt: vis en jobbbasert arbeidsflyt: send en POST-forespørsel for opprettelse (model="sora-2-pro"), motta en jobb-ID eller lokasjon, deretter poll eller vent på fullføring og last ned resulterende fil(er). Vanlige parametere i publiserte eksempler inkluderer prompt, seconds/duration, size/resolution og input_reference for bildeveiledede oppstarter.

Typiske parametere :

model: "sora-2-pro"
prompt: naturlig språklig scenebeskrivelse, eventuelt med dialogsignaler
seconds / duration: ønsket kliplengde ( Pro støtter høyeste kvalitet innen tilgjengelige varigheter)
size / resolution: i følge rapporter fra miljøet støtter Pro opptil 1080p i mange brukstilfeller.

Innholds-inndata: bildefiler (JPEG/PNG/WEBP) kan leveres som en ramme eller referanse; når de brukes, bør bildet matche måloppløsningen og fungere som et komposisjonsanker.

Renderingsatferd: Pro er finstemt for å prioritere ramme-til-ramme-konsistens og realistisk fysikk; dette innebærer typisk lengre beregningstid og høyere kostnad per klipp enn ikke-Pro-varianter.

Benchmark-ytelse

Kvalitative styrker: OpenAI har forbedret realisme, fysisk konsistens og synkronisert lyd sammenlignet med tidligere videomodeller. Andre VBench-resultater indikerer at Sora-2 og avledede modeller ligger på eller nær toppen blant samtidige lukkede systemer og temporal sammenheng.

Uavhengig timing/gjennomstrømning (eksempel-bench): Sora-2-Pro hadde i snitt ~2,1 minutter for 20-sekunders 1080p-klipp i én sammenligning, mens en konkurrent (Runway Gen-3 Alpha Turbo) var raskere (~1,7 minutter) på samme oppgave — avveininger er kvalitet vs. render-latens og plattformoptimalisering.

Begrensninger (praktiske og sikkerhetsmessige)

Ikke perfekt fysikk/konsistens — forbedret, men ikke feilfri; artefakter, unaturlige bevegelser eller lydsynkfeil kan fortsatt forekomme.
Varighets- og beregningsbegrensninger — lange klipp er beregningstunge; mange praktiske arbeidsflyter begrenser klipp til korte varigheter (f.eks. enkelt- til lave tosifrede sekunder for høy-kvalitets utdata).
Personvern / samtykkerisiko — likhetsinnsetting (“cameos”) innebærer samtykke- og mis-/desinformasjonrisiko; OpenAI har eksplisitte sikkerhetskontroller og tilbakekallingsmekanismer i appen, men ansvarlig integrasjon er påkrevd.
Kostnad og latens — Pro-kvalitetsrendringer kan være dyrere og tregere enn lettere modeller eller konkurrenter; ta høyde for fakturering per sekund/per render og kø.
Sikkerhetsinnholdsfiltrering — generering av skadelig eller opphavsrettsbeskyttet innhold er begrenset; modellen og plattformen inkluderer sikkerhetslag og moderering.

Typiske og anbefalte bruksområder

Bruksområder:

Markedsføring og annonseprototyper — lag raskt filmatiske konseptbevis.
Previsualisering — storyboard, kamerablokkering, visualisering av opptak.
Korte sosiale klipp — stiliserte klipp med synkronisert dialog og SFX.
Hvordan få tilgang til Sora 2 Pro API

Trinn 1: Registrer deg for API-nøkkel

Logg inn på cometapi.com. Hvis du ikke er bruker ennå, registrer deg først. Logg inn i din CometAPI console. Hent tilgangslegitimasjonen API-nøkkel for grensesnittet. Klikk “Add Token” ved API token i personssenteret, hent token-nøkkelen: sk-xxxxx og send inn.

cometapi-key

Trinn 2: Send forespørsler til Sora 2 Pro API

Velg “sora-2-pro”-endepunktet for å sende API-forespørselen og sett forespørselskroppen. Forespørselsmetode og kropp hentes fra nettstedets API-dokumentasjon. Nettstedet vårt tilbyr også Apifox-test for din bekvemmelighet. Erstatt <YOUR_API_KEY> med din faktiske CometAPI-nøkkel fra kontoen din. base url is office Create video

Sett inn spørsmålet eller forespørselen din i content-feltet—dette er hva modellen vil svare på . Behandle API-responsen for å få den genererte responsen.

Trinn 3: Hent og verifiser resultater

Behandle API-responsen for å få den genererte responsen. Etter behandling svarer API-et med oppgavestatus og utdata.

Intern trening / simulering — generer scenariovisualer for RL- eller robotikkforskning (med forsiktighet).
Kreativ produksjon — når det kombineres med menneskelig redigering (søm av korte klipp, fargekorrigering, erstatte lyd).

FAQ

Priser for Sora 2 Pro

Utforsk konkurransedyktige priser for Sora 2 Pro, designet for å passe ulike budsjetter og bruksbehov. Våre fleksible planer sikrer at du bare betaler for det du bruker, noe som gjør det enkelt å skalere etter hvert som kravene dine vokser. Oppdag hvordan Sora 2 Pro kan forbedre prosjektene dine samtidig som kostnadene 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 for Sora 2 Pro

Sora-2-pro er OpenAIs flaggskipmodell for video- og lydgenerering, designet for å lage korte, svært realistiske videoklipp med synkronisert dialog og lydeffekter, og med sterkere simulering av fysikk og verden enn tidligere videomodeller. Den er posisjonert som "Pro"-varianten av høyere kvalitet, tilgjengelig for betalende brukere og via API-et for programmatisk generering. Modellen vektlegger kontrollerbarhet, tidsmessig konsistens og lydsynkronisering for filmatiske og sosiale bruksområder.

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