How to Generate a Video With Sora Before the API Ends

To learn how to generate a video with Sora in July 2026, I would not send you to the discontinued web app: the only remaining route is OpenAI’s Videos API, and it is scheduled to shut down on 24 September 2026. That deadline turns a familiar creative tutorial into something more consequential. You can still generate short video with synchronised audio, image references, reusable non-human characters, extensions, edits, webhooks, and Batch processing, but every new workflow now needs an exit plan from its first line of code.

This guide gives you the practical path that still works. I explain how to prepare an API project, select Sora 2 or Sora 2 Pro, write a shot-level prompt, submit an asynchronous render, monitor progress, retrieve the MP4, calculate the true cost, and reduce failures caused by unsupported people, copyrighted material, mismatched reference images, excessive motion, or ambitious scene length. I also separate current API facts from historical consumer features so that old subscription tables do not mislead you.

The sharpest finding is not simply that Sora is closing. It is that the documentation itself now reflects a product in transition. OpenAI’s updated March 2026 prompting guide supports 16- and 20-second clips and 1080p Pro output, while portions of the endpoint reference still expose narrower values. I treat those differences as implementation risk, not trivia. By the end, you will know how to generate a video with Sora today, how to validate the live contract before spending, and which parts of your production system should remain portable when the API disappears.

The 2026 Access Reality: API-Only and Temporary

The first step is to discard advice written for the old Sora website, mobile app, ChatGPT subscription allowances, storyboard interface, social feed, or consumer credit packs. OpenAI states that the web and app experiences were discontinued on 26 April 2026. Its separate deprecation register states that the Videos API, the Sora 2 alias, Sora 2 Pro, and listed snapshots will be removed on 24 September 2026, with no recommended replacement published in that notice (OpenAI, 2026a; OpenAI, 2026d).

That means a ChatGPT Plus or Pro subscription is no longer the purchasing route for this workflow. API usage is billed separately through an OpenAI platform project. The current task is therefore closer to integrating a cloud media service than using a browser editor. You need an API key, a funded project, a local or server-side environment, storage for completed files, and logic for jobs that may remain queued or fail moderation.

Date	Product State	Practical Meaning
24 March 2026	API deprecation announced	New integrations inherit a fixed retirement date and should be treated as temporary.
26 April 2026	Web and app discontinued	Consumer tutorials, subscriptions, feeds, and interface screenshots are historical.
22 July 2026	Current editorial verification date	The Videos API remains documented and priced, but its remaining life is roughly two months.
24 September 2026	API and models scheduled for removal	Production systems require migration, archival, and fallback plans before this date.

For historical interface details and the vocabulary older tutorials still use, our earlier OpenAI Sora guide is useful context, but its consumer-plan material should not be treated as current access guidance.

“The challenges Sora faced reflect deeper limitations of AI’s creative capacities.”
Ahmed Elgammal, Rutgers University computer scientist, writing in The Conversation via TechXplore, April 2026

The sensible editorial position is balanced. The remaining API is still technically capable, and a short-lived integration can be rational for finishing a defined campaign, testing prompt assets, or exporting work before closure. It is not rational to build an undifferentiated long-term product whose core value depends exclusively on Sora remaining online.

What You Need Before the First Render

A reliable Sora request begins before the prompt. Set up one OpenAI project specifically for video generation so billing, rate limits, API keys, and logs remain isolated from other workloads. Store the key in an environment variable rather than in source code, and restrict access to server-side execution. Browser-side keys are exposed to users and should never be used for paid media generation.

Next, decide where completed assets will live. OpenAI’s documentation says downloadable video assets expire after a maximum of one hour, so a production job must copy the MP4 to durable object storage immediately after completion. The same content endpoint can provide a thumbnail and spritesheet, which are useful for review queues, media libraries, scrubbers, and editorial dashboards (OpenAI, 2026b). This one-hour rule is easy to miss because a successful job object is not the same thing as a permanent file archive.

Prepare a shot brief with one measurable outcome. State whether the render is a product insert, establishing shot, animated concept, mascot sequence, social clip, background plate, or editorial illustration. Define the target aspect ratio before creating any reference image because the input image must match the requested video size. Accepted reference formats are JPEG, PNG, and WebP. Human faces in input images are currently rejected, and real people, including public figures, cannot be generated through the general API.

