# Reddit Video Transcript (`truefetch/reddit-video-transcript`) Actor

Reddit Video Transcript captures speech from one public Reddit video post so discussions, commentary, and user-generated clips can be reviewed in text. It provides language detection, timed segments, post metadata, and optional translation into 133 languages. Starting transcript rate: $0.378.

- **URL**: https://apify.com/truefetch/reddit-video-transcript.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** Social media, Videos, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.378 / 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

> **Affiliate disclosure:** Apify links on this page may include referral parameters. If you sign up through one of these links, TrueFetch may earn a commission from Apify at no extra cost to you. Pricing, features, and Actor access are unaffected.

**Reddit Video Transcript converts one public Reddit video post into detected-language text, timestamped segments, post metadata, and an optional translated transcript.**

- **The required input is one public Reddit video-post URL; profiles, private posts, non-video posts, uploads, and cross-platform links are outside this Actor's scope.**
- **A successful submission yields one 22-field record linking the conversation in the audio to its subreddit post, timing, author, and available votes or comments.**
- **Users may choose among 133 translation targets; the additional event is charged only for an end-to-end translated segment list.**
- **Before media download, the platform precheck resolves the submitted post and confirms Reddit as the extractor.**

[**Run a one-result test**](https://apify.com/truefetch/reddit-video-transcript?fpr=aiagentapi) · [**View API**](https://apify.com/truefetch/reddit-video-transcript/api?fpr=aiagentapi)
For a minimal FREE-tier run, keep the Reddit example filled into the form. The transcript event is $0.42 and starting the default 8 GB Actor is $0.008; compute use varies. Spanish adds $0.12 after complete translation.

### What does Reddit Video Transcript do?

Reddit Video Transcript turns speech from one public Reddit video post into detected-language text and ordered `HH:MM:SS.mmm` segments. When exposed, post metadata can include title, description, creator, duration, thumbnail, publishing time, audio attribution, and engagement counts.

`translate` requests a separate language version of the Reddit clip. Recognition stays intact in `transcript`, and the translated phrases preserve its sequence and time ranges. Failed partial work is omitted.

It does not discover subreddit posts, enter private communities, read messages or comments, follow users, label speakers, monitor live feeds, download the MP4, or emit subtitle files. One public post URL is processed per invocation.

### How do I run Reddit Video Transcript?

1. Open [Reddit Video Transcript on Apify](https://apify.com/truefetch/reddit-video-transcript?fpr=aiagentapi).
2. Copy the canonical URL of one public Reddit video post and paste it into **Video URL**.
3. Pick a **Translate** target when another language is required; otherwise keep the selector empty.
4. Click **Start** and wait for media preparation and speech recognition to finish.
5. Inspect the Dataset result for community slang, nullable counters, and timestamp quality before export.

Start with a Reddit video post containing clear dialogue. The current input schema pre-fills this public URL:

```json
{
  "video_url": "https://www.reddit.com/r/Unexpected/comments/1cl9h0u/the_insurance_claim_will_be_interesting/",
  "translate": "spanish"
}
````

That input remains the full job scope and produces at most one Dataset item. Moderation, deletion, or community privacy changes can make the same permalink unavailable later.

### What data does Reddit Video Transcript return?

The Actor writes one successful result to the default Dataset. Its 22-field contract is nullable where Reddit omits a value.

| Group | Dataset fields | Meaning |
| --- | --- | --- |
| Processing | `processor`, `processed_at` | Actor URL and UTC processing time |
| Reddit video post | `platform`, `title`, `description`, `thumbnail`, `published_at` | Source identity, text, image, and publishing time |
| Creator | `author`, `author_id`, `author_url` | Creator details exposed for the media |
| Media | `duration`, `audio_title`, `audio_artist` | Source-reported length and audio attribution |
| Engagement | `view_count`, `like_count`, `shares_count`, `dislike_count`, `comment_count` | Reddit counters exposed for the post; unsupported or hidden values remain nullable |
| Labels | `categories`, `tags` | Source-provided classifications when available |
| Speech | `transcript`, `translation` | Original timestamped transcript and optional translated version |

This abbreviated response uses the same Reddit video-and-Spanish scenario. Values omitted by Reddit remain null, zero, or empty; the Actor does not invent them.

```json
{
  "processor": "https://apify.com/truefetch/reddit-video-transcript?fpr=aiagentapi",
  "processed_at": "2026-07-21T12:48:04+00:00",
  "platform": "Reddit",
  "title": "The insurance claim will be interesting",
  "description": null,
  "author": "darrenpauli",
  "duration": 53,
  "like_count": 23088,
  "dislike_count": 0,
  "comment_count": 505,
  "transcript": {
    "language": "English",
    "text": "What are we up to today? We are here today on set with Channel 7.",
    "segments": [
      {
        "start": "00:00:00.000",
        "end": "00:00:11.589",
        "text": "What are we up to today? We are here today on set with Channel 7."
      }
    ]
  },
  "translation": {
    "language": "Spanish",
    "text": "¿Qué vamos a hacer hoy? Hoy estamos aquí en el set con Channel 7.",
    "segments": [
      {
        "start": "00:00:00.000",
        "end": "00:00:11.589",
        "text": "¿Qué vamos a hacer hoy? Hoy estamos aquí en el set con Channel 7."
      }
    ]
  }
}
```

This 22-field record does not promise the Reddit video file, private community data, a summary, confidence scores, speaker names, SRT/VTT output, OCR text, or individual-word timing.

### What inputs can I configure?

| Input | Type | Required | Behavior |
| --- | --- | --- | --- |
| `video_url` | string | Yes | One public Reddit video-post URL. |
| `translate` | string enum | No | One of 133 target-language values. Empty means no translation. |

`video_url` must be a public Reddit permalink whose post contains downloadable video. The input contract intentionally omits account cookies, credentials, file uploads, subreddit search, usernames, date windows, and URL arrays.

Target values use lowercase names, including `spanish`, `french`, `arabic`, `japanese`, `chinese (simplified)`, and `chinese (traditional)`. The optional object sits beside the source transcript rather than replacing it.

### What platforms and markets does Reddit Video Transcript cover?

This Reddit-only Actor is tested with a canonical `/r/{community}/comments/{id}/{slug}/` URL containing native video. Reddit's help documents the [Images & Video post type](https://support.reddithelp.com/hc/en-us/articles/360060422572-How-do-I-post-and-comment-on-Reddit) and the Share control for linking a specific post.

Private communities, removed or deleted posts, comments, subreddit pages, user profiles, text-only posts, external pages without downloadable video, and restricted links are not promised.

Speech language is detected from audio. Review generated text and translation for names, slang, accents, community terminology, and code-switching.

Process only content you are authorized to use and review the current [Reddit User Agreement](https://redditinc.com/policies/user-agreement) for the intended workflow.

### Why use Reddit Video Transcript?

| Verified capability | Practical benefit |
| --- | --- |
| Reddit-specific platform validation | Reject unrelated platform links before transcription begins. |
| Spoken Reddit video converted to text and intervals | Find the claim, joke, reaction, or explanation and return to its approximate place in the clip. |
| Permalink context carried with the speech | Keep subreddit-facing title, author, thumbnail, date, duration, and exposed counters attached. |
| A translated reading with original timing | Compare community content across languages without discarding the detected wording. |
| One post-shaped object | Send a known Reddit video into moderation research, editorial analysis, or an AI pipeline without batch semantics. |

Reddit can remove a post or alter what anonymous visitors see. Audio recognition can also confuse usernames, memes, overlapping speakers, music, or niche vocabulary, so verify important quotations against the clip.

### Who is Reddit Video Transcript for?

The Actor serves developers, moderators, social teams, journalists, researchers, and AI builders with a specific public video post. Typical uses include searching dialogue, comparing speech with titles, drafting translations, and supplying timed text downstream.

Use another Actor to search Reddit, enumerate a community, collect discussion threads, access restricted content, save media, read text inside frames, prepare legal copy, watch live content, or process another platform.

### How can I use Reddit Video Transcript through the API or MCP?

The callable name is `truefetch/reddit-video-transcript`. Short clips can use the synchronous Dataset route; resilient automation should create a run, poll its state, and fetch the item later. Apify warns that the client response may time out before the underlying run stops.

```bash
curl -L "https://api.apify.com/v2/actors/truefetch~reddit-video-transcript/run-sync-get-dataset-items" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "video_url": "https://www.reddit.com/r/Unexpected/comments/1cl9h0u/the_insurance_claim_will_be_interesting/",
    "translate": "spanish"
  }'
```

Apify's hosted MCP server can expose only this Actor to a compatible client:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=truefetch/reddit-video-transcript",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

Expose the tool, then call `truefetch/reddit-video-transcript` with the permalink and `spanish`. Use the [Apify MCP guide](https://docs.apify.com/integrations/mcp?fpr=aiagentapi) to configure authorization and the [Actor API page](https://apify.com/truefetch/reddit-video-transcript/api?fpr=aiagentapi) for language-specific clients.

### How much does Reddit Video Transcript cost?

The bill contains start and usage events plus successful transcript and optional translation events. Local metadata prices appear below; verify the [live pricing page](https://apify.com/truefetch/reddit-video-transcript/pricing?fpr=aiagentapi) again before scaling scheduled subreddit workflows.

| Billed event | FREE | BRONZE | SILVER | GOLD | PLATINUM | DIAMOND | Billing unit |
| --- | ---: | ---: | ---: | ---: | ---: | ---: | --- |
| Actor start | $0.001 | $0.001 | $0.001 | $0.001 | $0.001 | $0.001 | One event per allocated GB, minimum one |
| Actor usage | $0.00001 | $0.00001 | $0.00001 | $0.00001 | $0.00001 | $0.00001 | Runtime, proxy, and storage usage unit |
| Transcript | $0.42000 | $0.40600 | $0.39200 | $0.37800 | $0.37800 | $0.37800 | One successful timestamped transcript |
| Translation | $0.12000 | $0.11600 | $0.11200 | $0.10800 | $0.10800 | $0.10800 | One complete translated transcript when requested |

FREE-tier fixed arithmetic is eight start units at $0.001 plus one $0.42000 transcript, totaling `$0.428` before usage. If Spanish completes, its $0.12000 event brings that subtotal to `$0.548`. Apply `maxTotalChargeUsd` when repeated Reddit jobs need a ceiling.

### How does Reddit Video Transcript compare with alternatives?

| Option | Best fit | Trade-off |
| --- | --- | --- |
| Reddit Video Transcript | Extracting dialogue from one selected public video permalink | It does not search communities or return the media asset |
| General Reddit scraper | Finding posts, subreddits, authors, and comment threads | Audio-to-text output may be unavailable |
| Universal transcription Actor | Mixing uploaded files with links from different sites | The form is not tailored to Reddit permalinks |
| Human transcription | Approving consequential quotes or interpreting difficult audio | Requires manual timing and longer turnaround |

Choose this Actor after locating the exact Reddit video whose audio matters. [Video To Text](https://apify.com/truefetch/video-to-text?fpr=aiagentapi) handles uploads and other sites, while [Best Video Downloader](https://apify.com/truefetch/best-video-downloader?fpr=aiagentapi) is appropriate when words and time ranges are not the required artifact.

### What are the limits and troubleshooting steps?

| Symptom or limit | What it means | Next step |
| --- | --- | --- |
| The Actor rejects the platform | The URL does not resolve as a supported Reddit video post | Copy the canonical `/r/.../comments/.../` post URL |
| Video information cannot be retrieved | The post is private, expired, deleted, restricted, or temporarily unavailable | Confirm the URL opens publicly and retry with the canonical link |
| The media has no usable speech | The post is silent, music-only, missing audio, or too noisy to recognize | Try a public Reddit clip with clearly audible words |
| Metadata is empty or duration is `0` | Reddit omitted that author, audio, timing, date, or engagement value | Preserve the schema's nullable representation instead of estimating it |
| Translation is absent | At least one source segment could not be translated | Keep the recognized transcript and retry later; partial translation is not billed |
| A synchronous API call returns HTTP 408 | The HTTP wait ended while the Actor was still processing | Switch to an asynchronous run and fetch the Dataset on completion |

Timing is phrase-level and ordered, not a per-word alignment. A support request should include the run ID, a minimal public Reddit permalink, expected behavior, and visible error—never an API token or private post.

### Frequently asked questions

#### Can it process a private community or removed post?

No. The input has no credential or cookie field. Use one publicly accessible Reddit video-post URL.

#### Can it crawl a creator profile or Reddit video feed?

No. The production contract is one specific Reddit video post per run, not discovery or batch crawling.

#### Does it use existing Reddit captions?

Recognition operates on the audio stream rather than Reddit captions. The result is JSON text and segments, not OCR from the video frame or a subtitle download.

#### What happens when a Reddit video contains only music?

A silent or music-only Reddit video can legitimately produce no detected speech; choose audible dialogue for a nonempty result.

#### Why are likes, comments, audio attribution, or creator ID empty?

Those values depend on what Reddit exposes for that exact post. The Dataset keeps them nullable instead of inventing a value.

#### Is translation billed if one segment fails?

No. Charging waits until the target-language object contains every translated segment.

#### Can I use segment timestamps as finished subtitles?

Treat them as navigation ranges or a subtitle draft. Exact word cues and final caption formatting require another review step.

#### Can I schedule the same Reddit video URL repeatedly?

Yes. Save the permalink as scheduled input, with the understanding that each run is billed separately and Reddit may later remove or restrict the post.

### Related TrueFetch Actors

- [Reddit Community Post](https://apify.com/truefetch/reddit-community-post?fpr=aiagentapi) focuses on post discovery and community metadata when spoken audio is not the only goal.
- [Reddit Post Search](https://apify.com/truefetch/reddit-post-search?fpr=aiagentapi) finds relevant Reddit posts before a specific video URL is selected for transcription.
- [Video To Text](https://apify.com/truefetch/video-to-text?fpr=aiagentapi) accepts files and non-Reddit media links through a broader transcription contract.

### Support and last updated

- [Actor page and documentation](https://apify.com/truefetch/reddit-video-transcript?fpr=aiagentapi)
- [API reference and generated clients](https://apify.com/truefetch/reddit-video-transcript/api?fpr=aiagentapi)
- [Issues](https://apify.com/truefetch/reddit-video-transcript/issues?fpr=aiagentapi)
- [TrueFetch community](https://t.me/TrueFetch)
- [Direct support](https://t.me/AiAgentApi)

Local schema, extractor behavior, metadata pricing, and official documentation links were checked on **July 21, 2026**. Reddit controls future post availability and exposed fields.

[**Run a one-result test**](https://apify.com/truefetch/reddit-video-transcript?fpr=aiagentapi) · [**View API**](https://apify.com/truefetch/reddit-video-transcript/api?fpr=aiagentapi)

# Actor input Schema

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

Paste one public Reddit video-post URL to transcribe

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

Optional target language for the translated transcript. Leave empty to return only the original transcript

## Actor input object example

```json
{
  "video_url": "https://www.reddit.com/r/Unexpected/comments/1cl9h0u/the_insurance_claim_will_be_interesting/"
}
```

# 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://www.reddit.com/r/Unexpected/comments/1cl9h0u/the_insurance_claim_will_be_interesting/"
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/reddit-video-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://www.reddit.com/r/Unexpected/comments/1cl9h0u/the_insurance_claim_will_be_interesting/" }

# Run the Actor and wait for it to finish
run = client.actor("truefetch/reddit-video-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://www.reddit.com/r/Unexpected/comments/1cl9h0u/the_insurance_claim_will_be_interesting/"
}' |
apify call truefetch/reddit-video-transcript --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Video Transcript",
        "description": "Reddit Video Transcript captures speech from one public Reddit video post so discussions, commentary, and user-generated clips can be reviewed in text. It provides language detection, timed segments, post metadata, and optional translation into 133 languages. Starting transcript rate: $0.378.",
        "version": "1.0",
        "x-build-id": "Y5GpjAO2KPig5QyL0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/truefetch~reddit-video-transcript/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-truefetch-reddit-video-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/truefetch~reddit-video-transcript/runs": {
            "post": {
                "operationId": "runs-sync-truefetch-reddit-video-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/truefetch~reddit-video-transcript/run-sync": {
            "post": {
                "operationId": "run-sync-truefetch-reddit-video-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": "Paste one public Reddit video-post URL to 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": "Optional target language for the translated transcript. Leave empty to return only the original 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
