# Audio & Video Transcriber (`smolevich90/audio-video-transcriber`) Actor

Transcribe audio and video from URLs, uploaded files or public Telegram posts into text with SRT and VTT subtitles.

- **URL**: https://apify.com/smolevich90/audio-video-transcriber.md
- **Developed by:** [Stanislav Shupilkin](https://apify.com/smolevich90) (community)
- **Categories:** AI
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$5.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?

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

## Audio & Video Transcriber

**A fast, multilingual audio transcriber and video transcriber that turns any media link or uploaded file into clean text with subtitles.** Give it audio or video URLs, upload a file, or drop in a public Telegram post — get back an accurate transcript plus ready-to-use SRT and VTT subtitles. It is speech to text without a browser, without an account, and without wiring up a transcription API yourself.

Recognition runs on Whisper Large v3 Turbo, which handles 90+ languages and auto-detects each one. Long recordings are split, transcribed and stitched back into a single transcript, so a two-hour file comes back as one clean block of text.

### What you can do with it

- **Transcribe podcasts, interviews and webinars** — point the audio transcriber at an episode URL and get a searchable transcript you can edit, publish or feed to an LLM.
- **Add subtitles to video** — every row ships an `srt` and a `vtt` string with real timestamps, ready to drop next to your video file or upload to any player.
- **Repurpose content** — turn a talk, a voice memo or a video note into a blog draft, show notes, or a newsletter.
- **Build a transcription pipeline** — call it from the Apify API as a hosted speech-to-text step, hand it a list of URLs, and read transcripts straight out of the dataset.
- **Search spoken content** — make the audio half of your sources visible to keyword search, brand monitoring and analysis.

### Inputs — three ways in, no login

- **Audio / video URLs** — direct links to `.mp3`, `.m4a`, `.wav`, `.mp4`, `.webm` and more. The file is streamed to disk and transcribed.
- **Uploaded file** — upload one audio or video file straight into the run; no hosting required.
- **Public Telegram posts** — paste a `https://t.me/<channel>/<id>` link and the media is resolved from Telegram's public web preview (voice notes, video notes and videos). No account, no phone number, no Telegram API. You can also drop these links into the URL list — they are detected automatically.

> YouTube links are intentionally **not** supported: transcribing YouTube from a datacenter needs residential proxies and cookies and sits in a licensing grey zone, so this Actor leaves it out by design.

### Output fields

One dataset row is one input. Every row carries:

| Field | Type | What it is |
|---|---|---|
| `source` | string | The URL, Telegram link or uploaded-file key you gave |
| `title` | string | A short label — the file name, or `channel/message_id` for Telegram |
| `duration_seconds` | integer | Length of the audio in seconds |
| `language` | string | Language Whisper detected |
| `transcript` | string | The full transcript — the whole point |
| `srt` | string | SubRip subtitles with timestamps (when SRT output is on) |
| `vtt` | string | WebVTT subtitles with timestamps (when VTT output is on) |
| `error` | string | Present **only** on a row that could not be transcribed, with the reason — the run keeps going and this row is not charged |

### Example output

```json
{
  "source": "https://example.com/episode-12.mp3",
  "title": "episode-12.mp3",
  "duration_seconds": 1834,
  "language": "English",
  "transcript": "And so my fellow Americans, ask not what your country can do for you...",
  "srt": "1\n00:00:00,000 --> 00:00:04,200\nAnd so my fellow Americans...",
  "vtt": "WEBVTT\n\n00:00:00.000 --> 00:00:04.200\nAnd so my fellow Americans..."
}
```

Export it as JSON, CSV, Excel or XML, or pull it straight from the Apify API into your own pipeline.

### How to transcribe audio or video

1. Paste one or more links into **Audio / video URLs**, or upload a file under **Upload a file**, or add **Telegram post links**.
2. Choose whether you want **SRT** and **VTT** subtitles (both on by default).
3. Optionally set a **language hint** and a **duration cap**.
4. Run it. Results stream into the dataset as each input finishes.

### Input options

| Field | What it does | Default |
|---|---|---|
| `urls` | Audio/video URLs (also accepts `t.me` post links) | — |
| `audioFile` | One uploaded audio or video file | — |
| `telegramPosts` | Public Telegram post links to resolve | — |
| `outputSrt` | Add an SRT subtitle string to every row | true |
| `outputVtt` | Add a WebVTT subtitle string to every row | true |
| `language` | ISO-639-1 hint (`en`, `ru`, `de`, …) | auto-detect |
| `maxDurationSeconds` | Skip anything longer, so one huge file can't eat the budget | 5400 |
| `maxFileSizeMb` | Skip files larger than this instead of downloading | 200 |

### Pricing: pay per event

You are charged for results, not for runtime:

| Event | Price |
|---|---|
| `audio-minute` — one minute of audio, rounded up per file | $0.005 |

A 3-minute clip costs $0.015. An hour of audio costs $0.30. Inputs that fail to download, media that exceeds your duration cap, and anything that could not be transcribed are **not** charged.

If you set a maximum spend on the run, the Actor stops as soon as your limit is reached and finishes successfully with everything transcribed up to that point — you keep the partial dataset and pay nothing extra.

### How it works

- **Media is streamed to disk and stripped, not rehosted.** For a video, the picture track is thrown away with ffmpeg before anything is sent to speech recognition, so runs stay fast and cheap. No headless browser is ever launched.
- **Long recordings are chunked and stitched.** Anything long is split into 15-minute segments, transcribed in order, and joined back into one continuous transcript. Subtitle timestamps are offset per segment so the SRT/VTT stays continuous across the whole file.
- **Recognition is Whisper Large v3 Turbo**, multilingual and self-switching. The detected language is reported in every row. Transient provider errors are retried; an input that still fails is written out with an `error` and skipped, never crashing the run.
- **Subtitles come from real segment timestamps** returned by the speech-to-text model, formatted into standard SRT and WebVTT strings.

### Limits worth knowing before you run it

- **No YouTube.** By design — see above.
- **Telegram: public posts only.** Private channels, groups and DMs are not reachable without an account, which this Actor deliberately does not use. Audio sent to a channel as a file attachment has no downloadable link in the public preview; voice notes, video notes and videos are fine.
- **Media links on Telegram's CDN are signed and expire**, so Telegram inputs are downloaded during the same run.
- **A single bad input is one row with an `error`, not a failed run.** The Actor logs a warning, writes the error row, and moves on to the next input.

# Actor input Schema

## `urls` (type: `array`):

Direct links to audio or video files to transcribe. You can also drop public Telegram post links (https://t.me/<channel>/<id>) here — they are resolved automatically.

## `audioFile` (type: `string`):

Upload a single audio or video file to transcribe instead of, or in addition to, the URLs above.

## `telegramPosts` (type: `array`):

Public Telegram post links, e.g. https://t.me/channel/123. The media is read from the public web preview — no account, no login. Audio sent as a file (document) cannot be downloaded from the preview; voice notes, video notes and videos can.

## `outputSrt` (type: `boolean`):

Add an SRT subtitle string (with timestamps) to every output row.

## `outputVtt` (type: `boolean`):

Add a WebVTT subtitle string (with timestamps) to every output row.

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

ISO-639-1 code (en, ru, de, ...). Leave empty to auto-detect — the transcriber is multilingual.

## `maxDurationSeconds` (type: `integer`):

Safety cap so one very long recording does not eat the whole budget. Longer inputs are skipped and never charged.

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

Files above this size are skipped instead of downloaded.

## Actor input object example

```json
{
  "urls": [
    "https://raw.githubusercontent.com/ggerganov/whisper.cpp/master/samples/jfk.wav"
  ],
  "outputSrt": true,
  "outputVtt": true,
  "maxDurationSeconds": 5400,
  "maxFileSizeMb": 200
}
```

# Actor output Schema

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

One row per input with its transcript and subtitles.

# 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 = {
    "urls": [
        "https://raw.githubusercontent.com/ggerganov/whisper.cpp/master/samples/jfk.wav"
    ],
    "maxDurationSeconds": 5400
};

// Run the Actor and wait for it to finish
const run = await client.actor("smolevich90/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 = {
    "urls": ["https://raw.githubusercontent.com/ggerganov/whisper.cpp/master/samples/jfk.wav"],
    "maxDurationSeconds": 5400,
}

# Run the Actor and wait for it to finish
run = client.actor("smolevich90/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 '{
  "urls": [
    "https://raw.githubusercontent.com/ggerganov/whisper.cpp/master/samples/jfk.wav"
  ],
  "maxDurationSeconds": 5400
}' |
apify call smolevich90/audio-video-transcriber --silent --output-dataset

```

## MCP server setup

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