# Instagram Comments (0.5$/1K 🤑) (`karamelo/instagram-comments-scraper`) Actor

Extract comments, replies, commenter profiles, timestamps, and engagement metrics from Instagram posts and reels without login. Cost-efficient  (0.5$/1K 🤑)

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

## Pricing

$0.50 / 1,000 results

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/actors/running/actors-in-store.md#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 extracts public comments, nested comment replies, commenter profile details, timestamps, and engagement metrics from Instagram posts and reels. Designed for social listening, community management, competitive research, influencer auditing, and sentiment analysis, this Actor collects structured comment data directly into datasets ready for export in JSON, CSV, Excel, or integration with external automation tools.

Operating in high-throughput batch mode, the Actor processes both single post URLs and large lists of target links or shortcodes. Whether analyzing audience reactions to a viral reel, tracking customer feedback under promotional announcements, or feeding large language models with conversational social data, it delivers clean, normalized, flat records without requiring user account credentials or session cookies.

### Why use Instagram Comments Scraper?

- **Zero login requirement** — Extract public comments and replies without providing personal Instagram account credentials, session tokens, or private browser cookies.
- **Deep conversation coverage** — Supports optional extraction of nested child replies under top-level parent comments, preserving the complete conversation hierarchy.
- **Rich commenter metadata** — Collects author username, unique user ID, full name, profile picture link, verification status, and account privacy indicators alongside every message.
- **Granular engagement metrics** — Captures individual comment like counts, reply counts, exact publication timestamps in ISO 8601 UTC format, and unique comment identifiers.
- **Multi-format target input** — Accepts standard post links, reel links, video links, direct shortcodes, or raw numeric media identifiers with automatic format detection.
- **Configurable extraction limits** — Set overall comment limits and per-post limits to maintain precise budget control and predictable run times.
- **Post caption context capture** — Automatically extracts the original post caption alongside every comment record, giving full context to audience discussions without separate queries.
- **Export-ready flat schema** — Outputs fully flat records optimized for immediate spreadsheet analysis, database ingestion, and business intelligence dashboards.

### Who needs this Actor?

- **Social Media Managers & Community Teams**: Monitor audience feedback, measure audience sentiment on brand campaigns, identify frequent commenters, and detect customer support inquiries or product questions hidden inside high-volume comment sections.
- **Brand Protection & PR Specialists**: Detect negative brand discourse, spot emerging public relations crises, track coordinated spam campaigns, and flag policy violations or impersonation across brand social channels.
- **Market Researchers & Consumer Analysts**: Conduct qualitative and quantitative consumer research by gathering real opinions, objections, and spontaneous feedback regarding products, competitors, or industry events.
- **Data Scientists & Machine Learning Engineers**: Collect diverse, human-written conversational text for training NLP classifiers, fine-tuning language models, evaluating aspect-based sentiment, and building topic clustering pipelines.
- **Influencer Marketing & Talent Agencies**: Audit influencer post authenticity, analyze follower engagement quality, evaluate audience tone, and identify true brand advocates versus generic bot engagement.
- **E-Commerce & DTC Brands**: Discover product feature requests, monitor unboxing reactions, identify common sizing or shipping concerns, and extract authentic testimonials for marketing optimization.

### Getting started

Running the Instagram Comments Scraper takes only a few simple steps from the Apify Console or via API.

#### Quick start through the Console

1. Open the Actor page in the Apify Console.
2. In the **Post or Reel URLs** field, paste one or more public Instagram post or reel URLs.
3. Set a conservative limit in **Max comments (total)**, such as 50 or 100, for your initial test run.
4. Keep the default Apify residential proxy configuration enabled to ensure seamless network routing.
5. Click the **Save & Start** button at the bottom of the page.
6. Once the run completes, navigate to the **Storage** tab to inspect the extracted comments in the dataset overview or download them as CSV, JSON, or Excel.

#### Configuration examples

##### Example 1: Basic run with post URLs

The simplest run takes one or more post URLs and extracts top-level comments up to the configured limit.

