Tutorial Lengkap API Karakter Sora 2: 2 Metode Membuat Karakter yang Dapat Digunakan Kembali, Mencapai Konsistensi Karakter Lintas Video

方法一：通过视频 URL 创建角色

这是最直接的方法：你已经有一个现成的视频，想从中提取角色特征。

基本用法

import requests

API_KEY = "your_api_key_here"
BASE_URL = "https://api.openai.com/v1"

def create_character_from_url(video_url, timestamps):
    """从视频 URL 创建角色"""
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "model": "sora-2-character",
        "url": video_url,
        "timestamps": timestamps
    }
    
    response = requests.post(
        f"{BASE_URL}/sora/v1/characters",
        headers=headers,
        json=payload
    )
    
    return response.json()

# 示例：从视频中提取角色
video_url = "https://cdn.example.com/my-video.mp4"
timestamps = "5,8"  # 从第5秒到第8秒

result = create_character_from_url(video_url, timestamps)
print(f"角色 ID: {result['id']}")
print(f"状态: {result['status']}")

timestamps 参数详解

timestamps 是一个 关键参数，用于指定角色在视频中的出现时间：

最佳实践:

• ✅ 选择角色清晰出现的片段
• ✅ 避免快速运动或模糊的场景
• ✅ 时间范围建议 3-10 秒
• ❌ 避免包含多个角色的混乱场景

完整示例：企业级封装

import requests
import time
from typing import Optional, Dict

class SoraCharacterClient:
    def __init__(self, api_key: str, base_url: str = "https://api.openai.com/v1"):
        self.api_key = api_key
        self.base_url = base_url
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }
    
    def create_character_from_url(
        self, 
        video_url: str, 
        timestamps: str,
        wait_for_completion: bool = True,
        timeout: int = 300
    ) -> Dict:
        """
        从视频 URL 创建角色
        
        Args:
            video_url: 视频 URL 地址
            timestamps: 时间范围，格式 "start,end"
            wait_for_completion: 是否等待任务完成
            timeout: 超时时间（秒）
        
        Returns:
            包含 character_id 的字典
        """
        payload = {
            "model": "sora-2-character",
            "url": video_url,
            "timestamps": timestamps
        }
        
        response = requests.post(
            f"{self.base_url}/sora/v1/characters",
            headers=self.headers,
            json=payload
        )
        response.raise_for_status()
        result = response.json()
        
        if not wait_for_completion:
            return result
        
        # 轮询等待完成
        character_id = result['id']
        start_time = time.time()
        
        while time.time() - start_time < timeout:
            status = self.get_character_status(character_id)
            
            if status['status'] == 'completed':
                print(f"✅ 角色创建成功: {character_id}")
                return status
            elif status['status'] == 'failed':
                raise Exception(f"❌ 角色创建失败: {status.get('error')}")
            
            time.sleep(2)  # 每2秒查询一次
        
        raise TimeoutError(f"⏰ 角色创建超时（{timeout}秒）")
    
    def get_character_status(self, character_id: str) -> Dict:
        """查询角色创建状态"""
        response = requests.get(
            f"{self.base_url}/sora/v1/characters/{character_id}",
            headers=self.headers
        )
        response.raise_for_status()
        return response.json()
    
    def list_characters(self) -> Dict:
        """列出所有已创建的角色"""
        response = requests.get(
            f"{self.base_url}/sora/v1/characters",
            headers=self.headers
        )
        response.raise_for_status()
        return response.json()

# 使用示例
client = SoraCharacterClient(api_key="your_api_key")

# 创建角色并等待完成
character = client.create_character_from_url(
    video_url="https://cdn.example.com/intro.mp4",
    timestamps="3.5,7.2",
    wait_for_completion=True
)

print(f"🎭 新角色 ID: {character['id']}")

# 查看所有角色
all_characters = client.list_characters()
print(f"📋 共有 {len(all_characters.get('data', []))} 个角色")

方法二：通过任务 ID 创建角色

如果你刚用 Sora 生成了一个视频，可以直接从该任务中提取角色，无需先下载视频再上传。

