Audio Speech-to-Text Transcriber

Convert speech in public audio and video files into transcript text, detected language, timestamped segments, and optional SRT/VTT subtitle files.

The Actor runs an open-source Whisper model inside the Apify container. It does not require an OpenAI, Deepgram, or other transcription API key.

Use it for podcast notes, interview research, accessibility captions, searchable media archives, or content-repurposing pipelines.

What does Audio Speech-to-Text Transcriber do?

For every submitted direct media URL, the Actor:

1. Validates that the URL and redirects resolve to public network addresses.
2. Streams the file to bounded temporary storage.
3. Uses ffprobe to measure its duration.
4. Runs local Whisper speech recognition on CPU.
5. Produces complete text and timestamped segments.
6. Optionally saves SRT and VTT subtitle artifacts.
7. Removes temporary media before the run exits.

The default dataset receives one record per URL. A successful record contains the transcript. A failed URL produces an uncharged error record so batch users can see exactly what needs attention.

If every submitted URL fails, the run exits with a failure status.

Who is it for?

• Podcast and media teams transcribing each new public recording.
• Researchers and journalists turning interviews or archives into searchable text.
• Accessibility teams generating a first-pass caption file for human review.
• Content teams feeding transcript text into summaries, articles, clips, or translations.
• Developers and data engineers adding repeatable speech recognition to scheduled Apify workflows.
• Archivists indexing public recordings that do not already have captions.

This Actor performs speech recognition. If a supported social video already has a published caption track and you only need to extract it, use Video Transcript Scraper instead.

Why use local speech recognition?

• No third-party transcription credential is needed.
• Media is not submitted to a separate paid transcription API.
• Input, output, limits, and errors have a stable machine-readable contract.
• Direct URLs can be processed in scheduled batches.
• Subtitle artifacts are available alongside normal dataset output.
• Charging begins only after the first useful transcription succeeds.

The bundled model is optimized for bounded CPU use rather than maximum accuracy. Review important transcripts before publication or compliance use.

Supported input media

Provide direct, anonymously downloadable HTTP or HTTPS audio/video file URLs.

Common containers and codecs supported by FFmpeg/PyAV can work, including WAV, MP3, M4A, FLAC, MP4, WebM, and similar formats.

The URL must point to media bytes. A web page, podcast landing page, YouTube watch page, TikTok post, cloud drive preview, or authenticated download is not a direct media URL.

The Actor intentionally does not use a browser, proxy, account login, social downloader, or paid speech API.

Input parameters

Field	Type	Default	Description
mediaUrls	array	required	One to ten direct public media URLs.
language	string	auto	Automatic detection or a code such as en, es, de, or pt-BR.
outputFormats	array	srt, vtt	Optional subtitle artifacts. Use an empty array for dataset-only output.
maxFileSizeMb	integer	250	Per-file download limit, from 1 through 500 MB.
maxDurationMinutes	integer	60	Per-file duration limit, from 1 through 180 minutes.

Language hints can improve speed or reliability when you already know the spoken language. Regional suffixes are accepted; inference uses the base language code.

Getting started

1. Open the Actor in Apify Console.
2. Paste one or more direct media URLs into Media URLs.
3. Leave Spoken language at auto, or provide a known language code.
4. Choose whether to create SRT and VTT files.
5. Keep the default size and duration limits for your first run.
6. Click Start.
7. Open Transcripts for dataset records.
8. Open Subtitle files for generated artifacts.

A working small input is:

{
  "mediaUrls": [
    { "url": "https://raw.githubusercontent.com/ggerganov/whisper.cpp/master/samples/jfk.wav" }
  ],
  "language": "en",
  "outputFormats": ["srt", "vtt"],
  "maxDurationMinutes": 5
}

Output fields

