codeYaan Logo Blog
Home Blog Services Courses
Login
OpenAI Sora: Text-to-Video AI Tutorial
HOW TO GUIDES Jan. 7, 2026, 5:30 p.m.

OpenAI Sora: Text-to-Video AI Tutorial

OpenAI Sora is the newest breakthrough in generative AI, turning plain text prompts into high‑quality video clips in seconds. While the hype often focuses on the flashy visuals, the real power lies in how developers can embed text‑to‑video generation directly into apps, games, and learning platforms. In this tutorial we’ll walk through the entire pipeline—setting up the API, crafting prompts, handling output, and polishing the result—so you can start building with Sora today.

What Is OpenAI Sora?

Sora is OpenAI’s multimodal model that accepts a natural‑language description and returns a short video (typically 5‑15 seconds). Under the hood it combines a diffusion‑based video generator with a language model that guides scene composition, motion, and lighting. The API mirrors the familiar ChatCompletion endpoint, but the response contains a URL to an MP4 file instead of plain text.

Key features include:

  • Prompt flexibility – you can describe characters, actions, camera angles, and even mood.
  • Control tokens – optional parameters like --duration or --style let you fine‑tune length and visual aesthetics.
  • Safety filters – built‑in content moderation ensures generated videos respect community standards.

Because Sora returns a downloadable video file, you can treat it like any other media asset: stream it in a web player, embed it in a React component, or feed it to a video‑editing pipeline.

Getting Started: Environment Setup

Before you can call Sora, you need an OpenAI API key with video access. If you don’t have one, request it from the OpenAI dashboard under “Beta Features → Sora”. Once you have the key, install the official Python client.

# Install the OpenAI Python SDK (v1.2+ includes video support)
pip install --upgrade openai

Next, create a small utility module to centralise the API key and handle basic error logging. This keeps your main script clean and makes it easier to swap keys for different environments.

# utils.py
import os
import openai
import logging

# Load API key from environment variable for security
openai.api_key = os.getenv("OPENAI_API_KEY")

def generate_video(prompt: str, **options):
    """
    Calls the Sora endpoint with a text prompt.
    Returns the URL of the generated MP4 file.
    """
    try:
        response = openai.Video.create(
            model="sora-1.0",
            prompt=prompt,
            **options
        )
        return response["data"]["url"]
    except openai.error.OpenAIError as e:
        logging.error(f"Sora generation failed: {e}")
        raise

Store your API key in a .env file or export it in your shell. Never hard‑code it in source files.

First Hands‑On: Simple Prompt to Video

Let’s generate a 7‑second clip of a sunrise over a mountain range. This example demonstrates the minimal required code and shows how to download the resulting video.

# simple_demo.py
import requests
from utils import generate_video

prompt = (
    "A time‑lapse of a sunrise over a rugged mountain range, "
    "soft pastel colors, gentle camera pan from left to right."
)

# Request a 7‑second video in cinematic style
video_url = generate_video(
    prompt,
    duration=7,
    style="cinematic",
    resolution="720p"
)

print(f"Video URL: {video_url}")

# Download the MP4 file locally
response = requests.get(video_url)
with open("sunrise.mp4", "wb") as f:
    f.write(response.content)

print("Saved as sunrise.mp4")

Run the script with python simple_demo.py. Within a few seconds you’ll see a short MP4 file that you can play in any media player. Notice how the style flag influences color grading, while resolution determines the output size.

Understanding the Parameters

  • duration – length in seconds (max 15 for most plans).
  • style – predefined visual themes such as cinematic, anime, pixel‑art.
  • resolution – supports 480p, 720p, and 1080p.

These arguments are optional; if omitted, Sora falls back to its default 5‑second, 720p, neutral style.

Pro tip: When experimenting, start with low resolution and short duration to reduce latency and cost. Once you’re happy with the composition, increase the settings for production quality.

Advanced Example: Multi‑Scene Narrative

Real‑world applications often need more than a single static clip. Suppose you’re building an educational app that explains the water cycle. You can chain multiple Sora calls, stitch the results together, and add voice‑over narration.

  1. Define a storyboard as a list of scene prompts.
  2. Generate each scene concurrently (using asyncio for speed).
  3. Merge the MP4 files with ffmpeg.
  4. Overlay a narrated audio track.

Below is a complete, runnable example that produces a three‑scene video (evaporation, condensation, precipitation) and adds a synthetic voice using OpenAI’s Text‑to‑Speech (TTS) model.

# water_cycle.py
import asyncio
import os
import subprocess
import requests
from utils import generate_video
import openai

openai.api_key = os.getenv("OPENAI_API_KEY")

# 1️⃣ Storyboard definition
SCENES = [
    {
        "prompt": "A bright sun heating a vast ocean, water vapor rising in soft wisps, cinematic style.",
        "duration": 6,
        "filename": "evaporation.mp4",
        "narration": "The sun heats the ocean, causing water to evaporate into vapor."
    },
    {
        "prompt": "Clouds forming high in the sky, water droplets coalescing, gentle pastel colors.",
        "duration": 5,
        "filename": "condensation.mp4",
        "narration": "The vapor rises, cools, and condenses into clouds."
    },
    {
        "prompt": "Heavy rain falling over a lush forest, droplets splashing, dramatic lighting.",
        "duration": 7,
        "filename": "precipitation.mp4",
        "narration": "When clouds become saturated, the water returns to Earth as rain."
    }
]

