# Instagram Reels Transcript Scraper (No Login) (`makework36/instagram-reels-transcript-scraper`) Actor

Scrape Instagram reels from any public profile and get AI transcripts — no login, no cookies. HTTP-pure via mirror + Groq Whisper.

- **URL**: https://apify.com/makework36/instagram-reels-transcript-scraper.md
- **Developed by:** [deusex machine](https://apify.com/makework36) (community)
- **Categories:** Social media, AI, Videos
- **Stats:** 4 total users, 2 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.

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

## Instagram Reels Transcript Scraper — Captions, AI Transcripts, Video URLs & Metadata (No Login)

> ⭐ **Useful?** [Leave a review](https://apify.com/makework36/instagram-reels-transcript-scraper/reviews) — it takes 10 seconds and is the single biggest thing that helps other content researchers, social media marketers, agencies and short-form video tool builders find this Instagram reels transcript scraper.

A fast, production-grade **Instagram reels scraper with built-in AI transcription**. Give it any public Instagram username and it pulls the profile's newest reels and videos, then transcribes the spoken audio of each one into clean text. For every reel you get the post URL, direct MP4 video URL, thumbnail, caption, like and comment counts, post date — and a full **AI-generated transcript** with automatic language detection.

**No login, no cookies, no Instagram account, no password.** The scraper never touches your account, so there is zero risk of a ban or a lockout. Pass an array of usernames like `["natgeo", "nasa"]` and get back clean JSON, CSV or Excel ready to drop into a content dashboard, a repurposing pipeline, a brand-monitoring tool or a research dataset.

Built for content researchers, social media marketers, agencies repurposing short-form video into blogs and newsletters, accessibility teams generating captions, competitive-intelligence analysts, creator-economy tools and anyone doing Instagram reels research at scale.

### ✨ Why use this scraper

Most Instagram scrapers require your session cookies or a logged-in account — which puts your real Instagram profile at risk of rate-limits, checkpoints and bans. This actor takes a completely different route: it reads public profile data through a **no-login mirror** and pulls the reel's MP4 straight from Instagram's open CDN, then runs the audio through **Whisper** (via Groq's `whisper-large-v3-turbo`) for a transcript.

That means:

- **Zero account risk** — nothing is ever logged in. Your Instagram profile is never used, so it can't be flagged.
- **Spoken-word transcripts, not just captions** — the post caption is rarely the same as what's actually said in the reel. This actor gives you both.
- **Automatic language detection** — Whisper detects the spoken language per reel, or you can force a language code.
- **HTTP-pure enumeration** — profile reels are pulled from a JSON endpoint, so listing is fast and cheap.
- **Direct CDN downloads** — video bytes come straight from Instagram's CDN (no proxy bottleneck), so transcription stays fast.
- **Metadata-only mode** — turn transcription off to get reels + video URLs + captions + engagement at a fraction of the cost.

Non-speech reels (pure music, ambient nature footage) are detected and returned with an empty transcript — and you are **not charged** for transcribing them.

### 📤 Output fields

One item per reel, flat JSON. Maps cleanly to a BigQuery schema, a Postgres table or a Google Sheet.

#### Reel metadata

| Field | Type | Description |
|-------|------|-------------|
| `username` | string | The profile the reel belongs to |
| `shortcode` | string | Instagram post identifier |
| `url` | string | Direct link to the post on instagram.com |
| `type` | string | Media type reported by Instagram |
| `isVideo` | boolean | `true` for reels / videos |
| `videoUrl` | string | Direct MP4 URL on Instagram's CDN |
| `thumbnailUrl` | string | Cover image URL |
| `caption` | string | Post caption (HTML-decoded, emojis preserved) |
| `takenAt` | string | Human-readable post date (e.g. `"2 days ago"`) |
| `timestamp` | integer | Unix timestamp of the post |

#### Engagement metrics

| Field | Type | Description |
|-------|------|-------------|
| `likes` | string/int | Like count (e.g. `15300` or `"15.3k"`) |
| `comments` | string/int | Comment count |

#### Transcript

| Field | Type | Description |
|-------|------|-------------|
| `transcript` | string | AI transcript of the spoken audio (`null` if the reel has no speech) |
| `transcriptLanguage` | string | Detected language, e.g. `"English"` (`null` when no speech) |
| `transcriptError` | string | Populated only if a reel failed to download or transcribe |

### 🎯 Use cases

- **Content repurposing** — turn a creator's reels into blog posts, newsletters, X threads or LinkedIn carousels. The transcript is your raw script.
- **Competitive research** — pull a competitor's reels weekly, read what they actually say, and benchmark caption vs spoken messaging.
- **Accessibility & subtitles** — generate transcripts and captions for reels that ship without them.
- **SEO & content mining** — extract spoken keywords and topics from a niche's top reels to inform your own content calendar.
- **Sentiment & trend analysis** — feed transcripts into OpenAI, Claude or a local Llama to cluster themes, hooks and messaging across a category.
- **Training data** — short-form spoken-language transcripts in many languages are valuable fine-tuning and search data.
- **Brand monitoring** — track what sponsored creators say about your brand in video, not just in the caption.
- **Lead research for agencies** — audit a prospect's Instagram presence (posting cadence, engagement, messaging) before a pitch.

### 🚀 How to use

#### Mode 1 — reels + transcripts from one profile

```json
{
    "profiles": ["natgeo"],
    "maxPostsPerProfile": 30,
    "transcribe": true
}
````

#### Mode 2 — metadata only (cheapest, no transcription)

```json
{
    "profiles": ["nasa"],
    "maxPostsPerProfile": 50,
    "transcribe": false
}
```

#### Mode 3 — multiple profiles in one run

```json
{
    "profiles": ["natgeo", "nasa", "bbcearth"],
    "maxPostsPerProfile": 20,
    "transcribe": true
}
```

#### Mode 4 — force a transcript language

```json
{
    "profiles": ["selena"],
    "maxPostsPerProfile": 15,
    "transcribe": true,
    "language": "es"
}
```

#### Mode 5 — a blocked profile via residential proxy

```json
{
    "profiles": ["some_private_looking_profile"],
    "maxPostsPerProfile": 25,
    "transcribe": true,
    "proxyGroup": "residential"
}
```

### 📥 Input

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `profiles` | array | `[]` | Public usernames or profile URLs (`natgeo`, `@nasa`, `https://www.instagram.com/instagram/`) — required |
| `maxPostsPerProfile` | integer | `30` | Max reels per profile, newest first (1–1000) |
| `onlyVideos` | boolean | `true` | Skip photo posts; only return videos (required for transcripts) |
| `transcribe` | boolean | `true` | Generate an AI transcript per reel. Turn off for metadata-only (cheaper, faster) |
| `language` | string | — | ISO-639-1 code (`en`, `es`, `pt`…) to force the transcript language. Empty = auto-detect |
| `proxyGroup` | string | `datacenter` | `datacenter` (default, cheapest) or `residential` for profiles that get blocked |

### 📋 Output example

```json
{
    "username": "natgeo",
    "shortcode": "C8xKq2pN3aZ",
    "url": "https://www.instagram.com/p/C8xKq2pN3aZ/",
    "type": "video",
    "isVideo": true,
    "videoUrl": "https://scontent.cdninstagram.com/o1/v/t2/.../reel.mp4",
    "thumbnailUrl": "https://scontent.cdninstagram.com/.../cover.jpg",
    "caption": "Keep exploring! ABC News and National Geographic are taking you...",
    "likes": "15.3k",
    "comments": 210,
    "takenAt": "2 days ago",
    "timestamp": 1749250000,
    "transcript": "Can you guess where we are? We're about to unveil the seven natural wonders of America. From a geologist's standpoint, globally, this is geology in action...",
    "transcriptLanguage": "English",
    "transcriptError": null
}
```

Export the dataset as **JSON**, **CSV**, **Excel**, **XML**, **JSONL** or **HTML table** directly from the Apify console, or via the Apify API.

### 💻 Code examples

#### curl

```bash
curl -X POST 'https://api.apify.com/v2/acts/makework36~instagram-reels-transcript-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{
    "profiles": ["natgeo"],
    "maxPostsPerProfile": 30,
    "transcribe": true
  }'
```

#### Python (apify-client)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("makework36/instagram-reels-transcript-scraper").call(run_input={
    "profiles": ["natgeo", "nasa"],
    "maxPostsPerProfile": 30,
    "transcribe": True,
})
for reel in client.dataset(run["defaultDatasetId"]).iterate_items():
    if reel.get("transcript"):
        print(f"{reel['shortcode']}  [{reel['transcriptLanguage']}]  {reel['transcript'][:80]}")
```

#### Node.js (apify-client)

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

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

const run = await client.actor('makework36/instagram-reels-transcript-scraper').call({
  profiles: ['nasa'],
  maxPostsPerProfile: 20,
  transcribe: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.table(items.map((r) => ({
  code: r.shortcode, likes: r.likes, lang: r.transcriptLanguage,
})));
```

#### Export to CSV

From the run page → *Export* → *CSV*. Or via API:

```
https://api.apify.com/v2/datasets/DATASET_ID/items?format=csv&token=YOUR_TOKEN
```

#### Repurpose a reel into a blog post

```python
from apify_client import ApifyClient
import openai

client = ApifyClient("YOUR_APIFY_TOKEN")
oa = openai.OpenAI()

run = client.actor("makework36/instagram-reels-transcript-scraper").call(run_input={
    "profiles": ["my_competitor"],
    "maxPostsPerProfile": 10,
    "transcribe": True,
})

for reel in client.dataset(run["defaultDatasetId"]).iterate_items():
    if not reel.get("transcript"):
        continue
    resp = oa.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": f"Turn this reel transcript into a 200-word blog intro:\n{reel['transcript']}"}],
    )
    print(reel["url"], "\n", resp.choices[0].message.content, "\n")
```

#### Zapier / Make.com no-code

Both Zapier and Make have an official Apify integration. Trigger on a schedule, action "Run Apify Actor", pass this actor's name and your input JSON, then send the output into a Google Sheet, Airtable, Slack alert or Notion row.

### ⚡ Performance

- **~1 second** to download each reel's MP4 (direct from Instagram's CDN, no proxy)
- **~5–8 seconds per reel** end-to-end with transcription (download + audio extraction + Whisper)
- **Metadata-only mode** lists ~12 reels per profile page in a single request — near-instant
- **Up to 1,000 reels per profile** — raise `maxPostsPerProfile` as needed
- Non-speech reels are detected and skipped for transcription automatically

