Geração de vídeos com Sora

Explorar

Visão geral

O Sora é a mais nova fronteira da OpenAI em mídia generativa: um modelo de vídeo de última geração capaz de criar clipes dinâmicos, ricos em detalhes e com áudio a partir de linguagem natural ou imagens. Desenvolvido com base em anos de pesquisa em difusão multimodal e treinado com dados visuais diversos, o Sora traz uma compreensão profunda do espaço 3D, do movimento e da continuidade de cenas para a geração de vídeos a partir de texto.

A API de vídeos disponibiliza essas capacidades aos desenvolvedores pela primeira vez, permitindo criar, estender, editar e gerenciar vídeos de forma programática.

Você pode usá-la para:

• Criar novos vídeos a partir de prompts.
• Orientar uma geração com uma imagem de referência.
• Reutilizar recursos de personagens em várias gerações para obter maior consistência visual.
• Dar continuidade a um clipe concluído com extensões de vídeo.
• Editar um vídeo existente com alterações específicas.
• Baixar vídeos finalizados e recursos complementares.
• Enviar grandes filas de renderização para processamento offline pela API de processamento em lote.

Modelos

A segunda geração do modelo Sora está disponível em duas variantes, cada uma voltada a diferentes casos de uso.

Sora 2

O sora-2 foi desenvolvido com foco em velocidade e flexibilidade. É ideal para a fase de exploração, quando você está experimentando o tom, a estrutura ou o estilo visual e precisa de feedback rápido, mais do que de fidelidade perfeita.

Ele gera resultados de boa qualidade rapidamente, o que o torna adequado para iterações rápidas, desenvolvimento de conceitos e cortes preliminares. O sora-2 costuma ser mais do que suficiente para conteúdo de redes sociais, protótipos e situações em que o prazo de entrega importa mais do que uma fidelidade extremamente alta.

Sora 2 Pro

O sora-2-pro produz resultados de maior qualidade. É a melhor escolha quando você precisa de resultados com qualidade de produção.

O sora-2-pro leva mais tempo para renderizar e custa mais para executar, mas produz resultados mais refinados e estáveis. É ideal para cenas cinematográficas em alta resolução, materiais de marketing e qualquer situação em que a precisão visual seja essencial.

Use sora-2-pro quando precisar de exportações em 1080p nas resoluções 1920x1080 ou 1080x1920.

Tanto sora-2 quanto sora-2-pro permitem gerar vídeos de 16 e 20 segundos.

Gere um vídeo

Gerar um vídeo é um processo assíncrono :

1. Quando você chama o endpoint POST /videos, a API retorna um objeto de tarefa com o id da tarefa e um status inicial.

2. Você pode consultar periodicamente o endpoint GET /videos/{video_id} até que o status mude para completed ou, para uma abordagem mais eficiente, usar webhooks (veja a seção sobre webhooks abaixo) para receber uma notificação automática quando a tarefa terminar.

3. Quando a tarefa atingir o estado completed, você poderá obter o arquivo MP4 final com GET /videos/{video_id}/content.

Inicie uma tarefa de renderização

Comece chamando POST /videos com um prompt de texto e os parâmetros obrigatórios. O prompt define os aspectos criativos e visuais, como os elementos em cena, a câmera, a iluminação e o movimento, enquanto parâmetros como size e seconds controlam a resolução e a duração do vídeo.

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

A resposta é um objeto JSON com um id exclusivo e um status inicial, como queued ou in_progress. Isso significa que a tarefa de renderização foi iniciada.

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

Escolha o tamanho e a duração

Escolha o menor formato que atenda às necessidades da sua produção:

• Use clipes mais curtos ao testar ajustes no prompt, no movimento ou na composição.
• Gere vídeos de até 20 segundos quando precisar de momentos mais longos, cenas mais completas ou peças publicitárias mais completas.
• Use sora-2-pro para exportações em maior resolução, em 1920x1080 ou 1080x1920.

Vídeos mais longos e tarefas em 1080p podem levar consideravelmente mais tempo para serem concluídos do que renderizações curtas em 720p ou 480p. Por isso, preveja uma latência maior nos fluxos voltados ao usuário.

Mecanismos de proteção e restrições

A API aplica várias restrições de conteúdo:

