# Video & Audio Transcriber · Whisper Speech-to-Text (`memo23/video-audio-transcriber`) Actor

Transcribe any video or audio URL to text with Whisper running inside the Actor — no API key. TikTok, YouTube, Instagram, Facebook, X, Rumble, podcast RSS feeds & direct files. Full text, timestamped segments, SRT + VTT subtitles, 99+ languages auto-detected. One flat rate for video and audio.

- **URL**: https://apify.com/memo23/video-audio-transcriber.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** AI, Videos, Social media
- **Stats:** 23 total users, 22 monthly users, 68.9% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

$20.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.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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 — Whisper Speech-to-Text for Any URL

> **$0.05 per minute transcribed — one flat rate for video AND audio** · no API key · text + timestamped segments + SRT + VTT · 99+ languages, auto-detected

Transcribe **any video or audio URL to text** with OpenAI **Whisper running inside the Actor** (faster-whisper). No external API, no key, no rate limits. Paste links from **TikTok, YouTube, Instagram, Facebook, X (Twitter), Rumble**, a **podcast RSS feed**, or a **direct media file** (mp3, mp4, wav, m4a, …) and get the full transcript, timestamped segments, ready-to-use **SRT and VTT subtitles**, and the detected language. Works on media that has no captions at all.

![How the Video & Audio Transcriber works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-video-audio-transcriber.png)

### Why use this transcriber

- **One Actor for both media types.** Video and audio at the same flat $0.05/minute — no separate video and audio products with different rates.
- **Real Whisper transcription, not caption scraping.** The audio track is extracted and transcribed, so it works on videos without subtitles.
- **Podcast feeds expand automatically.** Point it at an RSS/Atom feed and the newest episodes become transcripts (`maxEpisodesPerFeed`).
- **Translate while you transcribe.** `translateToEnglish: true` outputs an English transcript and English subtitles from any source language.
- **Subtitles as files, not just strings.** Every item stores a downloadable `.srt` and `.vtt` in the run's key-value store (`srtFileUrl` / `vttFileUrl`).
- **Self-contained.** All three Whisper models are baked into the image — nothing downloads at run time, and you never provide an API key.

### Supported inputs

| Input type | Example | Notes |
|---|---|---|
| TikTok video | `https://www.tiktok.com/@user/video/…` | audio extracted automatically |
| YouTube video / Short | `https://www.youtube.com/watch?v=…` | cookies input available for the bot-check gate |
| Instagram Reel / post | `https://www.instagram.com/reel/…` | public content |
| Facebook video | `https://www.facebook.com/watch?v=…` | public content |
| X (Twitter) video | `https://x.com/user/status/…` | public content |
| Rumble video | `https://rumble.com/v…` | |
| Podcast RSS/Atom feed | `https://feed.syntax.fm/rss` | newest `maxEpisodesPerFeed` episodes |
| Direct media file | `https://…/episode.mp3` | mp3, mp4, wav, m4a, flac, ogg, webm, mov, … |
| 1800+ other sites | SoundCloud, Vimeo, Twitch, Dailymotion, Bilibili, … | anything yt-dlp supports |

### Use cases

- Turn TikToks, Reels and Shorts into searchable, quotable text at scale.
- Generate SRT/VTT subtitles for repurposing clips across platforms.
- Transcribe podcast back-catalogs straight from the RSS feed for search, show notes, or SEO pages.
- Feed spoken content into summarization, RAG pipelines, or trend analysis.
- Accessibility and compliance transcripts.
- Monitor what creators or competitors say on video without watching hours of footage.

### How it works

1. **Resolve** — each URL is classified: social/video platform, podcast feed (expanded to episodes), or direct file. Every download tries a direct connection first and falls back to residential proxy only where networks block datacenter IPs; feeds and direct files never use it.
2. **Extract** — yt-dlp downloads the audio track (video is never kept), ffmpeg trims it to your `maxMinutesPerItem` cap.
3. **Transcribe** — faster-whisper (int8, VAD-filtered) runs on the file locally and returns language, segments and timings; the Actor builds the text, SRT and VTT and writes one dataset row per item.

### Input configuration

