Instagram Comment Scraper With Lead Generator

Instagram Comments Scraper — Comments, Replies & Owner Data

Instagram Comments Scraper pulls every top-level comment and threaded reply from any public Instagram post or reel and returns them as structured JSON — no browser, no manual scrolling. Each comment arrives with its text, timestamp, like count, reply count, and a full commenter profile object (username, verification status, privacy flag, and internal IDs), not just a name and a picture. Every response is typed JSON, ready to pass directly to an LLM for sentiment scoring, load into a spreadsheet, or feed a moderation pipeline. Point it at a handful of posts today, and it scales the same way across a hundred URLs in one run.

What is Instagram Comments Scraper?

Instagram Comments Scraper queries Instagram's internal comment-pagination GraphQL endpoints (the same ones the Instagram web app uses) for a list of post or reel URLs, and returns each top-level comment together with its threaded replies. It requires a logged-in Instagram sessionid cookie — Instagram login-walls its comment surfaces for logged-out requests, so the Actor cannot reliably read comments without one.

What sets this Actor apart from the field is the depth of the commenter object it returns: alongside username and profile picture, every comment and reply carries the account's verification status, private-account flag, mentionability flag, and internal Facebook/Instagram IDs — fields most comment scrapers document as just "username" and "profile picture." That owner object is useful on its own for filtering out private or unverified accounts before you ever look at the comment text.

No Instagram API key or developer app is involved — access is entirely through the sessionId cookie you supply and Apify's own infrastructure. That makes it a fit for anyone who wants comment data out of Instagram without registering a Meta developer app, requesting API review, or being limited to content their own connected Business account manages.

• Collects top-level comments and threaded replies from posts, reels, and IGTV URLs in one run
• Returns a full commenter profile per comment/reply — not just a username
• Orders results newest-first or most-liked-first, enforced client-side regardless of what Instagram's API returns
• Configurable per-post caps: up to 1,000 comments and 200 replies per comment
• Processes multiple post URLs in a single job, writing to one dataset in real time
• Falls back through Apify Proxy automatically if Instagram blocks a direct request

Typical users run this Instagram comment scraper for social listening on a brand's own posts, competitive research on a rival's campaign content, moderation triage on high-volume threads, or as the data-collection step in a larger sentiment-analysis or lead-generation pipeline. Because the output is flat, typed JSON, it drops directly into a spreadsheet, a data warehouse load job, or an LLM prompt without a separate parsing step.

What data can you get with Instagram Comments Scraper?

The Actor returns two result types per run — top-level comments and their nested replies — each carrying a full commenter profile object.

Result Type	Extracted Fields	Primary Use Case
Top-level comment	postUrl, commentUrl, id, text, ownerUsername, ownerProfilePicUrl, timestamp, repliesCount, replies[], likesCount, owner{}	Sentiment analysis, engagement tracking, spam triage
Reply	id, text, ownerUsername, ownerProfilePicUrl, timestamp, repliesCount, replies[], likesCount, owner{}, commentUrl	Full-thread conversation analysis
Commenter profile (owner object)	fbid_v2, full_name, id, is_mentionable, is_private, is_verified, latest_reel_media, profile_pic_id, profile_pic_url, username	Bot/spam filtering, verified-account signal, outreach lists

Comment order is a real, configurable control, not a fixed default: isNewestComments decides whether the server is asked for its recent or popular sort, and the fetched batch is then re-sorted client-side by timestamp (newest-first) or likesCount (most-liked-first) to guarantee the requested order regardless of what Instagram's own response ordering happens to be for that run.

Full Commenter Profile Data

