# Audio & Video Transcription: MP3, MP4 & Podcast to Text (`deapi/audio-video-to-text`) Actor

Transcribe audio and video files to text with AI: MP3, MP4, WAV, M4A and more, from direct links or podcast RSS feeds. Word timestamps, speaker labels, SRT/VTT subtitles, 90+ languages, up to 10 hours per file. No login or API key.

- **URL**: https://apify.com/deapi/audio-video-to-text.md
- **Developed by:** [deAPI](https://apify.com/deapi) (community)
- **Categories:** AI, Videos, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.13 / 1,000 transcript, per minute of audios

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

## Audio & Video Transcription: MP3, MP4 & Podcast to Text

**Audio and video transcription** and **speech to text** for files and podcasts: transcribe **MP3, MP4, WAV, M4A, FLAC, OGG, WebM, MOV** and more to text from a direct link, or get a **podcast transcript** straight from an **RSS feed**. Get the transcript with timestamps, speaker labels and ready-to-use SRT/VTT subtitles, in 90+ languages, for files up to 10 hours long. No login, no API key, nothing to install.

**deAPI transcription tools**

- Transcribing YouTube? → [YouTube Transcript AI: Subtitles, SRT & Speakers](https://apify.com/deapi/youtube-transcript-ai)
- Working with TikTok? → [TikTok Transcript from Audio: SRT, VTT & Speakers](https://apify.com/deapi/tiktok-transcript-scraper)
- Twitch or Kick VODs? → [Twitch & Kick VOD Transcriber: SRT, VTT & Speakers](https://apify.com/deapi/twitch-kick-transcript-scraper)

### What does Audio & Video Transcription do?

Paste links to audio or video files — or the RSS feed of a podcast — and the Actor downloads each file, extracts the audio track and transcribes it with an AI speech recognition model. Every file comes back as clean, punctuated text with timings, subtitles and the details you need to file it: the podcast name, episode title and publish date for feed episodes.

It works as a speech-to-text API for files: send links, get back text, timings, speakers and subtitle files as structured data.

### Why use it?

- **Any common format** — MP3, M4A, AAC, WAV, FLAC, OGG, Opus, WebM, MP4, MOV, MKV, AVI, WMV, MPEG.
- **Podcast RSS feeds** — the newest episodes of a show, with episode titles, dates and GUIDs.
- **Up to 10 hours per file** — whole lectures, meetings, audiobooks and livestream recordings.
- **Word-level timings** — every word, with a confidence score.
- **Speaker labels** — who said what, for interviews, panels and meetings.
- **SRT and VTT subtitles, properly split** — two-line cues, ready for an editor or a player.
- **Video costs the same as audio** — only the audio track is transcribed, and file size is never billed.
- **Priced at cost** — about $0.08 for a one-hour podcast.

### What data can you get?

| Data | Details |
|---|---|
| 📝 **Full transcript** | Clean, punctuated text of everything spoken in the file. |
| ⏱️ **Timestamps** | One per sentence, one for every word, or none at all. Sentence timing is in the base price. |
| 🗣️ **Speaker labels** | `SPEAKER_00`, `SPEAKER_01` … on every segment and word. |
| 🎬 **SRT and VTT subtitles** | Properly split, two lines, readable. |
| 🎙️ **Episode details** | For RSS feeds: podcast name, episode title, publish date, GUID, episode page and declared duration. |
| 🌍 **Language** | 90+ languages. Set the spoken language for the most reliable result, or leave it on auto-detect. |
| 🔢 **Confidence** | A 0–1 `score` on every word (with word timing), `avg_logprob` on every segment, and the language-detection confidence per file. |

### How to transcribe an audio or video file

1. Paste one or more links into **Audio or video file URLs** — the link must open the file itself — and/or podcast feeds into **Podcast RSS feeds**.
2. Pick a **timestamp level** — segment is the default and suits subtitles and reading.
3. Switch on **Label speakers** if the recording has more than one voice.
4. Pick the **spoken language** if you know it. Auto-detect can misidentify the language, which lowers accuracy.
5. Click **Start**, then download the dataset as JSON, CSV or Excel, or read it from the [Apify API](https://docs.apify.com/api/v2).

#### Which links work

| Link | Works |
|---|---|
| `https://example.com/episode.mp3` (or .m4a, .wav, .mp4, .mov …) | ✅ direct file link |
| A podcast RSS feed, e.g. `https://www.nasa.gov/feeds/podcasts/houston-we-have-a-podcast` | ✅ in **Podcast RSS feeds** |
| Dropbox / Google Drive *share pages*, web pages with a player | ❌ use the direct download link of the file |
| YouTube, TikTok, Twitch, Kick | ❌ use the dedicated deAPI transcript Actors above |
| Files behind a login | ❌ the link must be public |

#### How fast is it?

A one-hour podcast is downloaded, re-encoded and transcribed in about a minute and a half. Several files run in parallel.

#### Long recordings

Files over 2.5 hours are transcribed in parts and stitched back onto one timeline, so timestamps run continuously from start to finish. Speaker labels are numbered within each part and prefixed with it (`P2_SPEAKER_00`), because the same voice can be numbered differently in different parts. Each part is a separate transcription job, so the per-file fee is charged once per started 2.5 hours; the per-minute rate is unchanged.

### Input

```json
{
  "fileUrls": [
    "https://www.nasa.gov/wp-content/uploads/2015/01/590331main_ringtone_smallStep.mp3"
  ],
  "rssFeeds": [
    "https://www.nasa.gov/feeds/podcasts/houston-we-have-a-podcast"
  ],
  "maxEpisodesPerFeed": 1,
  "timestampLevel": "segment",
  "diarize": false,
  "language": "en",
  "includeSubtitles": true,
  "maxConcurrency": 2
}
```

### Output

One row per file or episode. This is the real result for the NASA podcast episode above, shortened:

```json
{
  "url": "https://traffic.megaphone.fm/NATIONALAERONAUTICSANDSPACEADMINISTRATION6740428946.mp3",
  "sourceType": "podcast-episode",
  "source": {
    "feedUrl": "https://www.nasa.gov/feeds/podcasts/houston-we-have-a-podcast",
    "podcast": "Houston We Have a Podcast",
    "title": "Reflections After Artemis II with Victor and Jeremy",
    "publishedAt": "Fri, 16 Oct 2026 13:00:00 -0000",
    "declaredDuration": "3617"
  },
  "status": "success",
  "hasSpeech": true,
  "durationSeconds": 3572.402,
  "language": "en",
  "languageConfidence": 0.99,
  "wordCount": 11314,
  "text": "Houston, we have a podcast. Welcome to the official podcast of the NASA Johnson Space Center...",
  "segments": [{ "start": 0.0, "end": 9.4, "text": "Houston, we have a podcast..." }],
  "srt": "1\n00:00:00,000 --> 00:00:03,120\nHouston, we have a podcast.\n\n...",
  "timestampLevel": "segment",
  "speakers": [],
  "parts": 1,
  "downloadedMB": 41.21,
  "billedMinutes": 60,
  "billedFiles": 1,
  "pricingOption": "standard"
}
```

With **word-level timestamps** each segment carries a `words` list, and with **speaker labels** every segment and word carries a `speaker`. Very long transcripts that do not fit one dataset row are saved as files and linked from `textUrl`, `srtUrl`, `vttUrl` and `segmentsUrl` — nothing is truncated.

### How much does it cost?

**$0.0075 per file + $0.00113 per minute (standard).** Word-level timings or speaker labels are $0.01063 per file + $0.00181 per minute.

Every price is the cost of the speech recognition plus Apify's platform costs and fee, with no markup beyond that. File size does not matter: a one-hour 1080p video costs exactly the same as the same hour as an MP3, because only the audio is transcribed. Recordings over 2.5 hours are transcribed in parts and pay the per-file fee once per part.

| What you asked for | Per file | Per minute |
|---|---|---|
| Plain text, or sentence timestamps | **$0.0075** | **$0.00113** |
| Word-level timings, or speaker labels, or both | **$0.01063** | **$0.00181** |

| File | Sentence timing | Word timing or speakers |
|---|---|---|
| A 1-minute voice note (1 MB) | $0.0086 | $0.0124 |
| A 30-minute interview MP3 (30 MB) | $0.0414 | $0.0649 |
| A 1-hour podcast episode (42 MB) | $0.0753 | $0.1192 |
| A 1-hour lecture as 720p MP4 (500 MB) | $0.0753 | $0.1192 |
| A 3-hour livestream recording, audio (170 MB) | $0.2184 | $0.3471 |

Files that fail — unreachable, not audio, too long, too big — are **never charged**, and neither are files skipped by a run cost limit or a free-plan allowance. Every one still gets a row explaining what happened.

Set **maximum cost per run** to cap your spend: the Actor measures each file before it transcribes it and skips anything the remaining budget cannot cover.

**Free plan:** 3 files per run, 30 minutes and 200 MB maximum each, 60 transcribed minutes per calendar month (resets at 00:00 UTC on the 1st), within a daily capacity shared by all free users. Any paid Apify plan removes the free-plan limits.

### Use cases

| Use case | Why it needs a transcript |
|---|---|
| **Podcast show notes and SEO** | Publish searchable episode pages, quotes and chapter markers. |
| **Content repurposing** | Turn recordings into articles, newsletters and social posts. |
| **Meetings, interviews and research** | Speaker-labelled transcripts of calls, focus groups and interviews. |
| **Media monitoring** | Track what is said across a set of podcasts, every day. |
| **Accessibility** | Real SRT and VTT subtitles for recordings that were never captioned. |
| **RAG and AI agents** | Timestamped, speaker-labelled text ready for a vector store or an LLM. |

### Tutorial: transcribe audio files and podcasts with the API

#### 1. One file in the Console

Open the Actor, keep the prefilled NASA link, set **Spoken language** to English and click **Start**. In a few seconds the **Transcripts** view shows *"That's one small step for man, one giant leap for mankind."*

#### 2. A podcast feed

Put `https://www.nasa.gov/feeds/podcasts/houston-we-have-a-podcast` into **Podcast RSS feeds** and set **Episodes per feed** to 1. The newest episode is transcribed, and the **Files & episodes** view shows its title and publish date.

#### 3. From Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("deapi/audio-video-to-text").call(run_input={
    "rssFeeds": ["https://www.nasa.gov/feeds/podcasts/houston-we-have-a-podcast"],
    "maxEpisodesPerFeed": 3,
    "language": "en",
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row["status"] == "success":
        print(row["source"].get("title"), row["wordCount"], "words")
```

#### 4. From JavaScript or cURL

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('deapi/audio-video-to-text').call({
    fileUrls: ['https://www.nasa.gov/wp-content/uploads/2015/01/590331main_ringtone_smallStep.mp3'],
    language: 'en',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].text);
```

```bash
curl -X POST "https://api.apify.com/v2/acts/deapi~audio-video-to-text/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"fileUrls": ["https://www.nasa.gov/wp-content/uploads/2015/01/590331main_ringtone_smallStep.mp3"], "language": "en"}'
```

The synchronous endpoint waits at most 5 minutes. For long files or whole feeds, start the run with `POST /v2/acts/deapi~audio-video-to-text/runs` and read the dataset when it finishes, or use the Python and JavaScript clients above, which wait for you.

#### 5. Keep a podcast transcribed automatically

Save an input with your feed and **Episodes per feed** set to 1 as a **Task**, add a daily **Schedule**, and attach a webhook or an integration (Make, Zapier, n8n, Google Drive) to send each new transcript where you need it.

### Audio transcription API and integrations

Every Apify Actor has a [REST API](https://docs.apify.com/api/v2), a [scheduler](https://docs.apify.com/platform/schedules), [webhooks](https://docs.apify.com/platform/integrations/webhooks) and official [JavaScript and Python clients](https://docs.apify.com/api/client/js). It also runs from Make, Zapier, n8n and as a tool for AI agents through the Apify MCP server.

### FAQ

#### How do I convert an MP3 to text?

Paste the direct link to the MP3 into **Audio or video file URLs** and click **Start**. The `text` field of the result is the transcript.

#### Can I transcribe a video file? How do I convert MP4 to text?

Yes — MP4, MOV, MKV, AVI, WMV, WebM and MPEG all work. Paste the direct link to the video; only the audio track is transcribed, so a video costs exactly the same per minute as its audio.

#### Is there a speech-to-text API? Do I need an API key?

Yes — this Actor is one. Call it through the [Apify API](https://docs.apify.com/api/v2) or the Python and JavaScript clients shown above with your Apify token. You do not need an account or a key with any speech recognition provider.

#### Can I transcribe many files in bulk?

Yes. Put as many links and feeds as you like into one run; up to 5 files are processed in parallel (set **Files in parallel**). Every file gets its own row, and failures never stop the rest of the batch.

#### Can I transcribe Spotify or Apple Podcasts links?

Not the show pages themselves, because they are players, not files. Use the show's RSS feed instead — almost every podcast has one, usually linked on the show's website or its hosting page — and paste it into **Podcast RSS feeds**.

#### How accurate is it?

Clear speech in a known language transcribes very reliably; heavy background music, cross-talk and poor microphones lower accuracy. Setting the spoken language helps more than anything else. Word-level `score` values let you find the passages the model was unsure about.

#### How do I transcribe a podcast?

Put the show's RSS feed into **Podcast RSS feeds**. The newest episodes are transcribed (3 by default, up to 50), each with its episode title and publish date. Most podcast hosts publish the RSS link on the show page; Apple Podcasts and Spotify pages are not feeds.

#### Can I upload a file from my computer?

Not directly — the Actor reads files from a link. Upload the file to any storage that gives a direct download link (an S3 or Google Cloud bucket, a Dropbox *direct* link, the Apify key-value store), and paste that link.

#### How long and how large can a file be?

Up to 10 hours and 1.5 GB on paid plans; 30 minutes and 200 MB on the free plan. A larger video is usually fine as its audio: an M4A or MP3 of the same recording is a fraction of the size.

#### Can I get SRT or VTT subtitles?

Yes, both, free of charge, on every file with timing, split into readable two-line cues.

#### Which languages are supported?

More than 90, auto-detected by default. Set the spoken language whenever you know it — auto-detect can misidentify the language, which lowers accuracy. The setting applies to every file in the run.

#### What happens if a file has no speech?

You get a row with `hasSpeech: false` and an empty transcript, not an error. Music and silence are valid outcomes. The file is still billed, because the audio was still processed.

#### Why did a file fail?

Usually because the link is not a direct file link (a web page with a player, a share page), the file is behind a login, or it has no audio track. Failures are never charged; the reason is in the row's `error` field.

#### Is my file stored?

The file is downloaded into the run, transcribed and deleted when the run's work on it is done. Your transcript stays in your own Apify storage.

### Support / feedback

Found a bug, hit a file that will not transcribe, or want a feature? Open a ticket in this Actor's **Issues** tab on its Apify Store page and include the file URL and run ID where you can.

# Actor input Schema

## `fileUrls` (type: `array`):

Direct links to audio or video files — the link must open the file itself, without a login. Works with **MP3, M4A, AAC, WAV, FLAC, OGG, Opus, WebM, MP4, MOV, MKV, AVI, WMV and MPEG**. Only the audio track is used, so a video costs exactly the same per minute as its audio. Up to **10 hours** and **1.5 GB** per file. For YouTube, TikTok, Twitch or Kick links use the dedicated deAPI transcript Actors. **Free plan: 3 files per run, 30 minutes and 200 MB maximum each, 60 transcribed minutes per calendar month (resets 00:00 UTC on the 1st), within a daily capacity shared by all free users. Paid plans remove the free-plan limits.**

## `rssFeeds` (type: `array`):

Podcast RSS feed URLs. The newest episodes of each feed are transcribed, and every row carries the podcast name, episode title, publish date and GUID. Example: `https://www.nasa.gov/feeds/podcasts/houston-we-have-a-podcast`.

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

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

## `timestampLevel` (type: `string`):

How finely the transcript is timed. **Segment** gives one timestamp per sentence — right for subtitles, reading, chapters and jumping to the moment something was said, and included in the base price. **Word** times every single word — right for clip cutting, word-by-word captions and search. **None** returns plain text only. Word moves the recording onto the precision rate ($0.01063 per file + $0.00181 a minute, against $0.0075 + $0.00113), and choosing speaker labels as well costs nothing extra on top.

## `diarize` (type: `boolean`):

Detect who is speaking and tag every line with a speaker (SPEAKER_00, SPEAKER_01, …). Use it for podcasts, interviews, panels, webinars and any recording with more than one voice. Speaker labels need timing to attach to, so switching this on together with **None** still returns sentence-level timing. Moves the recording onto the precision rate ($0.01063 per file + $0.00181 a minute, against $0.0075 + $0.00113); if you already picked Word timestamps, adding speakers costs nothing extra.

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

Pick the language spoken in the recording whenever you know it. Auto-detect can misidentify the language, which lowers transcription accuracy. One language applies to every file in the run, so split mixed-language batches into separate runs, or keep auto-detect and check `languageConfidence` in the output. The dropdown lists the 29 most requested languages; anything else is transcribed on auto-detect.

## `includeSubtitles` (type: `boolean`):

Return ready-to-use subtitle files as `srt` and `vtt` fields — paste them straight into a video editor, a player or a CMS. Free of charge. Subtitles need timing to exist, so they are produced at every timestamp level except None, and also at None when speaker labels are switched on. On very long recordings the files are saved to the run's key-value store and linked as `srtUrl` and `vttUrl` instead of being inlined, so nothing is ever truncated.

## `maxConcurrency` (type: `integer`):

How many files are downloaded and transcribed at the same time. It has no effect on price.

## Actor input object example

```json
{
  "fileUrls": [
    "https://www.nasa.gov/wp-content/uploads/2015/01/590331main_ringtone_smallStep.mp3"
  ],
  "maxEpisodesPerFeed": 3,
  "timestampLevel": "segment",
  "diarize": false,
  "language": "auto",
  "includeSubtitles": true,
  "maxConcurrency": 2
}
```

# Actor output Schema

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

One row per file or podcast episode: the full transcript text, timed segments (with word-level timings and speaker labels when requested), SRT and VTT subtitles, detected language, length, word count, the episode details for podcast feeds, and what was billed. Every file and feed you submit produces a row. Files that could not be transcribed carry status 'failed' with an 'error' field, and are not charged. Files left out because a free-plan allowance or a run cost limit was reached carry status 'skipped' with the reason in 'error', and are not charged either.

# 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 = {
    "fileUrls": [
        "https://www.nasa.gov/wp-content/uploads/2015/01/590331main_ringtone_smallStep.mp3"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("deapi/audio-video-to-text").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 = { "fileUrls": ["https://www.nasa.gov/wp-content/uploads/2015/01/590331main_ringtone_smallStep.mp3"] }

# Run the Actor and wait for it to finish
run = client.actor("deapi/audio-video-to-text").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 '{
  "fileUrls": [
    "https://www.nasa.gov/wp-content/uploads/2015/01/590331main_ringtone_smallStep.mp3"
  ]
}' |
apify call deapi/audio-video-to-text --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,deapi/audio-video-to-text"
        }
    }
}
```

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/elyhmwv4dobQbA4XC/builds/WkSBbwHW39AUTU0Va/openapi.json