API di trascrizione vocale per file audio e video

Carica file audio o video preregistrati e ricevi una trascrizione con etichette dei parlanti e timestamp per ogni segmento, in 75 lingue di origine con rilevamento automatico della lingua. Lo stesso progetto la traduce in oltre 135 opzioni linguistiche e regionali, con sottotitoli e audio doppiato.
Diarizzazione dei parlanti
75 lingue di origine
REST + SDK Python
upload, transcribe, read
OAuth 2.0
# 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\"}"
GET /v2/projects/{project_id}/transcription
segments
# 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}'
Utilizzato da team in tutto il mondo
Funzionalità

Tutto ciò che restituisce l'API da voce a testo

Il riconoscimento vocale è la prima fase di ogni progetto Rask. La trascrizione viene restituita in segmenti con etichette dei parlanti e timestamp, pronta per essere modificata, tradotta, sottotitolata e doppiata nello stesso progetto.

Trascrivi file audio e video

Carica file audio o video preregistrati, oppure inserisci un link, e l'API converte il parlato in testo scritto, segmento per segmento.

Diarizzazione dei parlanti

I diversi parlanti vengono rilevati automaticamente e ogni segmento riporta un'etichetta del parlante come SPEAKER_00. Specifica il numero di parlanti se lo conosci, o correggi un'etichetta in un secondo momento.

Timestamp per ogni segmento

Ogni segmento ha un orario di inizio e di fine nel formato HH:MM:SS,mmm, pronto per didascalie, ricerca e navigazione all'interno di una registrazione.

75 lingue di origine

Supporto multilingue in 75 lingue di origine. Lascia vuota la lingua di origine per rilevarla automaticamente, oppure impostala con un codice a due lettere.

Traduzione nello stesso segmento

Ogni segmento contiene il testo di origine e la sua traduzione in una qualsiasi di oltre 135 opzioni linguistiche e regionali, così la trascrizione e la traduzione rimangono allineate riga per riga.

Sottotitoli in formato .srt e .vtt

Ogni progetto completato include file di sottotitoli nella lingua di arrivo, sincronizzati con i segmenti della trascrizione. Nessun fornitore esterno necessario per i sottotitoli.

Termini specifici nella traduzione

Un glossario mantiene coerenti i nomi dei prodotti, i nomi propri e il vocabolario specifico del settore quando la trascrizione viene tradotta, o intenzionalmente nella lingua originale.

Modifica la trascrizione tramite l'API

Correggi una parola, regola un timestamp, assegna un nuovo parlante, aggiungi o elimina un segmento. I revisori correggono la trascrizione finale invece di ricominciare da capo.

Cresci senza limiti

Nessun limite di velocità, nessuna quota di concorrenza, nessun blocco per chiave. Esegui trascrizioni in batch sull'intera libreria audio e video in parallelo.
Guardalo in azione

Guarda una trascrizione trasformarsi in cinque versioni linguistiche

La stessa clip trascritta, tradotta e doppiata in inglese, francese, tedesco, portoghese e spagnolo, con l'audio di sottofondo originale intatto.
EN flag
En
FR flag
Fr
DE flag
De
PT flag
Pt
ES flag
Es
Flusso di lavoro

Tre richieste dal file audio alla trascrizione

La creazione del progetto avvia il riconoscimento vocale, seguito dalla traduzione e dal doppiaggio in un'unica fase. Utilizza l'endpoint /generate dopo aver modificato la trascrizione.
1

Carica un file audio o video

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.

POST /api/library/v1/media/link
2

Crea il progetto

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.

POST /v2/projects
3

Leggi la trascrizione

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.

GET /v2/projects/{id}/transcription
Il riconoscimento analizza file completi e pre-registrati anziché audio in tempo reale. Il tempo di elaborazione varia in base alla durata del file, al numero di parlanti e alla lingua di arrivo.
Creato intorno a te

Cerchi una lingua o un formato che non è presente nell'elenco? Contatta il nostro team

Una lingua di origine non inclusa nell'elenco, un formato di trascrizione richiesto dalla tua piattaforma, una maggiore velocità di elaborazione o un metodo di consegna personalizzato: il nostro team esamina le esigenze della tua integrazione e le opzioni disponibili.

Lingue e voci

Hai bisogno di una lingua non presente nel catalogo pubblico? Parla con il nostro team per condividere le tue esigenze e scoprire le opzioni disponibili.

Consegna e integrazione

Webhook, invio nella tua coda, consegna diretta al tuo S3, endpoint personalizzati. Diteci come il vostro sistema si aspetta di ricevere i dati.

Volume e capacità

Le dimensioni dei lotti, le lingue di arrivo per azione e la priorità di elaborazione sono termini contrattuali, non limiti fissi del prodotto.

Sicurezza e hosting

La residenza dei dati, l'SSO e SAML, le regole di conservazione e il supporto per la revisione della sicurezza vengono gestiti durante l'attivazione per le aziende.
Casi d'uso

