# Video To Text Transcription Scraper (`automation-lab/video-to-text-transcriber`) Actor

Convert direct public video files into plain text, timestamped segments, SRT, and VTT with local Whisper speech recognition—no separate transcription API key.

- **URL**: https://apify.com/automation-lab/video-to-text-transcriber.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** AI
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/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

## Video To Text Transcription Scraper

Convert direct public video files into reusable text, timestamped segments, and optional SRT or VTT subtitle files. This Actor performs **video to text transcription** locally with Whisper, so you do not need a separate speech-recognition API key.

Provide up to 10 anonymously accessible video file URLs. Each successful result includes the complete transcript, detected language, timestamps, duration, dimensions, codecs, and processing metadata.

### What does this Actor do?

The Actor downloads each supplied video within explicit size and duration limits, validates that it contains both video and audio streams, and runs local speech recognition.

It can:

- convert MP4, WebM, Ogg, and other ffmpeg-readable video files to text;
- detect the spoken language or use a supplied language hint;
- return a normalized full transcript;
- return segment-level start and end timestamps;
- create SRT and VTT subtitle files;
- expose video duration, dimensions, and codec metadata;
- process up to 10 direct video URLs in one run;
- report an actionable error record for each failed video.

This Actor does not scrape web pages or social post URLs. The URL must resolve directly to a public video file.

### Who is it for?

- **Content teams** converting recorded interviews, demos, or clips into draft copy.
- **Accessibility teams** creating timed subtitle files for review.
- **Researchers** turning supplied video evidence into searchable text.
- **Developers** adding direct-file transcription to an Apify Task, workflow, or API pipeline.
- **Automation teams** processing small batches of public or intentionally shared videos.

### Why use this video transcriber?

- **No transcription API key:** inference runs inside the Actor container.
- **Structured output:** use plain text and timestamped segments without parsing a document.
- **Subtitle artifacts:** generate SRT and VTT alongside the dataset record.
- **Video-specific validation:** audio-only files and silent videos fail clearly.
- **Safe public downloads:** private-network targets, credentialed URLs, oversized files, and excessive redirects are rejected.
- **Predictable charging:** only successfully transcribed started video minutes are charged.