Requirement	Current Rule	Operational Check
API access	Paid OpenAI platform project; Free tier not supported for Sora models	Confirm the model appears in the project and billing is active.
Authentication	Server-side API key	Load from an environment variable or managed secret store.
Reference image	JPEG, PNG, or WebP; must match target dimensions	Validate format, dimensions, file size, and absence of human faces.
Storage	Generated asset links expire within one hour	Download and copy to durable storage as soon as status becomes completed.
Moderation	Under-18-suitable content; no copyrighted characters/music or real people	Pre-screen prompt, reference asset, dialogue, and intended use.

A broader Sora video generator workflow can help teams translate creative goals into shot briefs, but the API retirement date should now sit at the top of every production checklist.

Finally, create a simple job record in your own database. At minimum, save your internal asset ID, OpenAI video ID, model, size, seconds, prompt version, creation time, status, error message, cost estimate, storage location, and review decision. That record makes retries auditable and preserves the creative intent after the API is no longer available.

How to Generate a Video With Sora Through the API

The remaining workflow is asynchronous. Your application submits a create request to POST /v1/videos, receives a job ID with a status such as queued or in_progress, then either polls GET /v1/videos/{video_id} or listens for a video.completed or video.failed webhook. After completion, it downloads the MP4 from GET /v1/videos/{video_id}/content (OpenAI, 2026b).

A Minimal Python Workflow for How to Generate a Video With Sora

The example below uses an eight-second 720p landscape render. It deliberately avoids the disputed 16- and 20-second values so it remains compatible with the narrower endpoint schema. It also saves the result immediately because the asset URL is temporary.

import os

from pathlib import Path

from openai import OpenAI

api_key = os.environ.get(“OPENAI_API_KEY”)

if not api_key:

    raise RuntimeError(“OPENAI_API_KEY is not set”)

client = OpenAI(api_key=api_key)

output_path = Path(“sora-output.mp4”)

video = client.videos.create_and_poll(

    model=”sora-2″,

    prompt=(

        “Wide locked-off shot of a cobalt ceramic teapot on a walnut table. “

        “Steam curls upward as morning window light crosses the frame. “

        “The lid lifts once, settles, and the camera remains still. “

        “Diegetic room tone only, no music, no text, no logos.”

    ),

    size=”1280×720″,

    seconds=”8″,

)

if video.status != “completed”:

    message = getattr(getattr(video, “error”, None), “message”, “Unknown error”)

    raise RuntimeError(f”Video failed: {message}”)

content = client.videos.download_content(video.id, variant=”video”)

content.write_to_file(output_path)

print(f”Saved {output_path.resolve()}”)

For interactive products, prefer webhooks over aggressive polling. OpenAI recommends reasonable polling intervals, such as 10 to 20 seconds, with exponential backoff. A render may take several minutes depending on the model, resolution, current load, and duration. Your interface should display queued and processing states rather than leaving the user with a frozen screen.

Use idempotency in your own application even if a specific video endpoint does not expose a convenient duplicate-prevention field. Generate an internal request fingerprint from the prompt version, model, size, seconds, and reference asset hash. Before retrying after a timeout, check whether the prior job exists. Otherwise, a network failure can produce two paid renders when the first request actually reached the service.

The official API reference publishes examples for HTTP, TypeScript, Python, Java, Go, Ruby, and command-line workflows. The underlying integration pattern remains the same: create, observe, retrieve, persist, review. Keep that sequence in a provider-neutral service layer so the final migration changes one adapter rather than your entire application.

Write Prompts as Shot Briefs, Not Wishes

Prompt quality is less about adjectives and more about visible, timed instructions. OpenAI’s March 2026 guide recommends defining framing, depth of field, action beats, lighting, palette, and sound. It also warns that repeated generations from the same prompt will vary, so iteration is part of the medium rather than evidence that the system is broken (Koenig et al., 2026).

“Treat your prompt as a creative wish list, not a contract.”
Robin Koenig, Joanne Shin, and Annika Brundyn, authors of OpenAI’s Sora 2 Prompting Guide, March 2026

I use a nine-part shot brief: purpose, duration, framing, subject, action, environment, light and palette, audio, and exclusions. The purpose keeps the render commercially useful. Duration controls how many actions can plausibly fit. Framing and camera movement determine spatial stability. A precise subject description reduces identity drift. One action written as observable beats is more reliable than a chain of events. The environment should include concrete objects, not abstract mood words. Light and colour anchors improve continuity. Audio should fit the available seconds. Exclusions remove text, logos, extra characters, abrupt cuts, or camera motion you do not want.

