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

Whisper speech to text for audio and video file links (mp3, wav, m4a, ogg, flac, mp4, webm, mov). Plain text, timed segments, SRT and WebVTT subtitles in 99 languages. No API key. Not for YouTube or other platform page links.

- **URL**: https://apify.com/atesen-software/audio-video-transcriber.md
- **Developed by:** [Atesen Software](https://apify.com/atesen-software) (community)
- **Categories:** AI, Videos, Developer tools
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $9.00 / 1,000 audio minute transcribed (tiny or base model)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 API: Speech to Text, SRT, VTT

Transcribes audio and video file URLs (mp3, wav, m4a, mp4 and more) with Whisper into text, timed segments, SRT and VTT subtitles. For video teams and developers; pay per result: from $9.00 per 1,000 audio minutes (see the Pricing tab for the current price).

Turn audio and video files into text. Give the Actor direct links to **mp3, wav, m4a, ogg, flac, aac, mp4, webm, mov or mkv** files and get back the transcript as plain text, timed segments (JSON), **SRT subtitles** and **WebVTT subtitles**. It runs the open-source **Whisper** speech to text model inside the Actor, so there is no API key to set up and your audio is not sent to any AI service.

This is an **audio transcription API** you can call from code, schedules, Make, Zapier, n8n or any HTTP client: **mp3 to text**, **video to text** and **subtitle generation** (SRT, VTT) from a list of URLs.

### What it does

- Downloads each file from the link you give (public, direct link to the file itself).
- Reads the audio track of audio and video files, cuts long files into 10-minute parts and transcribes them with Whisper (faster-whisper engine, Tiny, Base or Small model).
- Detects the language or uses the language you set (99 languages).
- Skips long silent parts (voice activity detection), which makes invented text in silence much less likely. No filter removes it completely, so check files that are mostly music or noise.
- Returns one dataset row per file: text, language, duration, timed segments, SRT and VTT. TXT, SRT and VTT are also saved as downloadable files.
- Charges only for audio that was transcribed and delivered. Failed downloads, blocked links, unsupported files and files without speech are free.

### What it does not do

- **No YouTube, Vimeo, TikTok, Instagram, X, SoundCloud, Spotify, Apple Podcasts or Google Drive page links.** The Actor reads direct links to media files only. It never downloads from video platforms. If you own the video, upload the file somewhere that gives a direct file link.
- No speaker labels (diarization), no word-by-word timestamps, no translation, no summaries.
- It is not a perfect transcript. Accuracy depends on the model and the recording. Base and Tiny are fast and fine for clear speech; they make more mistakes than large commercial models on noise, accents, overlapping speakers, music and non-English languages. Use Small for harder audio and check important text yourself.
- Subtitles are cut at segment level (about one sentence), not at word level.
- Long files are transcribed in 10-minute parts that are cut at exact times. A word spoken exactly at a cut can be missed or garbled. The language is detected once, on the first part, so a file that mixes languages is read as one language.
- Files behind a login, a cookie or a signed link that has expired cannot be downloaded.

### Input

| Field | What it does |
|---|---|
| Audio and video file URLs | Direct file links, one per line, up to 200 per run. |
| Model | Tiny (fastest), Base (default, good for clear speech) or Small (slower, more accurate). |
| Language | `auto` or a language code such as `en`, `es`, `de`, `fr`, `it`, `pt`, `nl`, `tr`, `ru`, `ja`, `ko`, `zh`, `ar`, `hi`. Setting it is faster and avoids a wrong guess on short clips. |
| Output format | All (default), JSON, TXT, SRT or VTT. |
| Maximum minutes per file | Only the first N minutes of a file are transcribed and charged. Default 120, up to 480. |
| Skip silence | On by default. |
| Maximum file size | Default 500 MB, up to 1024 MB. |
| Download time limit | Default 600 seconds per file. |

Example input:

```json
{
  "mediaUrls": [
    "https://raw.githubusercontent.com/openai/whisper/main/tests/jfk.flac",
    "https://upload.wikimedia.org/wikipedia/commons/4/46/1941_Roosevelt_speech_pearlharbor_p1.ogg"
  ],
  "model": "base",
  "language": "auto",
  "outputFormat": "all",
  "maxDurationMinutes": 120
}
```

### Output

One dataset row per file (example shortened):

```json
{
  "url": "https://raw.githubusercontent.com/openai/whisper/main/tests/jfk.flac",
  "status": "ok",
  "language": "en",
  "languageProbability": 0.99,
  "model": "base",
  "durationSeconds": 1115.7,
  "fileDurationSeconds": 1115.7,
  "billedMinutes": 19,
  "wordCount": 1814,
  "text": "This is a recording of ...",
  "segments": [{ "id": 0, "start": 1.2, "end": 6.8, "text": "This is a recording of ..." }],
  "srt": "1\n00:00:01,200 --> 00:00:06,800\nThis is a recording of ...\n",
  "vtt": "WEBVTT\n\n00:00:01.200 --> 00:00:06.800\nThis is a recording of ...\n",
  "files": { "txt": "https://api.apify.com/v2/key-value-stores/.../records/file-001.txt", "srt": "...", "vtt": "..." },
  "error": null
}
```

`status` is `ok` (whole file), `partial` (only the first part: maximum minutes, maximum cost per run, run time limit or an error in a later part; `truncated` and `note` say why), `no-speech` or `error`. A run summary with per-file results is saved in the key-value store under `SUMMARY`.

### How billing works

You pay per started minute of audio that was transcribed. A file is counted by its transcribed length rounded up to the next full minute (a 90 second file is 2 minutes; one second over a full minute is still that minute). Two rates exist: one for Tiny and Base, one for the more accurate and slower Small. The current rates are on the Pricing tab of this Actor. Files that fail, are blocked, are not audio or contain no speech are never charged, and a file is charged only after its result row is stored. If you set a maximum cost per run, the Actor stops cleanly: a file that does not fit is transcribed only up to the minutes you can still pay for and marked `partial`.

### Use cases

- Meeting, call and interview recordings to searchable text.
- Podcast and webinar transcripts and show notes.
- Subtitles (SRT, VTT) for videos you own, as an input for editors and players.
- Speech to text step in AI and RAG pipelines (feed the text or segments to a language model).
- Voice message and support call archives.

### Speed

Speech recognition runs on shared CPU inside the Actor. Measured on the default 2048 MB of memory: Base needed roughly 2 to 25 seconds of run time per minute of audio (it depends on how busy the platform server is), and Small needs about 3 to 4 times as long as Base. A 19 minute file with Base took about 5 minutes. Add about 10 seconds for starting the run. Long batches may need a longer run timeout; the Actor stops starting new files shortly before the timeout and reports the rest as not processed (free).

### Limits and safety

- Up to 200 links per run, 1024 MB per file, 480 minutes per file (default 120).
- Only `http` and `https` links. Links to local or private network addresses, cloud metadata addresses and names that resolve to them are blocked, including after redirects. The Actor does not open playlist or manifest files (HLS, DASH) or follow references inside files.
- The temporary disk of a run is twice its memory. For very large video files start the run with more memory.
- Keep the default 2048 MB of memory for the Small model. 1024 MB is enough for Tiny and Base, but Small needs about 1 GB for one 10-minute part and can be stopped by the system at 1024 MB (that file is reported as an error and is free).
- Audio is processed in memory and in temporary files and deleted when the run ends. Transcript text is never written to the run log.
- The links in the `files` field are signed storage links: anyone who has the link can open the file. Treat them like the transcript itself.

### Your content

You are responsible for the files you transcribe: you need the right to download and process them, and recordings of people can contain personal data. Do not use this Actor for content you may not process.

### Use via API

One request runs the Actor, waits for it and returns the dataset items as JSON. Send your token in the `Authorization` header, not in the URL:

```bash
curl -X POST "https://api.apify.com/v2/acts/atesen-software~audio-video-transcriber/run-sync-get-dataset-items?timeout=120" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mediaUrls":["https://raw.githubusercontent.com/openai/whisper/main/tests/jfk.flac"],"model":"base","outputFormat":"all"}'
```

The synchronous endpoint waits up to 300 seconds. For longer jobs start a run with `POST https://api.apify.com/v2/acts/atesen-software~audio-video-transcriber/runs` and read the dataset when it finishes.

**JavaScript** (`npm install apify-client`):

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('atesen-software/audio-video-transcriber').call({ mediaUrls: ["https://raw.githubusercontent.com/openai/whisper/main/tests/jfk.flac"], model: "base", outputFormat: "all" });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Use with AI agents (MCP)

Claude Desktop, Cursor, VS Code and other MCP clients can call this Actor as a tool through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp). Load only this Actor with:

```text
https://mcp.apify.com?tools=atesen-software/audio-video-transcriber
```

Client config (sign in with Apify OAuth when the browser opens, or add an `Authorization: Bearer <APIFY_TOKEN>` header instead):

```json
{
  "mcpServers": {
    "apify": { "url": "https://mcp.apify.com?tools=atesen-software/audio-video-transcriber" }
  }
}
```

Then ask in plain words, for example: "Transcribe this audio file to text and SRT subtitles: https://raw.githubusercontent.com/openai/whisper/main/tests/jfk.flac" The agent fills the same input fields you see on the Input tab, and runs are billed to your Apify account at the prices on the Pricing tab.

### FAQ

**What does it return?** One dataset row per file with the text, detected language, duration, timed segments, SRT and VTT. TXT, SRT and VTT are also saved as downloadable files in the key-value store.

**How much does it cost?** Pay per result: $0.009 per started audio minute with the Tiny or Base model ($9.00 per 1,000 minutes) and $0.025 per minute with the more accurate Small model (see the Pricing tab for the current prices). Failed downloads, blocked links, unsupported files and files without speech are free.

**Does it work with YouTube links?** No. It only reads direct media file links. See "What it does not do".

**Which languages are supported?** The 99 languages of the multilingual Whisper models. Quality is best for English and other widely spoken languages and lower for rare ones, especially with the Tiny and Base models.

