# Bulk Instagram Comments Scraper (`devil_port369-owner/instagram-comments`) Actor

Scrape Instagram comments at scale from any public post, reel, or TV content. Extract engagement data, commenter profiles, sentiment insights, and detailed comment metadata in seconds.

- **URL**: https://apify.com/devil\_port369-owner/instagram-comments.md
- **Developed by:** [DataFusionX](https://apify.com/devil_port369-owner) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

**Scrape Instagram comments at scale from any public post, reel, or TV content. Extract engagement data, commenter profiles, sentiment insights, and detailed comment metadata in seconds.**

---

### 📋 Table of Contents

- [Overview](#overview)
- [Key Features](#key-features)
- [What It Helps With](#what-it-helps-with)
- [How It Works](#how-it-works)
- [Input Schema](#input-schema)
- [Output Schema](#output-schema)
- [Usage Examples](#usage-examples)
- [Use Cases](#use-cases)
- [Performance & Limits](#performance--limits)
- [Troubleshooting](#troubleshooting)
- [Integrations & Webhooks](#integrations--webhooks)

---

### Overview

The **Instagram Comments Scraper** is a powerful tool that enables you to extract comments and replies from Instagram posts, reels, and TV content at scale. Whether you're conducting sentiment analysis, monitoring brand mentions, tracking audience engagement, or analyzing competitor content, this scraper provides unlimited access to public Instagram comment data with no request limits.

Designed for marketers, researchers, data analysts, and business intelligence professionals, the scraper automatically handles pagination, deduplication, and concurrent processing to deliver clean, structured data in multiple formats (JSON, CSV, Excel, XML, HTML).

---

### Key Features

#### What Can Instagram Comments Scraper Do?

- **💬 Scrape Instagram comments and replies at scale** - Extract unlimited comments from public posts, reels, and TV content with no API rate limits
- **👥 Capture commenter profiles** - Get usernames, user IDs, verification status, profile pictures, and bio information
- **⏰ Track engagement timestamps** - Analyze comment creation times in both Unix timestamp and ISO 8601 formats
- **🔢 Monitor engagement metrics** - Extract comment like counts, reply counts, and visibility patterns
- **🎬 Support multiple content types** - Works with Instagram posts (`/p/`), reels (`/reel/`), and TV content (`/tv/`)
- **🆔 Get detailed metadata** - Media IDs, shortcodes, parent-child comment relationships, and GIF support
- **⚡ Handle concurrent requests** - Process multiple posts simultaneously using configurable parallel execution (default: 2 concurrent posts)
- **📊 Export in multiple formats** - JSON, CSV, Excel, XML, HTML for seamless integration with analytics tools
- **🔄 Async dataset streaming** - Push comment records to Apify dataset immediately as they're scraped for real-time monitoring
- **🛡️ Handle edge cases** - Gated content detection, covered content, translation support, and GIF-only comments

---

### What It Helps With

#### Use Cases & Business Value

| Use Case | Benefit |
|----------|---------|
| **Sentiment Analysis** | Analyze audience reactions to marketing campaigns and track brand perception in real-time |
| **Engagement Tracking** | Monitor comment activity patterns, identify trending topics, and peak engagement times |
| **Brand Monitoring** | Detect brand mentions, customer feedback, and reputation insights across posts |
| **Competitor Analysis** | Analyze how competing content performs and resonates with audiences |
| **Misinformation Detection** | Identify and flag false or misleading information in comment threads |
| **Market Research** | Gather qualitative feedback from target audiences on products and campaigns |
| **Content Strategy** | Understand audience preferences and optimize content based on comment insights |
| **Customer Service** | Monitor mentions and respond to customer inquiries in real-time |
| **Influencer Analysis** | Track influencer engagement rates and audience quality |
| **Academic Research** | Collect data for studies on social media behavior and online discourse |

---

### How It Works

#### Step-by-Step Process

1. **Prepare Input**
   - Gather one or multiple Instagram post/reel/TV URLs
   - Can be full URLs (e.g., `https://www.instagram.com/p/ABC123/`) or raw shortcodes (e.g., `ABC123`)

2. **Configure Settings**
   - Set maximum comments per post (0 for unlimited)
   - Adjust thread pool concurrency if needed
   - Configure delay between paginated requests

3. **Start the Scraper**
   - The actor validates and normalizes all input URLs
   - Parses Instagram media shortcodes
   - Initiates concurrent scraping tasks

4. **Scrape Comments**
   - For each post, the scraper fetches comment batches using Instagram's GraphQL API
   - Automatically handles pagination and cursor management
   - Deduplicates comments using internal comment ID tracking
   - Extracts full comment metadata including replies

5. **Stream Results**
   - Comments are pushed to the Apify dataset record-by-record as they're scraped
   - No need to wait for completion to access data
   - Monitor progress in real-time via Apify dashboard

6. **Export & Integrate**
   - Download data in JSON, CSV, Excel, or other formats
   - Integrate with webhooks, APIs, and third-party tools
   - Use Python/Node.js SDKs for programmatic access

---

### Input Schema

#### Required & Optional Parameters

```json
{
  "post_urls": [
    "https://www.instagram.com/p/ABC123def/",
    "https://www.instagram.com/reel/XYZ789/",
    "ABC123def",
    "reel/XYZ789"
  ],
  "max_comments": 100
}
````

##### Input Fields

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `post_urls` | Array\[String] | ✅ Yes | - | Instagram post, reel, or TV URLs. Can be full URLs or raw shortcodes (e.g., `ABC123def`) |
| `max_comments` | Integer | ❌ No | 50 (free), unlimited (paid) | Maximum comments to scrape per post. Use `0` for unlimited (paid users only) |

##### URL Format Support

The scraper accepts multiple URL formats:

```
✅ Valid Formats:
- https://www.instagram.com/p/ABC123def/
- https://www.instagram.com/p/ABC123def/?utm_source=...
- https://www.instagram.com/reel/ABC123def/
- https://www.instagram.com/tv/ABC123def/
- https://www.instagram.com/username/p/ABC123def/
- https://www.instagram.com/username/reel/ABC123def/
- ABC123def (raw shortcode)
```

***

### Output Schema

#### Comment Data Fields

Each comment record contains the following fields:

```json
{
  "comment_id": "17949788698583607",
  "text": "Amazing content! Love this ❤️",
  "username": "gabriel2005120",
  "user_id": "123456789",
  "is_verified": true,
  "profile_pic_url": "https://scontent-msp1-1.cdninstagram.com/v/...",
  "created_at": 1637329453,
  "created_at_iso": "2021-11-19T13:54:13Z",
  "comment_like_count": 12,
  "child_comment_count": 2,
  "is_gif": false,
  "gif_url": null,
  "parent_comment_id": null,
  "is_covered": false,
  "has_translation": false,
  "post_url": "https://www.instagram.com/p/ABC123def/",
  "media_id": "1234567890123456789",
  "media_shortcode": "ABC123def",
  "source_url": "https://www.instagram.com/p/ABC123def/"
}
```

##### Output Fields Reference

| Field | Type | Description |
|-------|------|-------------|
| `comment_id` | String | Unique Instagram comment identifier |
| `text` | String | Comment text content (null for GIF-only comments) |
| `username` | String | Username of the commenter |
| `user_id` | String | User ID of the commenter |
| `is_verified` | Boolean | Whether the commenter has a verified badge |
| `profile_pic_url` | String | Profile picture URL of the commenter |
| `created_at` | Integer | Unix timestamp of comment creation |
| `created_at_iso` | String | ISO 8601 formatted datetime |
| `comment_like_count` | Integer | Number of likes received by the comment |
| `child_comment_count` | Integer | Number of replies to the comment |
| `is_gif` | Boolean | Whether the comment is a GIF-only comment |
| `gif_url` | String | CDN URL for GIF comments (null if not a GIF) |
| `parent_comment_id` | String | ID of parent comment if this is a reply (null for top-level) |
| `is_covered` | Boolean | Whether Instagram has hidden/covered the comment |
| `has_translation` | Boolean | Whether translation is available |
| `post_url` | String | Full URL of the Instagram post |
| `media_id` | String | Numeric Instagram media ID |
| `media_shortcode` | String | Instagram media shortcode |
| `source_url` | String | Original URL from input |

***

### Usage Examples

#### Example 1: Scrape Single Post

**Input:**

```json
{
  "post_urls": ["https://www.instagram.com/p/ABC123def/"],
  "max_comments": 100
}
```

**Expected Output:**

```json
[
  {
    "comment_id": "17949788698583607",
    "text": "This is amazing! 🔥",
    "username": "john_doe",
    "user_id": "987654321",
    "is_verified": false,
    "created_at": 1637329453,
    "created_at_iso": "2021-11-19T13:54:13Z",
    "comment_like_count": 45,
    "child_comment_count": 3,
    "media_shortcode": "ABC123def",
    "post_url": "https://www.instagram.com/p/ABC123def/"
  },
  {
    "comment_id": "17949788698583608",
    "text": "Totally agree with @john_doe",
    "username": "jane_smith",
    "user_id": "987654322",
    "is_verified": true,
    "created_at": 1637329500,
    "created_at_iso": "2021-11-19T13:55:00Z",
    "parent_comment_id": "17949788698583607",
    "media_shortcode": "ABC123def"
  }
]
```

#### Example 2: Scrape Multiple Reels

**Input:**

```json
{
  "post_urls": [
    "https://www.instagram.com/reel/ABC123def/",
    "https://www.instagram.com/reel/XYZ789abc/",
    "reel/DEF456ghi/"
  ],
  "max_comments": 0
}
```

#### Example 3: Using Raw Shortcodes

**Input:**

```json
{
  "post_urls": [
    "ABC123def",
    "XYZ789abc",
    "DEF456ghi"
  ],
  "max_comments": 500
}
```

#### Example 4: Programmatic Usage (Python SDK)

```python
from apify_client import ApifyClient

client = ApifyClient("apify_api_key")

run = client.actor("devil_port369-owner/instagram-comments").call(
    {
        "post_urls": ["https://www.instagram.com/p/ABC123def/"],
        "max_comments": 100
    }
)

## Retrieve results
dataset_id = run["defaultDatasetId"]
dataset_client = client.dataset(dataset_id)

for item in dataset_client.iterate_items():
    print(f"{item['username']}: {item['text']}")
```

#### Example 5: Using with Node.js SDK

```javascript
const Apify = require('apify-client');

const apifyClient = new Apify.ApifyClient({
    token: 'apify_api_key',
});

const run = await apifyClient.actor('devil_port369-owner/instagram-comments').call({
    post_urls: ['https://www.instagram.com/p/ABC123def/'],
    max_comments: 100,
});

const dataset = await apifyClient.dataset(run.defaultDatasetId).listItems();
dataset.items.forEach(item => {
    console.log(`${item.username}: ${item.text}`);
});
```

***

### Use Cases

#### 1. **Social Media Sentiment Analysis**

Analyze audience reactions to posts and track brand sentiment over time. Export comments and use AI/NLP tools to classify sentiment (positive, negative, neutral).

```
→ Benefits: Understand customer perception, identify issues early, measure campaign success
```

#### 2. **Competitive Intelligence**

Monitor competitor posts and analyze audience comments to understand market positioning and what resonates with audiences.

```
→ Benefits: Stay ahead of competitors, identify content gaps, benchmark engagement
```

#### 3. **Influencer Verification**

Analyze comment quality, engagement rates, and audience authenticity before partnering with influencers.

```
→ Benefits: Avoid fake influencers, measure true engagement, validate partnerships
```

#### 4. **Customer Feedback & Support**

Monitor brand mentions and comments to identify customer issues, feedback, and support requests.

```
→ Benefits: Fast response times, proactive support, customer satisfaction improvement
```

#### 5. **Market Research**

Gather qualitative insights directly from your target audience about products, preferences, and pain points.

```
→ Benefits: Direct customer voice, lower research costs, quick insights
```

#### 6. **Content Strategy Optimization**

Analyze what types of comments appear on high-engagement posts to optimize future content.

```
→ Benefits: Data-driven content strategy, higher engagement, better audience understanding
```

#### 7. **Crisis Management**

Detect negative comments and misinformation early to respond quickly and manage brand reputation.

```
→ Benefits: Rapid issue detection, proactive crisis response, reputation protection
```

#### 8. **Academic Research**

Study social media behavior, online discourse patterns, and community dynamics.

```
→ Benefits: Rich qualitative data, real-world insights, peer-reviewed research material
```

***

### Performance & Limits

#### Concurrent Processing

- **Default:** 2 simultaneous posts processed in parallel
- **Configurable:** Adjust `MAX_CONCURRENT_POSTS` in code for your needs
- **Recommendation:** 2-5 for most use cases to balance speed and stability

#### Rate Limiting & Delays

- **Delay between pages:**
- **Pagination batch size:**
- **Deduplication:**

#### Free vs. Paid Plans

| Feature | Free | Paid |
|---------|------|------|
| Comments per run | 50 | Unlimited |
| Concurrent posts | 2 | 2+ |

#### Issue: Missing GIF content

**Solution:** The scraper automatically handles GIF comments:

- `is_gif`: true if comment is GIF-only
- `gif_url`: Contains CDN URL (if available)
- `text`: null for GIF-only comments

#### Issue: Profile pic URLs expired

**Solution:** Profile pic URLs are valid for a limited time. Re-scrape if needed for fresh URLs.

***

#### Third-Party Tool Integrations

The scraper integrates seamlessly with:

- **Data Visualization:** Tableau, Power BI, Google Data Studio
- **Analytics:** Google Analytics, Mixpanel, Amplitude
- **AI/ML:** Hugging Face, OpenAI, Google Cloud AI
- **Automation:** Zapier, n8n, Make, IFTTT
- **CRM:** Salesforce, HubSpot, Pipedrive
- **Database:** Google Sheets, Airtable, MongoDB, PostgreSQL
- **Workflow:** GitHub Actions, GitLab CI, Jenkins

***

### FAQ

**Q: Can I scrape private accounts?**
A: No, only public posts and comments are accessible.

**Q: Is there a limit on comments per post?**
A: Free users: 50 per post. Paid users: Unlimited (use `max_comments: 0`).

**Q: How often can I run this?**
A: Free plan: Limited frequency. Paid plan: Unlimited runs.

**Q: What if a post has 100K+ comments?**
A: The scraper handles pagination automatically. You can set a limit or scrape all.

**Q: Does it include deleted comments?**
A: No, only currently visible comments are extracted.

**Q: Can I schedule recurring scrapes?**
A: Yes, via Apify Scheduler or webhook automations.

**Q: What formats does the output support?**
A: JSON, CSV, Excel, XML, HTML, plus programmatic access via SDKs.

**Q: Is it legal to scrape Instagram comments?**
A: Our Instagram scrapers are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly.
However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers. You can also read our blog post on the legality of web scraping.

**Q: Can I use integrations with Instagram Comment Scraper?**
A: You can integrate comment data scraped from Instagram with almost any cloud service or web app. We offer integrations with Zapier, n8n, Slack, Make, Airbyte, Gumloop, CrewAI, IFTTT, Lindy, GitHub, Google Sheets, Google Drive, and plenty more.
Alternatively, you could use webhooks to carry out an action whenever an event occurs, such as getting a notification whenever the Instagram Comment Scraper successfully finishes a run.
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

### Related Tools

- **Instagram Post Scraper** - Extract post captions, media, engagement metrics
- **Instagram Hashtag Scraper** - Scrape posts by hashtag
- **Instagram Profile Scraper** - Extract profile information and bio data
- **Instagram Stories Scraper** - Download and analyze Instagram stories

***

### Keywords for SEO/SEM

**Primary Keywords:**

- Instagram comment scraper
- Scrape Instagram comments
- Instagram API
- Comment extraction tool
- Social media scraping
- Instagram data extraction
- Comment sentiment analysis
- Instagram engagement analysis
- Bulk download Instagram comments
- Instagram automation

**Long-Tail Keywords:**

- How to scrape Instagram comments
- Best Instagram comment scraper tool
- Extract Instagram comments programmatically
- Instagram comment API free
- Scrape Instagram reel comments
- Instagram post comment analysis
- Automated Instagram comment collection
- Instagram comment data export
- Monitor Instagram comments
- Instagram comment archiving tool

**Semantic Keywords:**

- Instagram conversation analysis
- Social listening tool
- Audience sentiment tracking
- Comment thread extraction
- Instagram engagement metrics
- Influencer comment analysis
- Brand monitoring tool
- Customer feedback analysis
- Social media intelligence
- Real-time comment monitoring

# Actor input Schema

## `post_urls` (type: `array`):

Enter Instagram posts links

## `max_comments` (type: `integer`):

Maximum number of comments to fetch from the post. Set to 0 for unlimited.

## Actor input object example

```json
{
  "post_urls": [
    "https://www.instagram.com/reel/DY7SahztrRj/",
    "DY7SahztrRj"
  ],
  "max_comments": 15
}
```

# Actor output Schema

## `results` (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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "post_urls": [
        "https://www.instagram.com/reel/DY7SahztrRj/",
        "DY7SahztrRj"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("devil_port369-owner/instagram-comments").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 = { "post_urls": [
        "https://www.instagram.com/reel/DY7SahztrRj/",
        "DY7SahztrRj",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("devil_port369-owner/instagram-comments").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 '{
  "post_urls": [
    "https://www.instagram.com/reel/DY7SahztrRj/",
    "DY7SahztrRj"
  ]
}' |
apify call devil_port369-owner/instagram-comments --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bulk Instagram Comments Scraper",
        "description": "Scrape Instagram comments at scale from any public post, reel, or TV content. Extract engagement data, commenter profiles, sentiment insights, and detailed comment metadata in seconds.",
        "version": "0.0",
        "x-build-id": "fVLfNtbLIexIOfX39"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/devil_port369-owner~instagram-comments/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-devil_port369-owner-instagram-comments",
                "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/devil_port369-owner~instagram-comments/runs": {
            "post": {
                "operationId": "runs-sync-devil_port369-owner-instagram-comments",
                "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/devil_port369-owner~instagram-comments/run-sync": {
            "post": {
                "operationId": "run-sync-devil_port369-owner-instagram-comments",
                "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": [
                    "post_urls",
                    "max_comments"
                ],
                "properties": {
                    "post_urls": {
                        "title": "Targeted media links URLs or post ids",
                        "type": "array",
                        "description": "Enter Instagram posts links",
                        "items": {
                            "type": "string"
                        }
                    },
                    "max_comments": {
                        "title": "Max followings to fetch (0 = unlimited)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of comments to fetch from the post. Set to 0 for unlimited.",
                        "default": 15
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