Field	Meaning
sourceUrl	Submitted direct media URL.
status	succeeded or failed.
transcript	Complete normalized transcript, or null on failure.
language	Detected/requested base language, or null on failure.
languageProbability	Whisper language-detection confidence.
durationSeconds	Duration measured by ffprobe when available.
segments	Ordered objects with id, start, end, and text.
srtKey	Key-value-store key for the optional SRT file.
vttKey	Key-value-store key for the optional VTT file.
model	Inference model used; currently tiny.
processedAt	ISO 8601 completion time.
processingSeconds	Wall-clock processing time for the item.
error	Bounded failure explanation, otherwise null.

Representative output from the prefilled sample:

{
  "sourceUrl": "https://raw.githubusercontent.com/ggerganov/whisper.cpp/master/samples/jfk.wav",
  "status": "succeeded",
  "transcript": "And so my fellow Americans ask not what your country can do for you ask what you can do for your country.",
  "language": "en",
  "languageProbability": 1,
  "durationSeconds": 11,
  "segments": [
    {
      "id": 0,
      "start": 0,
      "end": 11,
      "text": "And so my fellow Americans ask not what your country can do for you ask what you can do for your country."
    }
  ],
  "srtKey": "TRANSCRIPT_001.SRT",
  "vttKey": "TRANSCRIPT_001.VTT",
  "model": "tiny",
  "processedAt": "2026-01-15T12:00:00.000Z",
  "processingSeconds": 4.5,
  "error": null
}

Subtitle artifacts

When requested, files use deterministic keys based on input order:

• TRANSCRIPT_001.SRT
• TRANSCRIPT_001.VTT
• TRANSCRIPT_002.SRT
• TRANSCRIPT_002.VTT

Artifact creation has no separate event charge. It is included in the successful audio-minute transcription event.

SRT uses comma millisecond separators. VTT uses dot millisecond separators and includes the WEBVTT header.

How much does it cost to transcribe audio?

Pricing is pay per event. A $0.005 start event is charged only after the first successful transcription. Each successfully transcribed started audio minute then emits one audio-minute event. A run with no successful transcription has no event charge.

On the BRONZE tier, the current audio-minute price is $0.01043 per started audio minute. Other platform tiers receive the active tiered prices shown in Console.

Examples at the BRONZE rate, including the one-time start event:

• An 11-second recording rounds to one minute: $0.01543.
• A 10-minute recording: $0.10930.
• A 60-minute recording: $0.63080.

Rounding is applied separately to each successful URL. Apify platform usage may also be subject to your account plan and the active pricing displayed before a run.

Batch and automation workflows

Podcast ingestion

Schedule a run whenever your feed pipeline discovers a new direct enclosure URL. Store transcript text in a search index and subtitle files with the episode assets.

Interview research

Submit a bounded batch, wait for the run, then export the dataset as JSON or CSV. Keep timestamps so researchers can return to the exact passage in the recording.

Accessibility review

Generate VTT, send it through a human correction step, and attach the reviewed file to the publishing system. Machine captions should be treated as a draft.

Content repurposing

Send the transcript to a summarizer, topic classifier, quotation finder, or translation Actor. Keep the source URL and timestamps for traceability.

Run with the Apify API using cURL

Replace YOUR_TOKEN with an Apify API token:

curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~audio-speech-to-text-transcriber/runs?token=YOUR_TOKEN&waitForFinish=3600" \
  -H "Content-Type: application/json" \
  -d '{
    "mediaUrls": [{"url":"https://raw.githubusercontent.com/ggerganov/whisper.cpp/master/samples/jfk.wav"}],
    "language":"en",
    "outputFormats":["vtt"]
  }'

Fetch dataset items from the defaultDatasetId returned by the run.

Run with JavaScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/audio-speech-to-text-transcriber').call({
  mediaUrls: [
    { url: 'https://raw.githubusercontent.com/ggerganov/whisper.cpp/master/samples/jfk.wav' },
  ],
  language: 'auto',
  outputFormats: ['srt', 'vtt'],
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].transcript);

