# Audio & Video Transcriber - Diarization, Subtitles & RAG (`fetchfinch/audio-video-transcriber`) Actor

Batch transcribe audio and video URLs or uploads into accurate, timestamped text. Get speaker labels, subtitles, confidence scores, optional sensitive-data redaction, downloadable files, and citation-ready RAG chunks in one Apify run.

- **URL**: https://apify.com/fetchfinch/audio-video-transcriber.md
- **Developed by:** [Fetch Finch](https://apify.com/fetchfinch) (community)
- **Categories:** AI, Videos, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $15.00 / 1,000 standard minutes

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Audio & Video Transcriber: Diarization, Subtitles & RAG

A paid Apify Actor for batch transcription of direct audio/video URLs and uploaded files. Actor users do not need to bring their own transcription-provider API key.

The first release intentionally focuses on a reliable media-to-transcript core. Social-page extraction is kept behind a future source-adapter boundary so a YouTube or TikTok layout change cannot break ordinary file transcription.

### Why this Actor is worth paying for

- One run accepts up to 100 direct URLs and uploads, with bounded concurrency and per-file failure isolation.
- `standard` mode handles ordinary recordings; `conversation` adds speaker diarization.
- Names and specialist vocabulary can be boosted with a custom glossary.
- Output includes confidence, review ranges, speakers, timestamps, detected language, and glossary coverage.
- Each successful item can produce TXT, Markdown, normalized JSON, SRT, and WebVTT files.
- Optional RAG rows preserve source URL, start/end timestamps, speaker IDs, token estimate, and a stable content hash.
- Provider-side PII/PCI/PHI/number redaction and Model Improvement Program opt-out are exposed explicitly.
- Cost guards reject oversized or over-duration media before transcription. Pay-per-event charges happen only after requested artifacts and RAG rows are written.
- Signed URL query strings are removed from logs and output URLs. Direct URLs are restricted to public HTTP(S) hosts to reduce SSRF risk.

### Input example

```json
{
  "mediaUrls": [
    "https://example.com/recording.mp3"
  ],
  "mode": "conversation",
  "language": "auto",
  "glossary": ["Apify", "your product name"],
  "redact": [],
  "privacyMode": true,
  "outputFormats": ["txt", "md", "json", "srt", "vtt"],
  "createRagChunks": true,
  "maxMinutesPerItem": 240,
  "maxTotalMinutes": 600
}
```

Set `dryRun` to `true` to download and inspect the files, return durations and estimated billed minutes, and make no transcription request or transcription-event charge.

`language` accepts `auto`, `multi` for code-switching, or a supported language code. Entity redaction (`pii`, `pci`, `phi`) is currently English-only; number redaction supports additional languages.

### Output contract

The default Dataset gets one `result` row per input:

- `success`: complete normalized transcript, compact segments, metadata, artifact links, RAG link, and billing details.
- `validated`: dry-run media metadata and estimated minutes.
- `failed`: stable error code, stage, retryability, and zero billed minutes.
- `duplicate`: duplicate input/options combination skipped with zero billed minutes.

Artifacts are stored in the default Key-Value Store. RAG chunks are stored in `audio-transcriber-rag-<run ID>` when enabled. The full raw provider response is retained only when `storeRawProviderResponse` is true.

### Pay-per-event setup

Create these events in the Actor's Apify Console monetization settings before publishing:

| Event | Suggested launch price | Charged when |
|---|---:|---|
| `apify-actor-start` | $0.00005/run | Apify's synthetic Actor-start event; keep the recommended default |
| `standard-minute` | $0.015/min | A standard transcript and all requested outputs succeeded |
| `conversation-minute` | $0.022/min | A diarized transcript and all requested outputs succeeded |
| `redacted-minute` | $0.004/min | Successful output requested one or more redaction groups |

In Console, open **Development → My Actors → this Actor → Publication → Monetization → Set up monetization**, choose pay per event, and add the three custom minute events exactly as written. Remove the synthetic `apify-default-dataset-item` event so the result row is not billed in addition to the transcription event. Apify charges `apify-actor-start` automatically; the code must not charge it.

Durations are rounded up separately per file. Glossary processing cost is absorbed by the transcription event rather than exposed as a confusing fourth usage add-on. Revisit prices after measuring the real mix of multilingual audio, privacy mode, diarization, retries, and Apify compute.

The Actor charges only for completed items and preflights Apify's maximum-run-charge limit before sending media to the transcription provider. Configure all three code-charged event names exactly as shown; a missing event is a deployment configuration error.

### Release boundary

Version 0.1 supports direct, publicly reachable media URLs and Apify file uploads. It does not claim to extract media from arbitrary webpage, YouTube, TikTok, Instagram, Google Drive share, or Dropbox share URLs. Those should be introduced as individually tested source adapters, with platform-specific terms and failure modes documented before they are marketed.

### Privacy notes

- Files are downloaded into an isolated temporary directory and deleted when processing finishes.
- Signed URL queries are used for download but removed from result rows, logs, Markdown, and RAG provenance.
- `privacyMode=true` requests that the transcription provider exclude media from model-improvement programs where supported.
- Redaction happens at the provider before the transcript is returned, but media still leaves Apify for third-party transcription processing.
- Apify storage retention and access remain controlled by the Actor run owner.

This is not a compliance certification. Customers handling regulated data should review Apify's and their own compliance requirements before use.

# Actor input Schema

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

Public or signed HTTP(S) URLs that return an audio/video file directly. Supported containers include MP3, M4A, WAV, FLAC, OGG, Opus, WebM, MP4, MOV, and MKV.

## `mediaFiles` (type: `array`):

Files uploaded from your computer. Uploads are processed together with Direct audio/video URLs.

## `mode` (type: `string`):

Standard is best for one primary speaker. Conversation adds versioned speaker diarization for interviews, meetings, podcasts, and calls.

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

Use auto to detect the dominant language, multi for code-switching, or a BCP-47/ISO language code such as en, de, es, fr, pt-BR, ja, or zh.

## `glossary` (type: `array`):

Up to 100 names, brands, acronyms, product terms, or short phrases whose recognition should be boosted. Nova-3 keyterm charges may apply.

## `multichannel` (type: `boolean`):

Enable when each participant is recorded on a distinct channel, such as stereo call recordings. Do not enable for ordinary joint-stereo music or video.

## `redact` (type: `array`):

Optional Deepgram redaction groups. Redaction is applied by the transcription provider and billed as an add-on only after success.

## `privacyMode` (type: `boolean`):

Request that Deepgram exclude the media from its Model Improvement Program. Keep enabled for production and sensitive recordings.

## `outputFormats` (type: `array`):

Files written to the run's Key-Value Store after successful transcription.

## `createRagChunks` (type: `boolean`):

Write deterministic chunks with source URL, timestamp range, speaker IDs, token estimate, and content hash to a separate Dataset.

## `chunkSizeTokens` (type: `integer`):

Approximate target size. Chunks preserve segment boundaries, so actual sizes vary.

## `chunkOverlapTokens` (type: `integer`):

Approximate overlap between neighboring chunks.

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

Reject longer files before transcription and before minute-based charges.

## `maxTotalMinutes` (type: `integer`):

Stop scheduling transcription when the cumulative rounded duration would exceed this limit.

## `maxFileSizeMb` (type: `integer`):

Reject oversized downloads before they reach the transcription provider.

## `maxConcurrency` (type: `integer`):

Concurrent downloads/transcriptions. Three is a safe default while demand and provider limits are being measured.

## `dryRun` (type: `boolean`):

Download and inspect each file, then return duration and estimated billable minutes without sending media to Deepgram or charging transcription events.

## `storeRawProviderResponse` (type: `boolean`):

Write the full provider JSON to the Key-Value Store. Disabled by default to minimize retained data.

## Actor input object example

```json
{
  "mediaUrls": [
    "https://static.deepgram.com/examples/interview_speech-analytics.wav"
  ],
  "mode": "standard",
  "language": "auto",
  "glossary": [],
  "multichannel": false,
  "redact": [],
  "privacyMode": true,
  "outputFormats": [
    "txt",
    "md",
    "json",
    "srt",
    "vtt"
  ],
  "createRagChunks": true,
  "chunkSizeTokens": 500,
  "chunkOverlapTokens": 50,
  "maxMinutesPerItem": 240,
  "maxTotalMinutes": 600,
  "maxFileSizeMb": 1024,
  "maxConcurrency": 3,
  "dryRun": false,
  "storeRawProviderResponse": false
}
```

# Actor output Schema

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

No description

## `artifacts` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mediaUrls": [
        "https://static.deepgram.com/examples/interview_speech-analytics.wav"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetchfinch/audio-video-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://static.deepgram.com/examples/interview_speech-analytics.wav"] }

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

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mediaUrls": [
    "https://static.deepgram.com/examples/interview_speech-analytics.wav"
  ]
}' |
apify call fetchfinch/audio-video-transcriber --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fetchfinch/audio-video-transcriber"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/mPkrUX6yx2FXAh9Me/builds/3jRMDxyXJCIOBYuNX/openapi.json