OpenAI Video API: Integration Guide, Pricing & Code

The single most important fact about the OpenAI video API in August 2026 is not how to call it. It is that OpenAI has officially deprecated the whole thing: the Videos API and every Sora 2 model alias are scheduled to shut down on September 24, 2026, with no replacement listed on OpenAI’s deprecations page. Most of what ranks for “openai video api” today either predates that announcement or simply repeats official docs, which means a developer evaluating this API has no single, current, code-level answer. This guide is that answer, verified against OpenAI’s own pages on August 19, 2026.

You will get the current pricing per second, a working Python and curl integration, the failure modes that actually cost time, and an honest look at what to build on once the shutdown lands. Modellix is an API aggregator and has a commercial interest in the migration part of this article; the facts about OpenAI’s API are drawn from OpenAI’s documentation and stand on their own.

The OpenAI video API is officially being shut down

OpenAI announced on March 24, 2026 that the Videos API and the Sora 2 video generation models were being deprecated, with removal from the API on September 24, 2026. The official deprecations page lists every affected item with that exact shutdown date:

• The Videos API (the /v1/videos endpoint family)
• sora-2 and sora-2-pro
• The snapshots sora-2-2025-10-06, sora-2-2025-12-08, and sora-2-pro-2025-10-06

The “recommended replacement” column for every row is empty. The video generation guide that still documents this API opens with the same banner, and the Create video reference marks the API “deprecated” with the same September 24 shutdown. If you read the Sora 2 model page today, the model is tagged “Legacy.”

What this means in practice: between now and September 24, 2026, the API keeps working and is billed normally. After that date, calls to these models and endpoints will fail, and OpenAI’s guidance is that developers should plan migrations. If you are starting a new integration today, the deprecation is not a reason to panic — it is a reason to design the integration so that the video provider is a replaceable module from day one. For a broader look at how OpenAI’s video route fits into the wider text-to-video API landscape, we maintain a separate guide with vendor-by-vendor details.

What the OpenAI video API does today

Until the shutdown, the Videos API exposes two models. sora-2 is the fast, flexible option for iteration — concepting, rough cuts, social clips. sora-2-pro is the production tier: slower to render, more expensive, and the only model that exports 1080p (1920x1080 or 1080x1920). Both support generations of 16 and 20 seconds, per the current video generation guide, with synced audio output.

The API is asynchronous, which shapes everything about integrating it:

1. POST /v1/videos returns a job object with an id and a starting status (queued).
2. You poll GET /v1/videos/{video_id} (the guide suggests every 10–20 seconds, with backoff) or register a webhook to receive video.completed / video.failed events.
3. When the job reaches completed, you download the MP4 from GET /v1/videos/{video_id}/content — and you should do it promptly, because download URLs expire one hour after generation.

Beyond plain text-to-video, the current feature set includes:

• Image-guided generation (input_reference): a JPEG, PNG, or WebP that becomes the first frame of the clip. The image must match the requested output resolution.
• Characters: upload a short MP4 of a reusable non-human subject (a mascot, an object), then reference it across generations by name. A single video can include up to two characters; the feature works best with 2–4 second clips.
• Video extensions: continue a finished clip with up to 20 additional seconds per call, up to six extensions for a 120-second maximum.
• Edits: POST /v1/videos/edits applies a targeted change (palette, staging, one element) to an existing video, replacing the older remix endpoint. Editing uploaded videos requires eligibility — contact sales for that workflow.
• Batch API: queue many renders offline through batch jobs via POST /v1/videos, useful for shot lists and scheduled render pipelines. Batch output is downloadable for 24 hours.

There are hard content guardrails: only content suitable for audiences under 18, no copyrighted characters or music, no real people (including public figures), and input images with human faces are rejected. Prompts and reference assets that violate these rules fail rather than silently producing output.

Illustrative diagram of the Videos API pipeline: prompt → timeline → frames → MP4. Concept art, not a product screenshot; generated August 19, 2026.

OpenAI video API pricing: verified per-second rates

OpenAI bills video generation per second of output, by model and resolution. The following rates were read from the official pricing page on August 19, 2026. Prices change; treat this table as a dated snapshot, not a quote.

Model	Size	Resolution	Standard price/sec	Batch price/sec
sora-2	720p	1280x720 / 720x1280	$0.10	$0.05
sora-2-pro	720p	1280x720 / 720x1280	$0.30	$0.15
sora-2-pro	1024p	1024x1792 / 1792x1024	$0.50	$0.25
sora-2-pro	1080p	1920x1080 / 1080x1920	$0.70	$0.35

