# 1. upload an audio or video file by link
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/interview.mp3", "name": "interview"}'
# 2. create the project - speech recognition starts automatically
# src_lang is optional: leave it out and the language is detected
curl -X POST https://api.rask.ai/v2/projects \
-H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
-d "{\"video_id\": \"$MEDIA_ID\", \"dst_lang\": \"es-mx\"}"# Read the transcript: one object per segment
curl -s https://api.rask.ai/v2/projects/$ID/transcription -H "Authorization: Bearer $TOKEN" \
| jq '.segments[] | {speaker, start, end, text: .src.text}'



Invia un file audio o video come dati di un modulo multipart, oppure inserisci il link di YouTube, Google Drive, S3, Vimeo o qualsiasi URL diretto. Riceverai un ID multimediale e i dettagli del file prima di qualsiasi addebito.
Inserisci l'ID multimediale come video_id e indica la lingua di arrivo. Se le conosci, aggiungi anche la lingua di origine e il numero di parlanti. Il riconoscimento si avvierà immediatamente.
Leggi la trascrizione non appena i segmenti sono pronti, mentre il file tradotto continua a essere elaborato. Scarica i sottotitoli e i file multimediali al completamento del progetto.
# pip install git+ssh://[email protected]/braskai/rask-sdk.git@main
import asyncio
from rask_sdk import clients, enums, schemas
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/interview.mp3"))
while media.status is enums.MediaStatus.PROCESSING:
await asyncio.sleep(5)
media = await client.get_media(media_id=media.id)
# src_lang omitted: the source language is detected automatically
job = await client.create_project(data=schemas.ProjectCreate(video_id=media.id, dst_lang="es-mx"))
while job.status is not enums.ProjectStatus.MERGING_DONE:
await asyncio.sleep(10)
job = await client.get_project(project_id=job.id)
transcript = await client.get_project_transcription(project_id=job.id)
for seg in transcript.segments:
print(seg.start, seg.end, seg.speaker, seg.src.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}"}
with open("interview.mp3", "rb") as f:
media = requests.post(f"{API}/api/library/v1/media", headers=h,
params={"kind": "audio"}, files={"data": f}).json()
while media["status"] == "processing":
time.sleep(5)
media = requests.get(f"{API}/api/library/v1/media/{media['id']}", headers=h).json()
pid = requests.post(f"{API}/v2/projects", headers=h, json={
"video_id": media["id"], "dst_lang": "es-mx", "num_speakers": 2}).json()["id"]
while requests.get(f"{API}/v2/projects/{pid}", headers=h).json()["status"] != "merging_done":
time.sleep(10)
# write the source transcript as an .srt file
segments = requests.get(f"{API}/v2/projects/{pid}/transcription", headers=h).json()["segments"]
with open("interview_en.srt", "w") as out:
for i, s in enumerate(segments, 1):
out.write(f"{i}\n{s['start']} --> {s['end']}\n{s['speaker']}: {s['src']['text']}\n\n")// 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());
let media = await call('POST', '/api/library/v1/media/link', { link: 'https://example.com/webinar.mp4' });
while (media.status === 'processing') { await sleep(5000); media = await call('GET', `/api/library/v1/media/${media.id}`); }
let p = await call('POST', '/v2/projects', { video_id: media.id, src_lang: 'en', dst_lang: 'de-de' });
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.forEach((s) => console.log(`[${s.start}] ${s.speaker}: ${s.src.text}`));
console.log(p.translation_vtt_path); // German subtitles for your player# 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. upload a local audio file
MEDIA_ID=$(curl -s -X POST "https://api.rask.ai/api/library/v1/media?kind=audio" \
-H "Authorization: Bearer $TOKEN" -F "data=@podcast_episode.mp3" | jq -r .id)
# 3. create the project once the media status is ready
ID=$(curl -s -X POST https://api.rask.ai/v2/projects \
-H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
-d "{\"video_id\": \"$MEDIA_ID\", \"dst_lang\": \"fr-fr\"}" | jq -r .id)
# 4. when status is merging_done, read the transcript with speaker labels
curl -s https://api.rask.ai/v2/projects/$ID/transcription -H "Authorization: Bearer $TOKEN" \
| jq -r '.segments[] | "\(.start) \(.speaker): \(.src.text)"'<?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']];
$media = $json($http->post('/api/library/v1/media/link', ['headers' => $h, 'json' => [
'link' => 'https://example.com/interview.mp3']]));
while ($media['status'] === 'processing') {
sleep(5);
$media = $json($http->get("/api/library/v1/media/{$media['id']}", ['headers' => $h]));
}
$p = $json($http->post('/v2/projects', ['headers' => $h, 'json' => [
'video_id' => $media['id'], 'dst_lang' => 'es-mx']]));
while ($p['status'] !== 'merging_done') {
sleep(10);
$p = $json($http->get("/v2/projects/{$p['id']}", ['headers' => $h]));
}
$t = $json($http->get("/v2/projects/{$p['id']}/transcription", ['headers' => $h]));
foreach ($t['segments'] as $s) {
echo $s['start'], ' ', $s['speaker'], ': ', $s['src']['text'], PHP_EOL;
}{"segments": [
{"speaker": "SPEAKER_00", "start": "00:00:00,320", "end": "00:00:07,316", "status": "done",
"src": {"text": "Thanks for joining us. Let's start with the new release.", "lang": "en"},
"dst": {"text": "Gracias por acompañarnos. Empecemos con la nueva versión.", "lang": "es-mx"}},
{"speaker": "SPEAKER_01", "start": "00:00:07,640", "end": "00:00:11,900", "status": "done",
"src": {"text": "Sure. The biggest change is the reporting view.", "lang": "en"},
"dst": {"text": "Claro. El cambio más grande es la vista de reportes.", "lang": "es-mx"}}
]}

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ì. Il riconoscimento vocale è la prima fase di ogni progetto su Rask. Carica un file audio o video, crea un progetto e leggi la trascrizione suddivisa in segmenti con etichette dei parlanti e timestamp tramite GET /v2/projects/{id}/transcription. Lo stesso progetto traduce la trascrizione e restituisce i sottotitoli e l'audio doppiato.
L'API accetta 75 lingue di origine. Lascia il campo src_lang vuoto e la lingua verrà rilevata automaticamente, oppure inserisci un codice a due lettere come en o de. La trascrizione può essere tradotta in oltre 135 lingue e opzioni regionali.
Sì. Carica file audio in formato MP3, WAV, FLAC o M4A, come podcast, interviste e chiamate registrate, e il progetto li trascriverà esattamente come farebbe con un video.
Sì. I diversi parlanti vengono rilevati automaticamente e ogni segmento include un'etichetta del parlante nel formato SPEAKER_XX. Specifica num_speakers se conosci il numero esatto e correggi il parlante di qualsiasi segmento tramite l'API.
No. I timestamp sono a livello di segmento: ogni segmento ha un orario di inizio e di fine nel formato HH:MM:SS,mmm. Questa è la tempistica utilizzata per i sottotitoli. Se ti serve un timestamp per ogni singola parola, scegli un'API di riconoscimento vocale dedicata.
No. Rask trascrive file audio e video completi e pre-registrati. Per sottotitoli in tempo reale, assistenti vocali, IA conversazionale e call center, dove il testo deve comparire mentre una persona sta ancora parlando, è più indicata un'API di trascrizione in streaming.
La precisione dipende dall'audio: microfoni, accenti, voci che si sovrappongono e rumore di fondo influiscono sul risultato. Testa l'API su un campione delle tue registrazioni e correggi qualsiasi segmento tramite l'API prima di pubblicarlo o tradurlo.
Il riconoscimento non prevede l'uso di un elenco di vocaboli personalizzati. Puoi correggere parole specifiche nella trascrizione utilizzando l'endpoint dei segmenti. Quando la trascrizione viene tradotta, un glossario mantiene coerenti i nomi dei prodotti, i nomi propri e i termini tecnici.
Il progetto completato include i file dei sottotitoli in formato SRT e VTT nella lingua di arrivo. La trascrizione nella lingua originale viene fornita sotto forma di segmenti JSON con i tempi di inizio e fine, che possono essere convertiti in SRT con poche righe di codice.
Sì. Nei piani che supportano l'importazione delle trascrizioni, potete fornire una trascrizione originale esistente, una traduzione approvata nella lingua di arrivo, oppure entrambe come file SRT o segmenti di testo temporizzati al momento della creazione del progetto. Rask può tradurre il vostro script originale o utilizzare la traduzione approvata per il doppiaggio.
I progetti vengono fatturati al minuto di audio o video, arrotondando al minuto intero successivo, utilizzando lo stesso monte minuti dell'app Rask. Il prezzo include trascrizione, traduzione, voce fuori campo e sottotitoli. I minuti aggiuntivi costano 3$ al minuto nei piani standard idonei. Le tariffe Enterprise sono personalizzate in base al vostro accordo. Se vi serve solo una trascrizione, un'API di riconoscimento vocale dedicata costa meno.
Iniziate con una prova gratuita nell'app Rask, senza bisogno di carta di credito, per testare la trascrizione e la traduzione sui vostri file. L'accesso alle API è disponibile nei piani Creator Pro, Business ed Enterprise, con funzioni che variano a seconda del piano scelto.
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.