Audio Transcriber (Apify Actor)

Transcribe audio, video and podcast RSS feeds to text, SRT/VTT and chapters through an Apify Actor. Callable from MCP clients via the Apify MCP server (https://mcp.apify.com/?tools=pennydata/audio-transcriber). Pay per use, $6 per 1,000 audio minutes.

View on apify.com

Hosted MCP Server

npx add-mcp 'https://mcp.apify.com/?tools=pennydata/audio-transcriber'

Installs into Claude Code, Codex, Cursor and more

Documentation

Transcribe Audio to Text: Video, Podcast RSS, SRT (Whisper) (`pennydata/audio-transcriber`) Actor

Transcribe audio to text with Whisper: paste any audio, video or podcast RSS URL (mp3, wav, m4a, mp4, webm, mov; up to 120 min per file) and get text, SRT and VTT. Translate to English. No API key. $6 per 1,000 audio minutes on the Free plan (less on paid plans). Failed files free.

URL: https://apify.com/pennydata/audio-transcriber.md
Developed by: Penny Data (community)
Categories: AI, Automation, MCP servers
Stats: 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
User rating: No ratings yet

Pricing

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

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

What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the API section below.

Each client library has reference documentation the quickstart does not restate: JavaScript/TypeScript (npm install apify-client) and Python (pip install apify-client).

README

Audio Transcription - Speech to Text, Audio to Text, Whisper

Paste an audio, video or podcast link. Get the text back. Whisper speech to text for mp3, mp4, wav, m4a, webm, ogg, flac or a podcast RSS feed. Output: plain text, timestamped segments, SRT and VTT subtitles. No OpenAI key needed.

Input scope: direct http(s) URLs of audio or video files (mp3, wav, m4a, ogg, flac, mp4, webm, mov) or podcast RSS feeds, up to 120 minutes per file (default cap 60, set maxMinutesPerFile). YouTube and other web-page links are not supported; link the file itself.

{ "urls": ["https://upload.wikimedia.org/wikipedia/commons/6/62/Weekly_Address-_Celebrating_Independence_Day.webm"], "outputFormats": ["text", "srt"] }

$0.006 per audio minute (Free plan; $0.0054 Bronze, $0.0048 Silver, $0.0042 Gold and above). Failed files are never charged. Add "estimateOnly": true for a free dry run that returns the duration and estimatedCostUsd without transcribing.

Google Drive and Dropbox share links work as urls (shared as "anyone with the link"). speakerLabels is accepted but not yet diarized: the transcript has no speaker names.

Try it: copy this input, press Start

{
  "urls": ["https://upload.wikimedia.org/wikipedia/commons/6/62/Weekly_Address-_Celebrating_Independence_Day.webm"],
  "outputFormats": ["text", "srt"],
  "maxMinutesPerFile": 10
}

That is a public 2 min 51 s video. You get one dataset row with text, segments, durationSeconds and an SRT link. First rows of segments from a real run (start and end in seconds):

start	end	text
0	13	I hope you all had a safe and happy Fourth of July filled with parades and cookouts, fireworks,
13	15.6	and family reunions.
15.6	19	We celebrated the White House with a few members of the military and their families.
19	25.24	We took a moment amid the festivities to remember what our independence day is all about.
25.24	30.04	What happened two hundred thirty seven years ago and what it meant to the world.

Run it from a terminal and get the rows back (replace YOUR_APIFY_TOKEN):

curl -s -X POST "https://api.apify.com/v2/acts/pennydata~audio-transcriber/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"urls":["https://upload.wikimedia.org/wikipedia/commons/6/62/Weekly_Address-_Celebrating_Independence_Day.webm"],"outputFormats":["text","srt"]}'

Want to know the price first? Add "estimateOnly": true for a free dry run that returns the duration and estimatedCostUsd without transcribing.

Problem or feature request? Open an issue on the Issues tab.

Max practical length per run: the 2-hour default run timeout fits roughly 10 to 24 one-hour episodes (about 700 to 1,450 audio minutes) on 4096 MB, so a 50-episode back catalog is best run as several runs of 10 episodes each (set maxEpisodes, and onlyNewSinceLastRun: true to continue where the last run stopped). Up to 120 min per file. Episodes that do not fit are returned as status: "skipped" rows and are not charged; every finished 2-minute slice is billed as it is saved. The default model is tiny (cheapest to run); choose base for higher accuracy, which the Actor still switches to tiny for runs over 5 audio minutes unless autoModel: false. The default run timeout is 2 hours; every 2-minute slice is saved to the dataset and billed as soon as it is done, and about 60 s before the run timeout the Actor stops cleanly and returns the partial transcript (status: "partial"), so a timeout never costs you the finished part.

Quick start, transcribe an mp4 (video to text):

{ "urls": ["https://example.com/interview.mp4"], "outputFormats": ["text", "srt"] }

Transcribe new podcast episodes automatically

Set onlyNewSinceLastRun to true and put the Actor on a daily Apify Schedule. Each run looks at the newest maxEpisodes episodes of the feed, skips every episode an earlier run already transcribed, and transcribes only the new ones. You are charged only for the new ones; a run with nothing new returns no rows and charges nothing. The episodes already seen are remembered per feed URL in a named key-value store (seen-episodes, or seen-<watchlistId>).

Open the Actor in Apify Console, set the input below, and click Save as a new task.
Run the task once. The first run transcribes the newest maxEpisodes episodes and remembers them.
Go to Schedules > Create new, set a cron such as 0 7 * * * (every day at 07:00 UTC), and add your task under Actors/Tasks.
Each scheduled run now outputs only episodes published since the previous run. Set maxEpisodes to at least the number of episodes the show publishes between two runs.

{
  "feedUrl": "https://feeds.npr.org/510289/podcast.xml",
  "maxEpisodes": 3,
  "onlyNewSinceLastRun": true
}

Migrating from steadyfetch/media-transcriber: same input JSON

Paste your existing input unchanged. These steadyfetch/media-transcriber input names are accepted here:

Input name	What it does here
`urls`	direct audio or video file URLs (same name)
`podcastUrls`	podcast RSS feed URLs or podcasts.apple.com show links; the newest episodes of each are transcribed
`maxEpisodesPerShow`	same as `maxEpisodes` (1 to 50)
`datasetId`, `datasetItems`	audio URLs read from the `url`, `audioUrl`, `mediaUrl`, `audio_url` or `enclosureUrl` field of a dataset (first 1,000 rows) or of inline rows
`newItemsOnly`	same as `onlyNewSinceLastRun` (see below); `watchlistId` names the memory
`outputFormats`	`text`, `segments`, `srt`, `vtt`; `markdown` and `rag` are accepted and ignored
`language`	same name, `auto` by default
`maxMinutesPerItem`	per-file length cap, up to 120
`maxTotalMinutes`	run-wide cap on audio minutes: a file that would pass it is skipped (not charged) and the run stops with the results so far
`maxRunSeconds`	soft deadline: the run stops cleanly after this many seconds and keeps partial results; the Actor run timeout still applies

Input names this Actor does not implement are ignored, not rejected. Output is one dataset row per file with text, segments, durationSeconds and status, so check the field names in the Output section below against your downstream code.

Switching from audio-video-to-text

Paste your existing donjuan_mime/audio-video-to-text input unchanged. It runs as is.

audio-video-to-text field	Here	Notes
`source_url`	merged into `urls`	direct mp3, wav, m4a, ogg, flac, mp4, webm or mov link; YouTube pages are not supported (same as there)
`model` = `tiny`	`model` = `tiny`	same
`model` = `base`	`model` = `base`	same
`model` = `small`, `medium`, `large`, `turbo`	runs `base`	only tiny and base exist here; the run log says so
output `txt`	`text`	plus `segments` with timestamps and `durationSeconds`
output `srt`, `vtt`	`outputFormats: ["srt", "vtt"]`	files in the key-value store, links in the row
output `json`, `tsv`	not provided	`segments` carries the same timestamps

Price: this Actor is $0.006 per audio minute on the Free plan ($0.0054 Bronze, $0.0048 Silver, $0.0042 Gold and above). audio-video-to-text goes from $0.00001 to $0.01 per result (per file) on 2026-11-01 11:30 UTC (public Store API pricingInfos). A 10-minute file costs $0.06 here on the Free plan (10 billed minutes) against $0.01 there, so for long files the per-result price is lower. Choose on features: SRT/VTT, podcast RSS feeds, per-file cost caps.

Switching from another transcriber? Paste your existing input

Inputs written for tidytools/audio-transcriber run here with only the Actor id changed. urls, audioUrls, podcastFeeds (RSS feeds or Apple Podcasts links), maxEpisodesPerFeed, newEpisodesOnly, transcriptionEngine (accurate runs model base), outputFormats (txt is read as text), saveSubtitles, language, wordTimestamps, maxMinutesPerFile, maxTotalMinutes, datasetId and datasetItems are read as they are. Fields without an equivalent here (for example titleIncludes, episodesSince, summarize, speakerLabels) are accepted, ignored and named in the run log. YouTube and other page links are not supported: link the media file itself.

Switching from memo23/video-audio-transcriber

No start fee. The only events in this Actor's pay-per-event config are audio-minute ($0.006 per audio minute transcribed on the Free plan, tiered down to $0.0042) and the optional chapters-generated ($0.01 per file, off by default). Failed files are never charged.
Same input field names work. mediaUrls (strings or { "url": ... } objects), model, language, translateToEnglish, wordTimestamps and maxMinutesPerItem are read as they are. speakerLabels (speaker diarization is not supported: the run logs a warning and the transcript has no speaker labels), vocabulary, summarize, usePublisherTranscripts, cookies and watchlistId are accepted and ignored. Our own names (urls, maxMinutesPerFile, ...) keep working.
Sources: direct links to media files (mp3, wav, m4a, ogg, flac, mp4, webm, mov) and podcast RSS feeds (rssFeedUrls, feedUrl). YouTube, TikTok and other page links are not supported.

Example input, pasted unchanged from an existing run:

{ "mediaUrls": ["https://example.com/episode.mp3"], "model": "base", "language": "en", "maxMinutesPerItem": 60 }

Turn podcast RSS feeds and audio or video file URLs into text, SRT and VTT subtitles. You give direct links to mp3, wav, m4a, ogg, flac, mp4, webm or mov files. You get the full transcript, timestamped segments and the duration for each file. The speech model (OpenAI Whisper, run locally inside the Actor) needs no API key and no third-party service.

Video to text: link an mp4, webm or mov file and the Actor extracts the audio track with ffmpeg and transcribes it. Billing is per audio minute, same as audio. A video with no audio track returns an error row and is not charged.

Not supported: YouTube, Vimeo, TikTok or other page links. Link the media file itself. For podcasts, paste the podcast's RSS/Atom feed URL into feedUrl and the newest episodes are found and transcribed for you.

Example output

Real result of a local run on the 3-second sample clip https://upload.wikimedia.org/wikipedia/commons/d/d1/En-uk-hello-6.ogg (the default input of this Actor):

{ "url": "https://upload.wikimedia.org/wikipedia/commons/d/d1/En-uk-hello-6.ogg", "status": "ok", "durationSeconds": 2.97, "text": "Hello", "srtUrl": "(key-value store link, when outputFormats includes srt)" }

Full field list and a longer example are under Output below.

Input

Field	Meaning
`feedUrl`	Podcast RSS/Atom feed URL. The newest `maxEpisodes` episodes with an audio enclosure are transcribed (one row per episode).
`podcastFeedUrl`	Alias of `feedUrl`.
`maxEpisodes`	Episodes to take from the feed (default 3, max 50).
`podcastName` / `podcastUrl`	No feed URL? Give a show name (e.g. `Planet Money`) or a podcasts.apple.com link; the Actor finds the RSS feed through Apple's public directory and transcribes the newest `maxEpisodes`. Ignored if `feedUrl` is set. Only shows with a public RSS feed are found.
`urls`	Direct http(s) links to media files. Provide `feedUrl`, `urls` or both.
Google Drive / Dropbox links	Share links (`drive.google.com/file/d/ID/view`, `dropbox.com/...?dl=0`) are rewritten to direct-download URLs automatically; the file must be shared as "anyone with the link".
`audioUrls`, `audioUrl`, `url`	Aliases of `urls` (array, single string, single string) so inputs written for other transcriber actors work unchanged. Merged with `urls`.
`language`	`auto` (default, the model detects it) or a language code such as `en`, `es`, `de`.
`model`	`tiny` (default, about 1.5x faster) or `base` (more accurate). Same price.
`outputFormats`	`text` (default). Add `srt` and/or `vtt` to also get subtitle files.
`generateChapters`	`false` by default. `true` adds `chapters: [{start, title}]`, `chaptersText` (ready-to-paste YouTube description lines, `00:00 Sourdough baking`, first at 00:00) and `youtubeChapters` (same, `0:00` style) to each row. 5-12 chapters of at least 60 s from pauses and topic shifts (3-4 for files under 5 minutes); titles are the chapter's key phrase. +$0.01 per file, only when chapters are produced.
`maxMinutesPerFile`	Skip files longer than this (default 60, max 120). Skipped files are not charged.
Run timeout (Apify run option)	Default 7200 s (2 hours). Needs about 1 min of run time per 4 to 12 audio minutes (`base` about 4x to 8x real time, `tiny` about 6x to 12x, measured on one CPU core); if you set a shorter timeout the Actor logs a warning with the estimate, stops cleanly before the limit and returns finished files (and a partial transcript) instead of timing out. Every finished file is saved to the dataset immediately.
`estimateOnly`	`false` by default. `true` is a free dry run: the Actor reads each file's duration and returns `durationSeconds` and `estimatedCostUsd` per file plus a `SUMMARY` total, with no transcription and no charge.
`maxCostUsd`	Optional spending cap. A file that would exceed it is skipped and the run stops.

Podcasters and editors: transcribe the latest episodes from an RSS feed

Paste your show's (or any public podcast's) RSS feed URL and the newest episodes are transcribed, one row per episode. Use it for show notes, searchable archives, quote pulling, SEO pages and subtitle files for editors. Example input (NPR's Planet Money feed, newest 1 episode):

{ "feedUrl": "https://feeds.npr.org/510289/podcast.xml", "maxEpisodes": 1, "outputFormats": ["text", "srt"] }

Each episode row has episodeTitle, pubDate, guid, audioUrl and transcript (the same text as text), plus feedTitle, segments and durationSeconds. Pricing: $0.006 per audio minute (Free plan; $0.0054 Bronze, $0.0048 Silver, $0.0042 Gold and above).

Output

One dataset row per file or podcast episode. Episodes from a feed also carry feedTitle, title (also as episodeTitle), pubDate (ISO), audioUrl and transcript (same as text):

{
  "url": "https://example.com/talk.mp3",
  "status": "ok",
  "language": "auto-detected",
  "durationSeconds": 133.23,
  "task": "transcribe",
  "wordCount": 312,
  "minutesBilled": 1,
  "billedMinutes": 1,
  "text": "Four score and seven years ago ...",
  "segments": [{ "start": 0, "end": 7, "text": "This is a LibriVox recording." }]
}

minutesBilled is the number of minutes charged for that file, so minutesBilled times the per-minute price is the charge. wordCount is the number of words in text.

Set task: "translate" to get English text from speech in another language (set language to the spoken language for best results). Set wordTimestamps: true to add words: [{word, start, end}] to every row.

Translate any language to English

Set translateToEnglish: true (or task: "translate") to translate audio and video in any language Whisper supports into English text, with timestamped segments and English SRT/VTT subtitles. Audio translation, speech translation and video subtitle translation in one run, same price as a plain transcript, no API key.

{ "urls": ["https://example.com/entrevista-espanol.mp3"], "translateToEnglish": true, "outputFormats": ["text", "srt"] }

Leave language on auto to let the model detect the spoken language. Rows report "task": "translate". Translation is into English only.

With outputFormats: ["text", "srt", "vtt"], each transcribed file also gets subtitle files built from the segment timestamps (SRT uses HH:MM:SS,mmm, VTT uses HH:MM:SS.mmm). They are saved in the run's key-value store (file-000.srt, file-000.vtt, ...) and the row gets srtUrl and vttUrl links. No extra charge.

Chapters (optional): with generateChapters: true, each file gets 5-12 chapters (3-4 under 5 minutes), each at least 60 s, built from pauses and topic changes in the transcript (no LLM, so titles are the chapter's most repeated key phrase, not summaries). chapters is [{"start": 304, "title": "Marathon training"}], chaptersText is the same as paste-ready lines (00:00 Sourdough baking, 05:04 Marathon training, ...) for a YouTube description or show notes, and youtubeChapters is the older 0:00 style. Files under about 3 minutes of speech, or partial transcripts, get no chapters and no chapter charge.

Failed files (status: "error", with the error) and skipped files (status: "skipped") are in the dataset too and are never charged. A SUMMARY record in the key-value store lists files, minutes billed and cost.

No speech: a file that is silent, or where the model hears no words (for example instrumental music), gets status: "no_speech" with empty text and is not charged (no audio-minute event).

YouTube, Vimeo, TikTok, SoundCloud and other page links fail at once with error: "not_a_media_url" and a note asking for a direct media file URL; nothing is downloaded or charged.

Pricing (pay per event)

Event	Price
`audio-minute`: one minute of audio successfully transcribed (rounded up per file, minimum 1)	$0.006 Free plan, $0.0054 Bronze, $0.0048 Silver, $0.0042 Gold and above
`chapters-generated`: optional, only when `generateChapters` is `true`; once per file, only if chapters were produced	$0.01

Every transcribed minute is billed (there is no free allowance). Example on the Free plan ($0.006/min): a 10-minute file bills 10 minutes, $0.06. A 60-minute episode bills 60 minutes, $0.36. Apify's standard platform usage rules apply on top of the event price as shown in the Console. Charges happen only after the transcript is saved.

Switching from media-transcriber, audio-video-to-text or mp3-to-text

Drop-in compatible with lergassy/mp3-to-text input: translateToEnglish is the same as task: translate, subtitleFormat (srt, vtt, both) adds subtitle files, and quality, diarize, chunkForRag and the other fields are accepted and ignored (no speaker labels or RAG chunks here).

Price: $0.006 per audio minute on the Free plan, tiered down to $0.0042 (failed files free), and this Actor accepts the same input fields, so you can paste your existing input unchanged. Accepted aliases: mediaUrls (array) and source_url (string) are merged into urls; rssFeedUrls (first feed) maps to feedUrl; maxEpisodesPerFeed to maxEpisodes; maxDurationMinutes to maxMinutesPerFile (capped at 120); translate: true is the same as task: translate; outputFormats may list segments, markdown or rag (segments are always returned, the other two are ignored). model values small and medium are accepted but run base here (only base and tiny exist). includeSubtitles: true (tidydata/audio-video-transcription) adds an SRT file, and its urls, language, maxEpisodes and maxMinutesPerFile fields have the same names here. Other fields of those Actors (monitor, RAG chunks, downloads, proxy and so on) are not implemented and are ignored.


{ "mediaUrls": ["https://upload.wikimedia.org/wikipedia/commons/d/d1/En-uk-hello-6.ogg"], "model": "base", "language": "en" }

Accuracy and speed (measured)

Whisper base on a 2-minute 13-second public-domain recording: 33 seconds on a 14-core PC, about 4x faster than real time. Expect slower on small Apify memory sizes: pick 4096 MB or more. The 2-minute test transcript was correct except for one rare word; background noise, heavy accents and music reduce accuracy as with any speech model. Segment timestamps are from the model and can be off by a second or two. Tiny is less accurate than base.

Limits

Files up to 1.5 GB and 120 minutes. Recommended length: keep each run under about 700 audio minutes (about 10 one-hour episodes) on 4096 MB (the default) and set the run timeout to at least 1 minute per 4 audio minutes (default run timeout is 2 hours). Long files are transcribed in 2-minute slices; when the run timeout is close, the Actor stops cleanly and returns what it has with status: "partial" and transcribedSeconds, billing only those minutes. Files it could not start in time are returned as status: "skipped" (reason: run_timeout_close) and are never charged. Short caller timeouts (for example a 60 s API call) work for clips up to a few minutes; use async runs for longer files. Private network addresses are blocked. Google Drive and Dropbox share links in urls are rewritten to direct-download links automatically (the file must be shared as "anyone with the link"; very large Drive files that show a virus-scan page are not supported). If the chosen model cannot finish a file before the run timeout but tiny can, the Actor switches to tiny for that file (turn off with autoModel: false). Speaker labels (diarization) are not provided: speakerLabels and diarize are accepted but ignored.

Related actors

Video Frame Extractor: pulls still frames from the same video you transcribe the audio of.
Shot PDF: turns web pages into screenshots or PDFs, handy next to transcripts for archiving.
RSS/Atom Feed Reader (bulk): collect podcast feed entries to feed into transcription.

Use with AI agents (MCP)

Call this actor from an AI agent (Claude, Cursor, or any MCP client) through the Apify MCP server. Add this URL as an MCP server in your client: https://mcp.apify.com?tools=pennydata/audio-transcriber It exposes this actor as a tool the agent can run with the same input as above. An Apify API token is required. This actor was built with AI assistance.

Built with AI help (Claude).

Actor input Schema

`feedUrl` (type: `string`):

Podcast feed (RSS or Atom with audio enclosures). The newest episodes are transcribed, one dataset item per episode with title, pubDate and audio URL. Can be combined with the file URLs below.

`maxEpisodes` (type: `integer`):

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

`podcastFeedUrl` (type: `string`):

Alias of feedUrl: podcast RSS/Atom feed URL. The newest maxEpisodes episodes are transcribed, each row carries episodeTitle, pubDate and guid.

`podcastName` (type: `string`):

Show name, e.g. Planet Money. The best match in the Apple Podcasts directory is resolved to its RSS feed and the newest episodes are transcribed. Ignored if feedUrl is set.

`podcastUrl` (type: `string`):

A podcasts.apple.com show link (contains /id123456789). Resolved to the show's RSS feed. Ignored if feedUrl is set.

`urls` (type: `array`):

Direct http(s) links to audio or video files (mp3, wav, m4a, ogg, flac, mp4, webm, mov ...). Pages such as YouTube or podcast web players are not supported; link the file itself.

`audioUrls` (type: `array`):

Alias of urls, for compatibility with other transcriber actors. Merged with urls.

`audioUrl` (type: `string`):

Alias for a single audio or video file URL. Merged with urls.

`url` (type: `string`):

Alias for a single audio or video file URL. Merged with urls.

`language` (type: `string`):

Spoken language, or auto to let the model detect it.

`task` (type: `string`):

transcribe keeps the spoken language; translate outputs English text from any supported language (Whisper translate). Same price.

`translateToEnglish` (type: `boolean`):

Compatibility with lergassy/mp3-to-text input; true is the same as task translate.

`wordTimestamps` (type: `boolean`):

Add words: [{word, start, end}] (seconds) to every row. Subtitle segments are then built from the words.

`generateChapters` (type: `boolean`):

Adds chapters: [{start, title}] plus chaptersText (00:00 Title lines to paste into a YouTube or podcast description) and youtubeChapters (same, 0:00 style). Built from pauses and topic shifts, 5-12 chapters of at least 60 s (3-4 under 5 minutes), needs about 3+ minutes of speech. Charged $0.01 per file only when chapters are produced.

`estimateOnly` (type: `boolean`):

Reads the duration of each file or feed episode and returns the estimated cost, without transcribing anything. Nothing is charged and the run finishes in seconds.

`autoModel` (type: `boolean`):

When a run has more than 5 audio minutes, use the tiny model so it finishes before the run timeout. Turn off to always use the selected model.

`model` (type: `string`):

base is more accurate; tiny is about 1.5x faster. Same price.

`translate` (type: `boolean`):

Compatibility with media-transcriber input; true is the same as task translate.

`mediaUrls` (type: `array`):

Compatibility with sauliusautomatesit/media-transcriber input; merged into urls.

`source_url` (type: `string`):

Compatibility with donjuan_mime/audio-video-to-text input; one direct file URL, merged into urls.

`rssFeedUrls` (type: `array`):

Compatibility with media-transcriber input; the first feed is used as feedUrl.

`maxEpisodesPerFeed` (type: `integer`):

Compatibility with media-transcriber input.

`maxDurationMinutes` (type: `integer`):

Alias of maxMinutesPerFile (default 60, capped at 120). Longer files get a skipped row with reason file_too_long, not charged; also the media-transcriber alias of maxMinutesPerFile.

`outputFormats` (type: `array`):

text always stays in the dataset. Add srt and/or vtt to also get subtitle files (from the segment timestamps) stored in the key-value store, with their URLs on each dataset item.

`maxMinutesPerFile` (type: `integer`):

Files longer than this are skipped (not transcribed, not charged).

`maxCostUsd` (type: `number`):

Spending guard: a file that would exceed this is skipped and the run stops. Leave empty for no cap.

`subtitleFormat` (type: `string`):

Compatibility with lergassy/mp3-to-text input; srt, vtt or both add subtitle files, like outputFormats.