Sora 2 Tutorial Completo da API de Personagens: 2 Métodos para Criar Personagens Reutilizáveis e Manter Consistência de Personagens em Múltiplos Vídeos

Método 1: Extrair Personagem de URL de Vídeo

Este é o método mais direto – você fornece uma URL de vídeo e especifica em qual intervalo de tempo o personagem aparece.

Estrutura Básica da Requisição

import requests

url = "https://api.openai.com/v1/sora/characters"

headers = {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json"
}

data = {
    "model": "sora-2-character",
    "url": "https://cdn.openai.com/sora/videos/example.mp4",
    "timestamps": "5,8"  # Extrai o personagem que aparece entre 5-8 segundos
}

response = requests.post(url, headers=headers, json=data)
print(response.json())

Parâmetros Detalhados

Entendendo o Parâmetro timestamps

O timestamps é crucial para a extração precisa do personagem. Veja como funciona:

// Formato: "inicio,fim" (em segundos)
"timestamps": "5,8"    // Extrai o personagem que aparece entre 5-8 segundos
"timestamps": "0,3"    // Extrai dos primeiros 3 segundos
"timestamps": "10,15"  // Extrai do intervalo 10-15 segundos

Dicas para escolher o timestamps ideal:

1. Escolha um segmento onde o personagem esteja claramente visível (não cortado, não borrado)
2. 3-5 segundos é geralmente suficiente para capturar as características
3. Evite cenas com múltiplos personagens no quadro
4. Prefira cenas com boa iluminação e ângulo frontal ou de perfil

Exemplo Completo com Tratamento de Resposta

import requests
import json

def criar_personagem_de_url(video_url, inicio, fim, api_key):
    """
    Cria um personagem a partir de uma URL de vídeo
    
    Args:
        video_url: URL do vídeo fonte
        inicio: Segundo inicial (int ou float)
        fim: Segundo final (int ou float)
        api_key: Sua chave de API OpenAI
    """
    url = "https://api.openai.com/v1/sora/characters"
    
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }
    
    data = {
        "model": "sora-2-character",
        "url": video_url,
        "timestamps": f"{inicio},{fim}"
    }
    
    try:
        response = requests.post(url, headers=headers, json=data)
        response.raise_for_status()
        
        resultado = response.json()
        character_id = resultado.get("character_id")
        
        print(f"✅ Personagem criado com sucesso!")
        print(f"🎭 Character ID: {character_id}")
        print(f"📝 Resposta completa: {json.dumps(resultado, indent=2)}")
        
        return character_id
        
    except requests.exceptions.RequestException as e:
        print(f"❌ Erro ao criar personagem: {e}")
        return None

# Uso
character_id = criar_personagem_de_url(
    video_url="https://cdn.openai.com/sora/videos/my-character.mp4",
    inicio=5,
    fim=8,
    api_key="sk-proj-..."
)

Exemplo de Resposta da API

{
  "id": "char_abc123xyz456",
  "object": "character",
  "created": 1735689600,
  "model": "sora-2-character",
  "character_id": "@char_abc123xyz456",
  "source": {
    "type": "url",
    "url": "https://cdn.openai.com/sora/videos/example.mp4",
    "timestamps": "5,8"
  },
  "status": "completed"
}

O character_id retornado (por exemplo, @char_abc123xyz456) é o que você vai usar em futuras gerações de vídeo para manter a consistência do personagem.

Método 2: Reutilizar Personagem de Task ID

Se você já gerou um vídeo anteriormente usando a Sora 2 Video API e quer extrair um personagem desse vídeo, pode usar o ID da tarefa (task ID) diretamente, sem precisar da URL.

Por Que Usar Este Método?

✅ Mais conveniente: Você já tem o task_id da geração anterior
✅ Mais rápido: Não precisa fazer upload/hospedar o vídeo
✅ Workflow integrado: Perfeito para pipelines automatizados

Estrutura Básica da Requisição

import requests

url = "https://api.openai.com/v1/sora/characters"

headers = {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json"
}

data = {
    "model": "sora-2-character",
    "from_task": "video_f751ab91c3764925a297e4c279a260b3",  # ID da tarefa anterior
    "timestamps": "5,8"
}

response = requests.post(url, headers=headers, json=data)
print(response.json())

Parâmetros Detalhados

Workflow Completo: Gerar Vídeo → Extrair Personagem