async def generate_scene(scene):
    video_url = generate_video(
        scene["prompt"],
        duration=scene["duration"],
        style="cinematic",
        resolution="720p"
    )
    r = requests.get(video_url)
    with open(scene["filename"], "wb") as f:
        f.write(r.content)
    print(f"Saved {scene['filename']}")

async def main():
    # 2️⃣ Generate all scenes in parallel
    await asyncio.gather(*(generate_scene(s) for s in SCENES))

    # 3️⃣ Concatenate videos with ffmpeg
    concat_file = "concat.txt"
    with open(concat_file, "w") as f:
        for s in SCENES:
            f.write(f"file '{s['filename']}'\n")
    subprocess.run(
        ["ffmpeg", "-f", "concat", "-safe", "0", "-i", concat_file,
         "-c", "copy", "water_cycle_raw.mp4"],
        check=True
    )
    print("Combined raw video: water_cycle_raw.mp4")

    # 4️⃣ Generate narration using OpenAI TTS (assume model "tts-1")
    narration_text = " ".join(s["narration"] for s in SCENES)
    tts_response = openai.Audio.speech.create(
        model="tts-1",
        voice="alloy",
        input=narration_text
    )
    with open("narration.mp3", "wb") as f:
        f.write(tts_response.content)
    print("Saved narration.mp3")

    # 5️⃣ Merge audio & video
    subprocess.run(
        ["ffmpeg", "-i", "water_cycle_raw.mp4", "-i", "narration.mp3",
         "-c:v", "copy", "-c:a", "aac", "-shortest", "water_cycle_final.mp4"],
        check=True
    )
    print("Final video ready: water_cycle_final.mp4")

if __name__ == "__main__":
    asyncio.run(main())

This script demonstrates a production‑ready workflow:

  • Parallel API calls cut total generation time from ~30 seconds to ~10 seconds.
  • Using ffmpeg for concatenation keeps the video quality lossless.
  • OpenAI’s TTS adds a professional‑grade voiceover without external services.
Pro tip: Cache each scene’s MP4 locally (e.g., with a hash of the prompt) so you don’t re‑generate unchanged clips during iterative development.

Real‑World Use Cases

Now that you’ve seen the mechanics, let’s explore where Sora can add genuine value.

1. Interactive E‑Learning

Imagine a language‑learning platform where each new vocabulary word is illustrated by a short animation. Instead of static images, a 5‑second clip shows the word in context—e.g., “apple” becomes a video of an apple falling from a tree. This boosts retention by engaging visual memory.

2. Dynamic Marketing Assets

Small businesses often lack the budget for professional video production. With Sora, a marketer can generate product teasers on the fly: simply feed a product description and let the model create a looping background video for social media ads.

3. Game Prototyping

Indie developers can prototype cutscenes without hiring animators. By feeding scene scripts into Sora, they obtain quick visual references that can be refined later or used directly in low‑poly games where realism isn’t critical.

4. Personalized Storytelling

Platforms that generate personalized bedtime stories can now add a visual layer. A child’s name, favorite animal, and setting become a custom short video, turning a simple narrative into an immersive experience.

Best Practices & Optimization

  • Prompt engineering – be explicit about camera movement, lighting, and style. “Close‑up of a hummingbird hovering over a red flower, shallow depth of field, golden hour lighting” yields far better results than “bird on a flower”.
  • Cost awareness – Sora pricing is per second of generated video. Use the duration flag wisely, and consider lower resolutions for internal testing.
  • Post‑processing – Sora’s output is raw MP4. Apply color grading, subtitles, or branding with standard video tools (ffmpeg, Adobe Premiere, etc.) to match your brand guidelines.
  • Safety compliance – always run the returned URL through OpenAI’s content moderation endpoint before publishing, especially if prompts are user‑generated.
Pro tip: Combine Sora with a background removal model (e.g., segment-anything) to isolate characters and composite them onto custom scenes, dramatically expanding creative possibilities.

Deploying Sora in a Web Application

For front‑end developers, the workflow is straightforward: a React component sends the prompt to a backend endpoint, which calls generate_video and returns the MP4 URL. The client then streams the video using the HTML5 <video> tag.

# Flask endpoint (backend/api.py)
from flask import Flask, request, jsonify
from utils import generate_video

app = Flask(__name__)

@app.route("/api/create-video", methods=["POST"])
def create_video():
    data = request.json
    prompt = data.get("prompt")
    if not prompt:
        return jsonify({"error": "Prompt required"}), 400

    url = generate_video(
        prompt,
        duration=data.get("duration", 5),
        style=data.get("style", "cinematic"),
        resolution=data.get("resolution", "720p")
    )
    return jsonify({"video_url": url})

// React component (frontend/VideoCreator.jsx)
import { useState } from "react";

export default function VideoCreator() {
  const [prompt, setPrompt] = useState("");
  const [videoUrl, setVideoUrl] = useState("");

  const handleGenerate = async () => {
    const res = await fetch("/api/create-video", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ prompt })
    });
    const data = await res.json();
    setVideoUrl(data.video_url);
  };

  return (