# Audio & Video Transcriber: Whisper Speech to Text (SRT, VTT) (`northledgertools/audio-video-transcriber`) Actor

Transcribe audio and video files, podcast RSS feeds and media pages to text with Whisper. Get plain text, timestamps, SRT, VTT and JSON. 90+ languages, auto language detection, optional translation to English. From $0.003 per minute, failed files are free.

- **URL**: https://apify.com/northledgertools/audio-video-transcriber.md
- **Developed by:** [NorthLedger Tools](https://apify.com/northledgertools) (community)
- **Categories:** AI, Videos, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 audio minute (base / distil small)s

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Audio & Video Transcriber: Whisper speech to text (TXT, SRT, VTT, JSON)

**Audio & Video Transcriber** turns spoken audio into text. Give it links to audio or video files, or a podcast RSS feed, and it returns the full transcript, timestamped segments and ready-to-use subtitle files (SRT, VTT, TXT, JSON). It runs OpenAI's Whisper model (through the fast `faster-whisper` engine) directly on Apify, so there is **no API key to bring** and no per-file minimum. You pay per minute of audio actually transcribed, and **failed files are free**.

**One call, agent-ready, from US$0.003 per audio minute.** That is the lowest per-minute price among the popular general audio/video transcribers on Apify Store (those with 50+ users start at US$0.006 per minute; checked 2026-10-26). One API or MCP call takes media URLs in and returns structured transcripts and SRT/VTT files out.

### What can this transcription tool do?

- 🎙️ **Speech to text for 90+ languages**, with automatic language detection or a language you choose.
- 🌍 **Translate to English**: turn non-English speech into an English transcript in one step.
- 🔗 **Many sources**: direct audio/video file links (MP3, M4A, WAV, FLAC, OGG, MP4, MOV, MKV, WebM...), **podcast RSS feeds** (transcribe the latest N episodes) and, best effort, media pages through yt-dlp.
- 🧾 **Every output you need**: full text, timestamped segments, optional word-level timestamps, plus `.txt`, `.srt`, `.vtt` and `.json` files saved to the key-value store.
- 🎚️ **Four models** to trade speed, price and accuracy (see below).
- 🔇 **Skips silence** with voice activity detection, which is faster and avoids invented text during silence or music.
- 📝 **Vocabulary hint**: pass names and jargon so rare words are spelled correctly.
- 💸 **Cost control**: per-file minute cap, per-run file cap and Apify's "Maximum cost per run" are all respected. If the budget runs out, the Actor stops cleanly.
- 🔒 **Safe by default**: only public http(s) URLs. Private, local and cloud-metadata addresses are refused.

### Models and pricing

Pay per event, no subscription. Billing is per **started minute of audio actually transcribed**, charged only after a transcript is produced.

| Model | Best for | Speed (4 GB run, measured) | Price per audio minute |
| --- | --- | --- | --- |
| **Base** | Clean studio audio and bulk jobs where lowest cost matters most | about 8x faster than real time | **US$0.003** |
| **Distil Small (English only)** | English with better accuracy than Base | about 4x real time | **US$0.003** |
| **Small** (default) | Good all-round accuracy, multilingual, accents, moderate noise | about 3x real time | **US$0.0075** |
| **Large v3 Turbo** | Highest accuracy, noisy audio, hard accents | about 1.3x real time | **US$0.016** |

Plus **US$0.002 per GB of memory per run** (US$0.008 at the default 4 GB) for starting the Actor. Standard Apify platform usage is included in these prices.

Default model is **Small**.

Examples:

| Job | Cost |
| --- | --- |
| One 60-minute podcast, Small (default) | about US$0.46 |
| One 60-minute podcast, Base | about US$0.19 |
| 100 files of 10 minutes each, Base | about US$3.01 |
| One 30-minute interview, Large v3 Turbo | about US$0.49 |

Failed downloads, undecodable files and silent files are never charged. Media longer than **Maximum minutes per file** is cut at that limit and only the minutes transcribed are charged.

### How to use it

1. Click **Try for free**.
2. Paste your media links (one per line). Podcast RSS feed URLs work too.
3. Pick a model and, if you know it, the language.
4. Click **Start**. Open the **Output** tab for the text and download links for TXT, SRT, VTT and JSON.

#### Example input

```json
{
    "mediaUrls": [
        "https://example.com/audio/interview.mp3",
        "https://feeds.npr.org/500005/podcast.xml"
    ],
    "model": "small",
    "language": "auto",
    "task": "transcribe",
    "outputFormats": ["txt", "srt", "vtt", "json"],
    "rssMaxEpisodes": 3,
    "wordTimestamps": false,
    "initialPrompt": "Interview about Kubernetes and PostgreSQL."
}
```

#### Example output (one dataset item per media file)

```json
{
    "url": "https://example.com/audio/interview.mp3",
    "inputUrl": "https://example.com/audio/interview.mp3",
    "title": null,
    "status": "success",
    "model": "small",
    "language": "en",
    "languageProbability": 0.98,
    "task": "transcribe",
    "durationSeconds": 311.4,
    "transcribedSeconds": 311.4,
    "truncated": false,
    "minutesCharged": 6,
    "wordCount": 810,
    "text": "This is NPR News Now. ...",
    "segments": [
        { "start": 0.0, "end": 4.6, "text": "This is NPR News Now." }
    ],
    "txtUrl": "https://api.apify.com/v2/key-value-stores/.../records/transcript-interview-3f2a9c1d.txt",
    "srtUrl": "https://api.apify.com/v2/key-value-stores/.../records/transcript-interview-3f2a9c1d.srt",
    "processingSeconds": 113.5,
    "error": null,
    "errorType": null
}
```

Failed files are still listed with `status: "failed"`, a readable `error` and an `errorType`: `INVALID_URL`, `DNS_ERROR`, `BLOCKED_URL`, `HTTP_ERROR`, `CONNECTION_ERROR`, `FILE_TOO_LARGE`, `DOWNLOAD_ERROR`, `DECODE_ERROR`, `SOURCE_BLOCKED`, `UNSUPPORTED_URL`, `FEED_ERROR`, `NO_SPEECH`, `CHARGE_LIMIT_REACHED`, `TRANSCRIPTION_ERROR`.

### Use it from AI agents, MCP and the API

The Actor is built for automation: URLs in, structured transcript out, machine-readable errors.

**Apify MCP server** (Claude, Cursor, VS Code, any MCP client): add `https://mcp.apify.com/?actors=northledgertools/audio-video-transcriber` and your agent gets a transcription tool.

**HTTP API (synchronous)**

```bash
curl -X POST "https://api.apify.com/v2/acts/northledgertools~audio-video-transcriber/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mediaUrls":["https://example.com/episode.mp3"],"model":"small"}'
```

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")
run = client.actor("northledgertools/audio-video-transcriber").call(run_input={"mediaUrls": ["https://example.com/episode.mp3"]})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["status"], item.get("text", item.get("error")))
```

**JavaScript**

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('northledgertools/audio-video-transcriber').call({ mediaUrls: ['https://example.com/episode.mp3'] });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].text);
```

