Media Transcriber: Audio, Video & Podcast to Text

Turn audio/video URLs and podcast RSS feeds into transcripts, subtitles and text for AI search. Download TXT, JSON, SRT, VTT, Markdown and timestamped RAG JSONL files. Transcribe in 90+ languages or translate speech to English, without a separate transcription API key.

You pay only for speech you actually receive. A silent, unreachable or expired recording is returned with the reason and costs you no audio minutes. From build 1.4.3, a run in which every recording was rejected that way finishes successfully with those reasons in your dataset, instead of failing — so one bad link never throws away the rest of a batch or your run history.

From 24 September 2026, Basic drops 12.5% to $0.035 per audio-minute — $35 per 1,000 billed minutes — with Quality at $0.06 and Max at $0.12. Until then every model bills at the current flat $0.04. Plan discounts continue on top. Full detail in Pricing.

Try it in about a minute: paste one recording URL, leave the tier on Basic, and run. For podcasts, enter the RSS feed and set maxEpisodesPerFeed: 1; you can then save the input as an Apify Task and schedule it.

Existing model values and default output formats remain compatible; use latest for current safeguards. Release history is in the Changelog tab.

Why this actor

• Source choices — public podcast feeds, direct audio/video links, YouTube and other yt-dlp supported sites. Source restrictions can prevent downloads.
• 6 output formats — text, timestamped segments, SRT, VTT, Markdown and RAG chunks; optional downloadable files.
• 90+ languages — auto-detected, or set it explicitly. Optional translate-to-English.
• Word-level timestamps — approximate timing for captions; review important alignments.
• Choose your tier — Basic uses the existing base model; Quality uses small; Max uses medium. Recognition models are preloaded, with no runtime weight download. Larger models are not always more accurate.
• Long recordings — audio is processed in five-minute chunks, with timestamps preserved across the recording. medium requires at least 4 GB memory.
• Bulk — pass many URLs in one run.
• Success-only audio charges — complete, delivered speech transcripts are billed per rounded-up minute; no audio charge is attempted for failed recognition or silence. The small start fee still applies.
• Repeat podcast runs — discover feed episodes and skip those previously delivered with the same monitor settings. Schedule the saved Task in Apify.

Use cases

You are a…	You use it to…
Podcaster / creator	Get transcripts and subtitles to use when writing show notes or posts
Video team	Produce SRT/VTT captions for accessibility and SEO
Researcher / journalist	Transcribe interviews, lectures, briefings, calls
AI / RAG builder	Convert audio/video into text to index and search
Localization team	Translate foreign-language audio to English text

Integration starter pack

Start from an existing workflow:

• Audio to text: first short recording.
• Video to subtitles: SRT and VTT exports.
• Podcast RSS transcription: discover episodes and save a repeat-run monitor.
• Audio to RAG chunks: source-linked chunks for your own search system.

Download the Python starter pack (ZIP). It includes a short speech test, a repeat-run podcast example, an audio-to-RAG example, automatic file downloads, and an HTTP recipe for n8n or other automation tools. Python 3.10+ with no packages to install. Set your Apify token in an environment variable; the examples include charge and timeout limits. The pack's HTTP recipe also works in n8n: start once, retain the run ID, poll, download, and inspect SUMMARY.stopReason and billing receipts before retrying remaining work.

See the actual input and output

These screenshots show actual Basic/Base output, displayed in a documentation viewer, from a permitted 33.62-second Harvard recording. Candidate build 1.4.11, 10 September 2026: 4 GB CPU/int8, beam 1, automatic language detection, no proxy. Recognition mistakes are left intact; this is not a flawless-accuracy claim. Subtitle and RAG panels show excerpts.

Watch the 37-second saved-run walkthrough (WebM): input → completed transcript → subtitles → Markdown → RAG → download and reuse guidance. Processing waits are omitted; this is not a speed benchmark. The workflow is also described in text below: choose a recording, select formats, run once, inspect SUMMARY, download from DOWNLOADS, and reuse the input as a Task. For repeat podcasts, follow the RSS settings below.

The actual native Apify form offers three suggested processing choices:

For a separate comparison, these are unedited Quality/Small outputs from the 33-second Harvard speech recording, tested on 10 September 2026 in candidate build 1.3.3 with 4 GB, CPU/int8, beam 1, automatic language detection and no proxy: TXT, SRT, Markdown, RAG JSONL. The output still contains a recognition error: this is a working example, not a flawless accuracy claim. To reproduce, use that recording with model: "small", select the desired formats and enable downloadFiles; run the starter pack to download and inspect them locally.

Input

Field	Type	Description
mediaUrls	array	Audio/video URLs. Provide these, rssFeedUrls, or both.
rssFeedUrls	array	Up to 10 public RSS 2.0 or Atom feeds containing audio/video enclosures.
maxEpisodesPerFeed	integer	Newest matching episodes to inspect per feed: 1 (default) to 25.
publishedAfter	string	Optional date, e.g. 2026-09-01. Undated episodes are excluded when set.
episodeTitleContains	string	Optional case-insensitive episode-title filter.
onlyNewEpisodes	boolean	Skip successfully delivered feed episodes across runs. Default false.
monitorKey	string	Required when onlyNewEpisodes is true; stable name of 1–80 characters.
model	string	base (Basic/default), small (Quality), or medium (Max). Legacy tiny inputs remain accepted for compatibility.
language	string	Two-letter code (e.g. en, es); blank = auto-detect.
translate	boolean	Translate speech to English instead of transcribing.
outputFormats	array	text, segments, srt, vtt, markdown, rag. Default: text + segments.
downloadFiles	boolean	Save selected formats as files in the run key-value store. Default false.
ragChunkWords	integer	Maximum words per RAG chunk: 50–1,000; default 250.
ragStrategy	string	segments preserves existing grouping/IDs; opt-in sentences groups punctuation-delimited sentences.
ragOverlapWords	integer	0–100 repeated context words, only with sentence mode and smaller than the chunk limit. Default 0.
paragraphs	boolean	Add paragraphText and whitespace-only TXT paragraph breaks; default false.
shareDownloadLinks	boolean	Opt-in signed single-file links. Anyone holding a link can read that file; default false.
wordTimestamps	boolean	Add per-word timestamps.
maxDurationMinutes	integer	Skip media longer than this (cost guard).
maxTotalMinutes	integer	Optional run-wide billed-minute cap. Each recording rounds up separately.
maxFailedItems	integer	Stop after this many failed items (default 3, maximum 20). Other guards can stop earlier.
maxDownloadMegabytes	integer	Per-item download limit in MiB (default 512); not an exact transfer-cost cap.
beamSize	integer	1 = fastest; higher = slightly more accurate.
proxyConfiguration	object	Proxy for downloads (helps with YouTube/geo limits).

Quick test — a short public speech sample

{
  "mediaUrls": ["https://raw.githubusercontent.com/ggml-org/whisper.cpp/master/samples/jfk.wav"],
  "model": "base",
  "maxDurationMinutes": 5,
  "outputFormats": ["text", "segments", "srt", "vtt", "markdown", "rag"],
  "downloadFiles": true
}

Recurring podcast transcription

Replace the placeholder with your podcast's public feed URL:

{
  "rssFeedUrls": ["https://example.com/your-podcast.rss"],
  "maxEpisodesPerFeed": 1,
  "onlyNewEpisodes": true,
  "monitorKey": "my-podcast-transcripts",
  "model": "base",
  "maxDurationMinutes": 60,
  "outputFormats": ["text", "markdown", "rag"],
  "downloadFiles": true
}

Save as a Task and add an Apify schedule. A repeat run inspects the newest matching window again; it does not backfill an older episode merely because the newest one was completed. Increase the window if several episodes can arrive between runs. Failed episodes remain eligible for retry while they remain in that window. Runs with nothing new charge no audio minutes; the standard Actor-start event still applies.

Use one non-overlapping run per monitor key. A delivered episode is checkpointed after the billing attempt, including a partial/unknown acknowledgement, to avoid blindly reprocessing already delivered speech. Checkpoints are not a cross-run lock or an exactly-once guarantee: a crash or storage error between steps can still cause a retry. Inspect SUMMARY and the BILLING-#### receipt before retrying an interrupted run. A monitor retains up to 5,000 completed episode IDs. Keep the same key and transcription/export settings to reuse it; changing those settings creates a separate checkpoint. Use a new key to deliberately reprocess. Checkpoints apply to feed episodes, not mediaUrls.

Recover interrupted recognition