For a broader input contract that also accepts direct audio files, use [Audio Speech-to-Text Transcriber](https://apify.com/automation-lab/audio-speech-to-text-transcriber).

### What data does it return?

| Field | Type | Description |
| --- | --- | --- |
| `sourceUrl` | string | Submitted direct video URL |
| `status` | string | `succeeded` or `failed` |
| `transcript` | string or null | Complete normalized transcript |
| `language` | string or null | Detected or requested language |
| `languageProbability` | number or null | Automatic language-detection confidence |
| `durationSeconds` | number or null | Probed video duration |
| `width`, `height` | number or null | Video dimensions in pixels |
| `videoCodec` | string or null | Probed video codec |
| `audioCodec` | string or null | Probed audio codec |
| `segments` | array | Timestamped transcript segments |
| `srtKey`, `vttKey` | string or null | Key-value-store artifact keys |
| `model` | string | Local Whisper model identifier |
| `processedAt` | string | ISO 8601 completion time |
| `processingSeconds` | number | Wall-clock time for the video |
| `error` | string or null | Failure reason for failed inputs |

### How to transcribe a video to text

1. Open the Actor input page.
2. Add one or more direct public video file URLs under **Video file URLs**.
3. Keep `language` set to `auto`, or enter a language code such as `en`.
4. Choose whether to generate SRT, VTT, both, or neither.
5. Adjust file-size and duration limits if necessary.
6. Start the run.
7. Read transcript records in the default dataset.
8. Download subtitle files from the run key-value store when requested.

A direct URL normally ends in a media extension or returns video bytes immediately. A YouTube watch page, Facebook post, cloud-drive preview page, or login screen is not a direct video file.

### Input parameters

#### `videoUrls`

Required array containing 1–10 direct, credential-free HTTP(S) video file URLs. Redirects are supported when every destination remains public.

If you upload a file to an Apify key-value store, use an intentionally public record URL. Do not expose private or sensitive recordings.

#### `language`

Optional spoken-language code. The default is `auto`.

Examples:

- `en` for English;
- `es` for Spanish;
- `de` for German;
- `pt-BR` for Brazilian Portuguese;
- `auto` for automatic detection.

A correct language hint can improve results on short or ambiguous recordings.

#### `outputFormats`

Optional array containing `srt`, `vtt`, both, or neither. Subtitle files use segment timestamps from the same transcript record and are included without an additional billing event.

#### `maxFileSizeMb`

Maximum bytes accepted per video, expressed in MB. Default: 250. Allowed range: 1–500.

#### `maxDurationMinutes`

Maximum accepted duration per video. Default: 60. Allowed range: 1–180.

### Example input

```json
{
  "videoUrls": [
    { "url": "https://media.w3.org/2010/05/sintel/trailer.mp4" }
  ],
  "language": "auto",
  "outputFormats": ["srt", "vtt"],
  "maxFileSizeMb": 250,
  "maxDurationMinutes": 5
}
```

### Example output

The prefilled W3C video currently produces a record shaped like this:

```json
{
  "sourceUrl": "https://media.w3.org/2010/05/sintel/trailer.mp4",
  "status": "succeeded",
  "transcript": "What brings you to the land of the gatekeepers? I'm searching for someone.",
  "language": "en",
  "languageProbability": 0.995,
  "durationSeconds": 52.208333,
  "width": 854,
  "height": 480,
  "videoCodec": "h264",
  "audioCodec": "aac",
  "segments": [
    { "id": 0, "start": 12.0, "end": 15.0, "text": "What brings you to the land of the gatekeepers?" }
  ],
  "srtKey": "TRANSCRIPT_001.SRT",
  "vttKey": "TRANSCRIPT_001.VTT",
  "model": "tiny",
  "processedAt": "2026-01-15T12:00:00.000Z",
  "processingSeconds": 8.2,
  "error": null
}
```

Timestamp boundaries and confidence can vary slightly between runtime versions. The transcript and metadata types remain stable.

### How much does it cost to transcribe video files?

Pricing has two parts:

- a **$0.005 start event**, charged once only after the first successful transcription;
- **$0.0172 per started video minute** at the Bronze tier, with lower per-minute rates at higher usage tiers.

Example Bronze-tier event charges:

| Successful video duration | Started minutes | Event price |
| ---: | ---: | ---: |
| 52 seconds | 1 | $0.0222 total including start |
| 5 minutes | 5 | $0.091 total including start |
| 25 minutes | 25 | $0.435 total including start |
| 100 minutes | 100 | $1.725 total including start |

Failed inputs are uncharged. Requested output artifacts are included in the successful-minute event. Apify platform usage may be billed according to your Apify plan. Exact live pricing is shown on the Actor page before a run.

### Video formats and direct URLs

ffmpeg performs media decoding, so common MP4, WebM, Ogg, MOV, and Matroska files normally work when their codecs are supported by the bundled runtime.

File extensions are not trusted on their own. The Actor probes the downloaded bytes and requires:

- a real video stream;
- an audio stream;
- a positive readable duration;
- duration and size within your limits.

Signed URLs can work if they remain valid and require no custom authorization header. Expired URLs fail with an error record.

### Accuracy and limitations

The Actor uses the compact local Whisper `tiny` model with CPU int8 inference. It favors autonomous processing and predictable costs over maximum model accuracy.

Accuracy can decrease with:

- overlapping speakers;
- background music or loud effects;
- low-volume speech;
- strong accents or specialized terms;
- very short utterances;
- multiple languages in one clip.

Review transcripts before using them for legal, medical, safety-critical, or publication decisions. Speaker diarization, translation, OCR, scene analysis, and summarization are not included.

### Failure behavior

Each submitted video is processed independently.

- A failed URL produces an uncharged dataset row with `status: "failed"` and an `error`.
- Successful videos in the same batch are preserved.
- If every video fails, the Actor run exits with failure status.
- Temporary media files are removed after processing.
- Transient network failures and temporary 429/5xx responses receive bounded retries.
- Stable invalid input, 404 responses, private destinations, and unsupported media are not retried blindly.

### Integration ideas

#### Accessibility pipeline

Run a Task when a team places a public video URL in a queue. Send the generated SRT to a reviewer and retain timestamped segments in a dataset.

#### Searchable research archive

Transcribe interview or evidence clips, then index `transcript` and `segments.text` in a search database.

#### Content repurposing

Send the transcript to a downstream summarizer, editor, or language model to draft notes, descriptions, or article outlines. Human review remains important.

#### Batch conversion

Submit up to 10 direct files per run and export the default dataset to JSON, CSV, Excel, or another Apify integration.

### Run with the Apify API using cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~video-to-text-transcriber/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "videoUrls": [{"url":"https://media.w3.org/2010/05/sintel/trailer.mp4"}],
    "language": "en",
    "outputFormats": ["srt"]
  }'
```

Use `run-sync-get-dataset-items` instead when your client can wait for the complete result.

### Run with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/video-to-text-transcriber').call({
  videoUrls: [{ url: 'https://media.w3.org/2010/05/sintel/trailer.mp4' }],
  language: 'auto',
  outputFormats: ['srt', 'vtt'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].transcript);
```

