# Instagram Follower Tracker (`automation-lab/instagram-follower-change-monitor`) Actor

Track public Instagram follower and following counts across runs with timestamped previous values, absolute changes, and percentage changes.

- **URL**: https://apify.com/automation-lab/instagram-follower-change-monitor.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Social media, Automation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.68 / 1,000 item processeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

Track public Instagram follower and following counts across repeated runs. This Instagram follower tracker saves one successful snapshot per profile, then exports previous values, absolute changes, percentage changes, and observation timestamps on later runs.

Use it for scheduled creator monitoring, competitor audience reporting, campaign checks, and spreadsheet or data-pipeline exports. It measures **counts**, not the identities of individual followers or unfollowers.

### What does this Actor do?

For each supplied public Instagram profile, the Actor:

1. validates and deduplicates usernames and profile URLs;
2. captures current follower, following, and post counts;
3. loads the last successful snapshot in the same state namespace;
4. calculates absolute and percentage changes;
5. writes one typed dataset row;
6. replaces the saved baseline only after a successful result.

The first observation has `changeState: "first_seen"` and null change fields. Later observations are `changed` or `unchanged`.

### Who is it for?

- **Influencer marketing teams** comparing creator audience growth.
- **Social media managers** checking owned profiles on a schedule.
- **Competitive intelligence teams** monitoring public competitor accounts.
- **Agencies** exporting repeatable client reports.
- **Analysts and developers** feeding timestamped Instagram counters into BI tools.

### Why use this Instagram tracker?

A normal profile scraper gives you current counters. This Actor adds the monitoring state required to answer what changed since the previous successful run.

- No Instagram login or cookies supplied by you.
- Public usernames, `@handles`, and profile URLs are supported.
- Task runs are isolated automatically by Apify Task ID.
- Direct/API runs can set a stable `stateNamespace`.
- Failed profiles do not overwrite a healthy baseline.
- Useful rows include both current and previous values.

### What data can I export?

| Field | Meaning |
| --- | --- |
| `instagramUserId` | Stable Instagram account ID |
| `username` | Username at observation time |
| `displayName` | Public display name |
| `profileUrl` | Canonical profile URL |
| `followersCount` | Current follower count |
| `followingCount` | Current following count |
| `postsCount` | Current post count when available |
| `previousFollowersCount` | Previous successful follower count |
| `previousFollowingCount` | Previous successful following count |
| `followersChange` | Current minus previous followers |
| `followersChangePercent` | Percentage follower change |
| `followingChange` | Current minus previous following |
| `followingChangePercent` | Percentage following change |
| `observedAt` | Current snapshot timestamp |
| `previousObservedAt` | Previous snapshot timestamp |
| `changeState` | `first_seen`, `changed`, or `unchanged` |
| `stateNamespace` | Snapshot-history namespace |

You can download the default dataset as JSON, CSV, Excel, XML, RSS, or HTML through Apify.

### How to track Instagram follower changes

1. Open the Actor input.
2. Add one or more public usernames or profile URLs under **Instagram profiles**.
3. Run once to establish the baseline.
4. Run again later with the same namespace to calculate changes.
5. For recurring monitoring, save the input as an Apify Task and add a daily or weekly Schedule.
6. Export the dataset or connect it to your automation.

For scheduled Tasks, leave `stateNamespace` empty unless you intentionally want several Tasks to share a named history. The Actor automatically uses the stable Task ID.

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `profiles` | string\[] | `nasa`, `natgeo` | Public usernames, @handles, or profile URLs; required |
| `stateNamespace` | string | Task ID or `default` | Stable history namespace, 1–64 letters, numbers, `_`, or `-` |
| `resetBaseline` | boolean | `false` | Ignore old values and save a fresh baseline |
| `maxProfiles` | integer | `100` | Maximum unique profiles processed, up to 500 |
| `maxRetries` | integer | `2` | Lower-cost structured-route attempts before bounded recovery |

Duplicate usernames are processed once. Post and Reel URLs are rejected because this Actor accepts profile pages only.

### Example input

```json
{
  "profiles": [
    "nasa",
    "@natgeo",
    "https://www.instagram.com/apify/"
  ],
  "stateNamespace": "weekly-creator-watch",
  "maxProfiles": 100,
  "maxRetries": 2
}
```

To deliberately restart history:

