Videogenerierung mit Sora

Entdecken

Übersicht

Mit Sora erweitert OpenAI erneut die Möglichkeiten generativer Medien: Das hochmoderne Videomodell erstellt aus natürlicher Sprache oder Bildern detailreiche, dynamische Clips mit Ton. Sora baut auf jahrelanger Forschung zu multimodaler Diffusion auf und wurde mit vielfältigen visuellen Daten trainiert. Dadurch verfügt es bei der Generierung von Videos aus Text über ein tiefes Verständnis von dreidimensionalem Raum, Bewegung und Szenenkontinuität.

Die Videos API macht diese Funktionen erstmals für Entwickelnde zugänglich und ermöglicht es, Videos programmatisch zu erstellen, zu verlängern, zu bearbeiten und zu verwalten.

Damit kannst du:

• Neue Videos aus Prompts erstellen.
• Die Generierung mit einem Referenzbild steuern.
• Charakter-Assets bei mehreren Generierungen wiederverwenden, um eine höhere visuelle Konsistenz zu erzielen.
• Einen fertigen Clip durch Videoverlängerungen fortsetzen.
• Ein bestehendes Video gezielt bearbeiten.
• Fertige Videos und ergänzende Assets herunterladen.
• Große Warteschlangen mit Renderaufträgen zur Offline-Verarbeitung über die Batch API übermitteln.

Modelle

Das Sora-Modell der zweiten Generation ist in zwei Varianten erhältlich, die auf unterschiedliche Anwendungsfälle zugeschnitten sind.

Sora 2

sora-2 ist auf Geschwindigkeit und Flexibilität ausgelegt. Es eignet sich ideal für die Erkundungsphase, in der du mit Stimmung, Aufbau oder visuellem Stil experimentierst und schnelle Rückmeldungen wichtiger sind als perfekte Detailtreue.

Es liefert schnell Ergebnisse in guter Qualität und eignet sich daher gut für schnelle Iterationen, die Konzeptentwicklung und Rohschnitte. Für Social-Media-Inhalte, Prototypen und Szenarien, in denen schnelle Ergebnisse wichtiger sind als höchste Detailtreue, ist sora-2 oft mehr als ausreichend.

Sora 2 Pro

sora-2-pro liefert hochwertigere Ergebnisse. Es ist die bessere Wahl, wenn du Ergebnisse in Produktionsqualität benötigst.

Das Rendern mit sora-2-pro dauert länger und kostet mehr, liefert aber ausgereiftere, stabilere Ergebnisse. Es eignet sich am besten für hochauflösendes Filmmaterial mit Kinoästhetik, Marketingmaterialien und alle Situationen, in denen visuelle Präzision entscheidend ist.

Verwende sora-2-pro, wenn du 1080p-Exporte in 1920x1080 oder 1080x1920 benötigst.

Sowohl sora-2 als auch sora-2-pro unterstützen die Generierung von Videos mit einer Länge von 16 und 20 Sekunden.

Ein Video generieren

Die Generierung eines Videos ist ein asynchroner Prozess:

1. Wenn du den Endpunkt POST /videos aufrufst, gibt die API ein Auftragsobjekt mit einer id für den Auftrag und einem anfänglichen status zurück.

2. Du kannst den Endpunkt GET /videos/{video_id} wiederholt abfragen, bis der Status zu completed wechselt. Effizienter ist es, Webhooks zu verwenden (siehe den Abschnitt zu Webhooks weiter unten), um automatisch benachrichtigt zu werden, sobald der Auftrag abgeschlossen ist.

3. Sobald der Auftrag den Status completed erreicht hat, kannst du die fertige MP4-Datei mit GET /videos/{video_id}/content abrufen.

Einen Renderauftrag starten

Rufe zunächst POST /videos mit einem Text-Prompt und den erforderlichen Parametern auf. Der Prompt legt die kreative Gestaltung fest: Motive, Kamera, Beleuchtung und Bewegung. Parameter wie size und seconds steuern dagegen die Auflösung und Länge des Videos.

1
2
3
4
5
6
7
8
9
10import OpenAI from "openai";

const openai = new OpenAI();

let video = await openai.videos.create({
  model: "sora-2",
  prompt: "A video of the words 'Thank you' in sparkling letters",
});

