Instagram Comments Scraper — Posts & Reels, No Login

What is Instagram Comments Scraper - Public Post & Reel Comments?

Instagram Comments Scraper is an Apify Actor for people and agents that start from a public Instagram post or Reel URL and need one dataset record per visible top-level comment. It accepts postUrls or Apify request-list style startUrls, and it returns comment text, usernames, timestamps, likes, profile URLs, cursors, provider provenance, and run summary data. The outcome is a structured comment dataset ready for analysis, spreadsheets, automation, and Apify MCP workflows.

Best fit and connected workflows

This Actor fits workflows that begin with a known public Instagram post or Reel and continue into comment-level analysis.

Common routing patterns include:

• social listening on public post and Reel conversations
• creator or brand monitoring from a specific URL
• lead research around public discussion on a post
• agent workflows that need compact comment rows through Apify MCP
• continuation runs when a single post needs the next page of comments

The Actor reads public comments through managed public-data APIs with an automatic fallback, so no Instagram login or cookies are needed. Pagination cursors are preserved so a large post can be continued in a later run.

Practical scenario

Maya manages creator research for a brand campaign. She starts with a public Reel URL, sets a comment cap, and lets the Actor collect the visible top-level comments. The returned rows give her commenter_username, text, created_at, comment_like_count, and commenter_profile_url. She uses those fields to spot repeated questions in the thread and then reviews the profiles behind the most relevant replies.

Input

Use postUrls for public Instagram post or Reel URLs. Use startUrls when another Apify actor or agent passes request-list objects. The remaining fields control pagination, provider routing, continuation, and row detail.

Field	Type	Purpose
postUrls	array of strings	Public Instagram post or Reel URLs to scrape comments from
startUrls	array of request objects	Alternative request-list input for /p/, /reel/, or /tv/ URLs
maxComments	integer	Maximum visible top-level comments to save per post or Reel
maxPagesPerPost	integer	Maximum comment pages to request per post
initialCursor	string	Cursor for continuing a previous single-post run
outputMode	string	compact or detailed rows
includeRawData	boolean	Adds the raw source comment object to each row when enabled

Focused input example

{
  "postUrls": [
    "https://www.instagram.com/reel/DOq6eV6iIgD/"
  ],
  "maxComments": 100,
  "maxPagesPerPost": 20,
  "outputMode": "compact",
  "includeRawData": false
}

Output

Each saved dataset row represents one visible top-level comment. The default dataset stores the rows, and RUN_SUMMARY in the key-value store provides provider usage, per-target status, counts, next cursors, warnings, and stop reason.

Field	Type	Purpose
record_type	string	Record type for this Actor, always comment
input_url	string	Original Instagram URL supplied in the input
post_url	string	Normalized public Instagram post or Reel URL
shortcode	string or null	Instagram shortcode parsed from the source URL
comment_id	string or null	Provider-returned Instagram comment ID when available
text	string or null	Visible comment text
created_at	string or null	Comment creation timestamp in ISO 8601 format when returned
comment_like_count	integer or null	Number of likes on the comment when available
commenter_username	string or null	Instagram username of the commenter
commenter_id	string or null	Provider-returned Instagram user ID of the commenter
commenter_is_verified	boolean or null	Verified status of the commenter account
commenter_profile_pic_url	string or null	Profile picture URL returned for the commenter
commenter_profile_url	string or null	Direct Instagram profile URL for the commenter
position	integer	One-based global row position in this run
page_number	integer	One-based provider page number for this target
source_cursor	string or null	Cursor used to fetch the page that returned this comment
next_cursor_at_fetch	string or null	Cursor returned with this page for continuation runs
source_url	string	Normalized post or Reel URL used for the provider request
run_id	string or null	Apify run ID when available
scraped_at	string	Timestamp when this row was saved
raw_data	object, array, string, number, boolean, or null	Optional raw provider comment object when detailed output is enabled

Illustrative output record

{
  "record_type": "comment",
  "input_url": "https://www.instagram.com/reel/DOq6eV6iIgD/",
  "post_url": "https://www.instagram.com/reel/DOq6eV6iIgD/",
  "shortcode": "DOq6eV6iIgD",
  "comment_id": "18051843701642870",
  "text": "Great post",
  "created_at": "2025-09-16T17:03:04.000Z",
  "comment_like_count": 3,
  "commenter_username": "catherina_thijs",
  "commenter_id": "46773599357",
  "commenter_is_verified": false,
  "commenter_profile_pic_url": "https://scontent.cdninstagram.com/profile.jpg",
  "commenter_profile_url": "https://www.instagram.com/catherina_thijs/",
  "position": 1,
  "page_number": 1,
  "source_cursor": "eyJjYWNoZWRfY29tbWVud...",
  "next_cursor_at_fetch": "AQHSpoi6HyDbzYRMzrD",
  "source_url": "https://www.instagram.com/reel/DOq6eV6iIgD/",
  "scraped_at": "2026-06-11T10:00:00.000Z"
}