### 📊 Comparison

Several Instagram scrapers live on the Apify Store. Here's how this one stacks up on what actually matters for short-form video research.

| Feature | This scraper | Alternative A | Alternative B | Alternative C |
|---------|--------------|---------------|---------------|---------------|
| Needs login / cookies | **No** | Yes | Yes | Sometimes |
| Risk to your account | **None** | High | High | Medium |
| AI transcript of spoken audio | **Built-in (Whisper)** | No | Add-on ($) | No |
| Auto language detection | **Yes** | No | Partial | No |
| Direct MP4 video URL | **Yes** | Yes | No | Yes |
| Caption + likes + comments | **Yes** | Yes | Yes | Partial |
| Metadata-only mode (cheaper) | **Yes** | No | No | Partial |
| Multiple profiles per run | **Yes (array)** | Yes | Single | Yes |
| Max reels per profile | **1,000** | 200 | 100 | 500 |
| Code examples in README | **Python / Node / curl / OpenAI** | None | None | None |

The honest take: if you only need post URLs and never care about what's actually said in the video, a basic metadata scraper is fine. If you want the transcript — the real script of each reel — without ever logging in, this scraper bundles it all in one pass.

### 💵 Pricing

Pay-per-event — you only pay for what you pull, with no subscription and no monthly minimum.

