Sora 2 Character API Komplette Anleitung: 2 Methoden zur Erstellung wiederverwendbarer Charaktere und Umsetzung videoübergreifender Charakterkonsistenz

Methode 1: Charaktererstellung über Video-URL

Die erste Methode extrahiert einen Charakter direkt aus einem existierenden Video über dessen URL. Diese Methode eignet sich besonders, wenn Sie bereits ein fertiges Video haben und daraus einen Charakter erstellen möchten.

Grundlegende Anfrage-Struktur

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.example.com/your-video.mp4",
    "timestamps": "5,8"
}

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

Parameter-Erklärung

timestamps Parameter im Detail

Der timestamps Parameter ist entscheidend für die präzise Charakterextraktion:

Format: "start,end" (in Sekunden)

Beispiele:

• "0,3": Extrahiert Charakter aus den ersten 3 Sekunden
• "5,8": Extrahiert Charakter aus Sekunde 5-8
• "10,15": Extrahiert Charakter aus Sekunde 10-15

Wichtige Hinweise:

1. Wählen Sie einen Zeitbereich, in dem der Charakter gut sichtbar ist
2. Vermeiden Sie Zeitbereiche mit schnellen Bewegungen oder Überblendungen
3. Idealerweise sollte der Charakter frontal oder aus einer klaren Perspektive zu sehen sein
4. Das Zeitfenster sollte mindestens 2-3 Sekunden betragen für optimale Ergebnisse

Vollständiges Beispiel mit Fehlerbehandlung

import requests
import json

def create_character_from_url(video_url, start_time, end_time, api_key):
    """
    Erstellt einen Charakter aus einem Video über dessen URL
    
    Args:
        video_url: Öffentlich zugängliche Video-URL
        start_time: Startzeit in Sekunden
        end_time: Endzeit in Sekunden
        api_key: Ihr OpenAI API-Schlüssel
    
    Returns:
        character_id: Die ID des erstellten Charakters
    """
    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"{start_time},{end_time}"
    }
    
    try:
        response = requests.post(url, headers=headers, json=data)
        response.raise_for_status()
        
        result = response.json()
        character_id = result.get('id')
        
        print(f"✓ Charakter erfolgreich erstellt: {character_id}")
        print(f"  Verwendung in Prompts: @{character_id}")
        
        return character_id
        
    except requests.exceptions.RequestException as e:
        print(f"✗ Fehler bei der Charaktererstellung: {e}")
        if hasattr(e.response, 'text'):
            print(f"  Details: {e.response.text}")
        return None

# Verwendungsbeispiel
api_key = "sk-proj-..."
video_url = "https://cdn.example.com/sample-video.mp4"

character_id = create_character_from_url(
    video_url=video_url,
    start_time=5,
    end_time=8,
    api_key=api_key
)

Typische Antwort

{
  "id": "char_abc123xyz",
  "object": "character",
  "created": 1704067200,
  "model": "sora-2-character",
  "status": "completed",
  "source": {
    "type": "url",
    "url": "https://cdn.example.com/your-video.mp4",
    "timestamps": "5,8"
  }
}

Methode 2: Charaktererstellung über Task-ID

Die zweite Methode nutzt ein bereits über die Sora API generiertes Video. Anstatt die Video-URL anzugeben, verwenden Sie einfach die Task-ID des ursprünglichen Videogenerierungs-Jobs.

Grundlegende Anfrage-Struktur

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_f751ab9c2d3e4f5a6b7c8d9e0f1a2b3c",
    "timestamps": "5,8"
}

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

Parameter-Erklärung

Workflow: Von der Videogenerierung zur Charaktererstellung

import requests
import time

