# Instagram Video AI Transcript Scraper API (`lance_api/instagram-video-ai-transcript-scraper-api`) 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-ai-transcript-scraper-api.md
- **Developed by:** [LanceAPI](https://apify.com/lance_api) (community)
- **Categories:** Social media, AI, Videos
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

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

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

#### At a glance

- **Input:** individual public Instagram Reel or video-post 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.
- **Limits:** up to **5 unique URLs on non-paying runs** or **100 on paying runs**. Profiles, profile feeds, Stories, private content, and image-only posts are not supported.

### 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. |
| `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. |
| `sessionid` | string | None | Optional sensitive session value for public content that Instagram places behind a login check. It does not grant access to private content. The input field is secret and the value is not written to Actor results or normal logs. |

The input Schema allows up to 100 URLs. The current runtime limit is 5 URLs for non-paying runs and 100 only when Apify identifies the run as paying. If the applicable limit is exceeded, the run stops with `BATCH_LIMIT_EXCEEDED` before processing items.

Supported hosts are `instagram.com`, `www.instagram.com`, and `m.instagram.com`. Standard Reel/post URLs and username-prefixed Reel URLs such as `https://www.instagram.com/USERNAME/reel/SHORTCODE/` are accepted and normalized. Share redirect links, profile URLs, Stories, 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`.
- With `targetLanguage: 'en'`, the Actor first requests direct speech translation while preserving the original-language transcript. If the returned result is empty, unchanged, or not identified as English, it automatically translates the completed transcript instead.
- For other target languages, the Actor first creates the original transcript and then translates its timed segments in safe-size batches for long text.
- If the detected speech is already English and English is requested, the Actor still returns a translation object equivalent to the original transcript.
- 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` | The media was available but contained no detectable speech. |
| `transcription_failed` | Speech transcription could not be completed. |
| `error` | Another item-level error occurred. |

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 |

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.

Failed media resolution, no-speech results, failed transcriptions, 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.

### 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 posts, removed posts, 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.
- 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 Instagram post or Reel URLs.

## `sessionid` (type: `string`):

Used only for this run and never stored in results or logs.

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

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

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

## Actor input object example

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

# 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/DbqnhhDR7rs/?utm_source=ig_web_copy_link&igsh=NTc4MTIwNjQ2YQ=="
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lance_api/instagram-video-ai-transcript-scraper-api").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "urls": ["https://www.instagram.com/reel/DbqnhhDR7rs/?utm_source=ig_web_copy_link&igsh=NTc4MTIwNjQ2YQ=="] }

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

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "urls": [
    "https://www.instagram.com/reel/DbqnhhDR7rs/?utm_source=ig_web_copy_link&igsh=NTc4MTIwNjQ2YQ=="
  ]
}' |
apify call lance_api/instagram-video-ai-transcript-scraper-api --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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