Generación de video con Sora

Explorar

Descripción general

Sora es el avance más reciente de OpenAI en la generación de contenido multimedia: un modelo de video de última generación capaz de crear clips dinámicos, con gran riqueza de detalles y audio, a partir de lenguaje natural o imágenes. Desarrollado a partir de años de investigación sobre difusión multimodal y entrenado con datos visuales diversos, Sora aporta una comprensión profunda del espacio 3D, el movimiento y la continuidad de las escenas a la generación de video a partir de texto.

La API de videos pone estas capacidades a disposición de los desarrolladores por primera vez y permite crear, extender, editar y administrar videos de forma programática.

Puedes usarla para:

• Crear videos nuevos a partir de prompts.
• Guiar una generación con una imagen de referencia.
• Reutilizar recursos de personajes en varias generaciones para lograr una mayor coherencia visual.
• Continuar un clip terminado con extensiones de video.
• Editar un video existente con cambios específicos.
• Descargar videos terminados y recursos complementarios.
• Enviar grandes colas de renderizado para procesamiento diferido a través de la API de procesamiento por lotes.

Modelos

El modelo Sora de segunda generación está disponible en dos variantes, cada una adaptada a distintos casos de uso.

Sora 2

sora-2 está diseñado para ofrecer velocidad y flexibilidad. Es ideal para la fase de exploración, cuando experimentas con el tono, la estructura o el estilo visual y necesitas evaluar resultados rápidamente, más que lograr una fidelidad perfecta.

Genera resultados de buena calidad con rapidez, por lo que es adecuado para iterar rápidamente, desarrollar conceptos y crear montajes preliminares. sora-2 suele ser más que suficiente para contenido de redes sociales, prototipos y situaciones en las que el tiempo de entrega importa más que una fidelidad extremadamente alta.

Sora 2 Pro

sora-2-pro produce resultados de mayor calidad. Es la mejor opción cuando necesitas resultados con calidad de producción.

sora-2-pro tarda más en renderizar y cuesta más ejecutarlo, pero produce resultados más pulidos y estables. Es ideal para secuencias cinematográficas de alta resolución, materiales de marketing y cualquier situación en la que la precisión visual sea fundamental.

Usa sora-2-pro cuando necesites exportar en 1080p con dimensiones de 1920x1080 o 1080x1920.

Tanto sora-2 como sora-2-pro permiten generar videos de 16 y 20 segundos.

Generar un video

Generar un video es un proceso asíncrono :

1. Cuando llamas al punto de acceso POST /videos, la API devuelve un objeto de trabajo con un id de trabajo y un status inicial.

2. Puedes consultar periódicamente el punto de acceso GET /videos/{video_id} hasta que el estado cambie a completado o, como alternativa más eficiente, usar webhooks (consulta la sección sobre webhooks más adelante) para recibir una notificación automática cuando termine el trabajo.

3. Una vez que el trabajo alcance el estado completed, puedes obtener el archivo MP4 final con GET /videos/{video_id}/content.

Iniciar un trabajo de renderizado

Para empezar, llama a POST /videos con un prompt de texto y los parámetros necesarios. El prompt define el aspecto y el estilo visual, incluidos los sujetos, la cámara, la iluminación y el movimiento, mientras que parámetros como size y seconds controlan la resolución y la duración del video.

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 respuesta es un objeto JSON con un identificador único y un estado inicial como queued o in_progress. Esto significa que el trabajo de renderizado ha comenzado.

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

Elegir el tamaño y la duración

Elige el formato más pequeño que satisfaga tus necesidades de producción:

• Usa clips más cortos cuando estés haciendo ajustes al prompt, el movimiento o la composición.
• Genera videos de hasta 20 segundos cuando necesites momentos más largos, escenas más completas o anuncios más desarrollados.
• Usa sora-2-pro para exportar videos de mayor resolución en 1920x1080 o 1080x1920.

Los trabajos de mayor duración y los de 1080p pueden tardar considerablemente más en completarse que los renderizados cortos de 720p o 480p, así que prevé una mayor latencia en los flujos que usan los usuarios.

Medidas de protección y restricciones

La API aplica varias restricciones de contenido:

• Solo se permite contenido apto para menores de 18 años (en el futuro habrá una opción para omitir esta restricción).
• Se rechazarán los personajes y la música protegidos por derechos de autor.
• No se pueden generar personas reales, incluidas las figuras públicas.
• Las cargas de personajes con apariencia humana están bloqueadas de forma predeterminada.
• Actualmente se rechazan las imágenes de entrada con rostros humanos.

