# Loom Transcript (`agentx/loom-transcript`) Actor

Loom Transcript converts one public share video into structured text for product demos, walkthroughs, async updates, and knowledge bases. It returns detected language, ordered timestamps, video metadata, and optional translation into 133 languages. Transcript runs begin at $0.3483.

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

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

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

- Input is one Loom `/share/{id}` recording whose link setting allows anyone with the link to view it.
- The precheck follows the share URL and confirms Loom media before download and speech recognition start.
- A completed recording produces one 22-field Dataset item containing available recording context and ordered speech segments.
- Workspace-only, invited-viewer, password-protected, deleted, or otherwise restricted Looms are not opened with credentials.

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

Use a recording you own or are authorized to process, confirm its link is publicly viewable, and review the generated transcript before connecting it to documentation automation.

---

### Why Choose This API

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

This Actor fits a known Loom share link, such as a product walkthrough, async update, or support explanation, when the audio must become structured text. One URL and one optional target language form the entire public input. Extractor identity, not the hostname string alone, makes the final platform decision.

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

| Capability | What is returned |
| --- | --- |
| Recording speech | Detected language, full text, and ordered `start` / `end` / `text` ranges |
| Loom context | Title, description, recorder identifiers, duration, publication time, thumbnail, categories, and tags when available |
| Exposed activity | Views and any supported nullable engagement fields returned by the extractor |
| Optional translation | A complete second-language segment list retaining source timing |

It does not enumerate a Loom workspace, process a folder, bypass share settings, export Loom's own transcript/comments/chapters, identify speakers, summarize the recording, or return its video file. Absent source fields stay null, zero, or empty.

The recording's audio drives recognition. Screen text, cursor actions, and slides are not read. Microphone quality, system-audio balance, accents, crosstalk, and company terminology can affect accuracy, so review operational instructions before reuse.

---

### Quick Start Guide

#### Run in Apify Console

