# Subtitle Delivery QC (`immemorial_sarinda/subtitle-delivery-qc`) Actor

Check simple SRT or WebVTT subtitles for numbering, timing, overlaps, reading rate, line length and media-duration overruns. Get one complete deterministic report. Restricted basic-cue profiles; no transcription, translation, repair or media inspection.

- **URL**: https://apify.com/immemorial_sarinda/subtitle-delivery-qc.md
- **Developed by:** [Picknotes](https://apify.com/immemorial_sarinda) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$100.00 / 1,000 completed reports

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

## Subtitle Delivery QC

Check one SRT or WebVTT basic-cue subtitle file for numbering, timing, overlaps,
reading rate, line length and endpoints beyond a supplied media duration.
Get one complete JSON report with a row for every cue. Reports with findings are
completed reports too. This tool does not transcribe, translate, repair, render,
inspect media, or certify accessibility or full WebVTT conformance.

### Quickstart

For the bundled synthetic SRT example, use:

```json
{"useDemo": true}
```

For your own simple SRT file, use:

```json
{
  "useDemo": false,
  "authorizedNonpersonalNonconfidentialData": true,
  "subtitleText": "1\n00:00:00,000 --> 00:00:02,000\nHello world\n",
  "optionsJson": "{\"profile\":\"srt-basic/1\",\"duration_ms\":6000,\"max_cps_milli\":17000,\"max_line_chars\":42}"
}
```

For WebVTT use profile `webvtt-basic/1` and an exact `WEBVTT` header followed by
an empty line. Use plain cue timing and text only. Cue identifiers, settings,
NOTE/STYLE/REGION blocks, markup and entities are unsupported. SRT requires
positive cue numbers and `HH:MM:SS,mmm` timestamps. WebVTT uses decimal points.
Both profiles accept LF or CRLF and an optional initial UTF-8 BOM. Unsupported
syntax rejects the entire input; it is never silently discarded.

`optionsJson` is a JSON string containing an object, not an embedded object.
`profile` is required. Optional `duration_ms`, `max_cps_milli` and
`max_line_chars` must be exact integers or null. Omission/null disables that
check. A rate of 17000 means 17 code points per second. Duration is 0–359999999
milliseconds, rate is 1–1000000, and line threshold is 1–4096.
Counts are Unicode code points, not visual width or graphemes.

### Limits

- Subtitle: 1,048,576 UTF-8 bytes; options: 4,096 UTF-8 bytes
- At most 10,000 cues and 4,096 code points per cue including internal line breaks
- Complete report: at most 2,097,152 bytes
- Raw Actor input envelope and complete dataset POST: each at most 4,500,000 bytes
- All limits apply together. Escaping can make the envelope larger than the subtitle.
- Processing is bounded: 50-second entry deadline and 10-second private worker deadlines.

No partial report is returned on rejection, timeout or output overflow.
Overlap findings provide one deterministic witness per affected cue, not every pair.

### Results and price

The default dataset receives at most one item containing the full canonical
report in `reportJson`, report byte length and SHA-256, input hashes and a
completion receipt. Parse `reportJson` as JSON to read the report. `ok` and
`issues` are both complete reports and use the same completed-report price:
USD 0.10, including platform usage; check the Actor's displayed pricing
before running. The receipt's expected price is not proof of configured billing,
a charge or settlement.

A delivery is confirmed only after exact dataset readback. An interrupted or
unconfirmed append may already have been accepted and billed. Check the run and
dataset before deciding what to do; never automatically repost an uncertain run.

### Input privacy

Apify stores INPUT before processing. Submit only data you have rights to process
that is nonpersonal and nonconfidential, without credentials or secrets. Own mode
requires the explicit authorization flag. Demo mode requires no customer content.
Reports omit cue text but retain timing, counts, ordinals and source hashes.
This is not anonymization, secret scanning or a storage/deletion guarantee.

# Actor input Schema

## `authorizedNonpersonalNonconfidentialData` (type: `boolean`):

Required true for your own input: confirm processing rights and nonpersonal, nonconfidential data without secrets.

## `optionsJson` (type: `string`):

Own mode only; exact UTF-8 JSON bytes at most4096. Required profile srt-basic/1 or webvtt-basic/1. Optional exact integer/null duration_ms, max_cps_milli and max_line_chars. Options bytes are hashed unchanged.

## `subtitleText` (type: `string`):

Own mode only; UTF-8 bytes at most1048576. Narrow basic-cue profiles reject markup, settings and unsupported syntax. Raw envelope byte cap applies independently.

## `useDemo` (type: `boolean`):

Use the bundled synthetic SRT example; omit subtitleText and optionsJson in demo mode.

## Actor input object example

```json
{
  "authorizedNonpersonalNonconfidentialData": false,
  "useDemo": true
}
```

# Actor output Schema

## `results` (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 = {
    "useDemo": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("immemorial_sarinda/subtitle-delivery-qc").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 = { "useDemo": True }

# Run the Actor and wait for it to finish
run = client.actor("immemorial_sarinda/subtitle-delivery-qc").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 '{
  "useDemo": true
}' |
apify call immemorial_sarinda/subtitle-delivery-qc --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,immemorial_sarinda/subtitle-delivery-qc"
        }
    }
}
```

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/OhZsrcXeBdci26ixo/builds/0bcaJxt3XQC90TaBh/openapi.json