• Somente conteúdo adequado para menores de 18 anos (uma configuração para desativar essa restrição estará disponível no futuro).
• Personagens e músicas protegidos por direitos autorais serão rejeitados.
• Não é permitido gerar pessoas reais, incluindo figuras públicas.
• Uploads de personagens com aparência humana são bloqueados por padrão.
• Atualmente, imagens de entrada com rostos humanos são rejeitadas.

Certifique-se de que os prompts, as imagens de referência e as transcrições respeitem essas regras para evitar falhas na geração.

Criação de prompts eficazes

Para obter os melhores resultados, descreva o tipo de plano, o assunto principal, a ação, o cenário e a iluminação. Por exemplo:

• “Plano aberto de uma criança empinando uma pipa vermelha em um parque gramado, luz dourada do fim de tarde, câmera se inclina lentamente para cima.”
• “Close de uma xícara de café soltando vapor sobre uma mesa de madeira, luz da manhã entrando pelas persianas, profundidade de campo suave.”

Esse nível de detalhamento ajuda o modelo a produzir resultados consistentes sem inventar detalhes indesejados. Para conhecer técnicas mais avançadas, consulte nosso guia de criação de prompts específico para o Sora 2.

Acompanhe o progresso

A geração de vídeos leva tempo. Dependendo do modelo, da carga da API e da resolução, uma única renderização pode levar vários minutos.

Para gerenciar isso com eficiência, você pode consultar a API periodicamente para obter atualizações de status ou receber notificações por webhook.

Consulte o endpoint de status periodicamente

Chame GET /videos/{video_id} com o ID retornado pela chamada de criação. A resposta mostra o status atual da tarefa, a porcentagem de progresso (se disponível) e eventuais erros.

Os estados típicos são queued, in_progress, completed e failed. Faça consultas em intervalos razoáveis (por exemplo, a cada 10–20 segundos), aumente exponencialmente o intervalo entre tentativas se necessário e informe aos usuários que a tarefa ainda está em andamento.

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

Exemplo de resposta:

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

Use webhooks para receber notificações

Em vez de consultar repetidamente o status da tarefa com GET, registre um webhook para receber uma notificação automática quando a geração de um vídeo for concluída ou falhar.

Os webhooks podem ser configurados na sua página de configurações de webhooks. Quando uma tarefa termina, a API emite um dos dois tipos de evento: video.completed e video.failed. Cada evento inclui o ID da tarefa que o acionou.

Exemplo de payload de webhook:

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

Obtenha os resultados

Baixe o MP4

Quando a tarefa atingir o status completed, obtenha o MP4 com GET /videos/{video_id}/content. Esse endpoint transmite os dados binários do vídeo e retorna cabeçalhos de conteúdo padrão, permitindo salvar o arquivo diretamente em disco ou encaminhá-lo para um serviço de armazenamento em nuvem.

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

Agora você tem o arquivo final do vídeo pronto para reprodução, edição ou distribuição. As URLs de download são válidas por no máximo 1 hora após a geração. Se precisar de armazenamento de longo prazo, copie o arquivo para seu próprio sistema de armazenamento o quanto antes.

Baixe os arquivos complementares

Para cada vídeo concluído, você também pode baixar uma miniatura e uma folha de sprites. Esses arquivos leves são úteis para prévias, controles de navegação pelo vídeo ou exibição em catálogos. Use o parâmetro de consulta variant para especificar o que deseja baixar. O padrão é variant=video para o 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

Use imagens de referência

Você pode orientar a geração com uma imagem de entrada, que funciona como o primeiro quadro do seu vídeo. Isso é útil quando o vídeo gerado precisa preservar a aparência de um elemento visual da marca, de um personagem ou de um ambiente específico.

Escolha o formato de input_reference de acordo com o tipo de requisição:

• Use input_reference com uma imagem enviada por upload em requisições multipart/form-data.
• Use input_reference com um objeto JSON em requisições application/json, incluindo as de processamento em lote. O formato JSON aceita file_id ou image_url.

A imagem deve ter a mesma resolução do vídeo desejado (size).

Os formatos de arquivo compatíveis são image/jpeg, image/png e 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"

Imagem de entrada gerada com OpenAI GPT Image	Vídeo gerado com Sora 2 (convertido para GIF)
Baixar esta imagem	Prompt: “Ela se vira e sorri, depois caminha lentamente para fora do enquadramento.”
Baixar esta imagem	Prompt: “A porta da geladeira se abre. Um monstro roxo, fofo e gordinho sai de dentro dela.”

Use personagens para manter a consistência

