Instagram Follower Tracker

See exactly who started following and who unfollowed any public Instagram account — tracked automatically over time. Run it on a schedule and every run hands you a clean list of new followers, lost followers (unfollowers), new following, and dropped following — matched on stable account IDs, so a username change never shows up as a fake unfollow.

🎯 What it does

You give the actor one or more public Instagram accounts to watch and choose whether to track their followers, their following, or both. The first run lists every current follower as it reads them — so the Output fills up live instead of sitting empty — and saves a baseline snapshot. Every run after that compares the current list against the previous snapshot and writes one row per change.

Each row tells you the tracked account, the change type (tracked on the first run, then new or lost), which list changed (followers or following), and the affected account's username, full name, profile picture, verified, and private flags, plus the timestamp it was recorded.

The snapshot is stored in a key-value store that persists between runs, so tracking accrues the longer you run it. Add the actor to an Apify Schedule (daily is typical) and you get a continuous, timestamped feed of audience changes — no database or backend of your own required.

ℹ️ First run lists everyone, then tracks changes. The first run for an account has nothing to compare against yet, so instead of reporting changes it lists all of its current followers (rows with change_type: "tracked") and saves the baseline. From the second run onward you get the new / lost changes. Watch the run's log or live status page to see the list fill up as it reads. (The following list isn't listed on the first run — only its new / lost changes, from the second run onward.)

🔧 How it works

A single 30-second model of what every run actually does:

• First run = baseline. The followers list is read end-to-end, written to the Output live as tracked rows, and saved as a snapshot. There are no new / lost rows yet — they start from the second run.
• Runs 2 and after = changes only. Each run re-reads the current list and reports who appeared (new) and who disappeared (lost) since the previous run.
• Two-run confirmation. Each candidate change must show up on two consecutive runs before it lands in the Output. Instagram returns the follower list in a slightly different order on each read, so this two-step check is what filters list-ordering noise out of your results. The trade-off: a real follow / unfollow lands in the Output one run after it actually happened — but everything you see is reliable, not noise.
• Followers vs. following — one asymmetry. Followers get a baseline listing on run 1 (you see the whole list in the Output). Following gets no baseline listing — only its new / lost changes, starting from run 2.
• Caps. Up to 150,000 followers and 1,000 following per account; lists bigger than that are skipped without charge. On the free plan the per-account ceilings are 1,000 followers / 500 following.

For a one-time, no-baseline export of an account's entire current followers or following list, use the Instagram Followers Scraper instead — this actor is designed for change-over-time monitoring, not a single-shot list dump.

📦 Output sample

Each current follower (on the first run) and each later followers / following change is pushed to the dataset as its own row — one account can be hundreds or thousands of rows, not a single item. Every row has the same shape (the list_type field says which list it came from); what a run produces just depends on whether it's the first run or a later one.

