# Large Video to Transcript (`esteemed_chimta/large-video-to-transcript`) Actor

Convert large video and audio files into speaker-labeled transcript bundles with TXT, JSON, SRT, VTT, and quality reports.

- **URL**: https://apify.com/esteemed\_chimta/large-video-to-transcript.md
- **Developed by:** [Will Pulier](https://apify.com/esteemed_chimta) (community)
- **Categories:** AI, Videos, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $100.00 / 1,000 transcription minutes

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Large Video to Transcript

Upload a large video or audio file, click **Go**, and get an MP3 plus timestamped transcript exports when the job is done.

Use the Actor's **Standby** tab for the customer flow. Do not start from **Runs** or the raw **Input** form unless you intentionally want the fallback Apify batch path.

Open the Standby uploader, choose an MP4, MOV, WebM, MP3, M4A, or WAV file, or paste a direct downloadable media URL. The Actor handles the rest: upload, media prep, MP3 creation, transcription, subtitles, quality reporting, ZIP packaging, and clean signed download links.

This is built for long recordings that are painful to process manually: client calls, Zoom recordings, sales calls, coaching sessions, podcasts, webinars, internal meetings, course videos, and research interviews.

### What You Get

Each successful source produces:

- `MP3`: normalized speech audio
- `TXT`: readable transcript with timestamps and speaker labels
- `JSON`: normalized transcript data with segments and word data when available
- `SRT`: subtitle export
- `VTT`: web subtitle export
- `quality.json`: coverage, word count, speaker count, warnings, and failures
- `ZIP`: one downloadable bundle containing all transcript artifacts when `includeZip` is enabled

The Actor also writes one dataset row per source with status, quality, duration, word count, speaker count, signed MP3/transcript/ZIP links, artifact keys, billing metadata, and any errors.

### How To Run

1. Open the Actor's **Standby** tab. If you are on **Runs** or **Input**, you are in the fallback Apify form, not the simple upload flow.
2. Open the upload page.
3. Choose one video/audio file or paste one direct downloadable media URL.
4. Click **Go**.
5. Keep the job page open, or bookmark it and come back later.
6. Download the MP3, transcript, subtitles, JSON, quality report, or ZIP bundle when the job is complete. The **Transcript** link downloads the `.txt` file directly.

The normal Apify **Input** form still works as a fallback/API-compatible batch path, but the Standby uploader is the primary product experience. It avoids Apify's technical upload modal and keeps the flow to: upload, click Go, download results.

Local files still need to transfer before transcription starts, but the Standby uploader shows progress and starts the worker run automatically. For very large files, especially over 500 MB, a direct downloadable media URL is usually faster and easier to retry. The finished MP3, TXT, JSON, SRT, VTT, quality report, and ZIP links are signed browser-download links, so you do not need to manually add an API token to open the results after a run completes. These files are stored in the run's default Apify key-value store, so retention follows the run storage settings on your Apify account; download or preserve important outputs before that storage expires.

### Why Use This Actor

- Handles large video and audio files without building your own upload/transcription pipeline.
- Produces transcript exports that are useful outside Apify: text, subtitles, JSON, and ZIP.
- Uses speaker-aware authoritative transcription by default.
- Includes a quality report so you can see whether the transcript looks complete.
- Continues processing later files even if one source fails.

### API Example

Run the Actor in normal mode with a direct media URL:

```bash
curl -X POST "https://api.apify.com/v2/acts/kTgaX3cfI6dlJHa6J/runs?token=$APIFY_TOKEN&maxTotalChargeUsd=10" \
  -H "Content-Type: application/json" \
  -d '{"media":["https://example.com/recording.mp4"]}'
````

Request body:

```json
{
  "media": ["https://example.com/recording.mp4"]
}
```

The Standby API also supports job-based submission:

```bash
curl -X POST "$ACTOR_STANDBY_URL/jobs" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mediaUrl":"https://example.com/recording.mp4"}'
```

### Managed Transcription

No provider account or API key is required. The managed transcription provider is included in the Actor price, so users can run the Actor like a normal paid Apify tool: submit media and receive MP3, transcript, subtitle, JSON, quality, and ZIP outputs.

Provider selection, audio preparation, chunking, retries, and quality checks are handled inside the Actor. Advanced provider overrides may be used for private testing, but they are not part of the public product surface.

### Pricing Behavior

This Actor is designed for Apify Pay Per Event pricing.

The production billing event is:

```text
transcription-minute
```

It represents one started minute of successfully generated transcript output. The Actor checks the run charge limit before expensive transcription work and delivers artifacts only after the configured Apify charge succeeds.

Recommended launch price:

```text
$0.10 per transcription-minute
```

The recommended price is meant to cover provider costs, platform compute, storage, large-file handling, retries, transcript formatting, subtitle generation, ZIP packaging, and quality reporting.

Launch margin policy:

- Keep platform usage pass-through enabled until real paid runs prove the runtime cost.
- Keep managed-key pricing at `$0.10/min` or higher.
- Raise to `$0.12-$0.15/min` if platform usage is absorbed and median runtime exceeds `4x` source audio duration.

### Limitations

- Transcription quality depends on source audio quality, overlapping speakers, background noise, accents, and provider behavior.
- Speaker labels are generic, such as `Speaker 0`, unless a future workflow maps names.
- Direct media URLs are supported for API users by passing strings in the `media` array; URLs must be downloadable by the Actor without an interactive login.
- Upload or transcribe only media you own, are licensed to process, or otherwise have permission to process.

### Development

```bash
python -m venv .venv
source .venv/bin/activate
python -m pip install -r requirements.txt
python -m unittest discover -s tests
python -m py_compile main.py src/apify_transcript/*.py
```

Docker build:

```bash
docker build -f .actor/Dockerfile .
```

# Actor input Schema

## `media` (type: `array`):

This is the fallback Apify run form. For the normal customer flow, go to the Actor Standby tab instead, open the upload page, choose one MP4, MOV, WebM, MP3, M4A, or WAV file, and click Go. Use this field only for API/batch-compatible normal runs.

## Actor input object example

```json
{}
```

# Actor output Schema

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

Dataset rows with status, quality, duration, word count, speaker count, and signed artifact links for each uploaded media file.

## `summary` (type: `string`):

JSON summary with total successful and failed media files.

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

Key-value store records for MP3, TXT, JSON, SRT, VTT, quality report, and ZIP outputs.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("esteemed_chimta/large-video-to-transcript").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("esteemed_chimta/large-video-to-transcript").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{}' |
apify call esteemed_chimta/large-video-to-transcript --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=esteemed_chimta/large-video-to-transcript",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Large Video to Transcript",
        "description": "Convert large video and audio files into speaker-labeled transcript bundles with TXT, JSON, SRT, VTT, and quality reports.",
        "version": "0.3",
        "x-build-id": "MQcFe0kBlID4TqMSL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/esteemed_chimta~large-video-to-transcript/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-esteemed_chimta-large-video-to-transcript",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/esteemed_chimta~large-video-to-transcript/runs": {
            "post": {
                "operationId": "runs-sync-esteemed_chimta-large-video-to-transcript",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/esteemed_chimta~large-video-to-transcript/run-sync": {
            "post": {
                "operationId": "run-sync-esteemed_chimta-large-video-to-transcript",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "media"
                ],
                "properties": {
                    "media": {
                        "title": "Fallback upload input",
                        "minItems": 1,
                        "maxItems": 10,
                        "type": "array",
                        "description": "This is the fallback Apify run form. For the normal customer flow, go to the Actor Standby tab instead, open the upload page, choose one MP4, MOV, WebM, MP3, M4A, or WAV file, and click Go. Use this field only for API/batch-compatible normal runs.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```