# 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



Carregue o vídeo de entrada ou envie um URL público, crie um projeto com um idioma de destino e aguarde por merging_done. A sincronização labial precisa do translated_video deste projeto.
A tarefa de verificação do rosto confirma pelo menos um rosto no vídeo. Habitualmente, inicia-se de forma automática. Se não se tiver iniciado, execute-a manualmente uma vez para o projeto.
Execute a tarefa de sincronização labial, acompanhe lipsync_task_progress de 0 a 100 e, em seguida, descarregue 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://...

es-mx e es-es igualmente. O registo do projeto glossary_version, para que edições posteriores nunca alterem silenciosamente o trabalho concluído.Sim. A API de sincronização labial da Rask funciona em qualquer vídeo dobrado no seu projeto. Confirme que o vídeo tem um rosto, inicie a tarefa de sincronização labial e transfira o vídeo sincronizado quando a tarefa estiver concluída. A autenticação utiliza credenciais de cliente OAuth 2.0, pelo que a integração da API segue o mesmo padrão que o resto da API da Rask.
A sincronização labial é aplicada a um vídeo traduzido. Crie e dobre o seu projeto primeiro e inicie a sincronização labial quando o projeto tiver uma ligação de vídeo traduzido e o estado de conclusão da fusão.
A sincronização labial utiliza o áudio dobrado do projeto. Para utilizar as suas próprias palavras, edite o texto traduzido ou crie a transcrição a partir do seu próprio ficheiro .srt, volte a dobrar o projeto e execute a sincronização labial na nova versão.
A sincronização labial da Rask utiliza imagens reais de oradores reais no seu vídeo de entrada. A geração de avatares falantes, humanos digitais e a geração de vídeo por IA a partir de uma imagem ou texto pertencem a outra categoria de produto, sendo preferível utilizar uma ferramenta de geração de vídeo por IA para esses casos.
Utilize imagens com o rosto do orador bem visível, boa iluminação e a boca desimpedida. Evite perfis muito pronunciados e elementos que cubram os lábios, como um microfone, uma mão ou legendas. A verificação de rostos confirma a presença de um rosto; utilize a pré-visualização para avaliar o resultado nas suas imagens.
A sincronização labial é cobrada separadamente da dobragem para cada geração de vídeo completo. Gerar uma nova versão com sincronização labial após edições gera um novo custo de sincronização labial.
Sim. Cada conta tem um minuto gratuito de sincronização labial nos seus créditos gratuitos. Execute a tarefa com is_free_lipsync definido como true para sincronizar um minuto do seu vídeo e verificá-lo. O ponto final de créditos mostra-o como lipsync_free_minutes.
Sim. Defina is_multiple_speakers como true quando puder haver mais do que um rosto no ecrã ao mesmo tempo, por exemplo, em entrevistas ou painéis. Se o vídeo mostrar sempre apenas um rosto de cada vez, defina-o como false para acelerar o processamento.
Faça uma chamada GET /v2/projects/{id}/lipsync. Na resposta, lipsync_task_status passa de started para done ou failed, lipsync_task_progress vai de 0 a 100 e tasks_in_lipsync_queue mostra quantas tarefas estão à frente da sua.
O tempo de processamento varia 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-lhe mostrar aos seus utilizadores exatamente em que estado está a tarefa.
A sincronização labial é gerada uma vez por versão dobrada. Depois de alterar o texto, os carimbos de data/hora, os oradores ou as vozes, volte a dobrar o projeto, aguarde por merging_done e execute a sincronização labial novamente. A nova geração de sincronização labial é cobrada separadamente. Uma verificação de rosto concluída não precisa de ser executada novamente.
Se check_face_task_status ou lipsync_task_status mostrar failed, contacte [email protected] com o seu project_id e a equipa irá analisar a situação.
O acesso à API está incluído nos planos pagos. Gera o seu ID de cliente e segredo na aplicação e pode começar a fazer chamadas imediatamente. Termos para empresas, preços por volume e cobertura de idiomas personalizados são tratados pela nossa equipa.