Sora 2 Pro Text to Video API

openai/sora-2-pro/text-to-video

Sora 2 Pro (Text to Video) transforms text prompts into cinematic 1080p Full HD video with synchronized audio, supporting fixed durations from 4 to 20 seconds, multiple resolution tiers, and 16:9 or 9:16 aspect ratios. It renders intricate facial micro-expressions and volumetric lighting while maintaining superior camera stability and physical continuity.

Input

Prompt

291

Duration

Aspect ratio

Resolution

Output

Idle

Your generated video will appear here

Add your prompt and required media, review the settings, then click Run.

Continue with

Sora 2 Pro Image to Video Sora 2 Text to Video Sora 2 Image to Video

Examples

Aerial orbit over a rain-slicked downtown intersection at night, neon signs reflecting on wet asphalt, traffic light trails, cinematic drone shot slowly circling, volumetric haze. Natural sound: distant traffic hum, rain drizzle, a faraway siren. Cinematic realistic motion, no text, no logos.

Extreme macro inside a mechanical watch movement, brass gears turning with precision, ruby jewels glinting under soft studio light, shallow depth of field, cinematic detail. Natural sound: delicate ticking, faint metallic clicks. Realistic macro motion, no text, no logos.

A massive glacier under dancing green aurora borealis, slow cinematic push-in across blue ice ridges, star field above, cold mist drifting. Natural sound: deep ice groans, soft polar wind. Cinematic realistic motion, no text, no logos.

REST API

Quick Start

Authenticate, submit 1080p generation request, and poll task status for cinematic video result.

Step 1: Set up authentication

Include Authorization: Bearer VIDGO_API_KEY in all HTTP request headers.

Endpoint: POSThttps://api.vidgo.ai/api/generate/submit
Authentication: Authorization: Bearer VIDGO_API_KEY

Step 2: Submit generation task

Send POST request to /api/generate/submit with model openai/sora-2-pro/text-to-video and input payload.

Submit request

REQUEST_BODY=$(cat <<'JSON'
{
  "model": "openai/sora-2-pro/text-to-video",
  "input": {
    "prompt": "Cinematic 1080p tracking shot: a vintage sports car speeds along an Amalfi coast highway at golden hour, waves crashing against coastal rocks below, sunlight glinting off metallic paint, dramatic lens flare, 35mm film grain, volumetric atmosphere. Audio: deep engine rumble, coastal wind gusts, rhythmic ocean surge.",
    "duration": 4,
    "resolution": "1080p",
    "aspect_ratio": "16:9"
  }
}
JSON
)

RESPONSE=$(curl --silent --show-error --fail-with-body \
  --request POST \
  --url "https://api.vidgo.ai/api/generate/submit" \
  --header "Authorization: Bearer $VIDGO_API_KEY" \
  --header "Content-Type: application/json" \
  --data "$REQUEST_BODY")

CODE=$(printf '%s' "$RESPONSE" | jq -r '.code // empty')
if [ "$CODE" != "0" ] && [ "$CODE" != "200" ]; then
  printf 'API error: %s
' "$RESPONSE" >&2
  exit 1
fi
printf '%s
' "$RESPONSE"

Step 3: Poll for video result

Poll with task_id while status is not_started or running, and stop at finished or failed. On success, read data.files[].file_url; on failure, read data.error_message.

Track status

GET https://api.vidgo.ai/api/generate/status/{task_id}

Poll with task_id while status is not_started or running, and stop at finished or failed. On success, read data.files[].file_url; on failure, read data.error_message.

not_startedrunningfinishedfailed

Submit response

{
  "code": 200,
  "data": {
    "task_id": "task-sora2-pro-t2v-109283",
    "status": "running",
    "created_time": "2026-09-17T10:00:00Z"
  }
}

Finished response

{
  "code": 200,
  "data": {
    "task_id": "task-unified-...",
    "status": "finished",
    "files": [
      {
        "file_url": "https://storage.vidgo.ai/generated/video.mp4",
        "file_type": "video"
      }
    ],
    "created_time": "2026-08-22T10:00:00Z",
    "progress": 100,
    "error_message": null
  }
}

Complete script example

Expand for a complete script with HTTP and business-code checks, task_id validation, polling, terminal-state handling, and a 600-second polling timeout.