console.log("Video generation started: ", video);

1
2
3
4
5
6
7
8
9
10from openai import OpenAI

openai = OpenAI()

video = openai.videos.create(
    model="sora-2",
    prompt="A video of a cool cat on a motorcycle in the night",
)

print("Video generation started:", video)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
)

func main() {
	client := openai.NewClient()
	video, err := client.Videos.New(context.Background(), openai.VideoNewParams{
		Model:  openai.VideoModelSora2,
		Prompt: "A video of the words 'Thank you' in sparkling letters",
	})
	if err != nil {
		panic(err)
	}
	fmt.Println("Video generation started:", video)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.videos.VideoCreateParams;

var video =
    client
        .videos()
        .create(
            VideoCreateParams.builder()
                .model("sora-2")
                .prompt("A paper airplane flying over a forest")
                .build());

System.out.println(video.id());

1
2
3
4
5require "openai"

client = OpenAI::Client.new
video = client.videos.create(model: "sora-2", prompt: "A paper airplane flying over a forest")
puts(video.id)

1
2
3
4
5
6
7curl -X POST "https://api.openai.com/v1/videos" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: multipart/form-data" \
  -F prompt="Wide tracking shot of a teal coupe driving through a desert highway, heat ripples visible, hard sun overhead." \
  -F model="sora-2-pro" \
  -F size="1280x720" \
  -F seconds="8" \

Die Antwort ist ein JSON-Objekt mit einer eindeutigen ID und einem anfänglichen Status wie queued oder in_progress. Das bedeutet, dass der Renderauftrag gestartet wurde.

12345678910{
  "id": "video_68d7512d07848190b3e45da0ecbebcde004da08e1e0678d5",
  "object": "video",
  "created_at": 1758941485,
  "status": "queued",
  "model": "sora-2-pro",
  "progress": 0,
  "seconds": "8",
  "size": "1280x720"
}

Größe und Dauer wählen

Wähle das kleinste Format, das die Anforderungen deiner Produktion erfüllt:

• Verwende kürzere Clips, wenn du Prompt, Bewegung oder Bildkomposition schrittweise verfeinerst.
• Generiere Videos mit einer Länge von bis zu 20 Sekunden, wenn du längere Handlungsmomente, ausführlichere Szenen oder umfangreichere Werbespots benötigst.
• Verwende sora-2-pro für Exporte mit höherer Auflösung in 1920x1080 oder 1080x1920.

Längere Videos und Renderaufträge in 1080p können deutlich mehr Zeit benötigen als kurze Renderings in 720p oder 480p. Plane daher bei Abläufen mit Nutzerinteraktion längere Wartezeiten ein.

Schutzmechanismen und Einschränkungen

Die API setzt mehrere inhaltliche Einschränkungen durch:

• Es sind nur Inhalte erlaubt, die für ein Publikum unter 18 Jahren geeignet sind (eine Einstellung zum Aufheben dieser Einschränkung wird künftig verfügbar sein).
• Urheberrechtlich geschützte Charaktere und urheberrechtlich geschützte Musik werden abgelehnt.
• Reale Personen, einschließlich Personen des öffentlichen Lebens, können nicht generiert werden.
• Charakter-Uploads, die das Aussehen von Menschen wiedergeben, werden standardmäßig blockiert.
• Eingabebilder mit menschlichen Gesichtern werden derzeit abgelehnt.

Achte darauf, dass Prompts, Referenzbilder und Transkripte diese Regeln einhalten, damit die Generierung nicht fehlschlägt.

Wirksame Prompts formulieren

Beschreibe für optimale Ergebnisse Einstellungsgröße, Motiv, Handlung, Schauplatz und Beleuchtung. Zum Beispiel:

• „Totale eines Kindes, das in einem Park mit Rasenflächen einen roten Drachen steigen lässt. Sonnenlicht zur goldenen Stunde, die Kamera schwenkt langsam nach oben.“
• „Nahaufnahme einer dampfenden Kaffeetasse auf einem Holztisch, Morgenlicht fällt durch Jalousien, geringe Schärfentiefe mit weichen Übergängen.“

So präzise Angaben helfen dem Modell, konsistente Ergebnisse zu erzeugen, ohne unerwünschte Details hinzuzuerfinden. Fortgeschrittene Techniken findest du in unserem Leitfaden zum Formulieren von Prompts für Sora 2.

Fortschritt verfolgen

Videogenerierung braucht Zeit. Je nach Modell, API-Auslastung und Auflösung kann ein einzelner Rendervorgang mehrere Minuten dauern.

Um den Fortschritt effizient zu verfolgen, kannst du den Status regelmäßig über die API abfragen oder dich über einen Webhook benachrichtigen lassen.

Status-Endpunkt regelmäßig abfragen

Rufe GET /videos/{video_id} mit der ID auf, die beim Erstellen zurückgegeben wurde. Die Antwort enthält den aktuellen Status des Auftrags, den Fortschritt in Prozent (falls verfügbar) und etwaige Fehler.

Typische Statuswerte sind queued, in_progress, completed und failed. Frage den Status in angemessenen Abständen ab (zum Beispiel alle 10–20 Sekunden), verwende bei Bedarf exponentielles Backoff und zeige den Nutzenden an, dass der Auftrag noch läuft.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24import OpenAI from "openai";
import { setTimeout as sleep } from "node:timers/promises";

const openai = new OpenAI();

async function main() {
  let video = await openai.videos.create({
    model: "sora-2",
    prompt: "A video of the words 'Thank you' in sparkling letters",
  });

  while (video.status === "queued" || video.status === "in_progress") {
    await sleep(2000);
    video = await openai.videos.retrieve(video.id);
  }

  if (video.status === "completed") {
    console.log("Video successfully completed: ", video);
  } else {
    console.log("Video creation failed. Status: ", video.status);
  }
}

main();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20import asyncio

from openai import AsyncOpenAI

client = AsyncOpenAI()


async def main() -> None:
    video = await client.videos.create_and_poll(
        model="sora-2",
        prompt="A video of a cat on a motorcycle",
    )

    if video.status == "completed":
        print("Video successfully completed: ", video)
    else:
        print("Video creation failed. Status: ", video.status)


asyncio.run(main())

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
)