It also connects to Make, Zapier, n8n, LangChain and LlamaIndex through Apify's integrations.

### Use cases

- **Podcasts and interviews**: searchable transcripts, show notes and quotes.
- **Subtitles**: SRT and VTT files for video editors and web players.
- **Meeting and call recordings**: turn recordings into text for summaries.
- **AI and RAG pipelines**: feed spoken content to LLMs, embeddings and search.
- **Research and journalism**: transcribe interviews and field recordings.
- **Accessibility and compliance**: captions for existing audio libraries.

### Tips

- **Pick the model for your audio.** Small (default) is a good all-rounder. Base is cheapest but makes more mistakes with applause, music or accents. Turbo is best for hard audio.
- **Set the language** when you know it. Automatic detection ignores a few very rare languages (for example Welsh and Latin) because Whisper often mistakes accented English for them. If your audio really is in one of those, choose the language explicitly.
- **Auto-detection** looks at speech near the start of the file only, so mixed-language files are best handled with an explicit choice.
- **Add a vocabulary hint** for names and product terms.
- **Use more memory for long files.** The Actor uses roughly one CPU core per 4 GB of memory, so 8 GB runs about twice as fast for the same cost per minute.
- **Start with a test file** and set **Maximum cost per run** before a big batch.

### Limitations

- Whisper can make mistakes with heavy accents, overlapping speakers and domain terms. There is no speaker labelling (diarization) yet.
- Media pages (YouTube, Vimeo, SoundCloud...) are handled through yt-dlp on a best-effort basis. Many sites, YouTube in particular, block downloads from cloud servers, in which case you get a `SOURCE_BLOCKED` error and are not charged. Direct file links and podcast feeds are the reliable inputs.
- Files behind logins, paywalls or expiring signed links may fail to download.
- Maximum download size is 2 GB per file.
- Only transcribe media you have the right to use, and follow the terms of the sites you take it from.