```json
{
  "profiles": ["nasa", "natgeo"],
  "stateNamespace": "weekly-creator-watch",
  "resetBaseline": true
}
```

### Example output

A later successful run produces a row like this:

```json
{
  "instagramUserId": "17841401474538262",
  "username": "nasa",
  "displayName": "NASA",
  "profileUrl": "https://www.instagram.com/nasa/",
  "isVerified": true,
  "isPrivate": false,
  "followersCount": 104353012,
  "followingCount": 91,
  "postsCount": 4923,
  "previousFollowersCount": 104353016,
  "previousFollowingCount": 91,
  "followersChange": -4,
  "followersChangePercent": 0,
  "followingChange": 0,
  "followingChangePercent": 0,
  "observedAt": "2026-09-16T14:08:11.000Z",
  "previousObservedAt": "2026-09-16T14:07:02.000Z",
  "changeState": "changed",
  "stateNamespace": "weekly-creator-watch"
}
```

Small percentage changes can round to `0` because percentages are reported to three decimal places. Baseline rows have null previous/change fields.

### How much does it cost to track Instagram follower changes?

The Actor uses pay-per-event pricing:

- one **Start** charge per run;
- one **Item processed** charge per successful profile snapshot;
- no item charge for a profile that cannot produce a useful snapshot.

The exact price depends on your Apify plan and is shown in Console before a run. The active BRONZE rate is $0.0028 per successful profile plus a $0.004 start event:

| Successful profiles | Billable events |
| ---: | --- |
| 1 | 1 start + 1 item |
| 10 | 1 start + 10 items |
| 100 | 1 start + 100 items |

Multiply the item count by your plan's live item rate, then add the one-time start event. These examples exclude any taxes, refunds, fraud adjustments, disputes, corrections, or clawbacks. Check the live Console pricing panel for the applicable tier before running.

### Scheduling and history isolation

The best monitoring workflow is an Apify Task:

1. create a Task from a working Actor input;
2. run it once to establish a baseline;
3. attach an Apify Schedule;
4. keep the profile list stable or interpret new profiles as `first_seen`;
5. connect completed datasets to your reporting destination.

Each Task receives its own automatic namespace. When you run the Actor directly from an API client, use a unique stable `stateNamespace` for each monitor. Reusing the same namespace intentionally shares baselines for matching usernames.

### Reliability, retries, and limits

Instagram is a changing third-party source. The Actor first tries a lightweight structured route, then uses a bounded US residential profile-page recovery when required. A recovery attempt can take longer and transfer more data.

- Maximum input size: 500 profile entries.
- Processing is conservative to reduce source blocking.
- Only public profile metadata is supported.
- Private profiles may expose counters but no private content is accessed.
- Deleted, renamed, unavailable, or blocked profiles can fail.
- Partial batches preserve successful rows.
- A run fails if every requested profile fails.
- A failed fetch does not replace the previous successful snapshot.

### Export to Google Sheets or a data pipeline

For a spreadsheet workflow, schedule the Task and connect the run dataset through Apify Integrations, Make, Zapier, or a webhook. Keep `username`, `observedAt`, `followersCount`, and `followersChange` as the core reporting columns.

For a warehouse workflow, fetch every run's dataset after completion and append rows keyed by:

```text
stateNamespace + username + observedAt
```

This gives you longer-term history while the Actor's own state store retains only the latest successful baseline needed for the next comparison.

### Run with the Apify API

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~instagram-follower-change-monitor/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "profiles": ["nasa", "natgeo"],
    "stateNamespace": "api-weekly-watch"
  }'
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/instagram-follower-change-monitor').call({
  profiles: ['nasa', 'natgeo'],
  stateNamespace: 'js-weekly-watch',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/instagram-follower-change-monitor").call(
    run_input={
        "profiles": ["nasa", "natgeo"],
        "stateNamespace": "python-weekly-watch",
    }
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use with MCP and AI agents

#### Claude Code

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/instagram-follower-change-monitor"
```

#### Claude Desktop, Cursor, and VS Code

Use this HTTP MCP configuration in Claude Desktop, Cursor, or VS Code:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/instagram-follower-change-monitor"
    }
  }
}
```

Example prompts:

- “Create a baseline for NASA and National Geographic Instagram follower counts.”
- “Run my weekly creator monitor and summarize absolute follower changes.”
- “Return only profiles whose follower count changed since the last snapshot.”