A Reusable Sora Prompt Template

Purpose: [What this shot must communicate]

Format: [4, 8, 12, 16, or 20 seconds; set duration in the API]

Camera: [Shot size, angle, lens feel, movement, depth of field]

Subject: [Distinctive appearance, materials, wardrobe, scale]

Action beats: [One visible action, timed in simple steps]

Setting: [Concrete foreground, midground, and background elements]

Lighting and palette: [Light direction, quality, 3 to 5 colour anchors]

Audio: [Short dialogue, ambience, or silence; no copyrighted music]

Constraints: [No logos, no text, no extra limbs, no abrupt cut, no real person]

A weak instruction says, ‘Make a cinematic luxury watch video.’ A stronger version says, ‘Eight-second macro product shot of an unbranded brushed-steel wristwatch on black slate. A narrow cool rim light traces the bezel while a warm reflection moves once across the crystal. The second hand advances smoothly. Slow 10-centimetre dolly-in, shallow depth of field, charcoal and steel palette, quiet mechanical tick, no hands, no logo, no text.’ The stronger prompt gives the model visible nouns, a plausible action, controlled movement, and a finite palette.

For a deeper explanation of how the second-generation model handles sound and cinematic continuity, read our Sora 2 cinematic analysis.

Do not ask prose to override API parameters. Writing ‘make it 20 seconds’ inside the prompt will not change a seconds field set to eight. Likewise, a request for ‘4K’ does not create an unsupported output size. The prompt controls the content of the container; the API call controls the container itself.

Choose the Model, Resolution, Duration, and Cost

Sora 2 is the iteration model. OpenAI positions it for concepting, prototypes, social media, and workflows where speed matters more than maximum fidelity. Sora 2 Pro is slower and more expensive but is intended for polished, stable, high-resolution work. Use Pro only after a cheaper draft has proved the composition, action, and timing. This two-stage approach reduces the most common financial mistake: paying premium rates to discover that the creative brief itself is wrong.

Model and Size	Standard Price/Second	Batch Price/Second	4 Seconds	8 Seconds	20 Seconds
Sora 2, 720p	$0.10	$0.05	$0.40	$0.80	$2.00
Sora 2 Pro, 720p	$0.30	$0.15	$1.20	$2.40	$6.00
Sora 2 Pro, 1024p	$0.50	$0.25	$2.00	$4.00	$10.00
Sora 2 Pro, 1080p	$0.70	$0.35	$2.80	$5.60	$14.00

These figures come from OpenAI’s current API pricing page and are priced per generated second, not per successful editorial approval (OpenAI, 2026c). A rejected prompt may fail before a render charge, but a technically successful output that your team discards is still production cost. Budget for variations. If a useful shot requires four attempts, the effective cost is four times the table value, before storage, review, editing, and staff time.

The hidden commercial limits are throughput and time. Sora 2 is not supported on the Free API tier. Documented Sora 2 request limits rise from 25 requests per minute at Tier 1 to 375 at Tier 5. Sora 2 Pro is tighter, from 10 requests per minute at Tier 1 to 150 at Tier 5. These are request limits, not promises that the rendering queue will complete at that speed. Video jobs remain asynchronous and can take several minutes.

There is also a documentation mismatch. The March 2026 prompting guide lists 4, 8, 12, 16, and 20 seconds and includes 1080p Pro sizes. The create endpoint reference captured during this review lists only 4, 8, and 12 seconds and sizes up to 1024×1792 or 1792×1024. The broader video guide supports 20-second generation and 1080p. Treat the latest guide as product intent but validate the live SDK schema and a low-cost test request before launching a 20-second or 1080p batch.

For context on how those costs compare with supported alternatives, our 2026 AI video generator comparison separates cinematic realism, control, commercial safety, and social-first speed rather than naming one universal winner.

Use Image References and Reusable Characters

Text alone leaves composition, wardrobe, materials, and colour relationships open to interpretation. An input reference image acts as the first frame and is the most direct way to lock a product, environment, mascot design, or art direction. The image must match the requested output dimensions exactly. A 1280×720 video therefore needs a 1280×720 reference. Mismatched sizes are a preventable source of rejection or unintended cropping.

