📈 Instagram Profile Stats & Growth Tracker

Instagram Profile Scraper — Followers, Growth & Engagement Data

Instagram Profile Stats & Growth Tracker pulls public profile data — followers, following, posts, verification and business flags, bio, contact details, and an engagement proxy — for any list of Instagram usernames, @handles, or profile URLs, and computes follower-growth deltas across scheduled runs. Every response is structured JSON, ready to pass directly to an LLM, load into a spreadsheet, or feed a monitoring pipeline. Unlike a one-off stats checker, the growth fields (followersDelta, growthPct, dailyAvgGrowth) are computed automatically from a persistent snapshot store, so there is no manual diffing between runs to track an account's trajectory.

What is Instagram Profile Stats & Growth Tracker?

Instagram Profile Stats & Growth Tracker is a bulk Instagram profile scraper: give it an array of usernames, @handles, or profile URLs and it returns one JSON row per input containing that account's public stats, flags, bio, and (optionally) how its follower count has changed since the last time you scraped it. No Instagram account, login, or cookies are required — the Actor reads Instagram's public profile endpoint the same way a logged-out browser visit does.

What sets it apart from a plain "profile checker" is that it remembers. When enableHistory is on, each run reads the account's previous follower snapshot from a persistent, named Apify Key-Value Store, computes the delta and growth rate against it, and then writes the new snapshot for next time — so a daily or weekly schedule turns into an automatic growth timeline without you storing or diffing anything yourself.

Key capabilities:

• 👤 Bulk profile lookup — any mix of bare usernames, @handles, and full https://instagram.com/... URLs in one urls array, deduplicated case-insensitively
• 📈 Cross-run follower-growth tracking — followersDelta, growthPct, dailyAvgGrowth, and previousSnapshotAt, computed from a persistent named Key-Value Store
• 🔥 Engagement proxy — average likes, average comments, and an engagement-rate percentage derived from the account's recent timeline posts
• 🧾 Bio and contact extraction — declared business email/phone plus emails and phone numbers regex-extracted from the biography text
• 👥 Related-profile discovery — Instagram's own "related accounts" suggestions for each profile
• ⚙️ Tunable concurrency, retries, and request pacing for balancing speed against Instagram's rate-limiting

What data can you get with Instagram Profile Stats & Growth Tracker?

Every input resolves to exactly one dataset row containing profile identity, growth, engagement, and contact data together — no separate calls to stitch results back together.

Result type	Extracted fields	Primary use case
Profile identity & stats	username, userId, fullName, userUrl, isVerified, isPrivate, isBusinessAccount, isProfessional, categoryName, followersCount, followsCount, postsCount, followersFollowingRatio, countIsExact	Lead enrichment, influencer vetting, account audits
Growth tracking	followersDelta, growthPct, dailyAvgGrowth, previousSnapshotAt	Follower-growth monitoring, competitor benchmarking over time
Engagement proxy	avgLikes, avgComments, engagementRatePct, lastPostAt, postsSampled	Influencer vetting, activity/health checks
Bio & contact data	biography, externalUrl, businessEmail, businessPhone, emailsFromBio, phonesFromBio, bioLinks	Lead generation, outreach list building
Related profiles	relatedProfiles (array of {id, username, fullName, isVerified, isPrivate, profilePicUrl})	Competitor/niche discovery, audience mapping
Media	profilePicUrl, profilePicUrlHD	Visual verification, media pipelines
Run metadata	scrapedAt, error	Auditing, pipeline error handling

Cross-run follower-growth tracking

This is the Actor's differentiator. When enableHistory is true (the default), every successful scrape writes {username, followersCount, scrapedAt} to a named Key-Value Store keyed by a sanitized version of the username. On the next run for that same username, the Actor reads that stored snapshot back, computes the delta, and returns it alongside the fresh stats — instead of leaving it to you to store yesterday's numbers and subtract them. The first time a username is ever scraped there is nothing to compare against, so all four growth fields come back null — never a fabricated 0. A snapshot is only written when followersCount was actually resolved for that run; a failed or unresolved scrape does not overwrite a good prior snapshot.