func main() {
	client := openai.NewClient()
	video, err := client.Videos.NewAndPoll(context.Background(), openai.VideoNewParams{
		Model:  openai.VideoModelSora2,
		Prompt: "A video of the words 'Thank you' in sparkling letters",
	}, 2000)
	if err != nil {
		panic(err)
	}
	if video.Status == openai.VideoStatusCompleted {
		fmt.Println("Video successfully completed:", video)
		return
	}
	fmt.Println("Video creation failed. Status:", video.Status)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.videos.Video;
import com.openai.models.videos.VideoCreateParams;

var video =
    client
        .videos()
        .create(
            VideoCreateParams.builder()
                .model("sora-2")
                .prompt("A paper airplane flying over a forest")
                .build());

while (video.status().equals(Video.Status.QUEUED)
    || video.status().equals(Video.Status.IN_PROGRESS)) {
  Thread.sleep(1000);
  video = client.videos().retrieve(video.id());
}
if (!video.status().equals(Video.Status.COMPLETED)) {
  throw new IllegalStateException("Video generation failed: " + video.status());
}
System.out.println("Video completed: " + video.id());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15require "openai"

client = OpenAI::Client.new
video = client.videos.create(model: "sora-2", prompt: "A paper airplane flying over a forest")

while [:queued, :in_progress].include?(video.status)
  sleep(2)
  video = client.videos.retrieve(video.id)
end

unless video.status == OpenAI::Models::Video::Status::COMPLETED
  raise "Video creation failed. Status: #{video.status}"
end

puts("Video successfully completed: #{video.id}")

Beispielantwort:

12345678910{
  "id": "video_68d7512d07848190b3e45da0ecbebcde004da08e1e0678d5",
  "object": "video",
  "created_at": 1758941485,
  "status": "in_progress",
  "model": "sora-2-pro",
  "progress": 33,
  "seconds": "8",
  "size": "1280x720"
}

Webhooks für Benachrichtigungen verwenden

Statt den Auftragsstatus wiederholt mit GET abzufragen, registriere einen Webhook, um automatisch benachrichtigt zu werden, wenn eine Videogenerierung abgeschlossen wird oder fehlschlägt.

Du kannst Webhooks auf deiner Seite für Webhook-Einstellungen konfigurieren. Wenn ein Auftrag beendet ist, sendet die API ein Ereignis eines dieser beiden Typen: video.completed und video.failed. Jedes Ereignis enthält die ID des Auftrags, der es ausgelöst hat.

Beispiel für eine Webhook-Payload:

{
  "id": "evt_abc123",
  "object": "event",
  "created_at": 1758941485,
  "type": "video.completed", // or "video.failed"
  "data": {
    "id": "video_abc123"
  }
}

Ergebnisse abrufen

MP4 herunterladen

Sobald der Auftrag den Status completed erreicht, rufe die MP4-Datei mit GET /videos/{video_id}/content ab. Dieser Endpunkt streamt die binären Videodaten und gibt die üblichen Content-Header zurück. So kannst du die Datei direkt auf einem Datenträger speichern oder an einen Cloud-Speicher weiterleiten.

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49import { writeFileSync } from "node:fs";

import OpenAI from "openai";

const openai = new OpenAI();

let video = await openai.videos.create({
  model: "sora-2",
  prompt: "A video of the words 'Thank you' in sparkling letters",
});

console.log("Video generation started: ", video);
let progress = video.progress ?? 0;

while (video.status === "in_progress" || video.status === "queued") {
  video = await openai.videos.retrieve(video.id);
  progress = video.progress ?? 0;

  // Display progress bar
  const barLength = 30;
  const filledLength = Math.floor((progress / 100) * barLength);
  // Simple ASCII progress visualization for terminal output
  const bar = "=".repeat(filledLength) + "-".repeat(barLength - filledLength);
  const statusText = video.status === "queued" ? "Queued" : "Processing";

  process.stdout.write(`${statusText}: [${bar}] ${progress.toFixed(1)}%`);

  await new Promise((resolve) => setTimeout(resolve, 2000));
}

// Clear the progress line and show completion
process.stdout.write("\n");

if (video.status === "failed") {
  throw new Error("Video generation failed");
}

console.log("Video generation completed: ", video);

console.log("Downloading video content...");

const content = await openai.videos.downloadContent(video.id);

const body = content.arrayBuffer();
const buffer = Buffer.from(await body);

writeFileSync("video.mp4", buffer);

console.log("Wrote video.mp4");

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46from openai import OpenAI
import sys
import time


openai = OpenAI()

video = openai.videos.create(
    model="sora-2",
    prompt="A video of a cool cat on a motorcycle in the night",
)

print("Video generation started:", video)

progress = getattr(video, "progress", 0)
bar_length = 30

while video.status in ("in_progress", "queued"):
    # Refresh status
    video = openai.videos.retrieve(video.id)
    progress = getattr(video, "progress", 0)

    filled_length = int((progress / 100) * bar_length)
    bar = "=" * filled_length + "-" * (bar_length - filled_length)
    status_text = "Queued" if video.status == "queued" else "Processing"

    sys.stdout.write(f"\r{status_text}: [{bar}] {progress:.1f}%")
    sys.stdout.flush()
    time.sleep(2)

# Move to next line after progress loop
sys.stdout.write("\n")

if video.status == "failed":
    message = getattr(
        getattr(video, "error", None), "message", "Video generation failed"
    )
    raise RuntimeError(message)

print("Video generation completed:", video)
print("Downloading video content...")

content = openai.videos.download_content(video.id, variant="video")
content.write_to_file("video.mp4")

print("Wrote video.mp4")

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41package main

import (
	"context"
	"fmt"
	"io"
	"os"

	"github.com/openai/openai-go/v3"
)

func main() {
	client := openai.NewClient()
	video, err := client.Videos.NewAndPoll(context.Background(), openai.VideoNewParams{
		Model:  openai.VideoModelSora2,
		Prompt: "A video of the words 'Thank you' in sparkling letters",
	}, 2000)
	if err != nil {
		panic(err)
	}
	if video.Status != openai.VideoStatusCompleted {
		panic(fmt.Errorf("video generation failed with status %s", video.Status))
	}

	response, err := client.Videos.DownloadContent(context.Background(), video.ID, openai.VideoDownloadContentParams{})
	if err != nil {
		panic(err)
	}
	defer response.Body.Close()
	file, err := os.Create("video.mp4")
	if err != nil {
		panic(err)
	}
	if _, err := io.Copy(file, response.Body); err != nil {
		panic(err)
	}
	if err := file.Close(); err != nil {
		panic(err)
	}
	fmt.Println("Wrote video.mp4")
}

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
27
28
29import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.videos.Video;
import com.openai.models.videos.VideoCreateParams;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;

var video =
    client
        .videos()
        .create(
            VideoCreateParams.builder()
                .model("sora-2")
                .prompt("A video of the words 'Thank you' in sparkling letters")
                .build());

while (video.status().equals(Video.Status.QUEUED)
    || video.status().equals(Video.Status.IN_PROGRESS)) {
  Thread.sleep(1000);
  video = client.videos().retrieve(video.id());
}
if (!video.status().equals(Video.Status.COMPLETED)) {
  throw new IllegalStateException("Video generation failed: " + video.status());
}
try (var content = client.videos().downloadContent(video.id())) {
  Files.copy(content.body(), Path.of("video.mp4"), StandardCopyOption.REPLACE_EXISTING);
}
System.out.println("Wrote video.mp4");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20require "openai"

client = OpenAI::Client.new
video = client.videos.create(
  model: "sora-2",
  prompt: "A video of the words 'Thank you' in sparkling letters"
)
pending_statuses = [
  OpenAI::Models::Video::Status::QUEUED,
  OpenAI::Models::Video::Status::IN_PROGRESS
]
while pending_statuses.include?(video.status)
  sleep(2)
  video = client.videos.retrieve(video.id)
end
raise "Video generation failed" if video.status == OpenAI::Models::Video::Status::FAILED

content = client.videos.download_content(video.id)
File.binwrite("video.mp4", content.read)
puts("Wrote video.mp4")

1
2
3curl -L "https://api.openai.com/v1/videos/video_abc123/content" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  --output video.mp4

Die fertige Videodatei steht dir jetzt zur Wiedergabe, Bearbeitung oder Weitergabe zur Verfügung. Download-URLs sind nach der Generierung höchstens 1 Stunde gültig. Wenn du die Datei langfristig aufbewahren möchtest, kopiere sie zeitnah in dein eigenes Speichersystem.

Zusätzliche Dateien herunterladen

Für jedes fertiggestellte Video kannst du auch ein Vorschaubild und ein Spritesheet herunterladen. Diese kleinen Dateien eignen sich für Vorschauen, Zeitleisten zum Durchsuchen von Videos oder Katalogansichten. Mit dem Abfrageparameter variant legst du fest, was du herunterladen möchtest. Der Standardwert ist variant=video für die MP4-Datei.

1
2
3
4
5
6
7
8
9# Download a thumbnail
curl -L "https://api.openai.com/v1/videos/video_abc123/content?variant=thumbnail" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  --output thumbnail.webp

# Download a spritesheet
curl -L "https://api.openai.com/v1/videos/video_abc123/content?variant=spritesheet" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  --output spritesheet.jpg

Bildreferenzen verwenden

Du kannst die Generierung mit einem Eingabebild steuern, das als erstes Bild deines Videos dient. Das ist nützlich, wenn das generierte Video das Aussehen eines Markenelements, eines Charakters oder einer bestimmten Umgebung beibehalten soll.

Wähle das Format für input_reference je nach Anfragetyp:

• Verwende input_reference mit einem hochgeladenen Bild in Anfragen vom Typ multipart/form-data.
• Verwende input_reference mit einem JSON-Objekt in Anfragen vom Typ application/json, auch bei der Stapelverarbeitung. Die JSON-Form akzeptiert entweder file_id oder image_url.

Das Bild muss der Auflösung des Zielvideos (size) entsprechen.

Unterstützte Dateiformate sind image/jpeg, image/png und image/webp.

1
2
3
4
5
6
7
8curl -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"

Mit OpenAI GPT Image generiertes Eingabebild	Mit Sora 2 generiertes Video (in GIF umgewandelt)
Dieses Bild herunterladen	Prompt: „Sie dreht sich um und lächelt, dann geht sie langsam aus dem Bild.“
Dieses Bild herunterladen	Prompt: „Die Kühlschranktür öffnet sich. Ein niedliches, pummeliges, lilafarbenes Monster kommt heraus.“

Charaktere für ein konsistentes Erscheinungsbild verwenden

Mit Charakteren kannst du ein wiederverwendbares, nicht menschliches Motiv hochladen und bei mehreren Generierungen darauf verweisen. Das ist nützlich, wenn ein Tier, ein Maskottchen oder ein Objekt über mehrere Einstellungen hinweg sein grundlegendes Aussehen, seinen Stil und seine Wirkung im Bild beibehalten soll.

Charaktere unterscheiden sich von input_reference. Eine Bildreferenz bestimmt das erste Bild einer einzelnen Generierung, während ein Charakter-Asset bei künftigen Videoanfragen wiederverwendet werden kann.

Erstelle den Charakter, indem du einen kurzen MP4-Clip an POST /v1/videos/characters hochlädst. Füge dann beim Erstellen eines Videos die zurückgegebene Charakter-ID in das Array characters ein.

1
2
3
4
5curl -X POST "https://api.openai.com/v1/videos/characters" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: multipart/form-data" \
  -F "video=@character.mp4;type=video/mp4" \
  -F "name=Mossy"

Gib den Namen des Charakters exakt in deinem Prompt an. Die Charakter-ID allein reicht nicht aus, um den Charakter in der Aufnahme zuverlässig beizubehalten.

Charaktere lassen sich mit input_reference kombinieren. Verlängerungen unterstützen keine Charaktere.

1
2
3
4
5
6
7
8
9
10
11
12curl -X POST "https://api.openai.com/v1/videos" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "sora-2",
    "prompt": "A cinematic tracking shot of Mossy, a moss-covered teapot mascot, weaving through a lantern-lit market at dusk.",
    "size": "1280x720",
    "seconds": "8",
    "characters": [
      { "id": "char_123" }
    ]
  }'

