# Instagram Comments Scraper (`goat255/instagram-comments-scraper`) Actor

Scrape the full comment thread of any public Instagram post or reel without a login. Give a list of post links and get back every comment as a clean row: text, author (username, name, verified), like and reply counts, and comment date. Paginated automatically to your chosen limit.

- **URL**: https://apify.com/goat255/instagram-comments-scraper.md
- **Developed by:** [Goutam Soni](https://apify.com/goat255) (community)
- **Categories:** Social media, Marketing, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 comment scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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 - Export All Comments From Posts & Reels

Scrape every comment on any public Instagram post or reel. Get the comment text, the author (username, display name, numeric ID, verified badge), like and reply counts, and the exact date it was posted, without an Instagram API key, login, or cookies.

### What this Instagram comments scraper does

Pass a list of post links, reel links, or bare shortcodes (mixed freely) and the actor returns one clean JSON row per comment. Pagination is walked automatically page after page until it hits the cap you set or the thread runs out, so a request for 2,000 comments really does walk the whole thread rather than stopping at the first page Instagram shows.

Perfect for **sentiment research, giveaway entry collection, audience discovery, moderation and brand-safety checks, and content analysis** on Instagram at scale.

### Why use this Instagram comments scraper

- **No API key, no login, no cookies.** Works on any public Instagram post or reel. You never hand over an Instagram account or a password.
- **Deep pagination.** Ask for 50 comments or 50,000 and the scraper keeps fetching until your cap is reached.
- **Flexible input.** Post links, reel links, and bare shortcodes all work in the same list, so you can paste whatever you already have.
- **Author details on every row**, including the numeric user ID and verified badge, so a comment thread doubles as a list of genuinely engaged accounts.
- **Reply counts included**, which makes it easy to find the comments that actually started a conversation.
- **Several posts at once**, processed in parallel, each row tagged with its post shortcode.
- **Residential proxies** built in with rotating IPs.
- **Clean, flat JSON.** Every field is always present, with `null` where a value genuinely does not exist, so CSV exports never shift columns.

### What data you get per comment

| Field | Type | Description |
|---|---|---|
| `type` | string | Record type, always `"comment"` |
| `postShortcode` | string | Shortcode of the post the comment belongs to |
| `commentId` | string | The comment's numeric ID |
| `text` | string | Full comment text, with mentions and emojis |
| `ownerUsername` | string | The comment author's handle |
| `ownerFullName` | string | The comment author's display name |
| `ownerId` | string | The comment author's numeric Instagram user ID |
| `ownerIsVerified` | boolean | Whether the author has a verified badge |
| `likeCount` | integer | Number of likes on the comment |
| `replyCount` | integer | Number of replies to the comment |
| `createdAt` | string | When the comment was posted (ISO 8601 UTC) |
| `scrapedAt` | string | When the row was scraped (ISO 8601 UTC) |

### How to use the Instagram Comments Scraper

1. Click **Try for free** on the actor page.
2. Enter post or reel links in the `posts` input. Bare shortcodes work too, and entries are deduplicated.
3. Set `maxCommentsPerPost` (default 500, up to 50,000) to cap how many comments come back per post.
4. Tune `concurrency` (default 5, up to 15) if you are scraping many posts at once.
5. Click **Save & start**. Download in JSON, CSV, Excel, XML or HTML, or stream via API.

#### Example input

```json
{
  "posts": [
    "https://www.instagram.com/p/CabcdEFghij/",
    "https://www.instagram.com/reel/CklmnOPqrst/",
    "CuvwxYZabcd"
  ],
  "maxCommentsPerPost": 2000,
  "concurrency": 5
}
````

#### Example output

```json
{
  "type": "comment",
  "postShortcode": "CabcdEFghij",
  "commentId": "17900000000000001",
  "text": "This is exactly what I needed, thank you!",
  "ownerUsername": "example_user",
  "ownerFullName": "Jane Doe",
  "ownerId": "100000001",
  "ownerIsVerified": false,
  "likeCount": 4,
  "replyCount": 1,
  "createdAt": "2026-07-20T18:00:00.000Z",
  "scrapedAt": "2026-07-21T09:00:00.000Z"
}
```

### Top use cases

- **Sentiment and audience research.** Read what people actually say under a post instead of inferring it from a like count.
- **Giveaway and contest entry collection.** Export every comment on an entry post, complete with author handles and timestamps.
- **Audience discovery.** People who comment are far more engaged than people who scroll past. Their handles make a strong prospect list.
- **Moderation and brand-safety checks.** Sweep the comments on your own posts for spam, abuse, or impersonation attempts.
- **Competitor research.** Read the objections and questions in a competitor's comment section to find gaps in your own messaging.
- **Content analysis.** Rank comments by `likeCount` and `replyCount` to see which reactions drove the conversation.
- **Customer feedback mining.** Product complaints and feature requests routinely land in comments before they reach support.

### Integrations

#### Apify API

```bash
curl "https://api.apify.com/v2/datasets/{DATASET_ID}/items?format=json"
```

#### Python

```python
from apify_client import ApifyClient
from collections import Counter

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("goat255/instagram-comments-scraper").call(run_input={
    "posts": ["https://www.instagram.com/p/CabcdEFghij/"],
    "maxCommentsPerPost": 2000,
})

comments = list(client.dataset(run["defaultDatasetId"]).iterate_items())

## Most engaged commenters and the top comment by likes
top_voices = Counter(c["ownerUsername"] for c in comments if c.get("ownerUsername"))
print(top_voices.most_common(10))

best = max(comments, key=lambda c: c.get("likeCount") or 0)
print(f"Top comment ({best['likeCount']} likes): {best['text']}")
```

#### JavaScript / Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('goat255/instagram-comments-scraper').call({
    posts: ['https://www.instagram.com/p/CabcdEFghij/'],
    maxCommentsPerPost: 2000,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
const questions = items.filter((c) => (c.text || '').includes('?'));
console.log(`${questions.length} of ${items.length} comments asked a question`);
```

#### No-code integrations

Stream results to Google Sheets, Slack, Zapier, Make, Amazon S3, HubSpot, or any webhook via [Apify Integrations](https://docs.apify.com/platform/integrations).

### Pricing

Pay per result. No subscription. No per-run start fee. You only pay for the comments you actually receive.

| Event | Price |
|---|---|
| Comment scraped (primary) | $0.002 |

Apify's $5 platform free credit applies on first use, which is roughly 2,500 free comments to start.

### FAQ

#### Do I need an Instagram account or API key?

No. The scraper works on any public Instagram post or reel without a login, cookies, or the Instagram Graph API.

#### What input formats does it accept?

Post links, reel links, and bare shortcodes, all in the same list. `https://www.instagram.com/p/CabcdEFghij/`, `https://www.instagram.com/reel/CabcdEFghij/`, and `CabcdEFghij` are all valid and refer to the same post.

#### Can it scrape comments on posts from private accounts?

No. Only public posts and reels are accessible. A post that cannot be reached returns a row with `ok: false` and a generic reason such as `not_found`.

#### How many comments can I get per post?

Up to 50,000 per post per run. Pagination is walked automatically, so setting `maxCommentsPerPost` to 2,000 returns 2,000 comments if the thread has them, not just the first page.

#### Does it include replies to comments?

Each row is a top-level comment and carries a `replyCount` telling you how many replies it received. Use that to find the threads worth reading, then rank by `likeCount` to find the comments the audience endorsed.

#### Why did I get fewer comments than I asked for?

The thread ran out. Ask for 2,000 on a post with 140 comments and you get 140 real rows rather than 2,000 padded ones. The run log states the count per post.

#### Can I export to CSV, Google Sheets or Excel?

Yes. JSON, CSV, Excel, XML and HTML are all supported, plus direct integrations to Google Sheets, Zapier, Make, Slack and S3.

#### What happens if one post in my list fails?

The run does not fail. The actor emits a row with `ok: false` and a generic reason for that post, then carries on with the rest of your list.

### Related Apify actors

- 📝 [Instagram Posts Scraper](https://apify.com/goat255/instagram-posts-scraper) - bulk export posts, captions, likes, comments, media.
- 🎬 [Instagram Reels Scraper](https://apify.com/goat255/instagram-reels-scraper) - reels with play counts, duration and direct video URLs.
- 👤 [Instagram Profile Scraper](https://apify.com/goat255/instagram-profile-scraper) - bios, follower counts, public emails, phone numbers, business info.
- 🔎 [Instagram Hashtag Scraper](https://apify.com/goat255/instagram-hashtag-scraper) - top and recent posts for any tag.

### Support

Found a bug or a missing field? Open an issue on the actor page. Reviews are read and replied to.

### Privacy

To improve our actors we collect anonymized usage telemetry (run stats and input patterns). No personal account data is collected.

# Actor input Schema

## `posts` (type: `array`):

Instagram posts or reels whose comments you want. Post links, reel links, or bare shortcodes all work. Examples: https://www.instagram.com/p/CabcdEFghij/, https://www.instagram.com/reel/CabcdEFghij/, CabcdEFghij.

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

Cap on comments returned per post. Pagination is walked across multiple pages until this is reached or the thread runs out.

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

How many posts to process in parallel.

## Actor input object example

```json
{
  "posts": [
    "https://www.instagram.com/p/DZFjl0SDZNw/",
    "https://www.instagram.com/p/DUitcKeDA4l/"
  ],
  "maxCommentsPerPost": 500,
  "concurrency": 5
}
```

# 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 = {
    "posts": [
        "https://www.instagram.com/p/DZFjl0SDZNw/",
        "https://www.instagram.com/p/DUitcKeDA4l/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("goat255/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 = { "posts": [
        "https://www.instagram.com/p/DZFjl0SDZNw/",
        "https://www.instagram.com/p/DUitcKeDA4l/",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("goat255/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 '{
  "posts": [
    "https://www.instagram.com/p/DZFjl0SDZNw/",
    "https://www.instagram.com/p/DUitcKeDA4l/"
  ]
}' |
apify call goat255/instagram-comments-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Comments Scraper",
        "description": "Scrape the full comment thread of any public Instagram post or reel without a login. Give a list of post links and get back every comment as a clean row: text, author (username, name, verified), like and reply counts, and comment date. Paginated automatically to your chosen limit.",
        "version": "0.1",
        "x-build-id": "FooVjcZ7e4WGTr5U7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/goat255~instagram-comments-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-goat255-instagram-comments-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/goat255~instagram-comments-scraper/runs": {
            "post": {
                "operationId": "runs-sync-goat255-instagram-comments-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/goat255~instagram-comments-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-goat255-instagram-comments-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "posts"
                ],
                "properties": {
                    "posts": {
                        "title": "Posts",
                        "type": "array",
                        "description": "Instagram posts or reels whose comments you want. Post links, reel links, or bare shortcodes all work. Examples: https://www.instagram.com/p/CabcdEFghij/, https://www.instagram.com/reel/CabcdEFghij/, CabcdEFghij.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxCommentsPerPost": {
                        "title": "Max comments per post",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Cap on comments returned per post. Pagination is walked across multiple pages until this is reached or the thread runs out.",
                        "default": 500
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 15,
                        "type": "integer",
                        "description": "How many posts to process in parallel.",
                        "default": 5
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