Chi utilizza un'API di trascrizione vocale per i video

Piattaforme con video integrati

Piattaforme LMS e di formazione per i clienti, piattaforme per creator e video, strumenti per webinar ed eventi virtuali, hosting video e SaaS per flussi di lavoro, piattaforme di digital adoption e live shopping. Aggiungi trascrizioni, sottotitoli e versioni tradotte di video registrati come funzionalità del tuo prodotto.

Agenzie di localizzazione e produzione

Utilizza la trascrizione con i nomi dei parlanti come bozza iniziale per i tuoi revisori, correggi i segmenti tramite l'API e fornisci sottotitoli, traduzioni e versioni doppiate dallo stesso progetto.

Produzione video interna e continua

Retail ed e-commerce internazionali, franchise globali, editori multimediali e università aziendali. Trascrivi corsi di formazione, webinar e interviste registrati, quindi pubblica sottotitoli e versioni in diverse lingue per ogni mercato.
Storie di clienti

Squadre vere, risultati tangibili

Come le aziende localizzano i video con Rask, attraverso i loro numeri.
freccia
freccia
Codice

Esempi di codice per l'API di trascrizione

Un esempio completo per ciascuna lingua: carica un file audio o video, crea il progetto, attendi e leggi i segmenti della trascrizione completi di parlanti e timestamp.
# 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())
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}"}

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")
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());

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
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. 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)"'
local file upload
audio file, multipart
<?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;
}
Guzzle 7
plain HTTP
Python è l'SDK ufficiale. Le schede Node, PHP e cURL mostrano semplici esempi HTTP sugli stessi endpoint.
Avanzamento

Come viene mostrato l'avanzamento di un progetto di trascrizione

La trascrizione è la prima fase di un progetto con stati definiti, così puoi monitorare i progressi reali anche per registrazioni lunghe. Ti basta gestire tre gruppi.

Operazione riuscita, fermati qui

merging_done
I file video e sottotitoli finali sono pronti. La trascrizione può essere letta in anticipo, non appena i suoi segmenti sono disponibili.

In corso, continua a verificare

created
uploading
transcription_started
separate_background_started
determine_speakers_started
translation_started
voiceover_started
merging_started
In più la corrispondenza _done stati. Questi si adattano perfettamente a un'interfaccia a fasi.

Errore, interruzione e segnalazione

failed
upload_failed
transcription_failed
translation_failed
voiceover_failed
merging_failed
no_audio
no_words
forbidden_link
no_audio, no_words e forbidden_link sono abbastanza specifici da poter essere mostrati direttamente ai vostri utenti.
Two speakers
GET /v2/projects/{id}/transcription
{"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"}}
]}

Oppure salta del tutto il controllo

Indica un endpoint webhook e ogni transizione di stato arriverà come richiesta POST, così la tua coda potrà reagire a ogni cambiamento nel momento stesso in cui si verifica. La consegna tramite webhook fa parte dell'onboarding per le aziende.
Leggi la documentazione
preserveAspectRatio="xMidYMid meet" aria-hidden="true" role="img">
Output

Segmenti della trascrizione, sottotitoli e file multimediali tradotti

Leggi la trascrizione come segmenti JSON dall'endpoint di trascrizione. Il progetto completato offre anche file di sottotitoli in formato SRT e VTT nella lingua di arrivo, il video tradotto e, per i piani idonei, l'audio tradotto come traccia WAV separata.
Campo
Formato
Cosa contiene
segments
JSON
Trascrizione: testo di origine, traduzione, nome del parlante, orario di inizio e di fine per ciascun segmento
voiceover
WAV
Solo audio tradotto, senza musica di sottofondo, disponibile nei piani idonei
translated_audio
WAV
Voce tradotta unita all'audio di sottofondo originale
translation_srt_path
.srt
Sottotitoli nella lingua di arrivo, sincronizzati con i segmenti
translation_vtt_path
.vtt
Gli stessi sottotitoli in formato WebVTT, per lettori web
translated_video
MP4
Il video tradotto con il doppiaggio
Controllo

Correggi la trascrizione segmento per segmento

Il riconoscimento vocale ti fornisce la prima bozza. Correggi una parola, un timestamp o un'etichetta del parlante con una richiesta per segmento, quindi rigenera la versione tradotta. La rigenerazione viene addebitata sui segmenti modificati, con un minimo di un minuto per esecuzione.

Modifica per singoli segmenti

Modifica per singoli segmenti
Ogni progetto espone la sua trascrizione come segmenti modificabili, quindi una correzione alla trascrizione finale richiede una singola richiesta di patch.
Scarica la trascrizione e i suoi segmenti
Modifica il testo originale e noi penseremo a ritradurlo
Modifica direttamente il testo tradotto per usare le parole che preferisci
Modifica i tempi, aggiungi segmenti o cancellane altri
Cambia la voce associata a qualsiasi speaker