Every comment and reply carries an owner object with ten fields, not just a display name. is_verified flags blue-check accounts, is_private flags locked accounts (useful for filtering out replies you can't cross-reference publicly), and is_mentionable and latest_reel_media come straight through from Instagram's own internal API response. Fields Instagram omits for a given account are returned as null — the Actor never fabricates a value to fill a gap. This is the field competitors' documented output tables leave out: most list "owner username" and "profile picture" and stop there.

"owner": {
  "fbid_v2": "17841400000000000",
  "full_name": null,
  "id": "1234567890",
  "is_mentionable": null,
  "is_private": false,
  "is_verified": true,
  "latest_reel_media": null,
  "profile_pic_id": null,
  "profile_pic_url": "https://scontent.cdninstagram.com/v/t51.2885-19/573688225.jpg",
  "username": "delicious.avocados07"
}

Threaded Replies

Replies are not a second dataset you have to join yourself — each top-level comment carries its own replies inline, in a replies array of the same shape as the parent comment (minus postUrl, which only top-level comments carry). Set includeNestedComments to true and give maxReplies a value to pull full conversation threads, capped per comment at the actual number of replies Instagram reports (child_comment_count) or your maxReplies value, whichever is lower.

⚠️ Limitations and honest caps

• A session cookie is functionally required, even though the schema doesn't enforce it. sessionId is not in the input schema's required list, but Instagram login-walls comment data for logged-out requests — omitting it produces a warning in the log and will likely fail to retrieve comments at all.
• Hard, documented caps: up to 1,000 comments per post and up to 200 replies per comment. Values above those are silently capped to the maximum, not rejected — there is no undocumented lower ceiling behind the schema's stated one.
• Replies can go missing without an error. If Instagram's reply-pagination query ID can't be parsed out of a post's page bundle (a site-side layout or bundling change), the Actor logs nothing about it and simply returns comments with no replies for that post — the run still succeeds.
• The key-value store OUTPUT entry is overwritten each run, not appended — it always holds only the current run's comments, not a running history.
• Posts are processed sequentially, not in parallel — one URL's comments (and its proxy retries) finish before the next URL starts.
• A non-connection error stops retries for that post. If a post fails for a reason other than a blocked/rate-limited response, the Actor logs the error and moves to the next URL without cycling through the remaining proxy tiers for that post.

Why not build this yourself?

Instagram has no public API for reading comments on an arbitrary public post. Meta's Instagram Graph API only returns comments on content a connected Business or Creator account manages itself — it has no endpoint for pulling comments off someone else's public post or reel, which is what most comment-monitoring and research use cases actually need.

Building this from scratch means reverse-engineering Instagram's internal GraphQL: extracting the current comment- and reply-pagination query IDs from the post page's JS bundle (they change without notice), computing or extracting the numeric media_id for each post, forging a matching CSRF token and a full browser header fingerprint (sec-ch-ua, priority, accept-language, and a dozen more) for every request, and building a proxy fallback path for when Instagram starts returning 403/429/503 responses. All of that logic already exists inside this Actor and is maintained as Instagram changes its internals — you supply URLs and a session cookie instead of a scraping pipeline.

The header fingerprint and query IDs are also the most fragile part of any homegrown version: Instagram ships new JS bundles regularly, and a hardcoded query ID or a stale Chrome version string in a sec-ch-ua header is often enough to trip a block. Maintaining that yourself means re-deriving the doc IDs and the fingerprint every time Instagram's frontend changes, on top of the proxy and session-cookie logistics.

How to scrape Instagram comments with Instagram Comments Scraper?

1. Open Instagram Comments Scraper on the Apify Console (Apify Store → Instagram Comments Scraper → Try for free, or run it directly if you already have it in your account).
2. Paste one or more Instagram post/reel URLs into directUrls — the Bulk edit view accepts one URL per line.
3. Open ⚙️ Limits, replies & access and set maxComments, maxReplies, includeNestedComments, and isNewestComments, then paste your Instagram sessionid cookie value into sessionId.
4. Leave proxyConfiguration empty for most runs — the Actor falls back through Apify Proxy automatically if a request is blocked. Configure it only if you need a specific proxy group or country.
5. Click Start, then open the Dataset tab for the per-comment table/JSON view, or download the OUTPUT key-value store entry for a single JSON array of every comment collected in the run.

The run itself happens entirely on Apify's infrastructure — there is no separate signup flow, API key, or install step beyond having an Apify account and this Actor's input filled in. Progress (which post is being fetched, how many comments have been saved) streams into the run's log in real time, and dataset rows appear as soon as each comment is fetched rather than only at the end of the run.

How to run multiple queries in one job

directUrls accepts an array, so add every post or reel URL you want in one run — one per line in the Bulk edit editor. The Actor processes each URL in turn (not in parallel) and pushes each post's comments to the same dataset as they're collected, so a partial run still leaves completed posts' data available even if a later URL fails. There is no documented concurrency setting for running multiple posts at once — batching is done by adding more URLs to the list, not by tuning a parallelism input.

⬇️ Input

Configure the run from three sections in the Apify Console UI, or send the equivalent JSON via the API.

Parameter	Required	Type	Default	Constraints
directUrls	No	array (stringList)	—	Instagram post/reel URLs, e.g. https://www.instagram.com/p/SHORTCODE/.
scrapingOptions	No	object (schemaBased)	—	Container for the five fields below.
scrapingOptions.maxComments	No	integer	10	minimum: 1, maximum: 1000. Top-level comments to collect per URL.
scrapingOptions.maxReplies	No	integer	2	minimum: 0, maximum: 200. Replies to fetch per comment.
scrapingOptions.sessionId	No (per schema)	string (textfield)	—	Instagram sessionid cookie value. Schema description marks it "Required" for reliable results, but it is not in the input schema's required list.
scrapingOptions.includeNestedComments	No	boolean	true	Enables reply collection for each top-level comment.
scrapingOptions.isNewestComments	No	boolean	false	true orders results newest-first by timestamp; false returns most-liked first.
proxyConfiguration	No	object (proxy, nullable)	—	Optional. Only needed if you want to pin a specific proxy group or country — the Actor already retries through Apify Proxy automatically on a block.

Leaving proxyConfiguration empty does not mean the Actor never uses a proxy — it means the first attempt for each post goes out directly, with no proxy. If Instagram responds with an HTTP 403, 429, or 503, the Actor automatically requests an Apify Proxy connection from the SHADER (datacenter) group, and if that also gets blocked, from the RESIDENTIAL group, retried up to three times, before it gives up on that URL. On those fallback tiers, the Actor forces Apify Proxy on with the SHADER or RESIDENTIAL group specifically — a proxy group you set yourself in proxyConfiguration is not used for the retry tiers, only for whatever the ladder passes through unchanged (like a country code, if your Apify plan and group support one).

Example input:

{
  "directUrls": [
    "https://www.instagram.com/p/DN8-GjPkgjS/",
    "https://www.instagram.com/reel/C1AbCdEfGhI/"
  ],
  "scrapingOptions": {
    "maxComments": 100,
    "maxReplies": 10,
    "sessionId": "6890xxxxx%3Axxxxxxxxxxxx%3Axxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
    "includeNestedComments": true,
    "isNewestComments": false
  },
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}

Common pitfalls:

• Pasting a URL to an Instagram profile instead of a specific post or reel. The Actor only accepts URLs containing /p/, /reel/, /reels/, or /tv/ (or a bare shortcode) — a profile URL is silently skipped with a warning in the log, not an error, and produces zero comments for that entry.
• Requesting more replies than a comment actually has. maxReplies is a ceiling, not a target — if a comment has 3 replies and maxReplies is 50, you get 3, because the Actor caps the request to the platform-reported reply count (child_comment_count) as well as to your input.
• Pasting an expired sessionid cookie. Instagram sessions expire after logout, a password change, or after enough time passes; an expired cookie behaves like no cookie at all — the run proceeds but is likely to return zero comments once Instagram rejects the request.

⬆️ Output

Every run writes to two places: the Actor's dataset (one record per top-level comment, in real time as each is fetched) and the key-value store, where the OUTPUT key holds the same records as a single JSON array — convenient for a one-file output.json download. Both are exportable in Apify's standard dataset formats (JSON, JSONL, CSV, Excel, XML, HTML table) from the Console or the API.

The dataset's default table view surfaces eight columns — id, text, timestamp, ownerUsername, commentUrl, postUrl, repliesCount, likesCount — but every record carries more than that; switch to the JSON view (or read the OUTPUT key) to see the nested replies array and the full owner object on every comment and reply.

Scraped results

[
  {
    "postUrl": "https://www.instagram.com/p/DN8-GjPkgjS/",
    "commentUrl": "https://www.instagram.com/p/DN8-GjPkgjS/c/17894957058162897",
    "id": "17894957058162897",
    "text": "This is exactly the kind of content I needed today, thank you!",
    "ownerUsername": "creator_daily",
    "ownerProfilePicUrl": "https://scontent.cdninstagram.com/v/t51.2885-19/573688225.jpg",
    "timestamp": "2026-06-14T21:11:18.000Z",
    "repliesCount": 1,
    "replies": [
      {
        "id": "17900000000000001",
        "text": "Agreed, saved this one.",
        "ownerUsername": "traveler_jenna",
        "ownerProfilePicUrl": "https://scontent.cdninstagram.com/v/t51.2885-19/482910033.jpg",
        "timestamp": "2026-06-14T21:20:04.000Z",
        "repliesCount": 0,
        "replies": [],
        "likesCount": 3,
        "owner": {
          "fbid_v2": "17841401111111111",
          "full_name": null,
          "id": "9988776655",
          "is_mentionable": null,
          "is_private": false,
          "is_verified": false,
          "latest_reel_media": null,
          "profile_pic_id": null,
          "profile_pic_url": "https://scontent.cdninstagram.com/v/t51.2885-19/482910033.jpg",
          "username": "traveler_jenna"
        },
        "commentUrl": "https://www.instagram.com/p/DN8-GjPkgjS/c/17894957058162897/r/17900000000000001"
      }
    ],
    "likesCount": 128,
    "owner": {
      "fbid_v2": "17841400000000000",
      "full_name": null,
      "id": "1234567890",
      "is_mentionable": null,
      "is_private": false,
      "is_verified": true,
      "latest_reel_media": null,
      "profile_pic_id": null,
      "profile_pic_url": "https://scontent.cdninstagram.com/v/t51.2885-19/573688225.jpg",
      "username": "creator_daily"
    }
  },
  {
    "postUrl": "https://www.instagram.com/p/DN8-GjPkgjS/",
    "commentUrl": "https://www.instagram.com/p/DN8-GjPkgjS/c/17894957058162898",
    "id": "17894957058162898",
    "text": "Where was this shot?",
    "ownerUsername": "wanderlust_max",
    "ownerProfilePicUrl": "https://scontent.cdninstagram.com/v/t51.2885-19/119002233.jpg",
    "timestamp": "2026-06-14T20:58:41.000Z",
    "repliesCount": 0,
    "replies": [],
    "likesCount": 9,
    "owner": {
      "fbid_v2": "17841402222222222",
      "full_name": "Max R.",
      "id": "5544332211",
      "is_mentionable": true,
      "is_private": false,
      "is_verified": false,
      "latest_reel_media": 1745603812,
      "profile_pic_id": null,
      "profile_pic_url": "https://scontent.cdninstagram.com/v/t51.2885-19/119002233.jpg",
      "username": "wanderlust_max"
    }
  },
  {
    "postUrl": "https://www.instagram.com/p/DN8-GjPkgjS/",
    "commentUrl": "https://www.instagram.com/p/DN8-GjPkgjS/c/17894957058162899",
    "id": "17894957058162899",
    "text": "🔥🔥🔥",
    "ownerUsername": "night_owl_studio",
    "ownerProfilePicUrl": "https://scontent.cdninstagram.com/v/t51.2885-19/887711223.jpg",
    "timestamp": "2026-06-14T20:45:02.000Z",
    "repliesCount": 0,
    "replies": [],
    "likesCount": 2,
    "owner": {
      "fbid_v2": "17841403333333333",
      "full_name": null,
      "id": "1122334455",
      "is_mentionable": null,
      "is_private": null,
      "is_verified": false,
      "latest_reel_media": null,
      "profile_pic_id": null,
      "profile_pic_url": "https://scontent.cdninstagram.com/v/t51.2885-19/887711223.jpg",
      "username": "night_owl_studio"
    }
  }
]

How can I use the data extracted with Instagram Comments Scraper?

• 🎯 Social & community managers: pull text, likesCount, and owner.is_verified for every comment on your own posts to prioritize replies to verified or high-engagement accounts first, and flag likely spam accounts (owner.is_private plus a generic username pattern) before they're seen. Running this across a full campaign's posts turns a manual "scroll and reply" routine into a queue you can triage in bulk.
• 🤖 AI engineers and LLM developers: the agent issues a run with target directUrls, receives structured JSON back, and passes text fields straight into a model as context for sentiment classification, comment summarization, or moderation flagging — no HTML parsing step required. Because every field is typed and consistently named across runs, the same prompt template works whether the agent pulled 5 comments or 5,000.
• 📊 Market researchers: compare ownerUsername overlap and likesCount distribution across a competitor's recent posts to gauge which content themes actually move an audience, not just which posts got the most likes. Cross-referencing owner.is_verified accounts commenting on a competitor's launch post can also surface which influencers or partners are already engaged.
• 📈 Growth and marketing teams: mine text and ownerUsername across a campaign hashtag's top posts to build an outreach list of engaged, non-private accounts using owner.is_private and owner.is_verified as filters. The commentUrl on each record makes it trivial to jump straight back to the original comment thread when it's time to reply.

How do you monitor new comments over time?

Comment monitoring means running the same post URLs on a schedule and diffing the results against the previous run to see what changed — new comments, reply growth on existing threads, and rising like counts.

Each comment's id is stable across runs, so a new id that wasn't in the previous dataset is a genuinely new comment. For existing ids, compare repliesCount and likesCount between runs to catch threads that are still gaining traction after the fact — a comment sitting at 5 replies last week and 40 this week is worth a second look regardless of whether new top-level comments arrived. Setting isNewestComments to true also puts the most recently posted comments first in each run's output, which makes a quick manual scan faster even without a full diff.

For the run itself, use Apify's Schedules feature (Console → Schedules) to trigger this Actor on a recurring interval against the same directUrls list, and pull each run's dataset via the Apify API to compare against the last one. The Actor has no built-in diffing or alerting of its own — the comparison logic runs on your side, against two datasets pulled from two scheduled runs.

A practical loop looks like: schedule a daily run across your tracked post URLs, store each day's dataset (or the OUTPUT key-value entry) keyed by run date, then diff id sets between yesterday's and today's output to isolate new comments, and diff likesCount/repliesCount on matching ids to isolate comments that are still gaining traction. Alert on whichever delta matters to your use case — a spike in new comments on a specific post, or a reply thread crossing a size threshold — rather than trying to alert on every change.

🔗 Integrate Instagram Comments Scraper and automate your workflow

Instagram Comments Scraper works with any language or tool that can send an HTTP request, through the Apify API and its official client libraries (apify-client for Python and Node.js). A run can be started, polled, and its dataset pulled entirely over HTTP, which is what makes it usable both from a script you run manually and from an unattended pipeline or agent.

REST API with Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("<YOUR_USERNAME>/instagram-comments-scraper").call(run_input={
    "directUrls": ["https://www.instagram.com/p/DN8-GjPkgjS/"],
    "scrapingOptions": {
        "maxComments": 100,
        "maxReplies": 10,
        "sessionId": "<YOUR_INSTAGRAM_SESSIONID_COOKIE>",
        "includeNestedComments": True,
        "isNewestComments": False,
    },
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["ownerUsername"], "-", item["text"])

Scheduled monitoring and delivery

There is no MCP server or webhook logic built into this Actor itself. For recurring runs, use Apify Schedules to trigger it on a cron-style interval, and Apify Webhooks to notify an external system (Slack, a queue, your own endpoint) when a run finishes — both are standard Apify platform features available to any Actor run from the Console or API, not something this Actor implements internally.

Is it legal to scrape Instagram comments?

Scraping publicly visible Instagram comments — content any visitor can see without logging in or bypassing a technical barrier — is generally treated as accessing public data, and this Actor returns only what a public post's comment section already shows. Courts in the United States have leaned toward this view: in hiQ Labs, Inc. v. LinkedIn Corp. (9th Cir. 2019), the court held that scraping publicly accessible data does not, on its own, violate the Computer Fraud and Abuse Act.

Comment data is personal data — it includes usernames, profile pictures, and text tied to identifiable people — so it falls under the GDPR in the EU/UK and under the CCPA and similar state laws in the US. Scraping for internal, aggregate research (sentiment trends, campaign monitoring) carries a different risk profile than scraping to build a dataset for AI training or public redistribution. Consult your legal team before any commercial use case that involves bulk storage or resale of comment data.

❓ Frequently asked questions

Do I need to be logged in to Instagram to use this scraper?

You need a logged-in Instagram account's sessionid cookie, pasted into scrapingOptions.sessionId. Instagram login-walls its comment-pagination endpoints for logged-out requests, so without a session cookie the Actor logs a warning and is unlikely to retrieve comments at all — even though the input schema doesn't technically require the field.

How do I control which comments come back first?

Set scrapingOptions.isNewestComments to true for newest-first ordering by comment timestamp, or leave it false (the default) for most-liked-first. The order is enforced by re-sorting the fetched comments client-side after collection, so it matches your setting regardless of the order Instagram's API itself returns them in.

How does Instagram Comments Scraper handle Instagram's anti-bot measures?

On an HTTP 403, 429, or 503 response, the Actor retries the request through a proxy ladder: no proxy first, then an Apify Proxy datacenter group, then an Apify Proxy residential group (retried up to three times) before giving up on that post and moving to the next URL. Each request also carries a full desktop-Chrome header fingerprint (sec-ch-ua, accept-language, priority, and related headers) and a freshly generated CSRF token, rather than a bare requests-library default header set.

Does Instagram Comments Scraper extract full commenter profile data?

Yes — every comment and reply carries an owner object with ten fields: username, id, fbid_v2, full_name, is_verified, is_private, is_mentionable, latest_reel_media, profile_pic_id, and profile_pic_url. Any of these Instagram doesn't return for a given account come back as null, not a guessed or blank value.

How many comments and replies does it return per post?

Up to maxComments top-level comments per URL (hard-capped at 1,000 regardless of a higher input value) and up to maxReplies replies per comment (hard-capped at 200). These are fixed ceilings enforced in the Actor's code, not a platform rate limit that varies by run.

How do I use it to monitor new comments on a post over time?

Schedule the same directUrls list to re-run on an interval using Apify Schedules, then compare each run's comment ids against the previous run's dataset — new ids are new comments, and unchanged ids with a higher likesCount or repliesCount show which threads are still active.

Does Instagram Comments Scraper work with Claude, ChatGPT, and AI agent frameworks?

There's no dedicated MCP server documented for this Actor. It is callable as an HTTP endpoint through the Apify API by any agent framework that can make a REST call — an agent triggers a run with a list of post URLs, waits for the dataset, and grounds its answer in the returned comment text and metadata.

How does Instagram Comments Scraper compare to other Instagram comment scrapers?

As observed on the Apify Store on 2026-07-25 (not measured here): apify/instagram-comment-scraper's listing documents owner ID, verification status, username, and profile picture per commenter, without a private-account or mentionability flag, and states results "may vary" with no fixed numeric cap. louisdeconinck/instagram-comments-scraper's listing markets itself as requiring no Instagram login and advertises "10,000+ comments in under 60 seconds" and a $0.001-per-comment price on its own page — figures from its listing, not independently verified here. This Actor requires a session cookie for reliable results, states fixed caps (1,000 comments, 200 replies) directly in the input schema, and returns the fuller ten-field owner object described above on every comment and reply.

Can I use Instagram Comments Scraper without managing proxies or Instagram infrastructure myself?

Yes for proxies — the Actor requests and rotates Apify Proxy datacenter and residential connections automatically when a request is blocked, with no proxy configuration required from you. You do still need to supply your own Instagram sessionid cookie; the Actor doesn't manage or generate Instagram credentials on your behalf.

Can I get replies without pulling every top-level comment first?

No — replies are fetched per parent comment, so the Actor always collects top-level comments first (up to maxComments) and then, for each one with child_comment_count > 0, fetches its replies up to maxReplies. There's no input for fetching replies to a specific comment ID in isolation; the unit of work is a post URL, not a single comment.

Related Scrapier tools for Instagram data

Instagram Comments Scraper focuses on comments and replies. If your workflow needs a different slice of Instagram, the Scrapier catalog covers adjacent surfaces:

• Instagram Following Scraper — following/follower lists for a profile, rather than comment activity.
• Instagram Hashtag Engagement Scraper — aggregate engagement across posts under a hashtag.
• Instagram Profile Growth Monitor — tracks a profile's own metrics (followers, posts) over repeated runs.
• Instagram Reel Engagement Analyzer — reel-level view/like/comment counts without pulling individual comment text.
• Instagram Profile Competitor Benchmark — side-by-side profile metrics across multiple accounts.

💬 Your feedback

Found a bug, or a field Instagram changed that isn't mapping correctly anymore? Open an issue on this Actor's Issues tab in Apify Console, or reach out through the Scrapier profile on the Apify Store. Bug reports and missing-field reports are the fastest way to get a fix shipped.