基本用法

def create_character_from_task(task_id, timestamps):
    """从 Sora 任务 ID 创建角色"""
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "model": "sora-2-character",
        "from_task": task_id,
        "timestamps": timestamps
    }
    
    response = requests.post(
        f"{BASE_URL}/sora/v1/characters",
        headers=headers,
        json=payload
    )
    
    return response.json()

# 示例：从刚生成的视频任务中提取角色
task_id = "video_f751ab2c-8945-4c5e-a123-456789abcdef"
timestamps = "2,6"

result = create_character_from_task(task_id, timestamps)
print(f"角色 ID: {result['id']}")

典型工作流：生成 → 提取 → 复用

这种方法非常适合 一气呵成的工作流：

class SoraWorkflow:
    def __init__(self, api_key: str):
        self.client = SoraCharacterClient(api_key)
    
    def generate_and_extract_character(
        self, 
        prompt: str, 
        character_timestamps: str
    ) -> str:
        """
        完整工作流：生成视频 → 提取角色 → 返回角色 ID
        
        Args:
            prompt: 视频生成提示词
            character_timestamps: 角色出现的时间范围
        
        Returns:
            character_id
        """
        # 第一步：生成视频
        print("🎬 步骤 1: 生成视频...")
        video_task = self._generate_video(prompt)
        task_id = video_task['id']
        
        # 等待视频生成完成
        self._wait_for_video(task_id)
        print(f"✅ 视频生成完成: {task_id}")
        
        # 第二步：从视频中提取角色
        print("🎭 步骤 2: 提取角色...")
        character = self.client.create_character_from_url(
            video_url=None,  # 使用 from_task，不需要 URL
            timestamps=character_timestamps
        )
        
        # 实际应该使用 from_task
        character = self._create_from_task(task_id, character_timestamps)
        
        character_id = character['id']
        print(f"✅ 角色提取完成: {character_id}")
        
        return character_id
    
    def _create_from_task(self, task_id: str, timestamps: str) -> Dict:
        """内部方法：从任务创建角色"""
        payload = {
            "model": "sora-2-character",
            "from_task": task_id,
            "timestamps": timestamps
        }
        
        response = requests.post(
            f"{self.client.base_url}/sora/v1/characters",
            headers=self.client.headers,
            json=payload
        )
        response.raise_for_status()
        return response.json()
    
    def _generate_video(self, prompt: str) -> Dict:
        """生成视频（示例）"""
        # 这里应调用 Sora 视频生成 API
        # 参考之前的文章
        pass
    
    def _wait_for_video(self, task_id: str):
        """等待视频生成完成"""
        # 轮询逻辑
        pass

# 使用示例
workflow = SoraWorkflow(api_key="your_api_key")

# 一键生成视频并提取角色
character_id = workflow.generate_and_extract_character(
    prompt="A young woman in a red dress walking in a park",
    character_timestamps="3,8"
)

print(f"🎉 角色已就绪，可以在后续视频中使用: @{character_id}")

两种方法对比

选择建议:

• 🎯 如果你的视频来自 Sora 自己生成 → 用 任务 ID 方法
• 🎯 如果你的视频来自其他来源（上传、第三方）→ 用 URL 方法

timestamps 参数最佳实践

1. 选择清晰的时间段

# ✅ 好的例子：角色正面清晰
timestamps = "5,8"  # 角色从正面走来，特征清晰

# ❌ 不好的例子：角色背对或模糊
timestamps = "0,2"  # 角色可能还在远处或侧面

2. 避免快速运动

# ✅ 稳定场景
timestamps = "10,15"  # 角色站立或缓慢行走

# ❌ 快速运动
timestamps = "20,22"  # 角色快速跑动，可能模糊

3. 时间范围建议

# 推荐：3-10 秒
timestamps = "5,10"  # 5秒足够提取特征

# 太短：< 2 秒
timestamps = "5,6"   # 可能特征不够充分

# 太长：> 15 秒
timestamps = "5,25"  # 增加处理时间，不必要

4. 处理多角色场景

