# Speech to Text with Timestamps (SRT/VTT) – Chinese & Japanese (`kumo-data-tools/speech-to-text-srt`) Actor

Transcribe audio and video files to SRT/VTT subtitles and text with timestamps. Accurate on Chinese (Simplified or Traditional output) and Japanese, works for many other languages. Pay only for minutes transcribed; files that fail to download or decode are free. Built for AI agents.

- **URL**: https://apify.com/kumo-data-tools/speech-to-text-srt.md
- **Developed by:** [Kumo Data Tools](https://apify.com/kumo-data-tools) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $15.00 / 1,000 audio minute transcribeds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Speech to Text with Timestamps (SRT/VTT) – Chinese & Japanese

Turn audio and video files into **subtitles (SRT / WebVTT)**, **plain text** and **JSON segments with start/end times**. Built for people and AI agents that need *timed* transcripts, with extra care for **Chinese** and **Japanese**.

- 🎯 **Accurate on Chinese and Japanese** – with the same speech model this Actor uses, we measured a character error rate of **8.0% (Chinese)** and **3.95% (Japanese)** on 30 + 30 clips of Google's FLEURS benchmark (whole clips, punctuation ignored, measured 2026-10-21).
- 🀄 **Simplified or Traditional** – Chinese output is normalized to the script you choose (简体 / 繁體). Segments detected as Japanese, or as mixed Japanese and Chinese, are left unchanged.
- ⏱️ **Timestamps from a modern speech model** – speech is split at natural pauses and every segment gets its own start/end time, ready for subtitles.
- 💸 **Pay only for audio that was transcribed** – a failed download or decode costs nothing.
- 🤖 **Agent-friendly** – one dataset item per file with the full text, segments and download links.

### How to use

1. Paste one or more **direct links** to audio or video files (mp3, m4a, wav, ogg, opus, flac, mp4, mov, webm …) into **Audio or video file URLs**.
2. Optional: set **Spoken language** (`zh`, `zh-cn`, `zh-tw`, `ja`, `en` …). Leave it empty to auto-detect.
3. Optional: choose **Chinese characters** (Auto / Simplified / Traditional / Keep).
4. Run. Each file becomes one dataset item; the SRT / VTT / TXT / JSON files are saved in the run's key-value store and linked from the item.

Leave the URL list empty to try it on a short bundled sample – free (the sample's transcript is pre-computed).

### Pricing

**$0.015 per started minute of audio, per file** (a 64-second file = 2 minutes = $0.03). Minutes are billed as they are transcribed: files that fail before transcription (download, decode, too long) and files with no detected speech are not charged; if transcription stops part-way, you get and pay for the minutes transcribed so far. Each run also has Apify's standard start fee of $0.00005 per GB of memory ($0.0001 at the default 2 GB). Platform usage is included. Set **Max total charge** on the run to cap your spend – files that would exceed it are skipped and reported, not charged.

### Input

| Field | Type | Default | Notes |
|---|---|---|---|
| `audioUrls` | array of strings | – | Up to 50 files per run, 500 MB and 60 minutes each (public http(s) links) |
| `language` | string | auto | ISO code, e.g. `zh`, `zh-tw`, `ja`, `en` |
| `chineseScript` | `auto` / `simplified` / `traditional` / `keep` | `auto` | Applied only to Chinese speech |
| `outputFormats` | array | `srt`, `vtt`, `txt` | `json` adds a JSON segments file |
| `maxSegmentSeconds` | integer | 15 | 5–30 |

### Output

One dataset item per input file:

```json
{
  "url": "https://example.com/meeting.m4a",
  "status": "ok",
  "durationSec": 64.27,
  "billableMinutes": 2,
  "detectedLanguages": ["ja"],
  "segmentCount": 13,
  "text": "本日の会議を始めます。\nまず先月の売り上げについてです。…",
  "segments": [{"start": 0.0, "end": 2.06, "text": "本日の会議を始めます。"}],
  "files": {"srt": "https://api.apify.com/v2/key-value-stores/…/records/file-0.srt", "vtt": "…", "txt": "…"}
}
```

`status` is `ok`, `partial` (stopped part-way: the transcribed minutes are included and billed), `error` (with `message`, not charged), `no_speech` (no speech detected: not charged) or `skipped` (max total charge reached, not charged).

### FAQ

**Which languages work?** Chinese (Mandarin) and Japanese are what we measured and tuned for. Other languages supported by the speech model also work; set `language` for the best result.

**How accurate are the timestamps?** Segment boundaries come from voice-activity detection at natural pauses, with a short padding around each segment. Timestamps are per segment, not per word.

**Can I transcribe YouTube or other platform links?** No. Use direct links to files you own or have the right to process. This Actor does not download from video platforms.

**How is my data handled?** Your file is downloaded into the run, decoded, and the speech is sent to OpenAI's transcription API. OpenAI states that data sent to its API is not used to train its models, and lists no retention for the transcription endpoint ([OpenAI: your data](https://developers.openai.com/api/docs/guides/your-data)). Results are stored only in your own Apify run storage, under Apify's retention settings. We do not keep copies.

**What if a file fails?** It is reported with a message; nothing is charged for audio that was not transcribed, and the other files in the run continue.

### Notes

- The bundled sample is a clip from **Google FLEURS** ([google/fleurs](https://huggingface.co/datasets/google/fleurs), dev split, `cmn_hans_cn`, file `11635592428808064812.wav`), licensed **[CC BY 4.0](https://creativecommons.org/licenses/by/4.0/)**, re-encoded to Opus (no other changes).
- Not affiliated with OpenAI or Google.

# Actor input Schema

## `audioUrls` (type: `array`):

Direct download links to audio or video files you have the right to transcribe (mp3, m4a, wav, ogg, opus, flac, mp4, mov, webm, ...). Up to 50 files per run, 500 MB and 60 minutes each. Leave empty to transcribe a short bundled sample for free.

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

Language code of the speech, e.g. zh, zh-cn, zh-tw, ja, en, ko. Leave empty to auto-detect. Setting it improves accuracy.

## `chineseScript` (type: `string`):

For Chinese speech only (segments detected as Japanese are left unchanged). auto = Traditional for zh-tw, Simplified otherwise.

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

Files written to the run's key-value store for each input (links are in the dataset). The dataset always contains the segments with timestamps.

## `maxSegmentSeconds` (type: `integer`):

Speech is split at pauses; segments stay about this long or shorter. 5-30.

## Actor input object example

```json
{
  "language": "",
  "chineseScript": "auto",
  "outputFormats": [
    "srt",
    "vtt",
    "txt"
  ],
  "maxSegmentSeconds": 15
}
```

# Actor output Schema

## `transcripts` (type: `string`):

No description

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

// Run the Actor and wait for it to finish
const run = await client.actor("kumo-data-tools/speech-to-text-srt").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("kumo-data-tools/speech-to-text-srt").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 '{}' |
apify call kumo-data-tools/speech-to-text-srt --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kumo-data-tools/speech-to-text-srt"
        }
    }
}
```

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/iIyRB0uJBagwSKDQC/builds/0ozZyyX0bUK7CPXn3/openapi.json