# Instagram Follower Tracker (`afanasenko/instagram-follower-tracker`) Actor Track new and lost Instagram followers and following over time. Schedule it: each run reports who started following and who unfollowed any public account β€” gained and lost, with timestamps. - **URL**: https://apify.com/afanasenko/instagram-follower-tracker.md - **Developed by:** [Andrey Afanasenko](https://apify.com/afanasenko) (community) - **Categories:** Lead generation, Social media, Automation - **Stats:** 9 total users, 3 monthly users, 100.0% runs succeeded, NaN bookmarks - **User rating**: No ratings yet ## Pricing from $0.03 / 1,000 follower checkeds 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/platform/actors/running/actors-in-store#pay-per-event ## What's an Apify Actor? Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases. 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. Actors are written with capital "A". ## 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. The best way to integrate Actors is as follows. In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md): ```bash pip install apify-client ``` In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md): ````bash # MacOS / Linux curl -fsSL https://apify.com/install-cli.sh | bash # Windows irm https://apify.com/install-cli.ps1 | iex ```bash In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md). If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README ## Instagram Follower Tracker [![Apify Actor](https://apify.com/actor-badge?actor=afanasenko/instagram-follower-tracker)](https://apify.com/afanasenko/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](https://docs.apify.com/platform/schedules) (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](https://apify.com/afanasenko/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: ```json { "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: ```json [ { "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`](.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): ```json { "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?](#-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: ```bash 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](https://docs.apify.com/platform/integrations/mcp) 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?](#-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](https://apify.com/afanasenko/instagram-followers-scraper) | | A username or URL | Scrape and enrich profiles, posts, and contact info | [Instagram Profile Scraper](https://apify.com/afanasenko/instagram-profile-scraper) | | A seed account | Discover similar / related accounts | [Instagram Related Profiles Scraper](https://apify.com/afanasenko/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](https://apify.com/afanasenko/instagram-profile-scraper-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](https://apify.com/afanasenko/instagram-follower-tracker/issues) β€” fastest way to get a fix shipped. - **Feature requests** in the same tab; we read every one. - **Ratings & reviews** on the [Apify Store page](https://apify.com/afanasenko/instagram-follower-tracker) 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. # Actor input Schema ## `usernames` (type: `array`): Instagram accounts to monitor β€” handles or profile URLs (one per line, e.g. `nike` or `https://instagram.com/zara`). Each run compares the account's current list against the previous run. Free plan: track 1 account across the trial (5 runs); paid plans track multiple accounts and larger lists, with no run limit. ## `trackFollowers` (type: `boolean`): When true, tracks each account's followers list β€” reports who newly followed and who unfollowed since the previous run. **Reliable up to 150,000 followers per account**; bigger follower lists are skipped without charge (not tracked). At least one of Track Followers / Track Following must be on. ## `trackFollowing` (type: `boolean`): When true, tracks each account's following list β€” reports which accounts the target started following and which it stopped following since the previous run. **Reliable up to 1,000 following per account**; bigger following lists are skipped without charge. The following list does **not** get a baseline listing on the first run β€” only its `new` / `lost` changes, starting from the second run. At least one of Track Followers / Track Following must be on. ## Actor input object example ```json { "usernames": [], "trackFollowers": true, "trackFollowing": true } ``` # Actor output Schema ## `runSummary` (type: `string`): No description ## `changes` (type: `string`): No description # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = {}; // Run the Actor and wait for it to finish const run = await client.actor("afanasenko/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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = {} # Run the Actor and wait for it to finish run = client.actor("afanasenko/instagram-follower-tracker").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print("πŸ’Ύ Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"]) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item) # πŸ“š Want to learn more πŸ“–? Go to β†’ https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{}' | apify call afanasenko/instagram-follower-tracker --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=afanasenko/instagram-follower-tracker", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Instagram Follower Tracker", "description": "Track new and lost Instagram followers and following over time. Schedule it: each run reports who started following and who unfollowed any public account β€” gained and lost, with timestamps.", "version": "0.0", "x-build-id": "3VLth3IbmqAiaNUiJ" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/afanasenko~instagram-follower-tracker/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-afanasenko-instagram-follower-tracker", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } }, "/acts/afanasenko~instagram-follower-tracker/runs": { "post": { "operationId": "runs-sync-afanasenko-instagram-follower-tracker", "x-openai-isConsequential": false, "summary": "Executes an Actor and returns information about the initiated run in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK", "content": { "application/json": { "schema": { "$ref": "#/components/schemas/runsResponseSchema" } } } } } } }, "/acts/afanasenko~instagram-follower-tracker/run-sync": { "post": { "operationId": "run-sync-afanasenko-instagram-follower-tracker", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } } }, "components": { "schemas": { "inputSchema": { "type": "object", "required": [ "usernames" ], "properties": { "usernames": { "title": "Accounts to Track", "type": "array", "description": "Instagram accounts to monitor β€” handles or profile URLs (one per line, e.g. `nike` or `https://instagram.com/zara`). Each run compares the account's current list against the previous run. Free plan: track 1 account across the trial (5 runs); paid plans track multiple accounts and larger lists, with no run limit.", "default": [], "items": { "type": "string" } }, "trackFollowers": { "title": "Track Followers", "type": "boolean", "description": "When true, tracks each account's followers list β€” reports who newly followed and who unfollowed since the previous run. **Reliable up to 150,000 followers per account**; bigger follower lists are skipped without charge (not tracked). At least one of Track Followers / Track Following must be on.", "default": true }, "trackFollowing": { "title": "Track Following", "type": "boolean", "description": "When true, tracks each account's following list β€” reports which accounts the target started following and which it stopped following since the previous run. **Reliable up to 1,000 following per account**; bigger following lists are skipped without charge. The following list does **not** get a baseline listing on the first run β€” only its `new` / `lost` changes, starting from the second run. At least one of Track Followers / Track Following must be on.", "default": true } } }, "runsResponseSchema": { "type": "object", "properties": { "data": { "type": "object", "properties": { "id": { "type": "string" }, "actId": { "type": "string" }, "userId": { "type": "string" }, "startedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "finishedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "status": { "type": "string", "example": "READY" }, "meta": { "type": "object", "properties": { "origin": { "type": "string", "example": "API" }, "userAgent": { "type": "string" } } }, "stats": { "type": "object", "properties": { "inputBodyLen": { "type": "integer", "example": 2000 }, "rebootCount": { "type": "integer", "example": 0 }, "restartCount": { "type": "integer", "example": 0 }, "resurrectCount": { "type": "integer", "example": 0 }, "computeUnits": { "type": "integer", "example": 0 } } }, "options": { "type": "object", "properties": { "build": { "type": "string", "example": "latest" }, "timeoutSecs": { "type": "integer", "example": 300 }, "memoryMbytes": { "type": "integer", "example": 1024 }, "diskMbytes": { "type": "integer", "example": 2048 } } }, "buildId": { "type": "string" }, "defaultKeyValueStoreId": { "type": "string" }, "defaultDatasetId": { "type": "string" }, "defaultRequestQueueId": { "type": "string" }, "buildNumber": { "type": "string", "example": "1.0.0" }, "containerUrl": { "type": "string" }, "usage": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "integer", "example": 1 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } }, "usageTotalUsd": { "type": "number", "example": 0.00005 }, "usageUsd": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "number", "example": 0.00005 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } } } } } } } } } ```