# Universal Media Transcriber · Whisper Speech-to-Text (`sauliusautomatesit/media-transcriber`) Actor

Transcribe audio & video from any URL — YouTube, podcasts, direct files and hundreds of sites — with Whisper. Get text, timestamped segments, SRT and VTT. 90+ languages, no API key.

- **URL**: https://apify.com/sauliusautomatesit/media-transcriber.md
- **Developed by:** [Saulius Saulenas](https://apify.com/sauliusautomatesit) (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 $40.00 / 1,000 audio minutes

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

## Universal Media Transcriber · Whisper Speech-to-Text

Turn **any audio or video URL into text** with OpenAI's Whisper (via the fast `faster-whisper` engine).
Works with **YouTube, podcasts, direct media files (mp3/mp4/wav/m4a…), and hundreds of other sites**.
Get plain text, timestamped segments, and ready-to-use **SRT / VTT subtitles** — in 90+ languages, with
optional English translation. **No API key.** Pay per minute of audio.

Give it a URL, get a transcript. It handles the download, audio extraction, and transcription end to end.

### Why this actor

- **Any source** — YouTube, podcast episodes, direct audio/video links, and hundreds of yt-dlp sites.
- **4 output formats** — plain text, timestamped segments, SRT and WebVTT subtitles.
- **90+ languages** — auto-detected, or set it explicitly. Optional **translate-to-English**.
- **Word-level timestamps** — perfect for captions and karaoke-style highlighting.
- **Choose your model** — `tiny`/`base` for fast & cheap, `small`/`medium` for higher accuracy.
- **Bulk** — pass many URLs in one run.
- **Fair pricing** — charged per minute of audio actually transcribed; failed items aren't charged.
- **Schedule it** — auto-transcribe new podcast episodes or channel uploads.

### Use cases

| You are a… | You use it to… |
|---|---|
| Podcaster / creator | Generate show notes, blog posts, and subtitles from episodes |
| Video team | Produce SRT/VTT captions for accessibility and SEO |
| Researcher / journalist | Transcribe interviews, lectures, briefings, calls |
| AI / RAG builder | Convert audio/video into text to index and search |
| Localization team | Translate foreign-language audio to English text |

### Input

| Field | Type | Description |
|---|---|---|
| `mediaUrls` | array | **Required.** URLs of audio/video to transcribe. |
| `model` | string | `tiny`, `base` (default), `small`, or `medium`. |
| `language` | string | Two-letter code (e.g. `en`, `es`); blank = auto-detect. |
| `translate` | boolean | Translate speech to English instead of transcribing. |
| `outputFormats` | array | `text`, `segments`, `srt`, `vtt`. |
| `wordTimestamps` | boolean | Add per-word timestamps. |
| `maxDurationMinutes` | integer | Skip media longer than this (cost guard). |
| `beamSize` | integer | 1 = fastest; higher = slightly more accurate. |
| `proxyConfiguration` | object | Proxy for downloads (helps with YouTube/geo limits). |

#### Example — transcribe a YouTube video

```json
{ "mediaUrls": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"], "model": "base", "outputFormats": ["text", "segments", "srt"] }
```

#### Example — transcribe podcast episodes with subtitles

```json
{
  "mediaUrls": ["https://example.com/episode-42.mp3", "https://example.com/episode-43.mp3"],
  "model": "small",
  "outputFormats": ["text", "srt", "vtt"]
}
```

### Output

One dataset item per URL:

```json
{
  "url": "https://www.youtube.com/watch?v=...",
  "title": "Interview with ...",
  "uploader": "Some Channel",
  "source": "Youtube",
  "language": "en",
  "languageProbability": 0.99,
  "durationSeconds": 612.3,
  "durationMinutes": 10.21,
  "model": "base",
  "wordCount": 1580,
  "segmentCount": 142,
  "text": "Full transcript text…",
  "segments": [{ "start": 0.0, "end": 4.2, "text": "Hello and welcome…" }, ...],
  "srt": "1\n00:00:00,000 --> 00:00:04,200\nHello and welcome…\n\n..."
}
```

A run **summary** (URLs requested, transcribed, errors, audio-minutes charged) is saved to the
key-value store under `SUMMARY`.

### Pricing

Pay-per-event: charged per **minute of audio** successfully transcribed (rounded up), plus a small
per-run start fee. Failed downloads/transcriptions are **not** charged. Larger models (`small`,
`medium`) cost more compute, so choose the model that fits your accuracy/budget. See the Pricing tab for
the live per-minute rate.

> Tip: `base` is the sweet spot for most content. Use `tiny` for quick drafts, `medium` for hard audio.

### FAQ

**What sources work?** YouTube, podcast episodes, direct audio/video file URLs, and hundreds of sites
supported by yt-dlp. For best results with YouTube at scale, enable Apify Proxy.

**Which languages?** Whisper supports 90+ languages and auto-detects by default. `translate: true`
outputs English.

**How accurate is it?** Whisper is state-of-the-art. Accuracy scales with model size; `base` is great
for clear speech, `small`/`medium` handle accents, noise and jargon better.

**Can I get subtitles?** Yes — include `srt` and/or `vtt` in `outputFormats`.

**Can I auto-transcribe new episodes?** Yes — schedule the actor over a list/feed of new URLs.

### Limitations

- Transcription is compute-bound; long media takes longer (and costs more minutes). Use
  `maxDurationMinutes` to cap.
- Some sites (certain social platforms) may rate-limit or block downloads; use a proxy and expect
  best-effort on those.
- Very noisy or overlapping speech is inherently harder; try a larger model.

# Actor input Schema

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

URLs of audio or video to transcribe. Works with YouTube, podcast episodes, direct audio/video files (mp3, mp4, wav, m4a…), and hundreds of other sites supported by yt-dlp.

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

Accuracy vs speed/cost. `tiny`/`base` are fast and cheap; `small`/`medium` are more accurate but slower (and cost more per minute of audio). `base` is a great default. (`small`/`medium` download on first use.)

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

Two-letter language code of the audio (e.g. `en`, `es`, `fr`, `de`, `hi`). Leave blank to auto-detect. Whisper supports 90+ languages.

## `translate` (type: `boolean`):

Translate the speech to English instead of transcribing in the original language.

## `outputFormats` (type: `array`):

Which transcript formats to include per item. `text` = full plain text; `segments` = timestamped chunks; `srt`/`vtt` = subtitle files.

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

Also produce per-word timestamps inside each segment (useful for captions/karaoke). Slightly slower.

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

Skip media longer than this (protects against accidental huge/expensive runs).

## `beamSize` (type: `integer`):

Decoding beam size. 1 = fastest (greedy); higher = slightly more accurate but slower.

## `proxyConfiguration` (type: `object`):

Proxy for downloading the media (helps with rate-limited or geo-restricted sources like YouTube).

## Actor input object example

```json
{
  "mediaUrls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  ],
  "model": "base",
  "translate": false,
  "outputFormats": [
    "text",
    "segments"
  ],
  "wordTimestamps": false,
  "maxDurationMinutes": 180,
  "beamSize": 1,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One item per media URL: the detected language, duration, word/segment counts, and the transcript in the requested formats (plain text, timestamped segments, SRT and/or WebVTT). Failed items carry an `error` and are not charged.

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

A JSON report: URLs requested, transcribed, errors, audio-minutes charged, the model used, and whether the run stopped at your maximum charge limit.

# 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://www.youtube.com/watch?v=dQw4w9WgXcQ"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sauliusautomatesit/media-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://www.youtube.com/watch?v=dQw4w9WgXcQ"] }

# Run the Actor and wait for it to finish
run = client.actor("sauliusautomatesit/media-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://www.youtube.com/watch?v=dQw4w9WgXcQ"
  ]
}' |
apify call sauliusautomatesit/media-transcriber --silent --output-dataset

```

## MCP server setup

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