A worked example, so the per-second unit means something: an 8-second sora-2 clip at 720p costs $0.80 at standard rates (8 × $0.10); the same clip on sora-2-pro at 1080p costs $5.60 (8 × $0.70). A 20-second 1080p pro render is $14.00. If you run the same jobs through the Batch API, those figures drop by half — useful for offline pipelines where latency is not a constraint.

Rate limits scale with your usage tier. The sora-2 model page lists these RPM caps: free tier is not supported for this model; Tier 1 gets 25 RPM, Tier 2 gets 50, Tier 3 gets 125, Tier 4 gets 200, and Tier 5 gets 375. Because a single render takes minutes, the practical constraint for most teams is concurrent jobs, not requests per minute.

Per-second metering concept for video API billing. Illustrative only — no prices in the image because they change; the table above is the dated source of truth.

Quick start: generate a video with the API

Everything below works against the current API. Keep the September 24, 2026 shutdown in mind, and pin your integration behind a thin client so the model can be swapped later.

Prerequisites: an OpenAI API key with a funded account (the free tier does not support video generation), and the official openai Python SDK (pip install openai).

The minimal flow — create a job, poll until it completes, download the MP4:

from openai import OpenAI

client = OpenAI(api_key="sk-...")  # from platform.openai.com

video = client.videos.create(
    model="sora-2",
    prompt="Wide shot of a child flying a red kite in a grassy park, golden hour sunlight, camera slowly pans upward.",
    size="1280x720",
    seconds=8,
)
print("job:", video.id, video.status)

while video.status in ("queued", "in_progress"):
    time.sleep(10)
    video = client.videos.retrieve(video.id)
    print(video.status, getattr(video, "progress", None))

if video.status == "completed":
    content = client.videos.download_content(video.id)
    with open("kite.mp4", "wb") as f:
        f.write(content.read())
else:
    print("failed:", video.error)

If you prefer curl, the same job looks like this:

curl -X POST "https://api.openai.com/v1/videos" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "sora-2",
    "prompt": "Close-up of a steaming coffee cup on a wooden table, morning light through blinds.",
    "size": "1280x720",
    "seconds": 8
  }'

# then poll
curl "https://api.openai.com/v1/videos/$VIDEO_ID" \
  -H "Authorization: Bearer $OPENAI_API_KEY"

# then download (valid for 1 hour)
curl -L "https://api.openai.com/v1/videos/$VIDEO_ID/content" \
  -H "Authorization: Bearer $OPENAI_API_KEY" --output clip.mp4

Key parameters on POST /v1/videos, from the API reference:

Parameter	Type	Notes
prompt	string	Required. Describe shot type, subject, action, setting, and lighting.
model	string	sora-2 (default) or sora-2-pro.
seconds	integer	Reference lists 4, 8, or 12, default 4; the current guide describes 16- and 20-second generations. See the gotcha below.
size	string	1280x720, 1920x1080, 1080x1920, and 1024p variants, matching the pricing table.
input_reference	object	{ "file_id": ... } or { "image_url": ... } for image-guided generation.

For long-running pipelines, webhooks are more efficient than polling: OpenAI emits video.completed and video.failed events, each carrying the job ID, so your worker only wakes up when a render finishes.

Common errors and integration gotchas

The failures that cost real time are rarely syntax errors. In rough order of frequency:

• Assuming generation is synchronous. A render takes minutes. Code that treats the create call as the finished result, or polls without backoff, is the classic bug. Design for queued → in_progress → completed/failed from the start.
• Losing the download window. Download URLs expire one hour after generation. Teams that download lazily (or only on the webhook, which may arrive late) get 404s and have to re-render. Download immediately, then move the file to your own storage.
• Guardrail rejections. Real people, human faces in input images, copyrighted characters, and copyrighted music are rejected. These failures surface as job errors, sometimes after minutes of queue time — validate prompts and reference assets before submitting.
• The seconds documentation conflict. The API reference for POST /v1/videos lists allowed seconds values of 4, 8, and 12 with a default of 4, while the current video generation guide describes 16- and 20-second generations on both models. The two pages disagree; if a duration you need is rejected, that is why. Test in your own account and pin the value that works.
• Free tier confusion. “Is OpenAI API free?” is one of the most asked questions about this API, and the answer for video is no: the sora-2 model page states the free tier is not supported. Budget a funded account before you start.
• Post-shutdown behavior. After September 24, 2026, requests to /v1/videos and the sora-2 models will fail. If you are building today, treat every hard-coded model name and endpoint as a migration point, and add a provider abstraction now rather than after the 404s start.

After September 24, 2026: what to build on instead

