Speech to text API for audio and video files

Upload pre-recorded audio or video and get a transcript with speaker labels and timestamps for every segment, in 75 source languages with automatic language detection. The same project translates it into 135+ language and regional options, with subtitles and dubbed audio.
Speaker diarization
75 source languages
REST + Python SDK
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}'
Used by global teams
Capabilities

Everything the speech to text API returns

Speech recognition is the first stage of every Rask project. The transcript comes back as segments with speaker labels and timestamps, ready to edit, translate, subtitle and voice in the same project.

Transcribe audio files and video

Upload pre-recorded audio or video, or post a link, and the API converts the speech into written text, segment by segment.

Speaker diarization

Different speakers are detected automatically, and each segment carries a speaker label such as SPEAKER_00. Pass the number of speakers if you know it, or correct a label later.

Timestamps for every segment

Each segment has a start and an end time in HH:MM:SS,mmm format, ready for captions, search and navigation inside a recording.

75 source languages

Multilingual support across 75 source languages. Leave the source language empty and it is detected automatically, or set it with a two-letter code.

Translation in the same segment

Every segment holds the source text and its translation, in any of 135+ language and regional options, so the transcript and the translation stay aligned line by line.

Subtitles in .srt and .vtt

Every finished project includes subtitle files in the target language, timed to the transcript segments. No second vendor for captions.

Domain terms in translation

A glossary keeps product names, proper nouns and domain specific vocabulary consistent when the transcript is translated, or in the original language on purpose.

Edit the transcript through the API

Fix a word, adjust a timestamp, reassign a speaker, add or delete a segment. Reviewers correct the final transcript instead of starting again.

Scale without limits

No rate limits, no concurrency quota, no per-key throttle. Run batch transcription across your whole audio and video library in parallel.
See it in action

See one transcript become five language versions

The same clip transcribed, translated and voiced in English, French, German, Portuguese and Spanish, with the original background audio intact.
EN flag
En
FR flag
Fr
DE flag
De
PT flag
Pt
ES flag
Es
Workflow

Three requests from audio file to transcript

Creating the project starts speech recognition, followed by translation and voiceover in the same run. Use the /generate endpoint after you edit the transcript.
1

Upload audio or video

Send an audio or video file as multipart form data, or post a link from YouTube, Google Drive, S3, Vimeo or any direct URL. You get a media id and the file metadata before you spend anything.

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

Create the project

Pass the media id as video_id and a target language. Add the source language or the number of speakers if you know them. Recognition starts immediately.

POST /v2/projects
3

Read the transcript

Read the transcript as soon as its segments are available, while the translated media continues processing. Download subtitle and media files when the project is complete.

GET /v2/projects/{id}/transcription
Recognition runs on complete, pre-recorded files rather than live audio. Processing time varies with file length, the number of speakers and the target language.
Built around you

Need a language or a format that is not listed? Talk to our team

A source language outside the list, a transcript format your platform expects, higher throughput or your own delivery method: our team reviews what your integration needs and the available options.

Languages and voices

Need a language outside the public catalogue? Talk to our team about your requirements and the available options.

Delivery and integration

Webhooks, push into your own queue, delivery straight to your S3, custom endpoints. Tell us how your pipeline expects to be fed.

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 uses a speech to text API for video

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. Add transcripts, captions and translated versions of recorded video as a feature of your product.

Localization and production agencies

Use the transcript with speaker labels as the first draft for your reviewers, correct segments through the API, and deliver subtitles, translations and dubbed versions from the same project.

In-house continuous video production

International retail and e-commerce, global franchises, media publishers, corporate universities. Transcribe recorded training, webinars and interviews, then publish captions and language versions for every market.
Customer stories

Real teams, measurable results

How companies localize video with Rask, in their own numbers.
arrow
arrow
Code

Speech to text API code examples