First (baseline) run → one tracked row per current follower (the whole list, streamed in batches as it's read), then the baseline snapshot is saved:

{
  "target_username": "natgeo",
  "change_type": "tracked",
  "list_type": "followers",
  "username": "jane_explores",
  "full_name": "Jane • Travel",
  "profile_pic_url": "https://instagram.fxyz-1.fna.fbcdn.net/v/t51.2885-19/abc.jpg",
  "is_verified": false,
  "is_private": false,
  "detected_at": "2026-05-21T10:15:30.000Z"
}

Every later run → just the changes since the previous run: a new row for each account that appeared and a lost row for each that disappeared:

[
  {
    "target_username": "natgeo",
    "change_type": "new",
    "list_type": "followers",
    "username": "mark_hikes",
    "full_name": "Mark Rivera",
    "profile_pic_url": "https://instagram.fxyz-1.fna.fbcdn.net/v/t51.2885-19/def.jpg",
    "is_verified": false,
    "is_private": false,
    "detected_at": "2026-05-22T09:02:11.000Z"
  },
  {
    "target_username": "natgeo",
    "change_type": "lost",
    "list_type": "following",
    "username": "old_brand_acct",
    "full_name": "Old Brand",
    "profile_pic_url": "https://instagram.fxyz-1.fna.fbcdn.net/v/t51.2885-19/ghi.jpg",
    "is_verified": true,
    "is_private": false,
    "detected_at": "2026-05-22T09:02:11.000Z"
  }
]

Here the account gained a follower (new, list_type: "followers") and stopped following someone (lost, list_type: "following") in the same run. Both lists produce the same row shape — list_type is "followers" or "following". One asymmetry: only the followers list gets a baseline tracked listing on the first run; the following list has no baseline listing, so its new / lost changes start from the second run.

The change type tells the three kinds apart:

• tracked — a current follower, listed on the first (baseline) run (followers list only).
• new — an account that appeared in the list since the previous run.
• lost — an account that disappeared (unfollowed, or the target stopped following it); carries the last-known details from the previous snapshot.

Missing optional values (e.g. no profile picture) come back as null.

The full per-field schema (types, descriptions, examples) is published in .actor/dataset_schema.json — that's also what AI agents see when they call the actor through Apify's MCP server.

⚡ Quick start

A minimal input (replace natgeo with the account you want to track):

{
  "usernames": ["natgeo"],
  "trackFollowers": true,
  "trackFollowing": true
}

🆓 On the free plan, pick an account with up to 1,000 followers / 500 following — larger accounts are skipped (and never charged) and need a paid plan. The free plan tracks 1 account (your trial account) across 5 tracking runs to try it out.

Run it once — it lists all current followers (as tracked rows) and sets the baseline — then run it again later: the second run lists everyone who followed or unfollowed (and, if enabled, the accounts it started or stopped following) in between. To make it automatic, open the Schedules tab in Apify Console and point a daily schedule at this actor with the same input.

📋 What you'll see after each run

Every run also writes a one-line USER_MESSAGE to the run's Storage tab explaining what it did. Use this table to map the message to what to do next:

If you see…	What it means	What to do
tracked rows in the Output + "Baseline saved — changes start from the next run"	First run for this account; the current follower list was written out and saved as the baseline.	Schedule the actor; the next run will list new / lost changes.
Empty Output + "No confirmed changes yet — N pending"	The run spotted possible changes but held them for next-run confirmation (the two-run noise filter).	Run again, or wait for the next scheduled run — anything real will be confirmed and listed.
Empty Output + "No follower changes since the last run"	Both lists were read and diffed cleanly; nothing changed since the previous run.	Nothing to do — your baseline is up to date.
Empty Output + "Account too large to track"	The followers list is over 150,000 (or the following list is over 1,000) — too large to diff reliably, so it was skipped. Not charged.	Pick a smaller account, or turn off the over-cap list and keep the other one on.
Empty Output + "Couldn't finish reading — please re-run"	Instagram briefly rate-limited the read, or a page timed out partway through a long list. The unread list isn't charged.	Re-run in a few minutes — a daily Schedule rides this out automatically.
Empty Output + "No accounts could be reached"	Every target account 404'd at lookup or is private.	Double-check the spelling and that the accounts are public.
Empty Output + "Free trial used up — N runs reached"	Every free run on this Apify account has been used.	Upgrade to a paid plan to keep tracking.
Empty Output + "Last free run coming up — 1 left"	A heads-up on the run before the free trial ends.	Upgrade soon if you want to keep tracking past this run.

📧 Get the changes emailed to you (schedule and Gmail)

Tracking pays off across repeated runs, so the ideal setup is a scheduled task that emails you each run's new and lost followers and following automatically — no need to open Apify Console to check. Apify has a built-in Gmail integration for this; the whole setup is point-and-click (no code):

1. Save your settings as a task

• Open this actor in Apify Console → Save as a new task (top-right).
• On the task's Input tab, set the account(s) and toggles/caps just like a normal run.

2. Add the email notification

• Open the task's Integrations tab → Send results email via Gmail.
• Click Connect with Google and choose the account to send from (manage connected accounts later under Settings → API & Integrations).
• Set the recipient address, customize the Subject and Body (they support run variables), and optionally attach the dataset so each email carries that run's change rows. By default the email is sent on successful runs. Click Save.

3. Put the task on a schedule

• Go to Schedules → Create new → click Add and select your task.
• Set the frequency in the Schedule setup card — e.g. 0 8 * * * (daily at 08:00) or the @daily shortcut; the next five run times preview live.

Every scheduled run now emails you that run's new/lost followers and following — a hands-off audience-change feed in your inbox.

ℹ️ The first run for an account is a baseline: its attached dataset lists all current followers (tracked), but there are no new / lost changes yet, so a changes-focused email shows zero changes — expected. Changes start from the second run, and because each follow/unfollow is confirmed across two consecutive runs before it's reported, a change lands in your inbox a run or two after it actually happens — not instantly, but reliably.

🧭 When to use it

• Spot unfollowers — find out who unfollowed your account, with names and timestamps.
• Audience growth tracking — log every new follower over time for reporting or outreach.
• Competitor / creator watch — monitor who a public account starts or stops following.
• Influencer vetting — watch following churn on accounts you're considering working with.
• Community management — keep a dated record of membership changes on brand or niche accounts.

🛠 Input

Field	Purpose
Accounts to Track (usernames)	One or more public handles or profile URLs to monitor. Free plan: 1 account (your trial account), 5 runs to try it.
Track Followers (trackFollowers)	Track the followers list — new followers and unfollowers. On by default.
Track Following (trackFollowing)	Track the following list — accounts the target started or stopped following. On by default.

At least one of Track Followers / Track Following must be on. List size is handled automatically: a followers list over 150,000 or a following list over 1,000 can't be diffed reliably, so it's skipped for that account and not charged. Cost scales with size — see 💰 How much will tracking cost?. On the free plan the per-account limit is lower (1,000 followers / 500 following); larger accounts need a paid plan (skipped and never charged on free).

💰 How much will tracking cost?

You're billed per follower checked, scaled by the account's size — not per API call. The actor uses Apify's Pay Per Event model, priced $0.03 per 1,000 followers (a 10,000-follower minimum, so the smallest accounts are $0.30). Tracking the account's following list is included at no extra charge — your bill is driven by the follower count only:

Event	Price	Triggered
Baseline Snapshot	$0.03 per 1,000 followers (min $0.30)	The first run for an account — lists all current followers and records the starting snapshot.
Account Checked	$0.03 per 1,000 followers (min $0.30)	Every run after the baseline — re-reads the list and reports new / lost.

Both cost the same per follower, because every run re-reads the account's whole list (Instagram exposes no "followed-on" date, so there's no cheaper incremental read). You're billed for the account's exact follower count (minimum 10,000). The first run is a one-time baseline that lists all current followers and sets the snapshot; the new / lost changes start from the second run.

