Génération de vidéos avec Sora

Explorer

Vue d’ensemble

Sora marque la dernière avancée d’OpenAI dans la génération de médias. Ce modèle vidéo de pointe peut créer des clips dynamiques, riches en détails et accompagnés de son, à partir de descriptions en langage naturel ou d’images. Fruit de plusieurs années de recherche sur la diffusion multimodale et entraîné sur des données visuelles variées, Sora apporte à la génération de vidéos à partir de texte une compréhension approfondie de l’espace 3D, du mouvement et de la continuité des scènes.

L’API Videos met pour la première fois ces capacités à la disposition des développeurs, en leur permettant de créer, prolonger, modifier et gérer des vidéos par programmation.

Vous pouvez l’utiliser pour :

• Créer de nouvelles vidéos à partir de prompts.
• Guider une génération à l’aide d’une image de référence.
• Réutiliser des ressources de personnages dans plusieurs générations pour renforcer la cohérence visuelle.
• Prolonger un clip terminé grâce aux extensions vidéo.
• Apporter des modifications ciblées à une vidéo existante.
• Télécharger les vidéos terminées et les ressources associées.
• Soumettre de longues files d’attente de rendus à traiter hors ligne via l’API Batch.

Modèles

Le modèle Sora de deuxième génération se décline en deux variantes, chacune adaptée à des cas d’utilisation différents.

Sora 2

sora-2 est conçu pour allier rapidité et souplesse. Il est idéal pendant la phase d’exploration, lorsque vous testez différentes ambiances, structures ou styles visuels et avez besoin de résultats rapides plutôt que d’une fidélité parfaite.

Il génère rapidement des résultats de bonne qualité, ce qui le rend bien adapté aux itérations rapides, à l’exploration de concepts et aux premiers montages. sora-2 est souvent largement suffisant pour les contenus destinés aux réseaux sociaux, les prototypes et les situations où le délai de réalisation compte davantage qu’une très haute fidélité.

Sora 2 Pro

sora-2-pro produit des résultats de meilleure qualité. C’est le choix à privilégier lorsque vous avez besoin d’un résultat de qualité professionnelle.

sora-2-pro demande plus de temps de rendu et coûte plus cher à utiliser, mais produit des résultats plus soignés et plus stables. Il est idéal pour les séquences cinématographiques en haute résolution, les supports marketing et toute situation où la précision visuelle est essentielle.

Utilisez sora-2-pro lorsque vous avez besoin d’exports 1080p en 1920x1080 ou en 1080x1920.

sora-2 et sora-2-pro prennent tous deux en charge les générations de 16 et de 20 secondes.

Générez une vidéo

La génération d’une vidéo est un processus asynchrone :

1. Lorsque vous appelez le point de terminaison POST /videos, l’API renvoie un objet représentant une tâche, avec son identifiant id et son statut initial status.

2. Vous pouvez interroger régulièrement le point de terminaison GET /videos/{video_id} jusqu’à ce que le statut passe à completed ou, pour une approche plus efficace, utiliser des webhooks (voir la section consacrée aux webhooks ci-dessous) afin de recevoir une notification automatique à la fin de la tâche.

3. Une fois que la tâche a atteint l’état completed, vous pouvez récupérer le fichier MP4 final avec GET /videos/{video_id}/content.

Lancez une tâche de rendu

Commencez par appeler POST /videos avec un prompt textuel et les paramètres requis. Le prompt définit les choix artistiques — sujets, caméra, éclairage et mouvement — tandis que des paramètres comme size et seconds déterminent la résolution et la durée de la vidéo.

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" \

La réponse est un objet JSON contenant un identifiant unique et un statut initial tel que queued ou in_progress. Cela signifie que la tâche de rendu a démarré.

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

Choisissez la taille et la durée

Choisissez le plus petit format qui répond à vos besoins de production :

• Utilisez des clips plus courts lorsque vous ajustez le prompt, les mouvements ou la composition.
• Générez des vidéos allant jusqu’à 20 secondes lorsque vous avez besoin de séquences plus longues, de scènes plus développées ou de spots plus complets.
• Utilisez sora-2-pro pour des exports en plus haute résolution, en 1920x1080 ou 1080x1920.

Les vidéos plus longues et les rendus en 1080p peuvent prendre nettement plus de temps que les rendus courts en 720p ou 480p. Prévoyez donc une latence plus élevée dans les parcours utilisateur.

Garde-fous et restrictions

L’API applique plusieurs restrictions de contenu :

• Seuls les contenus adaptés aux moins de 18 ans sont autorisés (un paramètre permettant de lever cette restriction sera disponible à l’avenir).
• Les personnages et les musiques protégés par le droit d’auteur seront refusés.
• Il est impossible de générer des personnes réelles, y compris des personnalités publiques.
• L’importation de personnages d’apparence humaine est bloquée par défaut.
• Les images d’entrée contenant des visages humains sont actuellement refusées.

