Lip-Sync-API für synchronisierte Videos

Passen Sie Mundbewegungen in über 135 Sprachen und Regionen an die synchronisierte Sprache an. Synchronisieren Sie Ihr Video über die API, wenden Sie die Lippensynchronisation auf das Ergebnis an und laden Sie ein Video herunter, in dem die sprechende Person auf dem Bildschirm die neuen Wörter ausspricht. Zuvor wird eine Gesichtserkennung durchgeführt. Die Lippensynchronisation wird für jede vollständige Videogenerierung separat von der Synchronisation abgerechnet, einschließlich der erneuten Generierung nach Bearbeitungen.
Kostenlose Vorschau-Minute
Mehrere Gesichter auf dem Bildschirm
REST + Python-SDK
check, preview, sync
OAuth 2.0
# 1. on a dubbed project: confirm the video has a face (runs once, usually automatically)
curl https://api.rask.ai/v2/projects/$ID/lipsync \
  -H "Authorization: Bearer $TOKEN"
#  "check_face_task_status": "done", "video_has_face": true

# 2. preview one free minute of lip-sync
curl -X PUT https://api.rask.ai/v2/projects/$ID/lipsync \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"is_multiple_speakers": true, "is_free_lipsync": true}'

# 3. lip-sync the full video - billed separately from dubbing
curl -X PUT https://api.rask.ai/v2/projects/$ID/lipsync \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"is_multiple_speakers": true, "is_free_lipsync": false}'
GET /v2/projects/{project_id}/lipsync
polling, 15s
# Poll until lipsync_task_status is done, then download lipsync_result_path
while :; do
  curl -s https://api.rask.ai/v2/projects/$ID/lipsync -H "Authorization: Bearer $TOKEN" \
    | jq '{lipsync_task_status, lipsync_task_progress, tasks_in_lipsync_queue}'
  sleep 15
done
Von globalen Teams genutzt
Funktionen

Alle Funktionen der Lip-Sync-API

Fügen Sie Ihren synchronisierten Videos eine Lippensynchronisation hinzu. Prüfen Sie, ob ein Gesicht zu sehen ist, nutzen Sie die kostenlose Vorschau-Minute Ihres Kontos (falls verfügbar) und verfolgen Sie den Fortgang über die API. Die vollständige Lippensynchronisation des Videos wird bei jeder Generierung separat von der Synchronisation abgerechnet.

Lippensynchronisation für übersetzte Videos

Passen Sie die Mundbewegungen an die synchronisierte Sprache in einem von Ihrem Projekt übersetzten Video an – aus dem unterstützten Katalog mit über 135 Sprachen und Regionen.

Automatische Gesichtserkennung

Vor der Lippensynchronisation prüft ein Gesichtserkennungsschritt, ob das Video mindestens ein Gesicht enthält. Dies wird einmal pro Projekt durchgeführt (meist separat), damit Sie das Ergebnis kennen, bevor Sie Minuten verbrauchen.

Mehrere Gesichter auf dem Bildschirm

Setzen Sie is_multiple_speakers für Interviews, Podiumsdiskussionen und Dialoge mit mehreren Sprechern auf true. Wenn immer nur ein Gesicht im Bild ist, setzen Sie es auf false, um die Verarbeitung zu beschleunigen.

Eine kostenlose Vorschau-Minute

Jedes Konto erhält eine kostenlose Minute für die Lippensynchronisation. Testen Sie diese mit is_free_lipsync an Ihrem eigenen Material und prüfen Sie das Ergebnis, bevor Sie das gesamte Video synchronisieren.

Separate Abrechnung für jede Generierung

Jede vollständige Video-Lippensynchronisation wird separat von der Synchronisation berechnet. Nach Text- oder Sprachänderungen synchronisieren Sie das Projekt einfach erneut und generieren eine neue lippensynchronisierte Version, die separat berechnet wird.

Warteschlangenposition und Fortschritt

Der Endpunkt für die Lip-Sync-Informationen gibt die Anzahl der vor Ihnen liegenden Aufgaben sowie den Fortschritt von 0 bis 100 an, sodass Ihre Nutzer den aktuellen Stand sehen.

Stimmen, die zum Gesicht passen

Die Lippensynchronisation funktioniert mit jeder Stimme, die das Projekt für einen Sprecher verwendet: entweder der geklonten Stimme oder einer voreingestellten KI-Stimme.