```json
{
  "startUrls": [
    "https://www.instagram.com/p/DdFFajKABI4/"
  ],
  "maxComments": 100,
  "maxCommentsPerPost": 100,
  "includeReplies": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

##### Example 2: Multi-post collection with nested replies

To collect a comprehensive view of conversations including threaded replies across multiple posts or reels, enable the `includeReplies` option and supply multiple URLs.

```json
{
  "startUrls": [
    "https://www.instagram.com/p/DdFFajKABI4/",
    "https://www.instagram.com/reel/DCKDRSpiy3b/"
  ],
  "maxComments": 500,
  "maxCommentsPerPost": 250,
  "includeReplies": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

##### Example 3: Extraction by post shortcodes or media IDs

When integrating with databases or content management systems where post shortcodes or numeric media identifiers are already cataloged, you can pass them directly via `postIds`.

```json
{
  "postIds": [
    "DdFFajKABI4",
    "3982613260166763064"
  ],
  "maxComments": 200,
  "maxCommentsPerPost": 100,
  "includeReplies": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

##### Example 4: Focused extraction with full replies and high volume

Extract comprehensive discussions from high-engagement posts with threaded replies enabled.

```json
{
  "startUrls": [
    "https://www.instagram.com/p/DdFFajKABI4/"
  ],
  "maxComments": 150,
  "maxCommentsPerPost": 150,
  "includeReplies": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

### Input parameters reference

The table below outlines all available input options, their data types, default values, and operational behaviors.

| Parameter | Type | Default | Required | Description |
|---|---|---|---|---|
| `startUrls` | Array of strings | `[]` | No | List of public Instagram post or reel URLs (e.g., `https://www.instagram.com/p/...` or `https://www.instagram.com/reel/...`). Query parameters and trailing slashes are handled automatically. |
| `postIds` | Array of strings | `[]` | No | List of Instagram post shortcodes (e.g., `DdFFajKABI4`) or numeric media IDs (e.g., `3982613260166763064`). May be combined with `startUrls`. |
| `maxComments` | Integer | `100` | No | Total maximum number of comments to extract across the entire run. Extraction terminates as soon as this limit is reached. |
| `maxCommentsPerPost` | Integer | `100` | No | Maximum number of comments to collect per individual post or reel. Enables balanced sampling across multi-post runs. |
| `includeReplies` | Boolean | `false` | No | When set to `true`, extracts nested child replies under parent comments in addition to top-level comments. |
| `proxyConfiguration` | Object | `{"useApifyProxy": true}` | No | Proxy settings for network requests. Apify residential proxies are strongly recommended for high reliability on Instagram. |

### Output data structure

Each extracted comment is pushed to the run's default dataset as an independent, structured record. Top-level comments and nested replies share the same uniform schema, allowing immediate export to tabular formats like CSV or relational database tables without nested unnesting operations.

#### Output record example

```json
{
  "id": "18068674361751476",
  "postId": "DdFFajKABI4",
  "postUrl": "https://www.instagram.com/p/DdFFajKABI4/",
  "postText": "Hard work pays off 🟡🔵",
  "commentText": "The greatest of all time! 🐐⚽",
  "type": "comment",
  "createdAt": "2024-09-09T18:22:10.000Z",
  "likesCount": 42,
  "replyCount": 3,
  "ownerId": "2309546356",
  "ownerUsername": "football_fan_official",
  "ownerFullName": "Football Central",
  "ownerProfilePicUrl": "https://instagram.falg6-1.fna.fbcdn.net/sample.jpg",
  "ownerIsVerified": false,
  "ownerIsPrivate": false,
  "isReply": false,
  "parentCommentId": null,
  "scrapedAt": "2026-09-12T12:15:10.000Z",
  "user": {
    "id": "2309546356",
    "username": "football_fan_official",
    "fullName": "Football Central",
    "isVerified": false,
    "isPrivate": false,
    "profilePicUrl": "https://instagram.falg6-1.fna.fbcdn.net/sample.jpg"
  }
}
```

#### Dataset field descriptions

| Field | Type | Description |
|---|---|---|
| `id` | String | Unique numerical identifier of the comment on Instagram. |
| `postId` | String | Shortcode identifying the parent Instagram post or reel. |
| `postUrl` | String | Canonical URL of the parent Instagram post or reel. |
| `postText` | String or null | Original caption or text of the Instagram post or reel, giving context to comments. |
| `commentText` | String | Full text message content of the comment or reply. |
| `type` | String | Record classification indicator: `"comment"` for top-level comments, `"reply"` for nested child replies. |
| `createdAt` | String | ISO 8601 UTC timestamp of when the comment was published on Instagram. |
| `likesCount` | Integer | Total count of likes received by this comment. |
| `replyCount` | Integer | Total number of child replies posted under this comment. |
| `ownerId` | String | Unique Instagram user ID of the comment author. |
| `ownerUsername` | String | Public Instagram handle (username) of the comment author. |
| `ownerFullName` | String or null | Public display name of the commenter, or `null` if not configured. |
| `ownerProfilePicUrl` | String or null | Direct URL to the commenter's profile avatar picture. |
| `ownerIsVerified` | Boolean | `true` if the comment author possesses a verified badge; otherwise `false`. |
| `ownerIsPrivate` | Boolean | `true` if the commenter's account is private; otherwise `false`. |
| `isReply` | Boolean | `false` for top-level parent comments; `true` for nested child replies. |
| `parentCommentId` | String or null | Unique ID of the parent comment when `isReply` is `true`; `null` for top-level comments. |
| `scrapedAt` | String | ISO 8601 UTC timestamp recording when this record was extracted by the Actor. |
| `user` | Object | Nested commenter profile summary object containing `id`, `username`, `fullName`, `isVerified`, `isPrivate`, and `profilePicUrl`. |

### Practical workflow tutorials

#### Workflow 1: Sentiment analysis on product launch announcements

Brands launching new merchandise or feature updates often receive hundreds of comments within minutes. Understanding the sentiment distribution enables rapid product adjustments and proactive support.

1. **Collect post links**: Identify the Instagram posts announcing the new product.
2. **Configure inputs**: Enter the post URLs in `startUrls`, set `maxComments` to `1000`, set `includeReplies` to `true`, and run the Actor.
3. **Retrieve the dataset**: Export the resulting dataset as JSON or CSV.
4. **Process sentiment**: In Python or an NLP pipeline, pass the `commentText` field through a sentiment classifier (such as VADER, RoBERTa, or an LLM prompt) to score positivity, neutrality, and negativity.
5. **Segment by commenter verification**: Cross-reference sentiment against `ownerIsVerified` and `likesCount` to spotlight feedback from industry figures or high-impact community members.
6. **Actionable deliverable**: Generate a launch sentiment summary report highlighting top praise themes and recurring customer questions.

#### Workflow 2: Identifying organic brand advocates and micro-influencers

Audiences who regularly leave thoughtful, high-engagement comments on brand channels represent prime candidates for ambassador and influencer partnership programs.

1. **Select target posts**: Identify the top 10 most popular posts on your brand's profile over the past quarter.
2. **Execute extraction**: Run the Actor with the list of post URLs, setting `maxCommentsPerPost` to `200`.
3. **Aggregate author data**: Group records by `ownerUsername` and `ownerId` to calculate comment frequency per user.
4. **Evaluate engagement**: Sum `likesCount` received across all comments by each author to measure how resonated their commentary was with other followers.
5. **Filter criteria**: Filter for authors with `ownerIsVerified == false` (identifying genuine organic users rather than established public figures) and non-private profiles (`ownerIsPrivate == false`).
6. **Outreach pipeline**: Export candidate profiles into your influencer relationship management tool or CRM for personalized partnership outreach.

#### Workflow 3: Competitor post benchmarking and customer question mining

Analyzing the comment sections of major competitors reveals customer pain points, feature desires, and service gaps that your product can address.

1. **Curate competitor URLs**: Identify key promotional or educational posts published by leading competitors in your niche.
2. **Configure inputs**: Supply the list of target post URLs and set `maxCommentsPerPost` to a representative sample size such as `250` or `500`.
3. **Execute collection**: Start the Actor run to harvest all public comments and optional nested discussion threads.
4. **Analyze opportunities**: Filter or search the resulting dataset for recurring inquiry patterns (such as pricing, shipping, sizing, product compatibility, or recurring complaints).
5. **Strategy implementation**: Use the extracted inquiries to refine your own product messaging, FAQ documentation, and competitive ad campaigns.

### Programmatic API usage

The Actor can be integrated into existing backends, microservices, and automated pipelines using the Apify API and official SDKs.

#### JavaScript and Node.js

Install the official JavaScript client using `npm install apify-client`.

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

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

const runInput = {
    startUrls: [
        'https://www.instagram.com/p/DdFFajKABI4/'
    ],
    maxComments: 100,
    includeReplies: false,
    proxyConfiguration: {
        useApifyProxy: true
    }
};

// Start the Actor run and wait for it to finish
const run = await client.actor('karamelo/instagram-comments-scraper').call(runInput);

// Fetch items from the default dataset
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Retrieved ${items.length} comments:`);
items.forEach((item) => {
    console.log(`[${item.ownerUsername}]: ${item.commentText} (${item.likesCount} likes)`);
});
```

#### Python

Install the official Python client using `pip install apify-client`.

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.getenv("APIFY_TOKEN"))

run_input = {
    "startUrls": [
        "https://www.instagram.com/p/DdFFajKABI4/"
    ],
    "maxComments": 100,
    "includeReplies": False,
    "proxyConfiguration": {
        "useApifyProxy": True
    }
}

run = client.actor("karamelo/instagram-comments-scraper").call(run_input=run_input)

dataset_items = client.dataset(run["defaultDatasetId"]).iterate_items()
for comment in dataset_items:
    print(f"[{comment['ownerUsername']}]: {comment['commentText']} (Likes: {comment['likesCount']})")
```

#### cURL (REST API)

You can trigger a synchronous run directly using cURL:

```bash
curl --request POST \
  --url "https://api.apify.com/v2/acts/karamelo~instagram-comments-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  --header "Content-Type: application/json" \
  --data '{
    "startUrls": ["https://www.instagram.com/p/DdFFajKABI4/"],
    "maxComments": 50,
    "includeReplies": false,
    "proxyConfiguration": {"useApifyProxy": true}
  }'