如果视频中有多个角色，timestamps 应该选择 目标角色独自出现或最突出的时间段：

# 场景：视频中有3个人物
# 0-5秒：三人都在
# 5-10秒：只有目标角色
# 10-15秒：又是三人

# ✅ 正确选择
timestamps = "5,10"  # 只提取目标角色

# ❌ 错误选择
timestamps = "0,5"   # 会混淆多个角色

实战案例：创建品牌 IP 角色库

假设你要为公司创建一套 AI 虚拟代言人角色库：

class BrandCharacterLibrary:
    def __init__(self, api_key: str):
        self.client = SoraCharacterClient(api_key)
        self.characters = {}
    
    def create_brand_character(
        self, 
        name: str, 
        video_url: str, 
        timestamps: str,
        metadata: Optional[Dict] = None
    ) -> str:
        """
        创建品牌角色并存储到库中
        
        Args:
            name: 角色名称（如 "主播小美"）
            video_url: 角色视频 URL
            timestamps: 时间范围
            metadata: 额外元数据（描述、用途等）
        
        Returns:
            character_id
        """
        print(f"📝 创建角色: {name}")
        
        character = self.client.create_character_from_url(
            video_url=video_url,
            timestamps=timestamps,
            wait_for_completion=True
        )
        
        character_id = character['id']
        
        # 存储到角色库
        self.characters[name] = {
            'id': character_id,
            'video_url': video_url,
            'timestamps': timestamps,
            'metadata': metadata or {},
            'created_at': time.time()
        }
        
        print(f"✅ {name} 创建成功: {character_id}")
        return character_id
    
    def get_character_id(self, name: str) -> Optional[str]:
        """根据角色名称获取 ID"""
        return self.characters.get(name, {}).get('id')
    
    def generate_video_with_character(
        self, 
        character_name: str, 
        prompt: str
    ) -> str:
        """
        使用指定角色生成视频
        
        Args:
            character_name: 角色名称
            prompt: 视频提示词
        
        Returns:
            视频任务 ID
        """
        character_id = self.get_character_id(character_name)
        if not character_id:
            raise ValueError(f"角色 '{character_name}' 不存在")
        
        # 在提示词中引用角色
        full_prompt = f"@{character_id} {prompt}"
        
        print(f"🎬 使用角色 '{character_name}' 生成视频")
        print(f"📝 提示词: {full_prompt}")
        
        # 调用 Sora 视频生成 API
        # ...（参考之前的文章）
        
        return "video_task_id"
    
    def export_library(self, filepath: str):
        """导出角色库到 JSON 文件"""
        import json
        with open(filepath, 'w', encoding='utf-8') as f:
            json.dump(self.characters, f, indent=2, ensure_ascii=False)
        print(f"💾 角色库已导出到: {filepath}")

# 使用示例
library = BrandCharacterLibrary(api_key="your_api_key")

# 创建多个品牌角色
library.create_brand_character(
    name="主播小美",
    video_url="https://cdn.example.com/xiaomei.mp4",
    timestamps="5,10",
    metadata={
        "description": "品牌主播，穿红色连衣裙",
        "use_case": "产品介绍视频"
    }
)

library.create_brand_character(
    name="技术专家老王",
    video_url="https://cdn.example.com/laowang.mp4",
    timestamps="3,8",
    metadata={
        "description": "中年男性，戴眼镜",
        "use_case": "技术讲解视频"
    }
)

# 使用角色生成视频
library.generate_video_with_character(
    character_name="主播小美",
    prompt="walking in a modern office, smiling and waving"
)

# 导出角色库
library.export_library("brand_characters.json")

输出示例：

📝 创建角色: 主播小美
✅ 主播小美 创建成功: char_abc123
📝 创建角色: 技术专家老王
✅ 技术专家老王 创建成功: char_def456
🎬 使用角色 '主播小美' 生成视频
📝 提示词: @char_abc123 walking in a modern office, smiling and waving
💾 角色库已导出到: brand_characters.json

常见问题与解决方案

Q1: timestamps 选择不当导致角色不准确？