OpenAI has not listed a replacement for the Videos API, so “the OpenAI video API” as a distinct endpoint family will stop existing on that date. What continues: the consumer Sora product (OpenAI’s Sora announcement page is live and describes video generation up to a minute long), and OpenAI’s image generation API, which is not affected by this deprecation.

That leaves three honest routes for a team that needs video generation in September and beyond:

1. Stay on OpenAI’s platform for images, move video elsewhere. OpenAI’s image models (gpt-image-2) are unaffected. If your product’s video needs are the same text-to-video and image-to-video tasks, model providers like Google (Veo), Kling, ByteDance (Seedance/Wan), Vidu, and MiniMax (Hailuo) offer per-second billed video APIs — our Veo vs Sora comparison digs into the closest direct alternative.
2. Use an aggregator to keep one key and one bill. Modellix aggregates image and video generation models from more than 10 providers behind a single REST API with pay-as-you-go billing — over 200 models in the catalog, including OpenAI image models and per-second video routes from vendors like Kling, Google, and MiniMax. We are an aggregator, and this is the part where we have a commercial interest, so the honest caveats: Modellix does not currently offer OpenAI’s video models (check our OpenAI provider page — the catalog covers OpenAI’s image and transcription models, not Sora), and we are not claiming this route is cheapest; the point is operational, not a price ranking. Live per-model pricing is on the Modellix pricing page.
3. Evaluate a direct multi-vendor setup. If you need OpenAI for images and another vendor for video, running two SDKs, two keys, and two invoices is workable — it just costs engineering time and opaque cross-vendor accounting.

Whichever route you take, a five-point migration checklist:

• Decide now, not in October. The API is fully functional today; treating the shutdown as an October problem is how integrations get stranded.
• Isolate the provider. One client class per vendor; no hard-coded model IDs in business logic.
• Standardize the task model. Your internal “render a clip” contract (prompt, duration, resolution, callback) should be vendor-neutral.
• Re-verify pricing the week you switch. Video prices move; the table in this article is dated August 19, 2026 and must be re-checked against each vendor’s live page before you commit budget.
• Plan the asset pipeline once. Download, store, thumbnail, and transcode steps are identical across vendors — build them once and reuse.

Frequently Asked Questions

Can OpenAI generate videos?

Yes. OpenAI’s video generation models are Sora 2 and Sora 2 Pro, served through the Videos API. As of August 2026, that API is deprecated with a shutdown date of September 24, 2026; the consumer Sora product is not part of that shutdown.

How much does the Sora 2 API cost?

Per second of output: sora-2 at 720p is $0.10/second, sora-2-pro is $0.30/second at 720p, $0.50/second at 1024p, and $0.70/second at 1080p (standard rates, verified August 19, 2026). Batch API prices are half. The free tier does not support this model.

Is the Sora API being shut down?

The Videos API and all Sora 2 model aliases and snapshots are scheduled to shut down on September 24, 2026, per OpenAI’s deprecations page. No replacement has been listed.

Can I call the OpenAI video API from Python?

Yes. The official openai Python SDK exposes client.videos.create(), client.videos.retrieve(), and client.videos.download_content(); the section “Quick start: generate a video with the API” above has a complete, copy-pasteable example.

Is video generation available through the Responses API?

OpenAI’s documentation does not currently describe video generation through the Responses API for the sora-2 family; video generation is documented under the dedicated Videos API, which is the deprecated surface. Re-check OpenAI’s docs before relying on any endpoint path, since the platform is in transition.

Does Modellix offer OpenAI’s video models?

No. Modellix’s OpenAI catalog covers image generation and transcription models (for example gpt-image-2), not Sora. Modellix does aggregate video generation models from other providers — Google, Kling, ByteDance, Vidu, and MiniMax among them — behind one API key.

What are the best OpenAI video API alternatives?

The closest direct alternative to Sora 2 is Google’s Veo family; Kling, ByteDance Seedance/Wan, Vidu, and MiniMax Hailuo also provide per-second billed text-to-video and image-to-video APIs. “Best” depends on your quality bar, latency, and budget — compare the same prompt, duration, and resolution across vendors before deciding.

How long can a Sora 2 video be?

The current guide describes 16- and 20-second generations on both models, with extensions that add up to 20 seconds per call and a 120-second maximum per video. Note the API reference lists 4/8/12 seconds for the create endpoint — test the duration you need in your own account.

---

Provider details and pricing reflect public information as of August 19, 2026, and change frequently. Validate against each provider’s live pricing before committing. Access image and video models, including the leading Chinese models, through a single API key at modellix.ai.

Run a Multi-Model Test Compare Live Pricing