```

### Platform integrations and data export

Data collected by the Actor can be exported directly or synchronized with third-party systems through built-in Apify platform capabilities:

- **Direct file exports**: Download dataset items in JSON, CSV, XML, Excel (.xlsx), or HTML table format directly from the Apify Console or through API download endpoints.
- **Google Sheets & Airtable**: Automatically push newly scraped comments into live spreadsheets using Apify integration connectors or Zapier/Make webhooks.
- **Webhooks & alerting**: Set up webhooks triggered on run completion to dispatch notifications to Slack channels, Discord webhooks, or internal notification services.
- **Cloud storage & databases**: Stream dataset exports into Amazon S3 buckets, Google Cloud Storage, BigQuery, Snowflake, or PostgreSQL using automated Apify integrations.

### Pricing model

The Instagram Comments Scraper operates on a **Pay-Per-Event** pricing model, charging solely for the actual comment records delivered into the default dataset:

- **Rate**: $0.50 per 1,000 comments ($0.0005 per comment item).
- **No charge for empty runs**: If a post has no comments or cannot be accessed, you are not charged event fees for missing results.
- **Transparent scale**: Pay only for what you extract, with linear predictability regardless of post count.

| Extracted comments | Estimated Actor event cost |
|---:|---:|
| 100 comments | $0.05 |
| 500 comments | $0.25 |
| 1,000 comments | $0.50 |
| 5,000 comments | $2.50 |
| 10,000 comments | $5.00 |
| 50,000 comments | $25.00 |

*Note: Standard Apify platform resource consumption (compute units and proxy bandwidth) applies according to your Apify subscription tier.*

### Limitations and operational boundaries

- **Public posts only**: The Actor can only collect comments from public Instagram posts and reels. Posts belonging to private accounts cannot be accessed without authorization and are not supported.
- **Post-level comment disabled**: If a post author has completely disabled comments on their publication, the Actor will detect that no comments are available and conclude without error.
- **Filtered or hidden comments**: Comments automatically filtered or flagged as offensive by Instagram's native anti-spam moderation algorithms or the creator's blocked word lists are not served in public web responses.
- **Proxy dependency**: Instagram employs strict network rate limits on web endpoints. It is essential to keep Apify residential proxies enabled (`"useApifyProxy": true`) to prevent requests from being throttled.
- **Real-time freshness**: Comment counts and likes update continuously on Instagram. Extracted values represent the exact state observed at the moment of the request.

### Troubleshooting guide

| Symptom | Probable cause | Recommended solution |
|---|---|---|
| Actor finishes with 0 comments | Post is private or has comments disabled | Verify that the target post URL is viewable in an incognito browser window without logging into Instagram. |
| Actor extracts fewer comments than `maxComments` | Post has fewer total comments than the limit | Check the actual public comment count on the post. Extraction stops naturally when all available comments are collected. |
| Rate limit or throttling error | Proxy settings disabled or misconfigured | Ensure `proxyConfiguration` has `"useApifyProxy": true` and default residential proxy groups enabled. |
| Invalid target URL error | Malformed URL or non-post link provided | Ensure target links match `https://www.instagram.com/p/...` or `https://www.instagram.com/reel/...`, or provide raw shortcodes. |

