# Audio & Video to Text Transcription (Whisper): Speech to Text (`fguiraud/audio-video-transcriber`) Actor

Speech to text for audio and video files and podcast RSS feeds: MP3, MP4, WAV, M4A and more to text, timestamps and SRT/VTT subtitles in 99 languages. Open-source Whisper, no API key. Optional AI summary and chapters. Pay per audio minute.

- **URL**: https://apify.com/fguiraud/audio-video-transcriber.md
- **Developed by:** [Fernando Guiraud](https://apify.com/fguiraud) (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 $6.00 / 1,000 audio minute (tiny/base)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

### What does Audio & Video to Text Transcription (Whisper) do?

**Audio & Video Transcriber** converts speech in **audio and video files** (MP3, MP4, WAV, M4A, OGG, FLAC, WEBM, MOV and more) into **text**, **timestamped segments** and ready-to-use **SRT / WebVTT subtitles**. It supports **99 languages**, detects the language automatically, and can also **translate speech to English**.

Use it as a **speech to text API**, **audio to text converter**, **video to text transcriber**, **podcast transcript generator** or **SRT subtitle generator**: no OpenAI key required.

It runs **open-source Whisper** (faster-whisper) directly on Apify, so there is no OpenAI key, no per-request API fee and no data sent to third parties. You **pay per minute of audio**, and failed or silent files are never billed.

Use it from the Apify Console, the API, schedules and integrations (Make, Zapier, n8n), or let **AI agents call it through the [Apify MCP server](https://mcp.apify.com)** ("transcribe this podcast episode and summarize it").

### Why use it?

- 🎙️ **Podcasts**: type a **podcast name**, or paste an **Apple Podcasts link** or **RSS feed**, and get the latest episodes transcribed, with podcast name, episode title and date. Schedule it to transcribe every new episode automatically.
- 🧑‍💼 **Meetings and calls**: turn recordings into text, and optionally get an **AI summary, chapters and action items** (Claude, with your own Anthropic key).
- 🎯 **Custom vocabulary**: give names, brands and jargon so they are spelled right.
- 🎬 **Videos and courses**: generate **SRT/VTT subtitles** with accurate timestamps.
- 🤖 **RAG and AI pipelines**: get **timestamped chunks with token counts**, ready for LLMs and vector databases.
- 🔗 **Paste any link**: direct file URLs, or Google Drive, Dropbox, OneDrive and GitHub share links.
- 🌍 **Multilingual content**: transcribe in the original language or translate to English in one step.

### How to transcribe an audio or video file

1. Click **Try for free**.
2. Paste direct links to your media files (for example a podcast `.mp3` or a meeting `.mp4`).
3. Pick a model: **base** (fast, recommended) or **small** (most accurate).
4. Click **Start**. Download the transcripts as JSON, CSV, Excel or HTML, or fetch them via API.

### Input

| Field | Description | Default |
|---|---|---|
| `sources` | Direct URLs of audio/video files | — |
| `base64Files` | Short files without a URL: `[{"fileName": "memo.m4a", "content": "<base64>"}]` | — |
| `podcastFeeds` / `maxEpisodesPerFeed` | Podcast names, Apple Podcasts links or RSS feeds; the newest N episodes of each are transcribed | — / 3 |
| `onlyNewEpisodes` | Skip episodes already transcribed in earlier runs (for schedules) | `true` |
| `model` | `base`, `small` or `tiny` | `base` |
| `language` | ISO code (`en`, `es`, `de`…) or `auto` | `auto` |
| `task` | `transcribe` or `translate` (to English) | `transcribe` |
| `outputs` | Any of `text`, `markdown` (paragraphs with `[HH:MM:SS]` times), `segments`, `srt`, `vtt`, `chunks` | `text`, `segments` |
| `vocabulary` | Names and terms to favour, e.g. `["Apify", "Dr. Nguyen"]` | — |
| `aiInsights` + `anthropicApiKey` | AI title, summary, key points, chapters, action items and topics | `false` |
| `saveFiles` | Also save `.txt`, `.srt` and `.vtt` files with download links (in `files`) | `false` |
| `wordTimestamps` | Start/end time for every word | `false` |
| `skipSilence` | Skip silent parts (faster, fewer hallucinations) | `true` |
| `maxDurationMinutes` | Only transcribe (and bill) the first N minutes of each file | 240 |

```json
{
  "sources": [{ "url": "https://example.com/podcast/episode-42.mp3" }],
  "model": "base",
  "language": "auto",
  "outputs": ["text", "segments", "srt"]
}
```

### Output

One record per file. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

```json
{
  "source": "https://example.com/podcast/episode-42.mp3",
  "status": "ok",
  "model": "base",
  "language": "en",
  "languageProbability": 0.99,
  "durationSeconds": 1834.2,
  "transcribedSeconds": 1834.2,
  "billedMinutes": 31,
  "text": "Welcome to the show. Today we talk about...\n\nOur guest is...",
  "segments": [{ "start": 0.0, "end": 4.2, "text": "Welcome to the show." }],
  "srt": "1\n00:00:00,000 --> 00:00:04,200\nWelcome to the show.\n",
  "insights": { "title": "Scaling data teams", "summary": "…", "keyPoints": ["…"], "chapters": [{ "start": "00:00:00", "title": "Intro" }, { "start": "00:07:42", "title": "Hiring" }], "actionItems": ["Send the hiring rubric to Ana"], "topics": ["data engineering"] },
  "stats": { "processingSeconds": 262.1, "speedFactor": 7.0, "segments": 412, "words": 5210 },
  "warnings": []
}
```

### How much does transcription cost?

Pay per event, with no subscription:

| Event | Price |
|---|---|
| Run start (per GB of memory, default 4 GB) | $0.0005 |
| Audio minute, base or tiny model | **$0.006** ($0.36 per hour) |
| Audio minute, small model | **$0.012** ($0.72 per hour) |
| AI insights per file (only with `aiInsights`; Claude usage is billed to your own key) | $0.01 |

A 30-minute podcast with the base model costs about **$0.18**. Each started minute is billed; failed files and files with no speech are free. Set **Max cost per run** and the Actor stops cleanly at that limit.

### Use it with AI agents (MCP): Claude, ChatGPT, Cursor

This Actor works as a **tool for AI agents** through the [Apify MCP server](https://mcp.apify.com). Add it to Claude Desktop, Claude Code, Cursor, VS Code or any MCP client with this server URL:

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

Then just ask in plain language, for example:

- *"Transcribe this podcast episode and summarise it: https://example.com/episode.mp3"*
- *"Transcribe the 3 newest episodes of this podcast feed and list the main topics"*
- *"Make Spanish SRT subtitles for this video: https://example.com/talk.mp4"*

Smallest useful input for an agent:

```json
{
  "sources": [{ "url": "https://example.com/episode.mp3" }],
  "outputs": ["text"]
}
```

- Asking only for `text` keeps the answer short; add `segments` or `srt` when timestamps are needed.
- `maxDurationMinutes` caps the length (and cost) of each file.
- Set `language` when you know it: it avoids misdetection on short clips.

Agents pay per result like everyone else (Apify also supports agentic payments), so there is no subscription to set up.

### Tips

- Long batches are safe: if the platform restarts or migrates the run, files already transcribed are skipped, so no minute is charged twice.
- **Speed**: the base model transcribes about 7× faster than real time at the default 4 GB of memory, and about 13× faster at 8 GB (same cost per minute, faster results).
- **Accuracy**: use `small` for accents, noisy recordings, music in the background and most non-English languages.
- Set `language` when you know it; auto-detection can be wrong on very short or noisy clips.
- For subtitles, add `srt` or `vtt` to `outputs` and enable `wordTimestamps` if you need per-word timing.

### Related tools

- Transcribing podcasts? [Podcast Transcript Scraper](https://apify.com/fguiraud/podcast-transcript-scraper) takes just the podcast name or its Apple Podcasts link and returns a table of episodes with their transcripts.

### FAQ and limitations

- **YouTube or other video pages?** No. The Actor needs a direct link to a media file or a podcast (name, Apple Podcasts link or RSS feed); it does not download from video platforms.
- **Transcribe every new episode automatically**: create an Apify **schedule** with your podcast feed. With `onlyNewEpisodes` (on by default) episodes transcribed in earlier runs are skipped, so you only pay for new ones.
- **Speaker names?** Speaker diarization (who said what) is not included yet.
- **Privacy**: files are processed inside your own Apify run and deleted when it ends; nothing is sent to external AI APIs.
- **Accuracy** depends on audio quality. Whisper can occasionally produce wrong words in silence or music; `skipSilence` reduces this.

Questions or feature requests? Open an issue in the **Issues** tab.

# Actor input Schema

## `sources` (type: `array`):

Direct links to media files: MP3, WAV, M4A, AAC, OGG, OPUS, FLAC, WEBM, MP4, MOV, MKV and more. Google Drive, Dropbox, OneDrive and GitHub share links work too (shared as 'Anyone with the link'). Pages of video platforms (YouTube, Vimeo...) are not supported.

## `base64Files` (type: `array`):

Short media files without a URL, e.g. from an AI agent: \[{"fileName": "memo.m4a", "content": "<base64>"}]. Keep the total input under ~9 MB; use URLs for longer recordings.

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

Podcast names (e.g. 'Lex Fridman Podcast'), Apple Podcasts links or RSS feed URLs. Names and Apple links are matched to the podcast's public RSS feed automatically. The newest episodes of each podcast are transcribed (see 'Episodes per feed'); results include the podcast name, episode title and publish date.

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

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

## `onlyNewEpisodes` (type: `boolean`):

Skip episodes already transcribed by previous runs of this Actor in your account (remembered in a key-value store named 'audio-transcriber-podcast-state'). Ideal for a daily schedule: you only pay for new episodes.

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

'base': good accuracy, fast (recommended). 'small': best accuracy, especially for accents, noisy audio and non-English speech; slower and billed at a higher per-minute price. 'tiny': fastest draft quality.

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

ISO code of the spoken language (en, es, de, fr, pt, it, ja, zh, ...) or 'auto' to detect it. Setting it avoids misdetection on short clips.

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

'transcribe': text in the spoken language. 'translate': translate the speech to English text.

## `vocabulary` (type: `array`):

Words the speech recognition should favour: people and company names, product names, technical terms (e.g. 'Kubernetes', 'Dr. Nguyen', 'Apify'). Improves spelling of rare words.

## `outputs` (type: `array`):

'text': full transcript split into paragraphs at pauses. 'segments': timestamped segments. 'srt' / 'vtt': ready-to-use subtitle files. 'chunks': ~chunkSize-character passages with start/end times and a token estimate, ready for vector databases. 'markdown': paragraphs prefixed with their start time, e.g. '**\[00:01:23]** ...'.

## `aiInsights` (type: `boolean`):

Analyse each transcript with Claude: title, summary, key points, chapters with start times, action items and topics (in 'insights'). Requires your Anthropic API key; Claude usage is billed to your Anthropic account, plus one small 'AI insights' event per file.

## `anthropicApiKey` (type: `string`):

Your key from console.anthropic.com. Stored as a secret input; used only to call Claude for this run.

## `insightsModel` (type: `string`):

'claude-opus-5': best quality (default). 'claude-sonnet-5': cheaper, great for meetings and podcasts. 'claude-haiku-4-5': cheapest (transcripts up to ~2 hours).

## `insightsInstructions` (type: `string`):

Optional, e.g. 'Summarise in Spanish', 'Focus on decisions and owners', 'Chapters every ~10 minutes'.

## `saveFiles` (type: `boolean`):

Save the transcript (.txt) and subtitles (.srt / .vtt, if selected in outputs) as files in the run's key-value store; the result includes their download links.

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

Add start/end times for every word inside each segment (for karaoke-style captions or precise search). Slightly slower.

## `chunkSize` (type: `integer`):

Target size of 'RAG chunks'.

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

Detect speech first and skip silent parts. Faster and reduces hallucinated text in long pauses.

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

Only the first N minutes of each file are transcribed (and billed).

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

Larger files are skipped (not billed).

## `failOnError` (type: `boolean`):

Mark the run as FAILED when a file cannot be transcribed. Useful for pipelines and monitoring.

## Actor input object example

```json
{
  "sources": [
    {
      "url": "https://archive.org/download/gettysburg_johng_librivox/gettysburg_address_64kb.mp3"
    }
  ],
  "maxEpisodesPerFeed": 3,
  "onlyNewEpisodes": true,
  "model": "base",
  "language": "auto",
  "task": "transcribe",
  "outputs": [
    "text",
    "segments"
  ],
  "aiInsights": false,
  "insightsModel": "claude-opus-5",
  "saveFiles": false,
  "wordTimestamps": false,
  "chunkSize": 1000,
  "skipSilence": true,
  "maxDurationMinutes": 240,
  "maxFileSizeMb": 1000,
  "failOnError": false
}
```

# Actor output Schema

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

No description

## `files` (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 = {
    "sources": [
        {
            "url": "https://archive.org/download/gettysburg_johng_librivox/gettysburg_address_64kb.mp3"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fguiraud/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 = { "sources": [{ "url": "https://archive.org/download/gettysburg_johng_librivox/gettysburg_address_64kb.mp3" }] }

# Run the Actor and wait for it to finish
run = client.actor("fguiraud/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 '{
  "sources": [
    {
      "url": "https://archive.org/download/gettysburg_johng_librivox/gettysburg_address_64kb.mp3"
    }
  ]
}' |
apify call fguiraud/audio-video-transcriber --silent --output-dataset

```

## MCP server setup

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