Instagram Followers Scraper: Daily Follower Counts

Instagram Scraper — Extract Followers, Growth Rate & Unfollows as JSON

This Instagram scraper collects a public profile's follower list and, when re-run against the same profile, diffs the current followers against the last saved snapshot to report exactly who's new, who unfollowed, and the percentage growth rate. Every response is typed, normalized JSON — no HTML, no selectors, no parsing. Follower rows carry Instagram's full account fields; a separate per-profile growth summary row carries the run-over-run delta. After reading this, you'll know exactly what to send in and what JSON comes back.

What is Instagram Followers Scraper: Daily Follower Counts?

Instagram Followers Scraper: Daily Follower Counts is an Apify Actor that scrapes the public follower list of one or more Instagram profiles and tracks growth across runs. No Instagram account or login is required to start it, but providing an Instagram sessionid cookie is recommended — without one, the source code logs a warning that access may be limited. Re-running it against the same profile (manually, or on an Apify Schedule) lets it diff the current follower set against a snapshot saved from the previous run.

• Scrape the public follower list for one or more Instagram profiles in a single run
• Track growth across runs: new followers, unfollows, and growth rate vs. the last snapshot
• Reset a profile's growth baseline on demand instead of diffing against old data
• Pad results toward your target count from post-comment authors when the raw follower list runs dry — clearly tagged so they're never confused with real followers
• No proxy management required — the Actor escalates through proxy tiers automatically on blocks

What data does Instagram Followers Scraper: Daily Follower Counts collect?

The Actor returns two distinct row shapes in the same dataset: per-follower account rows, and one per-profile growth summary row per run.

Data Type	Key Fields	JSON Field Names
Follower rows	username, full name, verified/private flags, avatar, Instagram internal IDs	username, full_name, is_verified, is_private, profile_pic_url, pk, id
Comment-padding rows	same shape as follower rows, tagged so they're never mistaken for real followers	sourceType: "post_commenter", followed_by
Growth summary row	new/unfollowed username lists, growth-rate percent, baseline flag	newSinceLastRunCount, unfollowedSinceLastRunCount, growthRatePct, hasBaseline, snapshotStoreName

Need more Instagram data?

If you also need bio, email, or phone contacts for the accounts you're tracking, Instagram Followers And Following Scrapper With Profile Emails scrapes the same followers/following lists with optional profile enrichment (biography, external links, public email/phone, business status) and lead-qualifying filters. If you specifically want to filter down to verified or business accounts with bio contact info, Instagram Followers: Blue Checkmark Accounts & Bio Contacts qualifies profiles by verified/business/professional status and extracts bio emails, phones, and links. Both are separate Actors in the API-Empire catalog.

Why not build this yourself?

Instagram's own Graph API is built for managing accounts you own — it requires a professional (business or creator) Instagram account linked to a Facebook Page, a registered Facebook App, and in most cases app review before it returns real data, and it does not expose an arbitrary third party's follower list. Building a DIY scraper instead means reverse-engineering Instagram's internal web endpoints, handling session cookies, and maintaining scraping code every time Instagram changes its internal API — plus sourcing and rotating proxies yourself. This Actor already does all of that, and adds the cross-run snapshot/diff logic needed to turn a single follower export into a growth history.

Why do developers and teams scrape Instagram?

For marketers and brand teams

Brand and social teams use follower scraping to move past a single vanity-metric snapshot and into an actual growth trend. Pulling currentFollowerCount, newSinceLastRunCount, unfollowedSinceLastRunCount, and growthRatePct for a competitor or influencer profile on a recurring schedule turns one-off follower counts into a growth curve you can chart, without manually re-checking a profile and doing the subtraction by hand. It's also the same mechanism used to measure the audience delta around a campaign or partnership — run the Actor once before and once after, against the same startUrls, and read growthRatePct on the summary row.

For researchers and analysts

