# Instagram Video Transcript Scraper (`lance_api/instagram-video-transcript-scraper`) Actor

Transcribe public Instagram Reels and video posts into text, timestamped segments, WebVTT, and SRT. Add optional transcript translation, structured media metadata, and deduplicated batch processing for APIs, automation, and AI agents.

- **URL**: https://apify.com/lance_api/instagram-video-transcript-scraper.md
- **Developed by:** [LanceAPI](https://apify.com/lance_api) (community)
- **Categories:** Social media, AI, Videos
- **Features:** Limited permissions
- **Stats:** 729 total users, 88 monthly users, 99.9% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $2.50 / 1,000 transcriptions

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

Turn public Instagram Posts, Reels, Stories, and Highlights into **clean, machine-readable transcripts**. Add one or more URLs and receive **plain text, timestamped segments, WebVTT, or SRT**, with optional translation and structured media metadata.

#### Stories and Highlights

A Story URL transcribes that individual video Story. A Highlight URL processes the Stories inside the Highlight and transcribes video Stories; image-only Stories are skipped.

- Individual Story URL format: `https://www.instagram.com/stories/USERNAME/STORY_ID/`.
- Highlight URL format: `https://www.instagram.com/stories/highlights/HIGHLIGHT_ID/`.
- Each Highlight produces **one Dataset item**, with individual results in `stories[]`. Its top-level `transcript` and `translation` are null. Image Stories have `status: "image_only"` and no transcription charge.
- A Highlight is `partial_success` if some videos fail or an optional translation fails while at least one video succeeds. All-image Highlights return `AUDIO_SOURCE_NOT_FOUND`.
- Transcription minutes are rounded up **separately for each video Story** that completes valid speech processing, including videos with no detected speech. Optional translation follows the same per-transcript rules as individual videos. A Highlight is not a single combined transcript or a single minute charge.
- Stories may expire or become unavailable; links do not grant access to private content. Highlight processing covers the returned complete collection; incomplete collections are not reported as fully processed.

This is an **unofficial Actor** and is not affiliated with, endorsed by, or sponsored by Instagram or Meta.

#### At a glance

- **Input:** public Instagram Post, Reel, individual Story, or Highlight URLs.
- **Output:** the original-language transcript as text, timed segments, SRT, WebVTT, or any combination of these formats.
- **Optional translation:** keeps the original transcript and adds a translated version in the requested language.
- **Metadata:** can include caption, author, publication time, duration, engagement, and temporary media URLs.
- **Pricing:** transcription starts at **$5.00 per 1,000 started video minutes**; optional translation starts at **$0.10 per 1,000 source characters**, with lower prices for higher Apify membership tiers.
- **Resolution coverage:** Free and paid runs use the same regular media-resolution flow. Paid plans provide lower transcription and translation prices and higher batch limits.
- **Optional enhanced mode:** if regular media resolution fails, one additional recovery method can be tried before transcription. A successful enhanced recovery adds **$0.005** only when the transcript is successfully produced; unsuccessful attempts are not charged.
- **Limits:** **free plans: 10 URLs per run and 100 free items per day; paid plans: 200 URLs per run** with no daily free-usage limit. Profiles, profile feeds, private content, and image-only posts are not transcribed.

### What you get

- **AI transcription:** generate a new speech transcript from a public Instagram video or Reel.
- **Flexible formats:** return plain text, timestamped segments, WebVTT, SRT, or multiple formats together.
- **Optional translation:** preserve the original-language transcript and add a translated version.
- **Media metadata:** return caption, publication time, duration, author, engagement, and temporary media URLs when available.
- **Reliable batches:** normalize URLs, remove duplicates, and isolate item-level failures.
- **Structured results:** create one Dataset item per unique accepted URL, including actionable error records.
- **Flexible exports:** download Dataset results as JSON, JSONL, CSV, XML, RSS, or Excel.

**Important:** the Actor generates a new transcript from the video's speech. It does not copy Instagram subtitles or translate the Instagram caption.

### Quick start in Apify Console

1. Open the Actor and click **Try for free** or **Start**.
2. **Paste one or more public Instagram video URLs.**
3. **Choose the output formats:** text, timed segments, WebVTT, or SRT.
4. Optionally **enable translation** and select a target language.
5. Click **Start**, then open the **Dataset** tab to view or export the transcripts.

Example input:

```json
{
  "urls": [
    "https://www.instagram.com/p/DbbQB9tCgeO/"
  ],
  "formats": ["text", "segments", "vtt", "srt"],
  "translate": true,
  "targetLanguage": "en",
  "includeMediaMetadata": true
}
```

This public example URL has been verified with the Actor and can be run directly. You can replace it with another public Instagram Reel or video-post URL that you are permitted to process.

### Input reference

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `urls` | array of strings | Required | Public Instagram URLs using `/reel/`, `/reels/`, or `/p/`. A `/p/` URL must contain video or audio. Blank entries are ignored and canonical duplicates are processed once. |
| `enhancedMode` | boolean | `false` | Optional. Tries an additional media-recovery method only after regular resolution fails. A successful recovery adds $0.005 only when transcription succeeds; failed attempts are not charged. |
| `formats` | array | `['text', 'segments']` | Any combination of `text`, `segments`, `vtt`, and `srt`. Selecting more formats does not run transcription more than once. |
| `translate` | boolean | `false` | Creates a translated transcript in addition to the original transcript. |
| `targetLanguage` | string | `en` | Translation target. Suggested values: `en`, `es`, `pt`, `fr`, `de`, `it`, `ja`, `ko`, `zh-CN`, `zh-TW`, `ar`, `hi`, `ru`, `id`, `tr`, `vi`, `th`, `nl`, `pl`, and `uk`. Other supported language codes may work; an unsupported value produces an item-level translation error. |
| `includeMediaMetadata` | boolean | `true` | Includes available `content`, `media`, `author`, and `engagement` fields in successful results. |

#### Free-plan usage limits

| | Free plan | Paid plan |
|---|---|---|
| URLs per run | **10** | 200 |
| Free items per day | **100** | Not checked (no daily free-usage limit) |

- The daily allowance is counted per Apify user, per Actor, and includes every submitted unique URL even if that item later fails. A Highlight counts as one item, no matter how many videos it contains.
- It resets at **00:00 UTC (08:00 Beijing time)**, not at local midnight.
- If a free run exceeds either limit, the whole run stops before any item is processed: no Dataset rows are written, nothing is charged, and the run is marked `FAILED` with an explicit reason (`BATCH_LIMIT_EXCEEDED` or `FREE_USAGE_LIMIT_EXCEEDED`). Split the batch, wait for the reset, or upgrade to a paid plan.
- Paid plans skip the central free-usage check entirely. If the platform cannot determine the billing state, the run is treated as free.

The Input Schema lists `maxItems: 200` so paid runs are not blocked by the form. The free-plan cap of 10 is enforced at runtime, where the billing state is known.

Supported hosts are `instagram.com`, `www.instagram.com`, and `m.instagram.com`. Standard Reel/post URLs, individual Story and Highlight URLs, and username-prefixed Reel URLs such as `https://www.instagram.com/USERNAME/reel/SHORTCODE/` are accepted and normalized. Share redirect links, profile URLs, Explore pages, login pages, and private content are not supported.

### Output reference

Each unique URL normally creates one Dataset record. Duplicate and tracking-parameter variants of the same canonical Instagram URL are omitted. Items run concurrently, so Dataset order is not guaranteed; match results using `inputUrl` instead of array position.

Successful result example:

```json
{
  "inputUrl": "https://www.instagram.com/p/DbbQB9tCgeO/",
  "normalizedUrl": "https://www.instagram.com/p/DbbQB9tCgeO/",
  "success": true,
  "status": "success",
  "content": {
    "shortcode": "DbbQB9tCgeO",
    "type": "video",
    "caption": "Example Instagram caption",
    "publishedAt": "2026-01-15T10:30:00.000Z",
    "durationSeconds": 18.4
  },
  "media": {
    "videoUrl": "https://example-cdn.invalid/video.mp4",
    "audioUrl": "https://example-cdn.invalid/audio.mp4",
    "thumbnailUrl": "https://example-cdn.invalid/thumbnail.jpg",
    "mediaUrlsTemporary": true
  },
  "author": {
    "username": "example_creator",
    "displayName": "Example Creator",
    "verified": false
  },
  "engagement": {
    "viewCount": 1200,
    "playCount": 1320,
    "likeCount": 85,
    "commentCount": 7,
    "shareCount": null
  },
  "transcript": {
    "source": "ai",
    "language": "es",
    "characterCount": 46,
    "text": "Este es un ejemplo breve de una transcripción.",
    "segments": [
      {
        "id": 0,
        "start": 0,
        "end": 4.8,
        "text": "Este es un ejemplo breve de una transcripción."
      }
    ]
  },
  "translation": {
    "source": "translation",
    "language": "en",
    "characterCount": 40,
    "text": "This is a short example of a transcript.",
    "segments": [
      {
        "id": 0,
        "start": 0,
        "end": 4.8,
        "text": "This is a short example of a transcript."
      }
    ]
  },
  "error": null
}
```

Fields unavailable from Instagram are omitted rather than filled with invented values. `videoVariants`, `items`, or other media fields appear only when actual alternatives exist. The Actor does not save video or audio files to the Dataset; returned Instagram CDN URLs are temporary and can expire.

Engagement metadata always contains `viewCount`, `playCount`, `likeCount`, `commentCount`, and `shareCount`. Each field contains the independent value supplied by Instagram or `null` when unavailable. `shareCount` has no separate switch or charge. Missing values are never copied from another metric, estimated, or replaced with zero.

#### Transcript fields

| Field | Meaning |
| --- | --- |
| `source` | Transcript origin, such as `ai` or `translation`. No speech-model identifier is exposed. |
| `language` | Detected transcript language or requested translation language. |
| `characterCount` | Number of Unicode characters in the returned text, including spaces and punctuation. This works consistently for languages that do not separate words with spaces. Translation charges use the original transcript's character count. |
| `text` | Plain transcript text when `text` is selected. |
| `segments` | Timed segments with `id`, `start`, `end`, and `text` when `segments` is selected. Times are in seconds. |
| `vtt` | Complete WebVTT subtitle document as a string when `vtt` is selected. |
| `srt` | Complete SubRip subtitle document as a string when `srt` is selected. |

This Actor returns segment-level timestamps. It does not provide speaker diarization, speaker names, or word-level timestamps.

`content.durationSeconds` is the canonical media duration and is rounded to at most two decimal places. Transcript and translation objects do not repeat a separate duration because audio-track measurements can differ slightly from Instagram's video metadata.

### Translation behavior

Translation never replaces the original `transcript`.

- With `translate: false`, `translation` is `null`.
- Speech processing creates the original-language transcript exactly once. It is not called again for translation.
- For every cross-language request, including Chinese to English, the Actor translates the completed transcript and its timed segments in safe-size batches for long text.
- If the detected speech language and target language are the same, the Actor returns a translation object equivalent to the original transcript without making a translation request.
- If translation fails, the item has `status: 'partial_success'`, preserves the original transcript, sets `translation` to `null`, and returns an error object.

Only transcript text is translated. Instagram captions and other metadata remain in their original language.

### Status and error handling

| Status | Meaning |
| --- | --- |
| `success` | Media resolution and transcription completed; requested translation also completed when enabled. |
| `partial_success` | The original transcript succeeded but optional translation failed. |
| `invalid_url` | The URL is malformed or not a supported Instagram post/Reel URL. |
| `login_required` | Instagram required authentication for the requested public page. |
| `private_content` | The content is private or otherwise inaccessible. |
| `media_not_found` | No usable video or audio source was found. |
| `no_speech` | Speech processing completed but the media contained no detectable speech. This is a **successful** outcome, not a failure. |
| `transcription_failed` | Speech transcription could not be completed. |
| `error` | Another item-level error occurred. |

A `no_speech` record is a completed result, not an error:

```json
{
  "success": true,
  "status": "no_speech",
  "inputUrl": "https://www.instagram.com/reel/...",
  "transcript": null,
  "translation": null,
  "error": null
}
```

The completed speech processing is still billed with `transcript-minute` (one unit per started minute of audio). `no_speech` is only reported when the speech service confirms that transcription finished; a failed, timed-out or invalid response stays `transcription_failed` with `success: false`. Translation is never attempted for a `no_speech` result and no translation charge is made. Inside a Highlight, a `no_speech` Story counts as a successful Story.

If `error.code` is `MEDIA_TEMPORARILY_UNAVAILABLE` and `retryable` is `true`, the media source could not be resolved after automatic retries. Retry the URL later; the post may still be valid and publicly accessible.

Failed records include:

```json
{
  "success": false,
  "status": "media_not_found",
  "transcript": null,
  "translation": null,
  "error": {
    "code": "MEDIA_NOT_FOUND",
    "message": "No usable media source was found.",
    "retryable": false
  }
}
```

Normal media, transcription, and translation failures are isolated to their URL, so other batch items continue. Top-level input errors such as empty input, no valid formats, or an exceeded batch limit fail the run before Dataset processing.

### Run with JavaScript

Install the Apify API client:

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

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const input = {
  urls: ['https://www.instagram.com/p/DbbQB9tCgeO/'],
  formats: ['text', 'segments', 'srt'],
  translate: true,
  targetLanguage: 'en',
  includeMediaMetadata: true,
};

const run = await client
  .actor('lance_api/instagram-video-ai-transcript-scraper-api')
  .call(input);

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

### Run with Python

Install the Apify API client:

```bash
pip install apify-client
```

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])