Run with Python

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("automation-lab/audio-speech-to-text-transcriber").call(run_input={
    "mediaUrls": [
        {"url": "https://raw.githubusercontent.com/ggerganov/whisper.cpp/master/samples/jfk.wav"}
    ],
    "language": "en",
    "outputFormats": ["vtt"],
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items[0]["transcript"])

Use with MCP and AI agents

Add the Apify MCP server to Claude Code:

claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/audio-speech-to-text-transcriber"

Use the same JSON under Claude Desktop, Cursor, or VS Code MCP settings:

{
  "mcpServers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/audio-speech-to-text-transcriber"
    }
  }
}

Example prompts:

• “Transcribe this direct WAV URL and return the timestamped segments.”
• “Create VTT captions for these three public MP3 files.”
• “Run speech recognition in English and summarize the resulting dataset.”

Limits and performance

• Maximum 10 URLs per run.
• Maximum configurable file size is 500 MB per URL.
• Maximum configurable duration is 180 minutes per URL.
• URLs and redirects resolving to loopback, link-local, private, or reserved networks are rejected.
• Authenticated URLs and URLs containing credentials are rejected.
• CPU transcription can take longer than the source duration for difficult or long media.
• The container uses the multilingual Whisper tiny model with CPU int8 inference.
• Very noisy speech, overlapping speakers, uncommon names, music, or low-bitrate audio can reduce accuracy.
• Speaker diarization, word-level timestamps, translation, and speaker labels are not currently provided.
• Social post pages and media that require a browser, cookies, login, or expiring client-side tokens are unsupported.

Failure behavior and troubleshooting

The URL produces HTTP 403 or 404.

Confirm it is a direct anonymously downloadable file URL. Signed URLs may expire before a scheduled run starts.

The Actor says the destination is private.

Private hosts, localhost, internal object stores, and redirects into private address space are deliberately blocked. Provide a public HTTPS download URL instead.

The record says no speech was detected.

The media may contain silence, music, or speech too weak for the bundled model. Verify the file locally and try a clean speech recording.

The language is wrong.

Set language to a known code instead of auto.

The run timed out.

Use shorter files or split a long recording before submission. Keep the default 2 GB memory allocation because speech inference is memory intensive.

Only some batch items failed.

Filter the dataset by the status field. Successful items are still available and billed through the normal audio-minute event; failed records include their error and are uncharged.

Privacy, legality, and responsible use

Only submit media you are authorized to download and process. Respect copyright, privacy, consent, employment, wiretapping, biometric, and data-protection requirements that apply to the recording and its speakers.

Do not use machine transcripts as the sole basis for legal, medical, safety, employment, or other high-impact decisions. Accuracy is not guaranteed. Review sensitive transcripts and captions with a qualified person.

The Actor prevents private-network URL access, but users remain responsible for the source URL and downstream handling of transcript data.

Related Automation Lab Actors

• Video Transcript Scraper — extract existing captions from supported social video sites.
• YouTube Transcript — retrieve available YouTube transcript tracks without running speech inference.
• Vimeo Transcript Scraper — retrieve transcript/caption data from Vimeo workflows.

Choose this Actor when the input is a direct media file and speech recognition must generate the transcript.

FAQ

Does it require an OpenAI or Deepgram key?

No. Inference runs with an open-source Whisper-compatible model inside the Actor container.

Does it download YouTube, TikTok, Instagram, or podcast pages?

No. V1 accepts direct public media file URLs only. Use a suitable downloader or caption extractor first when you have a web page rather than a media URL.

Are failed files charged?

No. The start and audio-minute events are emitted only after useful transcript text and segments have been produced. Failed URLs still receive an error record for diagnosis.

How are partial minutes billed?

Each successful file is rounded up independently. A 61-second file emits two audio-minute events.

Can it identify speakers?

No. Speaker diarization is not included.

Can I create only dataset output?

Yes. Set outputFormats to an empty array.

Is the transcript publication-ready?

Treat it as a machine-generated draft. Review names, punctuation, technical terms, and sensitive content before publishing.