Image references are best for one generation. Reusable characters are a separate feature designed for non-human subjects such as animals, mascots, or objects. You create a character from a short MP4 clip, then pass its character ID in future video requests and mention the character name verbatim in the prompt. OpenAI says character uploads currently work best with short two- to four-second source clips, matching aspect ratios, and 720p to 1080p material. A generation can include up to two characters (OpenAI, 2026b).

The distinction matters in production. A reference image anchors the opening frame but does not create a reusable identity record. A character asset can appear across multiple shots, but passing the ID alone is not enough. The prompt should repeat the same name and stable descriptive traits. Keep the source clip uncluttered, with one clear subject, neutral motion, consistent lighting, and enough views to communicate shape. Avoid busy backgrounds that the model may treat as part of the character.

Human likeness access is restricted. General character uploads that depict human likeness are blocked by default, and image references containing human faces are rejected. Do not design a campaign around a celebrity, employee, customer, or synthetic spokesperson unless your organisation has separately confirmed eligibility and consent requirements with OpenAI. Even then, rights clearance and disclosure remain editorial obligations, not mere API settings.

Teams comparing reference control across models can use our professional video model benchmark to understand why visual consistency, multimodal control, and provider stability should be evaluated separately.

A practical consistency workflow is to generate a clean still first, crop it to the final aspect ratio, use it as input_reference, and ask for one restrained action. Once that works, reuse the same descriptive nouns, palette anchors, and camera language in later prompts. Consistency improves when you reduce degrees of freedom, not when you add more poetic adjectives.

Extend and Edit Without Restarting

Sora’s extension and edit features can save money when a render is nearly correct. An extension continues an existing completed clip using the full source video as context, which helps preserve motion direction and scene continuity. Each extension can add up to 20 seconds, a video can be extended up to six times, and the documented maximum stitched duration is 120 seconds. Extensions accept a source video and prompt but do not currently support characters or image references (OpenAI, 2026b).

Use extension for continuation, not for changing the premise. A good extension prompt says, ‘Continue the same locked camera as the steam thins and morning light moves slowly across the table.’ A bad extension prompt introduces a new location, new cast, fast camera move, and different weather. The more the request departs from the original physical logic, the more likely continuity will fracture.

Editing is for a targeted change to an existing video. OpenAI’s guide says the system reuses the original structure, continuity, and composition while applying the modification. It works best when the request changes one variable: colour, lens feel, lighting temperature, prop position, or pacing. If the shot is close, edit it. If the action, staging, and identity are all wrong, regenerate from a simplified prompt.

The documentation is again in transition. One official guide states that the older remix endpoint is being deprecated in favour of an edits endpoint. The prompting cookbook presents an edit path with a video ID, while the main guide describes POST /v1/videos/edits. Before coding, inspect the current SDK method or generated API schema and do not hard-code a path copied from an old tutorial.

A useful contrast is Pika’s faster, transformation-led creative lane, described in our Pika AI video review. Sora’s remaining value is more cinematic and programmable, but Pika may be a better fit for playful social variations after Sora’s retirement.

Create an edit history in your asset record. Save the source video ID, edit instruction, new video ID, model, cost, and reviewer decision. This lineage is essential when one accepted clip is the fifth descendant of an earlier generation and the provider is about to remove the API that created it.

Design a Reliable Production Pipeline

A production-grade system should separate creative data from provider execution. Store the prompt, shot metadata, negative constraints, aspect ratio, duration, reference-asset hash, and review notes in your own schema. Then pass that neutral job specification to a Sora adapter. When Sora shuts down, the same job can be translated into another provider’s parameters without rewriting the editorial interface.

Use a state machine with explicit statuses: draft, validated, submitted, queued, processing, completed, failed, downloaded, reviewed, approved, rejected, and archived. Do not collapse completed and approved. Completed only means the provider returned a file. Approval requires human review for factual accuracy, brand compliance, continuity, rights, disclosure, audio quality, and technical artefacts.

Webhooks are the efficient default. Verify webhook signatures, enqueue the download task, fetch the video record again, and confirm the job belongs to your project before retrieving content. Make the handler idempotent because providers may retry delivery. If you must poll, start around 10 to 20 seconds, increase the interval gradually, and set a maximum wait time that moves stalled jobs to manual review rather than polling forever.