Veja como isso funciona na prática, do início ao fim:

import requests
import time
import json

class SoraCharacterWorkflow:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://api.openai.com/v1/sora"
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }
    
    def gerar_video_inicial(self, prompt):
        """Passo 1: Gerar o vídeo inicial"""
        print("🎬 Gerando vídeo inicial...")
        
        data = {
            "model": "sora-2.0-standard",
            "prompt": prompt,
            "duration": 10
        }
        
        response = requests.post(
            f"{self.base_url}/videos/generations",
            headers=self.headers,
            json=data
        )
        response.raise_for_status()
        
        task_id = response.json()["id"]
        print(f"📋 Task ID: {task_id}")
        
        return task_id
    
    def aguardar_conclusao(self, task_id):
        """Passo 2: Aguardar a conclusão do vídeo"""
        print("⏳ Aguardando conclusão do vídeo...")
        
        while True:
            response = requests.get(
                f"{self.base_url}/videos/generations/{task_id}",
                headers=self.headers
            )
            response.raise_for_status()
            
            status_data = response.json()
            status = status_data.get("status")
            
            if status == "completed":
                print("✅ Vídeo concluído!")
                return status_data
            elif status == "failed":
                raise Exception("❌ Geração de vídeo falhou")
            
            print(f"  Status: {status}...")
            time.sleep(5)
    
    def extrair_personagem(self, task_id, inicio, fim):
        """Passo 3: Extrair personagem do vídeo gerado"""
        print(f"🎭 Extraindo personagem do intervalo {inicio}-{fim}s...")
        
        data = {
            "model": "sora-2-character",
            "from_task": task_id,
            "timestamps": f"{inicio},{fim}"
        }
        
        response = requests.post(
            f"{self.base_url}/characters",
            headers=self.headers,
            json=data
        )
        response.raise_for_status()
        
        char_data = response.json()
        character_id = char_data.get("character_id")
        
        print(f"✅ Personagem criado: {character_id}")
        return character_id
    
    def gerar_video_com_personagem(self, prompt, character_id):
        """Passo 4: Gerar novo vídeo usando o personagem"""
        print(f"🎥 Gerando novo vídeo com personagem {character_id}...")
        
        # Incorpora o character_id no prompt
        prompt_completo = f"{character_id} {prompt}"
        
        data = {
            "model": "sora-2.0-standard",
            "prompt": prompt_completo,
            "duration": 10
        }
        
        response = requests.post(
            f"{self.base_url}/videos/generations",
            headers=self.headers,
            json=data
        )
        response.raise_for_status()
        
        return response.json()["id"]

# ===== EXEMPLO DE USO COMPLETO =====
workflow = SoraCharacterWorkflow(api_key="sk-proj-...")

# Passo 1: Gerar vídeo inicial com o personagem
task_id_inicial = workflow.gerar_video_inicial(
    prompt="Uma jovem mulher com cabelo ruivo curto, usando jaqueta de couro preta, caminhando em uma cidade cyberpunk à noite"
)

# Passo 2: Aguardar conclusão
workflow.aguardar_conclusao(task_id_inicial)

# Passo 3: Extrair personagem (aparece entre 3-7 segundos)
character_id = workflow.extrair_personagem(
    task_id=task_id_inicial,
    inicio=3,
    fim=7
)

# Passo 4: Gerar novos vídeos com o mesmo personagem
task_id_cafe = workflow.gerar_video_com_personagem(
    prompt="sentada em um café parisiense, bebendo cappuccino",
    character_id=character_id
)

task_id_praia = workflow.gerar_video_com_personagem(
    prompt="correndo na praia ao pôr do sol",
    character_id=character_id
)

print(f"""
🎉 Workflow completo!
- Personagem criado: {character_id}
- Vídeo café: {task_id_cafe}
- Vídeo praia: {task_id_praia}
""")

Vantagens do Método from_task

Comparação: URL vs Task ID

Quando Usar Cada Método

Dicas Avançadas para timestamps

O parâmetro timestamps pode parecer simples, mas usá-lo corretamente faz toda a diferença na qualidade do personagem extraído.

Regras de Ouro para timestamps

# ✅ BOM: Personagem claramente visível
"timestamps": "5,8"  # 3 segundos de cena limpa

# ❌ RUIM: Intervalo muito curto
"timestamps": "5,5.5"  # Apenas 0.5 segundos