Complete script example

set -euo pipefail
: "${VIDGO_API_KEY:?Set VIDGO_API_KEY in your environment}"

REQUEST_BODY=$(cat <<'JSON'
{
  "model": "openai/sora-2-pro/text-to-video",
  "input": {
    "prompt": "Cinematic 1080p tracking shot: a vintage sports car speeds along an Amalfi coast highway at golden hour, waves crashing against coastal rocks below, sunlight glinting off metallic paint, dramatic lens flare, 35mm film grain, volumetric atmosphere. Audio: deep engine rumble, coastal wind gusts, rhythmic ocean surge.",
    "duration": 4,
    "resolution": "1080p",
    "aspect_ratio": "16:9"
  }
}
JSON
)

SUBMIT_RESPONSE=$(curl --silent --show-error --fail-with-body \
  --request POST \
  --url "https://api.vidgo.ai/api/generate/submit" \
  --header "Authorization: Bearer $VIDGO_API_KEY" \
  --header "Content-Type: application/json" \
  --data "$REQUEST_BODY")

TASK_ID=$(printf '%s' "$SUBMIT_RESPONSE" | jq -r '.data.task_id // .task_id // empty')
BUSINESS_CODE=$(printf '%s' "$SUBMIT_RESPONSE" | jq -r '.code // empty')
if [ "$BUSINESS_CODE" != "0" ] && [ "$BUSINESS_CODE" != "200" ]; then
  printf 'Submit failed:
%s
' "$SUBMIT_RESPONSE" >&2
  exit 1
fi
if [ -z "$TASK_ID" ]; then
  printf 'Submit response did not include task_id:
%s
' "$SUBMIT_RESPONSE" >&2
  exit 1
fi

START_TIME=$(date +%s)
POLL_DELAY=2
while true; do
  if [ $(( $(date +%s) - START_TIME )) -ge 600 ]; then
    printf 'Timed out after 600 seconds
' >&2
    exit 1
  fi
  STATUS_RESPONSE=$(curl --silent --show-error --fail-with-body \
    --url "https://api.vidgo.ai/api/generate/status/$TASK_ID" \
    --header "Authorization: Bearer $VIDGO_API_KEY")
  STATUS=$(printf '%s' "$STATUS_RESPONSE" | jq -r '.data.status // .status // empty')
  BUSINESS_CODE=$(printf '%s' "$STATUS_RESPONSE" | jq -r '.code // empty')
  if [ "$BUSINESS_CODE" != "0" ] && [ "$BUSINESS_CODE" != "200" ]; then
    printf 'Status request failed:
%s
' "$STATUS_RESPONSE" >&2
    exit 1
  fi

  case "$STATUS" in
    finished)
      printf '%s' "$STATUS_RESPONSE" | jq -r '(.data.files // .files // [])[]?.file_url'
      break
      ;;
    failed)
      printf '%s' "$STATUS_RESPONSE" | jq -r '.data.error_message // .error_message // "Generation failed"' >&2
      exit 1
      ;;
    not_started|running)
      sleep "$POLL_DELAY"
      if [ "$POLL_DELAY" -lt 10 ]; then POLL_DELAY=$((POLL_DELAY + 1)); fi
      ;;
    *)
      printf 'Unexpected task status: %s
' "$STATUS" >&2
      exit 1
      ;;
  esac
done

Input parameters

Parameters passed within the input object to /api/generate/submit:

Field	Type	Required	Default	Description
prompt	string	Yes	—	At least 1 character after trimming.
duration	integer	No	4	4, 8, 12, 16, or 20, in seconds.
aspect_ratio	string	No	16:9	16:9 or 9:16.
resolution	string	No	1024p	720p, 1024p, or 1080p.

Response Fields

Task creation payload and query status response details:

Field	Type	Description
code	integer	Application result code; successful responses return 200.
message	string	Human-readable status or error message.
data.task_id	string	Unique asynchronous task identifier.
data.status	string	Current lifecycle: not_started, running, finished, or failed.
data.created_time	string	Task creation timestamp in ISO 8601 format.
data.files[]	array	Output files generated upon completion.
data.files[].file_url	string	Public URL for downloading or playing the generated video.
data.error_message	string \| null	Detailed error explanation when task status is failed.

Task Lifecycle

