# Instagram Post Engagers Scraper (`khadinakbar/instagram-post-engagers-scraper`) Actor

Extract Instagram post engagers from public post and Reel URLs: commenter usernames, profile URLs, comments, and optional follower enrichment. Provider-backed, cookieless, MCP-ready.

- **URL**: https://apify.com/khadinakbar/instagram-post-engagers-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (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

from $8.00 / 1,000 instagram engager founds

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 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 Post Engagers Scraper

Extract the people engaging with public Instagram posts and Reels. Paste one or more `/p/` or `/reel/` URLs and get one clean dataset row per engager: username, profile URL, their comment, likes on that comment, and the source post URL. Turn on enrichment and every engager row can also carry follower count, biography, category, website, and location when those fields are public — a prospect list you can hand straight to an outreach tool, without any Instagram login or cookies.

Designed for agencies, creator marketers, and outreach teams who need prospecting lists built from people who visibly interact with campaign, competitor, or niche posts. Commenters are the highest-intent engagers on Instagram: they wrote something, which makes them warmer leads than passive likers. To scrape comments as the primary entity instead, use [Instagram Comments Scraper](https://apify.com/khadinakbar/instagram-comments-scraper). To look up a handle next, pass `engager_profile_url` to [Instagram Profile Scraper](https://apify.com/khadinakbar/instagram-profile-scraper).

### What you get

| Output | What it answers |
|---|---|
| `engager_username` + `engager_profile_url` | **Who** engaged — a public handle, not just a count |
| `comment_text` + `comment_like_count` + `comment_created_at` | **What** they said, when, and how much traction the comment got |
| `post_url` + `shortcode` + `position` | **Context** — which post or Reel they engaged with and where in the comment list |
| `follower_count`, `biography`, `engager_location` (enriched) | **Who they are** on Instagram when the public profile exposes it |
| `provider`, `scraped_at`, `OUTPUT` / `RUN_SUMMARY` outcomes | **Provenance** — source, freshness, and run outcome |

### Who it is for (and why it matters)

- **Creator and talent agencies** — turn a viral Reel's comment section into a list of people already talking about the brand, then route warm handles into outreach or talent scouting.
- **Social growth teams** — capture commenters on competitor posts and campaign Reels so follow-up is personalized with the actual comment text instead of a cold DM.
- **Influencer marketers** — collect public handles from a niche post, enrich for follower count, and pre-qualify micro-influencers before you pitch.
- **E-commerce and DTC brands** — map who engages with product launch Reels and UGC posts, then segment by follower tier for seeding or affiliate outreach.
- **Community managers** — export commenter handles from high-engagement posts to build a community watchlist or ambassador shortlist.
- **AI agents and internal automation** — turn Instagram engagement into structured JSON for a research, enrichment, or CRM pipeline (details in the agent section below).

### When to use this Actor

- Build a prospect list from people commenting on a campaign, competitor, or niche post.
- Capture commenter handles from a Reel URL and keep the comment text for personalization.
- Enrich public commenter profiles with follower count and biography before outreach.
- Feed CRM or AI outreach workflows with engagement context — username, profile URL, and comment text.
- Batch up to 100 post URLs per run for competitor monitoring or multi-campaign reporting.
- Continue a previous single-post run with `initialCursor` when you need the next page of commenters.
- Schedule a re-run of the same post URLs to pick up new visible commenters as a post gains traction.

### Best fit & sibling routing

- For comments as the primary entity (thread rows rather than people-rows), start with [Instagram Comments Scraper](https://apify.com/khadinakbar/instagram-comments-scraper), then continue with this Actor when you want one engager row per commenter plus optional profile enrichment.
- For the commenter's public profile next, pass `engager_profile_url` to [Instagram Profile Scraper](https://apify.com/khadinakbar/instagram-profile-scraper) to pull bio, followers, verification, business category, and recent posts.
- For the posts themselves (caption, media, author stats), discover them with [Instagram Posts Scraper](https://apify.com/khadinakbar/instagram-posts-scraper) or [Instagram Reels Scraper](https://apify.com/khadinakbar/instagram-reels-scraper), then feed those URLs here for the people layer.
- For a unified Instagram MCP tool across profiles, posts, Reels, and comments, pair this Actor with [Instagram MCP Server](https://apify.com/khadinakbar/instagram-mcp-server) in agent pipelines where the agent picks the right mode per step.
- This Actor is optimized for public `/p/`, `/reel/`, and `/tv/` URLs. Profile pages, hashtag pages, and login-only content sit outside the contract; liker identity lists sit outside public no-login provider data, so the shipped engager type is commenters.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `postUrls` | array | example Reel URL | Public Instagram `/p/` or `/reel/` URLs (up to 100 per run) |
| `startUrls` | array | example request object | Alternative Apify request-list input for `/p/`, `/reel/`, or `/tv/` URLs |
| `maxEngagersPerPost` | integer | 100 | Cap engager rows saved per URL (output + cost cap) |
| `maxPagesPerPost` | integer | 20 | Provider pagination depth per post (~15 commenters per page) |
| `enrichProfiles` | boolean | false | Add public follower count, biography, location when available ($0.014/row extra) |
| `providerOrder` | enum | `scrapecreators-first` | Data provider priority; fallback fires automatically |
| `initialCursor` | string | — | Continue a previous single-post run using `nextCursor` from `RUN_SUMMARY` |
| `includeRawData` | boolean | false | Attach a compact provider payload fragment on each row |

Accepted URL forms include full URLs with query strings, bare shortcodes such as `DOq6eV6iIgD`, and Apify `startUrls` request objects. Duplicate or near-identical post URLs are deduplicated automatically, so you can feed a loosely scrubbed list without double-charging the same post.

#### Example input — single Reel, enrichment off

```json
{
    "postUrls": [
        "https://www.instagram.com/reel/DOq6eV6iIgD/"
    ],
    "maxEngagersPerPost": 20,
    "enrichProfiles": false
}
```

#### Example input — batch with enrichment on

```json
{
    "postUrls": [
        "https://www.instagram.com/reel/DOq6eV6iIgD/",
        "https://www.instagram.com/p/DOq6eV6iIgD/"
    ],
    "maxEngagersPerPost": 50,
    "enrichProfiles": true,
    "providerOrder": "scrapecreators-first"
}
```

#### Example input — startUrls + shortcode + pagination

```json
{
    "startUrls": [
        { "url": "https://www.instagram.com/reel/DOq6eV6iIgD/" }
    ],
    "postUrls": [
        "DOq6eV6iIgD"
    ],
    "maxEngagersPerPost": 100,
    "maxPagesPerPost": 2,
    "initialCursor": "AQHTJEAIQoIpZK-gp0VMirB3RXbRHpsfCTKHc2idkp3BT1Vroq3Sw5_VrhROoEMInszNadCNC9SaY10CZJtQXoEwIQ",
    "enrichProfiles": false,
    "includeRawData": false
}
```

### Output

One dataset row per engager. Fields:

| Field | Always present | Description |
|---|---|---|
| `record_type` | yes | Always `engager` |
| `engagement_type` | yes | Always `commenter` |
| `engager_username` | when exposed | Public Instagram handle |
| `engager_profile_url` | when exposed | `https://www.instagram.com/{username}/` |
| `engager_id` | when exposed | Numeric Instagram user ID from the provider |
| `engager_is_verified` | when exposed | Verification badge flag |
| `engager_profile_pic_url` | when exposed | Public profile picture CDN URL |
| `comment_text` | when exposed | Visible comment text |
| `comment_id` | when exposed | Provider comment identifier |
| `comment_created_at` | when exposed | Comment timestamp from the provider |
| `comment_like_count` | when exposed | Likes on that comment |
| `position` | yes | Position within the visible comment list (starts at 1) |
| `page_number` | yes | Provider pagination page where the row was found |
| `post_url`, `shortcode`, `input_url` | yes | Source post attribution |
| `source_cursor`, `next_cursor_at_fetch` | when exposed | Pagination cursors for continuation runs |
| `enriched` | yes | Whether public-profile enrichment was added |
| `follower_count`, `biography`, `engager_location` | enriched rows | Public profile enrichment fields |
| `current_company_name`, `current_company_url` | enriched rows | Business/category context when exposed |
| `enrichment_provider` | enriched rows | Which provider supplied the profile lookup |
| `provider`, `scraped_at`, `run_id` | yes | Provenance and freshness |
| `raw_data` | optional | Compact provider fragment when `includeRawData` is true |

Every terminal run also writes `OUTPUT` and `RUN_SUMMARY` records with `outcome` (`COMPLETE` / `PARTIAL` / `VALID_EMPTY` / `INVALID_INPUT` / `UPSTREAM_FAILED` / `CONFIG_ERROR`), per-URL results, provider diagnostics, pagination cursors, and billing counters.

#### Example output row — plain (live field shape)

```json
{
    "record_type": "engager",
    "engagement_type": "commenter",
    "provider": "scrapecreators",
    "input_url": "https://www.instagram.com/reel/DOq6eV6iIgD/",
    "post_url": "https://www.instagram.com/reel/DOq6eV6iIgD/",
    "shortcode": "DOq6eV6iIgD",
    "comment_id": "17877191487459886",
    "comment_text": "So true! if my dog doesnt like you? Your out",
    "comment_created_at": "2026-01-07T09:48:19.000Z",
    "comment_like_count": 0,
    "engager_username": "tracyjh64",
    "engager_id": "554153983",
    "engager_is_verified": false,
    "engager_profile_url": "https://www.instagram.com/tracyjh64/",
    "position": 1,
    "page_number": 1,
    "enriched": false,
    "follower_count": null,
    "biography": null,
    "engager_location": null,
    "scraped_at": "2026-08-18T11:44:57.637Z"
}
```

#### Example output row — enriched (expected field shape)

```json
{
    "record_type": "engager",
    "engagement_type": "commenter",
    "provider": "scrapecreators",
    "post_url": "https://www.instagram.com/reel/DOq6eV6iIgD/",
    "shortcode": "DOq6eV6iIgD",
    "comment_text": "This is exactly what we needed for our launch!",
    "comment_created_at": "2026-02-14T18:22:11.000Z",
    "comment_like_count": 12,
    "engager_username": "creatorstudio.nyc",
    "engager_profile_url": "https://www.instagram.com/creatorstudio.nyc/",
    "position": 2,
    "page_number": 1,
    "enriched": true,
    "follower_count": 8420,
    "biography": "NYC creator agency | UGC & brand collabs",
    "engager_location": "New York, New York",
    "current_company_name": "Creator Studio NYC",
    "enrichment_provider": "scrapecreators",
    "scraped_at": "2026-08-18T12:00:00.000Z"
}
```

### Workflow story: from a competitor Reel to a prospect list

A talent-agency researcher starts with a competitor Reel URL. She pastes it into this Actor with `maxEngagersPerPost: 50` and `enrichProfiles: true`. The run starts, the URL is fetched through the provider chain, and one row per visible commenter lands in the dataset. She filters rows where `follower_count` is between 5K and 50K, exports the shortlist to Sheets, then passes the warmest `engager_profile_url` values to Instagram Profile Scraper to confirm recent posts before outreach. Total elapsed time: a few minutes, total event cost under a dollar for a typical mid-size Reel.

### Workflow story: batch competitor monitoring

A growth lead at a skincare brand collects ten competitor launch Reel URLs from [Instagram Reels Scraper](https://apify.com/khadinakbar/instagram-reels-scraper), then feeds them into this Actor in one batch with `maxEngagersPerPost: 100`. Each post produces its own engager rows tagged by `post_url`. She deduplicates across the batch by `engager_username`, flags handles that appear on three or more competitor posts as high-intent, and schedules a weekly re-run to capture new commenters as posts accumulate engagement.

### Why AI agents and MCP clients choose this Actor

This Actor is built MCP-first — a single tool call with `postUrls` returns structured engager rows — which makes it a natural step in an agentic research or outreach pipeline. What agents weigh when picking a tool:

- **A predictable, bounded cost before the call.** The run prints the PPE cap from `maxEngagersPerPost` before charges fire, and only rows actually saved to the dataset are billed as `engager-found`.
- **Structured, schema-valid output.** Every row uses the same stable keys (`engager_username`, `engager_profile_url`, `comment_text`, `scraped_at`), nulls are explicit, and the dataset has a published schema — so downstream tools and the agent's own JSON parser validate cleanly without guessing.
- **Honest, machine-readable provenance.** Each row carries `provider` and `scraped_at`; each run carries `outcome` and per-URL diagnostics. An agent gets source and freshness signals instead of a black-box dump.
- **Explicit, machine-readable outcomes.** Every run ends in one of a small set of named outcomes, and the agent knows exactly which one without parsing logs. Invalid or non-post URLs return `INVALID_INPUT` with an actionable message; posts with no visible comment section return a clean `VALID_EMPTY` with zero fabricated rows; a fully unavailable post set ends `UPSTREAM_FAILED`. The agent can distinguish empty data, bad input, and target unreachable — then retry, adjust, or report.
- **Scope the agent can rely on.** Commenters are the engager type with identity in public data. The contract is explicit about what is included, so an agent routes to the right tool rather than over- or under-claiming coverage.

> "Given these Instagram Reel URLs, list everyone who commented, with their username, profile URL, and comment text, so I can build an outreach list."
>
> Expected behavior: dataset rows via `get-actor-output` with clean pagination; `OUTPUT` and `RUN_SUMMARY` readback for scope and provenance (`provider`, `scraped_at` on every row); unavailable posts reported per-URL in diagnostics; empty comment sections as a clean `VALID_EMPTY` outcome with zero fabricated rows; a printed PPE cap before any charge fires; and a downstream step that passes each `engager_profile_url` to a profile tool before outreach.

#### An agent tool-call example

A client can pass the saved input directly; this is the shape an agent would send to `call-actor`:

```json
{
    "postUrls": ["https://www.instagram.com/reel/DOq6eV6iIgD/"],
    "maxEngagersPerPost": 20,
    "enrichProfiles": false,
    "providerOrder": "scrapecreators-first"
}
```

Then read the results with `get-actor-output`, filtering on `engager_username`, `follower_count`, or `comment_text` to build the working list, and paginate with `offset`/`limit` for large batches.

### Pricing — Pay per event + platform usage

| Event | Price | Charged when |
|---|---|---|
| Actor start | $0.00005 | Once per run (scaled by memory) |
| `engager-found` | $0.008 | One engager row saved to the dataset |
| `engager-enriched` | $0.014 | Additional, only when a row was successfully enriched |

That is $8 per 1,000 engager rows, or $22 per 1,000 rows when enrichment fields are added.

#### Cost scenarios (typical runs)

| Run | Engager rows | Enrichment | Event cost (approx.) |
|---|---|---|---|
| One Reel, 3 visible commenters | 3 | off | ~$0.024 |
| One Reel, 20 visible commenters | 20 | off | ~$0.16 |
| One Reel, 20 commenters | 20 | on | ~$0.44 |
| 10-post batch, 100 rows | 100 | off | ~$0.80 |
| 10-post batch, 100 rows | 100 | on | ~$2.20 |

Your run log prints the cost picture as rows are saved, and only saved rows are billed. Platform usage (compute) is billed on top at Apify's rates — verify the live [Pricing tab](https://apify.com/khadinakbar/instagram-post-engagers-scraper/pricing) before you run; that page is the current source of truth for effective prices on your plan.

### API example

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~instagram-post-engagers-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "postUrls": ["https://www.instagram.com/reel/DOq6eV6iIgD/"],
    "maxEngagersPerPost": 20,
    "enrichProfiles": false
  }'
```

Results land in the run's default dataset: `https://api.apify.com/v2/datasets/{datasetId}/items?clean=true`. Paginate large batches with `offset`/`limit` on that endpoint. The same actor is exposed through Apify MCP as `apify--instagram-post-engagers-scraper` for agent clients.

#### JavaScript SDK example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('khadinakbar/instagram-post-engagers-scraper').call({
    postUrls: ['https://www.instagram.com/reel/DOq6eV6iIgD/'],
    maxEngagersPerPost: 20,
    enrichProfiles: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems({ clean: true });
console.log(items.map((row) => row.engager_username));
```

### Integrations and chaining

Rows are plain JSON — pipe the dataset into Google Sheets, Airtable, a CRM, or a profile-lookup step.

- **Natural chain 1 (lead generation):** this Actor → pass `engager_profile_url` values to [Instagram Profile Scraper](https://apify.com/khadinakbar/instagram-profile-scraper) to confirm followers, bio, and business category → load into your CRM or sequencer.
- **Natural chain 2 (content research):** start with [Instagram Reels Scraper](https://apify.com/khadinakbar/instagram-reels-scraper) or [Instagram Posts Scraper](https://apify.com/khadinakbar/instagram-posts-scraper) to surface the posts, then run their URLs through this Actor to map who is engaging with them.
- **Natural chain 3 (comment-first):** start with [Instagram Comments Scraper](https://apify.com/khadinakbar/instagram-comments-scraper) when you need the comment entity first, then use this Actor when the goal is one people-row per commenter with optional enrichment.
- **Monitoring:** schedule re-runs of the same post URLs to capture new visible commenters; deduplicate across runs by `engager_username`.
- **Enrichment fallback:** keep `enrichProfiles: true` and filter later — every row is self-contained, so you can drop enrichment fields if a downstream tool does not need them.

### Best results guidance

- Pick posts with a visible comment section: enough signal for outreach, still fully accessible through public data.
- Provide public `/p/` or `/reel/` URLs you have confirmed are currently visible.
- Start with `maxEngagersPerPost` at 20–100 so cost stays bounded while you validate the post has a useful comment section.
- For outreach lists, run with `enrichProfiles: true` and filter rows by `follower_count` against your target tier.
- Use `maxPagesPerPost` when you need deeper pagination; use `initialCursor` to continue a previous single-post run.
- Deduplicate across runs by `engager_username`; a person commenting on several of your posts is your warmest lead.
- Keep `providerOrder` at `scrapecreators-first` unless you are debugging a single provider.

### Scope, data boundary & recovery

- **Commenters are the engager type with identity in public data.** Reactions on the post itself sit outside this people-row contract; liker identities stay behind Instagram login on cookieless public-data APIs.
- **Top visible comments per post.** The data provider pages visible commenters; busier posts are capped by `maxEngagersPerPost` and `maxPagesPerPost` (flagged per post in the run summary).
- **Public-page enrichment only.** Follower count, biography, and location come from public profile pages; emails and private network data stay outside the contract. Enrichment charges only when real profile fields are present.
- **Per-URL resilience.** Provider hiccups route to the second provider automatically; a run with at least one working URL finishes as `PARTIAL` with diagnostics, a run where every URL is unavailable ends `UPSTREAM_FAILED`, and only saved rows are billed.
- **Input validation.** Missing or non-post URLs exit fast as `INVALID_INPUT` with an actionable message.

### Focused standalone workflow

This Actor is designed as a focused standalone workflow: post or Reel URL in, engager rows out, with optional enrichment. Use it on its own when you already have the URLs. Continue with sibling Actors only when the next job is profile lookup or comment-thread research.

### Builder's note

I built this after the LinkedIn Post Engagers Actor: agencies asked for the same "who engaged with this URL" workflow on Instagram. I found both ScrapeCreators and SociaVault expose commenter identities on public posts, while liker identities stay behind login — so I shipped an honest commenters contract with dual-provider fallback. In my testing, raw commenter rows (handle + URL) answered "who", but outreach teams kept asking "how big is this account" — that is why enrichment (followers, biography, location) is a first-class option rather than an afterthought. The same probe drove the recommended 20–100 engager sweet spot per post: big enough to be meaningful, small enough to stay fully within public visibility and predictable billing.

### FAQ

**How many engagers do I get per post?**
The public provider pages of visible commenters, capped by `maxEngagersPerPost` and `maxPagesPerPost`. The cap never invents hidden likers.

**Can I get liker identities?**
Public no-login provider routes expose commenters with identity. Liker rosters sit behind Instagram login, so this Actor ships an honest commenters contract.

**Is Instagram login or cookies required?**
This Actor runs entirely on public, no-login data through its provider chain. You never supply cookies, credentials, or a personal Instagram account.

**What happens if a post is deleted or restricted?**
It is reported per-URL in the `OUTPUT` diagnostics. Runs with at least one working URL still finish with useful data; a run where every URL is unavailable ends `UPSTREAM_FAILED`, and only rows actually saved are charged.

**What URL formats are accepted?**
Full `/p/`, `/reel/`, and `/tv/` URLs (with or without query strings), bare shortcodes, and Apify `startUrls` request objects.

**Can I continue pagination from a previous run?**
Yes — pass `initialCursor` from `RUN_SUMMARY` when exactly one target URL is supplied.

**Can an AI agent use this?**
Yes — it is MCP-ready and exposes one `postUrls`-in, structured-rows-out tool. Agents get schema-valid rows, provenance, cost caps, and honest `outcome` readback, so they can decide whether and how to use the result.

### Legal

This Actor retrieves publicly available data. You are responsible for complying with Instagram's Terms of Service, applicable data-protection laws (GDPR/CCPA), and Apify's [Exclusion Policy](https://apify.com/terms/exclusion-policy) when using the results. You are responsible for using the data in a manner authorized by those terms and applicable laws. This is not an official Instagram product.

# Actor input Schema

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

Public Instagram post or Reel URLs to extract engagers from. Accepts https://www.instagram.com/p/CODE/ and https://www.instagram.com/reel/CODE/. Up to 100 URLs per run. Not for profile URLs, hashtags, private posts, or login-only content.

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

Alternative Apify request-list input for Instagram /p/, /reel/, or /tv/ URLs. Use this when another actor or agent passes request objects. Not for usernames, hashtag pages, or explore URLs.

## `maxEngagersPerPost` (type: `integer`):

Maximum engager rows to save per URL. Default 100. Range 1 to 50000. This caps output volume and cost; it does not invent hidden likers.

## `maxPagesPerPost` (type: `integer`):

Maximum provider pagination pages to request per post. Defaults to 20. Each page usually returns around 15 commenters. Use maxEngagersPerPost for the row cap.

## `providerOrder` (type: `string`):

Which managed public-data API is tried first. ScrapeCreators is the recommended primary and SociaVault is the fallback. Use single-provider modes only when debugging.

## `initialCursor` (type: `string`):

Optional provider cursor for continuing a previous single-post run. Use nextCursor from RUN\_SUMMARY. Only applies when exactly one target URL is supplied.

## `enrichProfiles` (type: `boolean`):

When enabled, each engager username is looked up for follower count, biography, category, website, and location when the public profile exposes them. Enrichment costs an additional $0.014 per successfully enriched row on top of $0.008 per engager.

## `includeRawData` (type: `boolean`):

Attach the raw provider comment object to each dataset row for debugging custom fields. Defaults to false because raw payloads increase dataset size and token usage.

## Actor input object example

```json
{
  "postUrls": [
    "https://www.instagram.com/reel/DOq6eV6iIgD/"
  ],
  "startUrls": [
    {
      "url": "https://www.instagram.com/reel/DOq6eV6iIgD/"
    }
  ],
  "maxEngagersPerPost": 100,
  "maxPagesPerPost": 20,
  "providerOrder": "scrapecreators-first",
  "enrichProfiles": false,
  "includeRawData": false
}
```

# Actor output Schema

## `output` (type: `string`):

Terminal outcome envelope.

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

Dataset API URL for saved Instagram engager rows.

## `runSummary` (type: `string`):

Per-target status summary and provider diagnostics.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "postUrls": [
        "https://www.instagram.com/reel/DOq6eV6iIgD/"
    ],
    "startUrls": [
        {
            "url": "https://www.instagram.com/reel/DOq6eV6iIgD/"
        }
    ],
    "maxEngagersPerPost": 100,
    "maxPagesPerPost": 20,
    "enrichProfiles": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/instagram-post-engagers-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "postUrls": ["https://www.instagram.com/reel/DOq6eV6iIgD/"],
    "startUrls": [{ "url": "https://www.instagram.com/reel/DOq6eV6iIgD/" }],
    "maxEngagersPerPost": 100,
    "maxPagesPerPost": 20,
    "enrichProfiles": False,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/instagram-post-engagers-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 '{
  "postUrls": [
    "https://www.instagram.com/reel/DOq6eV6iIgD/"
  ],
  "startUrls": [
    {
      "url": "https://www.instagram.com/reel/DOq6eV6iIgD/"
    }
  ],
  "maxEngagersPerPost": 100,
  "maxPagesPerPost": 20,
  "enrichProfiles": false
}' |
apify call khadinakbar/instagram-post-engagers-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/instagram-post-engagers-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/Oxi0ygdnJgnZbltvC/builds/KdPd0ggX1tdZwahri/openapi.json