| Field | Type | Default | Description |
|---|---|---|---|
| `mediaUrls` | array | — (required) | Video/audio/podcast/direct-file URLs, up to 50 per run |
| `language` | string | auto-detect | ISO code (`en`, `es`, `pt`, `de`, …) to force a language |
| `model` | string | `base` | `tiny` (fastest) · `base` (fast) · `small` (most accurate) |
| `translateToEnglish` | boolean | `false` | Output English translation instead of original language |
| `maxMinutesPerItem` | integer | `120` | Per-URL cap; longer media is transcribed up to the cap |
| `maxEpisodesPerFeed` | integer | `1` | Newest episodes taken per podcast feed |
| `cookies` | string (secret) | — | Netscape cookies.txt for YouTube bot-gate or restricted content |
| `proxyConfiguration` | object | residential | Used only for social networks; feeds and files go direct |

Minimal input:

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

### Output — key 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 |
| `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) |
| `wordCount`, `model`, `task`, `sourceType`, `platform` | Run metadata per item |
| `error` | `null` on success; failed items keep the error message and are never charged |

#### Output sample

```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",
    "durationSeconds": 2926.8,
    "transcribedSeconds": 120,
    "billedMinutes": 2,
    "language": "en",
    "languageProbability": 0.9956,
    "model": "base",
    "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",
    "error": null
}
```

### Pricing

**Pay-per-event: $0.05 per minute of media transcribed** — the same rate whether the source is video or audio — plus a one-time actor-start fee of $0.01 per GB of run memory ($0.04 at the default 4 GB). Minutes are rounded up per item; failed items are never charged. No separate platform-usage bill.

| Media | Cost (default 4 GB run) |
|---|---|
| 1-minute TikTok | $0.09 |
| 10-minute YouTube video | $0.54 |
| 45-minute podcast episode | $2.29 |
| 10 × 1-minute Reels in one run | $0.54 |

### FAQ

**Do I need an OpenAI or any other API key?** No. Whisper runs inside the Actor container. You only provide URLs.

**Which sites work?** Anything yt-dlp supports (1800+ extractors) plus podcast RSS/Atom feeds and direct media links. TikTok, YouTube, Instagram, Facebook, X and Rumble are tested paths.

**What about videos without captions?** They work — this transcribes the actual audio, so captions are never required.

**How accurate is it?** The default `base` model handles clear speech well across 99+ languages and runs ~2× faster than `small`. For hard audio (music beds, crosstalk, heavy accents), set `model: "small"` — the most accurate option.

**How fast is it, and does memory matter?** Roughly 3–5× faster than realtime at the default 4 GB. Apify allocates one CPU core per 4 GB of run memory, so 8 GB runs transcribe long media about twice as fast. Progress is visible live in the run log and the run's status message (e.g. "transcribed 24/65 min, ~9 min left").

**Can it translate?** Yes — set `translateToEnglish: true` and the transcript and subtitles come out in English regardless of source language.

**YouTube says "Sign in to confirm you're not a bot"?** Paste a Netscape `cookies.txt` from a logged-in session into the `cookies` field. The field is stored as a secret.

**How do long files bill?** A 3-hour source with `maxMinutesPerItem: 120` transcribes and bills 120 minutes. Lower the cap to bound spend per item; the Actor also stops before exceeding your run's maximum cost.

**An Instagram/Facebook `scontent…` CDN link fails with "no audio track"?** Those raw CDN URLs are usually DASH video-only renditions — the audio lives in a separate stream. Paste the post/reel page URL (e.g. `https://www.instagram.com/reel/…`) and the Actor downloads the version that includes audio.

**Live streams?** Ongoing streams can't be transcribed — the recording has to finish first. A stream that ended within the last few hours may still be processing on YouTube's side (downloads are slow and unreliable until then); the Actor tells you when that's the case — retry once the regular video is published.

**Spotify links?** No — Spotify streams are DRM-protected. Use the show's RSS feed instead (most podcasts have one).

### Support

Found a bug or want another output field? Open an issue on the Actor's Issues tab — it is monitored.

### 🤖 For AI Agents & LLM Apps

**Purpose:** Turn any video/audio/podcast URL into transcript data (full text + timestamped segments + SRT/VTT + language) with one call. No API key management — Whisper runs inside the Actor.