Fertige Videos verlängern

Mit Videoverlängerungen kannst du ein bereits fertiggestelltes Video fortsetzen und ein neues, zusammengefügtes Video erstellen. Übergebe das Ausgangsvideo im Feld video an POST /v1/videos/extensions und ergänze einen Prompt, der beschreibt, wie die Szene weitergehen soll. Die API generiert dann das nächste Segment und nutzt dabei den gesamten Ausgangsclip als Kontext.

Verwende Verlängerungen, wenn du Bewegung, Kamerarichtung und Szenenkontinuität beibehalten möchtest. Wenn du nur das erste Bild einer neuen Generierung vorgeben möchtest, verwende stattdessen input_reference.

1
2
3
4
5
6
7
8
9
10curl -X POST "https://api.openai.com/v1/videos/extensions" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "video": {
      "id": "video_abc123"
    },
    "prompt": "Continue the scene as the camera rises over the rooftops and reveals the sunrise.",
    "seconds": "8"
  }'

Vorhandene Videos bearbeiten

Mit der Bearbeitungsfunktion kannst du vorhandene Videos gezielt anpassen, ohne alles von Grund auf neu zu generieren. Sende eine Anfrage an POST /v1/videos/edits mit einem Prompt und einer Referenz in video. Das System übernimmt die ursprüngliche Struktur, Kontinuität und Bildkomposition und setzt dabei die Änderung um. Am besten funktioniert das mit einer einzelnen, klar definierten Änderung. Kleine, gezielte Bearbeitungen erhalten mehr Details des Originals und verringern das Risiko von Artefakten.