问题: 选择的时间段角色特征不清晰，提取的角色 ID 不理想。

解决方案:

def find_best_timestamps(video_url: str, character_description: str) -> str:
    """
    辅助函数：帮助找到最佳时间段
    （实际需要视频分析能力，这里提供思路）
    """
    # 思路：
    # 1. 分析视频帧，检测人脸清晰度
    # 2. 找到角色正面、清晰、稳定的片段
    # 3. 返回推荐的 timestamps
    
    # 简化示例：手动指定多个候选
    candidates = [
        ("5,8", "角色正面行走"),
        ("12,15", "角色近景特写"),
        ("20,23", "角色静止站立")
    ]
    
    print("💡 推荐以下时间段:")
    for ts, desc in candidates:
        print(f"  - {ts}: {desc}")
    
    return candidates[0][0]  # 返回第一个推荐

# 使用
best_ts = find_best_timestamps(
    video_url="https://cdn.example.com/video.mp4",
    character_description="年轻女性，红色裙子"
)

Q2: 如何验证角色提取是否成功？

解决方案: 立即用提取的角色生成测试视频：

def verify_character(character_id: str) -> bool:
    """验证角色是否提取成功"""
    test_prompt = f"@{character_id} standing in a white room, neutral lighting"
    
    # 生成测试视频
    # result = generate_video(test_prompt)
    
    print(f"🧪 已生成测试视频，请检查角色是否正确")
    print(f"   如果不满意，请调整 timestamps 重新提取")
    
    return True

Q3: 角色 ID 如何管理？

解决方案: 使用数据库或 JSON 文件持久化：

import json
from pathlib import Path

class CharacterManager:
    def __init__(self, storage_file: str = "characters.json"):
        self.storage_file = Path(storage_file)
        self.characters = self._load()
    
    def _load(self) -> Dict:
        """加载角色库"""
        if self.storage_file.exists():
            with open(self.storage_file, 'r', encoding='utf-8') as f:
                return json.load(f)
        return {}
    
    def save(self):
        """保存角色库"""
        with open(self.storage_file, 'w', encoding='utf-8') as f:
            json.dump(self.characters, f, indent=2, ensure_ascii=False)
    
    def add_character(self, name: str, character_id: str, **kwargs):
        """添加角色"""
        self.characters[name] = {
            'id': character_id,
            **kwargs
        }
        self.save()
        print(f"✅ 角色 '{name}' 已保存")
    
    def get_id(self, name: str) -> Optional[str]:
        """获取角色 ID"""
        return self.characters.get(name, {}).get('id')

# 使用
manager = CharacterManager()
manager.add_character(
    name="主角小明",
    character_id="char_xyz789",
    description="男性，黑色T恤",
    source_video="intro.mp4"
)

# 后续使用
xiaoming_id = manager.get_id("主角小明")
prompt = f"@{xiaoming_id} playing basketball"

推荐 API 中转服务

在实际使用 Sora 2 Character API 时，推荐使用 APIYI 中转服务：

• ✅ 价格便宜: 比官方直连更优惠
• ✅ 稳定可靠: 国内访问速度快
• ✅ 免费试用: 新用户免费额度
• ✅ 完整支持: 支持所有 Sora 2 功能

访问 APIYI官网 注册即可开始使用。

总结

本文详细介绍了 Sora 2 Character API 的两种角色创建方法：

1. 视频 URL 方法: 适合导入外部视频角色
2. 任务 ID 方法: 适合 Sora 内部工作流

核心要点：

• ✅ 掌握 timestamps 参数的正确设置
• ✅ 选择角色清晰、稳定的时间段
• ✅ 建立角色库进行统一管理
• ✅ 通过测试视频验证角色质量

下一步行动:

1. 尝试从你的视频中提取第一个角色
2. 使用该角色 ID 生成测试视频
3. 建立自己的角色库系统

推荐 APIYI: 稳定可靠的 AI大模型API中转站，价格便宜、免费试用。访问 APIYI官网 开始你的 Sora 2 之旅！