class SoraCharacterWorkflow:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://api.openai.com/v1"
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }
    
    def generate_video(self, prompt):
        """Schritt 1: Video generieren"""
        url = f"{self.base_url}/sora/generations"
        
        data = {
            "model": "sora-2-1080p",
            "prompt": prompt
        }
        
        response = requests.post(url, headers=self.headers, json=data)
        response.raise_for_status()
        
        task_id = response.json()['id']
        print(f"✓ Videogenerierung gestartet: {task_id}")
        
        return task_id
    
    def wait_for_completion(self, task_id, max_wait=300):
        """Schritt 2: Auf Fertigstellung warten"""
        url = f"{self.base_url}/sora/generations/{task_id}"
        
        start_time = time.time()
        while time.time() - start_time < max_wait:
            response = requests.get(url, headers=self.headers)
            status = response.json()['status']
            
            if status == 'completed':
                print(f"✓ Video fertig generiert")
                return True
            elif status == 'failed':
                print(f"✗ Videogenerierung fehlgeschlagen")
                return False
            
            print(f"  Status: {status}... warte 5 Sekunden")
            time.sleep(5)
        
        print(f"✗ Timeout nach {max_wait} Sekunden")
        return False
    
    def create_character(self, task_id, start_time, end_time):
        """Schritt 3: Charakter aus generiertem Video erstellen"""
        url = f"{self.base_url}/sora/characters"
        
        data = {
            "model": "sora-2-character",
            "from_task": task_id,
            "timestamps": f"{start_time},{end_time}"
        }
        
        response = requests.post(url, headers=self.headers, json=data)
        response.raise_for_status()
        
        character_id = response.json()['id']
        print(f"✓ Charakter erstellt: {character_id}")
        
        return character_id
    
    def run_full_workflow(self, prompt, start_time, end_time):
        """Vollständiger Workflow"""
        print("\n=== Sora Charakter-Workflow ===\n")
        
        # Schritt 1: Video generieren
        task_id = self.generate_video(prompt)
        
        # Schritt 2: Warten
        if not self.wait_for_completion(task_id):
            return None
        
        # Schritt 3: Charakter erstellen
        character_id = self.create_character(task_id, start_time, end_time)
        
        print(f"\n✓ Workflow abgeschlossen!")
        print(f"  Task ID: {task_id}")
        print(f"  Charakter ID: {character_id}")
        print(f"  Verwendung: @{character_id}")
        
        return character_id

# Verwendungsbeispiel
api_key = "sk-proj-..."
workflow = SoraCharacterWorkflow(api_key)

character_id = workflow.run_full_workflow(
    prompt="Ein junger Mann mit blonden Haaren in einem blauen Anzug, der selbstbewusst durch eine moderne Stadt geht",
    start_time=2,
    end_time=5
)

Vorteile der Task-ID Methode

Praxisbeispiel: Charakterkonsistenz in Videoserie

Hier ein vollständiges Beispiel, wie Sie einen Charakter über mehrere Videos hinweg konsistent halten:

import requests
import time

class SeriesVideoGenerator:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://api.openai.com/v1"
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }
    
    def create_character_from_first_video(self, initial_prompt, timestamps="2,5"):
        """Episode 1: Charakter erstellen"""
        print("\n=== Episode 1: Hauptcharakter einführen ===")
        
        # Video generieren
        data = {
            "model": "sora-2-1080p",
            "prompt": initial_prompt
        }
        
        response = requests.post(
            f"{self.base_url}/sora/generations",
            headers=self.headers,
            json=data
        )
        task_id = response.json()['id']
        print(f"Video-Generierung gestartet: {task_id}")
        
        # Auf Fertigstellung warten
        self._wait_for_completion(task_id)
        
        # Charakter erstellen
        char_data = {
            "model": "sora-2-character",
            "from_task": task_id,
            "timestamps": timestamps
        }
        
        response = requests.post(
            f"{self.base_url}/sora/characters",
            headers=self.headers,
            json=char_data
        )
        
        character_id = response.json()['id']
        print(f"✓ Charakter erstellt: {character_id}")
        
        return character_id, task_id
    
    def generate_series_video(self, character_id, episode_prompt, episode_num):
        """Weitere Episoden mit demselben Charakter"""
        print(f"\n=== Episode {episode_num}: Charakter wiederverwenden ===")
        
        # Charakter im Prompt referenzieren
        full_prompt = f"@{character_id} {episode_prompt}"
        
        data = {
            "model": "sora-2-1080p",
            "prompt": full_prompt
        }
        
        response = requests.post(
            f"{self.base_url}/sora/generations",
            headers=self.headers,
            json=data
        )
        
        task_id = response.json()['id']
        print(f"Video-Generierung gestartet: {task_id}")
        
        self._wait_for_completion(task_id)
        print(f"✓ Episode {episode_num} abgeschlossen")
        
        return task_id
    
    def _wait_for_completion(self, task_id, max_wait=300):
        """Hilfsfunktion: Auf Fertigstellung warten"""
        start_time = time.time()
        while time.time() - start_time < max_wait:
            response = requests.get(
                f"{self.base_url}/sora/generations/{task_id}",
                headers=self.headers
            )
            status = response.json()['status']
            
            if status == 'completed':
                return True
            elif status == 'failed':
                raise Exception("Videogenerierung fehlgeschlagen")
            
            print(f"  Status: {status}...")
            time.sleep(5)
        
        raise Exception("Timeout")
    
    def create_video_series(self, series_config):
        """Vollständige Videoserie erstellen"""
        print("\n" + "="*50)
        print("VIDEOSERIE STARTEN")
        print("="*50)
        
        # Episode 1: Charakter einführen
        character_id, ep1_task = self.create_character_from_first_video(
            initial_prompt=series_config['episode_1']['prompt'],
            timestamps=series_config['episode_1'].get('timestamps', "2,5")
        )
        
        episodes = [ep1_task]
        
        # Weitere Episoden
        for i, episode in enumerate(series_config['additional_episodes'], start=2):
            task_id = self.generate_series_video(
                character_id=character_id,
                episode_prompt=episode['prompt'],
                episode_num=i
            )
            episodes.append(task_id)
        
        print("\n" + "="*50)
        print("SERIE ABGESCHLOSSEN")
        print("="*50)
        print(f"Charakter ID: {character_id}")
        print(f"Episoden: {len(episodes)}")
        for i, task_id in enumerate(episodes, start=1):
            print(f"  Episode {i}: {task_id}")
        
        return character_id, episodes

