# Whisper Transcriber — audio & video to text, SRT & VTT (`amanatools/whisper-transcriber`) Actor

Transcribe audio/video files or podcast RSS feeds with Whisper inside the Actor — no API key. Full text, timestamped segments, SRT + VTT subtitles, 99+ languages, optional English translation. Pay per minute transcribed; failed or silent files are never billed.

- **URL**: https://apify.com/amanatools/whisper-transcriber.md
- **Developed by:** [Dos](https://apify.com/amanatools) (community)
- **Categories:** AI, Developer tools
- **Stats:** 3 total users, 2 monthly users, 91.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Whisper Transcriber — audio & video to text, SRT & VTT

Send audio or video URLs — or a podcast RSS feed — and get back the
transcript: **full text, timestamped segments, and ready-to-save SRT + VTT
subtitle files.** Whisper runs *inside* the Actor (faster-whisper, int8,
CPU), so there is **no API key, no external service, and no per-provider
markup.** 99 languages, auto-detected — accuracy is strongest on
well-resourced languages (English, Spanish, Arabic, Russian, …); use the
`small` model for the harder ones. Optional translation to English.

Built for AI agents, podcast pipelines, subtitle workflows, meeting-notes
automation and anyone who needs speech as text without wiring up a
transcription provider.

### What you get

One dataset item per media file:

```json
{
  "url": "https://example.com/episode-42.mp3",
  "episode_title": "Episode 42 — Pricing",
  "status": "ok",
  "model": "base",
  "language": "en",
  "language_probability": 0.994,
  "duration_seconds": 1864.3,
  "billed_minutes": 32,
  "n_segments": 214,
  "n_words": 4930,
  "text": "Full transcript as one string …",
  "segments": [
    { "start": 0.0, "end": 6.48, "text": "Welcome back to the show." }
  ],
  "srt": "1\n00:00:00,000 --> 00:00:06,480\nWelcome back to the show.\n",
  "vtt": "WEBVTT\n\n00:00:00.000 --> 00:00:06.480\nWelcome back to the show.\n"
}
```

### Sources

- **Direct media files** — mp3, m4a, aac, ogg, opus, wav, flac, mp4, webm
  and anything else FFmpeg can decode. Up to 250 MB per file.
- **Podcast RSS/Atom feeds** — the feed URL expands to its newest episodes
  (`Episodes per RSS feed`, default 1, up to 10).

Not supported, deliberately: downloading from YouTube, TikTok or other
social platforms. Send direct media files you have the right to process.

### Pricing — pay only for delivered transcripts

| Event | Price | Charged when |
|---|---|---|
| `file-transcribed` | $0.005 | a file delivered a non-empty transcript |
| `transcription-minute` | $0.008 | per started minute of audio transcribed |

A 30-minute podcast episode costs **$0.245**. A one-hour meeting costs
**$0.485**. Compare: hosted transcription APIs charge $0.36–0.90 per hour
*plus* you build the pipeline.

The billing rule is deliberate: **files that fail to download, cannot be
decoded, or contain no recognizable speech are never billed — not even the
per-file fee.** If you got no transcript, you pay nothing. Your cost ceiling
per file = $0.005 + $0.008 × *Max minutes per file* (default 120).

### Options

| Field | Default | Notes |
|---|---|---|
| `media_urls` | — | file URLs and/or RSS feed URLs, up to 25 |
| `model` | `base` | `tiny` / `base` / `small` — accuracy vs speed |
| `language` | `auto` | ISO code (`en`, `ar`, `es`, …) skips detection |
| `task` | `transcribe` | `translate` = English output from any language |
| `rss_episodes` | `1` | newest N episodes per feed |
| `max_minutes_per_file` | `120` | hard cost/length cap; longer files flagged `truncated` |
| `vad_filter` | `true` | skip silence — faster, fewer hallucinated captions |
| `word_timestamps` | `false` | per-word timing inside segments (slower) |

`tiny` and `base` are baked into the image and start instantly; `small`
downloads once at the start of the run (~1 minute extra).

### Notes on quality

- **Voice-activity detection is on by default** — silent stretches are
  skipped instead of becoming hallucinated captions, and long quiet files
  transcribe much faster.
- For noisy audio, strong accents or lower-resource languages, switch to
  `small` — it is the most accurate model offered here.
- Set `language` explicitly for very short clips; auto-detection has less
  signal to work with under ~10 seconds.
- `translate` produces English text directly — no second pass needed.

### Limits, stated plainly

- CPU transcription: expect roughly 5–15 seconds of processing per audio
  minute with `base`, more with `small`. Long files take real time; the
  default run timeout (60 minutes) accommodates a full 2-hour episode with
  `base` — raise the run timeout for `small` on very long files.
- 250 MB per file, 25 URLs per run, 480 minutes max per file.
- Live streams are not supported — the URL must be a finite file.

### The family

| Actor | Use it for |
|---|---|
| **Whisper Transcriber** (this one) | speech in audio/video → text + subtitles |
| [PDF Text Extractor](https://apify.com/amanatools/pdf-text-extractor) | fast clean text from digital PDFs |
| [PDF OCR Extractor](https://apify.com/amanatools/pdf-ocr-extractor) | scanned PDFs, Arabic + English OCR |
| [Doc to Markdown](https://apify.com/amanatools/doc-to-markdown) | documents into LLM-ready Markdown |

### Issues and requests

Open an issue on the actor's Issues tab — I read all of them.

# Actor input Schema

## `media_urls` (type: `array`):

Audio/video file URLs (mp3, m4a, wav, ogg, flac, mp4, webm, …) or podcast RSS feed URLs — feeds expand to their latest episodes. Up to 25 URLs per run. Note: social-platform pages (YouTube, TikTok, …) are not supported — send direct media files you have the right to process.

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

Bigger models are more accurate and slower. 'base' is the sweet spot for clear speech; use 'small' for noisy audio, heavy accents or hard languages ('small' downloads on first use, adding ~1 minute once per run).

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

ISO code like 'en', 'ar', 'es', 'ru' — or 'auto' to detect. Setting it explicitly is slightly faster and more reliable for short clips.

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

'Transcribe' keeps the original language. 'Translate' produces English text regardless of the spoken language.

## `rss_episodes` (type: `integer`):

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

## `max_minutes_per_file` (type: `integer`):

Hard cap on transcribed audio per file — this is also your cost ceiling: max spend per file = $0.005 + $0.008 x this number. Longer files are transcribed up to the cap and flagged 'truncated'.

## `vad_filter` (type: `boolean`):

Voice-activity detection skips silent stretches — faster and fewer hallucinated captions on quiet audio. Turn off only if speech is being missed.

## `word_timestamps` (type: `boolean`):

Add per-word start/end times inside each segment. Slower; needed only for karaoke-style captions or precise alignment.

## `include_failed_files` (type: `boolean`):

If enabled, files that fail to download or decode still appear in the dataset with their status and error.

## Actor input object example

```json
{
  "media_urls": [
    "https://raw.githubusercontent.com/openai/whisper/main/tests/jfk.flac"
  ],
  "model": "base",
  "language": "auto",
  "task": "transcribe",
  "rss_episodes": 1,
  "max_minutes_per_file": 120,
  "vad_filter": true,
  "word_timestamps": false,
  "include_failed_files": true
}
```

# Actor output Schema

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

Default dataset: one item per file with url, status, language, duration, text, segments, srt and vtt.

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

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

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

```

## MCP server setup

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