# 1. one Spanish glossary - it applies to every Spanish regional variant
curl -X POST https://api.rask.ai/v2/glossaries \
-H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
-d '{"name": "Brand terms", "src_lang": "en", "dst_lang": "es",
"entries": {"Rask Studio": "Rask Studio", "onboarding": "incorporación"}}'
# 2. a localized version per market, both with the same glossary
for lang in es-mx es-es; do
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\": \"$lang\", \"glossary_id\": \"$GLOSSARY_ID\"}"
done# Review: source and translated text, segment by segment
curl -s https://api.rask.ai/v2/projects/$ID/transcription \
-H "Authorization: Bearer $TOKEN" \
| jq '.segments[] | {speaker, src: .src.text, dst: .dst.text}'



Create a glossary for each language pair, save custom voices for recurring presenters, and choose the regional locale for each market you publish in.
Upload the source video once, then create a project for each target locale with your glossary, or with an approved translation imported from SRT.
Read the translated text side by side, edit what reviewers flag, re-dub the changed segments and download the localized video and subtitles.
# pip install git+ssh://[email protected]/braskai/rask-sdk.git@main
import asyncio
from rask_sdk import clients, enums, schemas
MARKETS = ["es-mx", "es-es"]
async def localize(client, video_id, locale, glossary_id):
job = await client.create_project(data=schemas.ProjectCreate(
video_id=video_id, dst_lang=locale, glossary_id=glossary_id))
while job.status is not enums.ProjectStatus.MERGING_DONE:
await asyncio.sleep(10)
job = await client.get_project(project_id=job.id)
return job
async def main():
client = clients.RaskSDKClient(client_id=CLIENT_ID, client_secret=CLIENT_SECRET)
glossary = await client.create_glossary(data=schemas.GlossaryCreate(
name="Brand terms", src_lang="en", dst_lang="es",
entries={"Rask Studio": "Rask Studio", "onboarding": "incorporación"}))
jobs = await asyncio.gather(*(localize(client, VIDEO_ID, m, glossary.id) for m in MARKETS))
for job in jobs: # review before publishing
script = await client.get_project_transcription(project_id=job.id)
for seg in script.segments[:3]:
print(job.dst_lang, seg.speaker, seg.src.text, "->", seg.dst.text)
asyncio.run(main())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}"}
glossary = requests.post(f"{API}/v2/glossaries", headers=h, json={
"name": "Brand terms", "src_lang": "en", "dst_lang": "es",
"entries": {"Rask Studio": "Rask Studio", "onboarding": "incorporación"}}).json()
ids = [requests.post(f"{API}/v2/projects", headers=h, json={
"video_id": VIDEO_ID, "dst_lang": locale, "glossary_id": glossary["id"]}).json()["id"]
for locale in ["es-mx", "es-es"]]
for pid in ids:
while requests.get(f"{API}/v2/projects/{pid}", headers=h).json()["status"] != "merging_done":
time.sleep(10)
script = requests.get(f"{API}/v2/projects/{pid}/transcription", headers=h).json()
for seg in script["segments"][:3]:
print(seg["src"]["text"], "->", seg["dst"]["text"])// 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());
const glossary = await call('POST', '/v2/glossaries', {
name: 'Brand terms', src_lang: 'en', dst_lang: 'es',
entries: { 'Rask Studio': 'Rask Studio', onboarding: 'incorporación' },
});
for (const dst_lang of ['es-mx', 'es-es']) {
let p = await call('POST', '/v2/projects', { video_id: VIDEO_ID, dst_lang, glossary_id: glossary.id });
while (p.status !== 'merging_done') { await sleep(10000); p = await call('GET', `/v2/projects/${p.id}`); }
const { segments } = await call('GET', `/v2/projects/${p.id}/transcription`);
segments.slice(0, 3).forEach((s) => console.log(dst_lang, s.src.text, '->', s.dst.text));
}# 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. import the translation your reviewers approved (source and translated .srt)
TRANSCRIPT_ID=$(curl -s -X POST "https://api.rask.ai/v2/transcriptions/srt?src_lang=en&dst_lang=es-mx" \
-H "Authorization: Bearer $TOKEN" \
-F "src=@source_en.srt" -F "dst=@approved_es-mx.srt" | jq -r .id)
# 3. create the localized version from it - Rask voices the approved script
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\": \"es-mx\", \"transcript_id\": \"$TRANSCRIPT_ID\"}"<?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']];
$glossary = $json($http->post('/v2/glossaries', ['headers' => $h, 'json' => [
'name' => 'Brand terms', 'src_lang' => 'en', 'dst_lang' => 'es',
'entries' => ['Rask Studio' => 'Rask Studio', 'onboarding' => 'incorporación'],
]]));
foreach (['es-mx', 'es-es'] as $locale) {
$p = $json($http->post('/v2/projects', ['headers' => $h, 'json' => [
'video_id' => $videoId, 'dst_lang' => $locale, 'glossary_id' => $glossary['id']]]));
while ($p['status'] !== 'merging_done') {
sleep(10);
$p = $json($http->get("/v2/projects/{$p['id']}", ['headers' => $h]));
}
$script = $json($http->get("/v2/projects/{$p['id']}/transcription", ['headers' => $h]));
echo $locale, ': ', $script['segments'][0]['dst']['text'], PHP_EOL;
} 0s created
11s transcription_started
87s translation_started
99s voiceover_started
154s merging_started
165s merging_done

