# Audio & Video Transcription - Speech to Text, Whisper, SRT (`sophisticated_occasion/audio-video-transcriber`) Actor

Transcribe audio and video files and podcast RSS feeds to text with Whisper speech-to-text: plain transcript, timestamps, SRT and VTT subtitles, 90+ languages. $0.00597 per audio minute, failed files free. Your own or public media only.

- **URL**: https://apify.com/sophisticated_occasion/audio-video-transcriber.md
- **Developed by:** [HUG0 S](https://apify.com/sophisticated_occasion) (community)
- **Categories:** AI, Videos, For creators
- **Stats:** 1 total users, 1 monthly users, 82.4% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.97 / 1,000 transcribed audio minute (standard)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 Transcription - Speech to Text, Whisper, SRT

Turn **your own audio and video files** and **public podcast RSS feeds** into text, timestamped segments, **SRT** and **VTT** subtitles.
Works in 90+ languages, with automatic language detection. You pay **only for audio that was transcribed successfully**.

> **AI disclosure.** Transcripts are produced automatically by an AI speech-recognition model:
> faster-whisper, an open-source (MIT-licensed) re-implementation of OpenAI's open-source
> **Whisper** model, running on Apify's servers. No human checks the output. AI transcripts can contain errors, especially with
> names, numbers, accents, overlapping speakers, music or poor audio. Review the transcript before you rely on it for anything important.

### Why this one

- **Everything you need from one run:** the full transcript, sentence-level timestamps and ready-to-use SRT and VTT subtitle files, per file.
- **Files and podcasts:** your own audio/video links or a public podcast RSS feed, 90+ languages with automatic language detection.
- **You pay only for audio that was transcribed.** Unreachable URLs, non-audio files, too-long files and files with no speech are free and listed in `ERRORS`; files above your maximum cost per run are skipped, not charged.
- **Two models:** Standard (Whisper base) for fast, low-cost transcripts and Accurate (Whisper small) when the text matters more. Output is automatic and can contain errors, so review it.

### Quick start: example input, output and cost

Speech to text for audio, video and podcast RSS: transcript, timestamps, SRT and VTT subtitles, 90+ languages. Pay per audio minute, failed files free.

**Example input**

```json
{
  "fileUrls": [
    "https://upload.wikimedia.org/wikipedia/commons/8/8c/The_Eagle.ogg"
  ]
}
```

*Example file: "The Eagle" (Alfred, Lord Tennyson, 1851) read by Neil Carmichael, [Wikimedia Commons](https://commons.wikimedia.org/wiki/File:The_Eagle.ogg), licensed CC BY-SA 4.0. 16 seconds, billed as 1 minute.*

**Cost example:** A 60-minute podcast episode x $0.00597 = **$0.36** (accurate model: $1.18).

### What you get per file

| Field | Description |
|---|---|
| `text` | The full transcript |
| `segments` | Sentence-level segments with `start` / `end` times in seconds |
| `srt`, `vtt` | Ready-to-use subtitle files (as text) |
| `language`, `languageProbability` | Detected (or forced) language |
| `durationSec`, `billedMinutes` | Audio length and the minutes you were charged for |
| `episodeTitle`, `episodePublished`, `feedUrl` | For podcast episodes |
| `model`, `engine` | Which open-source model produced the transcript |

Inputs that fail (unreachable URL, not an audio file, too long, no speech) are **not charged**. They are listed in the `ERRORS`
record of the run's key-value store, with the reason.

### Pricing (pay per event)

| Event | Price | When it is charged |
|---|---|---|
| `audio-minute` (Standard, Whisper *base*) | **$0.00597 per audio minute** | After the transcript of a file has been saved |
| `audio-minute-accurate` (Accurate, Whisper *small*) | **$0.0197 per audio minute** | After the transcript of a file has been saved |

Minutes are counted per file and rounded up (a 61-second file = 2 minutes). Example: a 45-minute podcast episode costs
$0.27 (Standard) or $0.89 (Accurate). If you set a maximum cost per run, files that would exceed it are skipped and **not charged**.

### Input examples

**Files** (direct links to files you may process):

```json
{ "fileUrls": ["https://upload.wikimedia.org/wikipedia/commons/8/8c/The_Eagle.ogg", "https://upload.wikimedia.org/wikipedia/commons/1/16/President_Kennedy%27s_Speech_at_Rice_University.ogv"], "language": "en" }
```

**Podcast RSS** (newest 3 episodes of a NASA podcast, English, accurate model):

```json
{ "podcastFeedUrls": ["https://www.nasa.gov/feeds/podcasts/houston-we-have-a-podcast"], "maxEpisodesPerFeed": 3, "language": "en", "model": "small" }
```

### Which model should I choose?

- **Standard (base)** is fast and cheap and good for clear English speech.
- **Accurate (small)** makes noticeably fewer errors for Dutch, German and other non-English audio, and for noisy recordings.
  Our own test results are in the "Accuracy" section below.

### Accuracy (our measurement, word error rate, lower is better)

| Language (FLEURS samples, ~2 min each) | Standard (base) | Accurate (small) |
|---|---|---|
| English | 18% | 10% |
| Dutch | 50% | 24% |
| German | 20% | 11% |

Measured on 9 Oct 2026 with the public FLEURS benchmark by Google (CC-BY-4.0): read Wikipedia sentences with many names and numbers, so these figures are on the harsh side. Clear conversational English usually comes out better. **For Dutch and other non-English audio, use Accurate.**

### Limits and what is not supported

- Up to 200 files/feeds per run; up to 2 GB and 240 minutes per file by default (`maxFileDurationMinutes`, max 600).
- **Not supported:** page links of YouTube, Instagram, TikTok, Facebook, X/Twitter, Spotify, Vimeo, SoundCloud and similar platforms.
  Their terms do not allow downloading their media, so these links are refused (and not charged).
- Private network addresses (localhost, 10.x, 192.168.x, ...) are refused.
- The default run timeout is 2 hours. Processing takes roughly 8 s per audio minute (Standard) or 22 s (Accurate) at the default 4 GB memory; doubling the memory roughly halves it. If a file cannot finish before the run's timeout, it is skipped up front (not charged) with a message telling you to raise the timeout or memory.
- No speaker labels (diarization) and no translation yet.

### Your responsibility

Only submit audio you own or have permission to process, such as your own recordings, interviews with consent, or public podcast
feeds for personal or research use. Transcripts of people's voices can contain personal data. You decide what you do with them and must
handle them lawfully (e.g. GDPR).

### Privacy

Files are downloaded into the run's temporary container, transcribed and deleted when the run ends. Transcripts are stored only in
**your** run's dataset in your Apify account. The developer does not receive your audio or transcripts.

### Open-source components

faster-whisper and CTranslate2 (MIT), Whisper base/small model weights (MIT, converted by SYSTRAN), FFmpeg (LGPL/GPL, used as an unmodified command-line tool), Apify SDK (Apache-2.0). This Actor is an independent product and is not affiliated with or endorsed by OpenAI.

### Support

Open an issue on the **Issues** tab. Typical response time is 2–5 business days.

# Actor input Schema

## `fileUrls` (type: `array`):

Direct links to audio or video files you have the right to process (mp3, m4a, wav, ogg, flac, mp4, mov, webm...). Page URLs of platforms such as YouTube, Instagram, TikTok, Facebook, Spotify or Vimeo are refused, because their terms do not allow downloading.

## `podcastFeedUrls` (type: `array`):

Public podcast RSS feeds. The newest episodes (see 'Episodes per feed') are transcribed from their audio enclosures.

## `maxEpisodesPerFeed` (type: `integer`):

How many of the newest episodes to transcribe per RSS feed (1-50).

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

Standard is billed as 'audio-minute'; Accurate is billed as 'audio-minute-accurate'. See the Pricing tab.

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

ISO 639-1 code such as 'en', 'nl' or 'de'. Leave empty to detect the language automatically.

## `maxFileDurationMinutes` (type: `integer`):

Longer files are skipped (and not charged).

## Actor input object example

```json
{
  "fileUrls": [
    "https://upload.wikimedia.org/wikipedia/commons/8/8c/The_Eagle.ogg"
  ],
  "maxEpisodesPerFeed": 1,
  "model": "base",
  "maxFileDurationMinutes": 240
}
```

# Actor output Schema

## `transcripts` (type: `string`):

Text, segments, SRT and VTT for each transcribed file

## `errors` (type: `string`):

Inputs that could not be transcribed, with the reason

## `summary` (type: `string`):

Counts of transcribed files, failures and billed minutes

# 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 = {
    "fileUrls": [
        "https://upload.wikimedia.org/wikipedia/commons/8/8c/The_Eagle.ogg"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sophisticated_occasion/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 = { "fileUrls": ["https://upload.wikimedia.org/wikipedia/commons/8/8c/The_Eagle.ogg"] }

# Run the Actor and wait for it to finish
run = client.actor("sophisticated_occasion/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 '{
  "fileUrls": [
    "https://upload.wikimedia.org/wikipedia/commons/8/8c/The_Eagle.ogg"
  ]
}' |
apify call sophisticated_occasion/audio-video-transcriber --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,sophisticated_occasion/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/04lYDDN4o8CHgMrU3/builds/1Lcnw3sb8wGJDB7sz/openapi.json