Audio Transcriber — Fast, Accurate Speech-to-Text

URL in → transcript out. Pass direct audio/video file URLs; get one JSON dataset row per file. Google Drive / Dropbox share links and Apple Podcasts episode links are resolved to the media file automatically. No separate speech-to-text account required. API callers still need an Apify API token. Built for MCP agents, API clients, and scheduled pipelines (that is how almost all usage runs today).

Actor id	kaz_kakyo/audio-transcriber
Minimal input	{ "audioUrls": ["https://dpgr.am/spacewalk.wav"] }
Cost	$0.010/min zero-setup · $0.004/min BYOK · $0.00005 base start event (scales with memory)
Output	Dataset rows with type: "transcript" or type: "error"

Call it (MCP / API / schedule)

MCP (agents)

{
  "actor": "kaz_kakyo/audio-transcriber",
  "input": {
    "audioUrls": ["https://dpgr.am/spacewalk.wav"]
  }
}

Optional extras agents usually want:

{
  "audioUrls": ["https://dpgr.am/spacewalk.wav"],
  "diarize": true,
  "summarize": true,
  "includeSrt": true
}

After the run, read the default dataset. Every row has a type discriminator — filter on "transcript"; treat "error" as per-file failure. Bad/unsupported URLs become error rows and the run still SUCCEEDS (including all-failed batches) so agent mistakes do not look like platform outages. Missing provider credentials, upstream auth/credit errors, or a failure to save output after charging can fail the run.

API / apify-client

Install apify-client and set APIFY_TOKEN in your environment. This public 26-second sample should return one transcript, billed as one minute: $0.010 for transcription, plus the memory-scaled start event, with optional chapters off. Runs default to 4096 MiB; 2048 MiB also works for zero-setup files up to 1 GiB. It has one speaker; use your own permitted interview to try multiple-speaker labels.

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('kaz_kakyo/audio-transcriber').call(
  { audioUrls: ['https://dpgr.am/spacewalk.wav'], diarize: true },
  { maxTotalChargeUsd: 1.0, memory: 4096 }, // hard budget for this run
);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
const transcripts = items.filter((i) => i.type === 'transcript');
const errors = items.filter((i) => i.type !== 'transcript');
console.log({ runId: run.id, transcripts, errors });

Same shape via REST: POST /v2/acts/kaz_kakyo~audio-transcriber/runs with your token, then poll or attach a webhook.

Process new recordings repeatedly

Use a saved Task for fixed options, and pass new media URLs from your CMS, RSS feed or file uploader. A new run can transcribe and bill the same URL again; scheduling a fixed list does not provide cross-run deduplication.

1. Record a stable source ID and the Apify run ID in a durable ledger before retrying uncertain work.
2. Set maxTotalChargeUsd on every run. This caps each run, not monthly spending or all retries combined.
3. Read every dataset row. Save transcripts and route error/skip rows to a review destination. Also handle FAILED/TIMED-OUT runs.
4. If a request times out, inspect the existing run and dataset before starting another paid run.

Long runs checkpoint completed URLs for migration/resume within the same run. This is not an across-run ledger.

Podcast transcription guide and n8n starter — runnable API example, cost calculations, and explicit replay/restart limits.

For actor developers — use this as your transcription backend

Building an actor that touches audio or video (podcast tools, meeting pipelines, media scrapers)? Call this actor from yours instead of integrating a speech-to-text vendor: no key to manage, no audio handling, and your user's account pays the per-minute event directly — you never proxy the cost.

import { Actor } from 'apify';

const run = await Actor.call(
  'kaz_kakyo/audio-transcriber',
  { audioUrls: mediaUrls, diarize: true },
  { maxTotalChargeUsd: 2.0 },
);
const { items } = await Actor.apifyClient.dataset(run.defaultDatasetId).listItems();
const transcripts = items.filter((i) => i.type === 'transcript');