Researchers studying audience growth, influencer dynamics, or platform behavior over time need repeatable, public-data-only snapshots rather than a single scrape. Because every field not yet knowable (like deltas on a first run) is returned as null instead of a fabricated value, the dataset is safe to use in longitudinal analysis without silently introducing invented data points. Running the same startUrls on a fixed cadence builds a dataset of follower-count history and churn — newSinceLastRun and unfollowedSinceLastRun name the exact accounts behind each change — suitable for a research pipeline studying audience turnover across many public profiles at once.

For developers building data products

Developers building monitoring dashboards or growth-alert tools can call this Actor on a schedule and read the uncharged growth summary row directly — growthRatePct, newSinceLastRunCount, and unfollowedSinceLastRunCount are already computed server-side, with no client-side diffing logic to write or maintain. Because the output is stable JSON keyed by targetUsername and snapshotStoreName, it slots directly into a database, a Slack/webhook alert on a growth-rate threshold, or a customer-facing analytics product built on top of the Apify API rather than a scraping pipeline you have to babysit yourself.

How to scrape Instagram (step by step)

1. Open Instagram Followers Scraper: Daily Follower Counts on its Apify Store page.
2. Provide the required startUrls input — one or more Instagram profile URLs or usernames whose followers you want to collect.
3. Optionally set maxData (followers to collect per profile, default 100), add a sessionId cookie for better access, and toggle resetBaseline if you want to discard a profile's saved growth history and start over.
4. Start the run.
5. Download the results as JSON, CSV, or another Apify dataset export format — then re-run the same startUrls later (manually or on an Apify Schedule) to get real newSinceLastRun / unfollowedSinceLastRun / growthRatePct values on the growth summary row.

What to do when Instagram changes its structure

The Actor is maintained on an ongoing basis, and the output schema stays stable on your end — field names and types don't change even when Instagram's internal endpoints shift underneath. No numeric turnaround time is guaranteed.

⬇️ Input

Parameter	Required	Type	Description	Example Value
startUrls	Yes	array	Instagram profile URLs or usernames to scrape followers from and track for growth. Re-running with the same profile diffs this run's followers against the last run's snapshot.	["https://www.instagram.com/cristiano/", "nike"]
maxData	No	integer	Maximum number of followers to collect per profile. Range 1–100,000, default 100.	100
sessionId	No	string	Instagram sessionid cookie. Optional but recommended — without it, access may be limited and success rates lower. Kept secret once saved.	"80339464000%3AMwlUEdZkdshtFG%3A5%3AAYiJEi32U_OOJkvXyc232wBhDZz1Q4zQOFhTFSTy3g"
resetBaseline	No	boolean	When true, ignores any previously saved snapshot for the profiles above and starts a fresh baseline. Default false.	false
proxyConfiguration	No	object	Proxy settings. Automatically escalates from no proxy to datacenter to residential proxy (with retries) if requests are blocked.	{"useApifyProxy": false}

Example JSON Input

{
  "startUrls": [
    { "url": "https://www.instagram.com/cristiano/" },
    { "url": "https://www.instagram.com/nike/" }
  ],
  "maxData": 100,
  "sessionId": "your_session_id_here",
  "resetBaseline": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}

The most common mistake is expecting growth numbers on the very first run for a profile — the first run for any startUrls entry always establishes the baseline snapshot, so hasBaseline is false and the delta fields are empty until you run it again against the exact same profile.

⬆️ Output

Every row is typed, normalized JSON with a stable schema; results can also be downloaded as CSV, Excel, or other standard Apify dataset export formats. Two structurally distinct row types are pushed to the same dataset: follower/comment-padding rows (type: "row"), which are charged, and a per-profile growth summary row (type: "summary"), which is not.

Scraped follower rows

