# Instagram Comments Scraper - Likes & Commenters (`scrapesage/instagram-comments-scraper`) Actor

Scrape Instagram comments without login, including what other scrapers omit: the like count and reply count on every comment, plus optional commenter follower counts, bios and links. Filter by comment likes, add parent-post context, and monitor for new comments.

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

## Pricing

from $2.50 / 1,000 comment scrapeds

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Instagram Comments Scraper - Likes & Commenters

Scrape **Instagram comments without a login**, including the two things the popular comment scrapers leave out: **the like count on every comment** and **how many replies it has** - plus optional **commenter follower counts and bios**.

### Why this one

The widely used comment scrapers return a six-field view: id, text, timestamp, commenter username, commenter avatar, post URL. For sentiment work, UGC rights and community management that is not enough - you cannot tell a comment with 400 likes from one with none, and you cannot tell whether the commenter has 12 followers or 120,000.

| | This actor |
|---|---|
| Comment text, timestamp, commenter | ✅ |
| **Like count per comment** | ✅ 100% populated |
| **Reply count per comment** | ✅ 100% populated |
| Commenter follower count + bio + links | ✅ optional paid enrichment |
| Filter by minimum comment likes | ✅ |
| Parent-post context on every row | ✅ likes, comments, caption, owner |
| GIF-comment flag, verified-commenter flag | ✅ |
| Monitor mode for new comments | ✅ |
| Login required | ❌ never |

### What you get per comment

`commentId` · `text` · `textLength` · **`likeCount`** · **`replyCount`** · `isReply` · `parentCommentId` · `createdAt` · `createdAtTimestamp` · `hashtags[]` · `mentions[]` · `hasGiphy` · `hasTranslation` · `isCovered` · `restrictedStatus` · `commenterUsername` · `commenterId` · `commenterIsVerified` · `commenterProfilePicUrl` · `commenterProfileUrl` · `commenterFollowersCount`\* · `commenterFollowingCount`\* · `commenterFullName`\* · `commenterBio`\* · `commenterIsPrivate`\* · `commenterExternalUrls[]`\* · `postUrl` · `postShortCode` · `postOwnerUsername` · `postOwnerIsVerified` · `postLikeCount` · `postCommentCount` · `postedAt` · `postCaption` · `scrapedAt`

\* with `includeCommenterProfile: true`

### Input