Poll status until reaching finished or failed:

not_started
Task accepted and waiting in compute dispatch queue.
running
Diffusion model is generating 1080p frames and audio track.
finished
Generation completed; read video URL from data.files[0].file_url.
failed
Task stopped due to parameter error or safety filter; inspect data.error_message.

Polling and Errors

AuthenticationVerify Bearer API key in request header if 401 is received.
Resolution checkVerify resolution parameter is 720p, 1024p, or 1080p upon 400 response.
Polling intervalPoll with a 2-second base interval, extending gradually for longer jobs.
Webhook callbackProvide callback_url at request top level to receive asynchronous POST notifications.

Endpoint limits

Specification	Value	Details
Input mode	Text only	A prompt defines scene geometry, camera motion, and soundscape.
Output	MP4 video with native audio	Asynchronous video generation with downloadable MP4 URL upon completion.
Duration	4 / 8 / 12 / 16 / 20 seconds	Default is 4 seconds.
Aspect ratio	16:9 / 9:16	Default is 16:9.
Resolution	720p / 1024p / 1080p	Default is 1024p, supporting up to 1080p Full HD.
Billing basis	Per second × resolution rate	720p: 48 credits/s; 1024p: 80 credits/s; 1080p: 112 credits/s.

View Sora 2 Pro API documentation

Sora 2 Pro Text to Video

Sora 2 Pro Text to Video is OpenAI's flagship model for text-to-video generation. It creates cinematic video clips with rich optical lighting, surface textures, and native synchronized stereo audio directly from text instructions. With native support for 720p, 1024p, and 1080p resolutions, it is engineered for premium commercial advertisements, high-end film previs, and immersive digital showcases.

Why Choose This Endpoint?

1080p Flagship Full HD MasteryDelivers pristine 1080p visual fidelity, resolving fine textile weaves, facial micro-textures, and complex light diffusion ready for commercial broadcast.
Cinematic Optical Lighting & Camera ControlFaithfully adheres to optical physics, allowing natural language steering of zoom, dolly, tracking, and aerial maneuvers with rock-solid stability.
High-Dynamic Synchronized AudioJointly synthesizes spatial soundscapes and Foley effects timed precisely to on-screen choreography without external audio engineering.
Flexible Resolution ScalingOffers 720p, 1024p, and 1080p resolution tiers, letting you balance iteration speed during early drafts against final master rendering.
20-Second Temporal ContinuityMaintains subject appearance, momentum, and lighting logic consistently across sustained shots up to 20 seconds in length.
Transparent Predictable Tier PricingCalculates credit consumption transparently based on seconds × resolution rate, enabling studios to plan production budgets with precision.

Parameters

Parameter	Requirement	Description
prompt	Required	String. Describe subjects, lighting style, camera choreography, dynamic actions, and acoustic environment. Minimum 1 character after trimming.
duration	Optional	Integer. Sets clip duration in seconds: 4, 8, 12, 16, or 20. The playground defaults to 4 seconds. Default`48121620`
aspect_ratio	Optional	String. Sets framing format: 16:9 (default) or 9:16. Default`16:99:16`
resolution	Optional	String. Sets output resolution: 720p, 1024p, or 1080p. The playground defaults to 1024p. Default`1024p720p1080p`

How to Use

Configure API KeyGenerate an API key in the dashboard and attach Authorization: Bearer <API_KEY> to your HTTP request headers.
Select Resolution & DurationChoose between 720p, 1024p, or 1080p, and select a 4s to 20s tier. Credits scale predictably according to resolution and duration.
Submit Request & Download VideoSend POST request to /api/generate/submit, poll task status with the returned task_id, and retrieve your finished 1080p MP4 clip.

Pricing Structure

Sora 2 Pro is billed on a resolution rate per second basis: 720p at 48 credits/s (4s=192 credits), 1024p at 80 credits/s (4s=320 credits, default), and 1080p at 112 credits/s (4s=448 credits). Based on 2,000 credits for $10, it offers pay-as-you-go flexibility without requiring a recurring monthly subscription.