{
  "type": "row",
  "sourceType": "follower",
  "pk": "73320179592",
  "pk_id": "73320179592",
  "id": "73320179592",
  "full_name": "arizki",
  "is_private": true,
  "fbid_v2": "",
  "third_party_downloads_enabled": 0,
  "strong_id__": "73320179592",
  "profile_pic_id": "",
  "profile_pic_url": "https://instagram.fjsr11-1.fna.fbcdn.net/...",
  "is_verified": false,
  "username": "davabukandaffa5",
  "has_anonymous_profile_picture": false,
  "account_badges": [],
  "latest_reel_media": 0,
  "is_favorite": false,
  "followed_by": "cristiano",
  "success": true,
  "profileUrl": "https://www.instagram.com/davabukandaffa5/",
  "scrapedAt": "2026-07-14T09:00:00Z"
}

sourceType is "follower" for a real follower-list row, or "post_commenter" when the row was padded in from an author who commented on the target's own posts — used only when the follower list runs dry before reaching maxData, and always tagged so it is never confused with a real follower.

Growth summary row (second run onward)

{
  "type": "summary",
  "sourceType": "growthSummary",
  "isSummary": true,
  "targetUsername": "cristiano",
  "profileUrl": "https://www.instagram.com/cristiano/",
  "currentFollowerCount": 100,
  "previousFollowerCount": 97,
  "hasBaseline": true,
  "newSinceLastRun": ["newfan01", "newfan02"],
  "newSinceLastRunCount": 2,
  "unfollowedSinceLastRun": ["oldfan03"],
  "lostSinceLastRun": ["oldfan03"],
  "unfollowedSinceLastRunCount": 1,
  "growthRatePct": 3.09,
  "snapshotStoreName": "ig-daily-snapshot-cristiano",
  "scrapedAt": "2026-07-14T09:00:12Z",
  "success": true
}

On a profile's first run, hasBaseline is false, previousFollowerCount is null, and the delta lists are empty — the Actor never fabricates a growth number when there is nothing to compare against. This summary row is pushed without a charged event, so it is free; only the follower and comment-padding rows above (type: "row") are billed. If you export the dataset and only want the billed rows, filter on type == "row"; filter on type == "summary" to isolate only the free growth-tracking rows.

How many results can you scrape with Instagram Followers Scraper: Daily Follower Counts?

maxData caps followers collected per profile at up to 100,000, with a default of 100; there is no hard cap in the Actor itself on how many profiles you list in startUrls, so total rows scale with maxData × number of profiles. Pagination is handled internally: the Actor pages through Instagram's followers endpoint in batches, then falls back to paging through post comments if the raw follower list is exhausted before maxData is reached. Instagram's own access limits on an unauthenticated or rate-limited session can still reduce how much of that ceiling is reachable in a given run, which is why a sessionId cookie and proxy configuration are recommended for larger jobs.

Integrate Instagram Followers Scraper: Daily Follower Counts and automate your workflow

Instagram Followers Scraper: Daily Follower Counts works with any language or tool that can send an HTTP request, using the standard Apify API.

REST API integration

import requests

TOKEN = "YOUR_APIFY_TOKEN"
ACTOR = "API-Empire~instagram-followers-scraper-daily-follower-counts"

run = requests.post(
    f"https://api.apify.com/v2/acts/{ACTOR}/run-sync-get-dataset-items",
    params={"token": TOKEN},
    json={"startUrls": [{"url": "https://www.instagram.com/cristiano/"}], "maxData": 100},
)

for row in run.json():
    if row.get("type") == "summary":
        print(row["targetUsername"], row["growthRatePct"])

Works in Python, Node.js, Go, Ruby, cURL.

MCP for AI agents

The Actor can be exposed to an MCP-compatible client through Apify's Actors MCP Server by adding its ID to the server's actor list, for example running npx @apify/actors-mcp-server --actors API-Empire/instagram-followers-scraper-daily-follower-counts. Compatible with Claude, Cursor, and other MCP clients.

Automation platforms (n8n, Make)

In n8n, the Apify node's "Run Actor" operation can call this Actor by ID and pass startUrls, maxData, and resetBaseline directly from an upstream node. In Make, the Apify app's "Run an Actor" module takes the same actor ID and input JSON, letting you route the growth summary rows into a Google Sheet, database, or alerting module on a recurring schedule without custom code.