Bearbeiten, neu synchronisieren, anpassen

Ändern Sie Text, Timing oder Stimmen, synchronisieren Sie das Projekt neu und starten Sie die Lippensynchronisation für die neue Version. Die Gesichtserkennung muss dabei nicht erneut ausgeführt werden.

Skalieren Sie ohne Grenzen

Keine Ratenbegrenzung, kein gleichzeitiges Kontingent, keine Drosselung pro Schlüssel. Senden Sie Lippensynchronisationsaufgaben für Ihren gesamten Katalog, und die Position in der Warteschlange zeigt Ihnen genau, wo sich die jeweilige Aufgabe befindet.
In Aktion erleben

Von der Synchronisation bis zur passenden Lippenbewegung

Dasselbe Video wurde auf Französisch, Deutsch, Portugiesisch und Spanisch synchronisiert. Bei einem solchen Projekt passt die Lippensynchronisation die Lippenbewegungen an die neue Sprache an.
EN flag
En
FR flag
Fr
DE flag
De
PT flag
Pt
ES flag
Es
Workflow

In drei Schritten vom synchronisierten Video zum lippensynchronen Video

Die Lippensynchronisation wird bei einem bereits synchronisierten Projekt angewendet. Nutzen Sie den Endpunkt /generate, um nach Änderungen erneut zu synchronisieren.
1

Video synchronisieren

Laden Sie das Video hoch oder senden Sie eine öffentliche URL, erstellen Sie ein Projekt mit einer Zielsprache und warten Sie auf den Abschluss. Die Lippensynchronisation benötigt das übersetzte Video dieses Projekts.

POST /v2/projects
2

Gesicht überprüfen

Dieser Schritt bestätigt, dass mindestens ein Gesicht im Video zu sehen ist. Er startet normalerweise automatisch. Falls nicht, starten Sie ihn einfach manuell für das Projekt.

PUT /v2/projects/{id}/check_face
3

Lippensynchronisation starten und herunterladen

Starten Sie den Prozess, verfolgen Sie den Fortschritt von 0 bis 100 und laden Sie anschließend das Video herunter.

PUT /v2/projects/{id}/lipsync
Die Bearbeitungszeit hängt von der Videolänge und der Warteschlange ab. Der entsprechende Info-Endpunkt zeigt an, wie viele Aufgaben sich noch vor Ihrer befinden.
Auf Ihre Bedürfnisse zugeschnitten

Benötigen Sie eine Synchronisation für einen speziellen Fall? Sprechen Sie mit unserem Team

Höherer Durchsatz, Priorität bei der Verarbeitung oder individuelle Bereitstellung: Wenn Sie spezielle Anforderungen haben, prüft unser Team gerne die Möglichkeiten für Sie.

Sprachen und Stimmen

Benötigen Sie eine Sprache oder Stimme außerhalb des öffentlichen Katalogs? Sprechen Sie mit unserem Team über Ihre Anforderungen und die verfügbaren Optionen.

Bereitstellung und Integration

Webhooks, Einspeisung in Ihre eigene Warteschlange, direkte Bereitstellung auf Ihrem S3 oder benutzerdefinierte Endpunkte. Sagen Sie uns einfach, wie Ihre Pipeline Daten benötigt.

Volumen und Durchsatz

Batch-Größen, Zielsprachen pro Aktion und Verarbeitungspriorität sind Teil Ihrer vertraglichen Vereinbarung und unterliegen keinen starren Produktlimits.

Sicherheit und Hosting

Datenspeicherung, SSO und SAML, Aufbewahrungsregeln und Support bei Sicherheitsprüfungen werden im Rahmen des Enterprise-Onboardings geregelt.
Anwendungsfälle

Wer nutzt eine Lippensynchronisations-API?

Plattformen mit integrierten Videos

LMS- und Bildungsplattformen, Video-Plattformen, Webinar-Tools, Videohosting-SaaS und Live-Shopping. Fügen Sie Ihren Videos eine natürliche Lippensynchronisation hinzu, damit übersetzte Präsentationen auf dem Bildschirm absolut authentisch wirken.

Lokalisierungs- und Produktionsagenturen

Bieten Sie Lippensynchronisation als zusätzliche Option an. Nutzen Sie die kostenlosen Vorschminuten Ihres Kontos, um das Ergebnis zu testen.

Interne, kontinuierliche Videoproduktion

