# Bilibili Transcript (`agentx/bilibili-transcript`) Actor

Bilibili Transcript processes one public video part, keeping the selected part's speech and metadata together for multilingual research and media analysis. Results include detected language, ordered timestamps, and optional translation into 133 languages. Transcript pricing opens at $0.3483.

- **URL**: https://apify.com/agentx/bilibili-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.3483 / 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

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

**Bilibili Transcript converts one public Bilibili video part 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 Bilibili caption tracks or existing subtitle files.

- Supply one public Bilibili video-part URL; `?p=` selects the part and the Actor never expands an entire multipart work.
- Short links and redirects are resolved before the platform gate confirms the Bilibili extractor.
- One successful part produces one 22-field Dataset record containing source context and generated speech segments.
- The output excludes Bilibili subtitles, danmaku, comments, OCR, and the source media file.

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

For the first run, choose a public part with clear dialogue and verify that the selected `p` value matches the intended episode before automating more items.

---

### Why Choose This API

#### A narrow contract for one known Bilibili video

Use this Actor after identifying an exact Bilibili BV page and, for multipart media, the desired part. The contract stays narrow: one URL plus one optional translation target. Platform confirmation uses resolved extractor information, so string appearance alone is not treated as proof of support.

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

| Capability | What is returned |
| --- | --- |
| Audio transcription | Detected language, joined text, and ordered `start` / `end` / `text` ranges for the selected part |
| BV-part context | Title, description, uploader identifiers, duration, publish time, thumbnail, categories, and tags when available |
| Source counters | Current views, likes, shares, comments, and other supported nullable metrics |
| Optional translation | A complete target-language version aligned to the original segment intervals |

This is not a creator-space crawler, bangumi or series expander, live recorder, subtitle/danmaku exporter, speaker-labeling tool, summarizer, or downloader. When Bilibili omits a source value, the Dataset preserves its nullable, zero, or empty form rather than inferring it.

Recognition operates on the chosen part's audio. Mandarin dialects, mixed Chinese and English, names, background music, overlapping voices, and specialist vocabulary can affect accuracy. Check consequential wording against the selected part.

---

### Quick Start Guide

#### Run in Apify Console

