Skip to content
audo

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 as en, es, or ja), with speaker labels (Speaker 1 through Speaker 8) enabled by default.
  • Outputs & transcript reuse: Word-timed JSON, speaker-turn TXT, SRT, and VTT (<v Speaker N>) in one job, plus a reusable transcript_file_id that 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.

Terminal
# 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.body

Options are sent as form fields (or JSON keys) with the same names as the MCP tool's inputs:

  • language: spoken language code such as en, es, or ja (default: detected automatically across 60 languages).
  • verbatim: boolean (default true). Keeps filler words such as um and uh in the transcript so remove_fillers can cut them cleanly later.
  • speaker_labels: boolean (default true). Labels who speaks when (Speaker 1 through Speaker 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):

Terminal
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.body

For 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.

JSON
{
  "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::

TEXT
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:

TEXT
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.
TEXT
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: true runs automatically at no extra per-minute fee; pass speaker_labels: false when 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_labels is on (with speaker_count), off, or failed. If diarization fails on degenerate audio, the word-timed transcript still succeeds in full and result.warning explains 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):

Terminal
# 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:

JSON
{
  "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:

Terminal
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:

Terminal
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}'
done

For 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:

Terminal
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
done

Without 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:

  1. add_file with a public url (or signed upload) returns a file_id.
  2. transcribe_audio with {"file_id": "file_8Kc2QmP4"} runs transcription + speaker diarization and returns all four output formats alongside result.transcript_file_id.
  3. get_transcript with {"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 calling cut_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:

ToolNameStandaloneWith transcript_file_idFreeOutput & billing notes
Chapters and show noteswrite_show_notes$0.04/min$0.01/minFirst minute, 3 a dayYouTube 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 highlightsfind_highlights$0.04/min$0.01/minFirst minute, 3 a dayRanked, non-overlapping clip moments snapped to sentence boundaries (title, reason, score); $0.03 (`3` credits) minimum per paid run
Shorten transcriptshorten_transcript$0.04/min$0.01/minFirst minute, 3 a dayExtractive 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 wordsremove_fillers$0.03/min$0.01/minFirst minute, 3 a dayCuts um/uh (8 languages) and exact repeats ("the the") from audio and video in sync; dry_run: true lists selectable cut_ids
Censor audiocensor_audio$0.03/min$0.01/minFirst minute, 3 a dayBleeps (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 audiotranslate_transcript$0.05/min$0.02/minFirst 2 minutes, 3 a dayTranslates speech into any of the 60 supported languages while keeping speaker turns and cue timestamps (JSON, SRT, VTT, TXT)
Add captionsadd_captions$0.04/min$0.01/minFirst 30 seconds, 3 a dayBurns 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)
Terminal
# 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):

OptionMax upload & video inputSpeaker diarization & word timingsPre-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 extractionUp 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 failureKeyless 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 splittinggpt-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 stitchingWord 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 requestAPI 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 firstWord 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 hrUtterance 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 conversionRequires orchestrating two separate models (CTranslate2 Whisper + gated Hugging Face pyannote/speaker-diarization-3.1 token) and custom word-to-turn alignmentOpen-source weights, paid in hourly CUDA GPU instances or 15–60 s serverless GPU cold startsFull 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 MB audio clips inside an OpenAI or Groq app and only need plain text at $0.04–$0.36/hr without 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 ffmpeg demuxers, Hugging Face model images, and word-speaker alignment code.
  • When Audo AI wins: You accept user-uploaded audio or raw MP4/MOV videos 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 pass transcript_file_id straight into filler removal, profanity/PII censoring, meeting shortening, chapters, highlight clips, and burned-in video captions without building a media pipeline.

This page as Markdown