# ❌ RUIM: Intervalo muito longo
"timestamps": "0,30"  # 30 segundos - personagem pode mudar

# ✅ ÓTIMO: Close-up frontal
"timestamps": "12,15"  # Cena de diálogo frontal

# ❌ RUIM: Múltiplos personagens
"timestamps": "20,25"  # Cena de grupo - ambíguo

Estratégia para Escolher o Melhor Intervalo

1. Assista ao vídeo primeiro: Identifique onde o personagem está mais claro
2. Prefira close-ups: Ângulos frontais ou de perfil capturam melhor os detalhes
3. Evite movimento rápido: Cenas estáticas ou com movimento lento são ideais
4. Boa iluminação: Evite cenas muito escuras ou superexpostas
5. Personagem sozinho: Se possível, escolha um momento onde apenas ele aparece

Exemplo Prático de Análise

def analisar_video_para_timestamps(video_path):
    """
    Função helper para ajudar a escolher o melhor intervalo
    (simulação - na prática você faria isso manualmente ou com análise de vídeo)
    """
    recomendacoes = {
        "cena_dialogo_frontal": "12,15",      # Personagem falando de frente
        "caminhada_perfil": "5,8",             # Caminhando de perfil
        "close_up_rosto": "20,23",             # Close no rosto
        "acao_movimento": "30,33"              # Em movimento (menos ideal)
    }
    
    print("💡 Recomendações de timestamps:")
    for cena, intervalo in recomendacoes.items():
        print(f"  {cena}: {intervalo}")
    
    return recomendacoes

# Uso
analisar_video_para_timestamps("meu_video.mp4")

Usando o Character ID em Gerações Futuras

Depois de criar o personagem, você obtém um character_id (por exemplo, @char_abc123xyz456). Veja como usá-lo:

Sintaxe Básica

# Incorpore o character_id diretamente no prompt
prompt_com_personagem = f"{character_id} {sua_descricao_de_cena}"

# Exemplo
character_id = "@char_abc123xyz456"
prompt = f"{character_id} caminhando pela Times Square à noite, luzes de neon refletindo em seu rosto"

Exemplo Completo de Reutilização

def gerar_serie_videos_com_personagem(character_id, cenas, api_key):
    """
    Gera uma série de vídeos usando o mesmo personagem
    
    Args:
        character_id: ID do personagem criado
        cenas: Lista de descrições de cena
        api_key: Sua chave de API
    """
    url = "https://api.openai.com/v1/sora/videos/generations"
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }
    
    task_ids = []
    
    for i, cena in enumerate(cenas, 1):
        prompt_completo = f"{character_id} {cena}"
        
        data = {
            "model": "sora-2.0-standard",
            "prompt": prompt_completo,
            "duration": 10
        }
        
        response = requests.post(url, headers=headers, json=data)
        response.raise_for_status()
        
        task_id = response.json()["id"]
        task_ids.append(task_id)
        
        print(f"✅ Cena {i} iniciada: {task_id}")
        print(f"   Prompt: {prompt_completo[:80]}...")
    
    return task_ids

# Uso: Criar uma série de vídeos com o mesmo personagem
character_id = "@char_abc123xyz456"

cenas = [
    "acordando em um quarto moderno, luz do sol entrando pela janela",
    "preparando café na cozinha, sorrindo",
    "saindo de casa, fechando a porta",
    "andando pela calçada da cidade, cumprimentando vizinhos",
    "entrando em um café local, pedindo bebida"
]

task_ids = gerar_serie_videos_com_personagem(
    character_id=character_id,
    cenas=cenas,
    api_key="sk-proj-..."
)

print(f"\n🎬 {len(task_ids)} vídeos em geração com personagem consistente!")

Resultado: Consistência de Personagem

Com o character_id, o mesmo personagem aparecerá em todos os vídeos com:

• ✅ Mesma aparência facial
• ✅ Mesma cor e estilo de cabelo
• ✅ Mesmas características físicas
• ✅ Mesma vestimenta base (pode variar conforme o prompt)

Casos de Uso Práticos

1. Série de Conteúdo de Marca

# Crie um mascote de marca e use em múltiplas campanhas
character_id = "@char_mascote_marca"

campanhas = {
    "lancamento_produto": f"{character_id} apresentando entusiasmadamente o novo produto em um showroom moderno",
    "tutorial": f"{character_id} demonstrando como usar o produto passo a passo",
    "depoimento": f"{character_id} compartilhando experiência positiva com o produto"
}