### Frequently asked questions

##### Does this Actor require an Instagram account or login cookies?

No. The Actor operates entirely on public web data and does not require account credentials, passwords, session tokens, or browser cookies.

##### Can I extract comments from Instagram Reels?

Yes. Reels URLs (such as `https://www.instagram.com/reel/SHORTCODE/`) are fully supported alongside standard photo and carousel post links.

##### How do nested replies work?

By default, `includeReplies` is set to `false` to optimize speed and collect primary feedback. Setting `includeReplies` to `true` instructs the Actor to collect child comments posted under parent comments, marking them with `isReply: true` and attaching their `parentCommentId`.

##### Can I scrape comments from multiple posts in a single run?

Yes. You can supply multiple links in `startUrls` and multiple shortcodes in `postIds`. The Actor processes each target sequentially and aggregates all comments into a single dataset.

##### What happens if a comment contains emojis or non-Latin characters?

All comment text is preserved in complete UTF-8 encoding, accurately retaining emojis, international scripts, punctuation, and formatting.

##### How do I control my run expenses?

Set conservative boundaries for both `maxComments` (overall run ceiling) and `maxCommentsPerPost` (per-post ceiling). This prevents unintended large collections on viral posts with tens of thousands of comments.

### Responsible use and compliance

When collecting public social media data, users are responsible for ensuring that their data harvesting practices and downstream use cases comply with applicable data protection legislation (including GDPR, CCPA, and regional equivalents) and relevant platform terms of service. Avoid scraping private personal data, respect user deletion and privacy choices, and implement appropriate data retention and security safeguards for all extracted content.

