Instagram Likes Scraper With Comments

Scrape likers, commenters, and full comment content — including reply threads — from any public Instagram post, in one combined dataset. Unlike a comments-only scraper, this actor tells you who liked the post AND who commented, what they said, and how many likes/replies each comment got — all in a single run, from a single set of post URLs.

No login required to start the actor, but Instagram now serves a login-wall to unauthenticated requests on the likers, comments, and reply endpoints, so a session cookie is needed in practice for real data (see Input below).

What this Instagram comment scraper does

• Likers — every account that liked the post (likers_chrono endpoint), up to Instagram's own ceiling of roughly 950 returned per post (see Known Instagram limits below).
• Commenters — every account that left a top-level comment, each row carrying that user's actual comment: text, UTC timestamp, like count, reply count, hidden-by-Instagram flag, and hashtags/@mentions parsed out of the comment text.
• Reply threads — for comments that have replies (child_comment_count > 0), the actor fetches the reply thread itself (GraphQL, with a REST fallback) and pushes each reply as its own row, linked back to its parent comment.
• One combined, labeled dataset — liker rows, commenter rows, and reply rows all land in the same table, tagged by a row_type column so you can filter/sort/export by row kind instead of guessing from which fields are populated.

Why use this over a comments-only scraper

Most Instagram comment scraper actors on Apify Store only pull comments — you get a wall of text with no idea who liked the post, or you have to run a second, separate likes actor and merge the results yourself. This actor collects likers + commenters + comment content + replies from the same post URL in one run, so you can immediately see who engaged with the post and what they said, instead of exporting an anonymous username roster you can't act on.

Input

Field	Type	Required	Description
startUrls	array (stringList)	Yes	One or more Instagram post URLs, e.g. https://www.instagram.com/p/XXXXX/. Likers, commenters, and full comment content are collected from each.
maxCount	integer (1–10,000)	No	Cap on unique top-level users (likers + commenters combined) across all posts. Default 100. Reply authors are NOT counted against this cap.
maxCommentsPerPost	integer (1–10,000)	No	How many top-level comments to fetch full detail for (text, timestamp, like count, tagged users, hashtags) per post — a separate budget from maxCount. Default 100.
commentSortOrder	enum (popular | recent)	No	Order comments are ranked (locally, before the per-post cap is applied) — popular = highest comment-like-count first, recent = newest first. Default popular.
includeReplies	boolean	No	Fetch reply threads for comments that have them. Adds extra requests per post. Default true.
maxRepliesPerComment	integer (0–50)	No	Cap on replies fetched per comment when replies are included. Replies are additional rows, not counted against maxCount. Default 5.
sessionId	string (secret-style textfield)	No (required in practice)	Your Instagram sessionid cookie value (browser DevTools → Application → Cookies → instagram.com → sessionid). Instagram currently serves a login-wall to anonymous requests on the likers, comments, and reply endpoints — without a valid session the actor will return little to no real data.
proxyConfiguration	object (proxy editor)	No	Leave off for direct requests. The actor auto-escalates on a block: no proxy → Apify datacenter proxy → residential proxy, with retries.

Example input:

{
  "startUrls": ["https://www.instagram.com/p/DLm63qQpxvw/"],
  "maxCount": 200,
  "maxCommentsPerPost": 100,
  "commentSortOrder": "popular",
  "includeReplies": true,
  "maxRepliesPerComment": 5,
  "sessionId": "YOUR_INSTAGRAM_SESSIONID_COOKIE",
  "proxyConfiguration": { "useApifyProxy": false }
}

Output

Every item is one row — a liker, a commenter, or a reply — distinguished by row_type and is_child. Liker rows and commenter rows share the base identity fields; commenter and reply rows additionally carry the comment-detail fields.

Field	Present on	Description
row_type	all	"liker", "commenter", or "reply".
is_child	all	true only for reply rows.
username, full_name, id	all	The account's handle, display name, and numeric user ID (pk).
is_private, is_verified	all	Account flags.
profile_pic_url, profile_pic_id, is_new, latest_reel_media, latest_reel_media_utc	all	Extra fields returned by Instagram's user node (unchanged from the base actor).
liked_post, post_url	all	The post URL this row was collected from.
total_likes	all	The post's total like count (not the individual user's).
comment_id	commenter, reply	The comment/reply's numeric ID.
comment_url	commenter, reply	Deep link to the comment (or reply) on the post.
comment_text	commenter, reply	The comment/reply's text.
comment_created_at_utc	commenter, reply	ISO-8601 UTC timestamp the comment/reply was posted.
comment_like_count	commenter, reply	Like count on that comment/reply (commonly 0 — most comments receive no likes; this is a real, not fabricated, value).
child_comment_count	commenter, reply	Number of replies Instagram reports under that comment.
has_replies	commenter, reply	Convenience boolean, true when child_comment_count > 0.
is_covered	commenter, reply	true when Instagram has hidden the comment (rare, ~3% of comments in measured samples).
tagged_usernames	commenter, reply	@handles parsed out of the comment text (deduplicated). Present on a minority of comments — this is genuinely sparse data, not a broken parser.
hashtags	commenter, reply	#hashtags parsed out of the comment text. Sparser still than tagged_usernames.
parent_comment_id	reply only	The top-level comment this reply belongs to.
total_comments	commenter (one row per post-run)	The post's total comment count, from the same request.
comments_fetched_ratio	commenter (one row per post-run)	Comments actually fetched ÷ total_comments, for visibility into how complete the comment capture was for that post.
scraped_at	all	ISO-8601 UTC timestamp the row was collected.