The Actor returns all useful snapshots; your agent can filter `changeState` or `followersChange` afterward.

### Legality and responsible use

Use the Actor only for lawful purposes and public information. Respect Instagram's terms, applicable privacy and database laws, contractual obligations, and the rights of profile owners. Do not use count changes to harass, discriminate against, or make sensitive decisions about individuals.

This Actor does not log in, bypass private-account controls, or return individual follower identities. It is independently operated and is not affiliated with or endorsed by Instagram or Meta.

### Troubleshooting

#### Why are all change fields null?

This is the first successful observation in that namespace, or `resetBaseline` was enabled. Run later with the same profile and namespace.

#### Why did a profile fail while other rows succeeded?

The account may be unavailable, renamed, rate-limited, or temporarily blocked by Instagram. Successful profiles are preserved. Retry later rather than repeatedly launching identical runs.

#### Why did my history restart?

Check whether you changed `stateNamespace`, switched to another Task, or enabled `resetBaseline`. Each Task is isolated automatically.

#### Why is the percentage zero when the absolute change is not zero?

The percentage is rounded to three decimal places. A change of a few followers on a very large account can round to `0`.

### FAQ

#### Does it show who followed or unfollowed?

No. It reports follower and following **count changes**, not lists of people.

#### Can I monitor private accounts?

Only public counters that Instagram exposes may be returned. The Actor never accesses private posts or follower lists.

#### Can I monitor hundreds of profiles?

Yes, up to 500 entries per run, but begin with a smaller batch and schedule conservatively because source availability and runtime can vary.

#### Does the Actor keep full history?

The default dataset stores each run's exported rows. The internal state store keeps only the latest successful baseline per namespace and username. Append run datasets externally for long-term analysis.

#### Are profile URLs supported?

Yes. Use a direct `instagram.com/<username>/` profile URL. Post, Reel, Stories, Explore, and account-management URLs are rejected.

### Related automation-lab Actors

- [Instagram Public Profile Details Scraper](https://apify.com/automation-lab/instagram-public-profile-details) for richer current profile metadata without monitoring state.
- [Instagram Profile Stats Scraper](https://apify.com/automation-lab/instagram-profile-stats-scraper) for current qualification and engagement-summary metrics.
- [Instagram Account & Post Analytics Scraper](https://apify.com/automation-lab/instagram-account-post-analytics) for profile plus recent-post performance analysis.
- [X Follower Change Monitor](https://apify.com/automation-lab/x-follower-change-monitor) for the equivalent count-change workflow on X.

### Support

If Instagram changes its public responses or a valid public profile repeatedly fails, open an issue from the Actor page with a non-sensitive example input and the run URL. Do not include passwords, cookies, or private account data.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/instagram-follower-change-monitor/changelog.md

# Actor input Schema

## `profiles` (type: `array`):

Public Instagram usernames, @handles, or profile URLs to monitor.

## `stateNamespace` (type: `string`):

Optional stable identifier that keeps one monitor's history separate. Scheduled Tasks are isolated automatically by Task ID when this is omitted.

## `resetBaseline` (type: `boolean`):

Ignore the previous snapshot during this run and save the current counts as a new baseline.

## `maxProfiles` (type: `integer`):

Maximum number of unique profiles to process after validation and deduplication.

## `maxRetries` (type: `integer`):

Maximum lower-cost structured endpoint attempts before one bounded residential profile-page recovery.

## Actor input object example

```json
{
  "profiles": [
    "nasa",
    "natgeo"
  ],
  "resetBaseline": false,
  "maxProfiles": 100,
  "maxRetries": 2
}
```

# Actor output Schema

## `overview` (type: `string`):

Dataset containing current and previous audience counts, absolute and percentage changes, and observation timestamps.

# 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 = {
    "profiles": [
        "nasa",
        "natgeo"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/instagram-follower-change-monitor").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 = { "profiles": [
        "nasa",
        "natgeo",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/instagram-follower-change-monitor").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 '{
  "profiles": [
    "nasa",
    "natgeo"
  ]
}' |
apify call automation-lab/instagram-follower-change-monitor --silent --output-dataset

```

## MCP server setup

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

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/sLab2nK0vq8RsSUq1/builds/Cf64bVjdTQ2ouohTv/openapi.json