# 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 informe uma URL pública, crie um projeto com um 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. Caso não tenha começado, execute-a manualmente uma vez para o projeto.
Execute a tarefa de sincronização labial, acompanhe o lipsync_task_progress de 0 a 100 e, em seguida, baixe o vídeo a partir de 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. Os registros do projeto versao_glossario, garantindo que alterações futuras não modifiquem o trabalho finalizado sem que você perceba.Sim. A API de sincronização labial da Rask funciona em qualquer vídeo dublado no seu projeto. Verifique se o vídeo possui um rosto, inicie a tarefa de sincronização labial e baixe o vídeo sincronizado quando ela 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 é realizada em um vídeo traduzido. Crie e dube 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 utiliza o áudio dublado do projeto. Para usar o seu próprio texto, edite a tradução ou crie a transcrição a partir de um arquivo .srt próprio, dube o projeto novamente e execute a sincronização labial na nova versão.
A sincronização labial da Rask funciona com imagens reais de pessoas reais no seu vídeo de entrada. A geração de avatares falantes, humanos digitais e vídeos de IA a partir de imagens ou textos pertence a outra categoria de produto, sendo mais adequada para ferramentas específicas de geração de vídeos por IA.
Use gravações em que o rosto que está falando apareça com clareza, boa iluminação e a boca sem nenhum obstáculo. Evite perfis muito laterais e qualquer coisa que cubra os lábios, como microfone, mão ou legendas. A verificação confirma se há um rosto presente; use a prévia para avaliar o resultado no seu vídeo.
A sincronia labial é cobrada separadamente da dublagem para cada geração de vídeo completo. Gerar uma nova versão com sincronia após edições gera uma nova cobrança desse recurso.
Sim. Todas as contas têm um minuto gratuito de sincronia labial nos créditos gratuitos. Execute a tarefa definindo is_free_lipsync como verdadeiro para sincronizar um minuto do seu vídeo e analisá-lo. O endpoint de créditos mostra isso como lipsync_free_minutes.
Sim. Defina is_multiple_speakers como verdadeiro quando houver mais de um rosto na tela ao mesmo tempo, como em entrevistas ou debates. Se o vídeo mostrar apenas um rosto por vez, defina como falso 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 sincronia labial. A posição na fila e o valor do progresso permitem mostrar aos seus usuários exatamente em que pé está a tarefa.
A sincronia labial é gerada uma vez por versão dublada. Depois de alterar texto, marcações de tempo, falantes ou vozes, duble o projeto novamente, aguarde a mesclagem ser concluída (merging_done) e execute a sincronia labial outra vez. A nova geração de sincronia labial é cobrada separadamente. Uma verificação de rosto já concluída não precisa ser refeita.
Se check_face_task_status ou lipsync_task_status mostrar falha, entre em contato pelo e-mail [email protegida] com o 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 sua chave secreta no aplicativo e começa a fazer chamadas imediatamente. Condições para empresas, preços por volume e suporte a idiomas personalizados passam pela nossa equipe.