# Audio & Video Transcriber — podcasts, MP3, and 1,700+ sites (`dangul/audio-video-transcriber`) Actor

Transcribe any audio or video URL into text, timestamped segments, SRT, and WebVTT. Built for long recordings — handles multi-hour podcasts.

- **URL**: https://apify.com/dangul/audio-video-transcriber.md
- **Developed by:** [Daniel Gulla](https://apify.com/dangul) (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

$20.00 / 1,000 recording 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/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

## Audio & Video Transcriber

Turn any audio or video URL into text. Podcasts, interviews, lectures, webinars, meeting
recordings, MP3 and MP4 files, and pages from **1,700+ supported sites**.

Returns clean text, readable paragraphs, timestamped segments, and ready-to-use **SRT** and
**WebVTT** subtitles.

### Built for long recordings

Most transcription tools quietly fall over on anything longer than a few minutes, because
commercial speech-recognition APIs charge by the minute and multi-hour audio gets expensive
fast. This actor is designed the other way round.

A real example, start to finish: a **2-hour podcast episode** → 25,043 words across 2,577
timestamped segments, correctly aligned to the full 7,200 seconds.

### Quick start

```json
{
  "mediaUrls": [
    "https://traffic.libsyn.com/secure/atpfm/atp500.mp3",
    "https://example.com/interview.mp4"
  ],
  "includeParagraphs": true,
  "includeSrt": true
}
```

Leave `language` empty and it detects the language itself — detection is accurate and this is
usually the right choice. Set it explicitly only when you know the language and the audio is
noisy.

### What you get back

| Field | Description |
|---|---|
| `transcript` | Full transcript as clean, continuous text |
| `paragraphs` | The same text split into paragraphs on natural pauses — far easier to read |
| `segments` | Timestamped segments (`start`, `end`, `duration`, `text`) |
| `srt` | Ready-to-use SRT subtitle content |
| `vtt` | Ready-to-use WebVTT subtitle content, for HTML5 players |
| `language` · `languageProbability` | Detected language and confidence |
| `durationSeconds` | Length of the recording |
| `wordCount` | Words in the transcript |
| `processingSeconds` | How long this item took |

### What it accepts

- **Podcast episodes** — direct episode URLs from any host
- **Direct media files** — MP3, M4A, WAV, OGG, OPUS, FLAC, AAC, MP4, WEBM
- **Video and audio pages** — 1,700+ sites supported

If a URL plays in a browser, there is a good chance this actor can transcribe it.

### What people use it for

- **Podcast show notes and SEO** — publish transcripts so episodes become searchable text
- **Meeting and interview records** — searchable text instead of scrubbing through audio
- **AI and RAG pipelines** — feed spoken content into embeddings, summarisation, or Q\&A
- **Subtitling** — export SRT or WebVTT, then translate
- **Accessibility** — text alternatives for audio and video
- **Research** — search across hours of recordings by what was actually said

### Pricing

Pay per recording transcribed. **You are charged only for transcripts actually delivered** —
a URL that fails, is private, or contains no speech costs you nothing. Failed items still
appear in the dataset with an `error` field, so nothing disappears silently.

Note that the price is per **recording**, not per minute. A two-hour podcast costs the same
as a two-minute clip.

### Notes and limits

- Recordings are capped at 2 hours; longer audio is truncated.
- Paywalled, private, and DRM-protected media cannot be transcribed.
- Accuracy is high for clear speech. Heavy background music, crosstalk, and very poor
  recordings reduce it — as they do for any speech recogniser.
- Long recordings are processed in windows and stitched back together, so timestamps stay
  accurate across the whole file.
- This actor reads publicly accessible media only. You are responsible for ensuring you have
  the right to transcribe the content you submit.

### Support

Hit a URL that should work but does not, or need another output format? Open an issue on the
**Issues** tab with the URL you used, and it will usually be fixed quickly.

# Actor input Schema

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

Links to transcribe. Accepts podcast episodes, direct MP3/MP4/WAV files, and pages from 1,700+ supported sites.

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

Language code such as en, es, id, or de. Leave empty to detect automatically — detection is reliable and this is usually the right choice.

## `maxItems` (type: `integer`):

Hard cap on how many recordings this run will process.

## `includeParagraphs` (type: `boolean`):

Split the transcript into paragraphs on natural pauses. Much easier to read than one long block.

## `includeSegments` (type: `boolean`):

Return the transcript broken into timestamped segments.

## `includeSrt` (type: `boolean`):

Also return ready-to-use .srt subtitle content.

## `includeVtt` (type: `boolean`):

Also return ready-to-use .vtt subtitle content, for HTML5 video players.

## Actor input object example

```json
{
  "mediaUrls": [
    "https://download.samplelib.com/mp3/sample-15s.mp3"
  ],
  "maxItems": 25,
  "includeParagraphs": true,
  "includeSegments": true,
  "includeSrt": false,
  "includeVtt": false
}
```

# 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://download.samplelib.com/mp3/sample-15s.mp3"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("dangul/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://download.samplelib.com/mp3/sample-15s.mp3"] }

# Run the Actor and wait for it to finish
run = client.actor("dangul/audio-video-transcriber").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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://download.samplelib.com/mp3/sample-15s.mp3"
  ]
}' |
apify call dangul/audio-video-transcriber --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=dangul/audio-video-transcriber",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/tWMXNQTvXy9mrurb0/builds/eW9JM345HWJux9rgI/openapi.json