# 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



Téléchargez la vidéo d'origine ou envoyez une URL publique, créez un projet avec une langue cible et attendez que la fusion soit terminée. La synchronisation labiale nécessite la vidéo traduite de ce projet.
La tâche de vérification du visage confirme qu'il y a au moins un visage dans la vidéo. Elle démarre généralement automatiquement. Si elle n'a pas démarré, lancez-la vous-même une fois pour le projet.
Lancez la tâche de synchronisation labiale, suivez la progression de lipsync_task_progress de 0 à 100, puis téléchargez la vidéo depuis 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 et es-es de la même manière. L'historique du projet glossary_version, de sorte que les modifications ultérieures ne modifient jamais discrètement le travail déjà terminé.Oui. L'API de synchronisation labiale de Rask fonctionne sur n'importe quelle vidéo doublée de votre projet. Vérifiez que la vidéo comporte un visage, lancez la tâche de synchronisation labiale et téléchargez la vidéo synchronisée une fois la tâche terminée. L'authentification utilise les informations d'identification client OAuth 2.0, de sorte que l'intégration de l'API suit le même schéma que le reste de l'API Rask.
La synchronisation labiale s'applique à une vidéo traduite. Créez et doublé d'abord votre projet, puis lancez la synchronisation labiale lorsque le projet dispose d'un lien translated_video et du statut merging_done.
La synchronisation labiale utilise l'audio doublé du projet. Pour utiliser votre propre formulation, modifiez le texte traduit ou créez la transcription à partir de votre propre fichier .srt, redoublez le projet, puis lancez la synchronisation labiale sur la nouvelle version.
Rask synchronise les mouvements des lèvres sur des images réelles de locuteurs dans votre vidéo d'origine. La génération d'avatars parlants, d'humains numériques et la création de vidéos par IA à partir d'une image ou d'une consigne textuelle appartiennent à une autre catégorie de produits, pour laquelle un outil de génération de vidéos par IA sera plus adapté.
Utilisez des images où le visage qui parle est clairement visible, avec un bon éclairage et une bouche dégagée. Évitez les profils prononcés et tout ce qui cache les lèvres, comme un micro, une main ou des sous-titres. La vérification du visage confirme qu'un visage est présent ; utilisez l'aperçu pour évaluer le résultat sur votre vidéo.
La synchronisation labiale est facturée séparément du doublage pour chaque génération de vidéo complète. La génération d'une nouvelle version synchronisée après des modifications entraîne des frais supplémentaires.
Oui. Chaque compte dispose d'une minute gratuite de synchronisation labial dans ses crédits gratuits. Lancez la tâche en définissant is_free_lipsync sur true pour synchroniser une minute de votre vidéo et la visionner. L'endpoint des crédits l'affiche sous lipsync_free_minutes.
Oui. Définissez is_multiple_speakers sur true lorsque plusieurs visages peuvent apparaître à l'écran en même temps, par exemple lors d'interviews ou de tables rondes. Si la vidéo ne montre qu'un seul visage à la fois, définissez-le sur false pour accélérer le traitement.
Appelez GET /v2/projects/{id}/lipsync. Dans la réponse, lipsync_task_status passe de started à done ou failed, lipsync_task_progress va de 0 à 100 et tasks_in_lipsync_queue indique le nombre de tâches qui précèdent la vôtre.
Le temps de traitement varie selon la longueur de la vidéo et la file d'attente de synchronisation labial. La position dans la file d'attente et la valeur de progression vous permettent de montrer exactement à vos utilisateurs où en est la tâche.
La synchronisation labial est générée une seule fois par version doublée. Après avoir modifié le texte, les horodatages, les interlocuteurs ou les voix, redoublez le projet, attendez merging_done et relancez la synchronisation labial. La génération de la nouvelle synchronisation labial est facturée séparément. Une vérification des visages déjà effectuée n'a pas besoin d'être relancée.
Si check_face_task_status ou lipsync_task_status indique failed, contactez [email protected] avec votre project_id et l'équipe examinera le problème.
L'accès à l'API est inclus dans les abonnements payants. Vous générez votre identifiant client et votre secret dans l'application pour commencer à l'utiliser immédiatement. Pour les conditions d'entreprise, les tarifs dégressifs et la prise en charge de langues personnalisées, veuillez contacter notre équipe.