# Verwendungsbeispiel
api_key = "sk-proj-..."
generator = SeriesVideoGenerator(api_key)

# Videoserie-Konfiguration
series_config = {
    'episode_1': {
        'prompt': 'Eine junge Frau mit langen braunen Haaren und grünen Augen, trägt einen roten Mantel, geht durch einen herbstlichen Park',
        'timestamps': '3,6'
    },
    'additional_episodes': [
        {
            'prompt': 'sitzt in einem gemütlichen Café und schreibt in ihr Tagebuch, warmes Licht durch große Fenster'
        },
        {
            'prompt': 'steht auf einer Brücke bei Sonnenuntergang und blickt nachdenklich auf den Fluss'
        },
        {
            'prompt': 'läuft fröhlich durch eine verschneite Winterlandschaft, Schneeflocken tanzen um sie herum'
        }
    ]
}

# Serie generieren
character_id, episodes = generator.create_video_series(series_config)

print(f"\n✓ Alle Videos verwenden dieselbe Hauptfigur: @{character_id}")

Ausgabe-Beispiel

==================================================
VIDEOSERIE STARTEN
==================================================

=== Episode 1: Hauptcharakter einführen ===
Video-Generierung gestartet: video_a1b2c3d4...
  Status: processing...
  Status: processing...
✓ Charakter erstellt: char_x9y8z7

=== Episode 2: Charakter wiederverwenden ===
Video-Generierung gestartet: video_e5f6g7h8...
  Status: processing...
✓ Episode 2 abgeschlossen

=== Episode 3: Charakter wiederverwenden ===
Video-Generierung gestartet: video_i9j0k1l2...
  Status: processing...
✓ Episode 3 abgeschlossen

=== Episode 4: Charakter wiederverwenden ===
Video-Generierung gestartet: video_m3n4o5p6...

## Sora 2 Character API – zwei Erstellungsmethoden

### Methode 1: Charakterextraktion aus Video-URL

Dies ist der direkteste Ansatz, wenn Sie bereits vorhandenes Videomaterial haben.

**Anfrageparameter:**

| Parameter | Typ | Erforderlich | Beschreibung |
|------|------|------|------|
| `model` | string | ✅ | Fester Wert `sora-2-character` |
| `url` | string | ✅ | Öffentlich zugängliche Video-URL |
| `timestamps` | string | ✅ | Zeitbereich des Charakterauftritts, Format `"Startsekunde,Endsekunde"` |

<br>

**Vollständiges Anfragebeispiel:**

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

⚠️ Wichtige Hinweise:

1. Video-URL muss öffentlich erreichbar sein: Die OpenAI-Server müssen das Video abrufen können
2. CDN global konfigurieren: Wenn Sie OSS/CDN verwenden, stellen Sie sicher, dass es für globalen Zugriff konfiguriert ist, damit OpenAI-Server (normalerweise im Ausland) darauf zugreifen können
3. Zeitbereich bei timestamps:
   • Minimale Differenz: 1 Sekunde
   • Maximale Differenz: 3 Sekunden
   • Beispiel: "5,8" bedeutet von Sekunde 5 bis Sekunde 8 des Videos