Internationaler Handel, globale Franchises, Medienverlage und Unternehmen. Bei Marketing- und Schulungsvideos sorgt die Lippensynchronisation dafür, dass die übersetzte Sprache perfekt zum Sprecher passt.
Kundenreferenzen

Echte Teams, messbare Ergebnisse

Wie Unternehmen mit Rask Videos lokalisieren – in konkreten Zahlen.
Pfeil
Pfeil
Code

Code-Beispiele für die Lippensynchronisations-API

Ein vollständiges Beispiel für ein bereits synchronisiertes Projekt: Gesicht prüfen, Lippensynchronisation starten, Fortschritt verfolgen und Ergebnis herunterladen.
# pip install git+ssh://[email protected]/braskai/rask-sdk.git@main
import asyncio
from rask_sdk import clients, enums, schemas

PROJECT_ID = "..."   # a project with status merging_done

async def main():
    client = clients.RaskSDKClient(client_id=CLIENT_ID, client_secret=CLIENT_SECRET)

    info = await client.get_lipsync_info(project_id=PROJECT_ID)
    if info.check_face_task_status is not enums.LipsyncStatus.DONE:
        await client.run_check_face_task(project_id=PROJECT_ID)
        while (info := await client.get_lipsync_info(project_id=PROJECT_ID)).check_face_task_status is not enums.LipsyncStatus.DONE:
            await asyncio.sleep(10)
    if not info.video_has_face:
        raise SystemExit("No face found - lip-sync is not available for this video")

    await client.run_lipsync_task(project_id=PROJECT_ID,
        data=schemas.LipsyncTaskData(is_multiple_speakers=True, is_free_lipsync=False))

    while (info := await client.get_lipsync_info(project_id=PROJECT_ID)).lipsync_task_status is not enums.LipsyncStatus.DONE:
        print(info.lipsync_task_progress, info.tasks_in_lipsync_queue)
        await asyncio.sleep(15)

    print(info.lipsync_result_path)

asyncio.run(main())
github.com/braskai/rask-sdk
async, typed models
import time, requests

AUTH = "https://rask-prod.auth.us-east-2.amazoncognito.com/oauth2/token"
URL  = f"https://api.rask.ai/v2/projects/{PROJECT_ID}"   # a dubbed project

token = requests.post(AUTH, auth=(CLIENT_ID, CLIENT_SECRET),
                      data={"grant_type": "client_credentials"}).json()["access_token"]
h = {"Authorization": f"Bearer {token}"}

info = requests.get(f"{URL}/lipsync", headers=h).json()
if info["check_face_task_status"] != "done":
    requests.put(f"{URL}/check_face", headers=h)
    while (info := requests.get(f"{URL}/lipsync", headers=h).json())["check_face_task_status"] != "done":
        time.sleep(10)
assert info["video_has_face"], "No face found"

requests.put(f"{URL}/lipsync", headers=h,
             json={"is_multiple_speakers": True, "is_free_lipsync": False})

while (info := requests.get(f"{URL}/lipsync", headers=h).json())["lipsync_task_status"] not in ("done", "failed"):
    time.sleep(15)

print(info["lipsync_task_status"], info["lipsync_result_path"])
requests + polling
no SDK required
// no dependencies, Node 18+ global fetch - PROJECT_ID is a dubbed project
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
const auth = await fetch('https://rask-prod.auth.us-east-2.amazoncognito.com/oauth2/token', {
  method: 'POST',
  headers: { Authorization: 'Basic ' + btoa(`${CLIENT_ID}:${CLIENT_SECRET}`) },
  body: new URLSearchParams({ grant_type: 'client_credentials' }),
}).then((r) => r.json());
const h = { Authorization: `Bearer ${auth.access_token}`, 'Content-Type': 'application/json' };
const url = `https://api.rask.ai/v2/projects/${PROJECT_ID}`;
const info = () => fetch(`${url}/lipsync`, { headers: h }).then((r) => r.json());

let i = await info();
if (i.check_face_task_status !== 'done') {
  await fetch(`${url}/check_face`, { method: 'PUT', headers: h });
  while ((i = await info()).check_face_task_status !== 'done') await sleep(10000);
}
if (!i.video_has_face) throw new Error('No face found');

await fetch(`${url}/lipsync`, {
  method: 'PUT', headers: h,
  body: JSON.stringify({ is_multiple_speakers: true, is_free_lipsync: false }),
});

