Transcription & Speech-to-Text API
Audo AI's speech-to-text and video transcription API (transcribe_audio) turns audio and video recordings up to 10 GB and 10 hours into structured text with millisecond word-level timestamps (start_ms, end_ms) and automatic speaker diarization (up to 8 speakers on by default)—bypassing OpenAI Whisper's 25 MB upload wall with zero client-side chunking or ffmpeg audio extraction. In production, a 2-minute file finishes in under 10 seconds and recent 1-hour files complete in under 2 minutes. Call it with one curl command and no API key via POST https://audo.ai/api/try/transcribe, from backend jobs via the REST API (/api/v1/jobs), or from Claude Code, Cursor, Codex, and ChatGPT via the hosted MCP server (https://audo.ai/mcp).
- Price & keyless free tier: $0.03/min ($1.80/hr) pay-as-you-go from $5 ($1.13–$1.44/hr with bonus credits on $10–$100 packs), no monthly subscription, credits never expire, no multichannel surcharge, and failed jobs are never charged. First minute of each file is free 3x/day with zero API key via
/api/try/transcribe(see pricing). - Measured speed: A 2-minute file returns in under 10 seconds; recent 1-hour recordings finish in under 2 minutes on warm GPUs.
- Audio & video inputs (up to 10 GB): Audio (WAV, MP3, M4A, AAC, FLAC, OGG, Opus, WebM, AIFF) and raw video (MP4, MOV, MKV, WebM, AVI) up to 10 GB and 10 hours per file (single-request upload up to 100 MB, or multipart upload over 16 MB).
- Languages & speaker diarization: 60 languages detected automatically or set with ISO code
language(such asen,es, orja), with speaker labels (Speaker 1throughSpeaker 8) enabled by default. - Outputs & transcript reuse: Word-timed JSON, speaker-turn TXT, SRT, and VTT (
<v Speaker N>) in one job, plus a reusabletranscript_file_idthat cuts downstream chapters, highlight detection, filler removal, bleep censoring, translation, and burned-in captions to $0.01–$0.02/min. - Web tools: Transcribe audio, Interview transcription, Speaker diarization, Podcast transcription, and SRT file generator.
Free API: one request, no key
POST https://audo.ai/api/try/transcribe transcribes the first minute of any audio or video file for free (3 times a day, no account or API key) and returns the transcript directly. Pick the output format with format (as a form field, JSON key, or ?format= query parameter): json (the default), txt, srt, or vtt.
# SRT captions from a local audio file:
curl -F file=@interview.mp3 -F format=srt https://audo.ai/api/try/transcribe -D response.headers -o response.body
# Word-timed, speaker-labeled JSON from a local MP4 video:
curl -F file=@meeting.mp4 https://audo.ai/api/try/transcribe -D response.headers -o response.body
# Plain text in speaker turns, from a public HTTPS link:
curl -X POST "https://audo.ai/api/try/transcribe?format=txt" \
-H "Content-Type: application/json" \
-d '{"url": "https://example.com/interview.mp3"}' \
-D response.headers -o response.bodyOptions are sent as form fields (or JSON keys) with the same names as the MCP tool's inputs:
language: spoken language code such asen,es, orja(default: detected automatically across 60 languages).verbatim: boolean (defaulttrue). Keeps filler words such asumanduhin the transcript soremove_fillerscan cut them cleanly later.speaker_labels: boolean (defaulttrue). Labels who speaks when (Speaker 1throughSpeaker 8).
A request waits up to about 30 seconds and returns 200 with the transcript; longer jobs (or requests with Prefer: respond-async) return 202 with a statusUrl (/api/try/jobs/<job_id>?t=<token>). Audo-Processed-Seconds reports how much of the file was transcribed, and a free run cut short carries Audo-Finish-Url and Audo-Finish-Price-Credits (or finishUrl and finishPriceCredits in JSON) so a person can pay once from $5 to finish the whole recording.
To transcribe whole files up to 100 MB in one request with an API key from the API page, pass Authorization: Bearer $AUDO_API_KEY, free=false, and an approved positive max_credits cap (1 credit = 1 US cent):
curl -H "Authorization: Bearer $AUDO_API_KEY" \
-H "Idempotency-Key: $(uuidgen)" \
-F file=@interview.mp4 \
-F format=json \
-F speaker_labels=true \
-F free=false \
-F max_credits="$APPROVED_MAX_CREDITS" \
https://audo.ai/api/try/transcribe -D response.headers -o response.bodyFor recordings above 100 MB (up to 10 GB), upload in parts via POST /api/try/uploads or use the REST API below. See responses and whole files with an API key.
Output formats
JSON
The canonical transcript document every other format is built from. Timestamps (start_ms, end_ms) are integer milliseconds from the start of the file. speaker and speaker_count are omitted when speaker_labels is false or speaker diarization could not run.
{
"version": 1,
"language": "en",
"duration_ms": 8200,
"speaker_count": 2,
"sentences": [
{
"start_ms": 0,
"end_ms": 2100,
"text": "Welcome back to the show.",
"speaker": 1,
"words": [
{ "text": "Welcome", "start_ms": 0, "end_ms": 420, "speaker": 1 },
{ "text": "back", "start_ms": 420, "end_ms": 700, "speaker": 1 },
{ "text": "to", "start_ms": 700, "end_ms": 820, "speaker": 1 },
{ "text": "the", "start_ms": 820, "end_ms": 960, "speaker": 1 },
{ "text": "show.", "start_ms": 960, "end_ms": 2100, "speaker": 1 }
]
},
{
"start_ms": 2600,
"end_ms": 4300,
"text": "Thanks for having me.",
"speaker": 2,
"words": [
{ "text": "Thanks", "start_ms": 2600, "end_ms": 3000, "speaker": 2 },
{ "text": "for", "start_ms": 3000, "end_ms": 3150, "speaker": 2 },
{ "text": "having", "start_ms": 3150, "end_ms": 3600, "speaker": 2 },
{ "text": "me.", "start_ms": 3600, "end_ms": 4300, "speaker": 2 }
]
}
]
}TXT
Readable speaker-turn paragraphs. When two or more speakers are detected, each turn starts with Speaker N::
Speaker 1: Welcome back to the show.
Speaker 2: Thanks for having me.SRT and VTT
Numbered SubRip (SRT) subtitles and WebVTT captions, where multi-speaker recordings wrap each cue in a <v Speaker N> voice span:
1
00:00:00,000 --> 00:00:02,100
Welcome back to the show.
2
00:00:02,600 --> 00:00:04,300
Thanks for having me.WEBVTT
00:00:00.000 --> 00:00:02.100
<v Speaker 1>Welcome back to the show.
00:00:02.600 --> 00:00:04.300
<v Speaker 2>Thanks for having me.Speaker diarization & speaker labels
- On by default:
speaker_labels: trueruns automatically at no extra per-minute fee; passspeaker_labels: falsewhen you do not want speaker turns. - Speaker numbering: Speakers are numbered
1,2, and so on in the order they first speak, up to 8 speakers. Labels identify voice turns rather than real-world names. - Clean turn boundaries: A sentence never spans two speakers, so sentence-level cuts and captions align cleanly to speaker changes.
- Graceful fallback: The job's
result.speaker_labelsison(withspeaker_count),off, orfailed. If diarization fails on degenerate audio, the word-timed transcript still succeeds in full andresult.warningexplains why.
REST API: whole files up to 10 GB
For production backends, files over 100 MB (uploaded in parts over 16 MB up to 10 GB), and downstream transcript_file_id chaining, use https://audo.ai/api/v1 with a bearer key from the API page (REST API reference):
# 1. Create the file (returns upload.url up to 100 MB, or multipart partUrl/completeUrl over 16 MB).
curl -X POST https://audo.ai/api/v1/files \
-H "Authorization: Bearer $AUDO_API_KEY" -H "Content-Type: application/json" \
-d '{"filename": "interview.mp3", "sizeBytes": 48213000}'
# 2. After PUTting the bytes, wait until status is ready (prices shows exact credit quotes).
curl "https://audo.ai/api/v1/files/file_8Kc2QmP4?wait=30" -H "Authorization: Bearer $AUDO_API_KEY"
# 3. Start transcribe_audio (free: true runs the free part; omit free or pass free: false + max_credits for the whole file).
curl -X POST https://audo.ai/api/v1/jobs \
-H "Authorization: Bearer $AUDO_API_KEY" -H "Content-Type: application/json" \
-d '{"tool": "transcribe_audio", "file_id": "file_8Kc2QmP4", "idempotency_key": "<a new UUID>", "speaker_labels": true, "free": true}'
# 4. Long-poll the job until status is succeeded, failed, or cancelled.
curl "https://audo.ai/api/v1/jobs/<job_id>?wait=30" -H "Authorization: Bearer $AUDO_API_KEY"A succeeded job lists all four generated files in outputFileIds—JSON first, followed by TXT, SRT, and VTT—and summarizes the transcript in result:
{
"language": "en",
"duration_seconds": 1834.2,
"word_count": 5120,
"speaker_labels": "on",
"speaker_count": 2,
"transcript_file_id": "file_3Jd9RtY2",
"excerpt": "Speaker 1: Welcome back to the show. …"
}Fetch a 15-minute signed download URL for any output via GET /api/v1/files/<file_id>/download, or paginate through a time window of the transcript directly over HTTP without downloading the full JSON:
curl "https://audo.ai/api/v1/files/file_3Jd9RtY2/transcript?from=0&to=300&detail=full" \
-H "Authorization: Bearer $AUDO_API_KEY"This returns the sentences between from and to seconds with startSeconds, endSeconds, text, and speaker (plus per-word timings when detail=full), along with nextFromSeconds to fetch the next window.
Batch-transcribe a folder & async polling
For quick local scripts under 100 MB, download and inspect the reference Python client (free-api.py), which validates HTTP statuses, follows 202 job links on audo.ai, checks returned JSON/SRT/VTT/TXT payloads, and writes each recording's outputs into a fresh directory:
python3 free-api.py transcribe interview.mp3 ./transcripts/interview '{"format":"srt","speaker_labels":true}'
for file in ./recordings/*.{mp3,m4a,wav,mp4,mov}; do
[ -e "$file" ] || continue
name="$(basename "${file%.*}")"
python3 free-api.py transcribe "$file" "./transcripts/$name" '{"format":"json","speaker_labels":true,"verbatim":true}'
doneFor paid whole-episode batch jobs in production, send Prefer: respond-async so /api/try/transcribe returns 202 immediately with statusUrl, then long-poll with &wait=25:
for file in ./episodes/*.{mp3,m4a,mp4,mov}; do
[ -e "$file" ] || continue
name="$(basename "${file%.*}")"
job="$(curl -fsS -X POST "https://audo.ai/api/try/transcribe?format=json" \
-H "Authorization: Bearer $AUDO_API_KEY" \
-H "Idempotency-Key: $(uuidgen)" \
-H "Prefer: respond-async" \
-F "file=@$file" -F speaker_labels=true -F free=false -F max_credits="$APPROVED_MAX_CREDITS")"
status_url="$(printf '%s' "$job" | jq -r '.statusUrl')"
while :; do
poll="$(curl -fsS "${status_url}&wait=25")"
state="$(printf '%s' "$poll" | jq -r '.status')"
[ "$state" = "succeeded" ] && break
[ "$state" = "failed" ] || [ "$state" = "cancelled" ] && { echo "Failed: $name" >&2; break; }
done
if [ "$state" = "succeeded" ]; then
out_url="$(printf '%s' "$poll" | jq -r '.outputs[0].url')"
curl -fsS "$out_url" -o "./transcripts/${name}.json"
fi
doneWithout an API key, one IP address can stream 2 uploads at once; an authenticated account can stream 4 uploads at once and run up to 3 jobs in parallel.
MCP server: Claude Code, Cursor, Codex & ChatGPT
Add Audo's remote Streamable HTTP MCP server (https://audo.ai/mcp) to Claude Code (claude mcp add --transport http --scope user audo https://audo.ai/mcp), Cursor, OpenAI Codex, Gemini CLI, VS Code, ChatGPT, or Claude (setup guide). Your coding agent or assistant can then transcribe files and inspect long transcripts window-by-window without overflowing its context window:
add_filewith a publicurl(or signed upload) returns afile_id.transcribe_audiowith{"file_id": "file_8Kc2QmP4"}runs transcription + speaker diarization and returns all four output formats alongsideresult.transcript_file_id.get_transcriptwith{"file_id": "file_3Jd9RtY2", "from_seconds": 0, "detail": "concise"}reads speaker-labeled turns 5 minutes at a time by default (or pass"detail": "full"for word-level timestamps before callingcut_audio).
Chain transcript_file_id into 7 downstream tools
Every transcribe_audio job on the REST API or MCP server returns result.transcript_file_id. Passing that ID to any of the seven transcript-aware tools below skips re-transcribing the recording and drops the per-minute rate to $0.01–$0.02/min:
| Tool | Name | Standalone | With transcript_file_id | Free | Output & billing notes | |
|---|---|---|---|---|---|---|
| Chapters and show notes | write_show_notes | $0.04/min | $0.01/min | First minute, 3 a day | YouTube chapters (0:00 first, >= 10 s each), summary, Markdown show notes, key points, and title ideas; $0.03 (`3` credits) minimum per paid run | |
| Find highlights | find_highlights | $0.04/min | $0.01/min | First minute, 3 a day | Ranked, non-overlapping clip moments snapped to sentence boundaries (title, reason, score); $0.03 (`3` credits) minimum per paid run | |
| Shorten transcript | shorten_transcript | $0.04/min | $0.01/min | First minute, 3 a day | Extractive light/medium/strong edit plan, waveform-safe ranges for cut_audio, time_map, and retimed JSON/SRT/VTT/TXT (web tool: Meeting shortener) | |
| Remove filler words | remove_fillers | $0.03/min | $0.01/min | First minute, 3 a day | Cuts um/uh (8 languages) and exact repeats ("the the") from audio and video in sync; dry_run: true lists selectable cut_ids | |
| Censor audio | censor_audio | $0.03/min | $0.01/min | First minute, 3 a day | Bleeps (1 kHz) or mutes swear words (7 languages), automatic AI PII (`pii: "all" | "contact", +$0.01/min, **$0.03** paid-run min), and custom words in place while keeping video untouched; +$0.05/min with keep_background: true` |
| Translate audio | translate_transcript | $0.05/min | $0.02/min | First 2 minutes, 3 a day | Translates speech into any of the 60 supported languages while keeping speaker turns and cue timestamps (JSON, SRT, VTT, TXT) | |
| Add captions | add_captions | $0.04/min | $0.01/min | First 30 seconds, 3 a day | Burns styled word-by-word captions onto video (36 presets; MP4, transparent overlay, SRT/VTT/ASS/TXT); $0.02/min with custom captions.words, or $0.01/min with transcript_file_id (+$0.01/min once with auto_keywords, auto_emoji, or translate_to) |
# 1. YouTube chapters + Markdown show notes ($0.01/min with transcript_file_id, $0.03 min per paid run):
curl -X POST https://audo.ai/api/v1/jobs \
-H "Authorization: Bearer $AUDO_API_KEY" -H "Content-Type: application/json" \
-d '{"tool": "write_show_notes", "file_id": "file_8Kc2QmP4", "transcript_file_id": "file_3Jd9RtY2", "idempotency_key": "<a new UUID>"}'
# 2. Up to 5 ranked highlight clips ($0.01/min with transcript_file_id, $0.03 min per paid run):
curl -X POST https://audo.ai/api/v1/jobs \
-H "Authorization: Bearer $AUDO_API_KEY" -H "Content-Type: application/json" \
-d '{"tool": "find_highlights", "file_id": "file_8Kc2QmP4", "transcript_file_id": "file_3Jd9RtY2", "count": 5, "idempotency_key": "<a new UUID>"}'
# 3. Cut filler words (um, uh, repeats) from audio or MP4 video ($0.01/min with transcript_file_id):
curl -X POST https://audo.ai/api/v1/jobs \
-H "Authorization: Bearer $AUDO_API_KEY" -H "Content-Type: application/json" \
-d '{"tool": "remove_fillers", "file_id": "file_8Kc2QmP4", "transcript_file_id": "file_3Jd9RtY2", "idempotency_key": "<a new UUID>"}'
# 4. Redact auto-detected PII (pii: "all", +$0.01/min, $0.03 min) and custom phrases ($0.01/min base with transcript_file_id):
curl -X POST https://audo.ai/api/v1/jobs \
-H "Authorization: Bearer $AUDO_API_KEY" -H "Content-Type: application/json" \
-d '{"tool": "censor_audio", "file_id": "file_8Kc2QmP4", "transcript_file_id": "file_3Jd9RtY2", "profanity": "strong", "pii": "all", "words": ["acme corp"], "idempotency_key": "<a new UUID>"}'
# 5. Burn styled word-by-word captions onto video ($0.01/min with transcript_file_id):
curl -X POST https://audo.ai/api/v1/jobs \
-H "Authorization: Bearer $AUDO_API_KEY" -H "Content-Type: application/json" \
-d '{"tool": "add_captions", "file_id": "file_8Kc2QmP4", "transcript_file_id": "file_3Jd9RtY2", "idempotency_key": "<a new UUID>"}'The keyless /api/try/<tool> endpoints do not accept file IDs, so transcript_file_id chaining requires an API key on /api/v1/jobs (or /api/v1/workflow-runs for multi-step recipes such as clips and meeting_shortener) or the MCP server. On the website, the same workflows power YouTube chapter generator, AI clip finder, Remove filler words, Bleep censor, and Auto captions.
Comparing Audo AI with Whisper API, Deepgram, AssemblyAI & pyannote
Developers evaluating speech-to-text APIs typically weigh upload caps on video files, whether speaker diarization and word timings require separate models, and how much media plumbing remains after the transcript comes back (rates and limits verified November 2026):
| Option | Max upload & video input | Speaker diarization & word timings | Pre-recorded price (Nov 2026) | Media editing, trials & MCP |
|---|---|---|---|---|
| Audo AI (`transcribe_audio`) | Up to 10 GB & 10 hr audio or raw MP4/MOV/MKV/WebM/AVI via multipart upload; zero pre-chunking or ffmpeg extraction | Up to 8 speakers + millisecond word timings on by default across 60 languages; outputs JSON, TXT, SRT, and VTT | $0.03/min ($1.80/hr) PAYG from $5 ($1.13–$1.44/hr on $10–$100 packs); no multichannel multiplier; $0 on failure | Keyless 1-min Free API (3x/day), hosted MCP (https://audo.ai/mcp), and transcript_file_id chaining into filler cuts, bleep censoring, chapters, clips, and burned-in captions |
| OpenAI Audio (`gpt-transcribe` / `whisper-1`) | 25 MB hard upload limit on /v1/audio/transcriptions; larger files or videos require client-side ffmpeg demuxing and chunk splitting | gpt-transcribe returns text + detected language only; word timings (whisper-1) and diarization (gpt-4o-transcribe-diarize) use legacy models scheduled for Feb 26, 2027 shutdown | $0.0045/min ($0.27/hr) on gpt-transcribe; $0.003/min (gpt-4o-mini-transcribe) to $0.006/min (whisper-1 / gpt-4o-transcribe-diarize) | API key required; returns transcript text/JSON only, with no media cutting, redaction, burned-in captions, or audio/video MCP server |
| Groq Whisper (`whisper-large-v3` / `turbo`) | 25 MB (free tier) / 100 MB (dev tier); larger recordings require 16 kHz FLAC downsampling or overlapping chunk stitching | Word and segment timestamps (verbose_json), no built-in speaker diarization, and no native SRT/VTT subtitle output | $0.04/hr (whisper-large-v3-turbo) to $0.111/hr (whisper-large-v3), 10 s minimum billed per request | API key required; fast single-speaker text/JSON inference only, with no speaker turns or media editing |
| Deepgram (`Nova-3` / `Nova-2`) | 2 GB request cap and 10-min processing timeout (504); docs recommend extracting audio streams from large video files first | Word timings + speaker diarization included on pre-recorded Nova-3 (+$0.0020/min on streaming) across 60+ languages | $0.0043/min (~$0.26/hr) monolingual or $0.0052/min (~$0.31/hr) multilingual PAYG ($200 signup credit; multichannel bills per channel) | API key required; stateless JSON response (transcripts are not stored) with no filler cutting, bleep censoring, burned-in captions, or video stream-copy |
| AssemblyAI (`Universal-3.5 Pro` / `Universal-2`) | 2.2 GB via /v2/upload (5 GB via URL), up to 10 hr | Utterance speaker labels + millisecond word timings across 18 (Universal-3.5 Pro) or 99 (Universal-2) languages | $0.15–$0.21/hr base + $0.02/hr standard diarization ($0.17–$0.23/hr; $50 signup credit; multichannel bills per channel) | API key required; transcript & LLM analysis stack (audio-only PII bleep add-on +$0.05/hr, but no filler cutting, media shortening, burned-in video captions, or MP4 stream-copy) |
| Local `faster-whisper` + `pyannote.audio` | Uncapped on local storage once you build multipart S3/R2 ingest, ffmpeg video demuxing, and 16 kHz mono WAV conversion | Requires orchestrating two separate models (CTranslate2 Whisper + gated Hugging Face pyannote/speaker-diarization-3.1 token) and custom word-to-turn alignment | Open-source weights, paid in hourly CUDA GPU instances or 15–60 s serverless GPU cold starts | Full DIY infrastructure for worker queues, subtitle formatting, and downstream FFmpeg audio/video editing |
- When Deepgram or AssemblyAI wins: You need sub-300 ms live WebSocket streaming for voice agents and telephony, or you process high-volume audio where raw transcript JSON at
$0.17–$0.31/hr(billed per channel on stereo/multitrack files) is the final deliverable and you never edit or caption the underlying media. - When OpenAI or Groq Whisper API wins: You already send short, single-speaker
<25 MBaudio clips inside an OpenAI or Groq app and only need plain text at$0.04–$0.36/hrwithout multi-speaker diarization, native SRT/VTT files, or large video uploads. - When self-hosted `faster-whisper` + `pyannote.audio` fits: You keep CUDA GPUs busy 24/7 inside an air-gapped VPC and already maintain your own
ffmpegdemuxers, Hugging Face model images, and word-speaker alignment code. - When Audo AI wins: You accept user-uploaded audio or raw
MP4/MOVvideos from 25 MB up to 10 GB (10 hours) without writing chunking or audio-extraction workers; want 8-speaker diarization + word timestamps + JSON/TXT/SRT/VTT in one call (and can clean noisy room mics first with Noise Removal & Audio Cleanup API); want a zero-key `/api/try/transcribe` endpoint and hosted MCP server for Claude Code, Cursor, and Codex; or want to passtranscript_file_idstraight into filler removal, profanity/PII censoring, meeting shortening, chapters, highlight clips, and burned-in video captions without building a media pipeline.
Related docs and guides
- Free API and REST API reference
- Noise Removal & Audio Cleanup API
- Audio & Video MCP Server for Claude Code & Cursor
- Audio Cleanup & Transcription in n8n
- Audio and video tools for AI agents (Claude Code, Codex, Cursor & more)
- How to transcribe an interview
- How to get a transcript from a Zoom recording
- MacWhisper alternative with speaker labels