Contract stability promise: the input fields and the type: "transcript" | "error" output shape documented on this page are a frozen public contract — fields are only ever added, never renamed or removed, so a nested integration does not break on our releases. Batch-safe by design: your users' bad URLs come back as error rows, never as a failed run inside your actor.

Output contract

One dataset item per input URL (plus skipped/invalid rows). Success shape:

{
  "type": "transcript",
  "url": "https://dpgr.am/spacewalk.wav",
  "transcript": "Full smart-formatted text…",
  "durationSeconds": 204.3,
  "minutesBilled": 4,
  "model": "nova-3",
  "language": "en",
  "confidence": 0.97,
  "summary": "…",
  "speakerTranscript": "Speaker 0: …\nSpeaker 1: …",
  "srt": "1\n00:00:00,000 --> …",
  "utterances": [{ "start": 0.0, "end": 3.2, "speaker": 0, "text": "…" }],
  "words": [{ "word": "Hello", "start": 0.0, "end": 0.4, "confidence": 0.99, "speaker": 0 }]
}

Field	When present
transcript, durationSeconds, minutesBilled, language, confidence, model	always on success
summary	summarize: true (English audio)
speakerTranscript	diarize: true
srt	includeSrt: true
utterances / words	respective toggles
resolvedUrl	input was a share/episode link — the direct media URL actually transcribed (url stays your input)
wordsUrl / utterancesUrl / srtUrl	rare — oversized payloads spilled to the key-value store

Failure / skip row (never charged):

{ "type": "error", "url": "https://…", "error": "…" }

Download the dataset as JSON, CSV, Excel, or HTML from Console or the dataset API.

Why this one

• Two pricing options. Managed transcription is $0.01/min; BYOK is $0.004/min actor fee plus your own provider bill. Both add the start event.
• Nova-3 by default — or nova-2 / whisper-large. Diarization, SRT, summaries, keyterm boosting.
• Guarded local checks. Zero-setup runs download and decode media before provider processing. BYOK sends the URL to the provider.
• Batch-safe for agents. Bad links become type: "error" rows; URL/decode mistakes do not fail the run — inspect run failures separately from per-file errors.

Related actors

• YouTube Transcripts: captions and SRT from YouTube videos and channels, no audio upload needed.
• Media URL Transcriber: Vimeo, Loom and podcast RSS URLs to text.

Pricing

Event	Price	When
Audio minute (zero-setup)	$0.010	No key — transcription included
Audio minute (BYOK)	$0.004	deepgramApiKey set — you pay your provider at cost
Actor start	$0.00005 base	Once per run; units scale with memory above 1 GB

Minutes round up per file. With optional chapters off, 90 seconds costs $0.020 in managed minute charges; a 60-minute recording costs $0.600 managed, or $0.240 actor minute fees plus your own provider bill with BYOK. Add the memory-scaled start charge. Splitting a recording into files can increase rounded minutes.

Free Apify plan: zero-setup transcription needs a paid Apify plan. On a free plan, each file returns an uncharged free-plan error row and the run still succeeds; set deepgramApiKey to transcribe at the BYOK rate.

Optional chapter generation adds $0.01 per generated chapter set plus your own LLM usage. Start-event pricing can scale with run memory; check the Pricing tab for your settings. BYOK savings depend on your provider plan.

Input rules agents must follow

• audioUrls (required) — direct https links to files (mp3, wav, m4a, flac, ogg, opus, mp4, mov, webm, mkv; ≤2 GiB at the default 4096 MiB memory, ≤1 GiB at 2048 MiB). Google Drive / Dropbox share links and Apple Podcasts episode links (the URL with ?i=…) are resolved to the file automatically. Not YouTube / TikTok / Spotify / SoundCloud / Vimeo page URLs — those cannot be resolved. For YouTube captions use kaz_kakyo/youtube-transcripts; for TikTok use kaz_kakyo/tiktok-transcripts.
• deepgramApiKey — optional; encrypted; sent only to the transcription provider.
• model — nova-3 (default), nova-2, whisper-large.
• language / detectLanguage — BCP-47 or auto-detect; multi + nova-3 for code-switching.
• Toggles — diarize, smartFormat, paragraphs, summarize, includeSrt, includeUtterances, includeWords (see Input tab).
• keyterms — nova-3 only; boost product names / jargon / speaker names.

