# Audio & Video to Text - Whisper Speech-to-Text Transcriber (`teddythebuilder/speech-to-text-transcriber`) Actor

Transcribe audio and video files from URLs to text with OpenAI Whisper (faster-whisper): podcasts, interviews, meetings, voice notes. 99 languages with auto-detect, timestamped segments, SRT and WebVTT subtitles, optional translation to English. No API key, no external AI service.

- **URL**: https://apify.com/teddythebuilder/speech-to-text-transcriber.md
- **Developed by:** [Teddy Wasserman](https://apify.com/teddythebuilder) (community)
- **Categories:** AI, Developer tools, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.40 / 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 & Video to Text do?

Audio & Video to Text **transcribes audio and video files into text**. Give it direct links to audio files, or the RSS feed of a podcast to transcribe its newest episodes. It handles podcast episodes, interviews, meeting recordings, voice notes, lectures or video files, and get back the full transcript, timestamped segments and, if you want, ready-to-use **SRT and WebVTT subtitles** and word-level timestamps. The language is detected automatically (99 languages) or set by you, and it can translate speech from any supported language into English.

It runs **OpenAI's open-source Whisper model** (through faster-whisper, MIT licence) inside the Actor. There is no Google, OpenAI or other external API behind it, no API key to set up, and your audio is not sent to a third party. You choose between three model sizes: Tiny (fastest), Base (the default, good for clear speech) and Small (clearly more accurate on accents, names and noisy recordings).

### Why use Audio & Video to Text?

- **No API key, no per-token bills.** Paste URLs and run. You pay per minute of audio, with a published price and no hidden model fees.
- **Podcasts, interviews and meetings in bulk.** Hundreds of files in one run, from a list of URLs, from a podcast's RSS feed (the newest N episodes, with show and episode title and publication date), or from the file links in another Actor's dataset.
- **Subtitles and timestamps included.** Every phrase has a start and end time. Switch on SRT and WebVTT to get subtitle files for video editors and players, or word timestamps for search and highlighting.
- **99 languages with auto-detect.** The spoken language is detected from the first 30 seconds and returned with a confidence value. English, Swedish, German, French, Spanish, Japanese and many more are supported.
- **Translate to English.** One switch turns a Spanish, German or Swedish recording into an English transcript.
- **Made for pipelines.** Chain it after the Bulk Image & File Downloader or a podcast scraper via the dataset input, and send the text to a vector database, an LLM or a spreadsheet.
- **Honest billing.** Files that can't be downloaded, pages that are not audio or video, files over your limits and links blocked by `robots.txt` are free.

### What data can you extract?

| Field | Example | Description |
|---|---|---|
| `url` | `https://.../episode-12.mp3` | The file that was transcribed |
| `language` / `languageProbability` | `en` / `0.999` | Spoken language and the model's confidence |
| `durationSeconds` / `durationMinutes` | `259.2` / `4.32` | Length of the audio |
| `text` | `And so my fellow Americans ask not what your country can do for you…` | The full transcript |
| `wordCount` / `segmentCount` | `22` / `2` | Words and phrases found |
| `segments` | `[{"start": 0, "end": 7.6, "text": "…"}]` | Timestamped phrases (seconds); each segment also has `words` when word timestamps are on |
| `srt` / `vtt` | `1\n00:00:00,000 --> 00:00:07,600\n…` | Subtitle files as strings (optional) |
| `podcast` / `episodeTitle` / `publishedAt` | `NPR News Now` | Only for podcast feed input: show, episode title and publication time |
| `model` / `task` | `base` / `transcribe` | Model used, transcribe or translate |
| `minutesBilled` | `5` | Audio minutes charged (rounded up) |
| `processingSeconds` | `38.2` | Time the transcription took |

### How to use Audio & Video to Text (step by step)

1. Click **Try for free**.
2. Paste the **Audio / video file URLs**, one per line, or add **Podcast RSS feed URLs** and the number of **Episodes per feed**, or pick a **Dataset** from another run and set its **URL field**.
3. Choose the **Model**. Base is the right default; use Small for difficult audio.
4. Leave **Spoken language** empty to auto-detect, or enter a code such as `sv` to skip detection.
5. Optional: switch on **Include SRT and WebVTT subtitles**, **Word-level timestamps** or **Translate to English**, and set **Max audio minutes per run** so a long list can't surprise you.
6. Click **Start**. Open the **Transcripts** view or export to JSON, CSV or Excel.

### Input example

For a podcast, replace `audioUrls` with `"podcastFeedUrls": ["https://feeds.npr.org/500005/podcast.xml"], "episodesPerFeed": 3`.

```json
{
  "audioUrls": [
    "https://upload.wikimedia.org/wikipedia/commons/e/e0/Interview_with_Warren_Hanson_regarding_Hundred_Flowers.ogg"
  ],
  "model": "base",
  "language": "",
  "includeSubtitles": true,
  "maxMinutesTotal": 60
}
```

### Output example

```json
{
  "url": "https://raw.githubusercontent.com/ggerganov/whisper.cpp/master/samples/jfk.wav",
  "foundIn": "url",
  "contentType": "audio/wav",
  "model": "base",
  "task": "transcribe",
  "language": "en",
  "languageProbability": 0.929,
  "durationSeconds": 11.0,
  "durationMinutes": 0.18,
  "text": "And so my fellow Americans ask not what your country can do for you, ask what you can do for your country.",
  "wordCount": 22,
  "segmentCount": 2,
  "segments": [
    {"start": 0.0, "end": 7.6, "text": "And so my fellow Americans ask not what your country can do for you,"},
    {"start": 7.6, "end": 10.6, "text": "ask what you can do for your country."}
  ],
  "minutesBilled": 1,
  "processingSeconds": 0.8,
  "scrapedAt": "2026-11-04T12:54:10Z"
}
```

### How much does it cost?

Audio & Video to Text uses pay-per-event pricing.

| Event | Price (Free plan) | When it is charged |
|---|---|---|
| Actor start | $0.0005 | Once per run |
| Audio minute (Tiny and Base) | $0.008 ($8 per 1,000 minutes) | Every started minute of audio that was transcribed |
| Audio minute (Small model) | $0.016 ($16 per 1,000 minutes) | Every started minute, when you pick the Small model |

Each file is rounded up to whole minutes, so a 30-second clip is one minute. Files that can't be downloaded, are not audio or video, exceed the size or length limit, or are blocked by `robots.txt` are **free**. Paid Apify plans get Store discounts (Bronze −15%, Silver −30%, Gold and up −45%).

Worked examples (Free plan prices, Base model):

- **A 45-minute podcast episode:** 45 × $0.008 ≈ **$0.36**.
- **20 customer-interview recordings of 30 minutes:** 600 minutes ≈ **$4.80**.
- **A one-hour lecture with the Small model:** 60 × $0.016 ≈ **$0.96**.

**Speed.** A 4.3-minute interview took 52 seconds with Base and 126 seconds with Small for the whole run, including model start-up, on the default 4 GB memory. Long files scale roughly linearly, so an hour of audio takes around 10 minutes with Base. The first file of a run is a little slower because the model loads.

### Use cases

- **Podcast and video show notes.** Transcribe every episode, then summarise, chapter or search it.
- **Subtitles.** Generate SRT or WebVTT for videos you own, in the original language or translated to English.
- **Meeting and interview analysis.** Turn call recordings and user interviews into text for analysis, tagging or an LLM.
- **Research and journalism.** Transcribe speeches, hearings, field recordings and archive audio.
- **RAG and search.** Put what was said in your audio archive into a vector database with timestamps, so answers can link back to the exact second.
- **Accessibility.** Provide transcripts for audio content.

### Use with AI agents, MCP and the API

```bash
curl -X POST "https://api.apify.com/v2/acts/teddythebuilder~speech-to-text-transcriber/run-sync-get-dataset-items?token=<TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"audioUrls":["https://raw.githubusercontent.com/ggerganov/whisper.cpp/master/samples/jfk.wav"],"model":"base"}'
```

Python with `apify-client`:

```python
from apify_client import ApifyClient

client = ApifyClient("<TOKEN>")
run = client.actor("teddythebuilder/speech-to-text-transcriber").call(run_input={
    "audioUrls": ["https://example.com/episode-12.mp3"],
    "model": "small",
    "includeSubtitles": True,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item.get("language"), item.get("durationMinutes"), (item.get("text") or "")[:200])
```

**MCP:** available as a tool in the Apify MCP server (`https://mcp.apify.com`) for Claude, ChatGPT, Cursor and other MCP clients. Short recordings return within a minute, so agents can use the synchronous endpoint.

### Integrations

Send transcripts to Google Sheets, Airtable, Notion, a vector database, Slack, email, Make, Zapier, n8n or a webhook after each run.

### Data source and legality

The Actor downloads only the audio and video files you link to (or that are in the dataset you choose) and transcribes them locally with the open-source Whisper model. It respects `robots.txt`, sends a clear user agent and does not log in or bypass any protection. No audio is sent to an external AI or transcription service, and no file is stored: audio is deleted when the file is done, and only the text is saved in the dataset.

You are responsible for having the right to process the recordings (copyright, consent of the speakers, personal data). Speech can contain personal data; process recordings only with a legal basis and delete the transcripts when you no longer need them.

### FAQ

**Where do I find a podcast's RSS feed?**
Most podcasts list it on their website ("RSS" link) and hosting services such as Libsyn, Simplecast, Anchor and Buzzsprout publish it. Apple Podcasts and Spotify pages do not show the feed URL directly; search for the show name plus "RSS feed".

**Can it transcribe YouTube or other web page links?**
No. It needs a direct link to the media file (an MP3, MP4, WAV or similar), for example a podcast enclosure URL or a file in cloud storage. Links to web pages are rejected for free. Downloading from YouTube is not supported.

**Which formats work?**
MP3, M4A/AAC, WAV, OGG/Opus, FLAC, MP4, WebM, MOV, MKV and most other common audio and video formats. For video, only the audio track is used.

**Which model should I pick?**
Base for clear speech such as podcasts and meetings. Small if speakers have strong accents, names matter, or the recording is noisy. Tiny only when speed matters more than accuracy.

**Does it identify who is speaking?**
No. There is no speaker diarization. Segments have timestamps but no speaker labels.

**Why is some text missing or odd in a silent or music part?**
Speech models can invent words when there is only noise or music. "Skip silence" (on by default) removes long non-speech parts to avoid this. Always check important transcripts; accuracy depends on audio quality.

**What is the maximum file size or length?**
By default 300 MB and 180 minutes per file; you can change both in the input (up to 1,000 MB, any length with 0). Very long files need more time; raise the run timeout accordingly.

**How is a file billed if it has silence?**
By the full length of the file, rounded up to whole minutes, because the whole file is processed.

**Does it work with private files?**
Only if the URL works without a login, for example a signed link. The Actor never logs in anywhere.

**Questions or bugs?**
Open an issue on the actor page. We reply within 24 hours. If the actor helps you, a rating on the Store page helps others find it.

### Related actors

- [Bulk Image & File Downloader](https://apify.com/teddythebuilder/bulk-file-downloader): collect audio, video and image files from web pages into a dataset, then transcribe them here.
- [Image to Text OCR](https://apify.com/teddythebuilder/image-to-text-ocr): text from images and scanned PDFs.
- [PDF Text Extractor](https://apify.com/teddythebuilder/pdf-text-extractor): text and Markdown from PDFs for LLM and RAG use.
- [Website to Markdown](https://apify.com/teddythebuilder/website-to-markdown): clean Markdown of web pages for LLMs.

### Changelog and support

- **1.1 (November 2026):** podcast RSS feeds: transcribe the newest episodes with show and episode metadata.
- **1.0 (November 2026):** first release. Whisper Tiny, Base and Small; auto language detection; translation to English; timestamped segments, word timestamps, SRT and WebVTT; URL and dataset input.

Questions or feature requests? Open an issue on the actor page. We reply within 24 hours.

# Actor input Schema

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

Direct links to audio or video files (MP3, M4A, WAV, OGG, FLAC, MP4, WebM, MOV, MKV...). One URL per line. Podcast RSS enclosures work too. Web pages and YouTube links are not supported.

## `podcastFeedUrls` (type: `array`):

Transcribe the latest episodes of podcasts: give the RSS feed URL (find it on the podcast's website or in Apple Podcasts via the show's page) and the episode audio files are found automatically.

## `episodesPerFeed` (type: `integer`):

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

## `datasetId` (type: `string`):

Read audio/video URLs from another Apify dataset, e.g. the output of the Bulk Image & File Downloader (field fileUrl) or a podcast scraper.

## `datasetUrlField` (type: `string`):

Field in the dataset items that holds the audio/video URL, e.g. fileUrl, audioUrl, url.

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

Base is a good default for clear speech. Small is noticeably more accurate (names, accents, noise) but slower, so it is billed at a higher rate. Tiny is fastest and least accurate.

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

Two-letter code such as en, sv, de, fr, es, ja. Leave empty to detect it automatically from the first 30 seconds.

## `translateToEnglish` (type: `boolean`):

Output an English translation instead of a transcript in the spoken language.

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

Add a segments array with start/end seconds and text for every phrase.

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

Add ready-to-use srt and vtt strings.

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

Add start/end time for every word (a little slower).

## `skipSilence` (type: `boolean`):

Voice-activity detection removes long silences and music-only parts, which avoids made-up text and speeds things up. Billing still uses the full file length.

## `maxMinutesTotal` (type: `integer`):

Stop starting new files once this many audio minutes were transcribed. You pay per minute of audio.

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

Longer files are skipped for free (set 0 to allow any length).

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

Larger downloads are skipped for free.

## Actor input object example

```json
{
  "audioUrls": [
    "https://raw.githubusercontent.com/ggerganov/whisper.cpp/master/samples/jfk.wav"
  ],
  "podcastFeedUrls": [],
  "episodesPerFeed": 3,
  "datasetUrlField": "url",
  "model": "base",
  "translateToEnglish": false,
  "includeSegments": true,
  "includeSubtitles": false,
  "wordTimestamps": false,
  "skipSilence": true,
  "maxMinutesTotal": 60,
  "maxMinutesPerFile": 180,
  "maxFileSizeMb": 300
}
```

# Actor output Schema

## `results` (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": [
        "https://raw.githubusercontent.com/ggerganov/whisper.cpp/master/samples/jfk.wav"
    ]
};

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,teddythebuilder/speech-to-text-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/qPHU6PGJFLXemAw8Y/builds/Stz8mpa627b4cNwmq/openapi.json