Rask AI API for video dubbing, translation and transcription

One API for the whole video localization workflow: transcribe the speech, translate it, dub it in AI voices or voice clones, add lip-sync and download subtitles. Upload once, create a project for each target language, and collect the video, audio tracks, subtitles and transcript.
Voice cloning
Lip-sync and subtitles
REST + Python SDK
three requests, start to finish
OAuth 2.0
# 1. exchange your client id and secret for a token (valid 1 hour)
curl -X POST https://rask-prod.auth.us-east-2.amazoncognito.com/oauth2/token \
  -u "$CLIENT_ID:$CLIENT_SECRET" -d "grant_type=client_credentials"

# 2. upload the video - file, or a YouTube, Drive, S3, Vimeo or direct link
curl -X POST https://api.rask.ai/api/library/v1/media/link \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"link": "https://youtu.be/...", "name": "Q3 launch"}'

# 3. create the project - transcription, translation and dubbing start
curl -X POST https://api.rask.ai/v2/projects \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d "{\"video_id\": \"$VIDEO_ID\", \"dst_lang\": \"es-mx\"}"
GET /v2/projects/{project_id}
polling, 10s
# Poll until merging_done, then collect the files
curl -s https://api.rask.ai/v2/projects/$ID -H "Authorization: Bearer $TOKEN" \
  | jq '{status, translated_video, voiceover, translation_srt_path}'
Used by global teams
Capabilities

Everything the Rask AI API does

One API covers the whole video workflow. Every capability runs on the same project, the same authentication and the same per-minute billing, and each one has its own page with details and code.

AI dubbing

Transcription, translation, voices and mixing behind one project. Send a video and a target locale and get the dubbed video back.

Video translation

Translate videos into 135+ language and regional options from one upload, with the translated text available for review in every language.

Voice cloning

Keep each speaker's own voice with Instant Voice Clone, or reuse a saved Custom Voice Clone, in supported voice cloning languages.

Lip-sync

Match mouth movement to the dubbed speech as a separate task on a dubbed project, with a face check first. Billed separately for each full-video generation.

Speech to text and video transcription

Transcripts with speaker labels and segment timestamps in 75 source languages, with automatic language detection.

Subtitles in .srt and .vtt

Both formats on every finished project, in the target language, for your player, app or editing software.

Video localization

Regional language options, glossaries for brand terms and approved translations, so each market gets its own version.

Text to speech for video

Send your own script with timestamps and get voiceover timed to the picture, in AI voices or voice clones.

Scale without limits

No rate limits, no concurrency quota, no per-key throttle. Run your whole catalogue and every target language in parallel.
See it in action

What the Rask AI API returns

One source clip, dubbed through the API into English, French, German, Portuguese and Spanish, in the speakers' cloned voices with the original background audio.
EN flag
En
FR flag
Fr
DE flag
De
PT flag
Pt
ES flag
Es
Workflow

Three requests from upload to finished video

Every Rask AI API workflow follows the same pattern, and creating the project starts the full run. Use the /generate endpoint to regenerate after you edit the transcript or the voices.
1

Upload your video

Send a video or audio file as multipart form data, or post a link from YouTube, Google Drive, S3, Vimeo or any direct URL. You get a media id and the file metadata before you spend anything.

POST /api/library/v1/media/link
2

Create the project

Pass the media id as video_id and a target language. Optionally attach your own transcript or a glossary. Processing starts immediately.

POST /v2/projects
3

Collect the output

Read status until it reaches merging_done, then download the dubbed video, the audio tracks, the subtitle files and the transcript.

GET /v2/projects/{project_id}
Processing time varies with video length, the number of speakers and the target language. In one observed run, a 3:47 video was dubbed in 165 seconds.
Built around you

Need something outside the catalogue? Talk to our team.

A language, a voice, a delivery method or a throughput that the public catalogue does not cover yet: our team reviews your requirements and the available options with you.

Languages and voices

Need a language or voice outside the public catalogue? Talk to our team about your requirements and the available options.

Delivery and integration

Webhooks, push into your own queue, delivery straight to your S3, custom endpoints. Tell us how your pipeline expects to be fed.

Volume and throughput

Batch sizes, target languages per action and processing priority are all contract terms, not fixed product limits.

Security and hosting

Data residency, SSO and SAML, retention rules and security review support are handled as part of enterprise onboarding.
Use cases

Who builds on the Rask AI API

Platforms with video inside

LMS and customer-education platforms, creator and video platforms, webinar and virtual event tools, video hosting and workflow SaaS, digital adoption platforms, live shopping. Offer dubbing, subtitles and transcripts in other languages as features of your own product.

Localization and production agencies

Connect Rask to the delivery pipeline you already run: dubbing, voice clones, subtitles and lip-sync for client videos, with your reviewers editing the transcript before delivery.

In-house continuous video production

International retail and e-commerce, global franchises, media publishers, corporate universities. Localize training, product and marketing videos for every market through one integration.
Customer stories

Real teams, measurable results

How companies localize video with Rask, in their own numbers.
arrow
arrow
Code

Rask AI API code examples