Version 1.4 privately saves completed five-minute recognition sections in the run store as CHECKPOINT-####. To recover a stopped run, use Resurrect on that original run in Apify Console (or the run resurrection API). Keep its original build, input and storage. Do not start a separate new run to recover it. Media is downloaded again to verify its content hash, but saved sections do not repeat speech recognition. Changed/expired sources cannot be recovered this way. Retain the original run and its storage until recovery finishes.

Only a complete delivered recording is charged, for its full rounded-up duration; saved partial speech is not a paid result. Already-confirmed delivered items are skipped, with their outputs remaining in the same run. Uncertain delivery/billing blocks automatic reprocessing: inspect its dataset and BILLING-#### receipt first. Checkpoints reduce repeated work, not a promise of automatic restart, zero retry cost, or cross-run exactly-once delivery.

Build an audio knowledge base

Choose outputFormats: ["text", "markdown", "rag"] and downloadFiles: true. Each RAG chunk contains id, text, startSeconds, endSeconds, sourceUrl, sourceTitle, citationUrl and wordCount. Index the chunks in your own search or vector database. No embeddings, summaries or additional AI calls are made by this Actor. Chunk IDs are stable for identical source URL, bounds and text. Timestamps come from the transcript; if a single segment exceeds the word limit, its pieces share that segment's bounds. YouTube citation links include a time offset; other source URLs provide provenance only.

For sentence-aware grouping, add ragStrategy: "sentences" and optionally ragOverlapWords: 30. Sentence splitting is a punctuation heuristic, not a language model; overlap is bounded and may be smaller when a sentence fills the chunk. It repeats context intentionally. Chunk times remain segment-level bounds, not precise sentence/word alignment. Changing this strategy or enabling paragraphs creates a new podcast checkpoint fingerprint. Leave the new settings at their defaults to preserve the existing strategy and IDs when text/times are unchanged.

Output

One dataset item per successful media item; failures have an error row. Feed transcripts also include podcast title, episode title/ID, feed URL and publication date when available.

Example fields (formats appear only when selected):

{
  "url": "https://www.youtube.com/watch?v=...",
  "title": "Interview with ...",
  "uploader": "Some Channel",
  "source": "Youtube",
  "language": "en",
  "languageProbability": 0.99,
  "durationSeconds": 612.3,
  "durationMinutes": 10.21,
  "model": "base",
  "wordCount": 1580,
  "segmentCount": 142,
  "text": "Full transcript text…",
  "segments": [{ "start": 0.0, "end": 4.2, "text": "Hello and welcome…" }, ...],
  "srt": "1\n00:00:00,000 --> 00:00:04,200\nHello and welcome…\n\n..."
}

A run summary (URLs requested, transcribed, errors, audio-minutes charged) is saved to the key-value store under SUMMARY.

Download files

With downloadFiles: true, each successful row includes a files map with record keys and API URLs. The run's DOWNLOADS record lists those files; open it from the Output tab or Storage → Key-value store. Fetch protected API URLs using your Apify token, or download through Console. Keep your token private. Files follow your account's storage retention. The normal dataset output remains available whether or not files are enabled.

Restricted accounts can receive HTTP 403 from an unsigned API link even when the export succeeded. Use its consoleUrl, or send Authorization: Bearer YOUR_TOKEN to apiUrl. Do not add your account token to a shareable URL. Optional shareDownloadLinks: true creates signed links to individual files, without making the store public. Anyone with a signed link can read that file while it exists. Leave this off for private audio; deletion of the record ends access. SIGNED_LINK_UNAVAILABLE means authenticated access is still available.

Billing receipts and controlled stops

Each successful row's billing.receiptKey points to BILLING-#### in the same run store. Its status is charged, partial, unknown, or not_monetized; chargedMinutes is only the acknowledged amount. The row itself says see_receipt because delivery happens before the charge. An interrupted pending_delivery receipt needs reconciliation, not an automatic retry. SUMMARY separates minutes delivered, confirmed charges, unknown charges and unprocessed items. Partial/unknown billing stops the batch and marks the run failed while retaining completed output.

Actor-generated error rows and SUMMARY also include machine-readable recovery guidance:

Field	Meaning
retryable	Potential eligibility for one bounded retry after checking the cause, not an instruction to retry automatically. False for uncertain delivery/billing and resource limits.
recommendedAction	What to inspect or correct next. A summary with delivered items never recommends repeating the whole batch.
charged	Audio-minute state: true for acknowledged charges, false when none are acknowledged and no uncertainty is known, null when reconciliation is needed. Inspect receipts and minutesCharged for amounts.
chargeScope	Always audio_minutes_only; this does not include or waive the Actor-start fee.

Platform termination or invalid input can occur before the Actor writes these records. Never interpret a missing summary or unknown charge state as proof that a retry is free.

The Actor checks the native run charge budget before downloading and again once duration is known, and stops before a complete item would exceed the available rounded minutes. It also checks remaining run time, caps failures and downloads, and terminates stalled media workers. These reduce avoidable loss; they cannot make downloads, failures or crash windows cost-free. The internal failed-work allowance estimates compute only, not an exact total invoice cap.

Version 1.4 also checks estimated compute and transfer cost during each item, using its actual effective price, including the legacy price during transition. It includes observed platform startup time (or a fallback reserve), a $3 per-item and $5 per-run resource-estimate ceiling, and a smaller price-dependent item allowance. These are owner safeguards, not extra customer fees or a guaranteed margin. A very slow/demanding item can be stopped before completion; split the work or use lighter options only when that suits your requirements. Download retries and native HTTP/HLS/DASH fragments share a byte/request budget; expensive residential traffic receives a smaller allowance. External network download protocols are rejected. HTTP accounting includes overhead reserves but is not an exact wire-level invoice. Feed discovery, storage/billing calls and Actor finalisation have separate time limits.

Code / stop reason	What to do
CHARGE_LIMIT, MINUTE_LIMIT	Completed results are retained. Increase the chosen cap only if intended; submit remaining items, not the whole successful batch.
RUN_TIME_LIMIT, WALL_TIME_LIMIT	Use a smaller batch or enough run time for the selected model and word-timing options. Do not retry unchanged in a loop.
NO_SPEECH	Check that the recording contains clear speech. No audio-minute charge was attempted.
DOWNLOAD_FAILED, PROXY_UNAVAILABLE	Check source access/expiry and proxy settings. A proxy does not bypass every site's restrictions.
DURATION_LIMIT, DOWNLOAD_SIZE_LIMIT, LIVE_NOT_SUPPORTED	Use a shorter/smaller completed recording, or deliberately adjust the relevant limit.
FAILURE_LIMIT, FAILED_WORK_LIMIT	Correct the earlier errors before retrying remaining items.
ITEM_COST_LIMIT, RUN_COST_LIMIT, FEED_COST_LIMIT, TRANSFER_BUDGET	Resource allowance reached. Inspect SUMMARY; do not repeatedly retry unchanged. Completed transcripts/checkpoints remain available.
UNMETERED_PROTOCOL	Provide a completed direct HTTP(S) audio/video file or a supported native HTTP stream.
CHECKPOINT_MISMATCH, CHECKPOINT_INVALID, RESUME_RECONCILIATION_REQUIRED	Check the original run, identical input/settings/content and billing receipts before recovery.
MODEL_LOAD_FAILED, WORKER_EXITED	Share the failed run and its SUMMARY for investigation; do not increase retry counts blindly.
BILLING_UNAVAILABLE, BILLING_UNCERTAIN, PARTIAL_CHARGE	Inspect effective pricing and receipts. Never blindly repeat a charge or delivered item.
DELIVERY_FAILED, DELIVERY_STATE_UNCERTAIN, CHECKPOINT_FAILED	Inspect the dataset, downloads and receipts first; a storage acknowledgement can fail after acceptance.
TIMESTAMP_BOUNDS_ADJUSTED (warning)	Text is retained, times are bounded to decoded audio and original values remain in originalTiming. This is not acoustic realignment. Review important subtitles.

Pricing

These are pay-as-you-go processing tiers, not extra monthly subscriptions. All tiers include the existing text, subtitle, Markdown, RAG and podcast features; no hidden format or download fee.

Scheduled activation: 24 September 2026 at 19:51:10 UTC (20:51:10 BST).

Tier	API model	Scheduled headline per 1,000 billed minutes	Best starting use
Basic	base	$35	Everyday clear speech; the existing default recogniser
Quality	small	$60	Compare when Base misses too much on your language/content
Max	medium	$120	Difficult recordings where your own sample shows enough improvement