Glossari per la terminologia

Glossari per la terminologia
Quando la trascrizione viene tradotta, un glossario mantiene i nomi dei marchi, i nomi propri e i termini specifici invariati in ogni versione, o volutamente nella lingua originale.

Un glossario copre una coppia di lingue e si applica a tutte le varianti regionali di quella lingua, così un unico glossario in spagnolo è utile per es-mx e es-es allo stesso modo. Il progetto registra glossary_version, così le modifiche successive non alterano mai inaspettatamente il lavoro completato.
Input

Formati di file supportati

Trascrivi file audio come podcast, interviste e chiamate registrate, oppure video in qualsiasi formato supportato, o invia un URL. Se carichi un file non supportato, l'API lo rifiuta prima che venga addebitato qualsiasi minuto.

Video

7 formati
.mp4
.mov
.mkv
.avi
.webm
.m4v
.3gp

Audio

4 formati
.mp3
.wav
.flac
.m4a

Tutte le informazioni prima di iniziare

L'endpoint multimediale restituisce durata, dimensioni del file, codec video, frequenza dei fotogrammi, risoluzione, codec audio, frequenza di campionamento e configurazione dei canali. Valuta un file e stima il costo in anticipo, poiché i progetti vengono fatturati al minuto di audio o video.
Sicurezza e conformità

Sicurezza di livello aziendale per dati audio e vocali

Brask Inc detiene la certificazione SOC 2 Type II, opera nel rispetto del GDPR e pubblica lo stato dei controlli in tempo reale nel suo Trust Center, garantendo che registrazioni e trascrizioni siano gestite tramite controlli verificati.

Certificazioni

SOC 2 Tipo II
GDPR
Membro CAI e C2PA

Crittografia

TLS 1.2 in transito
AES-256 a riposo
Chiavi gestite SSE-S3
Rotazione delle chiavi almeno ogni 12 mesi

I tuoi contenuti

Ambiente di intelligenza artificiale chiuso
Mai utilizzato per addestrare modelli generali
Esportazione completa, senza vincoli

Accesso

SSO e SAML
Controllo degli accessi basato sui ruoli
Credenziali client OAuth 2.0

Enterprise

Opzioni di localizzazione dei dati
SLA personalizzati
Account manager dedicato

Diritti sulle voci

Voci sintetiche con diritti di utilizzo
Clonazione vocale basata sul consenso
Controlli di sicurezza dell'IA, supervisione umana
Confronto

API di Rask rispetto a un'API speech-to-text unita alla tua pipeline

Un'API speech-to-text trasforma l'audio in testo. Quando quel testo deve diventare sottotitoli, traduzioni e versioni doppiate, il resto richiede il lavoro sulla pipeline. Ecco lo stesso risultato, ottenuto in due modi diversi.
Ciò di cui hai bisogno
Rask API
Assemblato da componenti
Una trascrizione con etichette dei parlanti
Incluso
Incluso nella maggior parte delle API speech-to-text
Timestamp
Per segmento
Per parola in molte API speech-to-text
Traduzione della trascrizione
Stesso progetto, oltre 135 opzioni di lingua e regionali
Un'API di traduzione separata
Sottotitoli in formato .srt e .vtt
Incluso, nella lingua di arrivo
Creato dai tuoi dati di tempistica
Audio e video doppiati
Incluso
Un fornitore TTS unito al tuo mixaggio
Correggere un segmento
Una richiesta di patch, quindi rigenera
Modifica e risincronizza le tue copie
Limiti di velocità
Nessuno
Qualsiasi cosa il vostro provider richieda
Trascrizione in tempo reale di audio dal vivo
Usa un'API di riconoscimento vocale in streaming
Progettato appositamente per questo
Solo una trascrizione, al prezzo più basso
Un'API di riconoscimento vocale dedicata costa meno
Prezzo calcolato in base alle ore di audio
Domande frequenti

API di riconoscimento vocale: domande frequenti

Non riesci a trovare quello che cerchi? Contatta l'ufficio vendite.

Rask dispone di un'API di riconoscimento vocale?

Quali lingue è in grado di trascrivere?

Posso trascrivere file audio senza video?

Supporta la separazione dei parlanti (diarizzazione)?

L'API restituisce i timestamp a livello di singola parola?

Supporta la trascrizione in tempo reale?

Quanto è accurata la trascrizione?

Posso aggiungere un vocabolario personalizzato o termini specifici del settore?

Posso ricevere la trascrizione in un file SRT?

Posso usare una mia trascrizione?

Come viene fatturata la trascrizione?

È prevista una versione gratuita?

Come posso ottenere l'accesso alle API e una chiave API?

Inizia a doppiare in un solo pomeriggio

Fai la tua prima prova oggi e contattaci se hai bisogno di tariffe per grandi volumi o di una lingua che nessun altro offre.