Editorial Modellix cover reading OpenAI Video Generation API over the subtitle Integration Guide Pricing and Code, showing a glass video pipeline with two model nodes and a film strip

If you are evaluating the OpenAI video generation API today, the first fact you need is a date, not a model name: September 24, 2026. OpenAI’s deprecations page lists the Videos API, both sora-2 and sora-2-pro, and their dated snapshots for removal on that day, with an empty recommended-replacement column for every row. As of September 9, 2026 — the day every figure in this guide was verified — the API still works and still bills normally, but it is a terminating option with a fifteen-day runway, and OpenAI has not announced what comes after.

This guide is the integration handbook for that window and for the decision around it. You get the current model IDs and endpoint surface, same-day per-second pricing pulled from OpenAI’s pricing page, working Python and curl code, the failure modes that cost real time, and an honest read of what to build on after September 25. It is deliberately narrower than our separate OpenAI video API guide, which covers the shutdown timeline, every deprecated model name, and the migration question in depth; this article assumes you want to make the generation call itself and need the code-level details, verified today. Modellix is an API aggregator and has a commercial interest in the alternative part of this article; the facts about OpenAI’s API come from OpenAI’s documentation and stand on their own.

What the OpenAI video generation API is in September 2026

OpenAI’s video generation API is the Videos API, and it exposes exactly two current models. sora-2 is the fast, cheaper tier for iteration — concepting, rough cuts, social clips. sora-2-pro is the production tier: slower, more expensive, and the only one that exports 1080p (1920x1080 or 1080x1920). Both generate 16- and 20-second clips with synced audio, per the current video generation guide. The default snapshot for sora-2 is sora-2-2025-12-08, and dated snapshots (sora-2-2025-10-06, sora-2-pro-2025-10-06) can be pinned by model name — though pinning buys you nothing here, because the deprecations page puts the snapshots on the same September 24 removal list as the aliases. Everything goes on that date.

Three pieces of context keep this API from looking better or worse than it is:

  • The whole consumer side is already gone. OpenAI’s Sora discontinuation help article, updated within days of this writing, states that the Sora web and app experiences were discontinued on April 26, 2026. The shutdown is not limited to the API, and it is not upcoming — the consumer product has been dark for months.
  • OpenAI has exited video generation as a product line. The BBC’s reporting on the closure records that the Sora team’s work is being redirected to world-simulation research for robotics, and that the Disney licensing deal tied to Sora was dissolved. There is no Sora 3 successor because video is no longer on the roadmap — which is why the deprecations page has no replacement to point at.
  • The docs are mid-transition and contradict each other. OpenAI’s own video generation guide and the Create video API reference disagree on allowed durations and sizes (details in the gotchas section below). When a vendor’s own pages disagree, treat every parameter default as something to test in your account, not something to trust from a tutorial.

One more thing the API will not do: no free tier. The sora-2 model page prices the model in dollars per second, and video generation requires a funded OpenAI account — budget that before you start, not after the first 402.

OpenAI video generation API pricing: per-second rates, verified September 9, 2026

OpenAI bills video generation per second of output, by model and resolution. The table below was read from the official pricing page on September 9, 2026. Prices move; treat this as a dated snapshot, and re-check the page before you commit budget.

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

To make the unit concrete: an 8-second sora-2 clip at 720p costs $0.80 (8 × $0.10). The same length on sora-2-pro at 1080p costs $5.60 (8 × $0.70), and a 20-second 1080p pro render is $14.00. The Batch API halves every rate — worth it for offline render queues where latency does not matter.

Throughput limits scale with your usage tier, not with spend per render: the sora-2 model page lists standard RPM caps of 25 (Tier 1), 50 (Tier 2), 125 (Tier 3), 200 (Tier 4), and 375 (Tier 5). Because a single render takes minutes, the constraint you will actually hit is concurrent jobs rather than requests per minute — design your queue accordingly, and poll with backoff rather than tight loops.

Generate a video: Python and curl, end to end

Video generation is asynchronous: you submit a job, poll it to completion, then download the MP4. Every language binding for the Videos API is this same three-step shape, which is the single most useful thing to internalize before reading code.