run_input = {
    'urls': ['https://www.instagram.com/p/DbbQB9tCgeO/'],
    'formats': ['text', 'segments', 'srt'],
    'translate': True,
    'targetLanguage': 'en',
    'includeMediaMetadata': True,
}

run = client.actor('lance_api/instagram-video-ai-transcript-scraper-api').call(
    run_input=run_input
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Run with cURL

This synchronous endpoint waits for the run and returns Dataset items. Long videos can exceed HTTP client or endpoint timeouts; use the asynchronous Actor API for long-running production jobs.

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/lance_api~instagram-video-ai-transcript-scraper-api/run-sync-get-dataset-items' \
  -H 'Authorization: Bearer APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{
    "urls": ["https://www.instagram.com/p/DbbQB9tCgeO/"],
    "formats": ["text", "segments"],
    "translate": false,
    "includeMediaMetadata": true
  }'
```

For production, prefer sending the API token in an authorization mechanism supported by your client instead of placing it in command history or logs.

### Use with AI agents through MCP

This Actor can be discovered and called by MCP-compatible AI clients through the hosted Apify MCP server after the Actor is public, or while authenticated with an account that has access to it.

1. Connect your MCP client to `https://mcp.apify.com` using Streamable HTTP.
2. Sign in to Apify and approve access, or configure a secure Apify API token using your client's supported method.
3. Ask the agent to find and run `lance_api/instagram-video-ai-transcript-scraper-api`.
4. Provide the Actor input and ask the agent to retrieve the Dataset output.

The MCP tools commonly used are `search-actors`, `fetch-actor-details`, and `call-actor`. Running Actors and reading their storage requires authentication. Keep API tokens out of prompts, transcripts, source control, and screenshots.

Example agent request:

> Run lance_api/instagram-video-ai-transcript-scraper-api for this public Instagram Reel, return text and timestamped segments, translate the transcript to English, and summarize the result.

### Pricing

Transcription is billed per started media minute. Translation is billed separately per started 1,000 characters of the original transcript. Prices decrease with the Apify membership level:

| Service | Free | Starter | Scale | Business |
| --- | ---: | ---: | ---: | ---: |
| Transcription, per 1,000 started minutes | $5.00 | $3.50 | $3.00 | $2.50 |
| Translation, per started 1,000 source characters | $0.10 | $0.09 | $0.08 | $0.07 |
| Successful enhanced recovery | $0.005 | $0.005 | $0.005 | $0.005 |

For transcription, every started media minute is one unit: 60 seconds is one minute, while 61 seconds is two minutes. For translation, 1–1,000 source characters are one unit, while 1,001–2,000 characters are two units. Characters are counted as Unicode characters: each Chinese character or English letter counts as one, and spaces, punctuation, and numbers also count. Billing uses the original transcript length, not the translated output length.

Completed speech processing is billable even when no speech is detected, the media contains only music, or the result has no text or segments. The same pricing applies when a previously completed result is reused. Each started media minute is charged, with a minimum of one minute when duration is unavailable. Failed media resolution, speech-service requests that do not complete processing, removed duplicates, and failed translations do not create a charge for the failed service. If transcription succeeds but optional translation fails, only transcription remains billable. Requesting multiple output formats does not multiply charges.

Free and paid runs use the same regular media-resolution flow. Enhanced mode is optional and off by default; it runs only after regular resolution fails. The additional **$0.005 enhanced-result charge applies only when enhanced recovery leads to a successful transcript**. Invalid, private, and confirmed removed content remains unsupported.

### Use cases

- Generate SRT or WebVTT subtitles for permitted Instagram videos
- Index spoken content for semantic search or retrieval-augmented generation
- Create multilingual research datasets while retaining original-language text
- Analyze messaging, topics, and quotes across batches of public Reels
- Feed timestamped transcripts into editorial, moderation, accessibility, or review workflows
- Let AI agents retrieve and reason over spoken Instagram content through MCP

### Limits and practical notes

- Public Instagram Reel and video-post URLs only; profile and profile-post collection are not included.
- Image-only posts, private or removed content, expired/unavailable Stories, and unsupported redirect/share URLs cannot be transcribed.
- Instagram may require login, rate-limit access, change page data, or temporarily withhold media URLs.
- CDN media URLs are temporary and should not be treated as permanent download links.
- Transcription quality depends on audio clarity, music, overlapping speakers, accents, and background noise.
- Very long or high-volume jobs take longer. The synchronous REST endpoint can time out after 300 seconds even if an asynchronous run would continue normally.
- No verified public maximum media duration or media-file-size guarantee is enforced by this Actor. Test representative long videos before relying on them in production.
- Free-plan runs are capped at 10 URLs per run and 100 free items per day per Apify user, resetting at 00:00 UTC (08:00 Beijing time). See [Free-plan usage limits](#free-plan-usage-limits).
- Dataset item order is not guaranteed for batches.

### Responsible use

Use this Actor only for content you are legally permitted to access and process. Respect privacy, copyright, contractual restrictions, Instagram's terms, and applicable laws. Do not use session credentials to access private content, bypass access controls, or process another person's account without authorization.

Never publish, log, email, or include an Instagram session value or Apify API token in a support request. Rotate any credential immediately if it is exposed.

### FAQ

#### Does this Actor scrape profiles or all posts from a profile?

No. It accepts individual public Reel or video-post URLs only.

#### Does it download the media file into Apify storage?

No. It returns structured results and, when available, temporary Instagram CDN URLs. It does not save video or audio files to the Dataset.

#### Why is the Instagram caption missing?

Metadata is best effort. Instagram may omit or restrict caption data, and `includeMediaMetadata: false` intentionally removes metadata from successful results.

#### Why are `videoVariants` or other media arrays missing?

They are emitted only when the resolved post contains genuine alternatives. Empty diagnostic arrays are not added to the public result.

#### Can I request only SRT or WebVTT?

Yes. Select only the formats you need. The Actor still performs one transcription pass.

#### What happens when translation fails?

The original transcript is preserved, the item becomes `partial_success`, and the translation error is returned without a successful translation event.

#### Why did a valid-looking URL return `login_required` or `media_not_found`?

The post may be private, removed, image-only, region- or age-restricted, temporarily unavailable, or gated by Instagram. Confirm that the complete URL opens as a public video in a logged-out browser, then retry later.

#### Are duplicate URLs charged or returned twice?

Canonical duplicates are processed once and omitted from additional Dataset records. Tracking parameters do not create a second job for the same post.

#### Does the Actor expose its speech model or processing diagnostics?

No. Public output focuses on the transcript, requested formats, usable metadata, status, and actionable errors.

### Support

For help, open an issue on the Actor page or email lanceapi2026@hotmail.com.

Include the Actor run ID, input URL with sensitive query data removed, expected behavior, actual status, and a short reproducible description. Do not send Apify tokens, Instagram session IDs, passwords, cookies, or other credentials.

# Actor input Schema

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

Public Post, Reel, individual Story, or Highlight URLs. A Highlight returns one result containing stories; each video is transcribed separately and images are skipped. Free plans: at most 10 URLs per run and 100 free items per day (resets at 00:00 UTC / 08:00 Beijing time). Paid plans: up to 200 URLs per run, with no daily free-usage limit.

## `includeMediaMetadata` (type: `boolean`):

Include resolved post, media, author, and engagement data.

## `enhancedMode` (type: `boolean`):

If regular media resolution fails, try an additional low-frequency recovery method before transcription. The extra $0.005 charge applies only when enhanced recovery leads to a successful transcript; unsuccessful attempts are not charged.

## `formats` (type: `array`):

Choose which transcript fields to return.

## `translate` (type: `boolean`):

Keep the original transcript and add a translated version.

## `targetLanguage` (type: `string`):

Used only when translation is enabled.

## Actor input object example

```json
{
  "urls": [
    "https://www.instagram.com/reel/DcvbKxGlSm7/?utm_source=ig_web_copy_link&igsi=MzRlODBiNWFlZA=="
  ],
  "includeMediaMetadata": true,
  "enhancedMode": false,
  "formats": [
    "text",
    "segments"
  ],
  "translate": false,
  "targetLanguage": "en"
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `summary` (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.instagram.com/reel/DcvbKxGlSm7/?utm_source=ig_web_copy_link&igsi=MzRlODBiNWFlZA=="
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lance_api/instagram-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 = { "urls": ["https://www.instagram.com/reel/DcvbKxGlSm7/?utm_source=ig_web_copy_link&igsi=MzRlODBiNWFlZA=="] }

# Run the Actor and wait for it to finish
run = client.actor("lance_api/instagram-video-transcript-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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.instagram.com/reel/DcvbKxGlSm7/?utm_source=ig_web_copy_link&igsi=MzRlODBiNWFlZA=="
  ]
}' |
apify call lance_api/instagram-video-transcript-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lance_api/instagram-video-transcript-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/ZuAmrsZhEP0VQ7E9o/builds/AhYueh52sd7XkVqhN/openapi.json