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



Prześlij film lub podaj publiczny adres URL, utwórz projekt w wybranym języku docelowym i poczekaj na zakończenie scalania. Do synchronizacji warg potrzebny jest przetłumaczony film z tego projektu.
To zadanie potwierdza obecność co najmniej jednej twarzy na nagraniu. Zazwyczaj uruchamia się automatycznie. Jeśli tak się nie stało, uruchom je samodzielnie dla danego projektu.
Uruchom zadanie synchronizacji warg, śledź jego postęp od 0 do 100, a następnie pobierz film ze ścieżki wynikowej.
# 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())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"])// 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);# 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}'<?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'];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://...

es-mx oraz es-es podobnie. Projekt rejestruje wersja_słownika, dzięki czemu późniejsze poprawki nigdy nie zmieniają ukończonej pracy w tle.Tak. API synchronizacji ruchu warg Rask działa z każdym wideo, które zostało zdubbingowane w Twoim projekcie. Sprawdź, czy na wideo widać twarz, uruchom zadanie synchronizacji i pobierz gotowy plik, gdy zadanie się zakończy. Uwierzytelnianie wykorzystuje dane uwierzytelniające klienta OAuth 2.0, dzięki czemu integracja API przebiega tak samo jak w przypadku reszty API Rask.
Synchronizacja ruchu warg działa na przetłumaczonym wideo. Najpierw utwórz i zdubbinguj swój projekt, a następnie uruchom synchronizację, gdy projekt będzie posiadał link do przetłumaczonego wideo oraz status merging_done.
Synchronizacja ruchu warg korzysta ze zdubbingowanego dźwięku projektu. Aby użyć własnych słów, edytuj przetłumaczony tekst lub utwórz transkrypcję z własnego pliku .srt, zdubbinguj projekt ponownie, a następnie uruchom synchronizację dla nowej wersji.
Funkcja synchronizacji ruchu warg w Rask przetwarza rzeczywisty materiał wideo z prawdziwymi osobami. Generowanie mówiących awatarów, cyfrowych ludzi oraz wideo AI ze zdjęcia lub tekstu to inna kategoria produktów, do której lepiej sprawdzą się dedykowane narzędzia do generowania wideo AI.
Użyj materiału wideo, na którym mówiąca twarz jest dobrze widoczna, oświetlona, a usta nie są zasłonięte. Unikaj silnych profili bocznych oraz elementów zasłaniających usta, takich jak mikrofon, dłoń czy napisy. Kontrola twarzy potwierdza jej obecność; użyj podglądu, aby ocenić wynik na swoim materiale.
Synchronizacja ruchu warg jest rozliczana osobno od dubbingu dla każdej wygenerowanej wersji całego wideo. Wygenerowanie nowej wersji po edycji wiąże się z kolejną opłatą.
Tak. Każde konto otrzymuje jedną darmową minutę synchronizacji ruchu warg w ramach darmowych środków. Uruchom zadanie z parametrem is_free_lipsync ustawionym na true, aby zsynchronizować jedną minutę filmu i sprawdzić wynik. Punkt końcowy kredytów pokazuje to jako lipsync_free_minutes.
Tak. Ustaw wartość is_multiple_speakers na true, gdy na ekranie w tym samym czasie może znajdować się więcej niż jedna twarz, na przykład w wywiadach lub panelach dyskusyjnych. Jeśli w filmie zawsze widoczna jest tylko jedna twarz, ustaw tę wartość na false, aby przyspieszyć przetwarzanie.
Wywołaj zapytanie GET /v2/projects/{id}/lipsync. W odpowiedzi parametr lipsync_task_status zmienia się z started na done lub failed, lipsync_task_progress rośnie od 0 do 100, a tasks_in_lipsync_queue pokazuje, ile zadań znajduje się w kolejce przed Twoim.
Czas przetwarzania zależy od długości filmu oraz kolejki synchronizacji. Pozycja w kolejce i wskaźnik postępu pozwalają pokazać użytkownikom dokładny stan zadania.
Synchronizacja ruchu warg jest generowana raz dla każdej wersji z dubbingiem. Po zmianie tekstu, znaczników czasu, mówców lub głosów wykonaj ponowny dubbing projektu, poczekaj na komunikat merging_done i uruchom synchronizację ponowie. Nowe generowanie synchronizacji jest rozliczane osobno. Zakończone sprawdzanie twarzy nie musi być wykonywane ponownie.
Jeśli check_face_task_status lub lipsync_task_status wskazuje błąd, skontaktuj się z adresem [email protected], podając numer project_id, a nasz zespół zajmie się tą sprawą.
Dostęp do API jest zawarty w planach płatnych. W aplikacji generujesz identyfikator klienta oraz klucz tajny i możesz od razu zacząć wysyłać zapytania. Warunki dla firm, ceny wolumenowe i niestandardowe pakiety językowe są omawiane z naszym zespołem.