Methode 2: Charakterwiederverwendung über Task-ID

Wenn Sie zuvor über die Sora 2 API ein Video generiert haben, können Sie die Task-ID dieses Videos direkt zur Charakterextraktion nutzen, ohne das Video erneut hochladen zu müssen.

Anfrageparameter:

Vollständiges Anfragebeispiel:

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

Vorteile dieser Methode:

• ✅ Kein zusätzlicher Video-Upload nötig, spart Bandbreite
• ✅ Direkte Wiederverwendung bereits generierter Video-Assets
• ✅ Flüssigerer Workflow, ideal für Batch-Verarbeitung
• ✅ Vermeidung von Problemen durch abgelaufene oder nicht erreichbare Video-URLs

Tipp: Nutzen Sie die Sora 2 Character API über APIYI apiyi.com – die Plattform bietet stabile Anbindung und kostenloses Testguthaben.

Vergleich der beiden Sora 2 Character API-Methoden

Video-URL vs. Task-ID: Vergleich der beiden Methoden

Vergleichskriterium

Methode 1: Video-URL

Methode 2: Task-ID

Kernparameter

„url“

„from_task“

Anwendungsfall

Vorhandenes Videomaterial

Sora-generierte Videos

Upload erforderlich

Öffentliche URL nötig

✓ Kein Upload nötig

Netzwerkanforderung

CDN global erreichbar

✓ Keine Extra-Anforderung

Empfohlener Einsatz

Import externer Charaktere

Batch-Videoserien

Gemeinsamer Parameter: timestamps (Zeitbereich 1-3 Sek.)

Welche Methode sollten Sie wählen?

Wählen Sie die Video-URL-Methode:

• Sie haben vorhandenes Videomaterial (z.B. aufgenommene Realvideos, von anderen Plattformen heruntergeladene Videos)
• Sie müssen Charaktere aus nicht von Sora generierten Videos extrahieren

Wählen Sie die Task-ID-Methode:

• Sie nutzen die Sora 2 API für Batch-Videogenerierung
• Sie möchten aus bereits generierten Videos Charaktere für Folgevideos extrahieren
• Sie streben einen flüssigeren automatisierten Workflow an

Detaillierte Erklärung des timestamps-Parameters in der Sora 2 Character API

Der timestamps-Parameter ist der wichtigste Parameter in der Character API – er bestimmt, aus welchem Zeitabschnitt des Videos der Charakter extrahiert wird.

Formatregeln für timestamps

Tipps zur Einstellung von timestamps

1. Wähle Abschnitte mit klarer Sichtbarkeit des Charakters: Der Charakter sollte vollständig im Bild sein und nicht verdeckt werden
2. Vermeide schnelle Bewegungen: Wähle Zeitabschnitte, in denen der Charakter relativ still ist oder sich langsam bewegt
3. Achte auf gute Beleuchtung: Gut beleuchtete Abschnitte ermöglichen eine genauere Extraktion der Charaktermerkmale
4. Frontale Ansichten bevorzugen: Wenn möglich, wähle Abschnitte, in denen der Charakter zur Kamera schaut

Beispielszenario:

Angenommen, du hast ein 10-Sekunden-Video, in dem der Charakter von Sekunde 2-4 frontal erscheint und von Sekunde 6-9 seitlich in Bewegung ist:

// Empfohlen: Wähle den klaren frontalen Abschnitt
{
  "timestamps": "2,4"
}

// Nicht empfohlen: Charakter in seitlicher Bewegung
{
  "timestamps": "6,9"
}

Vollständiger Workflow der Sora 2 Character API

Python-Codebeispiel

import requests
import time

# APIYI Schnittstellenkonfiguration
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:
    """Methode 1: Charakter aus Video-URL erstellen"""
    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:
    """Methode 2: Charakter aus Task-ID erstellen"""
    response = requests.post(
        f"{API_BASE}/characters",
        headers=headers,
        json={
            "model": "sora-2-character",
            "from_task": task_id,
            "timestamps": timestamps
        }
    )
    return response.json()