# Actor input Schema

## `startUrls` (type: `array`):

Instagram post or reel URLs to scrape comments from (e.g., https://www.instagram.com/p/DdFFajKABI4/ or https://www.instagram.com/reel/DCKDRSpiy3b/).

## `postIds` (type: `array`):

Instagram post shortcodes (e.g., DdFFajKABI4) or numeric media IDs (e.g., 3982613260166763064).

## `maxComments` (type: `integer`):

Maximum total number of comments to extract across all posts. The run finishes once this limit is reached.

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

Maximum number of comments to extract from each individual post or reel.

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

Whether to extract nested reply comments under parent comments.

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

Select proxy settings. Apify residential proxies are strongly recommended for reliable Instagram scraping.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.instagram.com/p/DdFFajKABI4/"
  ],
  "postIds": [],
  "maxComments": 100,
  "maxCommentsPerPost": 100,
  "includeReplies": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        "https://www.instagram.com/p/DdFFajKABI4/"
    ],
    "postIds": []
};

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

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

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    "https://www.instagram.com/p/DdFFajKABI4/"
  ],
  "postIds": []
}' |
apify call karamelo/instagram-comments-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,karamelo/instagram-comments-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/bb0o4QAeB76kRqn2g/builds/mAh8Cgjdga3pwziUP/openapi.json