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. To look up a handle next, pass engager_profile_url to 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, 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 to pull bio, followers, verification, business category, and recent posts.
• For the posts themselves (caption, media, author stats), discover them with Instagram Posts Scraper or 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 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

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

Example input — batch with enrichment on

{
    "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

{
    "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)

{
    "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)

{
    "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, 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:

{
    "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 before you run; that page is the current source of truth for effective prices on your plan.

API example

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

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 to confirm followers, bio, and business category → load into your CRM or sequencer.
• Natural chain 2 (content research): start with Instagram Reels Scraper or 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 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 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.