Following tracking is free. The charge scales with the account's follower count; tracking its following list (up to 1,000) adds nothing. If you track only following (Track Followers off), there's no follower count to scale by, so you pay the flat $0.30 minimum per account per run.

What one run costs, by account size (by follower count — following adds nothing):

Followers	Charge per run
up to 10,000	$0.30
25,000	$0.75
50,000	$1.50
100,000	$3.00
150,000 (max)	$4.50

Accounts up to 150,000 followers are supported. A followers list larger than 150,000, and any following list over 1,000, are skipped without charge. Unreachable accounts (private, not found, error) are never charged.

⏱️ Large accounts take longer. The list is read page by page, so a 150,000-follower run can take up to ~1 hour; small accounts finish in well under a minute.

Your monthly cost depends on how often you schedule it and the account's size — each run re-checks the full list:

Account size	Weekly (~4.3 runs)	Daily (30 runs)
5,000 followers	~$1.30	~$9
50,000 followers	~$6.45	~$45
150,000 followers	~$19.35	~$135

Tracking a large account weekly instead of daily is the cheapest way to keep watching it.

🆓 Free vs paid plan

	Free plan	Paid plan
Accounts tracked	1 (your trial account)	Unlimited
Tracking runs	5 to try it, then upgrade	Unlimited
Followers + following tracking	✓	✓
Scheduling	✓	✓
Followers / following tracked per account	Up to 1,000 / 500	Up to 150,000 / 1,000

The free plan is a trial: track 1 account across 5 runs, on accounts up to 1,000 followers / 500 following. Upgrade to a paid plan to track multiple accounts, keep tracking with no run limit, and follow accounts with much larger lists.

📡 Live status & storage records

While the run is in progress, the actor exposes:

Storage key	Type	What it holds
status.html	HTML page	Live progress — including the running follower-collection count while a large list is read — plus change counts, cost, and elapsed time. Open it from the run's Storage tab.
RUN_SUMMARY	JSON	Aggregate run statistics — accounts checked, new/lost counts per list, followers written on baseline runs, baselines created, cost, timings.
USER_MESSAGE	JSON	Contextual note — baseline established, test-run hint, or unknown-input guidance.
SKIPPED_ACCOUNTS	JSON	Targets skipped this run (private, not found, error, or too large) with reasons.
FREE_LIMITS_APPLIED	JSON	Which free-plan limits were applied this run (e.g. account or run-count cap reached). Written only on free-plan runs that hit a limit.

The cross-run snapshots themselves live in a named key-value store, instagram-follower-tracker-state, which persists between runs in your own Apify account.

🤖 Programmatic / API use

Start a run from your own code or an AI agent:

curl -X POST "https://api.apify.com/v2/acts/afanasenko~instagram-follower-tracker/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"usernames":["natgeo"],"trackFollowers":true,"trackFollowing":true}'

The actor is also exposed as a tool through Apify's MCP server at mcp.apify.com. Once your MCP-enabled client (Claude, ChatGPT, Cursor, …) is connected to your Apify token, an LLM can run it with instructions like "track who unfollows @natgeo and report new unfollowers — and who @natgeo starts or stops following — every day."

❓ FAQ

Q: Can I get followers/following in chronological order (by the date each follow happened)? A: No — and no tool truly can. Instagram does not attach a "followed on" date to the follower/following data, so there's nothing to sort by. What you almost certainly want instead is what changed — and that's exactly what this actor gives you: run it on a schedule and each run lists who newly followed and who unfollowed since last time, with the detection timestamp. That's a forward-looking chronological record of changes.

Q: Can I watch progress during a long run? A: Yes. The list is read page by page, and the actor streams each batch of followers to the Output as it goes (in batches of ~100) and logs a running count with elapsed time (e.g. 📥 followers: 1,000 collected so far… (1m 12s)). The status.html live page also shows the current account and how many followers have been collected — so a large account visibly fills up instead of waiting on an empty screen.

Q: How much does it cost? A: $0.03 per 1,000 followers (a 10,000-follower minimum), per run — so a small account is $0.30, a 50,000-follower account is $1.50, and a 150,000-follower account (the max) is $4.50. The first run is a one-time baseline at the same price; every later run re-reads the whole list (Instagram has no incremental "since" feed). Monthly cost = the per-run cost × how often you schedule it — see How much will tracking cost? for examples. Unreachable accounts, and lists too large to track reliably, aren't charged. Tracking the following list is included at no extra charge — the price is based on followers only.

Q: Does tracking following cost extra? A: No. The bill is based on the account's follower count; its following list (up to 1,000 accounts) is included at no extra charge. If you track only following, it's the flat $0.30 minimum per account per run.

Q: A follower changed their username — will that look like an unfollow? A: No. Accounts are matched on their stable internal ID, not their username, so a rename is not reported as a loss + a gain.

Q: How fast is it? A: Reading a list is paginated, so time scales with its size — small accounts finish in well under a minute, a few thousand followers take a minute or two, and a very large account (up to 150,000) can take up to ~1 hour. Multiple accounts add up roughly linearly.

🔗 Other related actors (same author)

This actor is part of a family of focused Instagram tools — pick the one that matches your goal:

You start with…	You want to…	Use this actor
A public account	Track who follows / unfollows it over time	This actor
A public account	Pull and enrich its full followers / following list once	Instagram Followers Scraper
A username or URL	Scrape and enrich profiles, posts, and contact info	Instagram Profile Scraper
A seed account	Discover similar / related accounts	Instagram Related Profiles Scraper
An AI agent (Claude, Cursor, ChatGPT)	Query Instagram from inside your agent — MCP tools it picks by intent	Instagram Profile MCP Server

Use this one for change-over-time monitoring; use the Followers Scraper when you need a one-time enriched export of an entire list.

🛟 Support & feedback

• Open an issue on the actor's Issues tab — fastest way to get a fix shipped.
• Feature requests in the same tab; we read every one.
• Ratings & reviews on the Apify Store page help other users find the actor.

⚖️ Is it legal to track Instagram followers?

Yes — the actor reads publicly available follower and following lists from public Instagram accounts and does not bypass authentication, access private content, or act on your behalf. Use it in compliance with Instagram's Terms of Service and applicable privacy laws (GDPR, CCPA) — for any outreach built on the results, ensure you have a legitimate basis and a clear opt-out.