Limits: 500 files/run, ~10 min upstream processing per file, at most 4 concurrent provider jobs (2 for Whisper). Zero-setup files are checked before paid processing: the full decoded audio must fit the run budget, six hours, and the decoded-audio limit (1 GiB at 2048 MiB memory, about 4.6 hours of stereo or the full six hours of mono; 2 GiB at 4096 MiB or more). Oversized files are rejected rather than partially transcribed. Silent audio that decodes is still billed by duration.

Zero-setup processing also needs enough disk for each complete input and its decoded audio. Apify allocates disk at twice run memory, and 1 GiB is kept for the runtime. Below 4096 MiB each active file reserves 2 GiB (downloads and decoded audio up to 1 GiB each), so 2048 MiB admits one file at a time. At 4096 MiB or more each file reserves 4 GiB (up to 2 GiB each): 4096 MiB admits one file, 8192 MiB three and 16384 MiB four (subject to the model cap). A file over the 2048 MiB limits returns an uncharged insufficient-resources error that names 4096 MiB, and stays eligible when the run is resurrected with more memory. Allocations that cannot cover one file (below 2048 MiB) return the same uncharged error before downloading or decoding. Waiting jobs recheck the monetary budget. BYOK URL processing retains its existing path.

Default memory: runs default to 4096 MiB, the fastest setting for long files: a 53-minute podcast took about 22 s at 4096 MiB and 36–66 s at 2048 MiB, at similar compute cost. If you set memory yourself (API memory, a saved task or a schedule), 2048 MiB also works for zero-setup files up to 1 GiB (larger files return an uncharged insufficient-resources error naming 4096 MiB), and 8192 MiB or more processes several files in parallel. Below 2048 MiB zero-setup files return the uncharged insufficient-resources error. BYOK runs work with less memory. At 4096 MiB the start event counts as four units ($0.0002 per run).

See the Input tab for the full schema. See the API tab for run/dataset endpoints.

FAQ

Do I need my own speech-to-text account? No. Bring a key only for the $0.004/min rate.

What languages? Nova-3: 30+. whisper-large: 90+ for rarer languages.

Is my audio stored? Zero-setup runs temporarily download and decode media on the worker to check its duration and budget, then delete those temporary files. Source audio is not published to the dataset or key-value store. BYOK runs send the media URL to the speech-to-text service. Transcript JSON and oversized transcript fields are retained in your run outputs.

Why did my URL fail? It was not a direct, publicly reachable (or signed) media file, and not a resolvable share link (Drive/Dropbox/Apple Podcasts episode). Resolve other page URLs with a downloader first, then call this actor. The run still succeeds with type: "error" rows — check the dataset, not the run status. (Drive note: files past ~100 MB hit Drive's virus-scan page — host very large files elsewhere or use a signed URL.)

How do I keep costs predictable on a schedule? Set maxTotalChargeUsd on the run/task. Prefer BYOK once volume is steady.

---

If this saved you time, a Store review on the actor page helps a solo dev. Hit a problem? Open an issue.

Telemetry

When telemetry is configured, the actor sends usage and charge-summary events to the developer: a pseudonymous caller hash, paying-plan flag, run ID, origin, timestamps and event counts, plus how many inputs were YouTube or TikTok page links (counts only), and a per-run workflow summary: counts of input link types (direct file, Google Drive, Dropbox, Apple Podcasts, web-page link, invalid), transcript lengths in broad buckets (under 5 min, 5–30, 30–120, over 120), batch size bucket, which on/off options were used, whether the language was English or another language, and the memory tier. No media URLs, hostnames, file names, input content or transcripts are included.