Example output row (commenter):

{
  "row_type": "commenter",
  "is_child": false,
  "username": "example_user",
  "full_name": "Example User",
  "id": "123456789",
  "is_private": false,
  "is_verified": false,
  "profile_pic_url": "https://...",
  "liked_post": "https://www.instagram.com/p/DLm63qQpxvw/",
  "post_url": "https://www.instagram.com/p/DLm63qQpxvw/",
  "total_likes": 42419,
  "comment_id": "17912345678901234",
  "comment_url": "https://www.instagram.com/p/DLm63qQpxvw/c/17912345678901234/",
  "comment_text": "Love this! 🔥 @friend check it out #travel",
  "comment_created_at_utc": "2026-07-29T14:22:03Z",
  "comment_like_count": 3,
  "child_comment_count": 2,
  "has_replies": true,
  "is_covered": false,
  "tagged_usernames": ["friend"],
  "hashtags": ["travel"],
  "parent_comment_id": null,
  "total_comments": 2090,
  "comments_fetched_ratio": 0.0072,
  "scraped_at": "2026-07-30T09:15:41Z"
}

How dedup and row counting work (read before assuming "every user, every comment")

• One row per user, like the base actor. If the same account both liked the post AND left a comment, it gets one row (as a "liker" row, since likers are processed first) — not two. This mirrors the base actor's existing one-row-per-user behavior; it is a deliberate design choice, not a bug.
• One comment per user, per post. If a user left multiple top-level comments on a busy post, only one is attached to their row.
• Replies are never deduplicated against the top-level rows. A reply author gets their own reply row regardless of whether they already appear elsewhere as a liker or commenter, and reply rows do not count against maxCount — only against maxRepliesPerComment.

Known Instagram limits (disclosed honestly, not silently hidden)

• Likers cap out at roughly 950 per post. Instagram's likers_chrono endpoint stops returning a pagination cursor after ~950 users are returned, regardless of the post's real like count and regardless of maxCount. This is a platform limit, not an actor bug — a post with 42,000 likes will still return only its first ~950 likers.
• A session cookie is required in practice. Anonymous requests to the likers, comments, and reply endpoints are currently redirected to Instagram's login page. Set sessionId for reliable results.
• Reply-thread population rate has not been verified at scale. Only a small share of comments have replies on most posts (commonly under 5%) — an empty reply set for a given comment usually means Instagram genuinely has no replies there, not a missed fetch.
• comment_like_count is commonly 0. Most Instagram comments receive no likes; a 0 here is a real measured value, not a placeholder.
• Only public post data is collected.

How to use (Apify Console)

1. Open Apify Console → Actors → search Instagram Likes Scraper With Comments.
2. Paste one or more Instagram post URLs into startUrls.
3. Set sessionId under Advanced: Session & Proxy (recommended for reliable results).
4. Optionally adjust maxCount, maxCommentsPerPost, commentSortOrder, includeReplies, maxRepliesPerComment, and proxyConfiguration.
5. Click Start, then watch the log for progress.
6. Open the run's OUTPUT tab to view, filter, or export the dataset (JSON/CSV/Excel) — filter by row_type to isolate likers, commenters, or replies.

Use cases

• Community management — see exactly what commenters said, sorted by comment likes, to decide which threads to reply to first.
• Engagement audits — cross-reference who liked a post against who commented, in one export.
• Influencer/campaign reporting — pull comment sentiment context (text + hashtags/mentions) alongside raw like/comment counts for a post.
• Lead/competitor research — collect the usernames and comment content engaging with a competitor's or influencer's post.

Compliance

You are responsible for complying with Instagram's Terms of Service and applicable data-privacy law when using the data this actor collects (public post engagement data only — no private accounts, no profile-level enrichment, no email/phone extraction).