**Minimal input (tested):**

```json
{ "mediaUrls": ["https://github.com/openai/whisper/raw/main/tests/jfk.flac"] }
```

**Output fields (flat):** `url`, `inputUrl`, `sourceType`, `platform`, `title`, `uploader`, `publishedAt`, `thumbnailUrl`, `durationSeconds`, `transcribedSeconds`, `billedMinutes`, `language`, `languageProbability`, `task`, `model`, `text`, `wordCount`, `segments[]` (`{start,end,text}`), `srt`, `vtt`, `srtFileUrl`, `vttFileUrl`, `error`.

**Behaviors agents should know:**

- Podcast feed URLs expand to the newest `maxEpisodesPerFeed` episodes — one row each.
- `error` is non-null on failed items and those rows are never charged; check it before consuming `text`.
- Billing: `media-minute-transcribed` × `billedMinutes` per item, $0.05 each, plus a one-time `apify-actor-start` fee of $0.01 per GB of run memory. Bound spend with `maxMinutesPerItem` and the run's maximum cost setting.
- Long media takes real time (roughly 0.2–0.5× the media length depending on `model`); set your wait/polling timeout accordingly, or use `tiny` for drafts.

### Explore more actors

- [Rumble Scraper](https://apify.com/memo23/rumble-scraper) — videos, channels & search with direct media URLs.
- [YouTube Video Downloader](https://apify.com/memo23/youtube-video-downloader) — grab the source files this transcriber reads.
- [YouTube Video Details Scraper](https://apify.com/memo23/youtube-video-details-scraper) — metadata at scale before you pick what to transcribe.
- [YouTube Comments Scraper](https://apify.com/memo23/youtube-comments-scraper) — pair transcripts with audience reaction.
- [X (Twitter) Scraper](https://apify.com/memo23/twitter-x-scraper) — find the video posts worth transcribing.
- [Xiaohongshu / RedNote Scraper](https://apify.com/memo23/xiaohongshu-rednote-scraper) — the same workflow for China's RedNote.

### ⚠️ Disclaimer

This Actor processes only publicly accessible media that you point it at. Use it in compliance with each platform's Terms of Service and applicable laws, including copyright: transcribe content you have the right to process. You are responsible for how you use the output. The Actor does not bypass logins, paywalls, DRM, or any access controls; the optional cookies input only authenticates your own session to content you can already access.

### SEO Keywords

video transcriber, audio transcriber, whisper transcription, video to text, audio to text, speech to text API, TikTok transcript, YouTube transcript generator, Instagram Reel transcript, podcast transcription, RSS feed transcriber, SRT generator, VTT subtitles, subtitle generator, transcribe mp3, transcribe mp4, no API key whisper, faster-whisper actor, translate video to English, Apify transcription actor.

# Actor input Schema

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

Video, audio, podcast or direct-file URLs to transcribe. Works with TikTok, YouTube, Instagram, Facebook, X (Twitter), Rumble, SoundCloud, Vimeo, Twitch and 1800+ other sites, podcast RSS feeds (episodes are expanded automatically) and direct media links (mp3, mp4, wav, m4a, flac, …). Audio is extracted from video automatically.

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

ISO 639-1 code of the spoken language (e.g. 'en', 'es', 'pt', 'de'). Leave empty to auto-detect — Whisper recognizes 99+ languages.

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

Accuracy vs. speed trade-off. 'base' (default) is fast and accurate on clear speech, 'small' is the most accurate for hard audio, 'tiny' is fastest. All three are baked into the Actor image — no downloads at run time.

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

Instead of transcribing in the original language, output an English translation of the speech (Whisper's built-in translate task). SRT/VTT subtitles are translated too.

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

Safety cap on how many minutes of media to transcribe per URL. Longer items are transcribed up to this cap and billed only for the transcribed minutes.

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

When a URL is a podcast RSS/Atom feed, transcribe this many of the newest episodes (each episode becomes one output item).

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

Contents of a Netscape cookies.txt exported from a logged-in browser session. Useful for YouTube (avoids the 'Sign in to confirm you're not a bot' gate) and for age/region-restricted content on any network. Leave empty for public content and direct files.

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

Residential proxy by default — social networks (YouTube, TikTok, Instagram, …) block datacenter IPs when downloading media. Podcast feeds and direct media files are fetched without a proxy automatically, so residential bandwidth is only spent where it is needed.

## Actor input object example

```json
{
  "mediaUrls": [
    "https://github.com/openai/whisper/raw/main/tests/jfk.flac"
  ],
  "language": "",
  "model": "base",
  "translateToEnglish": false,
  "maxMinutesPerItem": 120,
  "maxEpisodesPerFeed": 1,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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://github.com/openai/whisper/raw/main/tests/jfk.flac"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/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://github.com/openai/whisper/raw/main/tests/jfk.flac"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/video-audio-transcriber").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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://github.com/openai/whisper/raw/main/tests/jfk.flac"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call memo23/video-audio-transcriber --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=memo23/video-audio-transcriber",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Video & Audio Transcriber · Whisper Speech-to-Text",
        "description": "Transcribe any video or audio URL to text with Whisper running inside the Actor — no API key. TikTok, YouTube, Instagram, Facebook, X, Rumble, podcast RSS feeds & direct files. Full text, timestamped segments, SRT + VTT subtitles, 99+ languages auto-detected. One flat rate for video and audio.",
        "version": "0.0",
        "x-build-id": "ALe1N4sR35DEsZ9IW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~video-audio-transcriber/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-video-audio-transcriber",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/memo23~video-audio-transcriber/runs": {
            "post": {
                "operationId": "runs-sync-memo23-video-audio-transcriber",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/memo23~video-audio-transcriber/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-video-audio-transcriber",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mediaUrls"
                ],
                "properties": {
                    "mediaUrls": {
                        "title": "Media URLs",
                        "minItems": 1,
                        "maxItems": 50,
                        "type": "array",
                        "description": "Video, audio, podcast or direct-file URLs to transcribe. Works with TikTok, YouTube, Instagram, Facebook, X (Twitter), Rumble, SoundCloud, Vimeo, Twitch and 1800+ other sites, podcast RSS feeds (episodes are expanded automatically) and direct media links (mp3, mp4, wav, m4a, flac, …). Audio is extracted from video automatically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "language": {
                        "title": "Language (optional)",
                        "type": "string",
                        "description": "ISO 639-1 code of the spoken language (e.g. 'en', 'es', 'pt', 'de'). Leave empty to auto-detect — Whisper recognizes 99+ languages.",
                        "default": ""
                    },
                    "model": {
                        "title": "Whisper model",
                        "enum": [
                            "tiny",
                            "base",
                            "small"
                        ],
                        "type": "string",
                        "description": "Accuracy vs. speed trade-off. 'base' (default) is fast and accurate on clear speech, 'small' is the most accurate for hard audio, 'tiny' is fastest. All three are baked into the Actor image — no downloads at run time.",
                        "default": "base"
                    },
                    "translateToEnglish": {
                        "title": "Translate to English",
                        "type": "boolean",
                        "description": "Instead of transcribing in the original language, output an English translation of the speech (Whisper's built-in translate task). SRT/VTT subtitles are translated too.",
                        "default": false
                    },
                    "maxMinutesPerItem": {
                        "title": "Max minutes per item",
                        "minimum": 1,
                        "maximum": 600,
                        "type": "integer",
                        "description": "Safety cap on how many minutes of media to transcribe per URL. Longer items are transcribed up to this cap and billed only for the transcribed minutes.",
                        "default": 120
                    },
                    "maxEpisodesPerFeed": {
                        "title": "Max episodes per podcast feed",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "When a URL is a podcast RSS/Atom feed, transcribe this many of the newest episodes (each episode becomes one output item).",
                        "default": 1
                    },
                    "cookies": {
                        "title": "Cookies (optional)",
                        "type": "string",
                        "description": "Contents of a Netscape cookies.txt exported from a logged-in browser session. Useful for YouTube (avoids the 'Sign in to confirm you're not a bot' gate) and for age/region-restricted content on any network. Leave empty for public content and direct files."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential proxy by default — social networks (YouTube, TikTok, Instagram, …) block datacenter IPs when downloading media. Podcast feeds and direct media files are fetched without a proxy automatically, so residential bandwidth is only spent where it is needed.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