Asegúrate de que los prompts, las imágenes de referencia y las transcripciones respeten estas reglas para evitar errores en la generación.

Diseño de prompts eficaces

Para obtener los mejores resultados, describe el tipo de plano, el sujeto, la acción, el entorno y la iluminación. Por ejemplo:

• “Plano general de un niño volando una cometa roja en un parque con césped, luz del sol durante la hora dorada, la cámara hace una panorámica lenta hacia arriba”.
• “Primer plano de una taza de café humeante sobre una mesa de madera, luz matutina que entra por las persianas, profundidad de campo suave”.

Este nivel de detalle ayuda al modelo a producir resultados consistentes sin inventar detalles no deseados. Para conocer técnicas más avanzadas de diseño de prompts, consulta nuestra guía de diseño de prompts específica para Sora 2.

Monitorear el progreso

La generación de video lleva tiempo. Según el modelo, la carga de la API y la resolución, un solo renderizado puede tardar varios minutos.

Para gestionar esto de manera eficiente, puedes consultar periódicamente la API para obtener actualizaciones de estado o recibir notificaciones mediante un webhook.

Consultar periódicamente el punto de acceso de estado

Llama a GET /videos/{video_id} con el ID que devuelve la llamada de creación. La respuesta muestra el estado actual del trabajo, el porcentaje de progreso (si está disponible) y cualquier error.

Los estados habituales son queued, in_progress, completed y failed. Consulta el estado a intervalos razonables (por ejemplo, cada 10–20 segundos), aplica una espera exponencial entre reintentos si es necesario e informa a los usuarios que el trabajo sigue en curso.

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

Ejemplo de respuesta:

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

Usar webhooks para recibir notificaciones

En lugar de consultar repetidamente el estado del trabajo con GET, registra un webhook para recibir una notificación automática cuando la generación de un video se complete o falle.

Puedes configurar los webhooks en la página de configuración de webhooks. Cuando un trabajo termina, la API emite uno de dos tipos de eventos: video.completed y video.failed. Cada evento incluye el ID del trabajo que lo desencadenó.

Ejemplo de la carga útil de un webhook:

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

Obtener los resultados

Descargar el MP4

Una vez que el trabajo alcance el estado completed, obtén el MP4 con GET /videos/{video_id}/content. Este punto de acceso transmite los datos binarios del video y devuelve encabezados de contenido estándar, por lo que puedes guardar el archivo directamente en el disco o canalizarlo a un servicio de almacenamiento en la nube.

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

Ahora tienes el archivo de video final listo para reproducirlo, editarlo o distribuirlo. Las URL de descarga son válidas durante un máximo de 1 hora después de la generación. Si necesitas almacenamiento a largo plazo, copia el archivo a tu propio sistema de almacenamiento cuanto antes.

Descargar recursos complementarios

Para cada video completado, también puedes descargar una miniatura y una hoja de sprites. Estos recursos ligeros son útiles para vistas previas, controles de desplazamiento por el video o vistas de catálogo. Usa el parámetro de consulta variant para especificar qué quieres descargar. El valor predeterminado es variant=video para el 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

Usar imágenes de referencia

Puedes guiar una generación con una imagen de entrada, que funciona como el primer fotograma de tu video. Esto resulta útil si necesitas que el video generado conserve la apariencia de un recurso de marca, un personaje o un entorno específico.

Elige el formato de input_reference según el tipo de solicitud:

• Usa input_reference con una imagen cargada en las solicitudes multipart/form-data.
• Usa input_reference con un objeto JSON en las solicitudes application/json, incluidas las de procesamiento por lotes. El formato JSON acepta file_id o image_url.

La imagen debe tener la misma resolución que el video de destino (size).

Los formatos de archivo compatibles son image/jpeg, image/png y 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"

Imagen de entrada generada con OpenAI GPT Image	Video generado con Sora 2 (convertido a GIF)
Descargar esta imagen	Prompt: “Ella se da vuelta y sonríe, luego camina lentamente hasta salir del encuadre”.
Descargar esta imagen	Prompt: “La puerta del refrigerador se abre. De él sale un monstruo morado, tierno y regordete”.

Usar personajes para mantener la consistencia

