# Audio Transcription & Speech to Text - Video, Podcasts, SRT (`afterstar/audio-transcriber`) Actor

Turns audio and video files (your own uploads, direct file links, public podcast feeds) into text and subtitles (SRT/VTT) in ~99 languages, on the open-source Whisper model, run inside the tool (no API key).

- **URL**: https://apify.com/afterstar/audio-transcriber.md
- **Developed by:** [Afterstar](https://apify.com/afterstar) (community)
- **Categories:** AI, Videos
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $9.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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Transcription & Speech to Text do?

It turns audio and video files into text and subtitles. Give it direct file links, upload your own files, or add a
public podcast RSS feed, and you get:

- the full transcript as plain text;
- timed segments (start, end, text) as JSON;
- SRT and VTT subtitle files, ready for video editors and players.

It runs the open-source Whisper speech recognition model (through faster-whisper) inside the run itself. There's no
API key to bring and no third-party service: your audio never leaves the run.

### What you get

|  |  |
|---|---|
| **Input** | Direct audio/video links (mp3, m4a, wav, ogg, flac, mp4, mov, webm), your own uploads, or public podcast RSS feeds |
| **Output** | Full text, timed segments (JSON), and SRT + VTT subtitle files |
| **Model** | Whisper small (accurate) or base (fast), run inside the tool; no API key, no third-party service |
| **Languages** | ~99, best on English and other major languages |
| **Podcasts** | 'Only new episodes' transcribes just the episodes it hasn't seen |
| **Price** | $0.009 per audio minute (fast: $0.005) + $0.005 per file transcribed |

### What can I transcribe?

- **Direct links** to audio or video files: mp3, m4a, wav, ogg, flac, mp4, mov, webm.
- **Your own files**, uploaded through the input form.
- **Public podcast RSS feeds.** The newest episodes are transcribed. With "Only new episodes", a scheduled run
  transcribes only the episodes it hasn't seen before. That's the easiest way to get every new episode as text
  automatically.

**Not supported:** YouTube, TikTok, Spotify, Apple Podcasts pages, SoundCloud, and other streaming, DRM or login
platforms. Their terms don't allow downloading, so those links get a status row saying so and are never fetched.
For a podcast, use the show's own public RSS feed instead. Links that a site's robots.txt disallows are skipped too.

### How much does it cost?

You pay per audio minute, charged as the minutes are transcribed, plus a small fee per file transcribed:

| Mode | Model | Price |
|---|---|---|
| Accurate (default) | Whisper small | **$0.009 per audio minute** ($9 per 1,000 minutes), on every Apify plan |
| Fast | Whisper base | **$0.005 per audio minute** ($5 per 1,000 minutes); less on paid Apify plans |
| Every file | | **$0.005 per file transcribed**, only when it succeeds |

- A 30-minute podcast episode costs $0.275 in accurate mode, or $0.155 in fast mode.
- The last started minute counts as a full minute.
- **You're never charged** for a file that can't be downloaded or decoded, or that has no speech.
- Apify's standard run start fee applies.
- Set a spending limit on the run, and the tool stops there and returns the transcript up to that point.

### Input

| Field | What it does |
|---|---|
| Audio or video files | Direct links, or your uploads |
| Public podcast RSS feeds | Feed URLs |
| Episodes per feed | The most episodes per feed in one run (default 1) |
| Max minutes per file | A cost guard: only the first N minutes of each file are transcribed and charged (empty = all) |
| Feeds: which episodes | "The newest episodes" or "Only new episodes (for schedules)" |
| Model | Accurate (small) or Fast (base) |
| Language | `auto` to detect, or a code such as `en`, `de`, `es` |
| Task | Transcribe in the spoken language, or translate to English |
| Output | Everything, plain text, segments, SRT or VTT |
| Word timestamps | Off by default. On: each segment also lists its words with start/end times and a confidence (same price) |

### Output

One row per file:

```json
{
  "id": "file:3f2a…",
  "statusCode": "ok",
  "sourceUrl": "https://example.com/episode-42.mp3",
  "sourceType": "rss",
  "episodeTitle": "Episode 42",
  "language": "en",
  "durationSec": 1834.2,
  "minutesCharged": 31,
  "text": "Welcome back to the show…",
  "segments": [{"start": 0.5, "end": 4.2, "text": "Welcome back to the show."}],
  "srtUrl": "https://api.apify.com/v2/key-value-stores/…/records/transcript-3f2a….srt",
  "vttUrl": "https://api.apify.com/v2/key-value-stores/…/records/transcript-3f2a….vtt",
  "generatedBy": "whisper-small (automatic speech recognition)"
}
```

Files that couldn't be processed get a row with `changeType: "status"` and a `statusCode`: `platform_not_supported`,
`robots_disallowed`, `download_failed`, `decode_failed`, `no_audio`, `no_speech` or `feed_failed`. The run's OUTPUT
record sums it up: files, transcribed, minutes charged, status rows, and whether the spending limit was reached.
With 'Word timestamps' on, each segment also has `words`: `[{"word": "Welcome", "start": 0.5, "end": 0.86, "probability": 0.97}, ...]`
(the segments are then included whatever the Output choice). Same price per minute.
A file cut by 'Max minutes per file' is transcribed up to that point and says so: `statusCode:
"trimmed_at_max_minutes"`, with the file's full length in `durationSec` and the minutes read in `minutesCharged`.

### Languages and accuracy

Whisper knows ~99 languages. It works best on English and other major languages; smaller languages get more word
errors. Try a short sample in your language first.

Like every speech recognition model, Whisper can sometimes produce text during music or noise ("hallucinations").
Voice detection and other settings reduce this, but check important transcripts. Every row says it was generated by
automatic speech recognition (`generatedBy`).

### Speed and limits

- In accurate mode, an hour of audio takes about 20 minutes; fast mode is about 3 times faster.
- Files up to 2 GB. The run timeout is 2 hours, which is enough for about 5 hours of audio in accurate mode.

### Your responsibility

Only transcribe audio you have the rights to. If it records people (for example, calls or meetings), make sure you
have their consent where the law requires it. We don't keep, read or reuse your audio or transcripts: they stay in
your own Apify storage.

### How it compares

| Instead of | With this tool |
|---|---|
| Typing it out by hand | A 30-minute episode in about 10 minutes of processing, for $0.275 |
| A transcription API with its own key | No account or key to bring: the model runs inside the run, and your audio isn't sent anywhere |
| Subtitles made in a video editor | SRT and VTT files come with every transcript |

### FAQ

**Can I run it on a schedule?** Yes. Add a podcast RSS feed, choose "Only new episodes" and schedule the run. A run
with nothing new finishes in seconds and costs only Apify's run start fee.

**Can I use it through the API or with AI agents?** Yes, like any Apify Actor: through the Apify API, the client
libraries, integrations (Make, Zapier, n8n), webhooks or MCP.

**Is this affiliated with OpenAI?** No. It uses the open-source Whisper model (MIT licence) through faster-whisper.

**Which file types work?** mp3, m4a, wav, ogg, flac, mp4, mov and webm, by direct link or upload, up to 2 GB per file.

**Why isn't YouTube supported?** YouTube, TikTok, Spotify, Apple Podcasts pages and SoundCloud don't allow downloading in their terms, so those links get a status row and are never fetched. For a podcast, use the show's public RSS feed.

**Am I charged when a file fails?** No. Files that can't be downloaded or decoded, or have no speech, are free.

**My file is bigger than 25 MB. Will it work?** Yes. Files up to 2 GB work, by direct link or upload, and one run can take about 5 hours of audio in accurate mode. The 25 MB cap belongs to hosted transcription APIs such as OpenAI's; this tool runs Whisper inside the run, so there's no upload cap of that kind. You pay $0.009 per audio minute (fast mode: $0.005) plus $0.005 per file transcribed, so a 1-hour recording costs $0.545 in accurate mode.

**Can I shrink a file for a 25 MB API instead?** Yes, if you can run ffmpeg. Keep only the audio, as mono 16 kHz at 32 kbps: `ffmpeg -i input.mp4 -vn -ac 1 -ar 16000 -b:a 32k output.mp3`. An hour of speech is then about 14 MB. For longer recordings, cut it into 15-minute parts with `ffmpeg -i output.mp3 -f segment -segment_time 900 -c copy part%03d.mp3` and send each part separately. Use this tool when you can't run ffmpeg (for example on a hosted automation platform) or don't want to split and join files.

**How do I call it from n8n, Make or Zapier?** Use Apify's integration for that platform and run the Actor `afterstar/audio-transcriber` with input like `{"audioUrls": [{"url": "https://example.com/episode.mp3"}]}`; the transcript rows are in the run's dataset. From a plain HTTP request, POST the same input to `https://api.apify.com/v2/acts/afterstar~audio-transcriber/run-sync-get-dataset-items` with your Apify token. That call waits up to 5 minutes, which is enough for short clips; for long files, start the run and read the dataset when it finishes (or add a webhook).

### More Afterstar tools

- [OCR Image to Text - Bulk Images, Screenshots & Scanned PDFs](https://apify.com/afterstar/image-ocr): Reads the printed text in images, screenshots and scanned PDFs (every page) in 31 languages: clean text, confidence, and optionally every word with its box.

Found a problem or need a feature? Open an issue on the Issues tab.

# Actor input Schema

## `audioUrls` (type: `array`):

Direct links to audio or video files (mp3, m4a, wav, ogg, flac, mp4, mov, webm), or upload your own files. YouTube, TikTok, Spotify, Apple Podcasts and SoundCloud are not supported.

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

Upload one of your own audio or video files (it goes to a key-value store in your account), or paste a link.

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

RSS feed URLs. The newest episodes are transcribed (see the limit below). With 'Only new episodes', a scheduled run transcribes only episodes it hasn't seen.

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

How many episodes per feed and run, at most.

## `maxMinutesPerFile` (type: `integer`):

A cost guard: only the first N minutes of each file or episode are transcribed and charged. The row says so (statusCode 'trimmed_at_max_minutes'). Empty = the whole file.

## `outputMode` (type: `string`):

For podcast feeds: transcribe the newest episodes, or only episodes not seen in earlier runs (use this with a schedule).

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

Accurate uses Whisper small ($0.009 per audio minute). Fast uses Whisper base ($0.005 per minute), about 3 times faster with more word errors.

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

'auto' to detect, or a code such as en, de, es, fi.

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

Transcribe in the language spoken, or translate the speech to English text.

## `outputFormat` (type: `string`):

What each result contains. SRT and VTT files are saved in the run's key-value store, with links in the row.

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

Each timed segment also lists its words with start and end times and a confidence (0-1), for karaoke-style captions, search or editing. Same price; a run takes about 10 % longer. The segments are included whatever the Output choice.

## Actor input object example

```json
{
  "audioUrls": [
    {
      "url": "https://upload.wikimedia.org/wikipedia/commons/d/dd/Armstrong_Small_Step.ogg"
    }
  ],
  "maxEpisodesPerFeed": 1,
  "outputMode": "all",
  "model": "small",
  "language": "auto",
  "task": "transcribe",
  "outputFormat": "all",
  "wordTimestamps": 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 = {
    "audioUrls": [
        {
            "url": "https://upload.wikimedia.org/wikipedia/commons/d/dd/Armstrong_Small_Step.ogg"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("afterstar/audio-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 = { "audioUrls": [{ "url": "https://upload.wikimedia.org/wikipedia/commons/d/dd/Armstrong_Small_Step.ogg" }] }

# Run the Actor and wait for it to finish
run = client.actor("afterstar/audio-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 '{
  "audioUrls": [
    {
      "url": "https://upload.wikimedia.org/wikipedia/commons/d/dd/Armstrong_Small_Step.ogg"
    }
  ]
}' |
apify call afterstar/audio-transcriber --silent --output-dataset

```

## MCP server setup

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