# Video Transcript Scraper (`automation-lab/video-transcript-scraper`) Actor

Extract transcripts and captions from YouTube, TikTok, Instagram Reels, and Facebook Reels. Get full text with timestamps. Supports 6+ languages.

- **URL**: https://apify.com/automation-lab/video-transcript-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

Extract captions and transcripts from **TikTok, YouTube, Instagram Reels, and Facebook Reels** — all in one actor. Paste video URLs and get back full-text transcripts with timestamps. No API key needed, no manual copying.

> **Supports:** TikTok · YouTube (videos + Shorts) · Instagram Reels · Facebook Reels

---

### What does Video Transcript Scraper do?

Video Transcript Scraper extracts the caption and subtitle tracks from social media videos and returns them as structured text data with timestamps. Give it a list of video URLs from any supported platform and it returns the full transcript, the individual timed segments, word count, and video metadata (title, author, thumbnail).

YouTube uses a native timedtext API for fast, reliable extraction. TikTok, Instagram, and Facebook are processed using a headless browser that intercepts subtitle API calls as the video player loads — the same approach used by the leading competitor but with wider platform coverage and better structured output.

Try it free on the [Apify Store](https://apify.com/automation-lab/video-transcript-scraper).

---

### Who is Video Transcript Scraper for?

**📢 Content marketers and social media managers**
- Repurpose video content into blog posts, newsletters, or social captions
- Extract key quotes from interview-style Reels for ad copy
- Audit influencer content for brand mentions before partnerships

**🎓 Researchers and academics**
- Analyze linguistic patterns across thousands of TikTok or YouTube videos
- Build datasets of spoken language from social media for NLP training
- Study how topics are discussed across different video platforms

**🤖 AI and automation engineers**
- Feed transcripts into LLMs for summarization, sentiment analysis, or Q&A
- Build RAG pipelines indexing video content as searchable text
- Automate transcript generation for video archives

**💼 SEO and content strategists**
- Convert YouTube video content into text for programmatic SEO pages
- Identify top-performing topics by analyzing what high-view videos say
- Extract transcript data from competitor channels for content gap analysis

---

### Why use Video Transcript Scraper?

- 🎯 **Multi-platform in one run** — mix TikTok, YouTube, Instagram, and Facebook URLs in a single input list
- ⚡ **Pure HTTP for YouTube** — no browser overhead; YouTube extraction is fast and free from blocking
- 🕐 **Timestamps included** — every segment has `startTime` and `endTime` in seconds, ready for SRT/VTT conversion
- 📄 **Clean text output** — `transcriptText` field is a single clean string with no markup or timing codes
- 🔁 **Graceful error handling** — failed or no-caption videos don't crash the run; they return an `error` field
- 🛡️ **Residential proxy support** — configure proxy for platforms that require it (TikTok, Instagram)
- 🔗 **No login required** — works on public videos without any account credentials
- 📊 **Structured JSON output** — every result includes platform, videoId, author, thumbnail, duration, language, segments, and word count

---

### What data can you extract?

| Field | Description | Example |
|-------|-------------|---------|
| `videoUrl` | Original input URL | `https://youtube.com/watch?v=...` |
| `platform` | Platform name | `youtube` / `tiktok` / `instagram` / `facebook` |
| `videoId` | Platform video ID | `dQw4w9WgXcQ` |
| `title` | Video title | `"10 Python Tips You Didn't Know"` |
| `author` | Channel or username | `"@techcreator"` |
| `thumbnailUrl` | Thumbnail image URL | `https://img.youtube.com/vi/.../maxresdefault.jpg` |
| `duration` | Duration in seconds | `243` |
| `language` | Caption language code | `en` |
| `transcriptText` | Full transcript as plain text | `"Today we're going to talk about..."` |
| `segments` | Array of timed caption segments | `[{startTime, endTime, text}, ...]` |
| `segmentCount` | Number of caption segments | `87` |
| `wordCount` | Approximate word count | `1243` |
| `scrapedAt` | Extraction timestamp | `2026-04-04T12:00:00.000Z` |
| `error` | Error message (null if successful) | `"No captions available"` |

**Segment object fields:**

| Field | Type | Description |
|-------|------|-------------|
| `startTime` | number | Segment start time in seconds |
| `endTime` | number | Segment end time in seconds |
| `text` | string | Caption text for this segment |

---

### How much does it cost to extract video transcripts?

This actor uses **Pay-Per-Event (PPE) pricing** — you only pay for successful transcript extractions.

| Event | Price (FREE tier) |
|-------|------------------|
| Run started | $0.06 (one-time) |
| Transcript extracted | $0.058 per video |

**Tiered discounts** — the more you use Apify, the less you pay per transcript:

| Apify Tier | Start fee | Price per transcript |
|------------|-----------|---------------------|
| FREE | $0.060 | $0.058 |
| BRONZE | $0.055 | $0.050 |
| SILVER | $0.045 | $0.039 |
| GOLD | $0.035 | $0.030 |
| PLATINUM | $0.025 | $0.020 |
| DIAMOND | $0.018 | $0.014 |

**Free plan estimate:** With $5 in free Apify credits, you can extract approximately **85 transcripts** (after the $0.06 start fee).

**Failed extractions are not charged** — if a video has no captions or extraction fails, you only pay the start fee.

**Real-world cost examples:**
- 50 YouTube transcripts: $0.06 + (50 × $0.058) = **$2.96**
- 200 mixed-platform transcripts: $0.06 + (200 × $0.058) = **$11.66**
- 500 YouTube Shorts for content analysis: $0.06 + (500 × $0.058) = **$29.06**

---

### How to extract video transcripts

1. Go to [Video Transcript Scraper on Apify Store](https://apify.com/automation-lab/video-transcript-scraper)
2. Click **Try for free**
3. In the **Video URLs** field, paste one or more video URLs (one per line)
4. *(Optional)* Adjust **Max retries** for flaky connections
5. *(Optional)* Configure **Proxy** — residential proxies improve success rates for TikTok and Instagram
6. Click **Start** and wait for results
7. Download results as **JSON, CSV, or Excel** — or connect to downstream tools

**Supported URL formats:**
````

## YouTube

https://www.youtube.com/watch?v=dQw4w9WgXcQ
https://youtu.be/dQw4w9WgXcQ
https://www.youtube.com/shorts/dQw4w9WgXcQ

## TikTok

https://www.tiktok.com/@username/video/7123456789012345678

## Instagram

https://www.instagram.com/reel/ABC123def/

## Facebook

https://www.facebook.com/reel/123456789

````

**Example input (JSON):**
```json
{
  "videoUrls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "https://www.youtube.com/shorts/5-WE64bwEMI",
    "https://www.tiktok.com/@nasa/video/7234567890123456789"
  ],
  "maxRetries": 2
}
````

**Example input — batch content analysis:**

```json
{
  "videoUrls": [
    "https://www.youtube.com/watch?v=VIDEO_ID_1",
    "https://www.youtube.com/watch?v=VIDEO_ID_2",
    "https://www.tiktok.com/@creator/video/TIKTOK_ID"
  ],
  "maxRetries": 3,
  "proxy": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

***

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `videoUrls` | array of strings | ✅ Yes | — | Video URLs to transcribe. Mix platforms freely. |
| `maxRetries` | integer | No | 2 | Max retry attempts per URL on failure (0–5). |
| `proxy` | object | No | Residential | Proxy configuration. Residential proxies recommended for TikTok/Instagram. |

**Proxy notes:**

- **YouTube**: No proxy needed. Works without any proxy configuration.
- **TikTok**: Residential proxy strongly recommended. Without it, TikTok often returns empty pages.
- **Instagram**: Residential proxy improves reliability for Reels.
- **Facebook**: Residential proxy helps bypass login walls on some videos.

***

### Output examples

**Successful YouTube transcript:**

```json
{
  "videoUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "platform": "youtube",
  "videoId": "dQw4w9WgXcQ",
  "title": "Rick Astley - Never Gonna Give You Up (Official Music Video)",
  "author": "Rick Astley",
  "thumbnailUrl": "https://i.ytimg.com/vi/dQw4w9WgXcQ/maxresdefault.jpg",
  "duration": 213,
  "language": "en",
  "transcriptText": "We're no strangers to love You know the rules and so do I...",
  "segments": [
    { "startTime": 18.56, "endTime": 20.56, "text": "We're no strangers to love" },
    { "startTime": 20.56, "endTime": 22.56, "text": "You know the rules and so do I" }
  ],
  "segmentCount": 54,
  "wordCount": 312,
  "scrapedAt": "2026-04-04T12:00:00.000Z",
  "error": null
}
```

**No captions available:**

```json
{
  "videoUrl": "https://www.tiktok.com/@creator/video/1234567890",
  "platform": "tiktok",
  "videoId": "1234567890",
  "title": "My TikTok video",
  "transcriptText": null,
  "segments": [],
  "segmentCount": 0,
  "wordCount": 0,
  "error": "No captions available for this TikTok video"
}
```

***

### Tips for best results

- 🎯 **YouTube has the highest success rate** — YouTube's timedtext API is reliable and fast. If you only need YouTube transcripts, no proxy configuration is needed at all.
- 📋 **Caption availability** — Not all videos have captions. Auto-generated captions are available on most YouTube videos. TikTok and Instagram auto-captions are only available on a subset of videos (typically creators who have enabled them).
- 🌐 **Always use residential proxy for TikTok** — TikTok actively blocks datacenter IPs. Configure `"apifyProxyGroups": ["RESIDENTIAL"]` for TikTok batches.
- 📦 **Batch efficiently** — Mix YouTube and TikTok/Instagram URLs in one run. YouTube URLs are free of proxy costs; the residential proxy charges only apply when actually used for non-YouTube platforms.
- 🔄 **Use maxRetries: 3 for large batches** — transient failures are common with social media platforms. Set retries higher for unattended automation runs.
- 📅 **Schedule for monitoring** — use Apify's scheduler to run weekly transcript extraction on channels you monitor, and connect to Google Sheets for automatic updates.
- 🚀 **Start small to test** — run 5-10 URLs first to verify captions are available for your target channels before running large batches.

***

### Integrations

**📊 Video Transcript Scraper → Google Sheets (content monitoring)**
Connect output via Apify webhooks to automatically append new transcripts to a Google Sheet. Use the built-in Google Sheets integration in Apify Console → Integrations.

**🤖 Video Transcript Scraper → OpenAI / Claude (AI summarization)**
Feed `transcriptText` into an LLM prompt via Make.com or Zapier: "Summarize this video transcript in 3 bullet points and extract 5 key quotes." Build content briefs automatically from competitor videos.

**📧 Video Transcript Scraper → Email alerts (keyword monitoring)**
Schedule weekly runs on a YouTube channel's latest videos. Use a Make.com filter on `transcriptText` to check for keyword mentions, then send a Slack or email alert when your brand or competitor is mentioned.

**🗂️ Video Transcript Scraper → RAG pipeline (AI search)**
Export JSON output, chunk `segments` arrays by timestamp windows, embed with OpenAI, and index into Pinecone or Weaviate. Build a searchable knowledge base of video content queryable by natural language.

**📝 Video Transcript Scraper → WordPress / CMS (SEO content)**
Pipe YouTube transcripts into a templating system that auto-generates blog post drafts. Each transcript becomes a lightly-edited article, turning a video library into an SEO content moat.

***

### Using the Apify API

Run Video Transcript Scraper programmatically from any language or CI/CD pipeline.

**Node.js:**

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('automation-lab/video-transcript-scraper').call({
  videoUrls: [
    'https://www.youtube.com/watch?v=dQw4w9WgXcQ',
    'https://www.youtube.com/shorts/5-WE64bwEMI',
  ],
  maxRetries: 2,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient(token="YOUR_API_TOKEN")

run = client.actor("automation-lab/video-transcript-scraper").call(run_input={
    "videoUrls": [
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
        "https://www.tiktok.com/@nasa/video/7234567890",
    ],
    "maxRetries": 2,
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
for item in items:
    print(item["platform"], item["wordCount"], item["transcriptText"][:100])
```

**cURL:**

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~video-transcript-scraper/runs" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "videoUrls": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"],
    "maxRetries": 2
  }'
```

***

### Use with AI agents via MCP

Video Transcript Scraper is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).

Add the Apify MCP server to your AI client — this gives you access to all Apify actors, including this one:

#### Setup for Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com"
```

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com"
        }
    }
}
```

Your AI assistant will use OAuth to authenticate with your Apify account on first use.

#### Example prompts

Once connected, try asking your AI assistant:

- "Use automation-lab/video-transcript-scraper to get the transcript of this YouTube video: https://www.youtube.com/watch?v=dQw4w9WgXcQ"
- "Extract transcripts from these 5 TikTok videos and summarize the main topics covered in each"
- "Get transcripts for all videos in this list and tell me which ones mention the keyword 'climate change'"

Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

***

### Is it legal to scrape video transcripts?

This actor extracts **publicly available caption data** from public videos on social media platforms. It does not:

- Bypass any authentication walls
- Download video or audio content
- Access private or unlisted videos
- Store or redistribute video content

Caption data scraped is functionally equivalent to reading the closed captions a user can already see while watching a video.

**Best practices:**

- Only scrape public videos
- Respect platform terms of service for your use case
- Do not use transcript data to reproduce original creative works in full
- Review [Apify's terms of service](https://apify.com/terms-of-use) and the [responsible scraping guidelines](https://apify.com/legal/responsible-scraping)

This actor is intended for research, analysis, content repurposing, and automation workflows using publicly available data.

***

### FAQ

**Which platform has the highest transcript success rate?**
YouTube has near-100% success for videos with captions (most YouTube videos have auto-generated English captions). TikTok success depends on whether the creator has enabled auto-captions — typically 60-70% of videos. Instagram and Facebook have lower availability as they rely on creators manually enabling captions.

**How much does it cost to transcribe 100 videos?**
On the FREE tier ($0.058/transcript): $0.06 start + (100 × $0.058) = **$5.86 total**. On the BRONZE tier ($0.050/transcript): $0.055 start + (100 × $0.050) = **$5.55 total**. Videos without captions are not charged.

**How is this different from the official YouTube Transcript API?**
YouTube has no official transcript API. This actor uses the internal timedtext endpoint that the YouTube player uses — the same data that shows as closed captions when you watch a video. It works for any public video with captions, including auto-generated ones.

**Why are some TikTok transcripts empty?**
TikTok only generates auto-captions for some videos — typically newer videos where the creator has TikTok's auto-caption feature enabled. Older videos or videos from creators who've opted out of captions will return `error: "No captions available"`. This is a TikTok platform limitation, not a scraper issue.

**Why does my TikTok run return no results?**
Most likely cause: no residential proxy configured. TikTok blocks datacenter IP addresses. Add `"proxy": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }` to your input and re-run.

**Can I extract transcripts from private or unlisted videos?**
No. This actor only works with publicly accessible videos. Private videos require authentication, which is outside the scope of this tool.

**What languages are supported?**
For YouTube, whatever caption tracks the video has (often multiple languages). The actor prefers English (`en`) but falls back to the first available track. For TikTok/Instagram/Facebook, language depends on what auto-caption track the platform generated — usually the creator's primary language.

**How fast does it run?**
YouTube extractions take 1-3 seconds each (pure HTTP). TikTok/Instagram/Facebook take 15-45 seconds each (browser-based). A batch of 50 YouTube videos completes in about 2-3 minutes. A mixed batch of 50 videos including TikTok takes 10-20 minutes depending on proxy response times.

***

### Other video and social media scrapers

Looking for related tools? Check out these other automation-lab actors:

- 🎵 [TikTok Sound Scraper](https://apify.com/automation-lab/tiktok-sound-scraper) — Extract all videos using a specific TikTok sound or music track
- 📺 [YouTube Scraper](https://apify.com/automation-lab/youtube-scraper) — Scrape YouTube video data, channel info, and comments
- 📸 [Instagram Scraper](https://apify.com/automation-lab/instagram-scraper) — Extract posts, reels, profiles, and hashtag feeds from Instagram
- 🔗 [Broken Link Checker](https://apify.com/automation-lab/broken-link-checker) — Crawl websites and find all broken or dead links
- 🛒 [Amazon Reviews Scraper](https://apify.com/automation-lab/amazon-reviews-scraper) — Extract product reviews from Amazon for sentiment analysis

# Actor input Schema

## `videoUrls` (type: `array`):

URLs of videos to transcribe. Supports TikTok, YouTube (videos & Shorts), Instagram Reels, and Facebook Reels. One URL per line.

## `maxRetries` (type: `integer`):

How many times to retry a video URL if extraction fails. Increase for flaky connections.

## `proxy` (type: `object`):

Proxy settings. TikTok and Instagram require residential proxies. YouTube works without any proxy.

## Actor input object example

```json
{
  "videoUrls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  ],
  "maxRetries": 2
}
```

# 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 = {
    "videoUrls": [
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
    ],
    "maxRetries": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/video-transcript-scraper").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 = {
    "videoUrls": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"],
    "maxRetries": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/video-transcript-scraper").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 '{
  "videoUrls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  ],
  "maxRetries": 2
}' |
apify call automation-lab/video-transcript-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Video Transcript Scraper",
        "description": "Extract transcripts and captions from YouTube, TikTok, Instagram Reels, and Facebook Reels. Get full text with timestamps. Supports 6+ languages.",
        "version": "0.1",
        "x-build-id": "lZwLC3GdGNDDL2bjb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~video-transcript-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-video-transcript-scraper",
                "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/automation-lab~video-transcript-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-video-transcript-scraper",
                "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/automation-lab~video-transcript-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-video-transcript-scraper",
                "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": [
                    "videoUrls"
                ],
                "properties": {
                    "videoUrls": {
                        "title": "Video URLs",
                        "type": "array",
                        "description": "URLs of videos to transcribe. Supports TikTok, YouTube (videos & Shorts), Instagram Reels, and Facebook Reels. One URL per line.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxRetries": {
                        "title": "Max retries per video",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "How many times to retry a video URL if extraction fails. Increase for flaky connections.",
                        "default": 2
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. TikTok and Instagram require residential proxies. YouTube works without any proxy."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