# Verwendungsbeispiel
# Methode 1: Charakter aus Video-URL erstellen
result1 = create_character_from_url(
    video_url="https://your-cdn.com/video/hero.mp4",
    timestamps="5,8"
)
print(f"Charakter-Erstellungsaufgabe: {result1}")

# Methode 2: Charakter aus Task-ID erstellen
result2 = create_character_from_task(
    task_id="video_f751abfd-87a9-46e2-9236-1d94743c5e3e",
    timestamps="2,4"
)
print(f"Charakter-Erstellungsaufgabe: {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:
    """Charakter erstellen und Charakter-ID zurückgeben"""
    # 1. Anfrage zur Charakter-Erstellung senden
    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 bis Aufgabe abgeschlossen ist
    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"Charakter-Erstellung fehlgeschlagen: {status_data}")

        time.sleep(5)  # Alle 5 Sekunden prüfen

def generate_video_with_character(prompt: str, character_id: str) -> str:
    """Video mit Charakter generieren"""
    # Charakter im Prompt über @character_id referenzieren
    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()

# Vollständiges Workflow-Beispiel
if __name__ == "__main__":
    # Schritt 1: Charakter erstellen
    character_id = create_character(
        video_url="https://your-cdn.com/video/hero.mp4",
        timestamps="5,8"
    )
    print(f"Charakter erfolgreich erstellt, ID: {character_id}")

    # Schritt 2: Mit Charakter eine Serie von Videos generieren
    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"Video {i+1} Generierungsaufgabe: {result}")

Hinweis: Über APIYI apiyi.com kannst du die Sora 2 Character API nutzen – die Plattform bietet vollständige Charakter-Management-Funktionen und technischen Support.

Häufig gestellte Fragen

@char_abc123xyz läuft durch eine futuristische Stadt mit blinkenden Neonlichtern

Zusammenfassung

Die wichtigsten Punkte zur Sora 2 Character API:

1. Zwei Erstellungsmethoden: Video-URL-Extraktion und Task-ID-Wiederverwendung – flexibel für verschiedene Szenarien
2. timestamps-Parameter: Zeitbereich 1-3 Sekunden, wählen Sie Abschnitte, in denen der Charakter klar sichtbar ist
3. Charakter-Wiederverwendung: Einmal erstellen, mehrfach über verschiedene Videos hinweg nutzen für konsistente Charakterdarstellung
4. CDN-Konfiguration: Bei Verwendung der Video-URL-Methode muss globale Erreichbarkeit sichergestellt sein

Nach der Beherrschung der Character API können Sie:

• Wiederverwendbare virtuelle Charaktere für Marken-IPs erstellen
• Videoinhalte mit konsistenten Charakteren als Serie produzieren
• Professionelle narrative Videosequenzen umsetzen

Wir empfehlen den Zugang zur Sora 2 Character API über APIYI apiyi.com. Die Plattform bietet stabile Services und kostenlose Test-Credits, damit Sie schnell mit der Charaktererstellung starten können.

📚 Referenzen

⚠️ Hinweis zum Linkformat: Alle externen Links verwenden das Format Ressourcenname: domain.com – zum einfachen Kopieren, aber nicht klickbar, um SEO-Gewichtsverluste zu vermeiden.

1. OpenAI Sora 2 offizielle Veröffentlichung: Vorstellung der Funktionen und Features von Sora 2

   • Link: openai.com/index/sora-2/
   • Beschreibung: Offizielle Informationen zu Sora 2 und der Characters-Funktion

2. OpenAI Help Center – Characters-Funktion: Leitfaden zur Erstellung und Verwendung von Characters

   • Link: help.openai.com/en/articles/12435986-generating-content-with-characters
   • Beschreibung: Offizielle Anleitung zur Nutzung der Characters-Funktion

3. OpenAI API-Dokumentation – Video Generation: Technische Dokumentation der Sora API

   • Link: platform.openai.com/docs/guides/video-generation
   • Beschreibung: API-Schnittstellenspezifikationen und Parameterbeschreibungen

4. OpenAI Sora Characters Seite: Produktvorstellung der Characters-Funktion

   • Link: openai.com/sora/characters/
   • Beschreibung: Produktpositionierung und Anwendungsszenarien der Characters-Funktion

Autor: Tech-Team
Technischer Austausch: Diskussionen sind in den Kommentaren willkommen. Weitere Ressourcen finden Sie in der APIYI apiyi.com Tech-Community