How it works

The Actor follows a straightforward flow:

1. It accepts public Instagram post or Reel URLs, or request-list style start URLs.
2. It uses managed public-data APIs to fetch visible top-level comments.
3. It uses a primary data source first and a fallback source automatically if the first one fails.
4. It stores one dataset row per comment using a compact schema by default.
5. It records diagnostics, including the route used and continuation cursors, in RUN_SUMMARY. If every route fails and no comment is saved, the run fails instead of finishing empty.
6. It supports continuation with initialCursor when exactly one target URL is supplied.

Pricing

This Actor uses pay per event pricing with Apify platform usage included. See the Pricing tab for current event prices.

The charged events are:

• apify-actor-start, once per run
• scraped-comment, once per visible top-level comment saved

For example, if a run saves one hundred comments, the execution includes one actor-start event and one hundred scraped-comment events with Apify platform usage included. Review the live Pricing tab before running larger comment sets.

Use with AI agents (MCP)

This Actor is available as an Apify Actor usable through Apify MCP. It is built for compact comment rows that agents can read directly, while still exposing provenance fields such as post_url, source_cursor, and next_cursor_at_fetch.

Tool description: Fetch public Instagram post or Reel comments from a URL and return dataset rows with comment text, author metadata, timestamps, likes, and pagination cursors.

Actor identity: khadinakbar/instagram-comments-scraper

Scrape the comments from this public Instagram Reel URL. Return compact rows with commenter usernames, text, timestamps, like counts, and the next cursor if more pages are available.

Output interpretation for agents:

• text is the visible comment body.
• commenter_username and commenter_profile_url identify the commenter.
• created_at is the provider timestamp when returned.
• source_cursor and next_cursor_at_fetch support continuation on a single target URL.
• raw_data is available when detailed output or raw-data capture is enabled.

Provenance and scope:

• Rows come from public Instagram post and Reel URLs only.
• The Actor stores comments in the default dataset and execution diagnostics in RUN_SUMMARY.
• The live schema marks each row as a comment record.
• Pagination is provider-based, with maxPagesPerPost controlling page requests and maxComments controlling saved rows.

Cost guidance for agents:

• Use smaller maxComments values for quick calls.
• Use initialCursor only when continuing one target URL.
• Keep includeRawData off for compact agent loops unless raw provider fragments are needed.

Apify API example

import { ApifyClient } from "apify-client";

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

const run = await client.actor("khadinakbar/instagram-comments-scraper").call({
  postUrls: ["https://www.instagram.com/reel/DOq6eV6iIgD/"],
  maxComments: 100,
  maxPagesPerPost: 20,
  outputMode: "compact",
  includeRawData: false,
});

const dataset = await client.dataset(run.defaultDatasetId).listItems();

console.log("Run ID:", run.id);
console.log("Items:", dataset.items);

Best results and outcome guidance

Use a public post or Reel URL as the starting point. Keep maxComments aligned with the amount of comment data you need. Use maxPagesPerPost to control provider pagination, and use initialCursor only for a single URL continuation run. If you want a cleaner agent payload, keep outputMode set to compact and leave includeRawData off. If you want provider debugging or custom field inspection, switch to detailed output and include raw data.

Continue the workflow

• Then use Instagram Followers Scraper — Followers & Following + Email when you want the follower list of an account whose commenters you studied.
• Then use Instagram Post Engagers Scraper when you want commenters with follower and bio enrichment for lead lists.

Builder's note

I designed the default table around post_url, commenter_username, text, created_at, comment_like_count and position, and I keep the page cursor on every row so a very large post can be resumed in a later run instead of re-scraped.

FAQ

When should I use postUrls instead of startUrls?

Use postUrls when you already have a public Instagram post or Reel URL. Use startUrls when another Apify actor or agent passes request-list objects.

Which Instagram URLs fit this Actor?

This Actor is routed for public /p/, /reel/, and /tv/ URLs that point to a post or Reel.

What happens if a data source is unavailable?

The Actor switches to its fallback source automatically. If every source fails before any comment is saved, the run fails and no comments are charged.

How do I continue a previous run?

Use initialCursor with exactly one target URL, and pass the next_cursor_at_fetch value from the prior run's RUN_SUMMARY.

What gets written to the dataset?

One dataset row is written per visible top-level Instagram comment, with commenter and provenance fields when the source returns them.

Where do I read execution diagnostics?

Read RUN_SUMMARY from the key-value store for per-target status, counts, cursors, warnings, and stop reason.

Responsible use

Use the Actor only for public Instagram post and Reel URLs that are available through the provider-backed public-data APIs. Keep usage aligned with Instagram content access rules, your own governance requirements, and the current Apify Pricing tab.