# Instagram Transcript Scraper & API: Reels & Video to Text (`quarra/instagram-transcript-scraper`) Actor

Turn Instagram Reels, video posts and carousels into text, from links or an account's latest videos. Plain text with timestamps, SRT and VTT, the language spoken, and the post's details. No login. Music-only reels and videos without speech are not charged.

- **URL**: https://apify.com/quarra/instagram-transcript-scraper.md
- **Developed by:** [Quarra Labs](https://apify.com/quarra) (community)
- **Categories:** Social media, Videos, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 transcripts

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

## Instagram Transcript Scraper: Reels and Videos to Text

Turn Instagram Reels and videos into text, without an account or API key. Paste reel or post links, or give an
account, and each video comes back with its transcript as plain text and as timestamped segments, its language,
optional SRT and WebVTT subtitle files, and the post's metadata (account, date, likes, comments, caption, sound).

Two things you would otherwise check by hand: reels that are only music come back as a free `no_speech` record
instead of a made-up transcript, and every video that cannot be transcribed (deleted, age-restricted, photo post)
gets a free record that says why. You pay only for transcripts delivered.

### What we measured

On the Apify platform on 8 October 2026, with the default settings, on 43 links taken from Reddit posts that shared
Instagram reels, plus two accounts:

- **25 transcripts** in 6 languages (English, Spanish, French, Russian, Portuguese, Hindi), average length 59 seconds.
- **17 reels without clear speech** (music, sounds, no audio track, loops such as "Peppino, Peppino, Peppino", one
  uncertain language) came back as free `missing` records: none was charged.
- **5 links** were deleted posts or age-restricted reels: free `error` records with the reason.
- 47 records in 2 minutes 30. The default input (one reel) runs in about 6 seconds.

Running the same input again (17 records: Hindi reels, two Indian news accounts, unknown accounts, damaged links) gave
the same verdict on every record, and Hindi came back in Hindi (Devanagari) every time (5 of 5 on the
hardest reel).

Speech-to-text runs on third-party AI providers: OpenAI's Whisper models (large-v3 and large-v3 turbo) run by Groq
for most videos, and ElevenLabs Scribe, a stronger model, to settle the language when hints disagree and as a
backup. The audio is sent to them only to be transcribed. ElevenLabs stores each transcript on its side: we delete
it as soon as we have read it and check that it is gone (we read it again and get "not found"); if a deletion cannot
be confirmed before the run ends, the run log says so.

Whisper is known to invent short phrases on music ("Thank you.", "Music", "Bye.", subtitle credits). We measured
that on 170 reels and TikTok videos and filter it: a phrase the model is not confident about, a known phantom
phrase, or a few words spread over a long stretch of music are not speech. A video whose speech is all filtered out
is `missing` with `missingReason: "no_speech"`, free. We never sell part of a video as its transcript: when the
filter has to leave out more than 20% of the speech (the model looped or was unsure over that part), the video is
`missing` with `missingReason: "incomplete_transcript"`, free. The same holds when Whisper hits its own limit: its
output is capped for each 30 seconds of audio, and dense speech in some scripts (Gujarati, Telugu, fast Hindi)
needs more, so the end of each 30 seconds is silently dropped. We detect it on every window; such a reel goes to a
second, stronger speech-to-text model, and if no model writes it in full, it is a free `incomplete_transcript`,
never a charged fragment. Loops are measured per character, so Hindi, Urdu, Arabic or Tamil text is judged like
English (until 8 October 2026 a byte-based measure dropped correct Hindi sentences as "loops").

### What you can transcribe

| Input | Examples | What you get |
|---|---|---|
| Reels | `https://www.instagram.com/reel/DbIdlf0j6uA/`, `/reels/…`, `/{account}/reel/…` | that reel |
| Video posts | `https://www.instagram.com/p/…`, `/tv/…`, `instagr.am/p/…`, share links (`/share/…`) | the video; for a carousel, each of its videos |
| Accounts | `@natgeo`, `https://www.instagram.com/natgeo/`, `…/natgeo/reels/` | the account's latest videos |

Mix them in one run. A video found in two inputs (a link and an account) is transcribed and charged once.

**Accounts:** without signing in, Instagram shows the 12 latest posts of an account (pinned posts first) and no more;
we read those, skip the photo posts, and transcribe up to `maxVideosPerAccount` videos. For older videos, paste their
links.

**Carousels:** each video of a carousel is its own record (`carouselIndex` 1, 2…), charged as one transcript each.
Photo carousels do not take the place of a video: the account's list is read on until `maxVideosPerAccount` videos
are found, and if the 12 posts Instagram shows do not hold that many, the run says so in its status.

### Languages

Whisper's fast model sometimes mistakes one language for another; on Hindi reels it then writes an invented English
"translation", or Hindi in the Urdu script. We do not trust a single detection when anything says otherwise:

1. Hints: the caption written by the author (its script: Devanagari, Hangul, Japanese kana…, or Hindi written in
   Latin letters, "Hinglish": "ke", "se", "mein", "nahi", "lekar"…). English is not used as a hint (Whisper only
   ever translates into English, so an English hint cannot catch a translation).
2. When a hint and the detection disagree, a stronger speech-to-text model settles the language and transcribes the
   reel. Hindi and Urdu reels (by their caption) go to it directly, and so does any reel the fast model hears as
   Hindi, Urdu or Punjabi without a hint (it mixes the three up). On 120 replayed decisions (8 October 2026) the
   ElevenLabs referee made no wrong call; when it is not available for a reel, Whisper large-v3 settles the language
   and must agree, or nothing is sold. The referee is paid per use, so a run calls it only once the transcripts it
   has delivered cover the cost: in a larger run such a reel waits for the others; sent alone, or in a run that
   delivers little, it can come back as a free `uncertain_language` record.
3. Hindi and Urdu are one spoken language in two scripts: the caption's script decides.
4. If the language still cannot be settled, the reel comes back as a free `uncertain_language` record, never as a
   charged guess, and never as a translation.

`language` is a preference, never an instruction: it changes neither the models used nor the number of passes, and
never forces a translation. A reel in English with `language: "fr"` comes back in English with
`requestedLanguageFound: false`. With `language` set to Hindi, Urdu or Punjabi, a reel that Whisper hears as English
(with no caption saying otherwise) comes back as a free `uncertain_language` record: on those languages Whisper
sometimes writes an English translation instead of what was said.

### Output

One record per video. A transcript (`status: "ok"`), shortened here:

```json
{
  "status": "ok",
  "platform": "instagram",
  "videoId": "DbIdlf0j6uA",
  "url": "https://www.instagram.com/reel/DbIdlf0j6uA/",
  "carouselIndex": null,
  "author": {
    "username": "natgeo",
    "fullName": "National Geographic",
    "id": "787132",
    "isVerified": true,
    "url": "https://www.instagram.com/natgeo/"
  },
  "caption": "Describe Pompeii: Out of Time in 3 words? It's Now Streaming. …",
  "hashtags": ["pompeiioutoftime"],
  "publishedAt": "2026-07-23T13:00:03Z",
  "isReel": true,
  "viewCount": null,
  "likeCount": 28343,
  "commentCount": 320,
  "sound": { "title": "Original audio", "author": "natgeo", "isOriginal": true },
  "durationSeconds": 36.2,
  "language": "en",
  "transcriptSource": "speech_to_text",
  "isAutoGenerated": true,
  "hasSpeech": true,
  "transcript": "Three words to describe this series about Pompeii. History. There's something you're going to want to see. …",
  "segments": [
    { "start": 0, "end": 4, "duration": 4, "text": "Three words to describe this series about Pompeii." },
    { "start": 4, "end": 5, "duration": 1, "text": "History." }
  ],
  "segmentCount": 14,
  "wordCount": 70,
  "characterCount": 432,
  "billedMinutes": 1,
  "input": "https://www.instagram.com/reel/DbIdlf0j6uA/",
  "inputType": "video",
  "position": null,
  "scrapedAt": "2026-10-08T01:07:51.288Z"
}
```

A video without a transcript comes back as a free record that holds the reason and nothing else (no account, counts
or caption: those come with transcripts):

```json
{
  "status": "missing",
  "platform": "instagram",
  "videoId": "DeLb7gYJNiV",
  "url": "https://www.instagram.com/reel/DeLb7gYJNiV/",
  "missingReason": "no_speech",
  "message": "no speech detected (music, sounds or silence); free",
  "input": "https://www.instagram.com/reel/DeLb7gYJNiV/",
  "inputType": "video"
}
```

#### Fields that need a word of explanation

- `status`: `ok` (transcript, charged), `missing` (the video exists but has nothing to transcribe: `no_speech`,
  `incomplete_transcript`, `no_audio`, `photo_post`, or `too_long` past your limit; free) or `error` (the link could
  not be read; free).
- `errorCode` and `retryable`: `not_found`, `age_restricted`, `invalid_url`, `account_not_found`, `account_private`,
  `account_empty` are final; `private` (Instagram showed the post as private), `blocked`,
  `network`, `transcription_capacity` and `transcription_failed` are worth retrying later (`retryable: true`).
- `language`: ISO 639-1 code of the language spoken and transcribed. We never translate: if you set `language` and a
  video is in another language, you get the language actually spoken, with `requestedLanguageFound: false`.
- `segments`: `start`, `end` and `duration` in seconds. `includeSrt` and `includeVtt` add ready-to-save `.srt` and `.vtt` files.
- `viewCount`: Instagram hides play counts from visitors who are not signed in, so it is usually null.
- `filteredSegments`: segments of the raw speech-to-text output left out of the transcript as non-speech (a
  "Thank you." over silence, a "\[Music]" tag, a model loop); minutes are billed on the video's length as usual.
  A model loop or an unsure passage that held more than 20% of the speech makes the video a free
  `incomplete_transcript` record instead.
- `billedMinutes`: the started minutes of video billed for this transcript (a 36-second reel is 1 minute).
- `input` and `position`: which of your inputs produced the record, and the rank of the video in an account's list.
  Records are written as each video finishes: sort by `input` and `position` for the source's order.

The dataset has three views: Overview, Transcripts and Video details. **For a spreadsheet, export the Transcripts
view as Excel (XLSX)**: one row per video, and Excel treats every cell as text. The full record with `segments` does
not fit a spreadsheet (one column per segment), and a CSV opened in Excel may read a caption that starts with `=`,
`+`, `-` or `@` as a formula: open CSV files as text, or prefer XLSX or JSON. Excel also cuts a cell after 32,767
characters (about 35 minutes of speech). Control characters and text-direction marks are removed from captions and
transcripts. The run's summary is the `OUTPUT` record of the default key-value store: per input, videos, transcripts,
missing, errors and duplicates, plus speech-to-text and network statistics.

### Input examples

The latest videos of two accounts and two reels, with subtitle files:

```json
{
  "urls": ["@natgeo", "https://www.instagram.com/bbcnews/", "https://www.instagram.com/reel/DbIdlf0j6uA/"],
  "maxVideosPerAccount": 6,
  "includeSrt": true
}
```

Text only, Spanish reels, at most 200 transcripts:

```json
{
  "urls": ["https://www.instagram.com/reel/…/", "https://www.instagram.com/reel/…/"],
  "language": "es",
  "transcriptFormat": "text",
  "maxItems": 200
}
```

### Pricing

Pay per result: **$0.001 per transcript plus $0.0045 per started minute of video** transcribed, plus a **start fee
of $0.004 per GB of memory per run** ($0.004 at the default 512 MB). A 40-second reel costs $0.0055, a 2-minute video
$0.010. Videos without speech, incomplete transcripts, deleted or private posts, errors and duplicates are free.
Platform usage is included.

| Apify plan | Per transcript | Per started minute |
|---|---|---|
| Free | $0.001 | $0.0045 |
| Bronze | $0.001 | $0.0040 |
| Silver | $0.001 | $0.0036 |
| Gold and above | $0.001 | $0.0034 |

Your maximum charge
per run is never exceeded: the length of each video is read before it is transcribed, and the run stops at the last
transcript it can charge and says so in its status. `maxItems` caps the transcripts of a run: ask for 10, get 10.

Free records are a by-product, not a product: a run stops, and says why, once 100 videos or inputs (an unknown
account counts) plus 2 per transcript have given no transcript, or once 15 minutes of audio plus 2 per billed minute
have been transcribed for nothing (music-only reels); audio we could not send because our capacity was used up
does not count. `maxDurationMinutes` (default 30, at most 60) skips longer videos
before anything is transcribed. A single video that would cost more than what is left of your maximum charge gets a
free `over_budget` record and the run goes on with cheaper ones.

### Use cases

- Content research: what creators in a niche say in their reels, searchable and quotable.
- Repurposing: turn your own reels into captions, blog posts, newsletters and subtitles.
- LLM pipelines: summaries, topic tagging, hooks and scripts analysis on hundreds of reels.
- Accessibility: SRT and VTT files to edit or upload.

### Limits

- **Speech or music.** The speech-to-text service does not return exactly the same text on every pass over the same reel;
  on clear speech the difference does not matter, on music it can. So we keep a margin: a reel is charged only when
  its speech is clear (enough words, good confidence, no loops such as "wrestles, wrestles, wrestles"); everything in
  between comes back as a free `no_speech` record. Clearly sung lyrics still count as speech. Short or distant speech
  over loud music (a slogan shouted once) may be classed as `no_speech`.
- **Accounts:** the 12 latest posts only (Instagram's limit without an account). No stories, highlights, tagged posts,
  hashtags or search.
- **Private accounts and age-restricted reels** need a signed-in account; we do not use accounts, so they come back
  as free `error` records.
- Instagram does not show captions (subtitles) to visitors: every video goes through speech-to-text.
- **Speed.** Our speech-to-text capacity is shared fairly between runs and paced: count about 3 seconds per video on
  large runs. If it is temporarily used up, the videos that need it get free `transcription_capacity` records
  (`retryable: true`, "temporarily used up, retry later") and the status says when to retry; they never count
  against your run's limits and never make it fail.
- Longest video: 60 minutes (`maxDurationMinutes`, 30 by default).
- **Connection:** keep the default (automatic). If you set your own connection and it refuses everything, the run
  stops at once with a free `proxy_failed` record per input and says so.

### Memory and speed

512 MB is the default and the best setting: the run waits on speech-to-text, not on memory, and the Actor uses
under 100 MB. More memory does not make it faster (the maximum is 1 GB).

### FAQ

**Is it legal to scrape Instagram transcripts?** This Actor reads only public posts, the way a visitor who is not
signed in sees them, and accepts no Instagram terms on your behalf. In *Meta v. Bright Data* (N.D. Cal., January
2024\) the court found that collecting public data while logged out did not breach Meta's terms; it is a first-instance
decision, not binding everywhere. Transcripts reproduce what people say, which may be protected by copyright and may
contain personal data: check that your use (research, analysis, quotation, accessibility) is allowed where you are,
and handle personal data under the rules that apply to you (GDPR in Europe). We keep nothing after the run;
the transcripts ElevenLabs stores are deleted during the run and the deletion is checked (the run log says so
if one could not be confirmed).

**Do I need an Instagram account or any setup?** No. Keep the default connection: its cost is included in the
price.

**Why is a reel "no_speech" when I hear someone?** Check `OUTPUT.speechFilter` for that video: very short or very
uncertain speech over music is filtered. If a reel with clear speech comes back `no_speech`, open an issue with the
link: we answer within 48 hours.

**What happens when Instagram changes something?** The Actor runs every day on known reels, so we see a change
before you do. A page Instagram refuses is retried automatically, and a run that fails on our side ends as Failed
and charges no transcript.

# Actor input Schema

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

One per line: reel or post URLs (instagram.com/reel/…, /p/…, /tv/…, share links) or accounts (@name or profile URL) for their latest videos.

## `maxVideosPerAccount` (type: `integer`):

For accounts: how many of their latest videos to transcribe. Without an account, Instagram shows the 12 latest posts (pinned ones first); photo posts among them are skipped.

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

Optional. The language you expect, as a code or a name (en, es, hi, English…). It is a preference, not an instruction: each video comes back in the language actually spoken, never translated (requestedLanguageFound: false when it differs). With Hindi, Urdu or Punjabi, a video heard as English is a free uncertain_language record (the model may have translated it). Empty: detected for each video.

## `transcriptFormat` (type: `string`):

transcript is the whole text in one string; segments is a list of {start, end, duration, text} in seconds.

## `includeSrt` (type: `boolean`):

Add an srt field: the transcript as a ready-to-save .srt subtitle file.

## `includeVtt` (type: `boolean`):

Add a vtt field: the transcript as a ready-to-save .vtt subtitle file.

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

Longer videos get a free too_long record instead of a transcript. Their length is read before anything is transcribed.

## `maxItems` (type: `integer`):

Optional cap for the whole run, counted in charged transcripts. Respected exactly. Free records (no speech, deleted, private) do not count; they are bounded separately (100 plus 2 per transcript).

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

Connection. Keep the default (automatic). Costs are included in the price.

## Actor input object example

```json
{
  "urls": [
    "https://www.instagram.com/reel/DbIdlf0j6uA/"
  ],
  "maxVideosPerAccount": 12,
  "transcriptFormat": "both",
  "includeSrt": false,
  "includeVtt": false,
  "maxDurationMinutes": 30,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Every video: transcript, segments, metadata, and the free missing/error records with their reason.

## `overview` (type: `string`):

One line per video: status, account, language, words, reason.

## `summary` (type: `string`):

Per-input counts, videos without speech, errors, speech-to-text and network statistics.

# 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/DbIdlf0j6uA/"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("quarra/instagram-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/DbIdlf0j6uA/"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("quarra/instagram-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/DbIdlf0j6uA/"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call quarra/instagram-transcript-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,quarra/instagram-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/WzpT523mQ51vbK5MH/builds/cTPD9JaQZNQO8bMRW/openapi.json