The Batch API is suitable for shot lists and offline queues. OpenAI says video Batch currently supports POST /v1/videos only, requires JSON rather than multipart uploads, and expects assets to be uploaded in advance or referenced through file IDs or image URLs. Batch is cheaper at the published rates, but it is not the right choice for an interactive editor where users expect immediate progress. It is best for overnight variants, localisation sets, scheduled campaign renders, and studio review queues.

Pipeline Layer	Recommended Design	Why It Survives Migration
Creative brief	Provider-neutral JSON with shot, action, camera, light, audio, and constraints	Preserves intent even when parameter names change.
Provider adapter	Maps neutral fields to Sora model, size, seconds, reference, and endpoints	Only the adapter must be replaced after sunset.
Job orchestration	Queue, webhook/polling, retries, idempotency, timeout, error capture	Asynchronous media generation is common across providers.
Asset storage	Immediate durable copy plus thumbnail, metadata, checksum, and lineage	Prevents provider expiry from becoming data loss.
Human review	Rights, factuality, continuity, safety, disclosure, and technical quality	Editorial standards remain constant across models.

Log cost at the job level. Estimate before submission from seconds and model, then reconcile after completion. Add a per-shot attempt count and an approval cost, which divides total spend by approved assets rather than generated assets. That metric exposes whether a nominally cheap model is producing expensive waste.

Moderation, Rights, and Provenance

The general Sora API enforces a narrower creative space than many users expect. OpenAI documents content suitable for audiences under 18, rejection of copyrighted characters and copyrighted music, inability to generate real people including public figures, default blocking of human-likeness character uploads, and rejection of input images containing human faces (OpenAI, 2026b). A prompt can be technically elegant and still fail because the subject or soundtrack is not permitted.

Rights review should happen before generation. Replace trademarked characters with original descriptions, licensed music with ambience or original sound, and celebrity references with non-identifying fictional subjects. Do not use ‘in the style of’ as a substitute for a legitimate visual brief. Describe objective production features such as lens, palette, lighting, material, period, and camera behaviour. This produces more controllable prompts and reduces unnecessary imitation risk.

“Harmful deepfakes and manipulated media will just migrate to platforms that are even more opaque and difficult to audit.”
Alon Yamin, CEO of Copyleaks, quoted by The Guardian, March 2026

OpenAI previously documented visible and invisible provenance signals, C2PA metadata, and internal tracing tools for Sora outputs. Because the first-party app is gone and the API is approaching retirement, publishers should not assume a watermark alone will communicate context. Preserve the original file, generation record, prompt, provider, model, date, editor, and disclosure language. If the video is materially illustrative or synthetic, label it where viewers encounter it, not only in hidden metadata.

The broader research warning is that platform design shapes output. A preliminary 2026 study generated 100 videos from the prompt ‘Depression’ across the former app and API. The app outputs showed recovery narratives in 78 percent of samples, compared with 14 percent for API outputs; the researchers also found narrow recurring visual symbols and demographic patterns (Flathers et al., 2026). The study is not a general quality benchmark, but it demonstrates that defaults and product layers can influence narrative framing.

For organisations seeking a more commercially governed alternative, our Adobe Firefly tutorial explains Adobe’s integrated creative workflow and its emphasis on brand and production controls.

Failure Modes and Performance Bottlenecks

The most expensive failures are not dramatic API errors. They are plausible-looking outputs that cannot be used: a product label mutates, a mascot changes shape, a hand appears, a camera move ignores the brief, dialogue overruns the clip, or a background object bends between frames. The remedy is systematic simplification, not longer prompts.

Symptom	Likely Cause	Best First Fix
Job rejected immediately	Real person, human face reference, copyrighted character/music, or unsuitable content	Remove the restricted element and pre-screen every input.
Subject changes identity	Description drift, multiple characters, busy background, or weak reference	Reuse exact descriptors, reduce cast, use a clean matching reference.
Motion breaks or objects deform	Too many actions, long duration, moving camera, or physical ambiguity	Use one action, shorter clip, locked camera, and concrete timing.
Dialogue is unsynchronised	Too many words for the duration or unclear speaker labels	Cut dialogue, label speakers, and give each line a short timing window.
Queue feels slow	High resolution, Pro model, long duration, or load	Prototype at 720p with Sora 2; use webhooks and honest progress states.
Download fails later	Temporary asset link expired	Copy the MP4 to durable storage immediately after completion.
Parameter rejected	Guide and endpoint schema are out of sync	Inspect current SDK schema and test with a low-cost request.