Prerequisites: an OpenAI API key on a funded account (no free tier for video, as noted above) and the official openai Python SDK (pip install openai).

The minimal flow in Python — create, poll, download — including the thumbnail variant that costs nothing extra:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import time
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",   # the reference default is portrait 720x1280 — set it explicitly
    seconds=8,
)
print("job:", video.id, video.status)

while video.status in ("queued", "in_progress"):
    time.sleep(10)  # 10–20s with exponential backoff is fine
    video = client.videos.retrieve(video.id)
    print(video.status, getattr(video, "progress", None))

if video.status == "completed":
    with open("kite.mp4", "wb") as f:
        f.write(client.videos.download_content(video.id).read())
    # Thumbnail and spritesheet are separate downloads, not separate jobs:
    with open("kite-thumb.webp", "wb") as f:
        f.write(client.videos.download_content(video.id, variant="thumbnail").read())
else:
    print("failed:", video.error)

The same job over REST with curl, so you can see the raw wire shape:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 1. Submit the job
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
  }'
# → {"id": "video_...", "status": "queued", ...}

# 2. Poll until status is "completed" or "failed" (10–20s intervals)
curl "https://api.openai.com/v1/videos/$VIDEO_ID" \
  -H "Authorization: Bearer $OPENAI_API_KEY"

# 3. Download — the URL is only valid for 1 hour after generation
curl -L "https://api.openai.com/v1/videos/$VIDEO_ID/content" \
  -H "Authorization: Bearer $OPENAI_API_KEY" --output clip.mp4

The response object carries id, status (queued / in_progress / completed / failed), progress, seconds, size, and — on failure — an error object with code, message, and a misalignment block whose error_type values classify content-policy rejections (SafetyAlertErrorType). Read the error block before writing your retry logic: retrying a policy rejection is wasted spend.

For image-guided generation, you send the reference image either as multipart upload or as JSON. Multipart is the direct route:

1
2
3
4
5
6
7
8
curl -X POST "https://api.openai.com/v1/videos" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: multipart/form-data" \
  -F 'prompt="She turns around and smiles, then slowly walks out of the frame."' \
  -F 'model="sora-2-pro"' \
  -F 'size="1280x720"' \
  -F 'seconds="8"' \
  -F 'input_reference="@sample_720p.jpeg;type=image/jpeg"'

In JSON requests (including Batch), input_reference becomes an object with either file_id or image_url — the file must match the requested output resolution, and supported formats are JPEG, PNG, and WebP. Key parameters on POST /v1/videos, straight from the API reference:

Parameter Value Notes
prompt string Required. Describe shot type, subject, action, setting, and lighting.
model sora-2 (default) or sora-2-pro Snapshots also accepted; all of them shut down September 24, 2026.
seconds 4, 8, 12 per the reference (default 4) The guide describes 16- and 20-second generations — see the docs-conflict gotcha.
size 720x1280, 1280x720, 1024x1792, 1792x1024 Reference default is portrait 720x1280; 1080p sizes appear on the guide and pricing page but not in this enum.
input_reference { "file_id": ... } or { "image_url": ... } First frame of the clip; image must match output resolution.

OpenAI-compatible video calls on Modellix

See how to run video generation jobs through Modellix's async task API with one key — including polling and error handling.

View Docs

Beyond text-to-video: the rest of the Videos API surface