2. Conteúdo Educacional em Série

# Professor virtual consistente
character_id = "@char_professor_virtual"

aulas = [
    f"{character_id} explicando conceitos básicos de programação em uma sala de aula moderna",
    f"{character_id} demonstrando código Python em um quadro branco digital",
    f"{character_id} respondendo perguntas frequentes dos alunos"
]

3. Storytelling Narrativo

# Personagem principal de uma história
character_id = "@char_protagonista"

capitulos = [
    f"{character_id} descobrindo um mapa misterioso em um sótão empoeirado",
    f"{character_id} viajando para uma floresta encantada ao amanhecer",
    f"{character_id} encontrando uma criatura mágica perto de um lago",
    f"{character_id} retornando para casa, transformado pela jornada"
]

Solução de Problemas Comuns

Problema 1: "Character extraction failed"

Causa: Intervalo de timestamps inadequado

Solução:

# ❌ Evite:
"timestamps": "0,1"  # Muito curto

# ✅ Use:
"timestamps": "5,8"  # 3-5 segundos é ideal

Problema 2: Personagem inconsistente nas gerações

Causa: Prompt muito descritivo sobrescrevendo o personagem

Solução:

# ❌ Evite descrições conflitantes:
prompt = f"{character_id} um homem alto de cabelo loiro..."  # Conflita com o personagem

# ✅ Descreva apenas a cena/ação:
prompt = f"{character_id} caminhando no parque ao pôr do sol"

Problema 3: "Invalid task_id"

Causa: Task ID expirou ou inválido

Solução:

# Verifique se o task_id ainda é válido
response = requests.get(
    f"https://api.openai.com/v1/sora/videos/generations/{task_id}",
    headers=headers
)

if response.json()["status"] != "completed":
    print("❌ Task ainda não concluído ou falhou")

Conclusão

A Sora 2 Character API revoluciona a criação de conteúdo em vídeo ao resolver o problema da consistência de personagem. Com os dois métodos – URL de vídeo e Task ID – você tem flexibilidade para se adequar a diferentes workflows.

Pontos-Chave para Lembrar

✅ timestamps é crucial: Escolha intervalos de 3-5 segundos com boa visibilidade do personagem
✅ Método URL: Para vídeos existentes e fontes externas
✅ Método Task ID: Para pipelines automatizados e vídeos gerados pela Sora
✅ Reutilize o character_id: Crie séries consistentes incorporando-o nos prompts

Próximos Passos

1. Experimente criar seu primeiro personagem usando um vídeo teste
2. Teste diferentes intervalos de timestamps para ver qual produz melhores resultados
3. Construa uma pequena série de 3-5 vídeos usando o mesmo personagem
4. Automatize o processo em seu pipeline de produção

Dica Final: A APIYI oferece acesso estável e acessível à Sora 2 Character API com teste gratuito. Perfeito para experimentar esses conceitos sem compromisso inicial!

🎬 Agora é sua vez de criar personagens consistentes e dar vida às suas histórias em vídeo!

Sora 2 Character API – Dois Métodos de Criação

Método 1: Extrair Personagem de URL de Vídeo

Esta é a forma mais direta, ideal quando você já possui material de vídeo pronto.

Parâmetros da Requisição:

Exemplo Completo de Requisição:

curl https://api.apiyi.com/sora/v1/characters \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-your-api-key" \
  -d '{
    "model": "sora-2-character",
    "url": "https://your-cdn.com/video/character-source.mp4",
    "timestamps": "5,8"
  }'

⚠️ Pontos Importantes:

1. URL do vídeo deve ser publicamente acessível: Os servidores da OpenAI precisam conseguir acessar o vídeo
2. CDN configurado globalmente: Se usar OSS/CDN, certifique-se de configurar acesso global para evitar que servidores da OpenAI (geralmente no exterior) não consigam acessar
3. Intervalo de timestamps:
   • Diferença mínima: 1 segundo
   • Diferença máxima: 3 segundos
   • Exemplo: "5,8" representa do segundo 5 ao segundo 8 do vídeo

Método 2: Reutilizar Personagem por ID da Tarefa

Se você já gerou vídeos através da API Sora 2, pode usar diretamente o ID da tarefa daquele vídeo para extrair o personagem, sem precisar fazer upload novamente.

Parâmetros da Requisição:

Exemplo Completo de Requisição:

curl https://api.apiyi.com/sora/v1/characters \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-your-api-key" \
  -d '{
    "model": "sora-2-character",
    "from_task": "video_f751abfd-87a9-46e2-9236-1d94743c5e3e",
    "timestamps": "5,8"
  }'

Vantagens deste Método:

• ✅ Não precisa fazer upload adicional de vídeo, economiza banda
• ✅ Reutiliza diretamente os recursos de vídeo já gerados
• ✅ Fluxo de trabalho mais fluido, ideal para processamento em lote
• ✅ Evita problemas de expiração ou acesso de URLs de vídeo

Dica: Utilize a API Sora 2 Character através da APIYI apiyi.com, que oferece serviços de integração estáveis e créditos gratuitos para testes.

Comparação dos Dois Métodos da API Sora 2 Character

URL de Vídeo vs ID da Tarefa: Comparação dos Métodos

Dimensão

Método 1: URL de Vídeo

Método 2: ID da Tarefa

Parâmetro Principal

“url”

“from_task”

Cenário Ideal

Vídeos prontos existentes

Reutilizar vídeos do Sora

Necessita Upload

Precisa URL pública

✓ Não precisa upload

Requisitos de Rede

CDN global necessário

✓ Sem requisitos extras

Caso de Uso

Importar personagens externos

Gerar séries de vídeos

Parâmetro comum: timestamps (intervalo de 1-3 segundos)

Como Escolher?

Escolha o método de URL de Vídeo quando:

• Você tem material de vídeo pronto (como vídeos filmados, baixados de outras plataformas)
• Precisa extrair personagens de vídeos não gerados pelo Sora

Escolha o método de ID da Tarefa quando:

• Está usando a API Sora 2 para gerar vídeos em lote
• Quer extrair personagens de vídeos já gerados para usar em vídeos subsequentes da série
• Busca um fluxo de trabalho automatizado mais fluido

Sora 2 Character API timestamps 参数详解

timestamps 是 Character API 最关键的参数，它决定了从视频的哪个时间段提取角色。

timestamps 格式规则

timestamps 设置技巧

1. 选择角色清晰可见的片段: 角色应该完整出现在画面中，不要被遮挡
2. 避免快速运动的片段: 选择角色相对静止或缓慢移动的时间段
3. 确保光线充足: 光线良好的片段能提取更准确的角色特征
4. 角色正面优先: 如果可能，选择角色面向镜头的片段

示例场景：

假设你有一个 10 秒的视频，角色在第 2-4 秒正面出镜，第 6-9 秒侧面运动：

// 推荐：选择正面清晰的片段
{
  "timestamps": "2,4"
}

// 不推荐：角色侧面运动
{
  "timestamps": "6,9"
}

Sora 2 Character API 完整工作流

Python 代码示例

import requests
import time

# APIYI 接口配置
API_BASE = "https://api.apiyi.com/sora/v1"
API_KEY = "sk-your-api-key"

headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {API_KEY}"
}

def create_character_from_url(video_url: str, timestamps: str) -> dict:
    """方法一：从视频 URL 创建角色"""
    response = requests.post(
        f"{API_BASE}/characters",
        headers=headers,
        json={
            "model": "sora-2-character",
            "url": video_url,
            "timestamps": timestamps
        }
    )
    return response.json()

def create_character_from_task(task_id: str, timestamps: str) -> dict:
    """方法二：从任务 ID 创建角色"""
    response = requests.post(
        f"{API_BASE}/characters",
        headers=headers,
        json={
            "model": "sora-2-character",
            "from_task": task_id,
            "timestamps": timestamps
        }
    )
    return response.json()

# 使用示例
# 方法一：从视频 URL 创建
result1 = create_character_from_url(
    video_url="https://your-cdn.com/video/hero.mp4",
    timestamps="5,8"
)
print(f"角色创建任务: {result1}")

# 方法二：从任务 ID 创建
result2 = create_character_from_task(
    task_id="video_f751abfd-87a9-46e2-9236-1d94743c5e3e",
    timestamps="2,4"
)
print(f"角色创建任务: {result2}")

import requests
import time

API_BASE = "https://api.apiyi.com/sora/v1"
API_KEY = "sk-your-api-key"

headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {API_KEY}"
}