Das Feld video akzeptiert entweder eine Video-ID oder ein hochgeladenes Video. Wenn du eine Video-ID übergibst, leitet die API das Modell aus dem Ausgangsvideo ab.

1
2
3
4
5
6
7
8
9curl -X POST "https://api.openai.com/v1/videos/edits" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "video": {
      "id": "video_abc123"
    },
    "prompt": "Shift the color palette to teal, sand, and rust, with a warm backlight."
  }'

Wenn du ein neues Video hochlädst, statt ein bereits generiertes Video zu bearbeiten, gib model ausdrücklich in der Anfrage an.

1
2
3
4
5
6curl -X POST "https://api.openai.com/v1/videos/edits" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: multipart/form-data" \
  -F "video=@source.mp4;type=video/mp4" \
  -F "model=sora-2-pro" \
  -F "prompt=Shift the color palette to teal, sand, and rust, with a warm backlight."

Die Bearbeitungsfunktion eignet sich besonders für schrittweise Verbesserungen, weil du verfeinern kannst, ohne Bewährtes zu verwerfen. Wenn du jede Bearbeitung auf eine klar definierte Anpassung beschränkst, bleiben der visuelle Stil, das Erscheinungsbild der Motive und der Bildausschnitt erhalten. Gleichzeitig kannst du verschiedene Stimmungen, Farbpaletten oder Inszenierungen ausprobieren. So lassen sich hochwertige Sequenzen deutlich leichter in kleinen, verlässlichen Schritten erstellen.