Vérifiez que les prompts, les images de référence et les transcriptions respectent ces règles pour éviter les échecs de génération.

Conception de prompts efficaces

Pour obtenir les meilleurs résultats, décrivez le type de plan, le sujet, l’action, le décor et l’éclairage. Par exemple :

• « Plan large d’un enfant faisant voler un cerf-volant rouge dans un parc verdoyant, lumière dorée du soleil, lent panoramique de la caméra vers le haut. »
• « Gros plan sur une tasse de café fumant posée sur une table en bois, lumière matinale filtrant à travers les stores, faible profondeur de champ créant un flou doux. »

Ce niveau de précision aide le modèle à produire des résultats cohérents sans inventer de détails indésirables. Pour des techniques de conception de prompts plus avancées, consultez notre guide de conception de prompts consacré à Sora 2.

Suivez la progression

La génération de vidéos prend du temps. Selon le modèle, la charge de l’API et la résolution, un seul rendu peut prendre plusieurs minutes.

Pour suivre efficacement la progression, vous pouvez interroger régulièrement l’API afin d’obtenir l’état du traitement ou recevoir une notification par webhook.

Interrogez régulièrement le point de terminaison d’état

Appelez GET /videos/{video_id} avec l’identifiant renvoyé par l’appel de création. La réponse indique l’état actuel de la tâche, le pourcentage de progression (s’il est disponible) et les éventuelles erreurs.

Les états habituels sont queued, in_progress, completed et failed. Interrogez l’API à un intervalle raisonnable (par exemple, toutes les 10 à 20 secondes), augmentez ce délai de manière exponentielle si nécessaire et indiquez aux utilisateurs que la tâche est toujours en cours.

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}")

Exemple de réponse :

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

Utilisez des webhooks pour les notifications

Au lieu d’interroger à répétition l’état de la tâche avec GET, enregistrez un webhook pour recevoir automatiquement une notification lorsque la génération d’une vidéo se termine ou échoue.

Vous pouvez configurer les webhooks sur votre page de paramètres des webhooks. Lorsqu’une tâche se termine, l’API émet un événement de l’un des deux types suivants : video.completed ou video.failed. Chaque événement inclut l’identifiant de la tâche qui l’a déclenché.

Exemple de charge utile d’un webhook :

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

Récupérez les résultats

Téléchargez le MP4

Une fois la tâche à l’état completed, récupérez le MP4 avec GET /videos/{video_id}/content. Ce point de terminaison transmet les données vidéo binaires sous forme de flux et renvoie les en-têtes de contenu standard. Vous pouvez ainsi enregistrer le fichier directement sur disque ou rediriger le flux vers un stockage cloud.

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

Vous disposez maintenant du fichier vidéo final, prêt à être lu, monté ou distribué. Les URL de téléchargement sont valides pendant 1 heure au maximum après la génération. Pour conserver le fichier à long terme, copiez-le rapidement dans votre propre système de stockage.

Téléchargez les ressources complémentaires

Pour chaque vidéo terminée, vous pouvez également télécharger une miniature et une feuille de sprites. Ces ressources légères sont utiles pour les aperçus, les barres de navigation vidéo ou l’affichage dans un catalogue. Utilisez le paramètre de requête variant pour préciser ce que vous souhaitez télécharger. La valeur par défaut est variant=video, pour le MP4.

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

Utilisez des images de référence

Vous pouvez guider une génération avec une image d’entrée qui sert de première image à votre vidéo. C’est utile si vous souhaitez que la vidéo générée conserve l’apparence d’un élément visuel de marque, d’un personnage ou d’un environnement précis.

Choisissez le format de input_reference en fonction du type de requête :

• Utilisez input_reference avec une image importée dans les requêtes multipart/form-data.
• Utilisez input_reference avec un objet JSON dans les requêtes application/json, y compris pour le traitement par lots. Le format JSON accepte soit file_id, soit image_url.

L’image doit avoir la même résolution que la vidéo cible (size).

Les formats de fichier pris en charge sont image/jpeg, image/png et 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"

Image d’entrée générée avec OpenAI GPT Image	Vidéo générée avec Sora 2 (convertie en GIF)
Télécharger cette image	Prompt : « Elle se retourne et sourit, puis sort lentement du cadre en marchant. »
Télécharger cette image	Prompt : « La porte du réfrigérateur s’ouvre. Un adorable monstre violet et potelé en sort. »

Utilisez des personnages pour maintenir la cohérence visuelle

Les personnages vous permettent d’importer un sujet non humain réutilisable et d’y faire référence dans plusieurs générations. C’est utile lorsque vous souhaitez qu’un animal, une mascotte ou un objet conserve ses principaux traits visuels, son style et sa présence à l’écran d’un plan à l’autre.

