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

Transcribe public audio and video URLs into searchable text, timestamps, and subtitles for captioning, research, archives, and AI workflows.

- **URL**: https://apify.com/fetch\_cat/video-audio-transcriber-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.94 / 1,000 started transcription minutes

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

# README

## Video & Audio Transcriber

Convert public audio and video into searchable transcript text, timestamped segments, and subtitle files. Provide one public media link or a batch, then export source-bound records for captioning, research, archives, and AI workflows.

### Who is it for?

Use this Actor when you need reusable text from spoken content without manually copying timestamps:

- **Content and video teams** preparing captions and searchable archives.
- **Researchers and journalists** creating notes from public interviews, lectures, and recordings.
- **Podcast teams** turning recent public episodes into text for editorial workflows.
- **AI builders** supplying speech-derived text to retrieval, analysis, or summarization pipelines.

### What you get

Each completed item includes transcript text, timed segments, subtitle text, language metadata, duration information, and the submitted source link. Batch results preserve item-level errors so one unavailable source does not hide successful work.

- Plain transcript text for search and analysis.
- Start/end timestamps for every transcript segment.
- SRT and WebVTT subtitle content.
- Source URL, resolved URL where available, title, and source classification.
- Language, selected model, processing task, and duration metadata.

### Input recipes

#### One public audio file

```json
{
  "mediaUrls": [{ "url": "https://raw.githubusercontent.com/ggml-org/whisper.cpp/master/samples/jfk.wav" }],
  "language": "en",
  "model": "base.en",
  "maxMinutesPerItem": 10
}
```

#### A batch with language detection

```json
{
  "mediaUrls": [
    { "url": "https://example.com/interview.mp3" },
    { "url": "https://example.com/presentation.mp4" }
  ],
  "language": "auto",
  "model": "base",
  "task": "transcribe",
  "maxMinutesPerItem": 30
}
```

#### Recent public podcast episodes

```json
{
  "feedUrls": [{ "url": "https://example.com/podcast.xml" }],
  "maxEpisodesPerFeed": 5,
  "language": "auto",
  "model": "base"
}
```

### Input settings

| Setting | What it controls |
| --- | --- |
| `mediaUrls` | Public audio/video links and supported public media pages. |
| `feedUrls` | Public podcast feed links for recent episodes. |
| `maxEpisodesPerFeed` | Maximum recent episodes to include from each feed. |
| `language` | `auto` detection or an ISO 639-1 code such as `en`, `es`, `de`, `fr`, or `ja`. |
| `model` | `tiny`, `base`, `small`, or English-focused `base.en`. |
| `task` | Keep spoken language with `transcribe`, or use `translate` for English text. |
| `maxMinutesPerItem` | Maximum audio duration to include for each item. |

Exact duplicate source links are handled once per run. Start with a short duration limit when checking an unfamiliar source.

### Output fields

One dataset row is returned for each unique submitted media item. Successful rows contain transcript content; unavailable or unsupported items contain a clear `error` value.

| Field | Description |
| --- | --- |
| `inputUrl` | Public source link submitted for this result. |
| `url` | Final publicly reachable media link when available. |
| `sourceType` | Source category, such as public media or podcast episode. |
| `platform` | Direct or resolved public source classification. |
| `title` | Available source title or file name. |
| `uploader` | Public uploader metadata when supplied by the source. |
| `durationSeconds` | Available source duration in seconds. |
| `transcribedSeconds` | Duration included in this transcript. |
| `language` | Detected or selected transcript language. |
| `languageProbability` | Language-detection confidence when available. |
| `model` | Speech model selected for the item. |
| `task` | `transcribe` or `translate`. |
| `text` | Plain transcript text. |
| `wordCount` | Number of words in `text`. |
| `segments` | Timed transcript segments with text. |
| `srt` | Subtitle content in SRT format. |
| `vtt` | Subtitle content in WebVTT format. |
| `srtUrl`, `vttUrl` | Download links for saved subtitle files when available. |
| `feedUrl`, `feedGuid` | Podcast origin and episode identifier when applicable. |
| `error` | Item-specific outcome information, or `null` after success. |
| `scrapedAt` | ISO timestamp for processing completion. |

### Example result

```json
{
  "inputUrl": "https://example.com/interview.mp3",
  "sourceType": "public-media",
  "durationSeconds": 132,
  "transcribedSeconds": 132,
  "language": "en",
  "model": "base",
  "task": "transcribe",
  "text": "Thank you for joining us today.",
  "segments": [{ "start": 0, "end": 2.4, "text": "Thank you for joining us today." }],
  "srt": "1\n00:00:00,000 --> 00:00:02,400\nThank you for joining us today.",
  "error": null
}
```

### Use cases

- Create captions and subtitle drafts for public video.
- Search spoken interviews, calls, lectures, and meetings that are publicly shared.
- Build a text archive for podcast editorial planning.
- Send transcript rows to an AI agent, vector database, spreadsheet, or reporting workflow.
- Keep source links with every exported transcript for traceability.

### Pricing