Originalvideo	Bearbeitetes generiertes Video
	Prompt: „Ändere die Farbe des Monsters zu Orange.“
	Prompt: „Direkt danach kommt ein zweites Monster heraus.“

Videoaufträge über die Batch API ausführen

Verwende die Batch API, wenn du viele Video-Renderaufträge für die Offlineverarbeitung, Review-Pipelines oder Studioabläufe in eine Warteschlange einreihen musst. Jede Zeile der Eingabedatei für die Stapelverarbeitung verwendet denselben JSON-Anfragetext, den du an POST /v1/videos senden würdest. Dadurch eignet sie sich gut für Einstellungslisten und geplante Renderwarteschlangen.

Für die Videogenerierung per Stapelverarbeitung gilt:

• Die Stapelverarbeitung unterstützt derzeit nur POST /v1/videos.
• Anfragen zur Stapelverarbeitung müssen JSON verwenden, nicht Multipart.
• Lade Assets im Voraus hoch und referenziere sie im JSON-Anfragetext.
• Verwende input_reference für Generierungen mit Bildreferenzen in der Stapelverarbeitung. Übergebe input_reference in JSON-Anfragen als Objekt mit entweder file_id oder image_url.
• Multipart-Uploads über input_reference, einschließlich Videoreferenzen als Eingabe, werden in der Stapelverarbeitung nicht unterstützt.
• Per Stapelverarbeitung generierte Videos stehen nach Abschluss der Stapelverarbeitung bis zu 24 Stunden zum Download bereit.

