# Instagram Reels Scraper — Plays, Likes & Comments by Profile (`foxlabs/instagram-reels-scraper`) Actor

The reels of public Instagram profiles in the order of the Reels tab (pinned first, then newest), each with its plays, likes and comment count and how it did against the profile's usual. Caption, exact time, duration and music on request. Only-new mode for monitoring. No login, no cookies.

- **URL**: https://apify.com/foxlabs/instagram-reels-scraper.md
- **Developed by:** [Berkan Kaplan](https://apify.com/foxlabs) (community)
- **Categories:** Social media, Videos
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 reels

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/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 Reels Scraper — Plays, Likes & Comments by Profile 🚀

**foXLabs Instagram series:** [Bulk Profile](https://apify.com/foxlabs/instagram-profile-scraper) · [Profile Posts](https://apify.com/foxlabs/instagram-profile-posts-scraper) · [Post Details](https://apify.com/foxlabs/instagram-post-details-scraper) · [Comments](https://apify.com/foxlabs/instagram-comments-scraper)

🎉 Give this Actor Instagram **profiles** and it returns the reels of each profile's Reels tab, one row per reel: **plays, likes, comment count**, an approximate time, the cover image, and how the reel did against what's usual for that profile. On request it reads each reel by itself: caption, exact time, duration, music, video address, co-authors, topics.

**It reads only what a signed-out visitor sees.** No login, no cookies, nothing from your own Instagram account. Not affiliated with Instagram or Meta.

### 🔍 What is the Instagram Reels Scraper — and when should you use it?

Give this Actor profiles and it returns their reels with play/like/comment counts and a performance score — for content strategists, influencer marketing and trend research.

**Use it when you need:** a profile's reels with plays and engagement; how a reel did vs the profile's median; or reel details (caption, music, duration, co-authors).

**Use something else when:** you want profile-level metrics → [Bulk Profile](https://apify.com/foxlabs/instagram-profile-scraper); photo posts and carousels → [Profile Posts](https://apify.com/foxlabs/instagram-profile-posts-scraper); a post's comments → [Comments](https://apify.com/foxlabs/instagram-comments-scraper).

### 🤖 Use with AI agents

**Already on the Apify MCP server?** Ask for this Actor by name: `foxlabs/instagram-reels-scraper`. An agent can discover it, run it and read the dataset over MCP; the Actor is built to run in Standby mode for on-demand lookups.

Otherwise paste this into Claude, ChatGPT, Cursor or any MCP-enabled assistant:

```
I want Instagram reels by profile using the Apify Actor
`foxlabs/instagram-reels-scraper`.

Input: `profiles` is a list of usernames/URLs; `maxReelsPerProfile` caps rows; `includeDetails`
reads each reel (caption, music, duration). Each row has playCount, likeCount, commentCount,
profileMedianPlays and playsVsProfileMedian.

Start with:
{ "profiles": ["natgeo"], "maxReelsPerProfile": 24 }

Ask me which profiles to analyse, run the Actor, then rank the reels by plays.
```

The machine-readable API, MCP config and OpenAPI definition live at `apify.com/foxlabs/instagram-reels-scraper.md`.

### 📋 Overview

Everything you need to turn a profile's Reels tab into clean, structured data — plays, engagement and a performance score — in one Actor, with no login, cookies or account.

**Why teams pick this Actor:**

- ✅ **Plays from the tab** — the real tile play figure, not the embed page's lower "views".
- 📊 **Performance score** — `playsVsProfileMedian` shows how a reel did vs the profile's usual.
- 🎬 **Optional details** — caption, exact time, duration, music, co-authors, topics, video address.
- 🎯 **Honest** — unknown is `null` never 0; a hidden like count stays `null`; limits spelled out.
- 💰 **Pay only for results** — `reel` / `reel-detailed` events per row; status rows free.
- 🤖 **Agent-ready** — MCP + Standby.

### ✨ Features

- 🔍 **Reels by profile** — username/@handle/URL, up to 10,000 profiles a run.
- ▶️ **Metrics** — playCount, likeCount (+ `likesHidden`), commentCount, approximate time, cover image, pin/position.
- 📈 **Benchmark** — `profileMedianPlays` + `playsVsProfileMedian`.
- 🎞️ **Details (opt-in)** — caption, hashtags, mentions, duration, video URL, music, co-authors, tagged users, topics, location.
- 🔁 **Only-new lists** for recurring runs.

### 🎬 Quick Start

```bash
curl -X POST "https://api.apify.com/v2/acts/foxlabs~instagram-reels-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"profiles": ["natgeo"], "maxReelsPerProfile": 24}'
```

### 🚀 Getting Started (3 steps)

1. **List your profiles** — one per line: `natgeo`, `@natgeo` or a URL.
2. **Set the cap & depth** — `maxReelsPerProfile`; turn on `includeDetails` for caption/music/duration.
3. **Run and export** — get a clean dataset as JSON, CSV or Excel.

### 📥 Input

| Field | Default | What it does |
|---|---|---|
| `profiles` | required | Usernames, @handles or URLs, one per line (up to 10,000); a profile named twice is read once. |
| `maxReelsPerProfile` | 100 | Reels per profile from the top of its Reels tab. |
| `maxReels` | 100000 | Reel rows in total. |
| `includeDetails` | false | Read each reel by itself (one more request per reel). |
| `onlyNewReels`, `listName` | false, `default` | Remember delivered reels and skip them later. |
| `proxyConfiguration` | auto | Nothing to change for normal use. |

```json
{ "profiles": ["nasa","nike","adidas"], "maxReelsPerProfile": 12, "includeDetails": true }
```

### 📤 Output

One row per reel (`type: "reel"`); a free `type: "status"` row for a line that brings no reels. Every row has 34 columns.

| Field | Description |
|---|---|
| `reelId`, `shortCode`, `url` | the reel (`reelId` is the unique key) |
| `profileUsername`, `input` | the profile whose tab listed it; your line |
| `ownerUserId`, `ownerUsername` | who published it (a tab also shows reels co-published by others) |
| `playCount` | the tab tile's play figure (not the embed "views") |
| `likeCount`, `likesHidden`, `commentCount` | likes (null when hidden), hidden flag, comments |
| `profileMedianPlays`, `playsVsProfileMedian` | the profile's first-page median, and this reel vs it |
| `takenAtApprox`, `isPinned`, `positionInProfile`, `displayUrl` | approx time, pin/position, cover |
| Details (`includeDetails`) | `takenAt`, `caption`, `hashtags`, `mentions`, `durationSeconds`, `videoUrl`, `musicArtist`, `musicTitle`, `usesOriginalAudio`, `coauthors`, `taggedUsers`, `topics`, `locationName`, `detailsSource` |
| `scrapedAt`, `error` | when made; reason on status rows |

Without details the detail columns are `null` (lists too, so "not read" isn't mistaken for "none"); with details an empty list is `[]`.

### 💼 Use cases

**1. Reel performance analysis** — a profile's reels ranked by plays and vs its median.
*Input:* the profile, defaults. *Output:* reels + `playsVsProfileMedian`. *Use:* find what over-performs.

**2. Influencer vetting** — what a creator's reels really get.
*Input:* the handles. *Output:* plays, likes, comments per reel. *Use:* judge real reach before a deal.

**3. Trend & music research** — captions, hashtags, music across reels.
*Input:* profiles, `includeDetails` on. *Output:* caption/music/topics. *Use:* spot trends and sounds.

### 🔗 Integration

**JavaScript / Node.js**

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('foxlabs/instagram-reels-scraper').call({ profiles: ['natgeo'], maxReelsPerProfile: 24 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')
run = client.actor('foxlabs/instagram-reels-scraper').call(run_input={'profiles': ['natgeo'], 'maxReelsPerProfile': 24})
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)
```

Written for `apify-client` 3 for Python, where `call()` returns a run object; with version 1 or 2 it returns a dict — write `run['defaultDatasetId']` there.

**Automation (n8n / Zapier / Make):** schedule → HTTP request to the Actor API with your `profiles` → handle the JSON dataset → push to a sheet, CRM or dashboard.

### 📊 Pricing

Pay-per-event, one event per delivered row: **`reel`** (from the reels list) or **`reel-detailed`** (when Instagram answered the per-reel details request with at least its exact time). A reel asked with details that came without them carries `reel`. Status rows are free. [View current pricing.](https://apify.com/foxlabs/instagram-reels-scraper)

### ❓ FAQ

**Do I need an Instagram login or cookies?** No — only what a signed-out visitor sees; figures can differ from the app.

**Is `playCount` the same as "views"?** No — it's the Reels tab tile's play figure, which ran 2.4–7.7× the embed page's "views" in our measurements.

**What's the performance score?** `playsVsProfileMedian` = the reel's plays ÷ the profile's first-page median plays.

**Can I get captions and music?** Yes — turn on `includeDetails` (one more request per reel).

**Can I export to CSV / Excel / JSON?** Yes — directly from the Apify dataset.

### 🐛 Troubleshooting / What it does NOT do

- **Reels only** — no photo posts/carousels, no comment texts (count only), no shares/saves/transcripts.
- **Nothing behind the login** — no private profiles, stories, highlights, follower lists, search, tagged tab.
- **Signed-in-only / age-restricted / private profiles** get a free status row (private reels aren't shown).
- **Hidden like count** → `likeCount: null`, `likesHidden: true` (plays and comments still come).
- **Media isn't downloaded** — `videoUrl`/`displayUrl` are Instagram's temporary addresses.
- **`takenAtApprox`** is read from the reel id (median 77 s before the exact time); use `takenAt` (details) when the time matters.
- **A changed Instagram page** ends the run with a message (not empty rows); a start-up check stops it before anything is charged.

### ⚠️ Trademark

Independent, third-party tool. Not affiliated with, endorsed by or connected to Instagram or Meta Platforms, Inc. "Instagram" and related marks belong to their owners and are used here for identification only.

### ⚖️ Is it legal to scrape this data?

Rows describe what an account published publicly; captions, co-authors, tagged accounts and places can be personal data. You decide why you collect them and are responsible for a lawful reason (GDPR and similar). Media belongs to its owners; the Actor gives no right to reuse it, and media addresses are temporary. The Actor writes only to your own run's storage. See Apify's blog post on the legality of web scraping.

### 🤝 Support & contact

- 🌐 **Website:** [data.foxlabs.com.tr](https://data.foxlabs.com.tr)
- 📧 **Email:** info@foxlabs.com.tr
- 🐛 **Issues:** open a ticket in the Actor's **Issues** tab — the run's `SOURCE_REPORT` record says which road was used and why the run stopped.
- 🧰 **More clean data actors:** [Fox Labs on Apify](https://apify.com/foxlabs)

### Changelog

#### 0.1.6 — 2026-10-10

- After an independent README review: a details answer without the reel's exact time counts as no details (row carries `reel`, not `reel-detailed`); a Reels tab whose first page carries no play counts gets a status row; the status message names cut/own-less profiles; `listName` checked only when `onlyNewReels` is on; a proxy set in the input is the road of every request.

#### 0.1 — 2026-10-09

- First version: reels per profile with plays, likes, comment count and a score vs the profile's median; details on request; only-new lists; free status rows; requests ≥80 ms apart; measured on the Apify platform (500 reels in 15 s; 60 with details in 28 s; a restarted run delivered no reel twice). Standby mode prepared.

# Changelog

This Actor's version history is a separate document: https://apify.com/foxlabs/instagram-reels-scraper/changelog.md

# Actor input Schema

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

One Instagram profile per line: a user name (natgeo), an @name (@natgeo) or a profile address (https://www.instagram.com/natgeo/). The three forms can be mixed; a profile named twice is read once.

## `maxReelsPerProfile` (type: `integer`):

How many reels to deliver for each profile, from the top of its Reels tab: the reels the profile pinned first, then newest first. The tab is followed page by page (12 reels a page) for as long as Instagram offers a next page, so a large number reaches far back.

## `maxReels` (type: `integer`):

The run stops when this many rows have been delivered (default 100,000, at most 1,000,000). Only delivered rows count. With more than 1,000 profiles at the default per-profile limit, raise it — otherwise the run stops at 100,000 rows and names the profiles it did not get to. Lower it to cap a run over many profiles.

## `includeDetails` (type: `boolean`):

Off: rows come from the profile's reels list alone — plays, likes, comment count, cover image and an approximate time (12 reels a request). On: each reel is also read by itself, which adds its caption, hashtags and mentions, the exact time it was published, its duration, its music, a video address, the account that published it, co-authors, tagged accounts, topics and place (one more request per reel, so a run takes longer).

## `onlyNewReels` (type: `boolean`):

Remember delivered reels under the list name below and skip them in later runs. Schedule the same profiles daily and each run brings only the reels it has not delivered before. With this on, "Maximum reels per profile" is how far down each Reels tab the Actor looks: of the first 100 (or whatever you set) it delivers the ones it has not delivered before, and it does not go further back.

## `listName` (type: `string`):

Name of the memory used by "Only reels not delivered before" (looked at only when that is on). Use a different name for each project. Letters, digits and hyphens (a hyphen not first or last), up to 40 characters; capitals are read as lower case.

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

Nothing to change for normal use: requests leave from the run's own address, and the Actor moves to Apify Proxy by itself if Instagram turns that address away. Turn a proxy on here to send every request through it: the run then stays on that proxy, and a setting the platform refuses ends the run with a message before anything is read.

## Actor input object example

```json
{
  "profiles": [
    "natgeo"
  ],
  "maxReelsPerProfile": 24,
  "maxReels": 100000,
  "includeDetails": false,
  "onlyNewReels": false,
  "listName": "default",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "profiles": [
        "natgeo"
    ],
    "maxReelsPerProfile": 24,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

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

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

```

## MCP server setup

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