1. Open [Bilibili Transcript on Apify](https://apify.com/agentx/bilibili-transcript?fpr=aiagentapi).
2. Open the required Bilibili part and copy the URL including its `?p=` value when present.
3. Paste it into **Video URL** and optionally choose one **Translate** language.
4. Start the run and inspect the one Dataset record after transcription completes.

The current schema pre-fills a BV URL selecting part 1:

```json
{
  "video_url": "https://www.bilibili.com/video/BV1o84y1V7EY/?p=1",
  "translate": "spanish"
}
````

The integration and response examples reuse that URL for a consistent scenario. A source can later be deleted, region-limited, made login-only, or reorganized into different parts. Replace an unavailable example with another public Bilibili part containing audible speech.

#### What success means

Success requires playable media for the requested part, a usable audio stream, detected speech, and a published result. Reading BV metadata without speech output does not satisfy the transcript contract.

***

### Input Parameters

#### Input configuration

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

The input processes one resolved media item. Creator spaces, searches, collections, series expansion, private or membership-only pages, uploads, cookies, credentials, and URL arrays are excluded. Playlist processing is disabled.

Correct BV syntax is only the first condition. The selected part must still be publicly accessible through the current extractor and expose audio; regional policy, deletion, authentication, or platform response changes can prevent preparation.

After source speech succeeds, translation can process segments concurrently and restores their original order. A single unrecoverable segment causes the whole optional translation to be omitted without its event charge.

***

### Output Data Schema

#### One 22-field Dataset item

The selected part maps to one Dataset item with 22 fields:

| 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 schema illustration for the part-1-and-Spanish example:

```json
{
  "processor": "https://apify.com/agentx/bilibili-transcript?fpr=aiagentapi",
  "processed_at": "2026-07-21T13:50:00+00:00",
  "platform": "BiliBili",
  "title": "English Speech - All About Me",
  "author": "嘀嗒英语Kidstalk",
  "duration": 20,
  "view_count": 120128,
  "like_count": 1769,
  "categories": [],
  "tags": ["英文", "演讲", "英语口语", "儿童英语"],
  "transcript": {
    "language": "English",
    "text": "Everyone, nice to meet you. Let me introduce myself.",
    "segments": [
      {
        "start": "00:00:00.830",
        "end": "00:00:10.660",
        "text": "Everyone, nice to meet you. Let me introduce myself."
      }
    ]
  },
  "translation": {
    "language": "Spanish",
    "text": "Hola a todos, encantada de conocerlos. Permítanme presentarme.",
    "segments": [
      {
        "start": "00:00:00.830",
        "end": "00:00:10.660",
        "text": "Hola a todos, encantada de conocerlos. Permítanme presentarme."
      }
    ]
  }
}
```

Displayed counts and text are illustrative snapshots. Actual metadata can change, and the Dataset does not add video/audio files, Bilibili subtitle tracks, danmaku, SRT/VTT, speaker labels, word timing, confidence, summaries, or legal verification.

***

### Integration Examples

#### REST API

The synchronous endpoint returns Dataset items directly:

```bash
curl -L "https://api.apify.com/v2/actors/agentx~bilibili-transcript/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "video_url": "https://www.bilibili.com/video/BV1o84y1V7EY/?p=1",
    "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/bilibili-transcript").call(
    run_input={
        "video_url": "https://www.bilibili.com/video/BV1o84y1V7EY/?p=1",
        "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/bilibili-transcript",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

Call `agentx/bilibili-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/bilibili-transcript/api?fpr=aiagentapi).

***

### Pricing & Cost Calculator

Bilibili Transcript uses event pricing. The repository metadata is the current build authority; any public Store page remains a separate deployed snapshot and can lag these values.

| 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.38700 |
| Transcript - Bronze | $0.37410 |
| Transcript - Silver | $0.36120 |
| Transcript - Gold, Platinum, Diamond | $0.34830 |
| Translation - Free | $0.15 |
| Translation - Bronze | $0.145 |
| Translation - Silver | $0.14 |
| Translation - Gold, Platinum, Diamond | $0.135 |

At Free tier, the fixed subtotal for a transcript on 8192 MB is `$0.387 + (8 × $0.001) = $0.395`, plus usage. A completed translation makes it `$0.387 + $0.15 + $0.008 = $0.545`. Start and runtime usage may accrue even when later work fails.

Check the [live pricing page](https://apify.com/agentx/bilibili-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

Index the joined transcript for part-level search, or index individual segments so a match can point back to an approximate interval. Embeddings and answers are downstream responsibilities.

#### Editorial and research review

Researchers, bilingual editors, education teams, and analysts can keep spoken claims beside the BV title, uploader, publish time, and available engagement. Preserve the source and part selector for reproducible review.

#### Accessibility drafts and content repurposing

Segment ranges can seed bilingual notes, caption editing, summaries, or search, but they remain machine-generated drafts rather than platform subtitles or certified accessibility output.

#### Multilingual review

One target language yields a parallel segment-aligned reading layer. Separate runs are required for additional target languages.

#### Automation boundaries

Discovery should first produce authorized BV links and part choices; this Actor then handles selected parts individually. A technically successful run does not grant publication or redistribution rights.

***

### FAQ

#### Does the Actor return Bilibili subtitles or danmaku?

No. The implemented path generates speech text from audio. Platform subtitles, danmaku, comments, and pixels rendered into the video are not input to that process.

#### Can it process a multi-part Bilibili video?

Use a URL that selects one specific part, such as `?p=1`. The run processes one resolved media item; it does not expand an entire multi-part series.

#### Can it process an entire creator page or series?

No. The public input accepts one video URL, and playlist and multi-part expansion are 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?

Bilibili 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 runs with 8192 MB and 2 CPUs. A part longer than 3600 seconds is prepared as sequential 900-second core blocks with 15-second edge context, then merged by owned time ranges. Long parts still cost more wall time and usage.

#### 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

Bilibili video to text, BV transcript with timestamps, transcribe one Bilibili part, and Bilibili speech for RAG describe this exact single-part workflow.

It is not a subtitle or danmaku downloader, creator-space scraper, multipart batch API, media downloader, summarizer, OCR tool, or guaranteed-verbatim service.

Use `agentx/bilibili-transcript` in API clients. Evaluate current Input, Output, Pricing, Reviews, and Issues only after deployment, because online Store state is not the authority for these local edits.

***

### Trust & Certifications

Repository evidence proves bounded interfaces: two closed input fields, exact part-oriented example data, 22 Dataset/view/display keys, platform confirmation, and complete-or-absent translation. It does not prove that a volatile Bilibili URL will remain accessible.

No rating, user count, monthly activity, or bookmark figure is copied from the Store because those values depend on publication state and age quickly.

No independent accuracy certificate, SLA, legal-transcript designation, privacy certification, or uptime guarantee is claimed. Bilibili controls source access and machine-generated speech requires review.

***

### 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. Review [Bilibili's Terms of Service](https://www.bilibili.com/blackboard/protocal/international_hans.html) and applicable law for your use case.

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) accepts uploaded media and public URLs from many platforms.

#### 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/bilibili-transcript?fpr=aiagentapi)
- [API reference](https://apify.com/agentx/bilibili-transcript/api?fpr=aiagentapi)
- [Issues](https://apify.com/agentx/bilibili-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.

The local schemas, code behavior, pricing metadata, and cited Bilibili terms were reviewed on **July 21, 2026**. Example availability and online Store state remain volatile.

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

# Actor input Schema

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

Paste one public Bilibili video-part URL to download and transcribe

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

Select an optional target language for the translated transcript

## Actor input object example

```json
{
  "video_url": "https://www.bilibili.com/video/BV1o84y1V7EY/?p=1"
}
```

# 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.bilibili.com/video/BV1o84y1V7EY/?p=1"
};

// Run the Actor and wait for it to finish
const run = await client.actor("agentx/bilibili-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.bilibili.com/video/BV1o84y1V7EY/?p=1" }

# Run the Actor and wait for it to finish
run = client.actor("agentx/bilibili-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.bilibili.com/video/BV1o84y1V7EY/?p=1"
}' |
apify call agentx/bilibili-transcript --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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