Is it legal to scrape Instagram?

Yes, scraping publicly available Instagram data is generally lawful, and this Actor only collects follower usernames and public profile fields that are visible on a profile's public follower list — it does not access private accounts or login-gated content. Because follower usernames and profile details are personal data, storing or using them at scale should follow GDPR/CCPA principles: have a lawful basis for collection, avoid retaining data longer than needed, and honor removal requests. Consult legal counsel for commercial use cases involving bulk personal data.

Frequently asked questions

Does Instagram Followers Scraper: Daily Follower Counts work without an Instagram account?

Yes. startUrls is the only required input, and no Instagram login is enforced. Providing an Instagram sessionid cookie is optional but recommended — the source code logs a warning and proceeds with reduced access when one isn't supplied.

How often is the scraped data updated?

Every run performs a live fetch against Instagram at the time it runs — the follower rows are not cached. "Daily" refers to the growth-tracking mechanism: the Actor compares this run's followers against a real snapshot saved from the profile's last run, it does not schedule itself, so a daily cadence requires you to re-run it (for example on an Apify Schedule) against the same startUrls.

What happens if a profile is private or has fewer followers than maxData?

A private or inaccessible profile returns 0 followers for that entry and the run continues to the next profile in startUrls; the growth-tracking summary row is only written when the profile was actually reachable, so a hard failure never overwrites a real prior snapshot with an empty one. If a public profile's follower list is smaller than maxData, the Actor pads the remainder from users who commented on the target's own posts, tagged sourceType: "post_commenter" so they're never mistaken for real followers.

Can I scrape private Instagram accounts?

No. Only publicly accessible follower lists are returned; the Actor does not attempt to bypass Instagram's privacy restrictions on private accounts.

How does daily tracking actually work?

Each target profile gets its own named Apify Key-Value store that persists the set of follower usernames collected on a run. The next time you run the Actor against the same profile, it reads that snapshot back, diffs it against the current run's usernames, and emits newSinceLastRun, unfollowedSinceLastRun, and growthRatePct on a per-profile summary row. This is a real cross-run diff, not a live-only calculation — but it only advances when you actually re-run the Actor, so the "daily" part of the cadence is up to how you schedule your runs. Use resetBaseline: true to discard a profile's saved history and start over.

Does Instagram Followers Scraper: Daily Follower Counts work for AI agent workflows and LLM pipelines?

Yes. It's callable as a standard HTTP API endpoint from any agent framework, and it's also reachable through Apify's Actors MCP Server for MCP-compatible clients. Every response is typed JSON with stable field names — no HTML or parsing step before passing rows to an LLM.

How does Instagram Followers Scraper: Daily Follower Counts handle Instagram's anti-bot system?

It escalates through proxy tiers automatically: no proxy (direct) by default, then a datacenter proxy, then a sticky residential proxy with retries if Instagram returns a block (403/429) response. A sessionId cookie can be supplied to further improve access.

Does Instagram Followers Scraper: Daily Follower Counts return data in a format LLMs can use directly?

Yes. Typed, normalized JSON with stable field names — no HTML, no selectors, no parsing. Pass it directly into an LLM context window, index it into a vector store, or route it through an agent tool call.

Can I use Instagram Followers Scraper: Daily Follower Counts without managing proxies?

Yes. By default it connects directly with no proxy, and automatically escalates to a datacenter then residential proxy only if Instagram starts blocking requests — you don't need to configure or rotate proxies yourself, though supplying your own proxyConfiguration is supported.

What happens when Instagram changes its structure or blocks the scraper?

The Actor is maintained on an ongoing basis, and the output schema stays stable on your end — field names and types don't change on your side even when Instagram's internal API shifts underneath. No numeric turnaround time is guaranteed.

Your feedback

Found a bug or missing a field? We want to know. Reach out through the Actor's Apify Store page (Issues tab) or your Apify Console support channel with a run ID, and reports like this directly shape what gets fixed and maintained.