### FAQ

**Do I need an OpenAI key?** No. Whisper runs inside the Actor.

**How is the audio length counted?** The decoded audio length is rounded up to whole minutes, per file. A 61-second clip is billed as 2 minutes.

**Is my audio stored?** Files are downloaded to the run's temporary disk, deleted after each transcription, and never shared. The transcripts stay in your run's storage until your plan's retention period ends.

**Can you add a feature (diarization, summaries, more formats)?** Open a ticket in the **Issues** tab. Requests are read and answered.

# Actor input Schema

## `mediaUrls` (type: `array`):

Links to audio or video files (MP3, M4A, WAV, MP4, MOV, WebM and more), podcast RSS feeds, or media pages (best effort via yt-dlp). One transcript is produced per file. Only public http(s) URLs are allowed.

## `model` (type: `string`):

Whisper model. 'base' is the fastest and cheapest but makes more mistakes. 'small' (default) is a good balance of accuracy and price. 'distil-small.en' is English-only and about as accurate as small but much faster. 'large-v3-turbo' is the most accurate and handles accents and noisy audio best, but runs slowly on CPU.

## `language` (type: `string`):

Spoken language as a two-letter ISO code (en, es, fr, de, pt, ja, ...). Leave as 'auto' to detect it from the first 30 seconds. Setting it explicitly is slightly faster and avoids detection mistakes.

## `task` (type: `string`):

'Transcribe' writes the speech in its original language. 'Translate to English' writes an English translation of non-English speech.

## `outputFormats` (type: `array`):

Transcript files saved in the key-value store, with a direct link in each dataset item. The text and timestamped segments are always included in the dataset as well.

## `includeSegments` (type: `boolean`):

Add a 'segments' array (start, end, text) to every dataset item. Turn off for smaller items.

## `wordTimestamps` (type: `boolean`):

Add start and end times for each word inside every segment. Slower (about 20-30% longer runs).

## `skipSilence` (type: `boolean`):

Skip long silent or music-only parts. Faster and prevents invented text in silence. Turn off for very quiet speech.

## `initialPrompt` (type: `string`):

Optional. A short sentence with names, jargon or spelling you expect, e.g. 'Interview with Dr. Okonkwo about Kubernetes and PostgreSQL.' Helps with rare words.

## `maxMinutesPerFile` (type: `integer`):

Cost cap per file. Longer media is cut after this many minutes, and only the minutes transcribed are charged.

## `rssMaxEpisodes` (type: `integer`):

When a URL is a podcast RSS feed, transcribe this many of the newest episodes.

## `maxFiles` (type: `integer`):

Safety limit on the total number of media files transcribed in one run (feed episodes count individually).

## `beamSize` (type: `integer`):

Search width. 1 is fastest. Higher values (up to 5) can slightly improve accuracy on difficult audio but are slower.

## Actor input object example

```json
{
  "mediaUrls": [
    "https://example.com/podcast/episode-12.mp3"
  ],
  "model": "small",
  "language": "auto",
  "task": "transcribe",
  "outputFormats": [
    "txt",
    "srt"
  ],
  "includeSegments": true,
  "wordTimestamps": false,
  "skipSilence": true,
  "maxMinutesPerFile": 120,
  "rssMaxEpisodes": 1,
  "maxFiles": 100,
  "beamSize": 1
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset with one item per media file: full text, timestamped segments, language, duration, links to the transcript files and, for failures, an error message.

## `files` (type: `string`):

TXT, SRT, VTT and JSON transcript files in the default key-value store.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mediaUrls": [
        "https://github.com/ggml-org/whisper.cpp/raw/master/samples/jfk.wav"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("northledgertools/audio-video-transcriber").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "mediaUrls": ["https://github.com/ggml-org/whisper.cpp/raw/master/samples/jfk.wav"] }

# Run the Actor and wait for it to finish
run = client.actor("northledgertools/audio-video-transcriber").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mediaUrls": [
    "https://github.com/ggml-org/whisper.cpp/raw/master/samples/jfk.wav"
  ]
}' |
apify call northledgertools/audio-video-transcriber --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,northledgertools/audio-video-transcriber"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/luRbk8piWpaZ9gnlO/builds/XUkDJIBQA9SMGm01M/openapi.json