# 𝕏 (twitter) Transcript (`agentx/x-twitter-transcript`) Actor

X Twitter Transcript turns one public X video post into structured text for news monitoring, quote capture, and social research. Output includes language detection, ordered timestamps, post metadata, and optional translation into 133 languages. The base transcript rate is $0.2592.

- **URL**: https://apify.com/agentx/x-twitter-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.2592 / 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

## X Twitter Transcript - Timestamped X Speech-to-Text API

**X Twitter Transcript converts one public X post containing video into detected-language text, ordered timestamped segments, source metadata, and an optional translated transcript.** It processes audible speech from the media; it does not promise to return X caption tracks or existing subtitle files.

- One public X Post URL containing video is accepted per run.
- Platform precheck confirms the resolved extractor before the formal download begins.
- Every successful result follows the 22-field Dataset contract used by the Actor.
- Requested translation is either complete and segment-aligned or absent; partial translation is not published as success.

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

Start with a short public video that contains clear speech. Confirm the output before scheduling large, long, translated, or business-critical workloads.

---

### Why Choose This API

#### A narrow contract for one known X video post

Use this Actor when you already know the public X video that you want to transcribe. The input is intentionally small: one `video_url` and one optional `translate` target. The Actor validates that the resolved media belongs to the X extraction path before the formal download begins.

The result combines source context and spoken content in one record:

| Capability | What is returned |
| --- | --- |
| Speech recognition | Detected language, combined transcript text, and ordered `start` / `end` / `text` segments |
| Video context | Title, description, author, account identifiers, duration, publication time, thumbnail, categories, and tags when exposed |
| Engagement context | Views, likes, dislikes, shares, and comments when the source exposes those values |
| Optional translation | A translated text and segment list that preserves the original segment timestamps |

This is not an account-feed crawler, multi-post processor, live recorder, native-caption service, speaker-diarization system, summary generator, or video downloader. A successful run creates one Dataset item. Missing source metadata remains null, zero, or empty according to the Dataset schema; the Actor does not invent values.

The transcript comes from speech recognition over the downloaded media. Names, accents, overlapping speakers, music, poor audio, and specialist terminology can reduce accuracy. Review quotations and high-stakes uses against the source video.

---

### Quick Start Guide

#### Run in Apify Console