| Event | Price | What you get |
|-------|-------|--------------|
| Actor start | **$0.005** per run | Pipeline initialization (once per run) |
| Reel scraped | **$0.003** per reel | Full metadata: caption, likes, comments, video URL, thumbnail |
| AI transcript | **$0.012** per reel | Whisper transcript — only charged when the reel actually has speech |

**A reel with a transcript = ~$0.015 all-in** (scrape + transcript). **Metadata-only** (`transcribe: false`) = **$0.003 per reel**.

| Volume | Metadata only | With transcripts |
|--------|---------------|------------------|
| 1,000 reels | ~$3 | ~$15 |
| 10,000 reels | ~$30 | ~$150 |

Apify gives every new user a **$5 free trial credit** — enough to transcribe ~330 reels while you evaluate. You're never charged for transcribing reels that have no speech (music-only / ambient).

### ❓ FAQ

**Do I need an Instagram account or login?**
No. The scraper never logs in and never uses cookies, so your account is never at risk. It only works with public profiles.

**Will this get my Instagram account banned?**
No — because your account is never used. Nothing about your real profile is touched.

**How accurate are the transcripts?**
Transcription uses OpenAI's Whisper (`large-v3-turbo`), one of the best speech-to-text models available. Accuracy depends on audio clarity. Reels with background music over speech transcribe less cleanly than clear narration.

**Why is `transcript` null on some reels?**
That reel has no spoken words — it's music-only or ambient footage. You are not charged for transcribing those.

**Can I transcribe in a specific language?**
Yes. Set `language` to an ISO code like `es`, `pt` or `fr` to force it. Leave it empty for automatic detection.

**Can I get reels without transcribing them?**
Yes. Set `transcribe` to `false` to get metadata, captions and video URLs only, at a much lower price.

**Can I download the actual video files?**
Each item includes a direct `videoUrl` to the MP4 on Instagram's CDN, which you can download yourself.

**A profile returns nothing — what do I do?**
Switch `proxyGroup` to `residential`. Some profiles or networks block datacenter traffic; residential IPs usually get through.