```json
{
  "postUrls": ["https://www.instagram.com/p/DbIdlf0j6uA/"],
  "usernames": ["natgeo"],
  "maxPostsPerUser": 3,
  "includeCommenterProfile": true,
  "maxEnrichments": 50,
  "minCommentLikes": 1,
  "maxResults": 100,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

| Field | What it does |
|---|---|
| `postUrls` | Post/Reel URLs or bare shortcodes |
| `usernames` | Read comments on each handle's recent posts |
| `maxPostsPerUser` | How many recent posts per handle (default 3) |
| `includeCommenterProfile` | Adds follower count, bio and links per commenter |
| `maxEnrichments` | Hard cap on commenter lookups, so the join can never run away |
| `minCommentLikes` | Skip low-value noise |
| `includeReplies` | Include reply comments when Instagram exposes them |
| `maxCommentsPerPost` / `maxResults` | Caps. `0` = no limit |
| `onlyNewComments` | Monitor mode for a scheduled feed |

### Honest limits - read before you buy

- **Instagram exposes roughly 14 top-level comments per post to logged-out visitors.** A post with 15,000 comments will return the newest ~14. Volume comes from breadth - pass many post URLs or several handles - not depth. Deeper comment pagination requires an internal token that is not present anywhere in the logged-out page, so this actor does not pretend to offer it.
- **Reply *bodies* are not available logged-out.** Measured across 202 comments: `parent_comment_id` was null on every one, so only top-level comments come back. What you *do* get is **`replyCount`** on every comment - so you can see which comments started a thread and how big it got, even though the replies themselves are out of reach without a login.
- **`likeCount` is real but often small** on the newest comments of a large post - that is the true value, not a defect. Use `minCommentLikes` to surface the ones that landed.
- **Commenter enrichment costs one request per unique commenter.** It is off by default, capped by `maxEnrichments`, cached per handle within a run, and billed as its own event - so it can never silently multiply your bill.
- **Public posts only.** Private accounts and comment-disabled posts return nothing, gracefully.

### Pricing (pay per event, no start fee)

| Event | Price | What it covers |
|---|---|---|
| `comment` | **$0.0025** | One comment with like count, reply count, timestamp, commenter handle, parent-post context |
| `commentEnriched` | **$0.008** | Adds that commenter's follower count, following count, full name, bio and links |

Comments are billed **before** they are written, and the enrichment is billed only when it actually produced data - never for a row that did not ship.

### Use with AI assistants (MCP)

Perfect as an LLM tool for sentiment and community analysis through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) - ask an assistant to "pull the most-liked comments on @natgeo's recent posts" and it can call this actor directly.

### Agent-ready: autonomous payments (x402 & Skyfire)

This actor is **agent-ready** — AI agents can discover it, run it, and **pay for it autonomously**, with no Apify account and no human in the loop. It uses [pay-per-event](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) pricing and [limited permissions](https://docs.apify.com/platform/actors/development/permissions), so it qualifies for Apify's agentic-payment standards:

- **[x402](https://docs.apify.com/platform/integrations/x402)** — an open, HTTP-native payment protocol. Agents pay per run in USDC on the Base network directly through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) — no account, no API key.
- **[Skyfire](https://docs.apify.com/platform/integrations/skyfire)** — agent-to-service payments for fully autonomous AI-agent workflows.

Building an AI agent, MCP tool, or autonomous data pipeline? This scraper is ready to plug in and pay as it goes.

### Integrations

[Make](https://apify.com/integrations/make), [Zapier](https://apify.com/integrations/zapier), [Slack](https://apify.com/integrations/slack), [Google Drive](https://apify.com/integrations/google-drive), [Airbyte](https://apify.com/integrations/airbyte), [GitHub](https://apify.com/integrations/github), the [Apify API](https://docs.apify.com/api/v2), [Schedules](https://docs.apify.com/platform/schedules) and [Webhooks](https://docs.apify.com/platform/integrations/webhooks).

### FAQ

**Do I need a login or cookies?** No.

**Why only ~14 comments per post?** That is what Instagram serves logged-out. See the limits section - this actor tells you the truth rather than quietly returning a thin result.

**Why are follower counts null?** Set `includeCommenterProfile: true`. It is off by default because it costs an extra request per commenter.

**Can I get replies to a specific comment?** Not without a login. You do get `replyCount` so you know which comments have threads.

### Related scrapers by scrapesage

- [Instagram Reels Scraper](https://apify.com/scrapesage/instagram-reels-scraper) - play counts, view counts and Reel analytics
- [Instagram Hashtag Scraper](https://apify.com/scrapesage/instagram-hashtag-scraper) - filtered hashtag and keyword post search
- [Threads Scraper](https://apify.com/scrapesage/threads-scraper) - profiles, posts and replies
- [YouTube Scraper](https://apify.com/scrapesage/youtube-scraper) - video and channel engagement data

# Actor input Schema

## `postUrls` (type: `array`):

Instagram post/Reel URLs or bare shortcodes whose comments you want, e.g. https://www.instagram.com/p/DbIdlf0j6uA/

## `usernames` (type: `array`):

Creator handles - the actor reads their recent posts and returns the comments on each.

## `maxPostsPerUser` (type: `integer`):

How many recent posts to read per username.

## `includeCommenterProfile` (type: `boolean`):

Fetches each unique commenter's profile to add follower count, following count, full name, bio and links. One request per unique commenter, capped below. Billed as the commentEnriched event.

## `maxEnrichments` (type: `integer`):

Hard cap on commenter profile fetches per run, so the enrichment join can never multiply your cost without a bound.

## `minCommentLikes` (type: `integer`):

Only return comments with at least this many likes - the cheapest way to skip low-value noise.

## `includeReplies` (type: `boolean`):

Include reply comments (those with a parent comment) as well as top-level ones.

## `maxCommentsPerPost` (type: `integer`):

Cap comments returned per post. 0 means every comment Instagram exposes to logged-out visitors.

## `maxResults` (type: `integer`):

Total comments across all inputs. 0 means no limit (the run's time budget stops it safely).

## `onlyNewComments` (type: `boolean`):

Remembers comments already returned for this target set and emits only new ones. Ideal on a schedule.

## `concurrency` (type: `integer`):

Parallel post fetches. Keep at 4 or below to respect the per-IP rate limits.

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

RESIDENTIAL is the tested default and strongly recommended.

## Actor input object example

```json
{
  "postUrls": [
    "https://www.instagram.com/p/DbIdlf0j6uA/"
  ],
  "usernames": [
    "natgeo"
  ],
  "maxPostsPerUser": 3,
  "includeCommenterProfile": false,
  "maxEnrichments": 50,
  "minCommentLikes": 0,
  "includeReplies": true,
  "maxCommentsPerPost": 0,
  "maxResults": 100,
  "onlyNewComments": false,
  "concurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Every scraped comment with like count, reply relationship, commenter handle and optional follower count, plus the parent post context, as JSON items in the default dataset.

# 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 = {
    "postUrls": [
        "https://www.instagram.com/p/DbIdlf0j6uA/"
    ],
    "usernames": [
        "natgeo"
    ],
    "maxPostsPerUser": 3,
    "maxEnrichments": 50,
    "maxResults": 100,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/instagram-comments-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 = {
    "postUrls": ["https://www.instagram.com/p/DbIdlf0j6uA/"],
    "usernames": ["natgeo"],
    "maxPostsPerUser": 3,
    "maxEnrichments": 50,
    "maxResults": 100,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/instagram-comments-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "postUrls": [
    "https://www.instagram.com/p/DbIdlf0j6uA/"
  ],
  "usernames": [
    "natgeo"
  ],
  "maxPostsPerUser": 3,
  "maxEnrichments": 50,
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapesage/instagram-comments-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapesage/instagram-comments-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/lzakcF7ukaTthxw0c/builds/OGao7qWJNM6GRY8Fr/openapi.json