Start with the smallest stable shot. Freeze the camera, remove background extras, reduce the action to one beat, shorten the duration, and use Sora 2 at 720p. Once the subject and motion work, add one variable per iteration. OpenAI’s prompting guide makes the same practical point: shorter clips generally follow instructions more reliably, and two four-second clips may edit together better than one eight-second generation (Koenig et al., 2026).

Audio has a strict time budget. A four-second shot supports one or two short exchanges at most. An eight-second clip can hold a little more, but long speeches create pacing and synchronisation problems. Put dialogue in a clearly labelled block, keep speaker names consistent, and use background sound as a rhythm cue rather than an overdescribed soundtrack.

“If your model is not the top at any one thing, it’s very hard to get mass usership.”
Trevor Harries-Jones, Render Network Foundation board member, quoted by The Verge, March 2026

That market observation matters at the workflow level. Sora can still produce useful material, but its sunset removes the strongest reason to tolerate provider-specific friction. If your shot repeatedly fails, compare the use case against another model instead of assuming every problem is a prompt-writing failure.

When Sora Is the Wrong Choice and How to Migrate

Sora is the wrong choice for any new product that requires stable availability beyond September 2026, for real-person likeness without a separately approved programme, for copyrighted characters or music, for guaranteed deterministic continuity, for interactive low-latency rendering, or for a workflow that cannot tolerate several minutes of queue time. It is also a poor fit when legal teams need a long-term vendor commitment that the current deprecation notice does not provide.

The case for using it is narrower but real. A team may need to finish an existing campaign, reproduce an established Sora look, export pending assets, validate a short research hypothesis, or convert a library of shot briefs into final material while the service remains available. In those cases, cap the work, document the deadline, and avoid creating new dependencies.

Migration should begin with an inventory. Export every completed video, thumbnail, spritesheet, prompt, reference image, character source clip, metadata record, and review note. The discontinued consumer product warns that associated data may be permanently deleted after any final export window, so archival should not wait for September (OpenAI, 2026a). Then classify workflows by need: cinematic realism, native audio, character consistency, commercial governance, social effects, API throughput, or cost.

Do not choose a replacement from a universal ranking. Run the same five to ten shot briefs through shortlisted providers, with identical duration and aspect ratio where possible. Score prompt adherence, object consistency, camera control, audio, artefacts, latency, cost per approved shot, rights posture, and API stability. A provider that wins a beauty test but lacks durable access may recreate the same problem.

ByteDance’s model family is one alternative direction. Our Seedance 2 analysis focuses on multimodal control, physics, and multi-shot coherence, which may suit teams whose priority is structured continuity rather than Sora’s creative variation.

Keep prompts portable by separating universal cinematography language from provider syntax. Preserve the purpose, subject, action beats, framing, lighting, palette, audio, and exclusions as neutral fields. Map only model names, resolutions, durations, reference formats, and endpoint paths inside adapters. This design turns the Sora sunset from a rewrite into a controlled provider change.

Our Content Testing Methodology

This guide was verified against OpenAI’s live Sora discontinuation notice, API deprecation register, video generation guide, Sora 2 prompting cookbook, model rate-limit pages, create and remix references, and API pricing page on 22 July 2026. We compared overlapping documents rather than trusting a single endpoint page because the current materials contain meaningful differences in supported duration, resolution, and edit paths. Where documents conflict, the article states the discrepancy and recommends runtime validation with the current SDK schema.

We modelled the end-to-end implementation as a production workflow: project and secret setup, neutral shot schema, asynchronous job creation, polling or webhook completion, immediate asset download, durable storage, metadata lineage, human review, cost reconciliation, and migration. No paid generation was executed because the editorial environment did not include an OpenAI API key. Consequently, latency and output-quality observations are documented vendor guidance or cited research, not an original render benchmark.

Pricing calculations multiply OpenAI’s published per-second rates by clip duration. Commercial limits include the documented Free-tier exclusion, requests-per-minute tiers, one-hour asset expiry, maximum two reusable characters per generation, up to six extensions and 120 seconds total, reference-image format and dimension rules, and current moderation restrictions. Industry context and direct quotes were cross-checked against The Guardian, The Verge, and researcher-authored analysis.