es-mx and es-es alike. The project records glossary_version, so later edits never silently change finished work.A video localization API turns one source video into different versions for other markets through automation in your own code: translated and voiced speech, captions, consistent terminology and optional lip-sync. With Rask, each market version is a project you create, review and download through one REST API.
Translation changes the words. Localization prepares the same video for a specific market: the regional language variant, brand terms that stay consistent, the speakers' voices, captions and a review step before publishing. The Rask API supports all of these in one workflow.
Yes. Create a project for each target locale, such as es-mx for Mexico and es-es for Spain, and reuse one Spanish glossary for consistent brand terms. Review the wording for each market. When a regional accent matters, choose an available AI voice preset for that locale; voice cloning uses the base language model and does not guarantee a distinct regional accent.
Create a glossary for each language pair and attach it when you create the project. Each project records the glossary version it used, so editing a glossary later never changes finished work. A glossary cannot be added to a project after it is created.
Yes, on plans with SRT upload. Import your approved target-language SRT when creating the project; a separate source-language SRT is optional. You can also provide both files when you have them. Rask uses your approved translation for dubbing.
Cultural relevance needs human judgment. The API gives reviewers every segment to adapt references, idioms and examples for the market before publishing, and Rask can add human QA to the workflow when your team cannot review every video.
The documented API endpoints localize the speech and the captions. Text that is part of the picture, such as titles in the footage, stays as filmed. Talk to our team if on-screen text is part of your localization workflow.
Localize into multiple languages from 135+ language and regional options, including Mexican and European Spanish, Brazilian and European Portuguese, and Canadian French. Each project takes one target locale. The full list is in the API documentation, and our team can discuss options outside it.
Yes, in supported voice cloning languages. Use Instant Voice Clone to preserve the speaker’s identity, or a saved Custom Voice Clone for a recurring presenter. Cloning uses the base language model, so selecting a regional locale does not guarantee that region’s accent. Choose an available AI voice preset when the regional accent is the priority.
Lip-sync is an optional step for footage where a real person speaks on camera. Run it on the localized version after review. Each full-video lip-sync generation is billed separately from dubbing, including generations after later edits.
API usage is billed per minute of video for each market version, from the same minutes pool as the Rask app. Additional minutes cost $3/min on eligible standard plans. Enterprise pricing is tailored to your agreement. Re-dubbing after review is billed on the combined duration of changed segments, with a one-minute minimum per run, and lip-sync is billed separately. Try localization in the Rask app with a free trial, no card required. To evaluate the API, book a demo with our team.
Yes. For recurring volume, our team can help map your current process, define review and approval stages, configure terminology and voices, connect Rask to your CMS or LMS, and add human QA where it is needed.
API access is available on Creator Pro, Business and Enterprise plans, with capabilities determined by your plan. You generate your client id and secret in the app and start calling immediately. Enterprise terms, volume pricing and custom language coverage go through our team.