# Audio, Video & Podcast Transcriber (Whisper) (`singgendarhan/audio-video-podcast-transcriber`) Actor

Transcribe audio and video files and podcast RSS episodes with OpenAI Whisper (faster-whisper, CPU). Get full text, timestamped segments, language detection and SRT + VTT subtitles. Pay per audio minute, only for transcripts that were saved.

- **URL**: https://apify.com/singgendarhan/audio-video-podcast-transcriber.md
- **Developed by:** [Nick Na](https://apify.com/singgendarhan) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.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?

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 & Podcast Transcriber (Whisper)

Turn audio files, videos and podcast episodes into **text, timestamped segments and SRT + VTT subtitles** with OpenAI's Whisper speech recognition. Paste direct links to media files, point it at files in your Apify storage, or give it a **podcast RSS feed** and it transcribes the latest episodes. You get one clean dataset row per file, plus downloadable `.srt`, `.vtt`, `.txt` and `.json` files.

**You pay per minute of audio, only for transcripts that were saved.** Broken links, unsupported files and refused URLs cost nothing.

Built for podcasters, content-repurposing workflows, researchers, journalists and no-code automations (n8n, Make, Zapier). It also works with **AI agents** through Apify's MCP server: clear input fields, predictable output, stable error codes.

> **Your media, your rights.** This Actor only transcribes media files you supply and podcast RSS enclosures, the download links podcast feeds publish for apps. It does **not** download from YouTube, TikTok, Instagram, Facebook, X/Twitter, Vimeo, Twitch, Spotify, SoundCloud, Apple Music, Netflix or similar platforms, whose terms forbid downloading. Such links are refused per item at no charge. It uses no cookies, logins or workarounds of any kind. **Only submit media you own or have permission to transcribe.**

### What it does

- **Transcribes audio and video:** mp3, m4a, wav, ogg, opus, flac, aac, mp4, webm, mov, mkv, avi and more. ffmpeg decodes the audio track; video is ignored.
- **Podcast RSS feeds:** reads the feed (RSS 2.0 with iTunes tags, Atom, RSS 1.0) and transcribes the **latest N episodes**, or only episodes **published since a date**. That is ideal for a daily or weekly schedule. A podcast website that links to its feed works too.
- **99 languages,** detected automatically from the first 30 seconds, or set by you.
- **Translate to English:** Whisper's built-in speech translation turns any supported language into English text and subtitles. It works best with Balanced quality.
- **Subtitles ready to upload:** SRT and WebVTT, split into readable cues of at most 2 lines and about 7 seconds each.
- **Word-level timestamps (optional):** start, end and confidence for every word. Useful for editing tools, karaoke-style captions and search.
- **Skips silence and music** with voice activity detection. That is faster and avoids made-up text in silent parts.
- **Vocabulary hint:** give names and jargon so Whisper spells them right, for example "Interview with Dr. Anika Okafor about CRISPR" or "A LibriVox recording". Without the hint, Fast heard "LibriVox" as "liberal box" in our tests.
- **Long files:** a 3-hour episode runs in the default 4 GB of memory. Audio is processed in 10-minute chunks cut at quiet moments.
- **Bulk and robust:**
  - downloads are polite: at most 2 at a time per host, with retries and backoff that honor `Retry-After`, and they resume interrupted transfers;
  - size, duration and content type are checked first;
  - one bad file never fails the run; it gets a row with an `errorCode`.
- **Spending cap respected:** if you set a maximum cost per run, the Actor stops cleanly before going over and marks the remaining files `skipped`.

### Use cases

- **Podcasters:** transcripts and captions for every episode, show notes, blog posts, SEO pages and accessibility. Schedule the Actor with `episodesSince` to catch new episodes automatically.
- **Content repurposing:** turn webinars, talks and interviews into text for articles, newsletters, social posts or LLM summarization.
- **Research:** transcribe interviews, focus groups, lectures, oral histories and public-domain archives in bulk, then search, code or analyze them.
- **Video teams:** SRT/VTT subtitles for your own videos; upload to your video host or player.
- **AI agents and automations:** an agent or an n8n/Make/Zapier flow sends a file URL and reads back `text`, `segments` and `srtUrl`.

### How to use

1. Paste **media file URLs** (one per line), and/or **podcast RSS feed URLs**, and/or point to records in an Apify **key-value store**.
2. Pick **Quality**:

   - **Fast** (Whisper base) is the default and fits clear speech;
   - **Balanced** (Whisper small) is more accurate on accents, noisy recordings and non-English speech, and about 3x slower.

   Fast costs $0.008 per minute, Balanced $0.016.
3. Optionally set the **language**, **translate to English**, **word timestamps**, a **vocabulary hint**, or the **episodes per feed / since date**.
4. Click **Start**. Results appear in the **Output** tab: status, language, duration, the transcript, and links to the SRT, VTT and JSON files.

#### Input example

```json
{
    "mediaUrls": [
        "https://images-assets.nasa.gov/video/jsc2026m000070-Artemis_II_Receive_Special_Message_from_Apollo_16_Astronaut_Charlie_Duke/jsc2026m000070-Artemis_II_Receive_Special_Message_from_Apollo_16_Astronaut_Charlie_Duke~mobile.mp4"
    ],
    "rssFeedUrls": ["https://feeds.megaphone.fm/nationalaeronauticsandspaceadministration1776343825"],
    "maxEpisodesPerFeed": 2,
    "quality": "fast",
    "language": "auto",
    "wordTimestamps": false
}
```

| Field | Default | What it does |
|---|---|---|
| `mediaUrls` | none | Direct http(s) links to audio/video files. Objects like `{"url": "..."}` are accepted too. |
| `rssFeedUrls` | none | Podcast RSS/Atom feed URLs (or a podcast website that links to its feed) |
| `maxEpisodesPerFeed` | `3` | Latest episodes per feed (1–500) |
| `episodesSince` | none | Only episodes published on/after this date (`YYYY-MM-DD`, or relative like `7 days`) |
| `quality` | `fast` | `fast` (Whisper base) or `balanced` (Whisper small) |
| `language` | `auto` | Whisper language code (`en`, `es`, `de`, `fr`, `pt`, `ja`, `zh`...) or `auto` |
| `translateToEnglish` | `false` | Output an English translation instead of the original language |
| `wordTimestamps` | `false` | Add per-word start/end/probability to segments and the JSON file |
| `skipSilence` | `true` | Voice activity detection: skip long silences and music |
| `initialPrompt` | none | Vocabulary hint: names, brands, jargon (max 600 characters) |
| `keyValueStoreId` / `keyValueStoreKeys` | none | Transcribe files stored in an Apify key-value store |
| `maxDurationMinutes` | `180` | Longer files are refused (up to 600) |
| `maxFileSizeMb` | `1000` | Larger downloads are stopped (up to 4000) |
| `itemTimeoutMinutes` | `120` | Time limit per file for download, and separately for transcription |

#### Output example

One dataset row per file or episode. The transcript files are in the run's key-value store:

```json
{
    "index": 0,
    "sourceType": "url",
    "source": "https://images-assets.nasa.gov/video/jsc2026m000070-.../...~mobile.mp4",
    "status": "succeeded",
    "language": "en",
    "languageProbability": 0.99,
    "durationSeconds": 58.3,
    "billedMinutes": 1,
    "wordCount": 106,
    "text": "Hello, Reed, Victor, Christina and Jeremy. This is Apollo 16 astronaut Charlie Duke. John Young and I landed on the moon in 1972 in the lunar module we named Orion. ...",
    "segments": [
        { "id": 0, "start": 5.3, "end": 10.5, "text": "Hello, Reed, Victor, Christina and Jeremy." },
        { "id": 1, "start": 10.5, "end": 14.4, "text": "This is Apollo 16 astronaut Charlie Duke." }
    ],
    "srtUrl": "https://api.apify.com/v2/key-value-stores/<storeId>/records/transcript-0000-jsc2026m000070-Artemis_II_Receive_Special_Message_from_Apoll.srt",
    "vttUrl": "https://api.apify.com/v2/key-value-stores/<storeId>/records/transcript-0000-....vtt",
    "txtUrl": "https://api.apify.com/v2/key-value-stores/<storeId>/records/transcript-0000-....txt",
    "jsonUrl": "https://api.apify.com/v2/key-value-stores/<storeId>/records/transcript-0000-....json",
    "quality": "fast",
    "model": "whisper-base",
    "task": "transcribe",
    "mediaFormat": "mov",
    "hasVideo": true,
    "processingSeconds": 5.0,
    "realTimeFactor": 0.086,
    "chargedEvents": { "audio-minute-transcribed": 1 },
    "errorCode": null,
    "errorMessage": null
}
```

Podcast episodes also carry `feedUrl`, `feedTitle`, `episodeTitle`, `episodeGuid`, `episodePublishedAt` and `episodeLink`.

A refused or failed item looks like this. It is never charged:

```json
{ "index": 3, "source": "https://www.youtube.com/watch?v=...", "status": "failed", "chargedEvents": {},
  "errorCode": "PLATFORM_NOT_SUPPORTED",
  "errorMessage": "This Actor only transcribes media files you supply or podcast RSS enclosures. YouTube links are not supported, because YouTube's terms do not allow downloading its content. ..." }
```

The `OUTPUT` record in the key-value store holds a run summary: `total`, `succeeded`, `failed`, `skipped`, `audioMinutesTranscribed`, `chargedEvents`.

**Error codes** (status `failed`, or `skipped` for `RUN_STOPPED`):

| Code | Meaning |
|---|---|
| `INVALID_URL` | Not a valid http(s) URL |
| `PLATFORM_NOT_SUPPORTED` | A streaming/social platform link (YouTube, TikTok, Spotify...) or an Apple Podcasts page |
| `URL_NOT_ALLOWED` | The host resolves to a private or local network address |
| `DOWNLOAD_FAILED` | HTTP error, DNS failure or network error after retries |
| `DOWNLOAD_TIMEOUT` | The server was too slow |
| `NOT_A_MEDIA_FILE` | The URL returned a web page, a document or a streaming playlist (HLS/DASH), not a file |
| `FILE_TOO_LARGE` | Over `maxFileSizeMb` |
| `UNSUPPORTED_MEDIA` | ffmpeg cannot read the file |
| `NO_AUDIO_TRACK` | A video without sound |
| `NO_AUDIO` | Empty file or less than 0.1 s of audio |
| `DURATION_TOO_LONG` | Over `maxDurationMinutes` |
| `DECODE_FAILED` | The audio track is corrupt |
| `FEED_FETCH_FAILED` | The RSS feed could not be downloaded |
| `NOT_A_FEED` | The URL is not an RSS/Atom feed (and does not link to one) |
| `FEED_HAS_NO_EPISODES` | No episodes with audio/video, or none since `episodesSince` |
| `KVS_RECORD_NOT_FOUND` | The key-value store or record does not exist |
| `ITEM_TIMEOUT` | Over `itemTimeoutMinutes` |
| `OUT_OF_MEMORY` | Run with more memory |
| `TRANSCRIPTION_FAILED` | Unexpected error (please report it with the run ID) |
| `RUN_STOPPED` | Skipped because the run reached your maximum cost or was aborted |

### Pricing

This Actor uses **pay-per-event** pricing. You pay for transcribed audio, not for compute time:

| Event | Price | When |
|---|---|---|
| Audio minute transcribed (Fast quality, the default) | **$0.008 per started minute** | For each file or episode whose transcript was saved |
| Audio minute transcribed (Balanced quality) | **$0.016 per started minute** | The same, with the larger Whisper small model (about 3x more compute) |
| Actor start | Apify's standard start fee | Once per run |

Examples:

- a 58-second clip: 1 minute = **$0.008** (Balanced: $0.016);
- a 42-minute podcast episode: **$0.336**;
- 10 hours of interviews: **$4.80**;
- failed, refused or skipped files: **$0**.

Minutes are rounded up per file, with 1 second of tolerance: 1:00.9 is billed as 1 minute, 1:01.5 as 2. Set **Max cost per run** in the run options to cap spending. The Actor checks the budget before each file and stops cleanly at the limit.

### Speed, limits and good to know

- **Speed (CPU).** With the default 4 GB of memory (1 CPU core):

  - **Fast** transcribes about **12–14x faster than real time**: our 69-minute test podcast took 4 min 50 s;
  - **Balanced** runs at about **4–5x real time**: about 13–15 minutes per hour of audio.

  More memory (up to 16 GB = 4 cores) processes several files, or several parts of one long file, in parallel. On 4 cores the same 69-minute podcast took 1 min 45 s. This is a CPU Actor, cheaper per minute than GPU tools, but not instant.
- **Accuracy.**
  - Whisper is very good on clear speech in major languages.
  - Use **Balanced** for strong accents, noisy or old recordings, phone or radio audio, and most non-English content.
  - Names and jargon improve with a vocabulary hint.
  - Like every Whisper model, it can occasionally repeat or invent a phrase in long silences or music. Keep "Skip silence and music" on.
- **No speaker labels (diarization)** in this version.
- **Limits.** Up to 600 minutes and 4 GB per file (defaults 180 minutes and 1 GB), and up to 5,000 inputs per run. Streaming playlists (HLS `.m3u8`, DASH `.mpd`) are not supported.
- **Where your files live.** In the run's default key-value store. Unnamed storages expire after the retention period of your Apify plan, so download or copy what you need.
- **Public URLs only.** Links to private or local network addresses are blocked. Private files: upload them to an Apify key-value store and use `keyValueStoreId` + `keyValueStoreKeys`.

### Use it from code, n8n, Make or agents

Run it synchronously and get the dataset back in one HTTP call (best for short files; synchronous runs time out after 300 s):

```bash
curl -X POST "https://api.apify.com/v2/acts/<ACTOR_ID>/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"mediaUrls": ["https://example.com/interview.mp3"], "quality": "fast"}'
```

In **n8n** or **Make**, use the Apify "Run Actor" node or module with the same JSON, then read `text`, `segments` or `srtUrl` from the dataset items. For new podcast episodes, schedule the Actor (Apify Schedules) with `rssFeedUrls` and `episodesSince: "7 days"`. AI agents can call it through the Apify MCP server; the input and dataset schemas describe every field.

### FAQ

**Can I transcribe YouTube, TikTok, Instagram or Spotify links?** No. Those platforms' terms do not allow downloading their content, so those links are refused at no charge. If you own the video, upload the original file (or a direct link to it) instead. For podcasts, use the show's RSS feed: it is published so apps can download episodes.

**Do I pay for files that fail?** No. Charges happen only after the transcript files are saved. Every failure gets an error code and costs $0.

**Why does Balanced cost more?** Whisper small needs about 3x more computing time per minute than Whisper base. Translation and word timestamps cost the same as plain transcription.

**Where do I find a podcast's RSS feed?** Your podcast host shows it ("RSS feed" in the show settings). For other shows, the podcast's website usually links to it. You can also paste the website URL and the Actor will look for the feed link. Apple Podcasts and Spotify pages don't work.

**How accurate is it?**

- On clear English speech, Fast got **94–96% of words right** in our tests (word error rate 4–6%, for example against NASA's human-made captions).
- Balanced is better on old, noisy and non-English audio: 97% vs. 94% on a 1941 radio recording.
- Results vary with audio quality, accents and jargon.
- Numbers come out as digits ("1972"), and punctuation and capitalization are included.

**Can it identify who is speaking?** Not yet (no diarization).

**Do you keep my audio?** No. Files are downloaded to temporary storage during the run and deleted right after transcription. Results are written only to your run's storage. Logs contain URLs and timings, not audio or transcripts.

**Can I use the transcripts commercially?** Yes. The models are MIT-licensed (OpenAI Whisper). You need the rights to the media you transcribe.

**Something looks wrong?** Open an issue on the Issues tab with the run ID. We read every one.

### Credits

- Whisper by OpenAI (MIT), https://github.com/openai/whisper. Runs via faster-whisper (MIT) by SYSTRAN, https://github.com/SYSTRAN/faster-whisper, and CTranslate2 (MIT).
- Silero VAD (MIT), https://github.com/snakers4/silero-vad
- FFmpeg (GPL/LGPL), https://ffmpeg.org, from Debian.
- The example video is NASA's public-domain "Artemis II Receive Special Message from Apollo 16 Astronaut Charlie Duke". NASA does not endorse this Actor.

# Changelog

This Actor's version history is a separate document: https://apify.com/singgendarhan/audio-video-podcast-transcriber/changelog.md

# Actor input Schema

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

Direct links to audio or video files, one per line: mp3, m4a, wav, ogg, opus, flac, aac, mp4, webm, mov, mkv and more. Links to records in an Apify key-value store work too. Pages on streaming or social platforms (YouTube, TikTok, Instagram, Facebook, X, Vimeo, Twitch, Spotify, SoundCloud, Apple Music, Netflix...) are refused at no charge. You must have the right to transcribe the media.

## `rssFeedUrls` (type: `array`):

Podcast RSS (or Atom) feed URLs, one per line. The Actor reads each feed and transcribes the latest episodes from their enclosure (download) URLs. A podcast website that links to its feed works too. Apple Podcasts and Spotify pages do not: use the show's RSS feed URL (your podcast host shows it).

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

How many of the latest episodes to transcribe from each feed (newest first).

## `episodesSince` (type: `string`):

Optional. Only transcribe episodes published on or after this date (YYYY-MM-DD). Combine with 'Episodes per feed' to cap the number. Useful for scheduled runs that pick up new episodes.

## `quality` (type: `string`):

Fast ($0.008/min) uses Whisper base: about 12x faster than real time on one CPU core, good for clear speech (podcasts, talks, interviews). Balanced ($0.016/min) uses Whisper small: more accurate on accents, noisy or old recordings and non-English speech, about 3x slower.

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

'auto' detects the spoken language from the first 30 seconds. Set a language code (en, es, de, fr, pt, it, nl, ja, zh, ru, pl, uk, tr, ar, hi, ko...) if you know it: it avoids misdetection on short or music-heavy intros. Whisper supports 99 languages.

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

Output an English translation instead of a transcript in the original language (Whisper's built-in speech translation). Works much better with quality 'Balanced'. Same price.

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

Add start/end times (and a confidence score) for every word to the segments in the dataset and in the JSON file. Subtitles are then cut exactly at word boundaries. Makes transcription about 20-40% slower; same price.

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

Use voice activity detection to skip long silences and music before transcribing. Faster and reduces made-up text in silent parts. Turn off only if speech is being cut.

## `initialPrompt` (type: `string`):

Names, brands and jargon that appear in the audio, written as a short sentence (for example: 'Interview with Dr. Anika Okafor about CRISPR and mRNA vaccines.'). Helps Whisper spell them correctly. Max 600 characters.

## `keyValueStoreId` (type: `string`):

Optional. ID or name of an Apify key-value store that holds audio/video files to transcribe (use together with 'Record keys'). Leave empty if you only use URLs or feeds.

## `keyValueStoreKeys` (type: `array`):

Keys of the audio/video records in the key-value store above, one per line (for example interview-01.mp3).

## `maxDurationMinutes` (type: `number`):

Files or episodes longer than this are not transcribed (and not charged); they get a DURATION_TOO_LONG error instead. Up to 600 minutes.

## `maxFileSizeMb` (type: `number`):

Downloads larger than this are stopped with a FILE_TOO_LARGE error (not charged). Video files are much larger than audio: 1 hour of 720p video is about 1 GB.

## `itemTimeoutMinutes` (type: `number`):

Maximum time for downloading one file, and separately for decoding and transcribing it. A file that takes longer fails with ITEM_TIMEOUT (not charged). With the default 4 GB memory (1 CPU core), 'Fast' needs about 5-6 minutes per hour of audio and 'Balanced' about 14-15.

## Actor input object example

```json
{
  "mediaUrls": [
    "https://images-assets.nasa.gov/video/jsc2026m000070-Artemis_II_Receive_Special_Message_from_Apollo_16_Astronaut_Charlie_Duke/jsc2026m000070-Artemis_II_Receive_Special_Message_from_Apollo_16_Astronaut_Charlie_Duke~mobile.mp4",
    "https://images-assets.nasa.gov/audio/06-05-26_MCC-H-calls-ISS-to-safe-haven/06-05-26_MCC-H-calls-ISS-to-safe-haven~128k.mp3",
    "https://example.com/recordings/interview.m4a"
  ],
  "rssFeedUrls": [
    "https://feeds.megaphone.fm/nationalaeronauticsandspaceadministration1776343825"
  ],
  "maxEpisodesPerFeed": 3,
  "quality": "fast",
  "language": "auto",
  "translateToEnglish": false,
  "wordTimestamps": false,
  "skipSilence": true,
  "maxDurationMinutes": 180,
  "maxFileSizeMb": 1000,
  "itemTimeoutMinutes": 120
}
```

# Actor output Schema

## `results` (type: `string`):

Status, language, duration, billed minutes, full text, timestamped segments, subtitle links and error details.

## `files` (type: `string`):

SRT and WebVTT subtitles, plain text and full JSON (with word timings if requested) in the run's key-value store.

## `summary` (type: `string`):

Counts of transcribed, failed and skipped files, audio minutes and the events charged.

# 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://images-assets.nasa.gov/video/jsc2026m000070-Artemis_II_Receive_Special_Message_from_Apollo_16_Astronaut_Charlie_Duke/jsc2026m000070-Artemis_II_Receive_Special_Message_from_Apollo_16_Astronaut_Charlie_Duke~mobile.mp4"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("singgendarhan/audio-video-podcast-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://images-assets.nasa.gov/video/jsc2026m000070-Artemis_II_Receive_Special_Message_from_Apollo_16_Astronaut_Charlie_Duke/jsc2026m000070-Artemis_II_Receive_Special_Message_from_Apollo_16_Astronaut_Charlie_Duke~mobile.mp4"] }

# Run the Actor and wait for it to finish
run = client.actor("singgendarhan/audio-video-podcast-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 '{
  "mediaUrls": [
    "https://images-assets.nasa.gov/video/jsc2026m000070-Artemis_II_Receive_Special_Message_from_Apollo_16_Astronaut_Charlie_Duke/jsc2026m000070-Artemis_II_Receive_Special_Message_from_Apollo_16_Astronaut_Charlie_Duke~mobile.mp4"
  ]
}' |
apify call singgendarhan/audio-video-podcast-transcriber --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,singgendarhan/audio-video-podcast-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/HTvb6biJApzmQkPru/builds/NPotRBhq4682nNoPS/openapi.json