**Do I need an OpenAI or other API key?** No. The model runs inside the Actor.

**Why did my video return `no-speech`?** The file has an audio track but no speech was detected (music, silence or noise). It is free. Turn off "Skip silence" if the speech is very quiet.

**Can I get only subtitles?** Yes, set the output format to SRT or VTT. The text is still in the row, and the subtitle file is saved in the key-value store.

**What about very long recordings?** Files are cut into 10-minute parts, so memory stays low. The language is detected on the first part and reused for the rest.

### Credits and licenses

- Speech recognition: [faster-whisper](https://github.com/SYSTRAN/faster-whisper) (MIT, SYSTRAN) on [CTranslate2](https://github.com/OpenNMT/CTranslate2) (MIT), with the [OpenAI Whisper](https://github.com/openai/whisper) model weights converted by SYSTRAN (MIT).
- Voice activity detection: [Silero VAD](https://github.com/snakers4/silero-vad) (MIT, Silero Team), shipped inside faster-whisper. Audio decoding: [FFmpeg](https://ffmpeg.org/) and [PyAV](https://github.com/PyAV-Org/PyAV) (BSD-3-Clause). The licence notices are in `THIRD-PARTY-NOTICES.md` in the Actor source.
- The default example uses two public domain recordings: an excerpt of President Kennedy's 1961 inaugural address (US federal government work, test file of the MIT-licensed openai/whisper repository) and an excerpt of President Roosevelt's 1941 address to Congress (public domain, Wikimedia Commons).

### Related actors

- [Video Frame Extractor: Video URL to JPG, PNG & WebP Frames](https://apify.com/atesen-software/video-frame-extractor)
- [YouTube Channel Scraper: Export Videos, Shorts & Subscribers](https://apify.com/atesen-software/youtube-channel-scraper)
- [PDF to Markdown + RAG Chunks: LLM-Ready PDF Text](https://apify.com/atesen-software/pdf-to-markdown-rag)

# Actor input Schema

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

Direct links to audio or video files (.mp3, .wav, .m4a, .ogg, .flac, .aac, .mp4, .webm, .mov, .mkv), one per line, up to 200 per run. The link must open the file itself and be public. Page links from YouTube, Vimeo, TikTok, Instagram, SoundCloud, Spotify or Google Drive are not supported.

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

Whisper model size. Base is fast and good for clear speech. Small is slower and more accurate on accents, noise and non-English languages. Tiny is the fastest and the least accurate.

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

Spoken language as a two-letter code (en, es, de, fr, it, pt, nl, tr, ru, ja, ko, zh, ar, hi, ...) or auto to detect it from the first 30 seconds of each file. Setting the language is faster and avoids wrong detection on short or noisy clips.

## `outputFormat` (type: `string`):

What each result row contains besides the plain text. All adds the timed segments (JSON), SRT and WebVTT subtitles. TXT, SRT and VTT are also saved as downloadable files in the key-value store of the run.

## `maxDurationMinutes` (type: `integer`):

Only the first N minutes of each file are transcribed and charged. Long files are processed in 10-minute parts.

## `vadFilter` (type: `boolean`):

Cut out long silent parts and music pauses before transcribing. Faster, and it makes invented text in silence much less likely (no filter removes it completely). Turn it off only for very quiet speech.

## `maxFileSizeMb` (type: `integer`):

Files larger than this are skipped without charge. The temporary disk of a run is twice its memory, so very large video files need a run with more memory.

## `downloadTimeoutSecs` (type: `integer`):

Longest time allowed to download one file.

## Actor input object example

```json
{
  "mediaUrls": [
    "https://raw.githubusercontent.com/openai/whisper/main/tests/jfk.flac",
    "https://upload.wikimedia.org/wikipedia/commons/4/46/1941_Roosevelt_speech_pearlharbor_p1.ogg"
  ],
  "model": "base",
  "language": "auto",
  "outputFormat": "all",
  "maxDurationMinutes": 120,
  "vadFilter": true,
  "maxFileSizeMb": 500,
  "downloadTimeoutSecs": 600
}
```

# Actor output Schema

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

One row per file: transcript text, timed segments, SRT, WebVTT, language and minutes charged

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

The TXT, SRT and VTT files in the key-value store of the run

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

Per-file result: status, language, audio seconds, minutes charged, notes and why the run stopped

# 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://raw.githubusercontent.com/openai/whisper/main/tests/jfk.flac",
        "https://upload.wikimedia.org/wikipedia/commons/4/46/1941_Roosevelt_speech_pearlharbor_p1.ogg"
    ],
    "language": "auto"
};

// Run the Actor and wait for it to finish
const run = await client.actor("atesen-software/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://raw.githubusercontent.com/openai/whisper/main/tests/jfk.flac",
        "https://upload.wikimedia.org/wikipedia/commons/4/46/1941_Roosevelt_speech_pearlharbor_p1.ogg",
    ],
    "language": "auto",
}

# Run the Actor and wait for it to finish
run = client.actor("atesen-software/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://raw.githubusercontent.com/openai/whisper/main/tests/jfk.flac",
    "https://upload.wikimedia.org/wikipedia/commons/4/46/1941_Roosevelt_speech_pearlharbor_p1.ogg"
  ],
  "language": "auto"
}' |
apify call atesen-software/audio-video-transcriber --silent --output-dataset

```

## MCP server setup

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