# 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



Envie o vídeo original ou forneça uma URL pública, crie um projeto com o idioma de destino e aguarde até que o status seja merging_done. A sincronização labial precisa do translated_video deste projeto.
A tarefa de verificação de rosto confirma a presença de pelo menos um rosto no vídeo. Ela geralmente começa de forma automática. Se não tiver iniciado, execute-a manualmente para o projeto.
Execute a tarefa de sincronização labial, acompanhe o progresso de lipsync_task_progress de 0 a 100 e, em seguida, baixe o vídeo em lipsync_result_path.
# 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://...

pt-br e pt-pt igualmente. O registro do projeto versão_do_glossário, garantindo que edições futuras nunca alterem o que já foi finalizado sem que você perceba.Sim. A API de sincronização labial da Rask funciona em qualquer vídeo dublado do seu projeto. Verifique se o vídeo possui um rosto, inicie a tarefa de sincronização labial e baixe o vídeo sincronizado quando a tarefa for concluída. A autenticação usa credenciais de cliente OAuth 2.0, portanto a integração da API segue o mesmo padrão do restante da API da Rask.
A sincronização labial é executada em um vídeo traduzido. Crie e duble seu projeto primeiro e inicie a sincronização labial quando o projeto tiver um link translated_video e o status merging_done.
A sincronização labial usa o áudio dublado do projeto. Para usar suas próprias palavras, edite o texto traduzido ou crie a transcrição a partir do seu próprio arquivo .srt, reduble o projeto e execute a sincronização labial na nova versão.
A sincronização labial da Rask funciona com gravações reais de pessoas reais no seu vídeo de entrada. A geração de avatares falantes, humanos digitais e vídeos por IA a partir de uma imagem ou texto pertence a outra categoria de produto, sendo mais adequada para ferramentas de geração de vídeo por IA.
Use gravações em que o rosto de quem fala esteja claramente visível, com boa iluminação e a boca sem obstruções. Evite perfis muito laterais e qualquer objeto que cubra os lábios, como microfone, mão ou legendas. A verificação confirma a presença de um rosto; use a visualização para avaliar o resultado no seu vídeo.
A sincronização labial é cobrada separadamente da dublagem para cada geração de vídeo completo. A criação de uma nova versão sincronizada após edições gera uma nova cobrança de sincronização labial.
Sim. Todas as contas contam com um minuto gratuito de sincronização labial em seus créditos gratuitos. Execute a tarefa definindo is_free_lipsync como true para sincronizar um minuto do seu vídeo e revisá-lo. O endpoint de créditos mostra isso como lipsync_free_minutes.
Sim. Defina is_multiple_speakers como true quando houver mais de um rosto na tela ao mesmo tempo, como em entrevistas ou painéis. Se o vídeo mostrar apenas um rosto por vez, defina como false para acelerar o processamento.
Faça uma chamada GET /v2/projects/{id}/lipsync. Na resposta, lipsync_task_status muda de started para done ou failed, lipsync_task_progress vai de 0 a 100, e tasks_in_lipsync_queue mostra quantas tarefas estão na sua frente.
O tempo de processamento varia de acordo com a duração do vídeo e a fila de sincronização labial. A posição na fila e o valor de progresso permitem que você mostre aos seus usuários exatamente em que pé está a tarefa.
A sincronização labial é gerada uma vez por versão dublada. Depois de alterar texto, marcas de tempo, falantes ou vozes, faça a redublagem do projeto, aguarde o merging_done e execute a sincronização labial novamente. A nova geração de sincronização labial é cobrada separadamente. A verificação de rostos concluída não precisa ser executada novamente.
Se check_face_task_status ou lipsync_task_status mostrar failed, entre em contato com [email protected] informando seu project_id e a equipe vai analisar o caso.
O acesso à API está incluído nos planos pagos. Você gera seu ID de cliente e segredo no aplicativo e começa a fazer chamadas imediatamente. Termos empresariais, preços por volume e cobertura de idiomas personalizados passam pela nossa equipe.