# Rutube Transcript (`agentx/rutube-transcript`) Actor

RUTUBE Transcript converts one public video or Short into structured text for media monitoring, multilingual analysis, and searchable archives. It provides detected language, ordered timestamps, video metadata, and optional translation into 133 languages. Transcript pricing starts at $0.3159.

- **URL**: https://apify.com/agentx/rutube-transcript.md
- **Developed by:** [AgentX](https://apify.com/agentx) (community)
- **Categories:** Videos, AI, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.3159 / transcript

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 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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## RUTUBE Transcript - Timestamped Speech-to-Text API

**RUTUBE Transcript converts one public RUTUBE video or Short into detected-language text, timestamped speech segments, source metadata, and an optional translated transcript.** The Actor uses downloaded audio for automatic speech recognition; it does not promise RUTUBE subtitles or a native transcript track.

- One public RUTUBE video or Short URL is accepted per run.
- The resolved extractor is checked as RUTUBE before the formal download begins.
- Every successful result follows the Actor's 22-field Dataset contract.
- Requested translation is either complete and segment-aligned or absent; partial translation is not published as success.

[Run RUTUBE Transcript](https://apify.com/agentx/rutube-transcript?fpr=aiagentapi) · [Open the API page](https://apify.com/agentx/rutube-transcript/api?fpr=aiagentapi)

Use this Actor only where you have the right to process the media. RUTUBE's own FAQ places restrictions on unauthorized copying, so public reachability is not a substitute for permission.

---

### Why Choose This API

#### One known RUTUBE video, one structured record

Use the Actor when you already have a RUTUBE video URL and need its audible speech in a predictable data shape. Input is deliberately limited to one `video_url` plus an optional `translate` target. The URL must provide accessible RUTUBE media.

| Capability | Returned data |
| --- | --- |
| Speech recognition | Detected language, combined text, and ordered `start` / `end` / `text` segments |
| Video context | Title, description, creator, duration, publication time, thumbnail, categories, and tags when exposed |
| Engagement context | Views and other count fields when RUTUBE exposes them |
| Optional translation | Translated full text and segments that keep the source timestamps |

This is not a channel crawler, search API, playlist scraper, live recorder, native-caption service, speaker-diarization tool, summary generator, or general video downloader. A successful run publishes one Dataset item. Metadata that is not available remains null, zero, or empty according to the shared schema.

Automatic speech recognition can make mistakes with noise, music, overlapping speakers, names, accents, and specialist terminology. Treat the result as a reviewable transcript, not a certified or evidentiary record.

---

### Quick Start Guide

#### Transcribe a RUTUBE Short in three steps

1. Paste one public RUTUBE video or Short URL.
2. Leave `translate` empty for Russian or another detected source language, or select one translation target.
3. Start the Actor and read the one output item from the default Dataset.

```json
{
  "video_url": "https://rutube.ru/shorts/6fbd5439a31021e12d7559d8af23212a/",
  "translate": "english"
}
````

RUTUBE documents public videos, Shorts, content available only by link, and private content requiring an access key. This Actor accepts no credentials or access key as a separate input. Removed, restricted, unavailable, geographically limited, or protected videos can fail even when the URL format looks correct.

For multiple URLs, create separate Actor runs and control concurrency through an Apify client or workflow. Playlist downloading is disabled.

***

### Input Parameters

| Parameter | Type | Required | Description |
| --- | --- | --- | --- |
| `video_url` | string | Yes | One public RUTUBE video or Short URL |
| `translate` | string | No | Optional target language selected from the configured list |

The schema pre-fills an editable public Short URL. RUTUBE's official [embedding guide](https://rutube.ru/info/embed/) notes that a Short can be represented in the horizontal player by replacing `shorts` with `video`; the Actor accepts the Short URL form directly and lets the extractor resolve the media identity.

This single-platform Actor does not expose `video_file`. Uploaded files are handled only by the universal Video Transcript Actor. A channel, search page, playlist, studio/manage link, unrelated platform URL, or credential-gated video is outside this Actor's input contract.

The URL must resolve as accessible RUTUBE media, so a matching hostname string alone is not enough. Translation begins only after transcription. If any translated segment ultimately fails, no translation is attached and the translation event is not charged.

***

### Output Data Schema

One successful run publishes exactly 22 top-level fields:

| Group | Fields |
| --- | --- |
| Processing | `processor`, `processed_at`, `platform` |
| Source | `title`, `description`, `author`, `author_id`, `author_url`, `duration`, `published_at`, `thumbnail` |
| Audio and taxonomy | `audio_title`, `audio_artist`, `categories`, `tags` |
| Engagement | `view_count`, `like_count`, `shares_count`, `dislike_count`, `comment_count` |
| Speech | `transcript`, `translation` |

`transcript` contains `language`, combined `text`, and ordered `segments`. Each segment contains formatted `start`, `end`, and `text` values. `translation` uses the same shape when a requested translation completes.

The sample below illustrates the stable output shape rather than promising that a third-party video or its metadata will remain available. Creator names, duration metadata, counts, categories, titles, and publication details can change or be absent.

```json
{
  "processor": "https://apify.com/agentx/rutube-transcript?fpr=aiagentapi",
  "processed_at": "2026-07-21T14:06:50+00:00",
  "platform": "Rutube",
  "title": "БИЗНЕС С НУЛЯ #бизнес #интервью",
  "description": "Описание. По вопросам рекламы.",
  "author": "БИЗНЕС АКАДЕМИЯ",
  "author_id": null,
  "author_url": null,
  "duration": 30,
  "audio_title": null,
  "audio_artist": null,
  "view_count": 8,
  "like_count": null,
  "shares_count": null,
  "dislike_count": null,
  "comment_count": null,
  "categories": ["Бизнес и предпринимательство"],
  "tags": [],
  "published_at": "2026-03-19T16:18:25+00:00",
  "thumbnail": "https://pic.rtbcdn.ru/video/2026-03-20/c4/3c/c43c1d1bcb479c86c5f4c2ce32e3ecf1.jpg",
  "transcript": {
    "language": "Russian",
    "text": "Здравствуйте, меня зовут Александр, я ведущий с нами снова Владимир, предприниматель.",
    "segments": [
      {
        "start": "00:00:00.030",
        "end": "00:00:09.160",
        "text": "Здравствуйте, меня зовут Александр, я ведущий с нами снова Владимир, предприниматель."
      }
    ]
  },
  "translation": {
    "language": "English",
    "text": "Hello, my name is Alexander. I am the host, and Vladimir, an entrepreneur, is with us again.",
    "segments": [
      {
        "start": "00:00:00.030",
        "end": "00:00:09.160",
        "text": "Hello, my name is Alexander. I am the host, and Vladimir, an entrepreneur, is with us again."
      }
    ]
  }
}
```

The translation illustrates the output shape. Engagement counts and source availability are point-in-time values, while ASR wording can vary after dependency or media changes.

***

### Integration Examples

#### Apify API

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/agentx~rutube-transcript/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"video_url":"https://rutube.ru/shorts/6fbd5439a31021e12d7559d8af23212a/"}'
```

The API returns run metadata first. Poll the run or attach a webhook, then fetch items from its default Dataset. Do not embed production tokens in public or client-side code.

#### Python client

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("agentx/rutube-transcript").call(
    run_input={
        "video_url": "https://rutube.ru/shorts/6fbd5439a31021e12d7559d8af23212a/",
        "translate": "english",
    }
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items[0]["transcript"]["text"])
```

#### MCP configuration

Apify's MCP server can expose Actors to compatible AI clients. Follow the current client-specific Apify instructions and keep the token in a protected secret.

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

MCP changes orchestration, not the Actor's one-video input and one-item output contract.

***

### Pricing & Cost Calculator

The configured transcript event uses tiered pay-per-event pricing:

| Apify plan tier | Transcript event | Translation event |
| --- | ---: | ---: |
| Free | $0.35100 | $0.13000 |
| Bronze | $0.33930 | $0.12567 |
| Silver | $0.32760 | $0.12133 |
| Gold, Platinum, Diamond | $0.31590 | $0.11700 |

A completed optional translation uses the same account-tier row. Actor start costs $0.001 per event, with one event per allocated GB. The fixed 8192 MB run therefore generates eight start events. Runtime usage is metered at $0.00001 per configured usage event.

One successful Free-tier transcript without translation starts at $0.351 + $0.008 = $0.359, plus runtime usage. A completed Free-tier translation brings the fixed subtotal to $0.489. At Gold or above, the transcript portion is $0.3159 and translation is $0.117.

Long media requires more processing time. Failed access or extraction attempts can consume startup and runtime resources. Verify current Store pricing and use platform spending limits before batch execution.

***

### Use Cases & Applications

#### Russian-language research

Create reviewable Russian text from public interviews, explainers, and Shorts that you are authorized to process. Preserve timestamps and the source URL with any indexed excerpt.

#### Search and RAG

Chunk `transcript.text` for search or retrieval while retaining segment time ranges. Downstream systems should link answers back to the original media and make ASR uncertainty clear.

#### Multilingual review

Keep the detected Russian transcript next to any translated version. This allows bilingual reviewers to distinguish source recognition from machine translation.

#### Editorial workflows

Use segments as draft show notes, caption-editing material, or an outline source. The Actor does not create a summary or certify accessibility, and human review remains necessary before publication.

***

### FAQ

#### Does it support RUTUBE Shorts?

Yes. The input contract accepts one public RUTUBE Short URL, and the official embedding guide documents how Shorts map to the horizontal video player. The media must still be reachable, contain an audio track, and yield detectable speech when the run occurs.

#### Can it process private or link-only video?

Only URLs reachable by the downloader can succeed. This Actor does not accept login credentials or claim to bypass access keys, passwords, geographic limits, or other restrictions.

#### Does it download native RUTUBE subtitles?

The production implementation transcribes media audio. It does not promise a RUTUBE subtitle or transcript track.

#### Why are some fields null?

RUTUBE may not expose every creator or engagement field. The stable Dataset shape is preserved without invented values.

#### How are long videos handled?

Media up to 3600 seconds is transcribed directly. Longer media is processed sequentially in 900-second core chunks with 15 seconds of context on each available side; only one temporary chunk is retained at a time. Long videos still take more time and may consume more usage events.

#### Can I rely on the transcript without review?

No. Review critical names, numbers, quotes, and translations against the source. ASR output is not suitable as the sole basis for consequential decisions.

***

### SEO Keywords & Search Terms

Common discovery phrases include RUTUBE transcript API, Rutube video to text, RUTUBE speech-to-text, Russian video transcription, RUTUBE Shorts transcript, timestamped Russian transcript, video ASR API, multilingual video translation, RUTUBE metadata extraction, and Apify RUTUBE automation.

These phrases describe search intent, not additional product promises. The Actor remains a one-video speech-recognition workflow with structured source fields and optional translation.

***

### Trust & Certifications

- The public input accepts one RUTUBE video or Short URL and rejects unrelated platform extractors before download.
- The Dataset contract exposes 22 named fields with timestamped source and optional translated segments.
- Translation is published and charged only when its complete segment-aligned structure succeeds.
- No Store rating, adoption figure, accuracy percentage, certification, or one-off test result is presented as evidence of future performance.

These are inspectable contract properties, not a guarantee that RUTUBE content, access policy, or media availability will remain unchanged.

***

### Legal & Compliance

Use this Actor only with media you have the right to process. RUTUBE's [information prohibitions](https://rutube.ru/info/taboo_agreement/) forbid automated scripts, bots, or crawlers from collecting information or interacting with RUTUBE without special permission and restrict copying third-party content outside the service's permitted features. Review the [RUTUBE User Agreement](https://rutube.ru/info/agreement/) and obtain the permissions required for your workflow.

Public access does not automatically authorize copying, translation, republication, profiling, or model training. Follow copyright, privacy, contractual, sector-specific, and data-protection requirements. Respect takedowns, access settings, age restrictions, and geographic limits.

Minimize personal data, define a lawful purpose and retention period, and support correction or deletion where applicable. Require qualified human review for legal, medical, financial, safety, accessibility, or evidentiary use.

***

### Related Tools

- [YouTube Transcript](https://apify.com/agentx/youtube-transcript?fpr=aiagentapi) processes one public YouTube video.
- [TikTok Transcript](https://apify.com/agentx/tiktok-transcript?fpr=aiagentapi) processes one public TikTok video.
- [Video Transcript](https://apify.com/agentx/video-transcript?fpr=aiagentapi) handles uploads and supported public video URLs.

Use [All Video Scraper](https://apify.com/agentx/all-video-scraper?fpr=aiagentapi) for broader discovery and metadata workflows. Use the universal [Video Transcript](https://apify.com/agentx/video-transcript?fpr=aiagentapi) when uploaded-file support is required.

***

### Support & Community

- [Actor documentation](https://apify.com/agentx/rutube-transcript?fpr=aiagentapi)
- [API reference](https://apify.com/agentx/rutube-transcript/api?fpr=aiagentapi)
- [Telegram support](https://t.me/AiAgentApi)
- [All AgentX APIs](https://apify.com/agentx?fpr=aiagentapi)

For a reproducible support request, include the Actor run ID, the public URL if safe, the approximate run time, and the failed stage. Remove tokens, access keys, private URLs, and sensitive transcript text before sharing logs.

# Actor input Schema

## `video_url` (type: `string`):

Public RUTUBE video or Short URL to download and transcribe

## `translate` (type: `string`):

Select a target language to translate the transcript

## Actor input object example

```json
{
  "video_url": "https://rutube.ru/shorts/6fbd5439a31021e12d7559d8af23212a/"
}
```

# Actor output Schema

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

Browse transcripts with timestamped subtitles, translations, and video metadata.

# 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 = {
    "video_url": "https://rutube.ru/shorts/6fbd5439a31021e12d7559d8af23212a/"
};

// Run the Actor and wait for it to finish
const run = await client.actor("agentx/rutube-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 = { "video_url": "https://rutube.ru/shorts/6fbd5439a31021e12d7559d8af23212a/" }

# Run the Actor and wait for it to finish
run = client.actor("agentx/rutube-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 '{
  "video_url": "https://rutube.ru/shorts/6fbd5439a31021e12d7559d8af23212a/"
}' |
apify call agentx/rutube-transcript --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Rutube Transcript",
        "description": "RUTUBE Transcript converts one public video or Short into structured text for media monitoring, multilingual analysis, and searchable archives. It provides detected language, ordered timestamps, video metadata, and optional translation into 133 languages. Transcript pricing starts at $0.3159.",
        "version": "1.0",
        "x-build-id": "hoXEZEAkCfH9m3zF7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/agentx~rutube-transcript/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-agentx-rutube-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/agentx~rutube-transcript/runs": {
            "post": {
                "operationId": "runs-sync-agentx-rutube-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/agentx~rutube-transcript/run-sync": {
            "post": {
                "operationId": "run-sync-agentx-rutube-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": [
                    "video_url"
                ],
                "properties": {
                    "video_url": {
                        "title": "🎥 Video URL",
                        "type": "string",
                        "description": "Public RUTUBE video or Short URL to download and transcribe"
                    },
                    "translate": {
                        "title": "🌍 Translate",
                        "enum": [
                            "afrikaans",
                            "albanian",
                            "amharic",
                            "arabic",
                            "armenian",
                            "assamese",
                            "aymara",
                            "azerbaijani",
                            "bambara",
                            "basque",
                            "belarusian",
                            "bengali",
                            "bhojpuri",
                            "bosnian",
                            "bulgarian",
                            "catalan",
                            "cebuano",
                            "chichewa",
                            "chinese (simplified)",
                            "chinese (traditional)",
                            "corsican",
                            "croatian",
                            "czech",
                            "danish",
                            "dhivehi",
                            "dogri",
                            "dutch",
                            "english",
                            "esperanto",
                            "estonian",
                            "ewe",
                            "filipino",
                            "finnish",
                            "french",
                            "frisian",
                            "galician",
                            "georgian",
                            "german",
                            "greek",
                            "guarani",
                            "gujarati",
                            "haitian creole",
                            "hausa",
                            "hawaiian",
                            "hebrew",
                            "hindi",
                            "hmong",
                            "hungarian",
                            "icelandic",
                            "igbo",
                            "ilocano",
                            "indonesian",
                            "irish",
                            "italian",
                            "japanese",
                            "javanese",
                            "kannada",
                            "kazakh",
                            "khmer",
                            "kinyarwanda",
                            "konkani",
                            "korean",
                            "krio",
                            "kurdish (kurmanji)",
                            "kurdish (sorani)",
                            "kyrgyz",
                            "lao",
                            "latin",
                            "latvian",
                            "lingala",
                            "lithuanian",
                            "luganda",
                            "luxembourgish",
                            "macedonian",
                            "maithili",
                            "malagasy",
                            "malay",
                            "malayalam",
                            "maltese",
                            "maori",
                            "marathi",
                            "meiteilon (manipuri)",
                            "mizo",
                            "mongolian",
                            "myanmar",
                            "nepali",
                            "norwegian",
                            "odia (oriya)",
                            "oromo",
                            "pashto",
                            "persian",
                            "polish",
                            "portuguese",
                            "punjabi",
                            "quechua",
                            "romanian",
                            "russian",
                            "samoan",
                            "sanskrit",
                            "scots gaelic",
                            "sepedi",
                            "serbian",
                            "sesotho",
                            "shona",
                            "sindhi",
                            "sinhala",
                            "slovak",
                            "slovenian",
                            "somali",
                            "spanish",
                            "sundanese",
                            "swahili",
                            "swedish",
                            "tajik",
                            "tamil",
                            "tatar",
                            "telugu",
                            "thai",
                            "tigrinya",
                            "tsonga",
                            "turkish",
                            "turkmen",
                            "twi",
                            "ukrainian",
                            "urdu",
                            "uyghur",
                            "uzbek",
                            "vietnamese",
                            "welsh",
                            "xhosa",
                            "yiddish",
                            "yoruba",
                            "zulu"
                        ],
                        "type": "string",
                        "description": "Select a target language to translate the transcript"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