The plain create-and-download flow is most of what tutorials cover, but the endpoint family has six more members worth knowing before you architect around them — some of them have limits that change the design.

  • Characters (POST /v1/videos/characters): upload a short MP4 of a reusable non-human subject (a mascot, an object) with a name, then pass characters: [{ "id": "char_..." }] on a create call and mention the name verbatim in the prompt. Character uploads depicting human likeness are blocked by default, a video can carry up to two characters, and the feature works best on short clips. Extensions do not support characters — plan around that if you need both.
  • Extensions (POST /v1/videos/extensions): continue a completed clip by passing { "video": { "id": ... }, "prompt": ..., "seconds": ... }. The guide documents up to 20 additional seconds per call and a 120-second ceiling per video; the output is a new stitched video, billed as a new generation.
  • Edits (POST /v1/videos/edits): targeted changes to an existing video (palette, staging, one element). Pass a video ID and the model is inferred; upload a new source video and you must set model explicitly. OpenAI’s own docs mark the older remix route as deprecated — use edits for new integrations.
  • Batch API: queue many renders offline by writing JSONL lines that each mirror a POST /v1/videos body, then submit through the batch guide. Batch supports the create endpoint only, is JSON-only (no multipart, so input_reference goes through file_id or image_url), and batch-generated videos stay downloadable for 24 hours instead of one.
  • Library management: GET /v1/videos lists your jobs (with limit, after, and order for pagination); DELETE /v1/videos/{video_id} removes one from OpenAI’s storage. GET /v1/videos/{video_id}/content accepts a variant parameter — video (default), thumbnail, or spritesheet — which is how the Python example above fetched a thumbnail without a second job.
  • Webhooks: instead of polling, register a webhook to receive video.completed and video.failed events, each carrying the job ID. This is the right pattern for anything that renders unattended.
Glass and chrome endpoint map showing one core video creation node surrounded by satellite routes for characters, extensions, edits, batch, and content downloads

Figure: the Videos API request surface — one async create flow in the middle, satellite endpoints around it. Concept diagram generated for this article, not a screenshot of the console.

Integration gotchas that cost real time

The failures that burn days on a first integration are rarely syntax errors. In rough order of frequency:

  • Treating creation as synchronous. A render takes minutes. Code that reads the create response as the finished result, or polls in a tight loop without backoff, is the classic first bug. Design for queued → in_progress → completed/failed from the start, and surface progress to your users.
  • Losing the download window. Content URLs expire one hour after generation. Teams that download lazily — or only on a webhook, which can arrive late — get 404s and have to re-render. Download immediately, then move the file to your own storage.
  • OpenAI’s docs contradict each other on duration and size. The video generation guide describes 16- and 20-second generations and 1080p exports, and even mentions 480p renders in its latency notes; the Create video reference allows only seconds of 4/8/12 and four sizes topping out at 1024p, with a portrait default. The two pages have disagreed for months. Send the exact value you need, test it in your own account, and pin what works rather than trusting either page blindly.
  • Content-policy rejections arrive late, as job failures. Real people (including public figures), human faces in input images, copyrighted characters, and copyrighted music are all rejected. Because video jobs queue, a rejected prompt can fail minutes after submission with a misalignment error block — validate prompts and reference assets before submitting, and do not auto-retry policy rejections.
  • Pinning a snapshot does not extend the runway. All three dated snapshots (sora-2-2025-10-06, sora-2-pro-2025-10-06, sora-2-2025-12-08) sit on the same September 24 removal list as the aliases. There is no legacy carve-out to migrate to.
  • The free-tier question has a clean answer. There is no free tier for video generation; searches for “openai video generation api free” mostly surface consumer tools. A funded account is a hard prerequisite.
  • Batch is stricter than the live API. JSON only, create endpoint only, assets pre-uploaded. Multipart workflows do not port to Batch unchanged.

After September 24: build now, build differently, or skip

The honest framing for a consideration-stage decision: integrating OpenAI’s video generation API in September 2026 is a bet with a known expiry. The three defensible postures are:

  1. Skip OpenAI video entirely. If you are starting from zero and have no OpenAI-specific constraint, a video API from Google (Veo), Kling, ByteDance, Vidu, or MiniMax gives you the same text-to-video and image-to-video primitives without a 15-day clock. Our text-to-video API landscape guide and the best AI video generation APIs 2026 roundup are the fastest way to compare; the Veo 3.1 API guide carries a full per-second price table verified September 8, 2026, and the image-to-video API guide covers first-frame workflows across vendors.
  2. Build now, designed for a September 25 swap. If Sora 2’s output quality or the OpenAI billing relationship matters to you in the next two weeks, use them — but isolate the provider behind a thin client from day one, so that swapping the model ID, base URL, and auth is a configuration change instead of a rewrite. The five-point migration checklist in our OpenAI video API guide applies verbatim; the abstraction below is the shape of it.
  3. Stay on OpenAI-adjacent infrastructure. OpenAI’s image generation API is not affected by this deprecation — gpt-image-2 and its edits endpoints keep running — and Microsoft still documents Sora 2 as a preview through Azure OpenAI Service / Microsoft Foundry with per-second billing and its own region availability (Sora 2 video generation overview). OpenAI’s September 24 removal applies to OpenAI’s own platform; verify availability on the Azure side before you rely on it, and note that the Azure route is a Microsoft service with its own preview lifecycle.