You are charged per started minute of successfully transcribed speech. Items that cannot be processed or do not produce speech are not charged. Current rates and tier discounts are shown on the [live Pricing tab](https://apify.com/fetch_cat/video-audio-transcriber-scraper/pricing). Use `maxMinutesPerItem` to control the maximum duration of each item.

### Limits and supported sources

Use publicly reachable media. Private links, login-only pages, DRM-protected media, and speaker diarization are outside this Actor's scope. Results can vary with source availability, audio quality, language, and selected model. Direct public media links are the most predictable starting point.

### Tips for better transcripts

- Choose the correct language when you already know it.
- Use `base.en` for English-only recordings; use multilingual models for other languages.
- Choose `small` when accuracy matters more than run time.
- Use shorter per-item limits to test a source before a longer batch.
- Export `segments`, `srt`, or `vtt` when your downstream workflow needs timestamps.

### API usage

Run the Actor through the Apify API using the same input object shown above. Replace `APIFY_TOKEN` with an Apify API token.

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/video-audio-transcriber-scraper').call({
  mediaUrls: [{ url: 'https://example.com/interview.mp3' }],
  language: 'auto',
  model: 'base',
  maxMinutesPerItem: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("APIFY_TOKEN")
run = client.actor("fetch_cat/video-audio-transcriber-scraper").call(run_input={
    "mediaUrls": [{"url": "https://example.com/interview.mp3"}],
    "language": "auto",
    "model": "base",
    "maxMinutesPerItem": 10,
})
print(client.dataset(run["defaultDatasetId"]).list_items().items)
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~video-audio-transcriber-scraper/runs?token=APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mediaUrls":[{"url":"https://example.com/interview.mp3"}],"language":"auto","model":"base","maxMinutesPerItem":10}'
```

### MCP and AI agents

Add this Actor to an Apify MCP client to let an agent request transcription and read the resulting dataset. Configure the tool using [Apify MCP](https://mcp.apify.com?tools=fetch_cat/video-audio-transcriber-scraper), then give your agent a public source URL and the desired transcript language or duration limit.

```bash
claude mcp add apify -- npx -y @apify/mcp-server
```

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/mcp-server"],
      "env": { "APIFY_TOKEN": "APIFY_TOKEN" }
    }
  }
}
```

Example prompts: “Transcribe this public WAV in English” and “Run the Video & Audio Transcriber on these public episode URLs, then summarize the dataset.”

### FAQ

#### Can I submit a video page URL?

Yes, for supported publicly reachable pages. A direct public media link is the most predictable option.

#### Can I translate speech to English?

Yes. Set `task` to `translate` and select a multilingual model.

#### How does automatic language work?

Set `language` to `auto` to return language metadata when it can be determined. If certainty is low, language fields may be empty rather than guessed.

#### Why does a batch item show an error?

The item may be unavailable, too large, unsupported, or contain no detected speech. Other valid batch items continue normally.

#### Is speaker diarization included?

No. This release provides transcript text and timed segments, not speaker labels.

### Related Actors

- [YouTube Scraper](https://apify.com/fetch_cat/youtube-scraper)
- [TikTok Sound Scraper](https://apify.com/fetch_cat/tiktok-sound-scraper)
- [Instagram AI Transcript Extractor](https://apify.com/fetch_cat/instagram-ai-transcript-extractor)
- [Podcast Episode Scraper](https://apify.com/fetch_cat/podcast-episode-scraper)
- [Video Metadata Scraper](https://apify.com/fetch_cat/video-metadata-scraper)

### Support

For help, share a sanitized input, the affected `inputUrl`, and the dataset `error` value. Do not send credentials or private-media links.

# Actor input Schema

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

Public direct media and supported no-login web video/audio pages. Duplicates are processed once.

## `feedUrls` (type: `array`):

Expand recent episodes from public podcast feeds.

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

Maximum recent enclosure episodes to expand from each public feed.

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

Use auto detection or an ISO 639-1 language code such as en, es, de, fr or ja.

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

tiny is fastest, base balances speed and quality, small favors accuracy, and base.en is the legacy English-only option.

## `task` (type: `string`):

Transcribe in the spoken language or translate speech to English.

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

Audio beyond this per-item billing and processing cap is not transcribed.

## Actor input object example

```json
{
  "mediaUrls": [
    {
      "url": "https://raw.githubusercontent.com/ggml-org/whisper.cpp/master/samples/jfk.wav"
    }
  ],
  "maxEpisodesPerFeed": 5,
  "language": "auto",
  "model": "base",
  "task": "transcribe",
  "maxMinutesPerItem": 30
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `subtitles` (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": [
        {
            "url": "https://raw.githubusercontent.com/ggml-org/whisper.cpp/master/samples/jfk.wav"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/video-audio-transcriber-scraper").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": [{ "url": "https://raw.githubusercontent.com/ggml-org/whisper.cpp/master/samples/jfk.wav" }] }

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/video-audio-transcriber-scraper").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": [
    {
      "url": "https://raw.githubusercontent.com/ggml-org/whisper.cpp/master/samples/jfk.wav"
    }
  ]
}' |
apify call fetch_cat/video-audio-transcriber-scraper --silent --output-dataset

```

## MCP server setup

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

```

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/gqEgfHFi11z72WZe6/builds/YRNdaQHEGjNDTal96/openapi.json