1. Open [Loom Transcript on Apify](https://apify.com/agentx/loom-transcript?fpr=aiagentapi).
2. In Loom, set the recording to **Anyone with the link**, copy its `/share/` URL, and paste it into **Video URL**.
3. Choose **Translate** only when one localized copy is required.
4. Start the run and review the single Dataset item after completion.

The schema currently pre-fills this Loom share link:

```json
{
  "video_url": "https://www.loom.com/share/c43a642f815f4378b6f80a889bb73d8d",
  "translate": "spanish"
}
````

The API and response sections reuse that ID for consistency. A recording owner can delete it or change sharing to workspace-only, specific people, or password-protected access. Replace an unavailable example with another authorized recording set to public link access.

#### What success means

A valid transcript requires a viewable share link, media with audio, detected speech, and one published Dataset object. Loading the share page or reading its title is not enough.

***

### Input Parameters

#### Input configuration

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

One run processes one share ID. Workspace homepages, libraries, folders, user pages, restricted recordings, password-protected links, uploads, cookies, credentials, and URL arrays are not accepted. The downloader never expands a collection.

A correct `/share/` format can still fail when link settings change, the recording is deleted, a password is added, Atlassian changes delivery, or no usable audio stream is exposed.

Translation begins only after source segments exist. Workers can run concurrently but output order follows the recording. Any final segment failure removes the optional translation and its charge rather than returning a partial structure.

***

### Output Data Schema

#### One 22-field Dataset item

A successfully transcribed Loom produces one 22-field Dataset record:

| 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 Loom-and-Spanish example:

```json
{
  "processor": "https://apify.com/agentx/loom-transcript?fpr=aiagentapi",
  "processed_at": "2026-07-21T13:30:00+00:00",
  "platform": "Loom",
  "title": "Lilah Nielsen Intro Video",
  "author": "Lilah Nielsen",
    "duration": 20,
    "categories": [],
  "tags": [],
  "transcript": {
    "language": "English",
    "text": "Hi there, hope everyone's having a great day.",
    "segments": [
      {
        "start": "00:00:00.320",
        "end": "00:00:08.519",
        "text": "Hi there, hope everyone's having a great day."
      }
    ]
  },
  "translation": {
    "language": "Spanish",
    "text": "Hola, espero que todos estén teniendo un gran día.",
    "segments": [
      {
        "start": "00:00:00.320",
        "end": "00:00:08.519",
        "text": "Hola, espero que todos estén teniendo un gran día."
      }
    ]
  }
}
```

Example values are illustrative snapshots. The Dataset does not add the video file, Loom's native transcript, comments, chapters, screen OCR, speaker identities, 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~loom-transcript/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "video_url": "https://www.loom.com/share/c43a642f815f4378b6f80a889bb73d8d",
    "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/loom-transcript").call(
    run_input={
        "video_url": "https://www.loom.com/share/c43a642f815f4378b6f80a889bb73d8d",
        "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/loom-transcript",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

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

***

### Pricing & Cost Calculator

Loom 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.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 |

A Free-tier run with one transcript, no translation, and the fixed 8192 MB configuration starts at `$0.387 + (8 × $0.001) = $0.395`, plus usage events. With translation, it starts at `$0.387 + $0.15 + $0.008 = $0.545`, 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/loom-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

#### Build a searchable recording library

Store `transcript.text` for whole-recording search or index timestamped `segments` as smaller retrieval units. Product walkthroughs, internal demonstrations, and recorded updates can then be found by spoken phrase. A downstream application can display matching text and its approximate video interval; embeddings and question answering remain downstream responsibilities.

#### Turn walkthroughs into working notes

Teams can turn an authorized Loom walkthrough into draft SOP steps, implementation notes, release summaries, or follow-up tasks. Segment timestamps provide a practical path back to the recording. The output is generated from audible speech, so review names, numbers, commands, and consequential instructions against the source before publishing them.

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

#### Review recordings across languages

Request one translation target when colleagues need to inspect the spoken content in another language. Translation preserves segment time ranges so reviewers can compare source and translated passages against the same point in the recording. Multiple target languages require separate runs and separate translation events.

#### Automation boundaries

This Actor is suited to a known video URL. Collect authorized Loom share URLs 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 Loom's generated transcript?

No. The verified path downloads audible media and generates speech text independently. It does not promise Loom's existing transcript, captions, comments, or chapters.

#### Can it process password-protected or workspace-only videos?

No access credentials are accepted. The share URL must be publicly reachable and expose downloadable media with an audio track.

#### Can it process an entire Loom workspace or folder?

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

Loom 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 Loom video to text, generating a Loom transcript with timestamps, extracting spoken words from a Loom 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 Loom 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/loom-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: a schema-constrained Loom share URL, a closed 22-field Dataset schema, timestamped segments, nullable source metadata, 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. Source 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. Confirm that the owner enabled appropriate link access using Loom's [recording sharing guidance](https://support.atlassian.com/loom/docs/share-your-recording/), and review the current [Atlassian product terms for Loom](https://www.atlassian.com/legal/product-terms) 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

- [YouTube Transcript](https://apify.com/agentx/youtube-transcript?fpr=aiagentapi) handles one public YouTube video.
- [TikTok Transcript](https://apify.com/agentx/tiktok-transcript?fpr=aiagentapi) handles one public TikTok 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/loom-transcript?fpr=aiagentapi)
- [API reference](https://apify.com/agentx/loom-transcript/api?fpr=aiagentapi)
- [Issues](https://apify.com/agentx/loom-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, public proof, the example URL, and official documentation links were last checked on **July 21, 2026**. Loom availability and Store statistics are volatile.

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

# Actor input Schema

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

Paste one public Loom share 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.loom.com/share/c43a642f815f4378b6f80a889bb73d8d"
}
```

# 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.loom.com/share/c43a642f815f4378b6f80a889bb73d8d"
};

// Run the Actor and wait for it to finish
const run = await client.actor("agentx/loom-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.loom.com/share/c43a642f815f4378b6f80a889bb73d8d" }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Loom Transcript",
        "description": "Loom Transcript converts one public share video into structured text for product demos, walkthroughs, async updates, and knowledge bases. It returns detected language, ordered timestamps, video metadata, and optional translation into 133 languages. Transcript runs begin at $0.3483.",
        "version": "1.0",
        "x-build-id": "Mz0nK3CD9tEkW0QCq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/agentx~loom-transcript/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-agentx-loom-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~loom-transcript/runs": {
            "post": {
                "operationId": "runs-sync-agentx-loom-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~loom-transcript/run-sync": {
            "post": {
                "operationId": "run-sync-agentx-loom-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 Loom share 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
