# Video & Audio Transcriber (`parsebird/video-audio-transcriber`) Actor

Transcribe video, audio, and podcasts from 1,800+ sites with OpenAI Whisper (faster-whisper). Get text, timestamped segments, SRT and VTT subtitles. Export as JSON, CSV, or Excel.

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

## Pricing

from $40.00 / 1,000 minute of media transcribeds

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?

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

### Video & Audio Transcriber

**Video & Audio Transcriber** turns any video, audio file, or podcast into text using **OpenAI Whisper** (the fast [`faster-whisper`](https://github.com/SYSTRAN/faster-whisper) implementation) running inside the Actor — **no API key, no OpenAI account**. Paste a **YouTube**, **TikTok**, **Instagram**, **Facebook**, **X (Twitter)**, **SoundCloud**, **Rumble**, **Dailymotion**, or podcast **RSS** URL — or a direct `.mp3` / `.mp4` link — and get back a full transcript, timestamped segments, and ready-to-use **SRT** and **VTT** subtitle files.

<table><tr>
<td style="border-left:4px solid #1C1917;padding:12px 16px;font-weight:600">
Speech-to-text for 1,800+ sites with OpenAI Whisper — pick the tiny, base, or small model, force a language or translate to English, cap minutes per item for cost control, and export transcripts, timestamps, and SRT/VTT subtitles as JSON, CSV, or Excel.
</td>
</tr></table>

##### Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this Actor.

```
Actor: parsebird/video-audio-transcriber (Apify). Transcribes video/audio/podcasts with OpenAI Whisper (faster-whisper), locally, no API key. Call it with ApifyClient.
Input:
  {
    "mediaUrls": ["https://www.youtube.com/watch?v=jNQXAC9IVRw", "https://feed.syntax.fm/rss", "https://traffic.megaphone.fm/ABC.mp3"],
    "model": "base",                // tiny | base | small
    "language": "",                 // "" = auto-detect, else ISO code: en, es, pt, de, fr, ...
    "translateToEnglish": false,     // true -> English translation instead of source language
    "maxMinutesPerItem": 120,        // per-URL cap; you are billed per transcribed minute
    "maxEpisodesPerFeed": 1,         // newest N episodes taken from each podcast feed
    "cookies": "",                   // Netscape cookies.txt for YouTube bot-gate / restricted content
    "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
  }
mediaUrls is required (max 50 per run). Feeds and direct files are fetched directly; the proxy is used only for social networks.
Output: one dataset item per media URL — text, segments[{start,end,text}], srt, vtt, srtFileUrl, vttFileUrl, language, languageProbability, title, uploader, publishedAt, thumbnailUrl, durationSeconds, transcribedSeconds, billedMinutes, wordCount, model, task, sourceType, platform, url, inputUrl, error.
Pricing: pay-per-event, tiered — from $0.04 to $0.05 per transcribed minute. Failed items are never charged.
API docs: https://apify.com/parsebird/video-audio-transcriber/api   Token: https://console.apify.com/account/integrations
```

### What does Video & Audio Transcriber do?

This Actor is a **video and audio transcription** tool and an **automatic subtitle generator**. It downloads the audio from the URL you give it, runs **OpenAI's Whisper** speech-recognition model on it, and returns clean, structured text.

- 🎧 **1,800+ supported sites** — anything [yt-dlp](https://github.com/yt-dlp/yt-dlp) can open: YouTube and YouTube Shorts, TikTok, Instagram Reels, Facebook video, X (Twitter), SoundCloud, Dailymotion, Rumble, Bilibili, Reddit, and more.
- 📰 **Podcast feeds** — pass an RSS or Atom feed URL and the Actor transcribes the newest `maxEpisodesPerFeed` episodes automatically.
- 📁 **Direct media files** — point it at an `.mp3`, `.mp4`, `.wav`, `.m4a`, `.flac`, `.ogg`, `.webm`, or `.mov` URL and it transcribes the file directly, no proxy needed.
- 🧠 **OpenAI Whisper, three sizes** — `tiny` (fastest), `base` (balanced), `small` (most accurate). Models are baked into the Actor image, so nothing downloads at run time.
- 🌍 **99+ languages** — auto-detect the spoken language, or force one with an ISO code. Optionally **translate to English** instead of transcribing.
- 🎬 **Subtitles included** — every result contains an `srt` and a `vtt` string plus direct download links to the stored `.srt` and `.vtt` files.
- ⏱️ **Timestamped segments** — `segments: [{ start, end, text }]` with seconds-precision timing for captions, search, or clipping.
- 💸 **Cost control** — `maxMinutesPerItem` caps how much of each item is transcribed; you are billed only for transcribed minutes, and failed items are never charged.

#### Why use this instead of the OpenAI API?

The OpenAI audio API needs an API key, bills separately, and caps upload size at 25 MB. This Actor runs Whisper **inside the container** with `faster-whisper` (a CTranslate2 reimplementation that is several times faster and lighter than the reference model), pulls the media for you from any supported site, and hands back subtitles and timestamps in one step — all billed through your existing Apify account.

### Supported inputs

| Input type | Example | Notes |
|------------|---------|-------|
| YouTube video / Short | `https://www.youtube.com/watch?v=…` | Add `cookies` if you hit the "sign in to confirm you're not a bot" gate. |
| TikTok video | `https://www.tiktok.com/@user/video/…` | Audio is extracted automatically. Residential proxy recommended. |
| Instagram Reel / post | `https://www.instagram.com/reel/…` | Public content only. |
| Facebook video | `https://www.facebook.com/watch?v=…` | Public content only. |
| X (Twitter) video | `https://x.com/user/status/…` | Public content only. |
| SoundCloud track | `https://soundcloud.com/user/track` | Transcribed directly as audio. |
| Dailymotion video | `https://www.dailymotion.com/video/…` | Supported. |
| Rumble video | `https://rumble.com/v…` | Supported. |
| Podcast RSS / Atom feed | `https://feed.syntax.fm/rss` | Newest `maxEpisodesPerFeed` episodes are transcribed. |
| Direct media file | `https://…/episode.mp3` | `mp3, mp4, wav, m4a, flac, ogg, webm, mov, …` — fetched directly, no proxy. |
| 1,800+ other sites | Bilibili, Reddit, Snapchat, Xiaohongshu, Kwai, Likee, … | Anything yt-dlp supports. Success depends on the site and your proxy. |

**Currently not working — flagged:**

- **Vimeo** — broken upstream in yt-dlp: Vimeo removed anonymous OAuth tokens ([yt-dlp #17271](https://github.com/yt-dlp/yt-dlp/issues/17271)), so Vimeo URLs require a logged-in `cookies` export. Without cookies the Actor returns a clear `error` for the item and does not charge it.
- **Live streams** — cannot be transcribed until the broadcast has ended and a recording exists.
- **DRM-protected audio** (e.g. Spotify, Apple Music tracks) — not downloadable; use the podcast's RSS feed instead.

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `mediaUrls` | array | **Yes** | — | Video / audio / podcast-feed / direct-file URLs. Up to 50 per run. |
| `model` | string | No | `base` | Whisper model: `tiny` (fastest), `base` (balanced), `small` (most accurate). |
| `language` | string | No | auto | ISO 639-1 code (`en`, `es`, `pt`, `de`, `fr`, …) to force a language. Empty = auto-detect. |
| `translateToEnglish` | boolean | No | `false` | Output an English translation instead of the original language. |
| `maxMinutesPerItem` | integer | No | `120` | Per-URL transcription cap in minutes (1–600). Longer media is transcribed up to the cap. |
| `maxEpisodesPerFeed` | integer | No | `1` | Newest episodes taken from each podcast feed URL (1–50). |
| `cookies` | string (secret) | No | — | Netscape `cookies.txt` content for the YouTube bot-gate or restricted content. |
| `proxyConfiguration` | object | No | Residential | Proxy for social networks only. Feeds and direct files always go direct. |

#### Minimal input

```json
{
    "mediaUrls": ["https://www.youtube.com/watch?v=jNQXAC9IVRw"]
}
```

#### Full input

```json
{
    "mediaUrls": [
        "https://www.youtube.com/watch?v=jNQXAC9IVRw",
        "https://feed.syntax.fm/rss",
        "https://traffic.megaphone.fm/FSI3025045146.mp3"
    ],
    "model": "base",
    "language": "en",
    "translateToEnglish": false,
    "maxMinutesPerItem": 60,
    "maxEpisodesPerFeed": 3,
    "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

### Output example

```json
{
    "url": "https://traffic.megaphone.fm/FSI3025045146.mp3",
    "inputUrl": "https://feed.syntax.fm/rss",
    "sourceType": "podcast-episode",
    "platform": "podcast",
    "title": "1023: Mosh, Caddy & Tailscale: A Remote Dev Deep Dive",
    "uploader": "Syntax - Tasty Web Development Treats",
    "publishedAt": "2026-07-22T11:00:00.000Z",
    "thumbnailUrl": "https://megaphone.imgix.net/podcasts/…/image.jpg",
    "durationSeconds": 2926.8,
    "transcribedSeconds": 120,
    "billedMinutes": 2,
    "language": "en",
    "languageProbability": 0.9956,
    "model": "base",
    "task": "transcribe",
    "text": "Everybody has built tools for agents nobody is building actual products …",
    "wordCount": 342,
    "segments": [
        { "start": 0, "end": 6.04, "text": "Everybody has built tools for agents nobody is building actual products once I got team hooks" }
    ],
    "srt": "1\n00:00:00,000 --> 00:00:06,040\nEverybody has built tools for agents …",
    "vtt": "WEBVTT\n\n00:00:00.000 --> 00:00:06.040\nEverybody has built tools …",
    "srtFileUrl": "https://api.apify.com/v2/key-value-stores/…/records/001-1023-mosh-caddy.srt",
    "vttFileUrl": "https://api.apify.com/v2/key-value-stores/…/records/001-1023-mosh-caddy.vtt",
    "error": null
}
```

#### Output fields

| Field | Description |
|-------|-------------|
| `text` | Full transcript as one string. |
| `segments` | `[{ start, end, text }]` with seconds-precision timestamps. |
| `srt` / `vtt` | Ready-to-save subtitle strings. |
| `srtFileUrl` / `vttFileUrl` | Direct download links to the stored `.srt` / `.vtt` files. |
| `language` / `languageProbability` | Detected language and confidence (0–1). |
| `title`, `uploader`, `publishedAt`, `thumbnailUrl` | Media metadata from the source. |
| `durationSeconds` / `transcribedSeconds` | Full source length vs. what was transcribed (after the cap). |
| `billedMinutes` | Minutes charged for this item (rounded up, never above `maxMinutesPerItem`). |
| `wordCount`, `model`, `task` | Word count, Whisper model used, `transcribe` or `translate`. |
| `sourceType`, `platform` | `video` / `audio` / `podcast-episode` / `direct-file`, and the source platform. |
| `url` / `inputUrl` | Resolved media URL and the URL you supplied (the feed URL for podcast episodes). |
| `error` | `null` on success. Failed items keep the error message and are **never charged**. |

### How to transcribe a video or audio file

1. Open the Actor and click **Try for free**.
2. Paste one or more URLs into **Media URLs** — a YouTube link, a TikTok link, a podcast RSS feed, or a direct `.mp3` URL.
3. Pick a **Whisper model**. `base` is a good default; use `small` for noisy audio or accents, `tiny` for speed.
4. (Optional) Set **Language** to force a language, turn on **Translate to English**, or lower **Max minutes per item** to control cost.
5. (Optional) For YouTube's bot-check gate, paste a `cookies.txt` export into **Cookies**.
6. Click **Start**. When the run finishes, open the **Output** / **Storage** tab and download the results as JSON, CSV, Excel, or the individual `.srt` / `.vtt` files.

You can also [schedule](https://docs.apify.com/platform/schedules) the Actor to transcribe the newest episode of a podcast every day, or call it from your own code via the [API](https://apify.com/parsebird/video-audio-transcriber/api).

### Use cases

- **Subtitles & captions** — generate SRT/VTT files for videos that have no captions, in the original language or translated to English.
- **Podcast show notes & search** — turn every episode into searchable text and timestamped segments.
- **Content repurposing** — pull quotes, write blog posts, or build clip lists from long videos and streams.
- **Accessibility** — add transcripts to media libraries and course platforms.
- **Research & monitoring** — transcribe interviews, earnings calls, press conferences, or a competitor's video channel.
- **AI & LLM pipelines** — feed clean transcripts into RAG, summarization, embeddings, or fine-tuning datasets.

### How it works

1. Each URL in `mediaUrls` is classified as a **direct file**, a **podcast feed**, or a **site URL**.
2. Podcast feeds are parsed and expanded into their newest `maxEpisodesPerFeed` episodes.
3. Direct files and podcast episodes are downloaded directly; site URLs are handled by **yt-dlp**, through the residential proxy, with your `cookies` if provided.
4. The audio is extracted and normalised with **ffmpeg** and clipped to `maxMinutesPerItem`.
5. **OpenAI Whisper** (`faster-whisper`, CPU, int8) transcribes — or translates — the audio with voice-activity detection to skip silence.
6. The transcript, timestamped segments, and generated **SRT** and **VTT** subtitles are pushed to the dataset; the subtitle files are also saved to the key-value store.
7. Results export from the Apify Console or API as JSON, CSV, Excel, XML, or RSS, and connect to Make, Zapier, Google Sheets, Slack, and more.

### Using the Actor via API

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

run_input = {
    "mediaUrls": [
        "https://www.youtube.com/watch?v=jNQXAC9IVRw",
        "https://feed.syntax.fm/rss",
    ],
    "model": "base",
    "maxMinutesPerItem": 60,
    "maxEpisodesPerFeed": 2,
}

run = client.actor("parsebird/video-audio-transcriber").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], "—", item["language"], "—", item["wordCount"], "words")
    print(item["text"][:300])
```

#### JavaScript

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

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });

const input = {
    mediaUrls: ['https://www.tiktok.com/@user/video/1234567890'],
    model: 'small',
    translateToEnglish: true,
};

const run = await client.actor('parsebird/video-audio-transcriber').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].text);
```

The Actor runs on the [Apify platform](https://apify.com), so you also get scheduling, a full REST API, webhooks, and native integrations. Results export as JSON, CSV, Excel, XML, or RSS.

### Pricing

This Actor uses the **pay-per-event** pricing model, **tiered by your Apify plan**. You are charged per **started minute of media actually transcribed** (rounded up per item), at the same flat rate for video and audio. **Failed items are never charged.**

| Plan | Price per transcribed minute | Price per 1,000 minutes |
|------|------------------------------|-------------------------|
| Free | $0.05 | **$50.00** |
| Bronze | $0.045 | **$45.00** |
| Silver | $0.045 | **$45.00** |
| Gold | $0.04 | **$40.00** |

A tiny [platform start fee](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) (~$0.05 per 1,000 runs) also applies. Examples on the Free plan: a 3-minute TikTok ≈ **$0.15**; a 45-minute podcast episode ≈ **$2.25**; capping `maxMinutesPerItem` to 10 for that episode ≈ **$0.50**.

### FAQ

**Do I need an OpenAI API key?**
No. Whisper runs inside the Actor with `faster-whisper`. You only need an Apify account.

**Which Whisper model should I pick?**
`base` handles clear speech well in most languages. Use `small` for noisy audio, strong accents, or technical vocabulary. Use `tiny` when speed matters more than accuracy.

**Can it transcribe a video that has no captions?**
Yes — it transcribes the actual audio, so captions are not required.

**How do I fix "Sign in to confirm you're not a bot" on YouTube?**
Export a `cookies.txt` from a browser where you are logged in to YouTube (use a "Get cookies.txt" extension) and paste its contents into the `cookies` input. A residential proxy also helps.

**Why did a Vimeo link fail?**
Vimeo removed anonymous access from the API that yt-dlp uses. Vimeo now requires a logged-in `cookies` export. This is flagged in the **Supported inputs** section above.

**Can I limit how much of a long video is transcribed?**
Yes. `maxMinutesPerItem` caps it (default 120). You are billed only for `transcribedSeconds`, and `billedMinutes` never exceeds the cap.

**How are podcast feeds handled?**
Pass the RSS/Atom feed URL. The Actor transcribes the newest `maxEpisodesPerFeed` episodes and sets `inputUrl` to the feed URL on each result.

**Can I get translated subtitles?**
Set `translateToEnglish: true`. The `srt` / `vtt` output and `text` will be in English regardless of the source language.

**Can I schedule recurring transcriptions?**
Yes. Use Apify's [scheduler](https://docs.apify.com/platform/schedules) to transcribe a feed or channel on any cron interval, and route results onward with a webhook or integration.

**Something looks wrong — where do I report it?**
Open the **Issues** tab on the Actor page. Include the URL and the run ID.

### Related Actors

- [Kick Video Downloader](https://apify.com/parsebird/kick-video-downloader) — download Kick.com VODs and clips.
- [Apple Podcasts Scraper](https://apify.com/parsebird/apple-podcasts-scraper) — podcast and episode metadata from Apple Podcasts.
- [RSS Feed Extractor](https://apify.com/parsebird/rss-feed-extractor) — parse any RSS/Atom feed into structured items.
- [YouTube Live Chat Scraper](https://apify.com/parsebird/youtube-live-chat-scraper) — replay chat messages from YouTube live streams.
- [YouTube Community Posts Scraper](https://apify.com/parsebird/youtube-community-posts-scraper) — community-tab posts, polls, and comments.
- Browse the full [ParseBird publisher page](https://apify.com/parsebird) for more.

### Legal and compliance

This Actor downloads and transcribes media from URLs that you supply. You are responsible for having the right to access and transcribe that content, and for using the transcripts in accordance with each source platform's terms of service, copyright law, and — where personal data is involved — applicable privacy laws such as the GDPR and CCPA. Do not use it to transcribe private, paywalled, or DRM-protected content you are not authorised to access. See Apify's [guide to the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/) for background.

# Actor input Schema

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

Video, audio, podcast RSS/Atom feed, or direct media file URLs to transcribe. Up to 50 per run. Works with YouTube, TikTok, Instagram, Facebook, X (Twitter), SoundCloud, Dailymotion, Rumble, podcast feeds, direct .mp3/.mp4/.wav/.m4a files, and 1,800+ other sites supported by yt-dlp.

## `maxMinutesPerItem` (type: `integer`):

Per-URL transcription cap in minutes. Longer media is transcribed only up to this many minutes. You are billed for transcribed minutes, so lower this to control cost.

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

For podcast RSS/Atom feed URLs, how many of the newest episodes to transcribe.

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

faster-whisper model. tiny is fastest, base is a good balance, small is the most accurate but slowest.

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

Force a language instead of auto-detecting it. Use an ISO 639-1 code such as en, es, pt, de, fr, it, nl, ja. Leave empty to auto-detect.

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

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

## `cookies` (type: `string`):

Netscape-format cookies.txt content. Use this for YouTube's "sign in to confirm you're not a bot" gate, or for age-restricted / members-only content. Export it from your browser with a cookies.txt extension.

## `proxyConfiguration` (type: `object`):

Proxy used only for social networks (YouTube, TikTok, Instagram, Facebook, X, etc.). Podcast feeds and direct media files are always fetched directly. Residential proxy is recommended for social networks.

## Actor input object example

```json
{
  "mediaUrls": [
    "https://raw.githubusercontent.com/ggml-org/whisper.cpp/master/samples/jfk.wav"
  ],
  "maxMinutesPerItem": 120,
  "maxEpisodesPerFeed": 1,
  "model": "base",
  "language": "",
  "translateToEnglish": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "mediaUrls": [
        "https://raw.githubusercontent.com/ggml-org/whisper.cpp/master/samples/jfk.wav"
    ],
    "maxMinutesPerItem": 120,
    "maxEpisodesPerFeed": 1,
    "model": "base",
    "language": "",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/video-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 = {
    "mediaUrls": ["https://raw.githubusercontent.com/ggml-org/whisper.cpp/master/samples/jfk.wav"],
    "maxMinutesPerItem": 120,
    "maxEpisodesPerFeed": 1,
    "model": "base",
    "language": "",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/video-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 '{
  "mediaUrls": [
    "https://raw.githubusercontent.com/ggml-org/whisper.cpp/master/samples/jfk.wav"
  ],
  "maxMinutesPerItem": 120,
  "maxEpisodesPerFeed": 1,
  "model": "base",
  "language": "",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call parsebird/video-audio-transcriber --silent --output-dataset

```

## MCP server setup

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