Glass cube showing one client interface with two swappable provider plugs, conveying a provider abstraction layer

Figure: the provider-abstraction pattern — your code talks to one interface; which vendor sits behind it becomes configuration. Concept diagram generated for this article.

The abstraction, kept deliberately small:

1
2
3
4
5
6
7
8
class VideoClient:  # your own thin interface
    def render(self, prompt: str, duration_s: int, size: str): ...

# OpenAI implementation (valid until 2026-09-24)
# class OpenAIVideo(VideoClient): ...  → openai.videos.create/retrieve/download_content

# Veo/Kling/etc. implementation (after 2026-09-24)
# class VendorVideo(VideoClient): ...  → same render() contract, different HTTP calls

If you want one key and one invoice across several video vendors rather than per-vendor accounts, an aggregator is the middle route — and this is where Modellix’s commercial interest sits, so the honest version: Modellix does not carry OpenAI’s video models (our OpenAI provider page lists image and transcription models such as gpt-image-2, which remains available at $0.1899 per image on its model page, verified today) but does aggregate per-second video routes from other providers — Google, Kling, ByteDance, Vidu, MiniMax — behind a single REST API with pay-as-you-go billing and per-task cost logs (Modellix API docs). None of that is a price argument: an aggregator can be cheaper or more expensive than a direct vendor on any given day, and we are not claiming otherwise. The operational case is the single key and single bill when OpenAI video stops being an option on September 25.

Start Generating on Modellix

Log in to call video models from multiple vendors through one Modellix key when OpenAI's video API shuts down.

Login

Frequently Asked Questions

Does OpenAI still have a video generation API?

Yes, until September 24, 2026. The Videos API with sora-2 and sora-2-pro (plus dated snapshots) is deprecated and shuts down on that date, per OpenAI’s deprecations page; the consumer Sora app and web product were already discontinued on April 26, 2026.

How much does the OpenAI video generation API cost?

Per second of output: sora-2 at 720p is $0.10/sec; sora-2-pro is $0.30/sec at 720p, $0.50/sec at 1024p, and $0.70/sec at 1080p, verified September 9, 2026. Batch API prices are half. There is no free tier.

Is there a successor to the OpenAI video generation API?

OpenAI has not listed a replacement — the recommended-replacement column on its deprecations page is empty for every video row, and OpenAI has said it is shifting the Sora team’s work toward world-simulation research. Microsoft separately documents Sora 2 as a preview through Azure OpenAI Service / Microsoft Foundry, with availability to check per region.

Can I call the OpenAI video generation API from Python?

Yes. The official openai Python SDK exposes client.videos.create(), client.videos.retrieve(), and client.videos.download_content() (the latter accepts a variant for thumbnails); the “Generate a video” section above has a complete copy-pasteable example including polling.

How is this article different from your OpenAI video API guide?

Our OpenAI video API guide is the shutdown-and-migration overview: the deprecation timeline, every affected model name, and the three migration routes. This article is the generation-side handbook: current model IDs and endpoints, same-day pricing, runnable code, and the request surface beyond plain text-to-video. Both were verified against OpenAI’s live pages on their respective dates; the earlier guide’s August snapshot has since been superseded by OpenAI’s confirmation that the consumer Sora product ended in April.

Does Modellix offer OpenAI’s video models?

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

Provider details and pricing reflect public information as of September 9, 2026, and change frequently — OpenAI’s video API shuts down September 24, 2026, with no replacement announced, and Microsoft’s Sora 2 preview has its own availability lifecycle. Validate against each provider’s live pricing and deprecations pages before committing. This article was written by Modellix, an API aggregator with a commercial interest in the single-key route it describes; the OpenAI integration material above is drawn from OpenAI’s own documentation. Access image and video models, including the leading Chinese models, through a single API key at modellix.ai.