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. Zero setup — no API key required. 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://…/file.mp3"] }
Cost	$0.010/min zero-setup · $0.004/min BYOK · $0.00005/run start
Output	Dataset rows with type: "transcript" or type: "error"

Call it (MCP / API / schedule)

MCP (agents)

{
  "actor": "kaz_kakyo/audio-transcriber",
  "input": {
    "audioUrls": ["https://example.com/interview.mp3"]
  }
}

Optional extras agents usually want:

{
  "audioUrls": ["https://example.com/interview.mp3"],
  "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. The run fails only on missing API key or upstream speech-to-text auth/credit errors.

API / apify-client

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://example.com/interview.mp3'], diarize: true },
  { maxTotalChargeUsd: 1.0 }, // hard budget for this run
);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
const transcripts = items.filter((i) => i.type === 'transcript');

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

Make it recurring (what sticky callers do)

One-shot trials convert to spend when the same input path runs again without a human:

1. Save a Task in Console with your fixed options (diarize, summarize, language, BYOK key). Agents and cron jobs call the task id, not ad-hoc input.
2. Schedule the Task (hourly/daily) when URLs are stable — e.g. overnight meeting exports, or a podcast enclosure list you refresh elsewhere.
3. Webhook on SUCCEEDED to your endpoint / Zapier / Make — pull defaultDatasetId and process only type === "transcript" rows.
4. Cap spend on every automated run with maxTotalChargeUsd (platform run option). When the cap hits, remaining files become type: "error" skipped rows — no surprise bill, no silent free transcripts.
5. Chain: any scraper/RSS actor that outputs media file URLs → this actor. Drive/Dropbox share links and Apple Podcasts episode links resolve automatically; other page links (YouTube, Spotify, SoundCloud, Vimeo) fail preflight — download/resolve those to a file URL first.

Long runs checkpoint finished URLs — a platform migration resumes without re-billing completed files.

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://example.com/interview.mp3",
  "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

• Cheapest managed speech-to-text on Apify. Zero-setup $0.01/min ($0.60/h). BYOK $0.004/min actor fee + provider wholesale $0.0043/min ($0.50/h all-in). Typical Store incumbents: ~$0.015–$0.030/min.
• Nova-3 by default — or nova-2 / whisper-large. Diarization, SRT, summaries, keyterm boosting.
• HTTP-only. The speech-to-text service fetches your URL; the actor does not download media, so no proxy/compute surcharge.
• Batch-safe for agents. Bad links become type: "error" rows; URL/decode mistakes do not fail the run — only auth/credit problems do.

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	Per run

Minutes round up per file. 90 s → 2 min → $0.02 zero-setup. 1 h meeting → $0.60 zero-setup, ~$0.50 all-in BYOK.

BYOK pays for itself quickly on recurring volume.

Input rules agents must follow

• audioUrls (required) — direct https links to files (mp3, wav, m4a, flac, ogg, opus, mp4, mov, webm, mkv, ≤2 GB). 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.
• 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, concurrency 4 (2 for Whisper). Silent audio that decodes is still billed by duration.

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? The actor never downloads or stores media — the speech-to-text service fetches the URL; only transcript JSON lands in your dataset.

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

Each run records one anonymous event: a salted hash of the caller account ID (never the raw ID), run origin (Console / API / MCP / …), and a timestamp. No inputs, results, or personal data — adoption measurement only.