Each complete recording is rounded up to a whole minute separately. Standard plan discounts are 5% Bronze, 10% Silver and 15% Gold/Platinum/Diamond. Actor start (apify-actor-start) remains $0.00005 per GB of run memory, minimum one event, with the normal plan discounts. Failed downloads, failed transcription and no-speech results have no audio-minute charge.

Transition: the Pricing tab is authoritative for the current effective rates. Until the new events become effective at the scheduled time above, the current build uses the existing audio_minute event ($40 per 1,000 headline minutes). It then automatically selects only the matching audio_minute_basic, audio_minute_quality or audio_minute_max event. SUMMARY records the actual event and effective unit price. Old immutable builds still use the retained legacy event; pinning an old build does not obtain the new safeguards.

Legacy compatibility: existing model: "tiny" inputs remain accepted through custom input or JSON, but Tiny is not a fourth suggested tier or the Basic default. It uses the legacy event until activation, then the Basic event on the current build.

Batching several recordings can share startup/model-loading time. Start with 4 GB; 2 GB was not consistently reliable for our longer Base fixture. Medium requires at least 4 GB. An 8 GB Medium comparison was faster but more expensive, so extra memory is not a promised saving.

Version 1.4 uses one recognition thread at 2–4 GB and two at 8 GB. It passes the same decoded samples directly into recognition, avoiding an extra temporary-WAV decode. Basic/Quality decode supported original audio without an intermediate lossy MP3, with a bounded conversion fallback. Max retains its existing MP3 path because the alternative did not improve its matched cost and slightly worsened our French reference result. All cached models and CPU/int8 recognition are retained; there is no new external service or accuracy guarantee.

FAQ

What sources work? Public direct files and podcast enclosures are the most predictable route. Website extractors, including YouTube, depend on current source restrictions. Proxy access can help some cases, but this Actor cannot guarantee a site's availability.

Already have YouTube captions? Use the separate YouTube Transcript Scraper when suitable captions exist. This Actor performs speech recognition; it does not silently replace it with caption extraction.

Which languages? Whisper supports 90+ languages and auto-detects by default. translate: true outputs English.

How accurate is it? Accuracy depends on recording quality, language and model. Start with base for clear speech and compare small/medium on difficult samples. Review important transcripts.

Can I get subtitles? Yes — include srt and/or vtt in outputFormats.

Can I auto-transcribe new episodes? Yes — use rssFeedUrls, onlyNewEpisodes and a stable monitorKey, then schedule the saved Task. This does not discover YouTube channel uploads.

Limitations

• Feeds must be public RSS 2.0 or Atom with downloadable enclosures, up to 4 MB. Private/authenticated feeds, internal-network addresses, nonstandard ports, UTF-16/32 XML and XML entity declarations are unsupported. The proxy setting applies to media downloads, not feed discovery.

• Markdown is a transcript, not generated show notes. RAG chunks do not identify speakers or create embeddings.

• Transcription is compute-bound; long media takes longer (and costs more minutes). Use maxDurationMinutes to cap and allow enough run time for the total audio in your batch.

• Audio is divided into five-minute chunks. Words exactly at a chunk boundary can be less accurate; segment and word timestamps remain relative to the original recording.

• Files with no recognized speech return errorCode: "NO_SPEECH" and are not charged for audio minutes. An all-error batch fails explicitly; a mixed batch retains its successful transcripts.

• Errors include errorCode, processing phase, and elapsed time. The SUMMARY record groups errors by cause. Share a failed run through Apify's debugging controls when requesting help.

• Some sites (certain social platforms) may rate-limit or block downloads; use a proxy and expect best-effort on those.

• Very noisy or overlapping speech is inherently harder; try a larger model.

Source support and benchmark conditions

All tests below were run on 10 September 2026, without a proxy. Candidate build numbers refer to the private validation Actor, not identically numbered production builds.