One complete example in each language: upload an audio or video file, create the project, wait, then read the transcript segments with speakers and timestamps.
# 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 is the official SDK. The Node, PHP and cURL tabs are plain HTTP examples against the same endpoints.
Progress

How a transcription project reports progress

Transcription is the first stage of a project with documented statuses, so you can show real progress on long recordings. You only need to act on three groups.

Success, stop here

merging_done
The final media and subtitle files are ready. The transcript can be read earlier, as soon as its segments are available.

In progress, keep polling

created
uploading
transcription_started
separate_background_started
determine_speakers_started
translation_started
voiceover_started
merging_started
Plus the matching _done states. These map cleanly onto a staged progress UI.

Failure, stop and report

failed
upload_failed
transcription_failed
translation_failed
voiceover_failed
merging_failed
no_audio
no_words
forbidden_link
no_audio, no_words and forbidden_link are specific enough to show directly to your own user.
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"}}
]}

Or skip polling entirely

Point us at a webhook endpoint and every state transition arrives as a POST, so your queue reacts to each change the moment it happens. Webhook delivery is part of enterprise onboarding.
Read the docs
preserveAspectRatio="xMidYMid meet" aria-hidden="true" role="img">
Output

Transcript segments, subtitles and translated media

Read the transcript as JSON segments from the transcription endpoint. The finished project also exposes subtitle files in SRT and VTT in the target language, the translated video and, on eligible plans, the translated speech as a separate WAV track.
Field
Format
What it is
segments
JSON
Transcript: source text, translation, speaker label, start and end time for each segment
voiceover
WAV
Translated speech only, no background, on eligible plans
translated_audio
WAV
Translated speech mixed with the original background audio
translation_srt_path
.srt
Subtitles in the target language, timed to the segments
translation_vtt_path
.vtt
Same subtitles as WebVTT, for web players
translated_video
MP4
The translated video with voiceover
Control

Correct the transcript segment by segment

Speech recognition gives you the first draft. Correct a word, a timestamp or a speaker label with one request per segment, then regenerate the translated version. Regeneration is billed on 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 to the final transcript is one patch request.
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
When the transcript is translated, a glossary keeps brand names, proper nouns and domain terms the same in every version, or 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

Transcribe audio files such as podcasts, interviews and recorded calls, or video in any supported format, or send a URL. Post an unsupported file and the API rejects it 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 of audio or video.
Security and compliance

Enterprise grade security for audio and speech data

Brask Inc holds SOC 2 Type II and operates under GDPR, and publishes live control status in its Trust Center, so recordings and transcripts are handled under audited controls.

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
OAuth 2.0 client credentials

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 API vs a speech to text API plus your own pipeline

A speech to text API turns audio into text. When that text has to become subtitles, translations and dubbed versions, the rest is pipeline work. Here is the same result, assembled two ways.
What you need
Rask API
Assembled from parts
A transcript with speaker labels
Included
Included in most speech to text APIs
Timestamps
Per segment
Per word in many speech to text APIs
Translation of the transcript
Same project, 135+ language and regional options
A separate translation API
Subtitles in .srt and .vtt
Included, in the target language
Built from your own timing data
Dubbed audio and video
Included
A TTS vendor plus your own mixing
Correcting a segment
One patch request, then regenerate
Edit and re-sync your own copies
Rate limits
None
Whatever your provider enforces
Real-time transcription of live audio
Use a streaming speech to text API
Built for it
A transcript alone, at the lowest price
A dedicated speech to text API costs less
Priced per hour of audio
FAQ

Speech to text API: common questions

Can't find what you're looking for? Contact sales.

Does Rask have a speech to text API?

Which languages can it transcribe?

Can I transcribe audio files without video?

Does it support speaker diarization?

Does the API return word level timestamps?

Does it support real-time transcription?

How accurate is the transcription?

Can I add custom vocabulary or domain terms?

Can I get the transcript as an SRT file?

Can I bring my own transcript?

How is transcription billed?

Is there a free tier?

How do I get API access and an API key?

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.