# 1. upload the video once - YouTube, Drive, S3, Vimeo or direct URL
curl -X POST https://api.rask.ai/api/library/v1/media/link \
-H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
-d '{"link": "https://example.com/onboarding.mp4", "name": "onboarding"}'
# 2. one project per subtitle language
for lang in es-mx fr-fr ja-jp; 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\"}"
done# When status is merging_done, download both subtitle files
P=$(curl -s https://api.rask.ai/v2/projects/$ID -H "Authorization: Bearer $TOKEN")
curl -s -o onboarding.es-mx.srt "$(echo $P | jq -r .translation_srt_path)"
curl -s -o onboarding.es-mx.vtt "$(echo $P | jq -r .translation_vtt_path)"



Invia il video come file o inserisci un link da YouTube, Google Drive, S3, Vimeo o qualsiasi URL diretto. Un solo caricamento copre tutte le lingue dei sottotitoli.
Passa l'ID multimediale come video_id e una lingua di arrivo per progetto. I progetti per lingue diverse vengono eseguiti in parallelo.
Leggi lo stato fino a quando non raggiunge merging_done, quindi scarica i file .srt e .vtt e salvali sui tuoi sistemi.
# pip install git+ssh://[email protected]/braskai/rask-sdk.git@main
import asyncio, urllib.request
from rask_sdk import clients, enums, schemas
LANGS = ["es-mx", "fr-fr", "ja-jp"]
async def subtitle(client, video_id, lang):
job = await client.create_project(data=schemas.ProjectCreate(video_id=video_id, dst_lang=lang))
while job.status is not enums.ProjectStatus.MERGING_DONE:
await asyncio.sleep(10)
job = await client.get_project(project_id=job.id)
# links are presigned for one hour - save the files right away
urllib.request.urlretrieve(job.translation_srt_path, f"video.{lang}.srt")
urllib.request.urlretrieve(job.translation_vtt_path, f"video.{lang}.vtt")
async def main():
client = clients.RaskSDKClient(client_id=CLIENT_ID, client_secret=CLIENT_SECRET)
media = await client.create_media_link(data=schemas.MediaCreateLink(link="https://example.com/onboarding.mp4"))
while media.status is enums.MediaStatus.PROCESSING:
await asyncio.sleep(5)
media = await client.get_media(media_id=media.id)
await asyncio.gather(*(subtitle(client, media.id, l) for l in LANGS))
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}"}
pid = requests.post(f"{API}/v2/projects", headers=h,
json={"video_id": VIDEO_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)
# translated subtitles: download the files
open("video.de-de.vtt", "wb").write(requests.get(p["translation_vtt_path"]).content)
# original-language captions: build a WebVTT file from the transcript segments
segs = requests.get(f"{API}/v2/projects/{pid}/transcription", headers=h).json()["segments"]
cues = [f"{s['start'].replace(',', '.')} --> {s['end'].replace(',', '.')}\n{s['src']['text']}" for s in segs]
open("video.en.vtt", "w").write("WEBVTT\n\n" + "\n\n".join(cues) + "\n")// no dependencies, Node 18+ global fetch
import { writeFile } from 'node:fs/promises';
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 langs = ['es-mx', 'pt-br', 'ko-kr'];
const tracks = await Promise.all(langs.map(async (dst_lang) => {
let p = await call('POST', '/v2/projects', { video_id: VIDEO_ID, dst_lang });
while (p.status !== 'merging_done') { await sleep(10000); p = await call('GET', `/v2/projects/${p.id}`); }
const file = `subs/${dst_lang}.vtt`;
await writeFile(file, await ((await fetch(p.translation_vtt_path)).text()));
return `<track kind="subtitles" srclang="${dst_lang}" src="/${file}">`;
}));
console.log(tracks.join('\n')); // paste inside your <video> element# 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. create the project for one subtitle language
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\": \"it-it\"}" | jq -r .id)
# 3. wait for merging_done
until [ "$(curl -s https://api.rask.ai/v2/projects/$ID -H "Authorization: Bearer $TOKEN" | jq -r .status)" = merging_done ]; do
sleep 10
done
# 4. save both subtitle files
P=$(curl -s https://api.rask.ai/v2/projects/$ID -H "Authorization: Bearer $TOKEN")
curl -s -o video.it-it.srt "$(echo $P | jq -r .translation_srt_path)"
curl -s -o video.it-it.vtt "$(echo $P | jq -r .translation_vtt_path)"<?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']];
foreach (['es-mx', 'tr-tr'] as $lang) {
$p = $json($http->post('/v2/projects', ['headers' => $h, 'json' => [
'video_id' => $videoId, 'dst_lang' => $lang]]));
while ($p['status'] !== 'merging_done') {
sleep(10);
$p = $json($http->get("/v2/projects/{$p['id']}", ['headers' => $h]));
}
// presigned links, valid for one hour
file_put_contents("video.$lang.srt", file_get_contents($p['translation_srt_path']));
file_put_contents("video.$lang.vtt", file_get_contents($p['translation_vtt_path']));
} 0s created
11s transcription_started
87s translation_started
99s voiceover_started
154s merging_started
165s merging_done

es-mx e es-es allo stesso modo. Il progetto registra glossary_version, così le modifiche successive non alterano mai inaspettatamente il lavoro completato.Sì. Ogni progetto Rask fornisce file di sottotitoli nei formati SRT e WebVTT nella lingua di arrivo. Caricate un video, create un progetto per ogni lingua dei sottotitoli e scaricate i file una volta completato il progetto.
Due formati per ogni progetto: un file SRT e un file WebVTT (VTT) nella lingua di arrivo. La trascrizione è disponibile anche come segmenti JSON con i relativi timestamp, qualora la vostra piattaforma richieda un formato di sottotitoli differente.
I file dei sottotitoli sono nella lingua di arrivo. Per i sottotitoli nella lingua originale, consultate i segmenti della trascrizione: ciascuno di essi include il testo originale con l'indicazione dell'ora di inizio e di fine, consentendo di generare un file SRT o VTT con poche righe di codice.
I sottotitoli sono disponibili in oltre 135 opzioni linguistiche e regionali, come es-mx, pt-br e fr-ca, partendo da 75 lingue di origine. Ciascun progetto prevede una sola lingua di arrivo; è possibile creare un progetto per ciascuna lingua a partire dallo stesso file caricato.
Non ancora. L'API restituisce i file dei sottotitoli da utilizzare nel vostro lettore o software di montaggio video. Per ottenere un video con i sottotitoli integrati, utilizzate l'applicazione web di Rask.
I file contengono il testo e la tempistica. Il carattere, la dimensione, il colore e la posizione vengono definiti nel vostro lettore video, applicazione o programma di montaggio, consentendo di utilizzare lo stesso file ovunque.
I file contengono esclusivamente i dialoghi parlati. Le descrizioni di brani musicali ed effetti sonori per non udenti o ipoudenti non vengono generate automaticamente; è possibile aggiungerle durante la fase di modifica dei sottotitoli.
Ogni segmento della trascrizione riporta un'etichetta identificativa dell'interlocutore nel formato SPEAKER_XX, permettendovi di inserire i nomi quando create i sottotitoli per interviste e dialoghi.
Modificate il testo o la tempistica del segmento tramite l'API e rigenerate il progetto. I file dei sottotitoli vengono aggiornati insieme alla versione doppiata. La rigenerazione viene fatturata sui segmenti modificati, con un minimo di un minuto per esecuzione.
I link per il download sono pre-firmati e validi per un'ora. Salvate i file sul vostro spazio di archiviazione o recuperate nuovamente il progetto per ottenere nuovi link.
Sì. Nei piani con importazione della trascrizione, caricate i sottotitoli nella lingua originale, un file SRT approvato nella lingua di arrivo, o entrambi durante la creazione del progetto. Usate i sottotitoli esistenti come origine o mantenete la vostra traduzione approvata per i sottotitoli e il doppiaggio nella lingua di arrivo.
I progetti vengono fatturati al minuto di video, arrotondato per eccesso al minuto intero successivo, attingendo dallo stesso monte minuti dell'app Rask. Il prezzo include trascrizione, traduzione, sottotitoli e versione doppiata. I minuti aggiuntivi costano 3$/min nei piani standard idonei. I prezzi per le aziende sono personalizzati in base al vostro contratto.
L'accesso alle API è disponibile nei piani Creator Pro, Business ed Enterprise, con funzioni che variano a seconda del piano scelto. Potete generare l'ID cliente e la password segreta direttamente nell'app e iniziare subito a effettuare chiamate. Per le condizioni dedicate alle aziende, i prezzi per grandi volumi e la copertura di lingue personalizzate, potete rivolgervi al nostro team.