One complete round trip in each language: authenticate, upload, create a project, wait, collect the files. Each feature page has examples for its own workflow.
# pip install git+ssh://[email protected]/braskai/rask-sdk.git@main
import asyncio
from rask_sdk import clients, enums, schemas

async def main():
    # the client exchanges your credentials for tokens and refreshes them
    client = clients.RaskSDKClient(client_id=CLIENT_ID, client_secret=CLIENT_SECRET)

    media = await client.create_media_link(data=schemas.MediaCreateLink(link="https://youtu.be/..."))
    while media.status is enums.MediaStatus.PROCESSING:
        await asyncio.sleep(5)
        media = await client.get_media(media_id=media.id)

    job = await client.create_project(data=schemas.ProjectCreate(video_id=media.id, dst_lang="es-mx"))
    while job.status is not enums.ProjectStatus.MERGING_DONE:
        await asyncio.sleep(10)
        job = await client.get_project(project_id=job.id)

    print(job.translated_video, job.translation_srt_path, job.translation_vtt_path)

asyncio.run(main())
github.com/braskai/rask-sdk
Python 3.8+, async
import time, requests

AUTH = "https://rask-prod.auth.us-east-2.amazoncognito.com/oauth2/token"
API  = "https://api.rask.ai"
token = requests.post(AUTH, auth=(CLIENT_ID, CLIENT_SECRET),
                      data={"grant_type": "client_credentials"}).json()["access_token"]
h = {"Authorization": f"Bearer {token}"}

with open("launch.mp4", "rb") as f:
    media = requests.post(f"{API}/api/library/v1/media", headers=h,
                          params={"kind": "video"}, files={"data": f}).json()
while media["status"] == "processing":
    time.sleep(5)
    media = requests.get(f"{API}/api/library/v1/media/{media['id']}", headers=h).json()

pid = requests.post(f"{API}/v2/projects", headers=h,
                    json={"video_id": media["id"], "dst_lang": "de-de"}).json()["id"]
while (p := requests.get(f"{API}/v2/projects/{pid}", headers=h).json())["status"] != "merging_done":
    time.sleep(10)

for field in ("translated_video", "translated_audio", "translation_srt_path"):
    print(field, p[field])   # presigned links, valid for one hour
requests + polling
no SDK required
// no dependencies, Node 18+ global fetch
const API = 'https://api.rask.ai';
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 call = (method, path, body) => fetch(API + path, { method, headers: h, body: body && JSON.stringify(body) }).then((r) => r.json());

let media = await call('POST', '/api/library/v1/media/link', { link: 'https://youtu.be/...' });
while (media.status === 'processing') { await sleep(5000); media = await call('GET', `/api/library/v1/media/${media.id}`); }

let p = await call('POST', '/v2/projects', { video_id: media.id, dst_lang: 'ja-jp' });
while (p.status !== 'merging_done') { await sleep(10000); p = await call('GET', `/v2/projects/${p.id}`); }

