# 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 source ou envoyez une URL publique, créez un projet avec une langue cible et patientez jusqu'à l'étape merging_done. La synchronisation labiale nécessite la vidéo traduite de ce projet.
La tâche de vérification du visage confirme qu'au moins un visage est présent dans la vidéo. Elle démarre généralement automatiquement. Si ce n'est pas le cas, lancez-la vous-même une fois pour le projet.
Lancez la tâche de synchronisation labiale, suivez sa progression (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 même. Les enregistrements du projet glossary_version, de sorte que les modifications ultérieures ne modifient jamais le travail terminé sans que vous le sachiez.Oui. L'API de synchronisation labiale de Rask fonctionne sur toutes les vidéos doublées de votre projet. Vérifiez que la vidéo contient 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 identifiants client OAuth 2.0, de sorte que l'intégration de l'API suit le même modèle que le reste de l'API Rask.
La synchronisation labiale s'applique à une vidéo traduite. Créez et doublez 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 vos propres mots, 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 de véritables séquences de vrais interlocuteurs dans votre vidéo d'origine. La génération d'avatars parlants, d'humains numériques et de vidéos par IA à partir d'une image ou d'une consigne textuelle relève d'une autre catégorie de produits, pour laquelle un outil de génération de vidéo par IA est plus adapté.
Utilisez des images où le visage qui parle est bien visible, avec un bon éclairage et une bouche dégagée. Évitez les profils trop marqué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 vos images.
La synchronisation labiale est facturée séparément du doublage pour chaque génération de vidéo complète. La création 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 labiale dans ses crédits offerts. 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 le nom de lipsync_free_minutes.
Oui. Définissez is_multiple_speakers sur true lorsque plusieurs visages peuvent apparaître simultanément à l'écran, par exemple lors d'interviews ou de tables rondes. Si la vidéo ne montre qu'un seul visage à la fois, réglez cette valeur 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. La position dans la file d'attente et la valeur de progression vous permettent d'indiquer précisément à vos utilisateurs où en est la tâche.
La synchronisation labiale est générée une seule fois par version doublée. Une fois que vous modifiez le texte, les horodatages, les intervenants ou les voix, redoublez le projet, attendez merging_done et relancez la synchronisation labiale. Cette nouvelle génération est facturée séparément. La vérification des visages n'a pas besoin d'être refaite.
Si check_face_task_status ou lipsync_task_status indique un échec, contactez [email protected] avec votre project_id et l'équipe se chargera d'examiner le problème.
L'accès à l'API est inclus dans les forfaits payants. Vous générez votre identifiant client et votre secret dans l'application pour commencer immédiatement. Pour les conditions destinées aux grandes entreprises, la tarification par volume et la prise en charge de langues personnalisées, contactez notre équipe.