# Video Transcript API: YouTube, TikTok, Instagram, X, Facebook (`amrameng/video-transcript-api`) Actor

Get transcripts from YouTube, TikTok, Instagram, X (Twitter), Facebook, and media files. Always returns clean text, even for videos without subtitles. Plain text or timestamped chunks, in bulk or via a real-time API. A pay-as-you-go Supadata alternative.

- **URL**: https://apify.com/amrameng/video-transcript-api.md
- **Developed by:** [Amram Englander](https://apify.com/amrameng) (community)
- **Categories:** Social media, AI, Videos
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $25.00 / 1,000 transcript extracteds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

![Video Transcript API — get transcripts from YouTube, TikTok, Instagram, X, and Facebook](https://i.imgur.com/yNa93B6.png)

**Get a transcript from any YouTube, TikTok, Instagram, X (Twitter), Facebook video or media file — in one tool.** This **video transcript API** returns clean text — even for videos with no subtitles. Output as plain text or timestamped chunks, in bulk or via a real-time API. No API keys, no per-platform setup. It's a pay-as-you-go **Supadata alternative** on Apify that transcribes YouTube, TikTok, Instagram, X, and Facebook for about $0.025 per transcript — with no monthly subscription and video metadata included in the same call.

Tired of juggling a separate YouTube transcript scraper, a TikTok caption tool, and an Instagram reel transcriber? This single Actor covers **all of them plus X/Twitter, Facebook, and direct file URLs (mp4, mp3, wav, m4a…)** and returns one consistent format.

### What does the YouTube, TikTok & Instagram transcript API do?

You paste one or more video URLs and get a transcript for each — fast, accurate, and in one consistent format across every platform. It works even when a video has no subtitles, and it detects the language automatically. There's nothing to configure.

It runs two ways:
- **Batch** — paste a list of URLs, get a dataset of transcripts.
- **Real-time API (Standby)** — call `GET /transcript?url=...` and get JSON back. A low-cost **Supadata alternative** on Apify.

### Which platforms and files are supported?

The input comes **pre-loaded with a working example from every platform plus a direct media file** — just press **Start** to see it transcribe across all of them, then swap in your own links.

| Platform | URL formats it accepts |
|---|---|
| **YouTube** | `youtube.com/watch?v=…`, `youtu.be/…`, `/shorts/…` |
| **TikTok** | `tiktok.com/@user/video/…`, `vm.tiktok.com/…` |
| **Instagram** | `instagram.com/reel/…`, `/p/…`, `/tv/…` |
| **X / Twitter** | `x.com/user/status/…`, `twitter.com/…/status/…` |
| **Facebook** | `facebook.com/…/videos/…`, `/reel/…`, `fb.watch/…` |
| **File URLs** | `.mp4 .webm .mp3 .m4a .wav .flac .ogg` (direct links) |

### What data does the transcript scraper return?

| Field | Description |
|---|---|
| `transcript` | Full clean plain-text transcript |
| `chunks` | Timestamped segments `{ text, offset, duration, lang }` |
| `lang` | Detected language (ISO 639-1, e.g. `en`) |
| `availableLangs` | Other languages the transcript is available in |
| `platform` | youtube / tiktok / instagram / twitter / facebook / file |
| `durationMs` | Media length in milliseconds |
| `title` | Video title |
| `channel` | Channel / author name |
| `channelUrl` | Channel / author profile URL |
| `viewCount` | View count (when the platform exposes it) |
| `likeCount` | Like count (when the platform exposes it) |
| `uploadDate` | Upload date (`YYYY-MM-DD`) |
| `thumbnail` | Thumbnail image URL |
| `description` | Video description / caption text |

**Transcript *and* full video metadata in a single call** — title, channel, views, likes, upload date, and thumbnail come back with every transcript, at no extra charge. (Supadata makes you call a separate metadata endpoint for that.)

### Why use this transcript API?

- **Every platform in one tool** — stop wiring up five different scrapers.
- **Works without subtitles** — videos with no captions still return a transcript (when the audio has speech).
- **Built for SEO, research, and AI** — feed transcripts to LLMs, summarize videos, repurpose content, build datasets, do accessibility captions, monitor competitors and influencers.
- **Bulk or API** — process large batches of URLs in one run, or call it live from your app.
- **Apify platform perks** — scheduling, integrations (Make, Zapier, n8n), API access, proxy rotation, and monitoring out of the box.

### LLM-ready transcripts for RAG and AI

Every transcript comes back **clean and pre-segmented** — no scraping artifacts, no HTML, no timestamps baked into the text. Drop it straight into a **RAG pipeline**, a vector database, or an LLM prompt for summarization, Q&A, sentiment analysis, or content repurposing. The timestamped `chunks` map one-to-one to embeddings when you need retrieval at the segment level, and the plain `transcript` string is ready to tokenize as-is.

### What can you build with it?

- **Video-to-text & audio-to-text** — turn any video *or* audio file (mp4, mp3, wav, m4a) into clean text, including multilingual content auto-detected across 50+ languages.
- **RAG & AI pipelines** — feed timestamped segments into a vector database for retrieval-augmented generation, semantic search, or an AI agent that reasons over video.
- **Subtitles & accessibility** — generate timestamped captions (SRT/VTT-style) from videos that have no subtitles of their own.
- **Content repurposing & SEO** — transcribe YouTube, TikTok, Instagram, X, and Facebook videos programmatically into articles, summaries, and show notes.
- **Research & monitoring** — build cross-platform transcript datasets to track competitors, influencers, and topics at scale.

### How to get a transcript (step by step)

1. Open the Actor — the **Video / file URLs** field is already pre-filled with a working example from every platform. Click **Start** to try it, or replace them with your own URLs (one per line, mix any platforms).
2. Click **Start**.
3. Download the results as **JSON, CSV, Excel, or HTML** — one transcript per URL.

That's it — no settings to configure. For real-time use, run the Actor in **Standby** mode and call `GET /transcript?url=<encoded-url>&text=true`.

### How much does it cost to get a transcript?

**About $0.025 per transcript**, any platform — one flat price whether the video has subtitles or not. Long videos (over ~20 minutes) add a small surcharge. **No monthly subscription** (unlike Supadata), and you only pay for transcripts you actually get back — failed or empty videos aren't charged.

On the Apify **free plan** you get $5 in platform credits every month — enough to test the Actor on real videos before you commit to anything.

### Supadata alternative on Apify

Looking for a **Supadata alternative**? This Actor covers the same platforms — YouTube, TikTok, Instagram, X (Twitter), Facebook, and direct media files — but as a **pay-as-you-go Apify Actor with no monthly subscription**. You pay about $0.025 per transcript and nothing while you're idle, instead of committing to a credit plan and losing unused credits at the end of each month.

| | This Actor | Supadata |
|---|---|---|
| **Pricing** | Pay-as-you-go, ~$0.025/transcript | Monthly subscription + credits (Free 100 → $5 → $17 → $47+) |
| **Monthly minimum** | None — pay only for what you run | Paid tiers are monthly plans |
| **Platforms** | YouTube, TikTok, Instagram, X, Facebook, files | YouTube, TikTok, Instagram, X, Facebook, files |
| **Video metadata** | Included in the same call | Separate metadata endpoint |
| **Works without subtitles** | Yes (speech-to-text fallback) | Yes |
| **Integrations** | Make, Zapier, n8n via Apify | API only |

Being upfront: Supadata's free tier (100 credits/month) is the cheaper choice if you only need a handful of transcripts, and its largest committed plans cost less per unit at very high volume. This Actor wins when you want **no subscription, no wasted credits, and metadata bundled in** — ideal for spiky, mid-volume, or pay-as-you-go workloads, or if you already run on Apify.

### Input

```json
{
  "urls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "https://www.tiktok.com/@user/video/734...",
    "https://www.instagram.com/reel/Cxyz123/"
  ]
}
````

Just URLs — that's the whole input. Every result comes back with **both** a clean transcript and timestamps, so there's nothing to configure.

| Field | Description |
|---|---|
| `urls` (required) | Video/file URLs — any platforms mixed |
| `lang` *(optional)* | Preferred language (ISO 639-1, e.g. `en`); best available is used otherwise |
| `maxDurationMinutes` *(optional)* | Skip videos longer than this many minutes; `0` = no limit |

### Output example

Every result includes **both** a clean `transcript` string and timestamped `chunks`:

```json
{
  "url": "https://www.tiktok.com/@user/video/734...",
  "platform": "tiktok",
  "lang": "en",
  "availableLangs": [],
  "durationMs": 18000,
  "title": "How we shot this in one take",
  "channel": "user",
  "channelUrl": "https://www.tiktok.com/@user",
  "viewCount": 482000,
  "likeCount": 31000,
  "uploadDate": "2026-05-21",
  "thumbnail": "https://...",
  "description": "Behind the scenes 🎬 #filmmaking",
  "transcript": "Hello everyone, in this video...",
  "chunks": [
    { "text": "Hello everyone", "offset": 0, "duration": 2140, "lang": "en" }
  ]
}
```

Read `transcript` for clean text, or use `chunks` for timestamps (subtitles, search, video sync). Download the dataset in JSON, CSV, Excel, or HTML. *(The real-time API lets you request just text or just chunks via the `text` parameter.)*

### Use it as an API (code examples)

Run the Actor in **Standby** mode and it behaves like a real-time transcript API — one HTTP call per URL, JSON back, no run to start. Authenticate with your Apify token. *(Your Actor's exact Standby URL is shown in the Console under the **Standby** tab.)*

**cURL**

```bash
curl "https://video-transcript-api.apify.actor/transcript?url=https://www.youtube.com/watch?v=dQw4w9WgXcQ&text=true" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN"
```

**Python**

```python
import requests

resp = requests.get(
    "https://video-transcript-api.apify.actor/transcript",
    params={"url": "https://www.tiktok.com/@cnn/video/7648387379912248589", "text": "true"},
    headers={"Authorization": "Bearer YOUR_APIFY_TOKEN"},
)
print(resp.json()["content"])
```

**JavaScript (Node)**

```js
const url = "https://www.instagram.com/reel/DUgLJzyEWIC/";
const res = await fetch(
  `https://video-transcript-api.apify.actor/transcript?url=${encodeURIComponent(url)}&text=true`,
  { headers: { Authorization: "Bearer YOUR_APIFY_TOKEN" } },
);
const { content, lang } = await res.json();
console.log(lang, content);
```

Pass `text=true` for plain text, or omit it to get timestamped `chunks`. Add `&lang=en` to prefer a language. The response is `{ content, lang, availableLangs, metadata }`, where `metadata` carries the video's title, channel, views, upload date, and thumbnail.

### FAQ

**How do I get a YouTube transcript via API?** Paste the YouTube URL (or call the Standby endpoint `GET /transcript?url=...`) and you get the transcript text back.

**Can I get a TikTok or Instagram reel transcript?** Yes — paste the TikTok or Instagram URL and you get the full transcript back.

**Does it work on videos without subtitles?** Yes — that's the point. Videos with no subtitles are transcribed too, as long as the audio has speech.

**Do I need any API keys or setup?** No — transcription is fully built in. Just paste URLs.

**Is this a Supadata alternative?** Yes. It's a pay-as-you-go **Supadata alternative** on Apify: the same transcripts from YouTube, TikTok, Instagram, X, and Facebook, but with no monthly subscription, video metadata included in the same call, and native Make/Zapier/n8n integrations. You pay about $0.025 per transcript instead of committing to a credit plan.

**What languages are supported?** 50+ languages, auto-detected and returned as ISO 639-1 codes.

**Can I get timestamps?** Yes — every result includes a `chunks` array of timestamped segments `{ text, offset, duration, lang }`, alongside the clean `transcript` text.

**How much does one transcript cost?** About **$0.025** per transcript, flat, on any platform — long videos (over ~20 minutes) add a small surcharge. No subscription, and you're only charged for transcripts you successfully get back.

**Is the output ready for LLMs and RAG?** Yes — you get clean plain text plus timestamped chunks, with no HTML or scraping artifacts, so it's ready to embed in a vector database or feed straight to an LLM.

**Can I transcribe an audio file, not just video?** Yes — pass a direct link to an mp3, wav, or m4a and you get the same output. It's a video- and audio-to-text API.

**Does it support multiple languages?** Yes — 50+ languages, auto-detected (ISO 639-1). It's a multilingual transcript API; pass `lang` to prefer a specific one.

**Can I generate subtitles?** Yes — every result includes timestamped segments you can turn into SRT/VTT-style captions, even for videos with no native subtitles.

**How do I transcribe a video programmatically?** Call the Standby endpoint `GET /transcript?url=...` from your code (see the cURL/Python/JS examples above), or run it in batch over a list of URLs.

### Related actors

Looking for other scrapers and APIs? **[Browse all Actors by this developer →](https://apify.com/amrameng)**

### Disclaimer & support

Only transcribe public content you're permitted to use, and respect each platform's Terms of Service. Private, age-restricted, or login-gated videos may be inaccessible, and clips with no speech (music/silent) return no transcript rather than fabricated text. Found a bug or need another platform? Open an **Issue** — feedback is welcome.

***

*Common search terms: video transcript API, video-to-text API, speech-to-text, YouTube / TikTok / Instagram / X / Facebook transcript API, multilingual transcript API, timestamped transcript, transcribe video programmatically, RAG transcript pipeline, Supadata alternative.*

# Actor input Schema

## `urls` (type: `array`):

The videos or media files to transcribe — paste as many as you like, mixing any platforms. One result per URL, and each includes both a clean transcript and timestamped chunks. The examples below show one of every supported source — edit or replace them.

## `lang` (type: `string`):

Optional ISO 639-1 code (e.g. "en", "es", "he"). If that language isn't available, the actor returns the best available one and lists the rest in availableLangs. Leave blank to auto-detect.

## `maxDurationMinutes` (type: `integer`):

Skip videos longer than this many minutes. 0 = no limit.

## `proxyConfiguration` (type: `object`):

Residential proxy is used by default and is required for YouTube/TikTok/Instagram (they block datacenter IPs). No need to change this.

## Actor input object example

```json
{
  "urls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "https://www.tiktok.com/@cnn/video/7648387379912248589",
    "https://www.instagram.com/reel/DUgLJzyEWIC/",
    "https://x.com/historyinmemes/status/1790637656616943991",
    "https://www.facebook.com/cnn/videos/10155529876156509/",
    "https://archive.org/download/NasaAudioHighlightReels/Sound-Bite_One-Small-Step.mp3"
  ],
  "maxDurationMinutes": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `transcripts` (type: `string`):

No description

# 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 = {
    "urls": [
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
        "https://www.tiktok.com/@cnn/video/7648387379912248589",
        "https://www.instagram.com/reel/DUgLJzyEWIC/",
        "https://x.com/historyinmemes/status/1790637656616943991",
        "https://www.facebook.com/cnn/videos/10155529876156509/",
        "https://archive.org/download/NasaAudioHighlightReels/Sound-Bite_One-Small-Step.mp3"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("amrameng/video-transcript-api").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 = { "urls": [
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
        "https://www.tiktok.com/@cnn/video/7648387379912248589",
        "https://www.instagram.com/reel/DUgLJzyEWIC/",
        "https://x.com/historyinmemes/status/1790637656616943991",
        "https://www.facebook.com/cnn/videos/10155529876156509/",
        "https://archive.org/download/NasaAudioHighlightReels/Sound-Bite_One-Small-Step.mp3",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("amrameng/video-transcript-api").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 '{
  "urls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "https://www.tiktok.com/@cnn/video/7648387379912248589",
    "https://www.instagram.com/reel/DUgLJzyEWIC/",
    "https://x.com/historyinmemes/status/1790637656616943991",
    "https://www.facebook.com/cnn/videos/10155529876156509/",
    "https://archive.org/download/NasaAudioHighlightReels/Sound-Bite_One-Small-Step.mp3"
  ]
}' |
apify call amrameng/video-transcript-api --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Video Transcript API: YouTube, TikTok, Instagram, X, Facebook",
        "description": "Get transcripts from YouTube, TikTok, Instagram, X (Twitter), Facebook, and media files. Always returns clean text, even for videos without subtitles. Plain text or timestamped chunks, in bulk or via a real-time API. A pay-as-you-go Supadata alternative.",
        "version": "0.1",
        "x-build-id": "xfYlfcGe6eZbdFQ1Q"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/amrameng~video-transcript-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-amrameng-video-transcript-api",
                "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/amrameng~video-transcript-api/runs": {
            "post": {
                "operationId": "runs-sync-amrameng-video-transcript-api",
                "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/amrameng~video-transcript-api/run-sync": {
            "post": {
                "operationId": "run-sync-amrameng-video-transcript-api",
                "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": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "Video / file URLs",
                        "type": "array",
                        "description": "The videos or media files to transcribe — paste as many as you like, mixing any platforms. One result per URL, and each includes both a clean transcript and timestamped chunks. The examples below show one of every supported source — edit or replace them.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "lang": {
                        "title": "Preferred language",
                        "type": "string",
                        "description": "Optional ISO 639-1 code (e.g. \"en\", \"es\", \"he\"). If that language isn't available, the actor returns the best available one and lists the rest in availableLangs. Leave blank to auto-detect."
                    },
                    "maxDurationMinutes": {
                        "title": "Max video length (minutes)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Skip videos longer than this many minutes. 0 = no limit.",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential proxy is used by default and is required for YouTube/TikTok/Instagram (they block datacenter IPs). No need to change this.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