Sora 2 Character API: Dua Metode Pembuatan

Metode 1: Ekstraksi Karakter dari URL Video

Ini adalah cara paling langsung, cocok untuk skenario di mana Anda sudah memiliki materi video yang siap pakai.

Penjelasan Parameter Request:

Contoh Request Lengkap:

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

⚠️ Hal Penting yang Perlu Diperhatikan:

1. URL video harus dapat diakses publik: Server OpenAI perlu bisa membaca video tersebut
2. Atur CDN secara global: Jika menggunakan OSS/CDN, pastikan dikonfigurasi untuk akselerasi global, hindari server OpenAI (biasanya di luar negeri) tidak dapat mengakses
3. Rentang waktu timestamps:
   • Selisih minimum: 1 detik
   • Selisih maksimum: 3 detik
   • Contoh: "5,8" berarti dari detik ke-5 hingga detik ke-8 video

Metode 2: Menggunakan Ulang Karakter dengan Task ID

Jika sebelumnya Anda pernah menghasilkan video melalui Sora 2 API, Anda dapat langsung menggunakan task ID video tersebut untuk mengekstrak karakter, tanpa perlu upload video lagi.

Penjelasan Parameter Request:

Contoh Request Lengkap:

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

Keunggulan Metode Ini:

• ✅ Tidak perlu upload video tambahan, menghemat bandwidth
• ✅ Langsung menggunakan ulang aset video yang sudah dihasilkan
• ✅ Workflow lebih lancar, cocok untuk pemrosesan batch
• ✅ Menghindari masalah URL video yang kedaluwarsa atau akses terbatas

Rekomendasi: Gunakan Sora 2 Character API melalui APIYI apiyi.com, platform ini menyediakan layanan akses yang stabil dan kuota testing gratis.

Perbandingan Dua Metode Sora 2 Character API

Bagaimana Memilih?

Pilih Metode URL Video jika:

• Anda punya materi video siap pakai (seperti video syuting langsung, video download dari platform lain)
• Perlu mengekstrak karakter dari video yang bukan dihasilkan oleh Sora

Pilih Metode Task ID jika:

• Anda sedang menggunakan Sora 2 API untuk batch generate video
• Ingin mengekstrak karakter dari video yang sudah dihasilkan, untuk digunakan dalam video serial berikutnya
• Mengejar workflow otomatis yang lebih lancar

Penjelasan Detail Parameter timestamps pada Sora 2 Character API

timestamps adalah parameter paling krusial dalam Character API – parameter ini menentukan segmen waktu mana dari video yang akan digunakan untuk mengekstrak karakter.

Aturan Format timestamps

Tips Mengatur timestamps

1. Pilih segmen dengan karakter yang terlihat jelas: Karakter harus muncul secara utuh dalam frame, tidak terhalang
2. Hindari segmen dengan gerakan cepat: Pilih periode waktu di mana karakter relatif diam atau bergerak lambat
3. Pastikan pencahayaan yang baik: Segmen dengan pencahayaan yang bagus akan menghasilkan ekstraksi fitur karakter yang lebih akurat
4. Prioritaskan tampak depan karakter: Jika memungkinkan, pilih segmen di mana karakter menghadap ke kamera

Contoh skenario:

Misalkan kamu punya video berdurasi 10 detik, karakter tampak dari depan di detik 2-4, dan dari samping dengan gerakan di detik 6-9:

// Direkomendasikan: pilih segmen tampak depan yang jelas
{
  "timestamps": "2,4"
}

// Tidak direkomendasikan: karakter dari samping dengan gerakan
{
  "timestamps": "6,9"
}

Alur Kerja Lengkap Sora 2 Character API

Contoh Kode Python

import requests
import time

# Konfigurasi APIYI interface
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:
    """Metode 1: Membuat karakter dari URL video"""
    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:
    """Metode 2: Membuat karakter dari task ID"""
    response = requests.post(
        f"{API_BASE}/characters",
        headers=headers,
        json={
            "model": "sora-2-character",
            "from_task": task_id,
            "timestamps": timestamps
        }
    )
    return response.json()

