# 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



Carica il video o invia un URL pubblico, crea un progetto con una lingua di arrivo e attendi il completamento dell'unione. La sincronizzazione labiale richiede il video tradotto di questo progetto.
Il controllo del volto verifica che ci sia almeno un volto nel video. Di solito si avvia automaticamente. Se non parte, avvialo tu una volta per il progetto.
Avvia l'attività di sincronizzazione labiale, segui l'avanzamento da 0 a 100, quindi scarica il video dal percorso dei risultati.
# 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 e es-es allo stesso modo. Il progetto registra glossary_version, così le modifiche successive non alterano mai inaspettatamente il lavoro completato.Sì. L'API di sincronizzazione labiale di Rask funziona su qualsiasi video doppiato nel vostro progetto. Verificate che il video contenga un volto, avviate l'attività di sincronizzazione labiale e scaricate il video sincronizzato al termine. L'autenticazione utilizza le credenziali client OAuth 2.0, quindi l'integrazione dell'API segue lo stesso schema del resto delle API di Rask.
La sincronizzazione labiale viene eseguita su un video tradotto. Create e doppiate prima il vostro progetto, quindi avviate la sincronizzazione labiale quando il progetto dispone di un link video tradotto e dello stato di unione completata.
La sincronizzazione labiale utilizza l'audio doppiato del progetto. Per utilizzare le vostre parole, modificate il testo tradotto o create la trascrizione dal vostro file .srt, doppiate nuovamente il progetto e infine eseguite la sincronizzazione labiale sulla nuova versione.
La sincronizzazione labiale di Rask si applica a riprese reali di persone reali presenti nel vostro video. La generazione di avatar parlanti, di umani digitali e la creazione di video con l'intelligenza artificiale da un'immagine o da un testo appartengono a una categoria diversa, per la quale è più adatto uno strumento specifico di generazione video con IA.
Utilizzate riprese in cui il volto che parla sia chiaramente visibile, con una buona illuminazione e la bocca libera da ostacoli. Evitate profili laterali accentuati e qualsiasi elemento che copra le labbra, come microfoni, mani o didascalie. Il controllo del volto verifica che sia presente un volto; utilizzate l'anteprima per valutare il risultato sul vostro filmato.
La sincronizzazione labiale viene fatturata separatamente rispetto al doppiaggio per ogni generazione dell'intero video. La creazione di una nuova versione sincronizzata dopo le modifiche comporta un ulteriore costo.
Sì. Ogni account include un minuto gratuito di sincronizzazione labiale tra i crediti gratuiti. Avvia l'operazione impostando is_free_lipsync su true per sincronizzare un minuto del tuo video e verificarne il risultato. L'endpoint dei crediti lo indica come lipsync_free_minutes.
Sì. Imposta is_multiple_speakers su true quando più di un volto può comparire sullo schermo nello stesso momento, ad esempio in interviste o tavole rotonde. Se il video mostra sempre un solo volto alla volta, impostalo su false per velocizzare l'elaborazione.
Chiama GET /v2/projects/{id}/lipsync. Nella risposta, lipsync_task_status passa da started a done o failed, lipsync_task_progress va da 0 a 100 e tasks_in_lipsync_queue mostra quanti lavori precedono il tuo.
Il tempo di elaborazione dipende dalla durata del video e dalla coda di sincronizzazione. La posizione in coda e la percentuale di avanzamento ti permettono di mostrare agli utenti lo stato esatto del lavoro.
La sincronizzazione labiale viene creata una sola volta per ogni versione doppiata. Dopo aver modificato testo, tempi, parlanti o voci, ripeti il doppiaggio del progetto, attendi merging_done ed esegui nuovamente la sincronizzazione labiale. La creazione della nuova sincronizzazione viene fatturata separatamente. Un controllo del volto già completato non deve essere eseguito di nuovo.
Se check_face_task_status o lipsync_task_status indica un errore, contatta [email protected] indicando il tuo project_id e il team analizzerà il problema.
L'accesso alle API è incluso nei piani a pagamento. Puoi generare l'ID cliente e la password segreta direttamente nell'app e iniziare a fare chiamate da subito. Per le condizioni aziendali, i prezzi basati sul volume e la copertura di lingue personalizzate, puoi rivolgerti al nostro team.