**Is scraping Instagram legal?**
Scraping publicly available data is generally permissible in most jurisdictions. Respect Instagram's [Terms of Use](https://help.instagram.com/581066165581870) and privacy regulations (GDPR, CCPA, LGPD). Consult legal counsel for your specific use case.

**Can I run this on a schedule?**
Yes. Apify's scheduler supports daily, weekly and custom cron expressions. Every run writes to a fresh dataset you can pull over the Apify API.

### 📝 Changelog

- **v0.1** (2026-06-07) — Initial release: no-login profile reel enumeration, direct-CDN MP4 download, Whisper transcription with auto language detection, metadata-only mode, datacenter / residential proxy support.

### 🔗 Related actors

- [YouTube Shorts Scraper](https://apify.com/makework36/youtube-shorts-scraper) — Shorts metadata, views, likes, dislikes, comments and music
- [TikTok Scraper](https://apify.com/makework36) — TikTok videos and creator analytics
- [Google Play Reviews Scraper](https://apify.com/makework36/play-store-reviews-scraper) — Android app reviews, ratings, locales
- [Telegram Channel Scraper](https://apify.com/makework36/telegram-channel-scraper) — public Telegram messages and metadata
- [Reddit MCP Server](https://apify.com/makework36/reddit-mcp-server) — Reddit data as MCP tools for Claude and Cursor

# Actor input Schema

## `profiles` (type: `array`):

Public Instagram usernames or profile URLs to scrape reels from. E.g. 'natgeo', '@nasa', or 'https://www.instagram.com/instagram/'.

## `maxPostsPerProfile` (type: `integer`):

Maximum number of reels/posts to fetch per profile (newest first).

## `onlyVideos` (type: `boolean`):

Skip photo posts; only return videos (required for transcripts).

## `transcribe` (type: `boolean`):

Download each reel and produce an AI transcript with Groq Whisper. Turn off to only get metadata + video URLs (cheaper).

## `language` (type: `string`):

ISO-639-1 code (e.g. 'en', 'es', 'pt') to force the transcript language. Leave empty for auto-detect.

## `proxyGroup` (type: `string`):

Apify Proxy group. 'datacenter' works for most profiles and is cheapest; switch to 'residential' only if a profile is blocked.

## Actor input object example

```json
{
  "profiles": [
    "natgeo"
  ],
  "maxPostsPerProfile": 30,
  "onlyVideos": true,
  "transcribe": true,
  "proxyGroup": "datacenter"
}
```

# 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 = {
    "profiles": [
        "natgeo"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("makework36/instagram-reels-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 = { "profiles": ["natgeo"] }

# Run the Actor and wait for it to finish
run = client.actor("makework36/instagram-reels-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 '{
  "profiles": [
    "natgeo"
  ]
}' |
apify call makework36/instagram-reels-transcript-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Reels Transcript Scraper (No Login)",
        "description": "Scrape Instagram reels from any public profile and get AI transcripts — no login, no cookies. HTTP-pure via mirror + Groq Whisper.",
        "version": "0.1",
        "x-build-id": "eEioW6rZlJdiw1M3v"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/makework36~instagram-reels-transcript-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-makework36-instagram-reels-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/makework36~instagram-reels-transcript-scraper/runs": {
            "post": {
                "operationId": "runs-sync-makework36-instagram-reels-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/makework36~instagram-reels-transcript-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-makework36-instagram-reels-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": [
                    "profiles"
                ],
                "properties": {
                    "profiles": {
                        "title": "Instagram profiles",
                        "type": "array",
                        "description": "Public Instagram usernames or profile URLs to scrape reels from. E.g. 'natgeo', '@nasa', or 'https://www.instagram.com/instagram/'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPostsPerProfile": {
                        "title": "Max reels per profile",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of reels/posts to fetch per profile (newest first).",
                        "default": 30
                    },
                    "onlyVideos": {
                        "title": "Only videos / reels",
                        "type": "boolean",
                        "description": "Skip photo posts; only return videos (required for transcripts).",
                        "default": true
                    },
                    "transcribe": {
                        "title": "Generate transcripts",
                        "type": "boolean",
                        "description": "Download each reel and produce an AI transcript with Groq Whisper. Turn off to only get metadata + video URLs (cheaper).",
                        "default": true
                    },
                    "language": {
                        "title": "Transcript language (optional)",
                        "type": "string",
                        "description": "ISO-639-1 code (e.g. 'en', 'es', 'pt') to force the transcript language. Leave empty for auto-detect."
                    },
                    "proxyGroup": {
                        "title": "Proxy type",
                        "enum": [
                            "datacenter",
                            "residential"
                        ],
                        "type": "string",
                        "description": "Apify Proxy group. 'datacenter' works for most profiles and is cheapest; switch to 'residential' only if a profile is blocked.",
                        "default": "datacenter"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