Os personagens permitem fazer upload de um elemento não humano reutilizável e usá-lo como referência em várias gerações. Isso é útil quando você quer que um animal, mascote ou objeto mantenha a mesma aparência básica, estilo e presença em cena ao longo de vários planos.

Os personagens são diferentes de input_reference. Uma imagem de referência condiciona o quadro inicial de uma única geração, enquanto um recurso de personagem pode ser reutilizado em futuras requisições de vídeo.

Crie o personagem fazendo upload de um clipe curto em MP4 para POST /v1/videos/characters. Depois, inclua o ID do personagem retornado no array characters ao criar um vídeo.

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"

Mencione o nome do personagem exatamente como ele é no seu prompt. Informar apenas o ID do personagem não basta para preservá-lo de forma confiável no plano.

Personagens podem ser combinados com input_reference. Extensões não oferecem suporte a personagens.

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

Estenda vídeos concluídos

As extensões de vídeo permitem continuar um vídeo já concluído e criar um novo resultado com os segmentos unidos. Forneça o vídeo de origem no campo video ao chamar POST /v1/videos/extensions, adicione um prompt descrevendo como a cena deve continuar, e a API gerará o próximo segmento usando o clipe de origem completo como contexto.

Use extensões quando quiser preservar o movimento, a direção da câmera e a continuidade da cena. Se você só precisa controlar o quadro inicial de uma nova geração, use 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"
  }'

Edite vídeos existentes

A edição permite fazer ajustes pontuais em um vídeo existente sem gerar tudo novamente do zero. Envie uma requisição POST /v1/videos/edits com um prompt e uma referência em video, e o sistema reutilizará a estrutura, a continuidade e a composição originais ao aplicar a modificação. Isso funciona melhor quando você faz uma única alteração bem definida, pois edições menores e específicas preservam melhor a fidelidade ao original e reduzem o risco de introduzir artefatos.

O campo video aceita um ID de vídeo ou um vídeo enviado por upload. Se você informar um ID de vídeo, a API inferirá o modelo a partir do vídeo de origem.

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

Se você fizer upload de um novo vídeo em vez de editar um vídeo já gerado, defina model explicitamente na requisição.

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

A edição é especialmente útil para iterar, pois permite refinar o resultado sem descartar o que já funciona. Ao limitar cada edição a um ajuste claro, você mantém o estilo visual, a consistência do elemento principal e o enquadramento da câmera, ao mesmo tempo que explora variações na atmosfera, na paleta ou na encenação. Isso facilita muito a criação de sequências bem-acabadas por meio de pequenos passos confiáveis.

Vídeo original	Vídeo gerado após a edição
	Prompt: “Mude a cor do monstro para laranja.”
	Prompt: “Um segundo monstro sai logo em seguida.”

Execute tarefas de vídeo pela API de processamento em lote

Use a API de processamento em lote quando precisar enfileirar muitas renderizações de vídeo para processamento offline, pipelines de revisão ou fluxos de trabalho de estúdio. Cada linha do arquivo de entrada do lote usa o mesmo corpo de requisição JSON que você enviaria a POST /v1/videos, o que torna essa API adequada para listas de planos e filas de renderização agendadas.

Para gerar vídeos com processamento em lote:

• Atualmente, o processamento em lote oferece suporte apenas a POST /v1/videos.
• As requisições de processamento em lote devem usar JSON, e não multipart.
• Faça upload dos arquivos com antecedência e referencie-os no corpo JSON da requisição.
• Use input_reference para gerações guiadas por imagens no processamento em lote. Em requisições JSON, passe input_reference como um objeto com file_id ou image_url.
• O processamento em lote não oferece suporte a uploads multipart de input_reference, incluindo entradas de vídeo de referência.
• Vídeos gerados em lote ficam disponíveis para download por até 24 horas após a conclusão do lote.

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

Quando um lote chega ao estado completed, as tarefas de vídeo presentes na saída já chegaram a um estado final, como completed, failed ou expired. Use valores estáveis de custom_id para associar os resultados do lote aos seus IDs internos de planos, à fila de edição ou ao pipeline de arquivos de mídia. Depois, baixe os arquivos finais usando os IDs de vídeo retornados.

Gerencie sua biblioteca

Use GET /videos para listar seus vídeos. O endpoint aceita parâmetros de consulta opcionais para paginação e ordenação.

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

Use DELETE /videos/{video_id} para remover do armazenamento da OpenAI os vídeos de que você não precisa mais.

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