def create_character(video_url: str, timestamps: str) -> str:
    """创建角色并返回角色 ID"""
    # 1. 发起角色创建请求
    response = requests.post(
        f"{API_BASE}/characters",
        headers=headers,
        json={
            "model": "sora-2-character",
            "url": video_url,
            "timestamps": timestamps
        }
    )
    task_data = response.json()
    task_id = task_data.get("task_id")

    # 2. 轮询等待任务完成
    while True:
        status_response = requests.get(
            f"{API_BASE}/characters/{task_id}",
            headers=headers
        )
        status_data = status_response.json()

        if status_data.get("status") == "completed":
            return status_data.get("character_id")
        elif status_data.get("status") == "failed":
            raise Exception(f"角色创建失败: {status_data}")

        time.sleep(5)  # 每 5 秒检查一次

def generate_video_with_character(prompt: str, character_id: str) -> str:
    """使用角色生成视频"""
    # 在 prompt 中通过 @character_id 引用角色
    full_prompt = f"@{character_id} {prompt}"

    response = requests.post(
        f"{API_BASE}/videos",
        headers=headers,
        json={
            "model": "sora-2",
            "prompt": full_prompt,
            "duration": 8,
            "resolution": "1080p"
        }
    )
    return response.json()

# 完整流程示例
if __name__ == "__main__":
    # 步骤 1: 创建角色
    character_id = create_character(
        video_url="https://your-cdn.com/video/hero.mp4",
        timestamps="5,8"
    )
    print(f"角色创建成功，ID: {character_id}")

    # 步骤 2: 使用角色生成系列视频
    scenes = [
        "walking through a futuristic city at night",
        "sitting in a coffee shop, reading a book",
        "running on a beach at sunset"
    ]

    for i, scene in enumerate(scenes):
        result = generate_video_with_character(scene, character_id)
        print(f"视频 {i+1} 生成任务: {result}")

提示: 通过 APIYI apiyi.com 接入 Sora 2 Character API，平台提供完整的角色管理功能和技术支持。

Perguntas Frequentes

@char_abc123xyz caminhando em uma cidade futurista, com luzes de neon piscando

Resumo

Pontos-chave da Sora 2 Character API:

1. Dois métodos de criação: Extração via URL de vídeo e reutilização de ID de tarefa, adaptando-se flexivelmente a diferentes cenários
2. Parâmetro timestamps: Intervalo de tempo de 1-3 segundos, escolha segmentos onde o personagem esteja claramente visível
3. Reutilização de personagens: Crie uma vez, use várias vezes em diferentes vídeos, mantendo a consistência do personagem
4. Configuração de CDN: Ao usar o método de URL de vídeo, garanta acessibilidade global

Depois de dominar a Character API, você poderá:

• Criar personagens virtuais reutilizáveis para IPs de marca
• Produzir conteúdo de vídeo em série com personagens consistentes
• Realizar vídeos narrativos contínuos de nível profissional

Recomendamos integrar a Sora 2 Character API através da APIYI apiyi.com – a plataforma oferece serviços estáveis e créditos gratuitos para testes, ajudando você a começar rapidamente com a funcionalidade de criação de personagens.

📚 Materiais de Referência

⚠️ Nota sobre formato de links: Todos os links externos usam o formato Nome do Material: domain.com para facilitar a cópia, mas não são clicáveis, evitando perda de peso SEO.

1. Lançamento Oficial do OpenAI Sora 2: Introdução às funcionalidades e características do Sora 2

   • Link: openai.com/index/sora-2/
   • Descrição: Informações oficiais sobre o Sora 2 e funcionalidades de personagens

2. Central de Ajuda OpenAI – Funcionalidade Characters: Guia de criação e uso de personagens

   • Link: help.openai.com/en/articles/12435986-generating-content-with-characters
   • Descrição: Instruções oficiais sobre como usar a funcionalidade de personagens

3. Documentação da API OpenAI – Video Generation: Documentação técnica da API Sora

   • Link: platform.openai.com/docs/guides/video-generation
   • Descrição: Especificações da interface API e descrição de parâmetros

4. Página OpenAI Sora Characters: Apresentação do produto de funcionalidade de personagens

   • Link: openai.com/sora/characters/
   • Descrição: Posicionamento do produto e cenários de uso da funcionalidade de personagens

Autor: Equipe Técnica
Intercâmbio Técnico: Sinta-se à vontade para discutir nos comentários. Para mais materiais, visite a comunidade técnica APIYI apiyi.com