while (!['done', 'failed'].includes((i = await info()).lipsync_task_status)) {
  console.log(i.lipsync_task_progress, i.tasks_in_lipsync_queue);
  await sleep(15000);
}
console.log(i.lipsync_result_path);
fetch, Node 18+
plain HTTP
# 1. token (valid 1 hour - cache and reuse it)
TOKEN=$(curl -s -X POST https://rask-prod.auth.us-east-2.amazoncognito.com/oauth2/token \
  -u "$CLIENT_ID:$CLIENT_SECRET" -d "grant_type=client_credentials" | jq -r .access_token)

# 2. face check on the dubbed project - start it only if it has not run yet
curl -s https://api.rask.ai/v2/projects/$ID/lipsync -H "Authorization: Bearer $TOKEN" \
  | jq '{check_face_task_status, video_has_face}'
curl -s -X PUT https://api.rask.ai/v2/projects/$ID/check_face -H "Authorization: Bearer $TOKEN"

# 3. run lip-sync (set is_free_lipsync to true for the free preview minute)
curl -s -X PUT https://api.rask.ai/v2/projects/$ID/lipsync \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"is_multiple_speakers": true, "is_free_lipsync": false}'

# 4. follow progress, then download the result
curl -s https://api.rask.ai/v2/projects/$ID/lipsync -H "Authorization: Bearer $TOKEN" \
  | jq '{lipsync_task_status, lipsync_task_progress, lipsync_result_path}'
PUT /v2/projects/{id}/lipsync
OAuth 2.0 client credentials
<?php
use GuzzleHttp\Client;

$http = new Client(['base_uri' => 'https://api.rask.ai']);
$json = fn($r) => json_decode($r->getBody(), true);
$auth = $json((new Client)->post('https://rask-prod.auth.us-east-2.amazoncognito.com/oauth2/token',
    ['auth' => [$clientId, $clientSecret], 'form_params' => ['grant_type' => 'client_credentials']]));
$h = ['Authorization' => 'Bearer ' . $auth['access_token']];
$info = fn() => $json($http->get("/v2/projects/$projectId/lipsync", ['headers' => $h]));

$i = $info();
if ($i['check_face_task_status'] !== 'done') {
    $http->put("/v2/projects/$projectId/check_face", ['headers' => $h]);
    while (($i = $info())['check_face_task_status'] !== 'done') sleep(10);
}
if (!$i['video_has_face']) exit('No face found');

$http->put("/v2/projects/$projectId/lipsync", ['headers' => $h,
    'json' => ['is_multiple_speakers' => true, 'is_free_lipsync' => false]]);

while (!in_array(($i = $info())['lipsync_task_status'], ['done', 'failed'])) sleep(15);
echo $i['lipsync_result_path'];
Guzzle 7
plain HTTP
Python ist das offizielle SDK. Die Registerkarten für Node, PHP und cURL zeigen einfache HTTP-Beispiele für dieselben Endpunkte.
Fortschritt

Wie der Fortschritt einer Aufgabe gemeldet wird

Der Info-Endpunkt informiert über den Gesichts-Check, den Status, die Position in der Warteschlange und den Fortschritt von 0 bis 100.

Erfolgreich, hier stoppen

lipsync_task_status: done
lipsync_task_progress: 100
Die Lippensynchronisation ist abgeschlossen. Der Download-Link ist verfügbar.

Wird ausgeführt, Status weiter abfragen

check_face_task_status: started
lipsync_task_status: started
lipsync_task_progress: 0-99
tasks_in_lipsync_queue
Solange der Fortschritt nicht verfügbar ist, befindet sich die Aufgabe in der Warteschlange: tasks_in_lipsync_queue zeigt an, wie viele Aufgaben noch ausstehen.

Fehler, Stopp und Meldung

lipsync_task_status: failed
check_face_task_status: failed
video_has_face: false
Ein Video ohne sichtbares Gesicht kann nicht lippensynchronisiert werden. Bei fehlgeschlagenen Aufgaben wenden Sie sich bitte an den Support. project_id.
Lip-sync task, as GET /lipsync reports it
GET /v2/projects/{project_id}/lipsync
check face     check_face_task_status  done     video_has_face  true
queued         lipsync_task_status     started  tasks_in_lipsync_queue  2
processing     lipsync_task_progress   0 → 50 → 100
complete       lipsync_task_status     done
               lipsync_result_path     https://...

