# Instagram Reels Scraper: Plays, Comments, Music, $1.5/1K (`transparent_meteorite/instagram-reels-scraper`) Actor
Scrape Instagram reels from any public account without login: play counts, likes, comments, duration, caption, hashtags, music or original audio, video and audio URLs, tagged users, collaborators, pinned flag and the latest comments. Reel URLs work too.
- **URL**: https://apify.com/transparent_meteorite/instagram-reels-scraper.md
- **Developed by:** [Detroit Web Agent - Open Data](https://apify.com/transparent_meteorite) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $0.40 / 1,000 reel rows
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 Reels Scraper: plays, likes, comments, music and video URLs, no login
[](https://console.apify.com/actors/VKxMGWQ4YBPDdG8iz/input)
| Price per 1,000 reels | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| **This Actor** | **$1.50** | **$1.40** | **$0.98** | **$0.40** |
| Most-used alternative | $2.60 | $2.30 | $1.40 | $1.00 |
Pay per event, no monthly rental. Prices read from each Actor's public Apify pricing on 2026-10-13; check the Pricing tab for the current figure.
Scrape the reels of any public Instagram account without logging in. Each row is one reel with its **play count**, likes, comments count, **duration**, caption, hashtags, mentions, **music or original audio**, the **video file URL**, the **audio-only track URL**, cover image, tagged users, collab co-authors, paid-partnership brands, the pinned flag, alt text and the **latest comments** with author, likes and date. Paste usernames, profile URLs or single reel URLs.
- No Instagram account, cookies or session. Nothing is logged in, so your own account is never at risk.
- Comments, alt text and audio are **included in the price**. There is no add-on charge.
- From **$1.50 per 1,000 reels** on the free plan, down to **$0.40 per 1,000** on paid plans.
- Accounts that do not exist, private accounts, failed pages and reels you filter out are never charged.
- 25 reels with full details usually arrive in well under a minute.
### Run in 30 seconds
1. Open the actor in [Apify Console](https://console.apify.com/actors?search=transparent_meteorite%2Finstagram-reels-scraper) (a free Apify account is enough).
2. Press **Start** with the prefilled input: the 25 newest reels of @natgeo, about $0.04 on the free plan.
3. Open the **Output** tab. The **Reels** view is a table with the cover, plays, likes, comments, duration, date, audio and link. Download CSV, Excel or JSON.
```json
{
"username": ["natgeo"],
"resultsLimit": 25
}
```
That is all the input you need. An empty input (`{}`) also works and runs the same example, so you can see the output before you type anything.
### Why this reels scraper
- **Real play counts.** `videoPlayCount` is the number Instagram shows under each reel, read from Instagram's own reels feed. Facebook plays are added in `fbPlayCount` when Instagram reports them for cross-posted reels.
- **Latest comments included.** Every reel carries up to about 15 of its latest comments: text, author handle, author picture, verified badge, comment likes, reply count and date. No extra charge per comment and no separate run.
- **Audio you can use.** `musicInfo` tells you whether the reel uses a licensed song (artist and title) or original audio, plus the audio ID so you can group reels that use the same sound. `audioUrl` is a direct link to the audio-only track.
- **Exact duration** in seconds with milliseconds (for example `51.605`), not a rounded label.
- **Collabs and partnerships.** Collab co-authors, tagged users and paid-partnership brands each have their own column.
- **Pinned reels are flagged**, and you can skip them in one click so a pinned reel from last year does not sneak into "last 30 days".
- **Date filter that saves money.** `onlyPostsNewerThan` stops paging as soon as reels get older than your date, so you only pay for what you asked for.
- **Almost nothing per run.** You pay only for the reels delivered, which matters when you schedule many small runs.
### What it does and who it is for
The actor reads what Instagram serves to any logged-out visitor: the account's public reels tab, and for each reel its public reel page. It combines both into one clean row per reel.
- **Social media managers and agencies:** see which reels of a competitor or a client actually get plays, and what audio they use.
- **Influencer marketing:** check a creator's real reel performance (plays, likes, comments) before you sign a deal, and see who they already work with through the paid-partnership and collab columns.
- **Trend and sound research:** collect the audio IDs and song names behind the best-performing reels in a niche.
- **Brands:** benchmark your reels against competitors every week with a schedule and a date filter.
- **Researchers and journalists:** archive public reels with timestamps, captions and the public comment snapshot.
- **Video and AI teams:** get the video and audio file URLs to analyse content you have the right to use.
### What you get: output fields
Every row is one reel.
| Field | What it is |
|---|---|
| `shortCode`, `url`, `id` | Reel shortcode, link and media ID |
| `type`, `productType` | `Video` and `clips` for reels |
| `caption` | Full caption text |
| `hashtags`, `mentions` | Hashtags and @mentions from the caption, original case |
| `videoPlayCount` | Plays on Instagram |
| `fbPlayCount` | Plays on Facebook, when reported |
| `likesCount` | Likes (null when the owner hides likes) |
| `commentsCount` | Total comments |
| `latestComments` | Latest comments: id, text, ownerUsername, ownerProfilePicUrl, ownerVerified, timestamp, likesCount, repliesCount |
| `firstComment` | Text of the first comment shown |
| `videoDuration` | Length in seconds |
| `videoUrl` | Video file URL (highest resolution offered) |
| `audioUrl` | Audio-only track URL |
| `displayUrl`, `images` | Cover image, and the cover in several sizes |
| `musicInfo` | artist_name, song_name, uses_original_audio, should_mute_audio, should_mute_audio_reason, audio_id |
| `hasAudio` | The reel has sound |
| `timestamp` | Posted at, ISO 8601 UTC |
| `dimensionsWidth`, `dimensionsHeight`, `originalWidth`, `originalHeight` | Size in pixels |
| `alt` | Instagram's alt text for the cover |
| `ownerUsername`, `ownerFullName`, `ownerId`, `ownerVerified`, `ownerProfilePicUrl` | Who posted it |
| `ownerFollowersCount` | Followers of the account you asked for |
| `taggedUsers` | Tagged accounts with id, username, full name, verified, picture |
| `coauthorProducers` | Collab co-authors |
| `paidPartnership`, `sponsors` | Paid-partnership flag and the brands named |
| `isPinned` | Pinned to the top of the account |
| `isCommentsDisabled`, `likeAndViewCountsDisabled` | Comment and count settings |
| `captionIsEdited` | The caption was edited after posting |
| `locationName`, `locationId` | Tagged place, when there is one |
| `inputUrl`, `scrapedAt` | Which input produced the row, and when it was read |
### Sample output
One row, shortened (long URLs cut):
```json
{
"inputUrl": "https://www.instagram.com/natgeo",
"id": "4007730061460546595",
"type": "Video",
"shortCode": "DeeUUHNAqQj",
"url": "https://www.instagram.com/p/DeeUUHNAqQj/",
"caption": "For a long time, we knew only the planets in our cosmic backyard. Today ...",
"hashtags": [],
"mentions": ["natgeoscience"],
"videoPlayCount": 349029,
"likesCount": 7223,
"commentsCount": 44,
"firstComment": "Incredible footage",
"latestComments": [
{"id": "18059...", "text": "Incredible footage", "ownerUsername": "someone", "ownerVerified": false,
"timestamp": "2026-10-14T14:02:11.000Z", "likesCount": 3, "repliesCount": 0}
],
"videoDuration": 51.605,
"videoUrl": "https://scontent...mp4?...",
"audioUrl": "https://scontent...mp4?...",
"displayUrl": "https://scontent...jpg?...",
"musicInfo": {"artist_name": "natgeo", "song_name": "Original audio", "uses_original_audio": true,
"should_mute_audio": false, "should_mute_audio_reason": "", "audio_id": "28847612568211894"},
"timestamp": "2026-10-14T13:00:04.000Z",
"ownerUsername": "natgeo",
"ownerFullName": "National Geographic",
"ownerVerified": true,
"ownerFollowersCount": 277000000,
"productType": "clips",
"isPinned": false,
"paidPartnership": false,
"taggedUsers": [{"username": "natgeoscience", "is_verified": true}],
"coauthorProducers": [{"username": "natgeoscience", "is_verified": true}],
"scrapedAt": "2026-10-14T16:20:31.000Z"
}
```
### Input options
| Input | What it does | Default |
|---|---|---|
| `username` | Usernames, @handles, profile URLs or reel URLs, one per line | `["natgeo"]` |
| `resultsLimit` | Newest reels per account, up to 1000 | 25 |
| `onlyPostsNewerThan` | A date (`2025-01-31`) or a span (`7 days`, `2 weeks`, `3 months`) | none |
| `skipPinnedPosts` | Leave out pinned reels | off |
| `includeComments` | Add the latest comments, alt text and edited flag to each reel | on |
| `maxItems` | Hard cap on rows across all accounts | none |
| `maxConcurrency` | Pages read in parallel | 20 |
| `proxyConfiguration` | Apify Proxy (default). No setup needed | Apify Proxy |
### Pricing
Pay per event: you pay for each reel delivered. No monthly rental, no add-ons.
| Apify plan | Price per 1,000 reels |
|---|---|
| Free | $1.50 |
| Starter (Bronze) | $1.40 |
| Scale (Silver) | $0.98 |
| Business (Gold) and above | $0.40 |
What is included in that price: the reel row, its latest comments, the alt text, the audio info and the video and audio URLs. What is never charged: accounts that do not exist, private accounts, pages Instagram refuses, and reels removed by your date or pinned filters. The run summary (`OUTPUT` in the key-value store) shows exactly how many rows were delivered and charged.
To cap your spend, set **Max rows in total** or a maximum cost per run in Apify Console. The actor stops cleanly when the cap is reached.
### How to run it
- **Apify Console:** paste usernames, press Start, download the table.
- **Schedule:** run it daily or weekly with `onlyPostsNewerThan: "7 days"` to collect only new reels.
- **API, Python or JavaScript:** see "Calling it from code" below.
- **Integrations:** send results to Google Sheets, Slack, Make, Zapier, n8n or a webhook from the Integrations tab.
### Reliability and blocking
Instagram rate-limits logged-out traffic. The actor uses Apify Proxy with a fresh session for every request, starts on fast datacenter IPs and moves to residential IPs on its own when Instagram pushes back. Slow requests are raced against a second attempt so one stuck connection does not hold up the run. If a reel page cannot be read, the reel is still delivered from the reels feed (plays, likes, video URL, audio, date) and the run log says how many reels are missing comments. If the reels feed itself is unavailable, the actor falls back to the account's public post timeline and keeps only reels.
### Limits and honest caveats
- **Public accounts only.** Private accounts return a warning and nothing is charged.
- **Latest comments, not all comments.** Instagram shows logged-out visitors about 15 recent comments per reel; that is what you get. For every comment on a reel, use a dedicated comments tool.
- **Likes can be hidden.** When the owner hides like counts, `likesCount` is null.
- **Video and image URLs expire.** Instagram's media links are signed and stop working after some days. Download files you need soon after the run.
- **Collab reels.** The reels tab of an account includes collab reels it co-authored; `ownerUsername` shows the account that posted them and `coauthorProducers` lists the collaborators.
- **Reels only.** Photos and carousels are not returned here. Use an Instagram posts scraper for the full grid.
### Use cases
1. **Competitor reels report:** every Monday, pull the last 7 days of reels for five competitors and sort by plays.
2. **Creator vetting:** compare a creator's median plays with their follower count before a paid campaign.
3. **Sound research:** group reels by `musicInfo.audio_id` to find sounds that keep getting high plays in your niche.
4. **Partnership mapping:** filter rows where `paidPartnership` is true to see which brands a creator works with.
5. **Content archive:** keep a dated record of a public account's reels with captions and comment snapshots.
6. **Hook analysis:** export captions, durations and plays to study which openings and lengths perform.
### Input guide
- `natgeo`, `@natgeo` and `https://www.instagram.com/natgeo/` all mean the same account.
- A reel URL such as `https://www.instagram.com/reel/DeeUUHNAqQj/` returns that reel only. Post URLs (`/p/...`) work too.
- Hashtag, explore, story and audio pages need a login, so they are skipped with a warning and never charged.
- Mixed lists are fine: accounts and reel URLs can sit in the same input.
### Worked examples
**Last 30 days of reels from three brands, without pinned reels**
```json
{
"username": ["nike", "redbull", "gopro"],
"resultsLimit": 200,
"onlyPostsNewerThan": "30 days",
"skipPinnedPosts": true
}
```
**Fastest possible run (no comments)**
```json
{
"username": ["natgeo", "nasa"],
"resultsLimit": 50,
"includeComments": false
}
```
**Specific reels by URL**
```json
{
"username": [
"https://www.instagram.com/reel/DeeUUHNAqQj/",
"https://www.instagram.com/reel/DecPSQfoaRe/"
]
}
```
### Tips to reduce cost and runtime
- Use `onlyPostsNewerThan` on scheduled runs. Paging stops at your date, so old reels are neither read nor charged.
- Set `resultsLimit` to what you will actually analyse. Instagram serves 12 reels per page, so 24 or 36 fill pages exactly.
- Turn off `includeComments` when you only need plays and likes. Runs get faster, the price stays the same.
- Put many accounts in one run rather than many runs with one account; accounts are processed in parallel.
### Calling it from code
Python:
```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("transparent_meteorite/instagram-reels-scraper").call(
run_input={"username": ["natgeo"], "resultsLimit": 25}
)
for reel in client.dataset(run["defaultDatasetId"]).iterate_items():
print(reel["shortCode"], reel["videoPlayCount"], reel["likesCount"])
```
JavaScript:
```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('transparent_meteorite/instagram-reels-scraper').call({
username: ['natgeo'],
resultsLimit: 25,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map((r) => [r.shortCode, r.videoPlayCount]));
```
HTTP, one call that runs the actor and returns the rows:
```bash
curl -X POST "https://api.apify.com/v2/acts/transparent_meteorite~instagram-reels-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
-H "Content-Type: application/json" \
-d '{"username": ["natgeo"], "resultsLimit": 25}'
```
### Related actors
More tools from the same publisher that fit this workflow:
- [TikTok Profile Scraper](https://apify.com/transparent_meteorite/tiktok-public-profile-scraper): profile stats, bio links and recent posts for a creator list
- [Company Enrichment by Domain](https://apify.com/transparent_meteorite/company-enrichment-by-domain): enrich a domain with socials, emails and tech stack
- [Website Email Extractor](https://apify.com/transparent_meteorite/website-contact-extractor): pull emails, phones and socials from each business website
- [Website Tech Stack Detector](https://apify.com/transparent_meteorite/website-tech-stack-detector): detect the CMS, frameworks and hosting behind any site
- [Local Business Leads](https://apify.com/transparent_meteorite/local-business-leads): find local businesses with no website from OpenStreetMap, a cheap complement to Maps data
- [Shopify Leads & Store Scraper](https://apify.com/transparent_meteorite/shopify-store-leads): Shopify store leads with apps, products and contacts
Use from AI agents: every actor here is callable through the Apify MCP server (mcp.apify.com).
### FAQ
**Do I need an Instagram account or cookies?**
No. The actor only reads what Instagram shows to logged-out visitors. You never share a login, so your account cannot be blocked.
**Is `videoPlayCount` the same number I see in the app?**
Yes, it is the play count Instagram shows on the reel. Instagram counts every start of the video, including replays.
**Why is `videoViewCount` empty?**
Instagram no longer reports the old "views" number for reels to logged-out visitors. Use `videoPlayCount`.
**How many comments do I get per reel?**
The latest comments Instagram shows publicly, usually about 15. `commentsCount` gives the total.
**Can I get reels from a hashtag or an audio page?**
Not without a login, so this actor does not offer it. Use account names or reel URLs.
**How fast is it?**
25 reels with comments usually finish in under half a minute of scraping. Instagram serves the reels tab 12 reels at a time, so very long runs take longer per page than per reel.
**What happens if Instagram blocks a request?**
It is retried on a fresh proxy session, then on residential IPs. Rows that still cannot be read are not charged, and the run log lists them.
**Can I run it on a schedule?**
Yes. Create a task with your accounts and `onlyPostsNewerThan`, then add a schedule in Apify Console.
**Is the data exportable?**
Yes: JSON, CSV, Excel, XML, RSS or HTML from the Output tab or the API.
### Terms and responsible use
The actor collects only publicly available data that Instagram shows to anyone without logging in. You are responsible for how you use it. Respect Instagram's terms, copyright in videos, images and audio, and privacy law such as the GDPR and the CCPA, especially for comment authors. Do not use the data for spam or harassment.
### Use it from AI assistants (MCP)
Connect the Apify MCP server (`https://mcp.apify.com`) to Claude, Cursor or another MCP client and add this actor as a tool. Ask, for example, "Get the last 20 reels of @nasa and tell me which three have the most plays per follower", and the assistant runs it for you.
### Changelog
- **0.1** (October 2026): first release. Reels by account or URL, play counts, durations, music and audio URLs, latest comments, collab and partnership fields, date and pinned filters, per-row pricing.
### Support
Something missing or wrong? Open an issue on the Issues tab with the run link. Requests for new fields are welcome and usually ship within days.
New to Apify? [Create a free account](https://console.apify.com/sign-up?fpr=rnmakg) and run this Actor in under a minute. Some links are affiliate links.
# Actor input Schema
## `username` (type: `array`):
Public accounts: a username (natgeo), an @handle or a profile URL (https://www.instagram.com/natgeo/). Reel URLs (https://www.instagram.com/reel/...) return that single reel.
## `resultsLimit` (type: `integer`):
Newest reels to return per account (up to 1000).
## `onlyPostsNewerThan` (type: `string`):
A date (2025-01-31) or a span like '7 days', '2 weeks', '3 months'. Older items are skipped and never charged.
## `skipPinnedPosts` (type: `boolean`):
Leave out items the account pinned to the top of its grid (pinned items can be old).
## `includeComments` (type: `boolean`):
Adds up to about 15 latest comments (text, author, likes, date), the alt text and the edited flag to every reel. Turn off for the fastest run.
## `maxItems` (type: `integer`):
Stop after this many rows across all accounts (0 = no cap). You are never charged above this.
## `maxConcurrency` (type: `integer`):
How many Instagram pages to read at once.
## `proxyConfiguration` (type: `object`):
Apify Proxy is used by default (datacenter first, residential automatically for retries). No setup needed.
## Actor input object example
```json
{
"username": [
"natgeo"
],
"resultsLimit": 25,
"skipPinnedPosts": false,
"includeComments": true,
"maxConcurrency": 20,
"proxyConfiguration": {
"useApifyProxy": 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"username": [
"natgeo"
],
"proxyConfiguration": {
"useApifyProxy": true
}
};
// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"username": ["natgeo"],
"proxyConfiguration": { "useApifyProxy": True },
}
# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/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 '{
"username": [
"natgeo"
],
"proxyConfiguration": {
"useApifyProxy": true
}
}' |
apify call transparent_meteorite/instagram-reels-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com/?tools=fetch-actor-details,transparent_meteorite/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 ` 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/VKxMGWQ4YBPDdG8iz/builds/M8cZNalPTabYNW4O7/openapi.json