{"custom_id":"shot-001","method":"POST","url":"/v1/videos","body":{"model":"sora-2-pro","prompt":"Slow dolly shot through a miniature paper city at blue hour, soft fog, practical window lights flickering on.","size":"1920x1080","seconds":"20"}}
{"custom_id":"shot-002","method":"POST","url":"/v1/videos","body":{"model":"sora-2-pro","prompt":"Portrait close-up of a red panda chef plating noodles in a stainless-steel kitchen, shallow depth of field.","size":"1080x1920","seconds":"16"}}

Wenn ein Stapel den Status completed erreicht, befinden sich die Videoaufträge in seiner Ausgabe bereits in einem Endzustand wie completed, failed oder expired. Verwende stabile Werte für custom_id, damit du die Ergebnisse der Stapelverarbeitung deinen internen Einstellungs-IDs, deiner Schnittwarteschlange oder deiner Asset-Pipeline zuordnen kannst. Lade anschließend die fertigen Assets mit den zurückgegebenen Video-IDs herunter.

Deine Bibliothek verwalten

Verwende GET /videos, um deine Videos aufzulisten. Der Endpunkt unterstützt optionale Abfrageparameter für Paginierung und Sortierung.

curl "https://api.openai.com/v1/videos?limit=20&after=video_123&order=asc" \
  -H "Authorization: Bearer $OPENAI_API_KEY" | jq .

Verwende DELETE /videos/{video_id}, um Videos, die du nicht mehr benötigst, aus dem Speicher von OpenAI zu entfernen.

curl -X DELETE "https://api.openai.com/v1/videos/REPLACE_WITH_YOUR_VIDEO_ID" \
  -H "Authorization: Bearer $OPENAI_API_KEY" | jq .