Usage	Rate	Details
720p Tier (4–20s)	48 credits/s (from 192 credits / 4s, ~$0.96)	Fastest Pro tier, ideal for high-speed dynamic staging tests.
1024p Tier (4–20s, default)	80 credits/s (from 320 credits / 4s, ~$1.60)	Default selection, providing an optimal balance of elite fidelity and throughput.
1080p Tier (4–20s)	112 credits/s (from 448 credits / 4s, ~$2.24)	Maximum Full HD fidelity for commercial TVCs, theatrical previs, and master deliverables.

Best Use Cases

Commercial Advertising & Brand TVCsProduce photorealistic 1080p commercial spots with complex multi-axis camera motion and pristine lighting suitable for broadcast delivery.
Cinematic Storyboarding & Feature PrevisEmpower film directors and cinematographers with dynamic previs clips, testing intricate illumination and continuous long-take pacing.
High-Fidelity Digital Showcases & InstallationsRender 1080p visuals with synchronized acoustic presence designed for high-resolution gallery screens and immersive experiential displays.
Teasers & Entertainment TrailersQuickly visualize fictional worlds, creature actions, and intense kinetic sequences in Full HD for early campaign pitches.

Pro Tips

Detail optical lighting conditions (e.g. 35mm anamorphic flare, backlit rim light, diffused overcast glow) to unlock Pro's rendering potential.
Employ specific camera directions like slow dolly forward or orbital tracking to evoke stable three-dimensional spatial perspective.
Validate shot pacing at 4s in 720p or 1024p before triggering 20s full master renders at 1080p.
Describe acoustic reverberation and room acoustics (e.g. footsteps echoing in an empty marble cathedral) for immersive synchronized audio.

Usage Notes

Sora 2 Pro accepts optional resolution parameter (720p, 1024p, 1080p) with 1024p preselected by default.
All generations output high-bitrate MP4 video files with integrated native audio tracks.
Supports webhook delivery via callback_url or resilient async polling with a recommended 2–3s baseline interval.

Sora 2 Image to VideoGenerate a 4-second to 20-second clip with synced audio from a text prompt and one required reference image.

Sora 2 Pro Image to VideoGenerate a 4-second to 20-second clip with synced audio from a text prompt and one required reference image.

Sora 2 Pro Text to Video API frequently asked questions

What is the Sora 2 Pro Text to Video API?

Sora 2 Pro Text to Video is OpenAI's flagship model for video generation from text. It creates cinematic videos up to 1080p Full HD resolution with native synchronized stereo audio directly from text instructions, supporting professional camera staging and multiple framing options. Built on OpenAI's most capable multimodal diffusion architecture, it adheres strictly to physical laws and continuous motion logic while rendering nuanced lighting and texture detail. You can call it programmatically or try it from the playground above.

What resolutions are supported by Sora 2 Pro Text to Video?

Sora 2 Pro Text to Video supports 720p, 1024p, and 1080p resolution tiers (the playground defaults to 1024p). The 1080p mode is engineered for commercial campaigns and large-screen exhibitions, delivering crisp facial textures and complex specular highlights.

How does Sora 2 Pro differ from the Standard Sora 2 model?

Compared to Standard Sora 2, Sora 2 Pro introduces native 1080p rendering, richer three-dimensional lighting complexity, more expressive facial micro-movements, and higher acoustic foley fidelity, making it the preferred choice for commercial-grade deliverables.

What is the maximum clip duration for Sora 2 Pro Text to Video?

A single call supports generating clips up to 20 seconds, with exact duration options of 4, 8, 12, 16, or 20 seconds (the playground defaults to 4 seconds). Even across a full 20-second take, the model maintains perspective and physical momentum without degradation.

Does Sora 2 Pro Text to Video support synchronized audio?

Yes. The model synthesizes native stereo soundscapes aligned with the video motion. By describing acoustic events, vehicle sounds, atmospheric weather, or character vocalizations in your prompt, the output MP4 includes synchronized audio automatically.

How should I prompt Sora 2 Pro for cinematic lighting?

We recommend describing optical lens traits and lighting setups explicitly, such as 35mm anamorphic flares, golden-hour rim lighting, or diffused softbox illumination. Pro responds with high precision to professional cinematography terms.

Which endpoint should I use to generate 1080p video from an image?

Use the companion Sora 2 Pro Image to Video endpoint. It supports 1080p Full HD output and auto aspect ratio matching, allowing you to animate still keyframes while preserving exact source framing and texture quality.