# 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}"# 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}'



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.
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.
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.
# 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"))// 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);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"))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)"'<?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"; }
}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.
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.
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.
# 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" }
}

es-mx and es-es alike. The project records glossary.version, so later edits never silently change finished work.The Rask AI API is a REST API for video localization. It transcribes the speech in a video, translates it, dubs it in AI voices or voice clones, adds optional lip-sync and returns subtitles, audio tracks and the transcript, all from one project.
AI dubbing, video translation, video localization, voice cloning, lip sync, text to speech for video, speech to text, video transcription and subtitles. They share one authentication, one project object and one minutes pool, and each has its own page with details and code.
API access is available on Creator Pro, Business and Enterprise plans, with capabilities determined by your plan. You create an API key in the app and start calling immediately. Enterprise terms, volume pricing and custom language coverage go through our team.
API v3 takes a single API key. Create it in the web app, choose what it may do and how much it may spend in a month, and send it as a Bearer token with every request. There is no token to fetch or refresh.
Yes. Official SDKs ship for TypeScript, Python, Go, Java and PHP, installed from npm, PyPI, Go, Maven Central and Packagist. The REST API works from any language, and this page has complete examples.
Source audio in 75 languages, with automatic language detection, and 135+ language and regional options as targets, such as es-mx or pt-br. Voice cloning is available in supported voice cloning languages; AI voice presets cover the rest.
Usage is billed per minute of video, rounded up to the next whole minute, from the same minutes pool as the Rask app. Additional minutes cost $3/min on eligible standard plans, and Enterprise pricing is tailored to your agreement. Regeneration is billed on the changed segments with a one-minute minimum per run, and lip-sync is billed separately for each full-video generation.
API v3 replaces OAuth with a single API key, prices every paid operation before it runs, and reports long work as jobs you can wait for. It adds voice clones, on-screen text translation, transcript versions, project copies and exports, and covers 82 operations against the 23 of v2. API v2 keeps working unchanged.
Wait on the job with GET /v3/jobs/{job_id}: the request stays open until the status changes, so you can show real progress without a polling loop.
Video in MP4, MOV, MKV, AVI, WebM, M4V and 3GP, audio in MP3, WAV, FLAC and M4A, or a link from YouTube, Google Drive, S3, Vimeo or a direct URL.
Yes. Upload source and translated SRT files, or send text segments as subtitles when you create the project, or replace the transcript later with POST /v3/projects/{project_id}/transcript/import. Rask then voices your approved text.
No. The API processes recorded video and audio files and delivers results as files. For live voice agents or real time captions, a streaming speech API is the better fit.
Brask Inc holds SOC 2 Type II and operates under GDPR, with live control status in its Trust Center. Custom voice clones are created with the consent of the speaker.