NewAPI v3 · November 2026 Release

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 + 5 SDKs
three requests, start to finish
API key
# 1. import the video - a YouTube, Google Drive or Vimeo link
JOB=$(curl -s -X POST https://api.rask.ai/v3/media/import \
  -H "Authorization: Bearer $RASK_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"url": "https://youtu.be/..."}' | jq -r .id)

MEDIA=$(curl -s "https://api.rask.ai/v3/jobs/$JOB?wait_seconds=20" \
  -H "Authorization: Bearer $RASK_API_KEY" | jq -r .result.media_id)

# 2. check the price - free, and nothing is charged
CAP=$(curl -s -X POST https://api.rask.ai/v3/projects/estimate \
  -H "Authorization: Bearer $RASK_API_KEY" -H "Content-Type: application/json" \
  -d "{\"media_id\":\"$MEDIA\",\"target_language\":\"es-mx\"}" | jq -r .total_minutes)

# 3. create the project - dubbing starts, and costs no more than $CAP
curl -X POST https://api.rask.ai/v3/projects \
  -H "Authorization: Bearer $RASK_API_KEY" -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d "{\"media_id\":\"$MEDIA\",\"target_language\":\"es-mx\",\"expected_cost_minutes\":$CAP}"
GET /v3/jobs/{job_id}
one request, 20s
# One request waits for the next change in the job
curl -s "https://api.rask.ai/v3/jobs/$JOB_ID?wait_seconds=20" \
  -H "Authorization: Bearer $RASK_API_KEY" \
  | jq '{status, stage, progress, estimated_finish_at}'
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.

On-screen text, translated too

Titles, captions and slide text burned into the picture are translated and rendered back into the video, so the dubbed version reads in the target language as well as it sounds.
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 /projects/{project_id}/dub endpoint to regenerate after you edit the transcript or the voices.
1

Upload your video

Import the file from a YouTube, Google Drive or Vimeo link, or upload it straight to storage with a presigned URL. You receive a media id and the technical metadata before anything is charged.

POST /v3/media/import
2

Create the project

Pass the media id and a target language, with the price you accepted as expected_cost_minutes. Processing starts immediately and the project keeps that number as its ceiling.

POST /v3/projects
3

Collect the output

Wait for the job, then list the project outputs: the dubbed video, the audio tracks, the subtitle files and the transcript, each with a download link.

GET /v3/projects/{project_id}/outputs
Processing time varies with video length, the number of speakers and the target language. Follow the job and collect the files when it succeeds.
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

Delivery to your storage, custom endpoints, connections to the systems your team already runs. Describe how your pipeline receives files and our team scopes it with you.

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 rask-sdk
from rask_sdk import Rask

rask = Rask()                                   # reads RASK_API_KEY

# one call uploads the file and answers with the import job
import_job = rask.uploads.upload_file("launch.mp4")
media_id = rask.jobs.wait(import_job.id).result.media_id

# the price you accept becomes the ceiling of the work
estimate = rask.projects.estimate_project(media_id=media_id, target_language="es-mx")
print(f"The dub costs {estimate.total_minutes} minutes")

created = rask.projects.create_project(
    media_id=media_id,
    target_language="es-mx",
    expected_cost_minutes=estimate.total_minutes,
)
processed = rask.jobs.wait(created.id)
rask.jobs.wait(processed.result.auto_dub.dub_job_id)

outputs = rask.exports.list_project_outputs(processed.result.project_id).data
print(next(o.url for o in outputs if o.kind == "dubbed_video"))
pypi.org/project/rask-sdk
Python 3.11+
// npm install @braskai/api
import { Rask } from '@braskai/api';

const rask = new Rask();                        // reads RASK_API_KEY

const { data: importJob } = await rask.uploads.uploadFile('launch.mp4');
const { data: imported } = await rask.jobs.wait(importJob.id);
const order = { media_id: imported.result.media_id, target_language: 'es-mx' };

const { data: estimate } = await rask.projects.estimateProject({ body: order });
console.log(`The dub costs ${estimate.total_minutes} minutes`);

const { data: created } = await rask.projects.createProject({
  body: { ...order, expected_cost_minutes: estimate.total_minutes },
});
const { data: processed } = await rask.jobs.wait(created.id);
await rask.jobs.wait(processed.result.auto_dub.dub_job_id);

const { data: outputs } = await rask.exports.listProjectOutputs(processed.result.project_id);
console.log(outputs.data.find((o) => o.kind === 'dubbed_video')?.url);
httpx, no SDK
no SDK required
import os, httpx

API = "https://api.rask.ai/v3"
h = {"Authorization": f"Bearer {os.environ['RASK_API_KEY']}"}
c = httpx.Client(base_url=API, headers=h, timeout=30)

job = c.post("/media/import", json={"url": "https://youtu.be/..."},
             headers={"Idempotency-Key": os.urandom(16).hex()}).json()
media = c.get(f"/jobs/{job['id']}", params={"wait_seconds": 20}).json()["result"]["media_id"]

order = {"media_id": media, "target_language": "es-mx"}
cap = c.post("/projects/estimate", json=order).json()["total_minutes"]

created = c.post("/projects", json={**order, "expected_cost_minutes": cap},
                 headers={"Idempotency-Key": os.urandom(16).hex()}).json()

outputs = c.get(f"/projects/{created['project_id']}/outputs").json()["data"]
print(next(o["url"] for o in outputs if o["kind"] == "dubbed_video"))
Node 22+, Bun, Deno
plain HTTP
API=https://api.rask.ai/v3
AUTH="Authorization: Bearer $RASK_API_KEY"

JOB=$(curl -s -X POST $API/media/import -H "$AUTH" -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" -d '{"url":"https://youtu.be/..."}' | jq -r .id)
MEDIA=$(curl -s "$API/jobs/$JOB?wait_seconds=20" -H "$AUTH" | jq -r .result.media_id)

ORDER="{\"media_id\":\"$MEDIA\",\"target_language\":\"es-mx\"}"
CAP=$(curl -s -X POST $API/projects/estimate -H "$AUTH" -H "Content-Type: application/json" \
  -d "$ORDER" | jq -r .total_minutes)

PROJECT=$(curl -s -X POST $API/projects -H "$AUTH" -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d "$(jq -c --argjson cap "$CAP" '. + {expected_cost_minutes:$cap}' <<<"$ORDER")" | jq -r .project_id)

curl -s $API/projects/$PROJECT/outputs -H "$AUTH" \
  | jq -r '.data[] | select(.available) | "\(.kind)\t\(.url)"'
shell script
token to download
<?php
// composer require "braskai/rask-sdk:^3.0@alpha"
use Rask\Rask;

$rask = new Rask();                       // reads RASK_API_KEY

$importJob = $rask->uploads->uploadFile('launch.mp4');
$mediaId   = $rask->jobs->wait($importJob->id)->result->mediaId;

$estimate = $rask->projects->estimateProject(
    mediaId: $mediaId, targetLanguage: 'es-mx'
);
echo "The dub costs {$estimate->totalMinutes} minutes\n";

$created = $rask->projects->createProject(
    mediaId: $mediaId, targetLanguage: 'es-mx',
    expectedCostMinutes: $estimate->totalMinutes
);
$processed = $rask->jobs->wait($created->id);

foreach ($rask->exports->listProjectOutputs($processed->result->projectId)->data as $o) {
    if ($o->kind === 'dubbed_video') { echo $o->url, "\n"; }
}
Guzzle 7
plain HTTP
Official SDKs for TypeScript, Python, Go, Java and PHP. The raw tabs call the same endpoints over plain HTTP.
Spend control

The price is agreed before the work starts

Every paid operation has a free estimate that runs the same price function as the charge. You send that number back with the request, and it becomes the ceiling for the work.
1

Estimate anything, free

Projects, dubs, copies, lip-sync, on-screen text and segment generation each have an estimate. It costs nothing, changes nothing, and returns the exact price in minutes.

2

A ceiling, not a guess

Send the estimate as expected_cost_minutes. A price at or below it is charged as it is. A higher price fails the request and charges nothing.

3

Keys with limits

Give every integration its own key, with the rights it needs and a monthly spending limit. A key without spending rights can estimate and report while spending nothing.

Progress

How a Rask AI API project reports progress

Long work answers with a job. One request waits up to twenty seconds for the next change and returns the status, the stage and the progress, so your interface follows the work with a single open request.

Success, stop here

succeeded
The job holds its result: the project id, the media id or the files it produced. List the project outputs to get the download links.

In progress, keep polling

queued
running
uploading
transcribing
separating_audio
translating
voicing
merging
Plus the matching Each job also reports progress from 0 to 100 and the seconds it expects to still need, which map cleanly onto a staged progress bar. states. These map cleanly onto a staged progress UI.

Failure, stop and report

failed
failed
canceled
insufficient_balance
cost_changed
media_too_long
no_speech_detected
source_unavailable
source_url_not_allowed
no_speech_detected, source_unavailable and source_url_not_allowed are specific enough to show directly to your own user. Every error also returns a machine-readable slug.
One job, followed from queued to succeeded
GET /v3/jobs/{job_id}
# the request stays open until the job changes, then returns at once
{
  "status": "running",
  "stage": "translating",
  "progress": 46,
  "estimated_finish_at": "2026-11-17T09:41:18Z"
}

# ask again; the next answer is the finished job
{
  "status": "succeeded",
  "result": { "project_id": "c7d2a9e4-3b1f-4a6c-8d5e-9f0b2e7c1a63" },
  "links": { "outputs": "/v3/projects/c7d2a9e4.../outputs" }
}

One open request, no polling loop

Ask for a job with wait_seconds and the request stays open until the status changes, then returns at once. Your queue reacts to each change without a timer and without repeated calls.
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
dubbed_video
MP4
The dubbed video, ready to publish
voice_track
WAV
Translated speech only, on eligible plans, for your own mix
dubbed_audio
WAV
Translated speech mixed with the original background audio
target_subtitles
.srt .vtt
Subtitles in the target language
onscreen_video
.vtt
The video with translated on-screen text
/v3/projects/{id}/transcript
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
API keys with scopes and spend caps

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
Cost before you pay
Quoted first, capped at the quote
Billed per vendor after the work
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?

What is new in API v3?

How do I follow a long job?

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.