Los personajes te permiten cargar un sujeto no humano reutilizable y usarlo como referencia en varias generaciones. Esto resulta útil cuando quieres que un animal, una mascota o un objeto mantenga la misma apariencia básica, estilo y presencia en pantalla en varias tomas.

Los personajes son distintos de input_reference. Una imagen de referencia condiciona el fotograma inicial de una sola generación, mientras que un recurso de personaje se puede reutilizar en futuras solicitudes de video.

Crea el personaje cargando un clip MP4 corto en POST /v1/videos/characters y luego incluye el ID de personaje devuelto en el arreglo characters cuando crees un video.

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"

Menciona el nombre del personaje exactamente como está escrito en tu prompt. Pasar solo el ID del personaje no basta para conservarlo de forma confiable en la toma.

Los personajes se pueden combinar con input_reference. Las extensiones no admiten personajes.

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

Extender videos completados

Las extensiones de video te permiten continuar un video ya completado y crear un nuevo resultado que une ambos segmentos. Proporciona el video de origen en el campo video de la solicitud a POST /v1/videos/extensions y agrega un prompt que describa cómo debe continuar la escena. La API genera el siguiente segmento usando todo el clip de origen como contexto.

Usa extensiones cuando quieras conservar el movimiento, la dirección de la cámara y la continuidad de la escena. Si solo necesitas controlar el primer fotograma de una nueva generación, usa input_reference en su lugar.

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

Editar videos existentes

La edición te permite tomar un video existente y hacer ajustes específicos sin volver a generar todo desde cero. Envía una solicitud a POST /v1/videos/edits con un prompt y una referencia en video, y el sistema reutiliza la estructura, la continuidad y la composición originales al aplicar la modificación. Esto funciona mejor cuando haces un solo cambio bien definido, ya que las ediciones pequeñas y específicas conservan mejor la fidelidad al original y reducen el riesgo de introducir artefactos.

El campo video acepta un ID de video o un video cargado. Si pasas un ID de video, la API infiere el modelo a partir del video de origen.

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 cargas un video nuevo en lugar de editar uno ya generado, establece model explícitamente en la solicitud.

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 edición es especialmente útil para iterar porque te permite perfeccionar el resultado sin descartar lo que ya funciona. Al limitar cada edición a un solo ajuste claro, mantienes el estilo visual, la coherencia del sujeto y el encuadre de la cámara, mientras exploras variaciones en la atmósfera, la paleta de colores o la puesta en escena. Así es mucho más fácil crear secuencias pulidas mediante pasos pequeños y confiables.

Video original	Video generado editado
	Prompt: “Cambia el color del monstruo a naranja”.
	Prompt: “Un segundo monstruo sale justo después”.

Ejecutar trabajos de video con la API de procesamiento por lotes

Usa la API de procesamiento por lotes cuando necesites poner en cola muchas renderizaciones de video para procesarlas sin conexión, incorporarlas a procesos de revisión o integrarlas en flujos de trabajo de estudio. Cada línea del archivo de entrada del lote usa el mismo cuerpo de solicitud JSON que enviarías a POST /v1/videos, lo que la hace adecuada para listas de tomas y colas de renderización programadas.

Para generar videos con el procesamiento por lotes:

• Actualmente, el procesamiento por lotes solo admite POST /v1/videos.
• Las solicitudes de procesamiento por lotes deben usar JSON, no multipart.
• Carga los recursos con anticipación y haz referencia a ellos desde el cuerpo de la solicitud JSON.
• Usa input_reference para las generaciones guiadas por imágenes en el procesamiento por lotes. En las solicitudes JSON, pasa input_reference como un objeto con file_id o image_url.
• El procesamiento por lotes no admite cargas multipart de input_reference, incluidas las entradas de video de referencia.
• Los videos generados mediante procesamiento por lotes están disponibles para su descarga durante un máximo de 24 horas después de que se complete el 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"}}

Cuando un lote alcanza el estado completed, los trabajos de video incluidos en su salida ya han alcanzado un estado final, como completed, failed o expired. Usa valores estables de custom_id para poder asociar los resultados del lote con tus ID internos de tomas, tu cola de edición o tu flujo de procesamiento de recursos. Luego, descarga los recursos finales con los ID de video devueltos.

Administrar tu biblioteca

Usa GET /videos para obtener una lista de tus videos. El punto de acceso admite parámetros de consulta opcionales para paginar y ordenar los resultados.

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

Usa DELETE /videos/{video_id} para eliminar del almacenamiento de OpenAI los videos que ya no necesites.

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