# Audio and Video Transcriber: text, SRT and VTT subtitles (`examsens.ai/audio-video-transcriber`) Actor

Transcribes audio and video files you link to or upload, and podcast RSS episodes, into text with timestamps, SRT and VTT subtitles and the detected language. A Whisper speech model runs inside the actor; no outside service is called.

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

## Pricing

from $9.00 / 1,000 audio minute transcribeds

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 and Video Transcriber: text, SRT and VTT subtitles

Give it audio or video files and it returns what was said: the full transcript, timestamped segments, ready to use SRT and VTT subtitle files, and the spoken language it detected.

Speech recognition runs inside the actor with OpenAI's Whisper models (tiny, base and small, through faster-whisper). No outside speech service is called and no API key is needed. The models are released under the MIT License.

### What you can send

- Direct file links: up to 1 GB each, in the formats under "Accepted files". From a video, the audio track is used.
- Uploaded files: upload from your computer in the input form. Choose a permanent or existing key-value store in the upload dialog, then pick that store under "Key-value stores with your files". The run gets read access to the stores you pick and nothing else.
- Key-value stores: every record in a picked store whose key ends in `.mp3`, `.wav`, `.flac`, `.ogg`, `.oga`, `.opus`, `.webm`, `.mkv`, `.mka` or `.ogv` is transcribed.
- Podcast RSS feeds: the newest episodes of each feed, as many as you set.

### Accepted files

- Containers: MP3, WAV, FLAC, Ogg (`.ogg`, `.oga`, `.ogv`, `.opus`), WebM and MKV
- Audio codecs: Opus, Vorbis, FLAC, MP3 and PCM
- Video codecs, when the file has a picture: AV1, VP8, VP9 and Theora

A file in any other format, or one that holds any other codec, gets an error row that names what it holds and lists what is accepted, and is not charged.

Links to pages on video and social platforms (YouTube, TikTok, Instagram, Facebook, X, Vimeo, Twitch, SoundCloud, Spotify and others) are refused with an error row. Send a direct link to a file you own or are allowed to process.

### Options

- Speech model: `tiny` (fastest), `base` (default), `small` (most accurate)
- Spoken language: a two letter code such as `en` or `es`, or empty to detect it
- Translate the speech to English
- Word timestamps: every word with its start, end and probability
- Names and terms to expect, so the model spells them right
- Skip silence and music (default on)
- Maximum minutes per file (default 120): only that many minutes from the start are transcribed and billed

### Output

Dataset: one item per file with `url`, `ok`, `language`, `languageProbability`, `durationSeconds`, `transcribedSeconds`, `speechSeconds`, `minutesCharged`, `wordCount`, `text`, `segments` (each with `start`, `end`, `text` and, with word timestamps on, `words`), `srt`, `vtt`, and links to the `.srt`, `.vtt` and `.txt` files saved in the run's key-value store. Podcast episodes also carry `title`, `published` and `feed`. A file that cannot be downloaded or read gets `ok: false` and an `error` in plain words, and the run carries on with the next file.

### Tested

- An English speech clip in FLAC, and the same clip as MP3 with cover art, as Opus in WebM with AV1 video, and as Opus in MKV with VP9 video
- An English Ogg Vorbis clip, and WAV and Opus music files
- A Spanish audiobook chapter in MP3 (language detected as `es` at 0.973), and the same chapter translated to English with word timestamps
- A NASA podcast RSS feed
- A file read from a picked key-value store
- Errors: a YouTube link, a web page, a PNG image, a missing file (HTTP 404), an empty file, a link that is not an RSS feed, MP4, M4A and AAC files, and MKV files with H.264 video or AAC audio
- The maximum charge: a file cut short at the limit and the next file left unprocessed

### Speed

Apify gives a run one CPU core for every 4 GB of memory, so speed follows the memory you choose. With 2 GB and the base model, the first 2 minutes of a podcast episode, 101 seconds of it speech, took 48 seconds to transcribe.

### Pricing

Pay per event: one event per started minute of audio transcribed. A 90 second file is two events. A file that fails is not charged. The run stops starting new files when it reaches the maximum charge you set, and a file is cut to the minutes that charge still covers.

### Scope and conduct

Only the files, stores and feeds you supply are read. Files are deleted from the run's disk once decoded. The transcript is machine made and can contain mistakes. Speaker labels are not produced.

### Support

Questions and problems: the Issues tab on this page. Replies are written by an AI assistant on behalf of the developer and reviewed by the developer.

# Actor input Schema

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

Direct links to audio or video files, up to 1 GB each: MP3, WAV, FLAC, Ogg, Opus, WebM or MKV, with Opus, Vorbis, FLAC, MP3 or PCM audio and AV1, VP8, VP9 or Theora video. Other files get an error item naming their format. Links to pages on video or social platforms such as YouTube or TikTok are refused. Use files you own or are allowed to process.

## `uploadedFiles` (type: `array`):

Upload files from your computer. When the upload dialog asks for a store, choose a permanent or existing store, then pick that same store under "Key-value stores with your files" so the run can read it.

## `fileStores` (type: `array`):

Apify key-value stores that hold your audio or video files. Every record whose key ends in .mp3, .wav, .flac, .ogg, .oga, .opus, .webm, .mkv, .mka or .ogv is transcribed. The run gets read access to these stores only.

## `podcastFeeds` (type: `array`):

Podcast RSS feed URLs. The newest episodes (see the next field) are taken from each feed's audio or video enclosures.

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

How many of the newest episodes to transcribe from each podcast feed.

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

Whisper model size. tiny is the fastest, small is the most accurate, base sits between them.

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

Two letter language code of the speech, such as en, es, de, fr or ja. Leave empty to detect it from the first 30 seconds of speech.

## `translateToEnglish` (type: `boolean`):

Write the transcript and subtitles in English, whatever language is spoken.

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

Add every word with its start time, end time and probability to each segment. Takes longer.

## `vocabulary` (type: `string`):

Names, brands and jargon in the recording, separated by commas, so the model spells them right. The first 800 characters are used.

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

Detect the parts with speech first and transcribe only those. Turn off if words go missing from quiet speech.

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

Transcribe at most this many minutes from the start of each file. Billing counts only the minutes transcribed.

## Actor input object example

```json
{
  "fileUrls": [
    {
      "url": "https://github.com/openai/whisper/raw/main/tests/jfk.flac"
    }
  ],
  "maxEpisodesPerFeed": 1,
  "model": "base",
  "language": "",
  "translateToEnglish": false,
  "wordTimestamps": false,
  "skipSilence": true,
  "maxMinutesPerFile": 120
}
```

# Actor output Schema

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

No description

# 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": [
        {
            "url": "https://github.com/openai/whisper/raw/main/tests/jfk.flac"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("examsens.ai/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": [{ "url": "https://github.com/openai/whisper/raw/main/tests/jfk.flac" }] }

# Run the Actor and wait for it to finish
run = client.actor("examsens.ai/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": [
    {
      "url": "https://github.com/openai/whisper/raw/main/tests/jfk.flac"
    }
  ]
}' |
apify call examsens.ai/audio-video-transcriber --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,examsens.ai/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/aArZ4j21qawnl2Ctb/builds/CMkICMpYHdxbg1hpD/openapi.json