1. Open [X Twitter Transcript on Apify](https://apify.com/agentx/x-twitter-transcript?fpr=aiagentapi).
2. Paste one public X Post URL in **Video URL**.
3. Leave **Translate** empty for the source-language transcript, or choose one target language.
4. Click **Start** and open the default Dataset after the run succeeds.

The schema example is a real public input:

```json
{
  "video_url": "https://x.com/captainamerica/status/719944021058060289",
  "translate": "spanish"
}
````

The same URL is used in this guide's API and output examples so that the scenario remains testable. Public videos can later be removed, restricted, made private, age-gated, or changed by their owners. Replace an unavailable example with another public X video containing audible speech.

#### What success means

A completed production run must download a media file with an audio track, detect speech, publish one Dataset item, and charge the `transcript` event. An HTTP response, title lookup, or metadata-only extraction is not enough to prove transcript success.

***

### Input Parameters

#### Input configuration

| Input | Type | Required | Description |
| --- | --- | --- | --- |
| `video_url` | string | Yes | One public X video URL to download and transcribe. |
| `translate` | string | No | One target language from the schema's 133 selectable values. Leave empty to skip translation. |

Only one video is processed per run. Profile URLs, search pages, feed URLs, Posts without video, private media, uploads, cookies, credentials, and lists of URLs are outside this Actor's public input contract. The downloader is configured not to process playlists.

X documents how to copy a permanent Post URL in its [official URL guide](https://help.x.com/en/using-x/post-and-moment-url). The schema accepts a public Post URL when the source makes video media accessible. A URL may still fail because of removal, access restrictions, regional availability, temporary platform changes, or the absence of an audio track.

Translation is attempted only after the source transcript succeeds. If any segment cannot be translated after the available attempts, the Actor leaves `translation` empty and does not charge the translation event. It never presents the source text as if it were a successful translation.

***

### Output Data Schema

#### One 22-field Dataset item

The default Dataset contains one record for a successful video. The fields are:

| Group | Fields | Notes |
| --- | --- | --- |
| Processing | `processor`, `processed_at` | Actor URL and processing timestamp |
| Identity | `platform`, `title`, `description`, `thumbnail`, `published_at` | Source-provided video identity |
| Author | `author`, `author_id`, `author_url` | Channel or uploader context when available |
| Media | `duration`, `audio_title`, `audio_artist` | Source-reported values; duration can be 0 when metadata is absent |
| Engagement | `view_count`, `like_count`, `shares_count`, `dislike_count`, `comment_count` | Nullable source metrics |
| Labels | `categories`, `tags` | Source classifications when exposed |
| Speech | `transcript`, `translation` | Timestamped source transcript and optional translated version |

Abbreviated output from the production-checked scenario:

```json
{
  "processor": "https://apify.com/agentx/x-twitter-transcript?fpr=aiagentapi",
  "processed_at": "2026-07-21T13:30:00+00:00",
  "platform": "Twitter",
  "title": "Captain America - Are you sure you made the right choice?",
  "author": "Captain America",
  "author_id": null,
  "author_url": "https://twitter.com/CaptainAmerica",
  "duration": 3,
    "like_count": 2,
  "categories": [],
  "tags": [],
  "transcript": {
    "language": "English",
    "text": "Jose, Team Cap, welcome to the team!",
    "segments": [
      {
        "start": "00:00:00.350",
        "end": "00:00:03.178",
        "text": "Jose, Team Cap, welcome to the team!"
      }
    ]
  },
  "translation": {
    "language": "Spanish",
    "text": "¡Jose, equipo Cap, bienvenido al equipo!",
    "segments": [
      {
        "start": "00:00:00.350",
        "end": "00:00:03.178",
        "text": "¡Jose, equipo Cap, bienvenido al equipo!"
      }
    ]
  }
}
```

Counts and source text are snapshots, not permanent facts. The Dataset does not add a source media file, caption track, SRT/VTT file, speaker labels, word-level timing, confidence score, summary, or legal verification.

***

### Integration Examples

#### REST API

The synchronous endpoint returns Dataset items directly:

```bash
curl -L "https://api.apify.com/v2/actors/agentx~x-twitter-transcript/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "video_url": "https://x.com/captainamerica/status/719944021058060289",
    "translate": "spanish"
  }'
```

For long videos or workflows that must not hold one HTTP connection open, start an asynchronous run and retrieve its Dataset afterward. Apify documents that synchronous Dataset responses can time out after 300 seconds while the Actor run continues.

#### Python client

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("agentx/x-twitter-transcript").call(
    run_input={
        "video_url": "https://x.com/captainamerica/status/719944021058060289",
        "translate": "spanish",
    }
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["transcript"]["text"])
```

#### MCP for AI clients

Configure the Apify MCP server with the Actor-scoped tool URL:

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

