# Kick Video Transcript (`truefetch/kick-video-transcript`) Actor

Kick Video Transcript turns one public Kick Clip into searchable text for stream highlights, reactions, and creator monitoring. It returns detected language, ordered timestamps, clip metadata, and optional translation into 133 languages. Transcript event pricing starts at $0.378.

- **URL**: https://apify.com/truefetch/kick-video-transcript.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** Social media, Videos, Automation
- **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.

**Kick Video Transcript converts one public Kick Clip into detected-language text, timestamped segments, clip metadata, and an optional translated transcript.**

- **Input is one shareable Kick Clip address in `kick.com/{channel}?clip={clip_id}` form, not a channel, live broadcast, or full VOD.**
- **A completed Clip becomes one 22-field Dataset item pairing source context with ordered speech segments.**
- **Translation offers 133 target languages and creates a charge only when the whole translated transcript is attached.**
- **The platform precheck resolves the Clip identifier and confirms Kick media before download and speech recognition begin.**

[**Run a one-result test**](https://apify.com/truefetch/kick-video-transcript?fpr=aiagentapi) · [**View API**](https://apify.com/truefetch/kick-video-transcript/api?fpr=aiagentapi)
A smallest useful FREE-tier test uses the Clip already present in the schema. It bills one $0.42 transcript event, the default 8 GB start charge of $0.008, and variable Actor usage. A completed translation adds $0.12.

### What does Kick Video Transcript do?

Kick Video Transcript isolates the spoken part of one short Kick highlight and returns it as detected-language text plus ordered `HH:MM:SS.mmm` intervals. The same record carries whatever Clip context Kick exposes, such as its title, channel identity, duration, thumbnail, publish time, and views.

Set `translate` when reviewers need another language. Source speech always stays under `transcript`; a successful `translation` mirrors its segment order and time ranges instead of replacing it. If any segment cannot be translated after retries, the Actor leaves translation absent and does not charge that event.

This narrowly scoped Actor does not discover clips, record a live channel, process a whole VOD, identify speakers, download a media deliverable, or create SRT/VTT files. Each run is one known public Clip.

### How do I run Kick Video Transcript?

1. Open [Kick Video Transcript on Apify](https://apify.com/truefetch/kick-video-transcript?fpr=aiagentapi).
2. On Kick, open the desired Clip and copy its share link; paste that complete address into **Video URL**.
3. Choose a **Translate** language only if a second language is required.
4. Start the run. Platform confirmation happens before media preparation and transcription.
5. Inspect the one Dataset item, especially names and timestamps, before sending it downstream.

The current schema pre-fills this short public Clip example, which is reused throughout the guide:

```json
{
  "video_url": "https://kick.com/mxddy?clip=clip_01GYXVB5Y8PWAPWCWMSBCFB05X",
  "translate": "spanish"
}
````

One invocation represents one Clip job. The Clip owner or Kick can remove the source later, so a saved input is not a guarantee of future access.

### What data does Kick Video Transcript return?

After speech recognition succeeds, the Actor publishes one object to the default Dataset. The contract contains 22 keys; fields that Kick does not supply stay nullable rather than being reconstructed.

| Group | Dataset fields | Meaning |
| --- | --- | --- |
| Processing | `processor`, `processed_at` | Actor URL and UTC processing time |
| Kick Clip | `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` | Counts exposed by the current extraction path |
| Labels | `categories`, `tags` | Source-provided classifications when available |
| Speech | `transcript`, `translation` | Original timestamped transcript and optional translated version |

The abbreviated sample below illustrates the Clip-and-Spanish input. It documents shape and value types, not a promise that volatile counters or source text will remain identical.

```json
{
  "processor": "https://apify.com/truefetch/kick-video-transcript?fpr=aiagentapi",
  "processed_at": "2026-07-21T13:00:03+00:00",
  "platform": "KickClip",
  "title": "Maddy detains Abd D:",
  "description": null,
  "author": "AbdCreates",
  "author_id": "mxddy",
  "duration": 35,
  "view_count": 971,
  "transcript": {
    "language": "English",
    "text": "Oh, that works too. Alright, let's see what's better.",
    "segments": [
      {
        "start": "00:00:00.000",
        "end": "00:00:10.880",
        "text": "Oh, that works too. Alright, let's see what's better."
      }
    ]
  },
  "translation": {
    "language": "Spanish",
    "text": "Eso también funciona. Bien, veamos qué es mejor.",
    "segments": [
      {
        "start": "00:00:00.000",
        "end": "00:00:10.880",
        "text": "Eso también funciona. Bien, veamos qué es mejor."
      }
    ]
  }
}
```

The Dataset does not include a `status` field, source video file, SRT or VTT file, summary, confidence score, speaker identity, private account data, or word-level timeline.

### What inputs can I configure?

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

`video_url` must resolve to playable public Clip media through the Kick extractor. Query-string Clip IDs belong with their channel path; stripping the query can turn the input into an unsupported channel page. Cookies, credentials, uploads, channel names, date ranges, and URL arrays are not accepted.

Targets are lowercase enum values, including `spanish`, `french`, `japanese`, `arabic`, `chinese (simplified)`, and `chinese (traditional)`. Omitting the selector avoids translation work and its event charge.

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

This Actor recognizes the public `kick.com/{channel}?clip={clip_id}` family. Kick's [official Clips guide](https://help.kick.com/en/articles/7120566-how-to-create-clips-on-kick) describes Clips as 10-to-180-second extracts from a livestream or VOD and explains how viewers copy or download the published Clip. The query parameter selects the item; the bare channel address does not.

Only process material you are entitled to use. Kick's [Terms of Service](https://kick.com/terms-of-service) retain rights in platform and user content and require users to respect intellectual-property and other third-party rights. Public playback alone does not authorize every redistribution, commercial use, or automated workflow.

Removed, expired, access-limited, or unpublished Clips can fail even when the URL syntax is correct. Channel homepages, live players, VOD pages, dashboards, and sources without an exposed audio track remain outside the supported surface.

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

### Why use Kick Video Transcript?

| Clip-focused capability | Practical benefit |
| --- | --- |
| Extractor-backed Kick confirmation | Stop an unrelated or malformed URL before paying the full transcription cost. |
| Text and time ranges together | Jump back to a shouted phrase, reaction, or commentary moment in the highlight. |
| Clip context in the same object | Preserve channel, title, thumbnail, duration, and available view information beside the words. |
| Segment-aligned translation | Compare source speech and a target language on matching time windows. |
| Stable 22-key result | Feed short-form review, moderation, indexing, or archive systems without platform-specific reshaping. |

Kick may change public data, and speech recognition may mishear names, overlapping voices, music, or specialized vocabulary. Review quotations, captions, translations, and high-stakes conclusions.

### Who is Kick Video Transcript for?

Developers, streamers, esports editors, moderation teams, journalists, and researchers can use it when they already know the exact Clip. Common jobs include indexing a highlight, reviewing quoted commentary, preparing a localized excerpt, and attaching speech text to an internal Clip record.

It is the wrong product for discovering a creator's library, monitoring a live channel, reading chat, recognizing overlays, producing courtroom-grade text, or fetching non-Kick media.

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

The callable Actor ID is `truefetch/kick-video-transcript`. Although Kick Clips are short by design, queueing, model loading, or translation can still make a synchronous client wait. For resilient automation, start a run asynchronously and read its Dataset after completion; Apify's synchronous Dataset endpoint can return HTTP 408 after 300 seconds while the run itself continues.

```bash
curl -L "https://api.apify.com/v2/actors/truefetch~kick-video-transcript/run-sync-get-dataset-items" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "video_url": "https://kick.com/mxddy?clip=clip_01GYXVB5Y8PWAPWCWMSBCFB05X",
    "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/kick-video-transcript",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

Call `truefetch/kick-video-transcript` with the same URL and `spanish`. See the [Apify MCP guide](https://docs.apify.com/integrations/mcp?fpr=aiagentapi) and [Actor API page](https://apify.com/truefetch/kick-video-transcript/api?fpr=aiagentapi).

### How much does Kick Video Transcript cost?

The local pricing metadata defines four events: Actor start, variable usage, transcript, and optional translation. The table mirrors that current file; the [published pricing page](https://apify.com/truefetch/kick-video-transcript/pricing?fpr=aiagentapi) should be rechecked after deployment because online Store data can lag local edits.

| 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-event example: 8 GB creates eight start events, so `$0.001 × 8 + $0.42000 = $0.428` before usage. Adding a completed Spanish translation makes the fixed subtotal `$0.548`. Set `maxTotalChargeUsd` when a scheduler or API caller needs a hard ceiling.

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

| Option | Best fit | Trade-off |
| --- | --- | --- |
| Kick Video Transcript | A known Clip that needs speech, timing, and Clip context | Accepts one Clip only; does not return video or identify speakers |
| Kick channel/VOD collector | Discovering broadcasts, schedules, or a creator's larger archive | Transcription of a specific short highlight is not its central contract |
| Universal video-to-text | Uploads or a queue mixing Kick with other sources | Wider input surface with less Clip-specific guidance |
| Human review | Publication-critical quotes, speaker attribution, or nuanced slang | Highest judgment, but slower and harder to automate |

Choose this Actor when words and time ranges are the deliverable for one Kick highlight. Use [Video To Text](https://apify.com/truefetch/video-to-text?fpr=aiagentapi) for uploads or mixed sources, or [Best Video Downloader](https://apify.com/truefetch/best-video-downloader?fpr=aiagentapi) when the actual MP4 is required.

### What are the limits and troubleshooting steps?

| Symptom or limit | What it means | Next step |
| --- | --- | --- |
| Platform is rejected | The address resolves as a channel, VOD, or another extractor instead of Kick Clip | Copy the full share link including `?clip=` |
| Clip information cannot be read | The item was deleted, restricted, unpublished, or is temporarily unavailable | Open it without authentication and retry only if it still plays |
| No speech is detected | The highlight is silent, music-only, overwhelmed by game audio, or unintelligible | Select a dialogue-heavy Clip and verify its audio locally |
| A context field is null or `duration` is `0` | The current Kick extraction result omitted that value | Preserve the documented empty form; do not infer a counter or identity |
| Translation is missing | At least one segment failed all translation attempts | Use the original transcript; no translation event is charged |
| Sync call returns HTTP 408 | The HTTP response window ended before the Actor run | Poll an asynchronous run and fetch its Dataset when terminal |

Segment boundaries are ordered but are not word-level timestamps. Never post a private token or confidential media in an issue. Share the run ID, the smallest public reproduction URL, the expected behavior, and the visible error.

### Frequently asked questions

#### Can it process a channel page, live stream, or full VOD?

No. The supported contract is one specific public Kick Clip URL per run.

#### Can it crawl a channel's Clip library?

No. The input contains neither channel discovery nor a URL array. Supply a Clip already found elsewhere.

#### Does it use Kick's existing Clip transcript?

No. Speech recognition runs on the exposed audio; the output is the Actor's normalized object, not a native Kick caption export or subtitle file.

#### What happens when a Kick Clip contains no speech?

The run can report that no speech was detected. Game sound, music, and crowd noise are not guaranteed to contain recognizable dialogue.

#### Why are description, thumbnail, or creator ID empty?

Kick's extraction response controls those fields. The Dataset deliberately keeps the missing form rather than guessing from a channel page.

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

No. Charging occurs only after the complete translated segment list has been attached to the result.

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

Use them to navigate a Clip or align downstream review, not as final captions. They are segment ranges, not word-level timing or a delivered subtitle asset.

#### Can I schedule the same Kick Clip URL repeatedly?

Yes, but each successful execution is billed independently and the Clip may disappear between schedules. Avoid polling a static highlight when no downstream change is expected.

### Related TrueFetch Actors

- [Video To Text](https://apify.com/truefetch/video-to-text?fpr=aiagentapi) accepts uploads and mixed-platform sources that do not belong in a Kick-only input.
- [Instagram Video Transcript](https://apify.com/truefetch/instagram-video-transcript?fpr=aiagentapi) handles short public Instagram posts with the related timestamped-result shape.
- [Best Video Downloader](https://apify.com/truefetch/best-video-downloader?fpr=aiagentapi) returns media when transcript text is not the desired artifact.

### Support and last updated

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

The local input, Dataset, output, and pricing metadata plus the cited Kick documentation were reviewed on **July 21, 2026**. Clip availability and published Store information remain volatile.

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

# Actor input Schema

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

Paste one public Kick Clip 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://kick.com/mxddy?clip=clip_01GYXVB5Y8PWAPWCWMSBCFB05X"
}
```

# 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://kick.com/mxddy?clip=clip_01GYXVB5Y8PWAPWCWMSBCFB05X"
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/kick-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://kick.com/mxddy?clip=clip_01GYXVB5Y8PWAPWCWMSBCFB05X" }

# Run the Actor and wait for it to finish
run = client.actor("truefetch/kick-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://kick.com/mxddy?clip=clip_01GYXVB5Y8PWAPWCWMSBCFB05X"
}' |
apify call truefetch/kick-video-transcript --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Kick Video Transcript",
        "description": "Kick Video Transcript turns one public Kick Clip into searchable text for stream highlights, reactions, and creator monitoring. It returns detected language, ordered timestamps, clip metadata, and optional translation into 133 languages. Transcript event pricing starts at $0.378.",
        "version": "1.0",
        "x-build-id": "eHZrqY4Toyg3H9vYa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/truefetch~kick-video-transcript/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-truefetch-kick-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~kick-video-transcript/runs": {
            "post": {
                "operationId": "runs-sync-truefetch-kick-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~kick-video-transcript/run-sync": {
            "post": {
                "operationId": "run-sync-truefetch-kick-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 Kick Clip 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