### Run with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("automation-lab/video-to-text-transcriber").call(run_input={
    "videoUrls": [{"url": "https://media.w3.org/2010/05/sintel/trailer.mp4"}],
    "language": "auto",
    "outputFormats": ["vtt"],
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items[0]["transcript"])
```

### Use with Apify MCP

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/video-to-text-transcriber"
```

#### Claude Desktop, Cursor, and VS Code

Use this equivalent MCP configuration in Claude Desktop, Cursor, or VS Code:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/video-to-text-transcriber"
    }
  }
}
```

Example prompts:

- “Transcribe this direct MP4 URL and return the text with timestamps.”
- “Create SRT and VTT files for these two public WebM videos.”
- “Convert this interview video to English text and list each timestamped segment.”

### Legality and responsible use

Only process videos you are authorized to access and transcribe. Respect copyright, privacy, confidentiality, contractual restrictions, and applicable recording-consent laws.

The Actor intentionally blocks private-network destinations and credentialed URLs, but technical access does not by itself grant legal permission. Avoid publishing private file URLs in Task inputs, logs, or shared datasets.

### FAQ and troubleshooting

#### Why does the Actor say there is no video stream?

You probably supplied an audio file, HTML page, preview page, or unsupported container. Open the URL without authentication and confirm it returns video bytes directly.

#### Why does the Actor say there is no audio stream?

The video is silent or its audio codec could not be detected. A visible video stream alone cannot produce speech text.

#### Why did automatic language detection choose the wrong language?

Short or noisy videos can be ambiguous. Set `language` to a known code such as `en` and rerun.

#### Why did every video fail the run?

Inspect the dataset error rows. Typical reasons are an expired signed URL, HTTP 403/404, private destination, oversized file, duration above the chosen limit, missing audio, or no detected speech.

#### Can it transcribe YouTube, TikTok, Instagram, or Facebook post URLs?

Not directly. This Actor accepts direct video file URLs, not post pages or media-platform pages. Use a source-specific automation to obtain an authorized direct file first.

#### Does it translate or identify speakers?

No. It returns speech in the recognized language without translation or speaker diarization.

### Related Actors

- [Audio Speech-to-Text Transcriber](https://apify.com/automation-lab/audio-speech-to-text-transcriber) — accepts direct public audio and video media URLs.
- [Facebook Video Transcript Extractor](https://apify.com/automation-lab/facebook-video-transcript-extractor) — works with supported public Facebook video transcript workflows.

### Support

If a valid direct public video fails, include the run URL, HTTP-visible file type, and non-sensitive input settings in an Apify issue. Do not post private recordings, expiring secrets, credentials, or sensitive transcript contents.

# Actor input Schema

## `videoUrls` (type: `array`):

One to ten direct, anonymously accessible HTTP(S) video file URLs. Uploaded files may be supplied through their public Apify key-value-store URL. Web pages and social post URLs are not supported.

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

Use auto to detect the language, or provide a language code such as en, es, de, or pt-BR.

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

Optionally save SubRip (SRT) and/or WebVTT files in the run key-value store.

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

Reject each download above this limit. The hard maximum is 500 MB.

## `maxDurationMinutes` (type: `integer`):

Reject videos longer than this limit. The hard maximum is 180 minutes.

## Actor input object example

```json
{
  "videoUrls": [
    {
      "url": "https://media.w3.org/2010/05/sintel/trailer.mp4"
    }
  ],
  "language": "auto",
  "outputFormats": [
    "srt",
    "vtt"
  ],
  "maxFileSizeMb": 250,
  "maxDurationMinutes": 60
}
```

# Actor output Schema

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

Dataset containing successful transcripts and per-video error records.

## `files` (type: `string`):

Key-value store containing optional SRT and VTT artifacts.

# 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 = {
    "videoUrls": [
        {
            "url": "https://media.w3.org/2010/05/sintel/trailer.mp4"
        }
    ],
    "language": "auto",
    "outputFormats": [
        "srt",
        "vtt"
    ],
    "maxFileSizeMb": 250,
    "maxDurationMinutes": 60
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/video-to-text-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 = {
    "videoUrls": [{ "url": "https://media.w3.org/2010/05/sintel/trailer.mp4" }],
    "language": "auto",
    "outputFormats": [
        "srt",
        "vtt",
    ],
    "maxFileSizeMb": 250,
    "maxDurationMinutes": 60,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/video-to-text-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 '{
  "videoUrls": [
    {
      "url": "https://media.w3.org/2010/05/sintel/trailer.mp4"
    }
  ],
  "language": "auto",
  "outputFormats": [
    "srt",
    "vtt"
  ],
  "maxFileSizeMb": 250,
  "maxDurationMinutes": 60
}' |
apify call automation-lab/video-to-text-transcriber --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/video-to-text-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/35ioD2nmdfH5NKipw/builds/hMCYtKBaEsJ0Edq3X/openapi.json