This article was researched and drafted with AI assistance and reviewed by the Sami Ullah Khan editorial desk at Perplexity AI Magazine. All data, citations, pricing figures, and named quotes have been independently verified against primary sources before publication.

Conclusion

The practical answer to how to generate a video with Sora is now clear but temporary. Use the OpenAI Videos API, submit a controlled shot brief, select the cheapest model and resolution that can prove the idea, monitor the asynchronous job, download the MP4 within the asset window, and preserve every prompt and reference outside the provider. For refinement, use image references, non-human character assets, extensions, and focused edits rather than repeatedly restarting complex scenes.

The more important decision is whether the workflow should exist at all. OpenAI has already ended the consumer product and has scheduled the API and both Sora 2 models for removal on 24 September 2026. There is no announced replacement in the deprecation notice. That makes Sora suitable for bounded completion work and research, not a dependable foundation for a new long-term platform.

Open questions remain. OpenAI continues to describe world-simulation research as strategically important, competitors are improving quickly, and the underlying techniques may reappear in different products. None of that changes the current operational fact. A responsible team should finish what genuinely benefits from Sora, archive the evidence needed to govern those assets, and move the enduring parts of the workflow into a provider-neutral system before the deadline.

FAQs

Can I Still Generate a Video With Sora in 2026?

Yes, but only through OpenAI’s Videos API as of 22 July 2026. The Sora web and app experiences ended on 26 April 2026. OpenAI has scheduled the Videos API, Sora 2, and Sora 2 Pro for removal on 24 September 2026.

Is Sora Included With ChatGPT Plus or Pro Now?

The old consumer access model is no longer current because the Sora web and app experiences have been discontinued. The remaining API workflow is billed separately through an OpenAI platform project at published per-second rates.

How Much Does an Eight-Second Sora Video Cost?

At current standard rates, eight seconds costs about $0.80 with Sora 2 at 720p, $2.40 with Sora 2 Pro at 720p, $4.00 at 1024p, or $5.60 at 1080p. Batch prices are listed at half the standard rates.

What Is the Maximum Sora Video Length?

OpenAI’s March 2026 guide documents direct generations up to 20 seconds. Extensions can add up to 20 seconds each, up to six times, for a documented total of 120 seconds. Some endpoint-reference pages still list shorter values, so validate the current SDK.

Can Sora Generate Videos of Real People?

The general API documentation says real people, including public figures, cannot be generated. Input images containing human faces are rejected, and human-likeness character uploads are blocked by default unless separately approved.

Does Sora Generate Audio With Video?

Sora 2 and Sora 2 Pro output video with synchronised audio. Prompt dialogue directly, label speakers consistently, and keep lines short enough for the clip. Long speeches and crowded exchanges are more likely to lose timing and lip synchronisation.

Why Is My Sora Job Taking So Long?

Video generation is asynchronous and may take several minutes. Longer clips, higher resolutions, Sora 2 Pro, current API load, and queue conditions increase latency. Use webhooks, honest progress states, and 720p draft renders before premium output.

What Should Replace Sora After September 2026?

There is no single replacement for every use case. Compare supported providers using your own shot briefs and score prompt adherence, continuity, audio, latency, cost per approved asset, rights posture, API stability, and commercial fit.

References

OpenAI. (2026a). What to know about the Sora discontinuation. OpenAI Help Center.

OpenAI. (2026b). Video generation with Sora. OpenAI API Documentation.

Koenig, R., Shin, J., & Brundyn, A. (2026). Sora 2 prompting guide. OpenAI Cookbook.

OpenAI. (2026c). Pricing: Video generation models. OpenAI API Documentation.

OpenAI. (2026d). Deprecations: Sora 2 video generation models and Videos API. OpenAI API Documentation.

Kerr, D. (2026, March 24). OpenAI shutters AI video generator Sora in abrupt announcement. The Guardian.

Heath, A., & Weatherbed, J. (2026, March). Why OpenAI killed Sora. The Verge.

Elgammal, A. (2026, April 27). Sora shutdown reveals costly limits of AI video generation and creative use. The Conversation, republished by TechXplore.

Flathers, M., Smith, G., Herpertz, J., Zhou, Z., & Torous, J. (2026). Depictions of depression in generative AI video models: A preliminary study of OpenAI’s Sora 2. arXiv.