Oder das Abfragen ganz überspringen

Verweisen Sie auf einen Webhook-Endpunkt, und jeder Statusübergang kommt als POST an, sodass Ihre Warteschlange im Moment des Geschehens auf jede Änderung reagiert. Die Webhook-Bereitstellung ist Teil des Enterprise-Onboardings.
Dokumentation lesen
preserveAspectRatio="xMidYMid meet" aria-hidden="true" role="img">
Ausgabe

Videobearbeitung mit Lippensynchronisation, Synchronisation und Untertiteln

Laden Sie das generierte Video von lipsync_result_path herunter. Das Projekt speichert das synchronisierte Video ohne Lippensynchronisation sowie die übersetzten Untertitel im SRT- und VTT-Format. Bei entsprechenden Tarifen ist die übersetzte Stimme zudem als separate Tonspur verfügbar.
Feld
Format
Was es ist
lipsync_result_path
MP4
Das lippensynchronisierte Video, bereit zur Veröffentlichung
voiceover
WAV
Nur die übersetzte Sprache für Ihre eigene Abmischung
translated_audio
WAV
Übersetzte Sprache gemischt mit dem Original-Hintergrundaudio
translation_srt_path
.srt
Untertitel in der Zielsprache
translation_vtt_path
.vtt
Dieselbe Untertiteldatei als WebVTT für Webplayer
translated_video
MP4
Das synchronisierte Video ohne Lippensynchronisation zum Vergleich
Steuerung

Bearbeiten Sie die Synchronisation und generieren Sie anschließend eine aktualisierte, lippensynchronisierte Version

Nachdem Sie Text, Timing oder Stimmen geändert haben, können Sie die angepassten Abschnitte erneut synchronisieren und die Lippensynchronisation für das aktualisierte Video erstellen. Die erneute Synchronisation sowie jede neue Generierung der vollständigen Videolippensynchronisation werden separat berechnet.

Bearbeitung auf Segmentebene

Bearbeitung auf Segmentebene
Bearbeiten Sie einzelne Transkriptionsabschnitte und synchronisieren Sie die geänderten Zeilen neu. Um die Lippenbewegungen zu aktualisieren, erstellen Sie eine neue Lippensynchronisation für das gesamte Video; dies wird separat berechnet.
Das Transkript und seine Segmente abrufen
Den Quelltext anpassen, damit wir ihn neu übersetzen
Den übersetzten Text direkt anpassen, um Ihre eigenen Formulierungen beizubehalten
Zeitstempel anpassen, Segmente hinzufügen oder löschen
Sprechern eine neue Stimme zuweisen

Glossare für Fachbegriffe

Glossare für Fachbegriffe
Hinterlegen Sie ein Glossar, damit Markennamen und Fachbegriffe in jeder Synchronisation einheitlich ausgesprochen werden und die Lippensynchronisation diesen Formulierungen folgt.

Ein Glossar deckt ein Sprachpaar ab und gilt für alle regionalen Varianten dieser Zielsprache, sodass ein einziges spanisches Glossar es-mx und es-es gleichermaßen dient. Das Projekt speichert glossary_version, sodass spätere Änderungen bereits fertiggestellte Arbeit nicht unbemerkt verändern.
Eingabe

Unterstützte Dateiformate

Laden Sie eines von sieben Videoformaten hoch oder übergeben Sie eine öffentliche URL. Da reine Audiodateien kein Gesicht im Bild zeigen, gilt die Lippensynchronisation ausschließlich für Videoformate.

Video

7 Formate
.mp4
.mov
.mkv
.avi
.webm
.m4v
.3gp

Audio

4 Formate
.mp3
.wav
.flac
.m4a

Metadaten, bevor Kosten entstehen

Der Medienendpunkt liefert Informationen zu Dauer, Dateigröße, Videocodec, Bildrate, Auflösung, Audiocodec, Abtastrate und Kanalbelegung. Überprüfen Sie eine Datei vorab und schätzen Sie die Kosten ein, da sowohl die Synchronisation als auch die Lippensynchronisation jeweils nach Videominuten abgerechnet werden.
Sicherheit und Compliance

Gesichter und Stimmen – sicher verarbeitet