# Contoh penggunaan
# Metode 1: Membuat dari URL video
result1 = create_character_from_url(
    video_url="https://your-cdn.com/video/hero.mp4",
    timestamps="5,8"
)
print(f"Task pembuatan karakter: {result1}")

# Metode 2: Membuat dari task ID
result2 = create_character_from_task(
    task_id="video_f751abfd-87a9-46e2-9236-1d94743c5e3e",
    timestamps="2,4"
)
print(f"Task pembuatan karakter: {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:
    """Membuat karakter dan mengembalikan character ID"""
    # 1. Mengirim request pembuatan karakter
    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. Polling menunggu task selesai
    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"Pembuatan karakter gagal: {status_data}")

        time.sleep(5)  # Cek setiap 5 detik

def generate_video_with_character(prompt: str, character_id: str) -> str:
    """Menghasilkan video menggunakan karakter"""
    # Referensi karakter dalam prompt menggunakan @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()

# Contoh alur lengkap
if __name__ == "__main__":
    # Langkah 1: Membuat karakter
    character_id = create_character(
        video_url="https://your-cdn.com/video/hero.mp4",
        timestamps="5,8"
    )
    print(f"Karakter berhasil dibuat, ID: {character_id}")

    # Langkah 2: Menggunakan karakter untuk menghasilkan seri video
    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"Task pembuatan video {i+1}: {result}")

Tips: Akses Sora 2 Character API melalui APIYI apiyi.com – platform ini menyediakan fitur manajemen karakter yang lengkap dan dukungan teknis.

Pertanyaan Umum

@char_abc123xyz berjalan di kota futuristik, lampu neon berkelap-kelip

Kesimpulan

Poin-poin inti Sora 2 Character API:

1. Dua cara pembuatan: Ekstraksi dari URL video dan reuse dari task ID, fleksibel untuk berbagai skenario
2. Parameter timestamps: Rentang waktu 1-3 detik, pilih segmen di mana karakter terlihat jelas
3. Reuse karakter: Buat sekali, gunakan berkali-kali di berbagai video, menjaga konsistensi karakter
4. Konfigurasi CDN: Saat menggunakan metode URL video, pastikan dapat diakses secara global

Setelah menguasai Character API, kamu bisa:

• Membuat karakter virtual yang dapat digunakan kembali untuk brand IP
• Memproduksi konten video seri dengan karakter yang konsisten
• Merealisasikan video naratif berkelanjutan tingkat profesional

Disarankan mengakses Sora 2 Character API melalui APIYI apiyi.com – platform ini menyediakan layanan stabil dan kuota uji coba gratis untuk membantu kamu cepat memahami fitur pembuatan karakter.

📚 Referensi

⚠️ Catatan Format Link: Semua link eksternal menggunakan format Nama Referensi: domain.com, mudah untuk disalin tapi tidak bisa diklik, untuk menghindari kehilangan bobot SEO.

1. Peluncuran Resmi OpenAI Sora 2: Pengenalan fitur dan karakteristik Sora 2

   • Link: openai.com/index/sora-2/
   • Keterangan: Informasi resmi dan fungsi karakter Sora 2

2. Pusat Bantuan OpenAI – Fitur Characters: Panduan pembuatan dan penggunaan karakter

   • Link: help.openai.com/en/articles/12435986-generating-content-with-characters
   • Keterangan: Panduan penggunaan fitur karakter dari pihak resmi

3. Dokumentasi API OpenAI – Video Generation: Dokumentasi teknis Sora API

   • Link: platform.openai.com/docs/guides/video-generation
   • Keterangan: Spesifikasi interface API dan penjelasan parameter

4. Halaman OpenAI Sora Characters: Pengenalan produk fitur karakter

   • Link: openai.com/sora/characters/
   • Keterangan: Positioning produk dan skenario penggunaan fitur karakter

Penulis: Tim Teknis
Diskusi Teknis: Silakan berdiskusi di kolom komentar, untuk lebih banyak referensi bisa kunjungi komunitas teknis APIYI apiyi.com