# Instagram Follower Tracker - New Followers & Unfollows (`seemuapps/instagram-follower-tracker`) Actor

Track new followers and unfollowers of any public Instagram profile. Schedule runs to get one row per follow, unfollow and following change.

- **URL**: https://apify.com/seemuapps/instagram-follower-tracker.md
- **Developed by:** [Seemu Scraping](https://apify.com/seemuapps) (community)
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.15 / 1,000 follower scanneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Instagram Follower Tracker - New Followers & Unfollows

Find out who followed and who unfollowed any public Instagram profile. Run it on a schedule and get one row for every new follower, every unfollow and every change to the following list. No login or cookies needed.

### What you get

Every run compares the profile's current followers (and/or following) list with the snapshot saved by the previous run, and outputs one row per change:

- **trackedUsername**: the profile you are tracking
- **list**: `followers` or `following`
- **change**: `new` (started following, or was followed), `lost` (unfollowed, or was unfollowed) or `baseline` (first run)
- **userId**, **username**, **fullName**, **isVerified**, **profilePicUrl**: who changed
- **detectedAt**: when this run spotted the change
- **previousSnapshotAt**: the last snapshot that did not include the change (for `lost`, the last time the account was seen)

A **SUMMARY** record in the Key-value store gives the totals for each profile and list: total accounts, new, lost, and a status (`baseline`, `compared`, `incomplete`, `unavailable`, `not_found`).

Export to JSON, CSV, Excel or Google Sheets, or send the changes to Slack, email or a webhook with Apify integrations.

### Use cases

- **Unfollower tracking**: see exactly who unfollowed your brand or creator account, and when
- **Audience growth monitoring**: get a daily list of new followers to welcome, qualify or add to a CRM
- **Competitor analysis**: watch who starts following a competitor, and who they start following
- **Influencer vetting**: spot follow-for-follow churn and sudden follower spikes
- **Lead generation**: turn new followers of niche accounts into a daily list of warm leads

### How to use

1. Enter one or more **Instagram usernames** (with or without @).
2. Choose which **lists to track**: Followers, Following, or Both.
3. Run the actor once. This first run saves a **baseline** snapshot and outputs one summary row per list with its size. Turn on **Output full list on first run** if you also want every current follower as a row.
4. Set up a **schedule** (see below). Every later run outputs only what changed since the previous run.

#### Schedule it to track changes automatically

1. Save your input as a **Task** (Actor page → **Save as a new task**).
2. Open **Schedules** in Apify Console → **Create new** → pick a frequency (daily is a good default; weekly for large accounts).
3. Add your task to the schedule.
4. Optional: add an integration (Slack, email, Google Sheets, webhook) to the task so every new follower and unfollow gets sent to you.

Snapshots live in a named key-value store (default `instagram-follower-tracker-snapshots`) that is kept between runs. To keep separate histories, for example one per client, give each task its own **Snapshot store name**. To start over, delete that store or use a new name.

### Input example

```json
{
  "usernames": ["raycastapp", "@yourbrand"],
  "mode": "both",
  "maxFollowers": 10000,
  "emitBaselineList": false
}
```

### Output example

```json
{
  "trackedUsername": "raycastapp",
  "list": "followers",
  "change": "lost",
  "userId": "51767272098",
  "username": "pliiight",
  "fullName": "",
  "isVerified": false,
  "profilePicUrl": "https://scontent.cdninstagram.com/...",
  "count": null,
  "detectedAt": "2026-10-12T03:16:54.468Z",
  "previousSnapshotAt": "2026-10-12T03:09:47.845Z"
}
```

On the first run you get a baseline row instead, for example `{ "change": "baseline", "count": 1544, ... }`.

### How accurate is it?

Instagram does not always return exactly the same list twice. Each read can miss a few accounts that show up again in the next one. To avoid false alerts:

- **Unfollows are confirmed over two runs.** An account that is missing for the first time is held back. It is reported as `lost` only if it is still missing on the next run and a direct search of the list cannot find it. So an unfollow is reported one scheduled run after it happens.
- **New followers are reported straight away.** Instagram lists followers newest first, so an account that reappears deep in the list is treated as a glitch, not a new follow.

### Limits

- **Best for small and mid-size accounts.** Every run reads the whole list, so cost and run time grow with follower count. Instagram returns about 25 accounts per request, so 1,500 followers take roughly 10 seconds to 2 minutes and 10,000 take roughly 1 to 15 minutes, depending on Instagram's response times.
- **Verified accounts:** Instagram only shows the ~50 most recent followers of verified (blue badge) accounts, to everyone. Follower tracking for verified accounts only covers those. The following list is not affected.
- **Private accounts**, and public accounts that hide their lists, cannot be tracked. They show up as `unavailable` in the summary and are not charged.
- When the list Instagram returns is much smaller than the follower count on the profile, the summary includes a warning note. This is usually because of hidden, restricted or deactivated accounts.
- **Max accounts per list** (default 10,000) is a safety cap. If a list is bigger, only the most recent accounts are read: new followers are still detected, but unfollow detection is turned off for that list. Set it to 0 for no cap.
- On the free plan, each run reads up to 500 accounts per list for up to 3 profiles.
- If a run gets close to its timeout, it stops and keeps the previous snapshot unchanged, so you never get false unfollows from a half-read list. Increase the run timeout for big lists.

### Pricing

Pay per event:

- **follower-scanned**: per account read from a tracked list. This is what the run actually costs to do, whether or not anything changed.
- **result**: per change row in the dataset (`new`, `lost`, or a `baseline` row when the full list is output on the first run).

The baseline summary row and private or not-found profiles are not charged.

### FAQ

**Does it need my Instagram login?** No. It only reads public data.

**Can I see who unfollowed me on Instagram?** Yes. Track your own username with Followers selected and schedule daily runs. Every unfollow shows up as a `lost` row.

**Can I track several accounts at once?** Yes. Add as many usernames as you like. Each profile and list keeps its own snapshot.

# Actor input Schema

## `usernames` (type: `array`):

Public Instagram profiles to track (with or without @). Each one keeps its own snapshot between runs.

## `mode` (type: `string`):

Track the followers list, the following list, or both.

## `maxFollowers` (type: `integer`):

Safety cap on how many accounts are read from each list per run (most recent first). If a list is bigger than this, new followers are still detected but unfollow detection is turned off for that list. Set 0 for no cap.

## `emitBaselineList` (type: `boolean`):

On the first run for an account there is nothing to compare against. Off (default): output one baseline summary row with the list size. On: also output every account in the list as a 'baseline' row (charged per row).

## `snapshotStoreName` (type: `string`):

Name of the key-value store that keeps snapshots between runs. Use a different name to keep separate tracking histories (e.g. one per client). Letters, digits and hyphens only.

## Actor input object example

```json
{
  "usernames": [
    "raycastapp"
  ],
  "mode": "followers",
  "maxFollowers": 10000,
  "emitBaselineList": false,
  "snapshotStoreName": "instagram-follower-tracker-snapshots"
}
```

# Actor output Schema

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

One row per change: trackedUsername, list (followers/following), change (new/lost/baseline), userId, username, fullName, isVerified, profilePicUrl, detectedAt, previousSnapshotAt.

## `summary` (type: `string`):

SUMMARY record in the default key-value store: per account and list, the total count, number of new and lost accounts, and status.

# 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 = {
    "usernames": [
        "raycastapp"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("seemuapps/instagram-follower-tracker").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 = { "usernames": ["raycastapp"] }

# Run the Actor and wait for it to finish
run = client.actor("seemuapps/instagram-follower-tracker").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 '{
  "usernames": [
    "raycastapp"
  ]
}' |
apify call seemuapps/instagram-follower-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,seemuapps/instagram-follower-tracker"
        }
    }
}
```

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/hgfmvooFBpvadh2fX/builds/pmYfum2RWFk4GJWif/openapi.json