Brask Inc erfüllt die Anforderungen nach SOC 2 Type II, arbeitet gemäß DSGVO und veröffentlicht den aktuellen Systemstatus im Trust Center. Videos mit Gesichtern und Stimmen werden in einer geschlossenen KI-Umgebung verarbeitet.

Zertifizierungen

SOC 2 Type II
DSGVO
Mitglied bei CAI und C2PA

Verschlüsselung

TLS 1.2 während der Übertragung
AES-256 im Ruhezustand
Verwaltete SSE-S3-Schlüssel
Schlüsselrotation mindestens alle 12 Monate

Ihre Inhalte

Geschlossene KI-Umgebung
Niemals zum Trainieren allgemeiner Modelle verwendet
Vollständiger Export, keine Bindung an einen Anbieter

Zugang

SSO und SAML
Rollenbasierte Zugriffskontrolle
OAuth 2.0-Client-Anmeldeinformationen

Enterprise

Optionen für den Speicherort der Daten
Individuelle SLAs
Dedizierter Ansprechpartner

Stimmrechte

Synthetische Stimmen mit Nutzungsrechten
Einwilligungsbasierte Stimmklonung
KI-Sicherheitskontrollen, menschliche Überprüfung
Vergleich

Rask API im Vergleich zu einer selbst entwickelten Lippensynchronisations-Pipeline

Eine eigenständige Lippensynchronisations-API erfordert eine fertige Tonspur in der Zielsprache. Rask erstellt die synchronisierte Tonspur und passt die Lippen in einem einzigen Projekt an. Hier sehen Sie dasselbe Ergebnis, auf zwei verschiedene Weisen umgesetzt.
Was Sie benötigen
Rask API
Aus Einzelteilen zusammengesetzt
Eine übersetzte Tonspur zur Synchronisation
Im selben Projekt erstellt
Zunächst Transkriptions-, Übersetzungs- und Sprachdienstleister
Gesichtsprüfung vor der Bezahlung
Automatisch, einmal pro Projekt
Ihr eigener Gesichtserkennungsschritt
Mehrere Gesichter auf dem Bildschirm
is_multiple_speakers: true
Von Ihnen selbst entwickeltes und optimiertes Tracking pro Gesicht
Vorschau vor dem vollständigen Durchlauf
Eine kostenlose Minute pro Konto
Für jeden Testlauf bezahlen
Erneut synchronisieren nach einer Skriptbearbeitung
Eine neue vollständige Lipsync-Generierung für das gesamte Video, separat berechnet
Erneut für die gesamte Datei bezahlen
Hintergrundmusik und Effekte
Unter der neuen Stimme beibehalten
Ein von Ihnen erstellter Schritt zur Quellentrennung
Untertitel im .srt- und .vtt-Format
Im Lieferumfang enthalten
Aus Ihren eigenen Timing-Daten generiert
Einblick in die Warteschlange
Warteschlangenposition und Fortschritt 0–100
Was auch immer Ihr Anbieter bereitstellt
Ratenlimits
Keine
Was auch immer Ihr strengster Anbieter verlangt
Abrechnung
Pro vollständiger Lipsync-Generierung für das Video
Pro Durchlauf, pro Anbieter
Häufig gestellte Fragen

Lip-Sync-API: Häufig gestellte Fragen

Sie finden nicht, wonach Sie suchen? Wenden Sie sich an den Vertrieb.

Gibt es eine Lip-Sync-API?

Kann ich ein Video synchronisieren, ohne es vorher zu dubben?

Kann ich meine eigene Audiospur für das Lipsync verwenden?

Generiert die API sprechende Avatare aus einem Bild oder einem Prompt?

Welche Voraussetzungen muss ein Video für Lipsync erfüllen?

Wie wird Lipsync abgerechnet?

Gibt es eine kostenlose Vorschau für die Lippensynchronisation?

Funktioniert die Lippensynchronisation bei mehreren Sprechern?

Wie kann ich den Fortschritt der Lippensynchronisation verfolgen?

Wie lange dauert die Lippensynchronisation?

Was passiert, nachdem ich die Synchronisation bearbeitet habe?

Was ist, wenn die Lippensynchronisation fehlschlägt?

Wie erhalte ich API-Zugriff und einen API-Schlüssel?

Starten Sie noch heute Nachmittag mit der Synchronisation

Starten Sie noch heute Ihre erste Anfrage und sprechen Sie mit uns, wenn Sie Großkundenkonditionen oder eine seltene Sprache benötigen.