const { translated_video, voiceover, translation_vtt_path } = p;
console.log({ translated_video, voiceover, translation_vtt_path });
fetch, Node 18+
plain HTTP
# 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. upload by link
VIDEO_ID=$(curl -s -X POST https://api.rask.ai/api/library/v1/media/link \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"link": "https://youtu.be/..."}' | jq -r .id)

# 3. create the project once the media status is ready
ID=$(curl -s -X POST https://api.rask.ai/v2/projects \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d "{\"video_id\": \"$VIDEO_ID\", \"dst_lang\": \"pt-br\"}" | jq -r .id)

# 4. wait for merging_done, then read the links
until [ "$(curl -s https://api.rask.ai/v2/projects/$ID -H "Authorization: Bearer $TOKEN" | jq -r .status)" = merging_done ]; do
  sleep 10
done
curl -s https://api.rask.ai/v2/projects/$ID -H "Authorization: Bearer $TOKEN" \
  | jq '{translated_video, translated_audio, translation_srt_path}'
shell script
token to download
<?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']];

$media = $json($http->post('/api/library/v1/media/link', ['headers' => $h, 'json' => [
    'link' => 'https://youtu.be/...']]));
while ($media['status'] === 'processing') {
    sleep(5);
    $media = $json($http->get("/api/library/v1/media/{$media['id']}", ['headers' => $h]));
}

$p = $json($http->post('/v2/projects', ['headers' => $h, 'json' => [
    'video_id' => $media['id'], 'dst_lang' => 'fr-fr']]));
while ($p['status'] !== 'merging_done') {
    sleep(10);
    $p = $json($http->get("/v2/projects/{$p['id']}", ['headers' => $h]));
}
echo $p['translated_video'], PHP_EOL, $p['translation_srt_path'], PHP_EOL;
Guzzle 7
plain HTTP
Python is the official SDK. The Node, PHP and cURL tabs are plain HTTP examples against the same endpoints.
Progress

How a Rask AI API project reports progress

Every project, whatever you use it for, moves through the same documented statuses. Show your users a staged progress bar and act on three groups only.

Success, stop here

merging_done
Every output file is ready. Fetch the project once more to get the download links, which stay valid for one hour.

In progress, keep polling

created
uploading
transcription_started
separate_background_started
determine_speakers_started
translation_started
voiceover_started
merging_started
Plus the matching _done states. These map cleanly onto a staged progress UI.

Failure, stop and report

failed
upload_failed
transcription_failed
translation_failed
voiceover_failed
merging_failed
no_audio
no_words
forbidden_link
no_audio, no_words and forbidden_link are specific enough to show directly to your own user. Every error also returns a machine-readable slug.
Observed run, 3:47 source video, en → es-mx
GET /v2/projects/{project_id}
   0s  created
  11s  transcription_started
  87s  translation_started
  99s  voiceover_started
 154s  merging_started
 165s  merging_done

Or skip polling entirely

Point us at a webhook endpoint and every state transition arrives as a POST, so your queue reacts to each change the moment it happens. Webhook delivery is part of enterprise onboarding.
Read the docs
preserveAspectRatio="xMidYMid meet" aria-hidden="true" role="img">
Output

Video, audio, subtitles and transcript from one project

A finished project exposes the dubbed video, two audio tracks, two subtitle files and the transcript. On eligible plans, the translated voice comes on its own as WAV, next to the full mix with the original background.
Field
Format
What it is
translated_video
MP4
The dubbed video, ready to publish
voiceover
WAV
Translated speech only, on eligible plans, for your own mix
translated_audio
WAV
Translated speech mixed with the original background audio
translation_srt_path
.srt
Subtitles in the target language
translation_vtt_path
.vtt
The same subtitles as WebVTT, for web players
/transcription
JSON
Source text, translation, speaker label and timestamps per segment
Control

Edit the transcript, regenerate only what changed

Automation does most of the work, and your team keeps the final say. Correct a line, a timestamp or a voice, regenerate, and pay for the changed segments, with a one-minute minimum per run.

Segment-level editing

Segment-level editing
Every project exposes its transcript as addressable segments, so a correction is one patch request rather than a new project.
Fetch the transcript and its segments
Patch the source text and we re-translate it
Patch the translated text directly to keep your own wording
Adjust timestamps, add segments, delete segments
Reassign the voice attached to any speaker

Glossaries for terminology

Glossaries for terminology
Attach a glossary and brand names, product names and technical terms translate the same way in every project, or stay in the original language on purpose.

A glossary covers one language pair and applies across all regional variants of that target language, so one Spanish glossary serves es-mx and es-es alike. The project records glossary_version, so later edits never silently change finished work.
Input

Supported file formats

Seven video and four audio formats, plus links from YouTube, Google Drive, S3, Vimeo and direct URLs. An unsupported file is rejected before any minutes are charged.

Video

7 formats
.mp4
.mov
.mkv
.avi
.webm
.m4v
.3gp

Audio

4 formats
.mp3
.wav
.flac
.m4a

Metadata before you spend

The media endpoint returns duration, file size, video codec, frame rate, resolution, audio codec, sample rate and channel layout. Validate a file and estimate cost in advance, because projects are billed by the minute.
Security and compliance

Ready for procurement and security review

Brask Inc holds SOC 2 Type II and operates under GDPR, and publishes live control status in its Trust Center for your security team.

Certifications

SOC 2 Type II
GDPR
CAI and C2PA member

Encryption

TLS 1.2 in transit
AES-256 at rest
SSE-S3 managed keys
Key rotation at least every 12 months

Your content

Closed AI environment
Never used to train general models
Full export, no lock-in

Access

SSO and SAML
Role-based access control
OAuth 2.0 client credentials

Enterprise

Data residency options
Custom SLAs
Dedicated account manager

Voice rights

Synthetic voices with usage rights
Consent-based voice cloning
AI safety controls, human in the loop
Comparison

Rask AI API vs a pipeline assembled from vendors

Transcription, translation, voices, lip-sync and subtitles usually come from separate vendors. Here is the same video workflow, assembled two ways.
What you need
Rask API
Assembled from parts
Transcription with speaker labels
Included
A speech to text API
Translation into 135+ language and regional options
Included
A translation API
AI voices and voice clones
Included
A TTS vendor and a voice cloning vendor
Background audio under the new speech
Mixed automatically
Source separation plus your own mixing
Lip-sync
A separate task on the same project
A lip-sync vendor
Subtitles in .srt and .vtt
Included
Your own file writer
Fixing one line
Regenerate the changed segments
Re-run the pipeline for the file
Terminology control
Glossaries
Custom post-processing
Billing
Per minute of video, one pool
Per character, per hour and per request across vendors
Rate limits
None
Whatever each provider enforces
Please, fill out this form, and Rask AI team will be in touch with you shortly!
FAQ

Rask AI API: common questions

Can't find what you're looking for? Contact sales.

What is the Rask AI API?

Which APIs are part of the Rask AI API?

How do I get access to the Rask AI API?

How does authentication work?

Is there an SDK?

Which languages does the API support?

How is the Rask AI API priced?

Are there rate limits?

Does the API support webhooks?

Which file formats can I upload?

Can I use my own transcript or translation?

Does the API work in real time?

Is the Rask AI API secure?

Start dubbing in one afternoon

Make your first request today, and talk to us when you need volume terms or a language nobody else has.