Les personnages se distinguent de input_reference. Une image de référence conditionne la première image d’une seule génération, tandis qu’une ressource de personnage peut être réutilisée dans de futures requêtes de génération de vidéos.

Créez le personnage en envoyant un court clip MP4 à POST /v1/videos/characters, puis incluez l’identifiant de personnage renvoyé dans le tableau characters lorsque vous créez une vidéo.

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"

Mentionnez le nom exact du personnage dans votre prompt. Fournir uniquement son identifiant ne suffit pas à préserver de manière fiable le personnage dans le plan.

Les personnages peuvent être combinés avec input_reference. Les extensions ne prennent pas en charge les personnages.

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" }
    ]
  }'

Prolongez les vidéos terminées

Les extensions vidéo permettent de prolonger une vidéo déjà terminée et d’obtenir une nouvelle vidéo assemblée. Fournissez la vidéo source dans le champ video à POST /v1/videos/extensions, ajoutez un prompt décrivant la suite de la scène, et l’API génère le segment suivant en utilisant l’intégralité de la vidéo source comme contexte.

Utilisez les extensions pour préserver les mouvements, l’orientation de la caméra et la continuité de la scène. Si vous souhaitez uniquement contrôler la première image d’une nouvelle génération, utilisez plutôt 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"
  }'

Modifiez des vidéos existantes

La modification permet d’apporter des ajustements ciblés à une vidéo existante sans tout régénérer de zéro. Envoyez une requête POST /v1/videos/edits avec un prompt et une référence video : le système conserve la structure, la continuité et la composition d’origine tout en appliquant la modification. Vous obtiendrez de meilleurs résultats avec une seule modification bien définie, car les ajustements limités et ciblés préservent mieux la fidélité à l’original et réduisent le risque d’introduire des artefacts.

Le champ video accepte soit un identifiant de vidéo, soit une vidéo importée. Si vous fournissez un identifiant de vidéo, l’API déduit le modèle à partir de la vidéo source.

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."
  }'

Si vous importez une nouvelle vidéo au lieu de modifier une vidéo déjà générée, définissez model explicitement dans la requête.

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."

La modification est particulièrement utile pour itérer, car elle permet d’affiner le résultat tout en conservant ce qui fonctionne déjà. En limitant chaque modification à un ajustement précis, vous préservez le style visuel, la cohérence du sujet et le cadrage, tout en explorant des variations d’ambiance, de palette ou de mise en scène. Il devient ainsi beaucoup plus facile de créer des séquences soignées par petites étapes fiables.

Vidéo d’origine	Vidéo générée modifiée
	Prompt : « Changez la couleur du monstre en orange. »
	Prompt : « Un deuxième monstre sort juste après. »

Exécutez des tâches vidéo avec l’API de traitement par lots

Utilisez l’API de traitement par lots pour mettre en file d’attente de nombreux rendus vidéo destinés à un traitement hors ligne, à des pipelines de révision ou à des workflows de studio. Chaque ligne du fichier d’entrée du lot utilise le même corps de requête JSON que celui envoyé à POST /v1/videos, ce qui convient bien aux listes de plans et aux files de rendus planifiés.

Pour la génération de vidéos par lots :

• Le traitement par lots ne prend actuellement en charge que POST /v1/videos.
• Les requêtes de traitement par lots doivent utiliser le format JSON, et non multipart.
• Importez les ressources à l’avance et référencez-les dans le corps JSON de la requête.
• Utilisez input_reference pour les générations guidées par une image dans le traitement par lots. Dans les requêtes JSON, fournissez input_reference sous forme d’objet contenant soit file_id, soit image_url.
• Les importations multipart via input_reference, y compris les vidéos de référence fournies en entrée, ne sont pas prises en charge dans le traitement par lots.
• Les vidéos générées par lots peuvent être téléchargées jusqu’à 24 heures après la fin du traitement du lot.

{"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"}}

Lorsqu’un lot atteint l’état completed, les tâches vidéo figurant dans sa sortie ont déjà atteint un état final tel que completed, failed ou expired. Utilisez des valeurs custom_id stables pour pouvoir associer les résultats du lot à vos identifiants de plans internes, à votre file de montage ou à votre pipeline de ressources, puis téléchargez les ressources finales à l’aide des identifiants de vidéos renvoyés.

Gérez votre bibliothèque

Utilisez GET /videos pour lister vos vidéos. Le point de terminaison prend en charge des paramètres de requête facultatifs pour la pagination et le tri.

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

Utilisez DELETE /videos/{video_id} pour supprimer du stockage d’OpenAI les vidéos dont vous n’avez plus besoin.

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