Video localization API for every market

Turn one source video into a localized version for each market: the right regional language, consistent brand terms, the speakers' voices, subtitles and optional lip-sync. One API runs the localization workflow, and your team reviews the script before anything is published.
135+ language and regional options
Glossaries and review
REST + Python SDK
one source, two Spanish markets
OAuth 2.0
# 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
GET /v2/projects/{project_id}/transcription
review
# 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}'
Used by global teams
Capabilities

What the video localization API covers

Localization is more than a translated audio track. The API brings regional language options, terminology control, voices, subtitles and review into one workflow per market. Add optional lip-sync, billed separately.

135+ language and regional options

Localize for a specific region: es-mx or es-es, pt-br or pt-pt, fr-ca or fr-fr. Each project takes one target locale, and the source language is detected automatically.

Terminology control

Glossaries keep brand names and brand terms the same in every localized version. One glossary covers all regional variants of a language, and each project records the glossary version it used.

Your approved translation

Start from automatic translation, or bring a translation your reviewers already approved as an SRT file and let Rask voice it.

Lip-sync for on-camera footage

Match mouth movement to the localized speech where a real person speaks on camera. Optional, and each full-video generation is billed separately.

Background audio preserved

Music, room tone and effects from the original audio stay in the mix under the localized speech, so every market hears the same production.

Subtitles and captions

Each localized version comes with captions in SRT and VTT, in the target language and timed to the localized speech.

Speaker voices across markets

In interviews and dialogue, Instant Voice Clone keeps each speaker's voice in supported languages, and a saved Custom Voice Clone gives a recurring presenter one consistent voice. AI voice presets cover the rest.

Review before publishing

Reviewers read the source and translated text side by side, correct what does not fit the market, and re-dub only the changed segments.

Scale without limits

No rate limits, no concurrency quota, no per-key throttle. Generate hundreds of localized versions in parallel when a release goes to every market.
See it in action

One source video, localized for four markets

The same clip localized into French, German, Portuguese and Spanish: translated speech in the speakers' cloned voices, with the original background audio intact.
EN flag
En
FR flag
Fr
DE flag
De
PT flag
Pt
ES flag
Es
Workflow

Three steps in a video localization workflow

Set the rules once, then localize every new video with them. Creating a project starts the localization; use the /generate endpoint after review edits.
1

Set your localization rules

Create a glossary for each language pair, save custom voices for recurring presenters, and choose the regional locale for each market you publish in.

POST /v2/glossaries
2

Create a version per market

Upload the source video once, then create a project for each target locale with your glossary, or with an approved translation imported from SRT.

POST /v2/projects
3

Review and publish

Read the translated text side by side, edit what reviewers flag, re-dub the changed segments and download the localized video and subtitles.

GET /v2/projects/{id}/transcription
Processing time varies by project. Re-dubbing after review is billed on the combined duration of the changed segments, with a one-minute minimum per run.
Built around you

Localizing at volume? Plan the workflow with our team

Recurring volume, several reviewers, your own CMS or LMS: our team can help design the localization workflow, configure terminology and review stages, and add human QA where your team cannot review every video.

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 uses a video localization 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 localized versions with regional language options inside your product, so your users reach a global audience and a new market without leaving your platform.

Localization and production agencies

Run localization for several clients with a glossary per brand and a review step per project. Bring translations your linguists approved as SRT files, and deliver dubbed video, captions and optional lip-sync from one video localization workflow.

In-house continuous video production

International retail and e-commerce, global franchises, media publishers, corporate universities. Localize marketing videos, video ads, e-learning and product video content for each region with consistent brand terms, and create an updated version when the source video changes.
Customer stories

Real teams, measurable results

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

Video localization API code examples

One complete example in each language: create a glossary, localize one source video for two Spanish markets and read the translated text for review.
# 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())
github.com/braskai/rask-sdk
async, typed models
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"])
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());

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));
}
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. 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\"}"
POST /v2/transcriptions/srt
approved translation from SRT
<?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;
}
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 each localized version reports progress

Every market version is a project with its own documented status, so you can track a whole release across markets in one view. You only need to act on three groups.

Success, stop here

merging_done
Localization is complete. Fetch the project once more to retrieve the download links available for your project.

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, one sequence per market version.

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.
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

Localized video, audio and subtitles for each market

Each market version returns the localized video and captions in SRT and VTT. On eligible plans, you can also download the localized voice on its own or mixed with the original audio, for your own edit or distribution.
Field
Format
What it is
translated_video
MP4
The localized video, ready to publish
voiceover
WAV
Localized speech only, 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
Same subtitles as WebVTT, for web players
original_video
MP4
Your source file as stored, for reference
Control

Keep brand terms and wording consistent in every market

Localization quality comes from a review process. Reviewers check each segment, correct wording that does not fit the market and re-dub only those segments. Glossaries carry their decisions into the next video and keep brand consistency across markets.

Segment-level editing

Segment-level editing
Every project exposes its transcript as segments with the source and translated text, so a reviewer's correction is one patch request.
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 to each project so brand names and product terms translate the same way in every localized version, 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

Upload any of seven video and four audio formats, or send a URL. Audio-only content such as podcasts can be localized too; lip-sync applies to footage with a face on screen.

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 the cost of each market version in advance, because localization is billed by the minute.
Security and compliance

Ready for procurement in every market

Brask Inc holds SOC 2 Type II and operates under GDPR, and publishes live control status in its Trust Center. Data residency options are part of enterprise onboarding.

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 API vs a localization workflow you assemble yourself

Video localization brings translation, voice, subtitles, terminology and review into one production workflow. Here is the same workflow, assembled two ways.
What you need
Rask API
Assembled from parts
Regional language options
135+ language and regional options
Locale support that differs per vendor
Brand terms in every version
Versioned glossaries per language pair
Find-and-replace scripts you maintain
Translations your reviewers approved
Imported as SRT, then voiced
Manual alignment to the video
Speaker voices across markets
Instant and custom voice clones
A separate voice vendor per language
Background music and effects
Kept under the localized speech
A source-separation step you build
Captions in .srt and .vtt
Included
Generated from your own timing data
Lip-sync for on-camera footage
Optional, billed per full-video generation
A separate vendor
Fixing a line after review
Re-dub the changed segments only
Re-render the whole version
Rate limits
None
Whatever your strictest vendor enforces
Workflow design and human QA
Available with our team
Hired and managed separately
FAQ

Video localization API: common questions

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

What is a video localization API?

How is video localization different from video translation?

Can I localize one video for several regions of the same language?

How do I keep brand names consistent across localized versions?

Can I use translations we already approved?

Does the API handle cultural references?

Does the API translate on-screen text?

Which languages and regions are supported?

Can I keep the speaker's voice in every market?

How does lip-sync fit into a localization workflow?

How much does video localization cost?

Can Rask help design our localization workflow?

How do I get API access and an API key?

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.