{
  "username": "humansofny",
  "followersCount": 12456789,
  "followersDelta": 3140,
  "growthPct": 0.0253,
  "dailyAvgGrowth": 448.57,
  "previousSnapshotAt": "2026-07-19T09:02:11Z"
}

growthPct is followersDelta divided by the previous snapshot's follower count, expressed as a percentage. dailyAvgGrowth divides the raw delta by the number of days elapsed since previousSnapshotAt, so runs spaced unevenly (daily one week, weekly the next) still produce a comparable daily rate.

Engagement proxy from recent posts

Alongside stats and growth, the Actor derives avgLikes, avgComments, and engagementRatePct from the timeline post data returned with the profile — the Actor's own code notes this typically covers the most recent ~12 posts, whatever Instagram's profile endpoint returns for that account in that response. engagementRatePct is (avgLikes + avgComments) / followersCount × 100. When an account has no visible posts in that response (private accounts you don't follow, or a genuinely empty account), all five engagement fields come back null and postsSampled is 0 — not a fabricated zero engagement rate.

Why not build this yourself?

Instagram does not publish a general-purpose API for looking up an arbitrary public profile's follower count and growth history. The Instagram Graph API only exposes data for Business or Creator accounts that you (or your client) own and have connected via a Facebook Page and app review — it cannot be used to look up a competitor's or an influencer's profile you don't manage. The old Instagram Basic Display API, which was closer to a general profile-lookup surface, has been deprecated.

That leaves scraping the public profile page as the only option for bulk, arbitrary-account lookups — and the page's data layer changes shape often enough (inline JSON blocks, window._sharedData, an embedded xdt_api payload, or nothing but og: meta tags depending on what Instagram serves that day) that a single fixed parser breaks regularly. This Actor tries the web_profile_info API endpoint first, then falls back through four separate HTML extraction methods in order before giving up on a profile, and every fetch runs through a fresh residential-proxy IP with retry back-off tuned for Instagram's rate limits. Building and maintaining that fallback chain, plus the growth-snapshot storage, is the work this Actor replaces.

What is the difference between a profile stats checker and a growth tracker?

A profile stats checker returns a single snapshot: today's follower count, following count, and bio, nothing more. A growth tracker additionally tells you how that snapshot compares to the last one — the delta, the percentage change, and a normalized daily rate — without you having to store and diff the numbers yourself.

The distinction matters because a single follower count is a data point, not a trend: 500,000 followers means very different things depending on whether the account gained 50,000 last week or lost 5,000. This Actor returns both in the same row: the plain snapshot fields (followersCount, followsCount, postsCount, ...) for a one-off lookup, and the growth fields (followersDelta, growthPct, dailyAvgGrowth, previousSnapshotAt) for a monitored one, controlled entirely by whether enableHistory is on and whether the same historyStoreName is reused across runs. You don't need a second Actor or a separate scheduling setup to get from "checker" to "tracker" — it's the same run, with history turned on.

How to scrape Instagram profiles with Instagram Profile Stats & Growth Tracker?

1. Open Instagram Profile Stats & Growth Tracker on the Apify Store and click Try for free (or Start, if you already have it saved) to open the run form in Apify Console.
2. Enter the profiles to scrape in urls — the only required field. Mix and match: bare usernames (humansofny), @handles (@cristiano), or full URLs (https://instagram.com/natgeo).
3. Leave enableHistory on (default true) if you want growth tracking, and set historyStoreName if you want a dedicated store for this project rather than the shared default.
4. Adjust concurrency, maxRetries, delayMs, and proxyConfiguration if the defaults are too fast or too slow for your target accounts, then click Start.
5. When the run finishes, open the Dataset tab and export the results as JSON, CSV, Excel, or via the API — one row per input, success or error.

{
  "urls": ["humansofny", "https://instagram.com/natgeo", "@cristiano"],
  "enableHistory": true,
  "concurrency": 2
}

How to track growth across multiple profiles in one job

Batching is just the urls array — there is no separate "watchlist" object. Put every account you want tracked into the same urls list and reuse the same historyStoreName on every run; the Actor keys each snapshot by username internally, so one store safely holds history for an unlimited number of different accounts at once. concurrency (default 2, 1–10) controls how many of those profiles are fetched in parallel, each on its own fresh proxy IP.

⬇️ Input

The Actor takes one JSON object with the following properties, exactly as declared in its input schema:

Parameter	Required	Type	Default / constraints	Description
urls	Yes	array of strings	—	Instagram profiles to scrape. Accepts full URLs (https://instagram.com/username), plain usernames, and @handles. Duplicates are removed case-insensitively.
enableHistory	No	boolean	default true	When on, each username's follower count is snapshotted to a named Key-Value Store; later runs compute followersDelta, growthPct, dailyAvgGrowth, and previousSnapshotAt against the last stored snapshot. First run for a username returns null for these fields.
historyStoreName	No	string	default "instagram-followers-history"	Name of the persistent (named) Key-Value Store used for follower snapshots. Reuse the same name across runs to accumulate history.
concurrency	No	integer	default 2, min 1, max 10	Number of profiles fetched in parallel, each on a fresh proxy IP and a fresh Chrome TLS client.
maxRetries	No	integer	default 3, min 1, max 10	How many times to retry fetching a profile page before recording an error row for it.
delayMs	No	integer	default 2000, min 0, max 60000	Base delay in milliseconds used for the per-profile jitter and the retry back-off.
proxyConfiguration	No	object (proxy editor)	prefill {"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}	Proxy settings. RESIDENTIAL proxies are strongly recommended — Instagram blocks most datacenter IPs. A fresh proxy IP is used per profile.

Example JSON input

{
  "urls": ["humansofny", "https://instagram.com/natgeo", "@cristiano"],
  "enableHistory": true,
  "historyStoreName": "instagram-followers-history",
  "concurrency": 2,
  "maxRetries": 3,
  "delayMs": 2000,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}

Common pitfall: setting delayMs to 0 does not fully disable pacing. It removes the pre-request jitter, but the retry back-off used after a failed attempt is computed as delayMs / 1000 or 2.0 seconds — and in the Actor's code, a delayMs of 0 evaluates as falsy, so the fallback of 2.0 seconds is used for retries regardless. If you need genuinely zero-delay retries, that isn't a configuration this Actor supports; delayMs above 0 behaves as documented.

A second pitfall: urls entries are matched against Instagram's own username pattern (letters, digits, periods, underscores, 1–30 characters). An unresolvable entry — a malformed handle, a non-Instagram URL, or a URL with no path — does not stop the run; it produces a single error row with error set to "Invalid input: ..." and every data field null.

⬆️ Output

Results are typed, normalized JSON with a consistent schema across every run — one row per entry in urls, whether it succeeded or failed. Export as JSON, CSV, Excel, or XML from the Dataset tab, or pull it programmatically via the Apify API or apify_client.

The default dataset view in Apify Console surfaces 35 of the row's fields as table columns. The Actor's row-building code (_blank_row in src/main.py) actually writes 36 fields — the view omits inputRaw (the original, unmodified string you passed in for that row, before URL/handle parsing), which is still present in every row if you read the dataset directly via the API rather than the console table.

Billing: this Actor uses pay-per-event pricing with a single charged event, row_result, billed once per row pushed to the dataset. There is no separate uncharged "accounting" row and no free retry — every input in urls produces exactly one row and is charged as one row_result, including rows where extraction failed (invalid username format, profile not found, or an unresolved fetch after maxRetries attempts) and error is non-null. Budget for the number of entries in urls, not just the number you expect to resolve successfully.

Scraped results

[
  {
    "inputRaw": "humansofny",
    "username": "humansofny",
    "userId": "186497643",
    "fullName": "Humans of New York",
    "userUrl": "https://www.instagram.com/humansofny",
    "isVerified": true,
    "isPrivate": false,
    "isBusinessAccount": true,
    "isProfessional": true,
    "categoryName": "Media/News Company",
    "followersCount": 12456789,
    "followsCount": 12,
    "postsCount": 3210,
    "followersFollowingRatio": 1038065.75,
    "countIsExact": true,
    "followersDelta": 3140,
    "growthPct": 0.0253,
    "dailyAvgGrowth": 448.57,
    "previousSnapshotAt": "2026-07-19T09:02:11Z",
    "avgLikes": 42130.5,
    "avgComments": 512.25,
    "engagementRatePct": 0.3428,
    "lastPostAt": "2026-07-25T14:03:00Z",
    "postsSampled": 12,
    "biography": "Stories from around the world.",
    "externalUrl": "https://humansofnewyork.com",
    "businessEmail": null,
    "businessPhone": null,
    "emailsFromBio": [],
    "phonesFromBio": [],
    "bioLinks": [{ "title": null, "url": "https://humansofnewyork.com" }],
    "relatedProfiles": [
      { "id": "1234567", "username": "natgeo", "fullName": "National Geographic", "isVerified": true, "isPrivate": false, "profilePicUrl": "https://scontent.cdninstagram.com/..." }
    ],
    "profilePicUrl": "https://scontent.cdninstagram.com/...",
    "profilePicUrlHD": "https://scontent.cdninstagram.com/...",
    "scrapedAt": "2026-07-26T08:14:02Z",
    "error": null
  },
  {
    "inputRaw": "@cristiano",
    "username": "cristiano",
    "userId": "173560420",
    "fullName": "Cristiano Ronaldo",
    "userUrl": "https://www.instagram.com/cristiano",
    "isVerified": true,
    "isPrivate": false,
    "isBusinessAccount": false,
    "isProfessional": false,
    "categoryName": null,
    "followersCount": 640620591,
    "followsCount": 584,
    "postsCount": 3756,
    "followersFollowingRatio": 1096953.75,
    "countIsExact": true,
    "followersDelta": null,
    "growthPct": null,
    "dailyAvgGrowth": null,
    "previousSnapshotAt": null,
    "avgLikes": 3812940.0,
    "avgComments": 18422.5,
    "engagementRatePct": 0.5975,
    "lastPostAt": "2026-07-24T19:41:00Z",
    "postsSampled": 12,
    "biography": "SIUUUbscribe to my Youtube Channel!",
    "externalUrl": null,
    "businessEmail": null,
    "businessPhone": null,
    "emailsFromBio": [],
    "phonesFromBio": [],
    "bioLinks": [],
    "relatedProfiles": [],
    "profilePicUrl": "https://scontent.cdninstagram.com/...",
    "profilePicUrlHD": "https://scontent.cdninstagram.com/...",
    "scrapedAt": "2026-07-26T08:14:05Z",
    "error": null
  },
  {
    "inputRaw": "this-handle-does-not-exist-9999",
    "username": "this-handle-does-not-exist-9999",
    "userId": null,
    "fullName": null,
    "userUrl": "https://www.instagram.com/this-handle-does-not-exist-9999",
    "isVerified": null,
    "isPrivate": null,
    "isBusinessAccount": null,
    "isProfessional": null,
    "categoryName": null,
    "followersCount": null,
    "followsCount": null,
    "postsCount": null,
    "followersFollowingRatio": null,
    "countIsExact": null,
    "followersDelta": null,
    "growthPct": null,
    "dailyAvgGrowth": null,
    "previousSnapshotAt": null,
    "avgLikes": null,
    "avgComments": null,
    "engagementRatePct": null,
    "lastPostAt": null,
    "postsSampled": null,
    "biography": null,
    "externalUrl": null,
    "businessEmail": null,
    "businessPhone": null,
    "emailsFromBio": [],
    "phonesFromBio": [],
    "bioLinks": [],
    "relatedProfiles": [],
    "profilePicUrl": null,
    "profilePicUrlHD": null,
    "scrapedAt": "2026-07-26T08:14:07Z",
    "error": "Profile not found"
  }
]

Two implementation details worth knowing when you consume this data: countIsExact is true when counts came from Instagram's structured API/JSON payload, and false when the Actor had to fall back to parsing the approximate, rounded numbers in the page's og:description meta tag (the "13M followers" style string) — treat false rows as directional, not precise. And counts follow a null-not-zero rule throughout: a genuine 0 (an account following nobody) is preserved as 0; a value Instagram simply didn't return comes back null.

How can I use the data extracted with Instagram Profile Stats & Growth Tracker?

• 📊 Social media managers and marketers: track your own accounts' followersCount and growthPct against competitors' in the same run, and pull avgLikes / engagementRatePct to see whose audience is actually engaged, not just large.
• 🤝 Influencer vetting and partnerships: before signing a creator, cross-check the follower count they report against followersCount, and use engagementRatePct and postsSampled as a sanity check against inflated or bot-heavy audiences.
• 🤖 AI engineers and LLM developers: an agent issues a batch of usernames, receives structured JSON back, and passes profile stats, growth, and bio data as grounded context for a research or outreach assistant — no scraping logic inside the agent itself.
• 📈 Growth and competitive analysts: schedule the same urls list weekly against a shared historyStoreName and chart followersDelta / dailyAvgGrowth over time to benchmark your account's trajectory against named competitors.
• 📧 Lead generation teams: pull businessEmail, businessPhone, emailsFromBio, and phonesFromBio off business accounts in a niche to build an outreach list without visiting each profile by hand.

How do you monitor follower growth over time?

Follower-growth monitoring here means running the same list of usernames on a recurring schedule and letting the Actor's own snapshot store do the comparison, instead of exporting each run's numbers and diffing them in a spreadsheet.

Each run that has enableHistory on and points at the same historyStoreName reads back the last snapshot for every username in urls, computes how much has changed, and writes a fresh snapshot for the next run. The fields to watch are followersDelta (raw change since the last run), growthPct (percentage change), and dailyAvgGrowth (change normalized to a per-day rate, so it stays comparable even if your schedule isn't perfectly even) — plus previousSnapshotAt, which tells you exactly when the baseline was taken so you can spot a run that was skipped or delayed.

A practical loop: put your watchlist of usernames into urls, set a fixed historyStoreName (e.g. "my-brand-watchlist"), and use an Apify Schedule (Console → Schedules → Create new, pointed at this Actor) to run it daily or weekly. Each scheduled run's dataset already contains that period's growth numbers — no external cron job or database needed to compute the delta, only to decide what to do with it (alerting, charting, or feeding it into another pipeline). The Actor itself does not send webhooks or notifications on a threshold; use an Apify Schedule combined with an Apify webhook on the Actor run, or read the dataset from your own automation, to act on a growthPct you care about.

Integrate Instagram Profile Stats & Growth Tracker and automate your workflow

Instagram Profile Stats & Growth Tracker works with any language or tool that can call the Apify API — the Apify Console UI is only one way to run it.

REST API with Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_API_TOKEN>")

run_input = {
    "urls": ["humansofny", "https://instagram.com/natgeo", "@cristiano"],
    "enableHistory": True,
    "concurrency": 2,
}

run = client.actor("instagram-profile-stats-growth-tracker").call(run_input=run_input)

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["username"], row["followersCount"], row["followersDelta"])

Scheduled monitoring and delivery

The Actor has no built-in webhook or notification mechanism of its own; delivery is handled through the Apify platform around it. Set up an Apify Schedule to run it on a recurring cadence against the same historyStoreName, and optionally attach an Apify webhook on run completion to push the run's dataset URL to your own endpoint, or poll the dataset via apify_client / the REST API after each scheduled run finishes.

Is it legal to scrape Instagram profiles?

Yes — scraping publicly accessible Instagram profile pages is generally legal in the United States; hiQ Labs, Inc. v. LinkedIn Corp., 938 F.3d 985 (9th Cir. 2019), held that scraping data a website makes publicly available, without logging in, does not violate the Computer Fraud and Abuse Act. This Actor only reads what any logged-out visitor to a public profile can already see — it does not log in, does not access private accounts' content, and does not bypass any access control.

That said, the profile, bio, and contact data this Actor returns is often personal data about identifiable individuals, so GDPR (if you or the data subjects are in the EU/EEA) and the CCPA/CPRA (for California residents) can still apply to how you store, process, and use it afterward, independent of whether the collection itself was lawful. Scraping for one-off research carries a different risk profile than scraping to build a persistent database of individuals' contact details for outreach — the latter is where privacy-law obligations bite hardest. Consult your legal team for commercial use cases involving bulk data storage, especially anything touching emailsFromBio, phonesFromBio, businessEmail, or businessPhone.

❓ Frequently asked questions

Does this Actor require an Instagram account or login?

No. It reads Instagram's public profile endpoint the same way a logged-out browser visit does — no username, password, session cookie, or app token for your Instagram account is ever needed.

How does Instagram Profile Stats & Growth Tracker handle Instagram's anti-bot measures?

Each profile is fetched through a fresh proxy IP (RESIDENTIAL is prefilled and recommended in proxyConfiguration, since Instagram blocks most datacenter ranges) with a fresh Chrome-impersonating TLS client per request. Requests are paced with a random jitter based on delayMs before each profile and an exponential retry back-off (starting at delayMs/1000 seconds, or 2.0 seconds if delayMs is 0, multiplying by 1.5 on each retry) up to maxRetries attempts before the profile is recorded as an error row.

Does Instagram Profile Stats & Growth Tracker track follower growth automatically?

Yes — with enableHistory on (the default), followersDelta, growthPct, and dailyAvgGrowth are computed automatically from a persistent named Key-Value Store on every run after the first for a given username, in the same row as the current stats. No separate export-and-diff step is required.

How many profiles can I scrape in one run?

There is no maximum-items limit declared in the urls field of the input schema, and the Actor's code does not cap the array length — the practical ceiling is your proxy budget, concurrency (1–10), and how long you're willing to let the run take, not an enforced cap.

Can this Actor scrape private Instagram accounts?

It returns whatever a logged-out visit to a private profile exposes — typically the username, identity flags (including isPrivate: true), and profile picture — but not follower/following counts, bio, or the timeline data used for the engagement proxy, since Instagram doesn't expose those to visitors who don't follow the account. Fields it can't see come back null, not a guessed value.

Are the follower counts exact?

When countIsExact is true, the count came from Instagram's structured API/JSON response and is precise. When it's false, the Actor had to fall back to the rounded, human-readable number in the page's meta description (e.g. "13M") — treat those as approximate.

How do I use this Actor to monitor an account's growth over time?

Put the account(s) in urls, leave enableHistory on with a fixed historyStoreName, and attach an Apify Schedule to run it on a recurring cadence. Each run's followersDelta, growthPct, and dailyAvgGrowth fields describe the change since the previous scheduled run.

Does Instagram Profile Stats & Growth Tracker work with Claude, ChatGPT, and AI agent frameworks?

It doesn't expose a dedicated MCP server. It is callable as a standard Apify Actor run via the REST API or apify_client, which any agent framework that can make an HTTP call — including custom Claude, ChatGPT, or LangChain-based agents — can invoke to retrieve live profile and growth data before generating an answer.

How does Instagram Profile Stats & Growth Tracker compare to other Instagram profile scrapers?

As observed on the Apify Store on 2026-07-26, karamelo/fast-instagram-profile-stats-checker-free returns a similar identity/count field set (including a facebook_id field this Actor does not expose) but does not document any cross-run growth computation. instaprism/instagram-profile-scraper documents a comparable field set and explicitly tells users to "set up scheduled runs... compare results to track growth" themselves — it does not compute deltas for you. sepia_ironmonger/instagram-follower-tracker's store listing title advertises "Analytics & Growth Monitor," but as of that date its published README is the unmodified default Apify Crawlee/CheerioCrawler JavaScript template, with no Instagram-specific fields or growth logic documented. This Actor is the only one of the three, as checked, that computes followersDelta, growthPct, and dailyAvgGrowth automatically from a persistent snapshot store rather than leaving comparison to the user.

Can I use this Actor without managing my own proxies?

Yes. proxyConfiguration is prefilled with Apify Proxy's RESIDENTIAL group, which the Actor uses to get a fresh IP per profile — you don't need to source or rotate proxies yourself, only an Apify account to run the Actor and, for RESIDENTIAL proxy access, sufficient Apify plan/proxy allowance.

💬 Your feedback

Found a bug or a field that doesn't match what Instagram actually returns? Let us know via the Actor's Issues tab on its Apify Store page, or send feedback through Apify Console's built-in contact options on the Actor page — reports like this keep the fallback parsers working as Instagram's page structure changes.