Call `agentx/x-twitter-transcript` with the same input fields. See the [Apify MCP documentation](https://docs.apify.com/integrations/mcp?fpr=aiagentapi) and the [generated Actor API page](https://apify.com/agentx/x-twitter-transcript/api?fpr=aiagentapi).

***

### Pricing & Cost Calculator

X Twitter Transcript uses pay-per-event pricing. The repository metadata is authoritative for the build being audited; the public Store's “from” price reflects the lowest transcript tier and may lag a deployment.

| Event | Current price |
| --- | ---: |
| Actor start | $0.001 per charged start event; the 8192 MB run configuration charges eight start events |
| Actor usage | $0.00001 per usage unit; total depends on runtime resources |
| Transcript - Free | $0.28800 |
| Transcript - Bronze | $0.27840 |
| Transcript - Silver | $0.26880 |
| Transcript - Gold, Platinum, Diamond | $0.25920 |
| Translation - Free | $0.10000 |
| Translation - Bronze | $0.09667 |
| Translation - Silver | $0.09333 |
| Translation - Gold, Platinum, Diamond | $0.09000 |

A Free-tier run with one transcript, no translation, and the fixed 8192 MB configuration starts at `$0.288 + (8 × $0.001) = $0.296`, plus usage events. With translation, it starts at `$0.288 + $0.10 + $0.008 = $0.396`, plus usage events. Failed work may still consume start and usage events; the transcript event is tied to successful Dataset publication.

Check the [live pricing page](https://apify.com/agentx/x-twitter-transcript/pricing?fpr=aiagentapi) before scheduling a large workload. Estimate with representative media because speech density, duration, network behavior, and translation length affect runtime.

***

### Use Cases & Applications

#### Search and retrieval over one video

Store `transcript.text` for whole-video search or index the timestamped `segments` as smaller retrieval units. A downstream application can display the matching text and its approximate video interval. The Actor does not create embeddings or answer questions; those are downstream responsibilities.

#### Editorial and research review

Researchers, journalists, analysts, and content teams can inspect spoken claims alongside source title, author, publication time, and engagement fields. Metadata availability varies, and ASR can be wrong, so cite the original video and manually verify consequential quotations.

#### Accessibility drafts and content repurposing

The segment list can seed caption editing, show notes, summaries, articles, or social copy. It is a draft transcript, not a certified accessibility artifact. Human review remains appropriate before publication.

#### Multilingual review

Request one translation target when a team needs to inspect the spoken content in another language. The translation preserves segment time ranges, which helps compare source and translated text. For multiple target languages, run the Actor separately for each target and account for each translation event.

#### Automation boundaries

This Actor is suited to a known video URL. Use an X discovery workflow to identify video Posts first, then invoke one transcription run per chosen URL. Do not treat a successful transcription as permission to republish the underlying video or transcript.

***

### FAQ

#### Does the Actor return the X Post text or on-screen text?

No. The verified path downloads the Post's video audio and generates speech text. It does not return the Post body as the transcript and does not perform OCR on text displayed in the video.

#### What kind of X URL is supported?

Use the permanent URL of one public Post containing downloadable video with an audio track. Protected, deleted, suspended, restricted, audio-only Space, and live content is not promised.

#### Can it process an entire X account or feed?

No. The public input accepts one video URL, and multi-post processing is disabled. Use a discovery Actor first and submit individual video URLs in separate runs.

#### What happens if the video has no speech?

The run fails without a transcript Dataset item. Silent clips, music-only media, missing audio, or speech that cannot be detected do not satisfy the successful output contract.

#### Why are some metadata fields null?

X or the extraction response did not expose them for that video. The schema intentionally permits nullable values instead of fabricating counts, dates, audio attribution, or author details.

#### Are timestamps word-accurate?

No. They are segment time ranges formatted as `HH:MM:SS.mmm`. They are useful for navigation and downstream processing but are not guaranteed word-level alignments.

#### How are long videos handled?

The Actor uses a fixed 8192 MB configuration. 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. Runtime and cost still grow with duration and speech density, so use asynchronous runs for long inputs.

#### Is translation always charged when requested?

No. Translation is charged only when the complete translated structure is produced. If any segment ultimately fails, the output keeps `translation` empty and the translation event is not charged.

***

### SEO Keywords & Search Terms

People may describe this task as converting a X video to text, generating a X transcript with timestamps, extracting spoken words from a X URL, or preparing video speech for search and RAG. Those phrases describe the same narrow workflow: one public video enters, and one structured transcript record leaves.

The Actor is not positioned as a X subtitle downloader, channel scraper, bulk transcript endpoint, audio downloader, video summarizer, or guaranteed verbatim transcription service. Keeping those boundaries explicit helps users choose the right tool and prevents misleading search claims.

For programmatic discovery, use the stable Actor name `agentx/x-twitter-transcript`. For human evaluation, inspect the Input, Output, Pricing, Reviews, and Issues tabs on the live Store page.

***

### Trust & Certifications

The strongest available evidence is the public contract: one schema-constrained Post URL, a platform extractor check, a 22-field Dataset schema, ordered timestamped segments, and a complete-or-absent translation object. These properties can be inspected before integrating and validated from each completed run.

No Store rating, user count, monthly activity, bookmark total, or one-off test result is presented as evidence of future availability or transcription accuracy. X delivery and speech recognition remain variable.

No independent accuracy certification, SLA, legal-transcript status, GDPR certification, CCPA certification, or guaranteed uptime is claimed here. Apify supplies the Actor execution and storage platform; source availability and extraction behavior remain external dependencies.

***

### Legal & Compliance

Process only content you are authorized to use. Public accessibility does not remove copyright, privacy, contractual, publicity, data-protection, or platform-policy obligations. X's current [Terms of Service](https://x.com/en/tos) prohibit crawling or scraping without prior written consent and restrict automated access to published interfaces unless X specifically allows otherwise. Use this Actor only where you have the required permission or another lawful basis that applies to your situation.

The Actor returns source metadata and generated speech text. It does not grant a license to the video, verify ownership, determine fair use, provide legal advice, or certify the accuracy of quotations. Avoid submitting private credentials or confidential URLs because they are not part of the supported input contract.

If a source owner deletes or restricts a video, future runs can fail even when an older run succeeded. Retain the source URL and processing time when provenance matters.

***

### Related Tools

#### Related AgentX Actors

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

#### Enrich with broader discovery

- [All Video Scraper](https://apify.com/agentx/all-video-scraper?fpr=aiagentapi) provides broader video metadata and media workflows.
- [All Jobs Scraper](https://apify.com/agentx/all-jobs-scraper?fpr=aiagentapi) supplies cross-platform job data for content or labor-market research.
- [All Shopping Scraper](https://apify.com/agentx/all-shopping-scraper?fpr=aiagentapi) supplies cross-market product data for commerce research.

Choose a discovery Actor when you do not yet have a specific video URL. Keep transcription runs one video at a time.

***

### Support & Community

- [Actor page and documentation](https://apify.com/agentx/x-twitter-transcript?fpr=aiagentapi)
- [API reference](https://apify.com/agentx/x-twitter-transcript/api?fpr=aiagentapi)
- [Issues](https://apify.com/agentx/x-twitter-transcript/issues?fpr=aiagentapi)
- [Telegram support](https://t.me/AiAgentApi)

When reporting a problem, include the public video URL, run ID, expected result, observed error, and whether translation was enabled. Do not post private tokens or credentials.

Schema, code behavior, pricing metadata, the example URL, and official documentation links were last checked on **July 21, 2026**. X availability, terms, and Store statistics are volatile.

[Run a one-video test](https://apify.com/agentx/x-twitter-transcript?fpr=aiagentapi) · [View pricing](https://apify.com/agentx/x-twitter-transcript/pricing?fpr=aiagentapi)

# Actor input Schema

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

Paste one public X post URL containing video to download and transcribe

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

Select an optional target language for the translated transcript

## Actor input object example

```json
{
  "video_url": "https://x.com/captainamerica/status/719944021058060289"
}
```

# 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://x.com/captainamerica/status/719944021058060289"
};

// Run the Actor and wait for it to finish
const run = await client.actor("agentx/x-twitter-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://x.com/captainamerica/status/719944021058060289" }

# Run the Actor and wait for it to finish
run = client.actor("agentx/x-twitter-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://x.com/captainamerica/status/719944021058060289"
}' |
apify call agentx/x-twitter-transcript --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "𝕏 (twitter) Transcript",
        "description": "X Twitter Transcript turns one public X video post into structured text for news monitoring, quote capture, and social research. Output includes language detection, ordered timestamps, post metadata, and optional translation into 133 languages. The base transcript rate is $0.2592.",
        "version": "1.0",
        "x-build-id": "eTQVm9zcEDcqIB9tA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/agentx~x-twitter-transcript/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-agentx-x-twitter-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~x-twitter-transcript/runs": {
            "post": {
                "operationId": "runs-sync-agentx-x-twitter-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~x-twitter-transcript/run-sync": {
            "post": {
                "operationId": "run-sync-agentx-x-twitter-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 X post URL containing video 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 an optional target language for the translated 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