Source / output	Evidence, build and limits
Direct WAV / OGG recordings	English Harvard and VOA samples: short and 4-minute speech, Base/Small/Medium baseline in 1.3.3; Harvard Base and all exports rechecked in 1.4.11, 4 GB/int8/beam 1.
Multilingual direct files	First ten French FLEURS validation clips, selected before model output; 97 seconds total, Base/Small/Medium in 1.3.3, 4 GB/int8/beam 1. Not a language-wide accuracy claim.
Multi-chunk audio	A 6.6-minute synthetic German fixture exercised two chunks: Base/Small/Medium, 4 GB/int8/beam 1 in 1.3.3 and 1.4.8. Not a real hour-long podcast benchmark.
RSS / Atom	RSS fixture delivery/repeat checks in 1.3.4 and 1.4.8, Base/4 GB. Atom parsing and failure/skip cases are regression-tested; no broad live-feed access guarantee.
YouTube and other sites	Best-effort yt-dlp extractors; no new exhaustive source/proxy benchmark. Geo/account restrictions, expiry and blocking can fail.
SRT, VTT, Markdown, RAG and files	All six formats rechecked in 1.4.11, Base/4 GB/int8/beam 1; same recognised speech, no extra model calls. Check warnings and export-access settings.

Baseline candidate build 1.3.3, 10 September, no proxy, 4 GB CPU, beam 1, faster-whisper 1.1.1/int8: English reference word-error rates were Base 9.9%, Small 1.2%, Medium 4.9% on 81 normalised words. On 246 French words, the corresponding rates were 30.9%, 11.8%, 5.7%. These are small reference samples, not a guarantee or a reason to assume Medium always wins. Recognition errors can include names, numbers, omissions and plausible invented text; review important results.

Privacy and feedback

Process only recordings you have permission to use. Recognition runs in the Actor container; this package adds no external transcription/LLM provider. Original media is downloaded into temporary working storage and removed after processing. Transcripts, optional files and monitor checkpoints remain in your Apify account according to its retention/access settings. Source URLs and transcript text can contain personal data; this is not an automatic PII redactor, diarisation service or compliance certification. Signed file links are optional bearer-access links: share them deliberately.

For help, open an issue and share the affected run using Apify's debugging controls. Never paste account tokens or sensitive recordings into a public issue. Honest reviews help other users choose; all feedback is welcome and no incentive is offered.

Changelog

• 1.4.3 — 13 September 2026: a run whose every recording was rejected by its own source — silence, an unreachable or expired link, a live stream, an unsupported protocol, or a recording past your own duration or size limit — now finishes successfully and reports each reason as a dataset row, instead of failing the run. Charging is unchanged: those rows are still zero audio minutes. Faults on our side still fail the run.
• 1.4.2 — 10 September 2026: three suggested tiers with legacy API compatibility; grouped RAG controls; conservative retry/action and audio-charge diagnostics; real-output screenshots, saved-run walkthrough, native changelog and scheduled pricing date.
• 1.4 — 10 September 2026: in-flight compute/transfer estimates and retry limits; bounded feed and SDK operations; lower-overhead sample processing; private recovery checkpoints with content/settings validation and uncertain-delivery blocking. No tariff change in this release.
• 1.3 — 10 September 2026: model-aware effective-price preflight and receipts; bounded worker/download/failure handling; safe optional single-file links; timestamp diagnostics; opt-in sentence-aware RAG and whitespace-only paragraphs; clearer onboarding and limits. Tier prices follow the separate effective-date process described above.
• 1.2 — 9 September 2026: podcast feeds and repeat-run checkpoints, Markdown and RAG files.
• 1.1 — 6 September 2026: bounded five-minute audio processing, no-speech failure handling and cached models. The historical 75-minute fixture verified duration acceptance, not real-world long-podcast recognition accuracy or a universal runtime guarantee.

Historical reliability update — 6 September 2026

We're sorry for the disruption caused by recent transcription issues. The following fixes are now live:

• Long recordings: fixed a memory-related restriction that rejected recordings below the advertised duration limit. Audio now processes in five-minute chunks.
• Empty results: if no speech is recognized, the Actor returns a clear NO_SPEECH error and charges no audio minutes. The standard Actor-start fee still applies.
• Model startup: all four speech models are now bundled, removing model downloads during your run.

These fixes passed cloud tests, including a 75-minute test recording that the previous build rejected. Please retry with the latest build. If your task is pinned to an older build, update that selection. Long recordings still need enough run time, especially with the medium model.

If a retry fails, share the run through Apify's debugging controls and open an issue on this Actor's page so we can investigate your specific case. Please also report any earlier empty transcript that incurred an audio-minute charge for review. Prices were unchanged in that September 6 release; see the current Pricing section for the later tier transition.