Instagram Followers Scraper: Multi-Profile Analysis

Instagram Scraper — Extract Followers, Overlap Summary and Matrix

Instagram Followers Scraper: Multi-Profile Analysis collects follower records — username, full name, profile picture, verified and private status — from any public Instagram profile, and returns them as typed JSON with no HTML to parse. Give it two or more profiles in the same run and it also computes, at no extra request cost, a shared-follower overlap summary and an N×N profile-pair overlap matrix. Unlike scraping frameworks that hand back raw HTML, this Actor returns structured rows ready for your database, spreadsheet, or LLM pipeline. This guide covers every input and output field and how audience, competitive-intelligence, and research teams actually deploy it.

🧭 What Does Instagram Followers Scraper: Multi-Profile Analysis Do?

This Actor scrapes the public follower list of one or more Instagram profiles and, when it collects followers for 2+ profiles in a single run, cross-references those already-collected lists to surface shared audience. No Instagram account is strictly required to start a run, but an authenticated sessionid cookie is required for the real followers endpoint to return data — without it, Instagram's API returns 401 and the Actor falls back to padding results from post commenters or returns zero rows. Key capabilities:

• Scrape followers from any number of public Instagram profiles in one run
• Accept plain usernames, full profile URLs, or {"url": "..."} objects interchangeably
• Compute a shared-follower overlap summary — every username following 2+ of your input profiles
• Compute a profile-pair overlap matrix — shared-follower counts between every pair of input profiles
• Cap collection per profile from 1 to 100,000 followers via maxData
• Fall back to post-commenter data (sourceType: "comment_fallback") when the authenticated followers endpoint is unavailable
• Escalate automatically through no-proxy → datacenter → residential proxies on blocks

⚡ Features & Capabilities

The Actor's capabilities split into follower collection, cross-profile analysis, and resilience against blocks.

Core features

• Real-time dataset writes — every follower row is pushed to the dataset as it's collected, not batched at the end of the run
• Dual collection path — primary path hits Instagram's authenticated friendships/{user_id}/followers/ endpoint; if that's unavailable, the Actor pulls additional users from commenters on the target's own posts (GraphQL xdt_api__v1__feed__user_timeline_graphql_connection + media comments API)
• Deduplication by user ID across both collection paths, so no follower is double-counted within a profile's list
• Zero-cost cross-profile overlap — the overlap summary and overlap matrix are pure local set-intersections over rows already collected in the run, with no additional HTTP calls to Instagram
• Full field set on every row: pk, pk_id, id, fbid_v2, strong_id__, full_name, username, profile_pic_url, profile_pic_id, is_verified, is_private, has_anonymous_profile_picture, account_badges, latest_reel_media, is_favorite, third_party_downloads_enabled, plus derived followed_by, sourceType, success, profileUrl, and scrapedAt
• Configurable overlap threshold via minSharedProfiles, so large profile sets can be filtered down to only the most broadly shared audience
• Automatic proxy escalation — no proxy by default, datacenter proxy on the first block, sticky residential proxy with retries if blocks continue

Instagram Followers Scraper: Multi-Profile Analysis within the Scrapio data stack

This Actor covers followers and cross-profile follower overlap. For following-list monitoring with daily added/removed/stable diffs, use instagram-following-scraper-with-daily-unfollowers-report. For raw follower/following counts and growth-rate tracking across many accounts, use instagram-followers-count-scraper-multiple-accounts-follower-counts. For related-profile network expansion combined with a follows-back diff, use instagram-followers-and-following-scrapper-with-mutual-connections-profile. For contact-detail extraction from a profile's bio, use instagram-profile-scraper-with-bio-link-email-extraction.

Why do developers and data teams scrape Instagram?

Instagram follower data underpins a specific set of commercial, research, and product workflows — from vetting an influencer's real audience to building network-analysis datasets.

🏢 Brand, agency, and influencer marketing teams

Marketing and partnerships teams feed a shortlist of influencer or competitor startUrls into a run, collect username, is_verified, is_private, and full_name for each follower, and use the overlap summary's sharedWithProfiles and overlapCount fields to see exactly how much audience two creators already share before signing a collaboration or cross-promotion deal. The profile-pair overlap matrix ranks an entire shortlist of candidate accounts by audience overlap in one pass, so a team comparing ten potential partners doesn't need to manually diff ten separate follower exports.

📊 AI training data and RAG indexing

The username, full_name, and sharedWithProfiles fields give language models structured, deduplicated identity data instead of scraped HTML fragments to parse. For RAG, the overlap-summary rows (overlapCount, sharedWithProfiles, totalProfilesScanned) let an agent answer "which accounts share the most audience with X" directly from indexed rows rather than re-deriving it. For training data, the follower row's fixed field set — always the same 21 keys, always typed primitives — gives a consistent record shape across every profile scraped, which matters more for model training than any single field's content.

📱 Competitive and market intelligence

Track how much of your own follower base already overlaps with a competitor's, using the same overlapCount and matrix values used for partnership vetting — but pointed at rivals instead of collaborators. Re-running the same startUrls set periodically and comparing overlapCount over time shows whether a competitor's audience is converging with or diverging from yours.

🔬 Research and academic use

Social network researchers use the follower rows and overlap matrix to study audience clustering, community structure, and cross-account audience sharing across public Instagram profiles — all from data Instagram already serves to any authenticated viewer of a profile's followers list. This is limited to publicly accessible profile and follower data; the Actor does not access private accounts or non-public relationship data.

🎥 Product and SaaS development

Teams building influencer-discovery platforms, audience-overlap dashboards, or partnership-vetting tools use this Actor as the collection layer, then layer their own scoring or visualization on top of the overlapCount, sharedFollowerCount, and matrix fields it already computes.

🍚 Input Parameters

The Actor takes 6 input parameters, only 1 of which is required.

Parameter	Required	Type	Description	Example Value
startUrls	Yes	array	Instagram profile URLs or usernames to scrape. Accepts full URLs, bare usernames, or {"url": "..."} objects. Add 2+ to unlock overlap analysis.	["https://www.instagram.com/cristiano/", "nike"]
maxData	No	integer	Maximum followers to collect per profile (1–100,000). Default: 100.	500
computeOverlap	No	boolean	When true (default) and 2+ profiles are supplied, emits the overlap-summary and overlap-matrix datasets.	true
minSharedProfiles	No	integer	Minimum number of input profiles a follower must appear under to be included in the overlap summary. Default: 2, minimum: 2.	3
sessionId	No	string	Instagram sessionid cookie from a currently logged-in browser session. Required for the real followers endpoint; without a value of at least 10 characters, the Actor falls back to comment-based padding or returns 0 rows.	"58012345678%3A..."
proxyConfiguration	No	object	Apify proxy configuration. Defaults to no proxy; the Actor escalates to datacenter, then sticky residential proxy automatically on blocks.	{"useApifyProxy": true}

{
  "startUrls": [
    { "url": "https://www.instagram.com/cristiano/" },
    { "url": "https://www.instagram.com/nike/" },
    { "url": "adidas" }
  ],
  "maxData": 500,
  "computeOverlap": true,
  "minSharedProfiles": 2,
  "sessionId": "58012345678%3Aabcdefghij1234567890%3A29%3AAY...",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}

Supported URL types and input formats

startUrls array items are parsed by a single username-extraction rule: if the value starts with http, the Actor takes the URL path segment as the username; otherwise it strips a leading @ and trailing / and uses the value as-is. All three of the following resolve to the same target:

• https://www.instagram.com/cristiano/ — full profile URL
• cristiano — bare username
• {"url": "cristiano"} — object shape, same as the base Instagram Followers Scraper's input format

Add 2 or more distinct profiles to trigger computeOverlap; a single profile runs as a standard follower scrape with no overlap output.

📦 Output Format

Every run produces typed, normalized JSON with a stable field set per row — no HTML, no manual parsing. Results export as JSON, CSV, Excel, or JSONL directly from the Apify dataset, or are retrievable via the Apify API.

Output for followers

The default dataset holds one row per follower, tagged with which target profile it came from. This is the full 21-field row the Actor writes — the same set exposed in the default dataset view:

{
  "pk": "73320179592",
  "pk_id": "73320179592",
  "id": "73320179592",
  "full_name": "Arizki Davabukan",
  "is_private": true,
  "fbid_v2": "",
  "third_party_downloads_enabled": 0,
  "strong_id__": "73320179592",
  "profile_pic_id": "",
  "profile_pic_url": "https://scontent.cdninstagram.com/v/t51.2885-19/example_150x150.jpg",
  "is_verified": false,
  "username": "davabukandaffa5",
  "has_anonymous_profile_picture": false,
  "account_badges": [],
  "latest_reel_media": 0,
  "is_favorite": false,
  "followed_by": "cristiano",
  "sourceType": "follower",
  "success": true,
  "profileUrl": "https://www.instagram.com/davabukandaffa5/",
  "scrapedAt": "2026-07-25T09:14:03Z"
}

sourceType is either follower (Instagram's real followers endpoint) or comment_fallback (padded from commenters on the target's own posts, used only when the followers endpoint is unavailable or the target has fewer followers than requested). success is always true for every row in this dataset — rows that fail to build are never pushed, so nothing needs to be filtered out.

Output for overlap summary and matrix

When computeOverlap is on and 2+ profiles produced followers, two additional named datasets are written per run, plus a lookup record in the key-value store.

overlap-summary-<runId> — one row per username shared across 2+ input profiles:

{
  "username": "some_shared_user",
  "pk": "123456789",
  "fullName": "Some Shared User",
  "sharedWithProfiles": ["cristiano", "nike"],
  "overlapCount": 2,
  "totalProfilesScanned": 3
}

overlap-matrix-<runId> — one row per profile pair, plus one full-matrix summary row:

{"profileA": "cristiano", "profileB": "nike", "sharedFollowerCount": 41, "isSameProfile": false}
{"profileA": "cristiano", "profileB": "cristiano", "sharedFollowerCount": 500, "isSameProfile": true}
{"type": "matrix_full", "profiles": ["cristiano", "nike", "adidas"], "matrix": [[500, 41, 18], [41, 480, 9], [18, 9, 470]]}

Both dataset names, plus uniqueProfilesAnalyzed, minSharedProfiles, and overlapRowsCount, are also written to the run's key-value store under the key OVERLAP_ANALYSIS_INFO — the fastest way to locate the right per-run datasets programmatically.

Schema stability and export options

Field names are stable across runs and are not renamed if Instagram changes its front end, since they're built explicitly by the Actor's row-construction code rather than passed through raw from the page. If Instagram removes a field from its API response, that key still appears on the row with its default value (empty string, false, or 0) rather than disappearing, so downstream schemas don't break. Results are available as JSON, CSV, Excel (XLSX), and JSONL through the Apify dataset export options, and programmatically through the Apify API and client libraries.

💡 Instagram Followers Scraper: Multi-Profile Analysis Strategy Guide

🎯 Strategy 1: Real-time enrichment pipeline

Trigger a run whenever a new lead or partner profile enters your CRM: pass its handle as a single-item startUrls array, then read back full_name, is_verified, is_private, and followed_by from the resulting rows to enrich the CRM record with real audience data. For partnership evaluation, run 2+ candidate profiles together so the same call also returns overlapCount — how much their audiences already overlap with an existing partner or your own account — without a second run.

🎯 Strategy 2: Scheduled monitoring and alerting

Use an Apify Schedule to re-run the same startUrls set on a recurring cadence. After each run, read OVERLAP_ANALYSIS_INFO from the key-value store to locate that run's overlap-summary-<runId> and overlap-matrix-<runId> datasets, then diff overlapCount per username and sharedFollowerCount per profile pair against the previous run's values (stored externally, since each run's datasets are independent). Alert when a tracked pair's sharedFollowerCount crosses a threshold you define — for example, a competitor's audience overlap with your brand growing significantly.

🎯 Strategy 3: Bulk dataset build

For research or training-dataset builds, pass a large startUrls list in a single run, set maxData up to its 100,000 ceiling per profile, and export the default dataset directly to CSV or JSONL once the run completes. The Actor has no separate documented concurrency setting to tune — profiles are processed within the one run you start — so scale by increasing maxData and the number of profiles in startUrls rather than by launching parallel runs against the same targets.

Strategy comparison at a glance

Strategy	Best for	Run pattern	Output format
Real-time enrichment	Per-lead or per-partner CRM enrichment	Single-profile or small-batch run on demand	JSON row appended to CRM
Scheduled monitoring	Ongoing overlap/competitor tracking	Apify Schedule, recurring startUrls set	Per-run named datasets + KV lookup
Bulk dataset build	Research and training datasets	One large-startUrls run, high maxData	CSV / JSONL export

🌴 Related Instagram Scrapers & Tools

Scraper Name	What it extracts
instagram-followers-and-following-scrapper-with-mutual-connections-profile	Followers or following lists, related-profile expansion, and a follows-back mutual-connection diff
instagram-followers-count-scraper-multiple-accounts-follower-counts	Follower/following/post counts and growth deltas across multiple accounts over time
instagram-following-scraper-with-daily-unfollowers-report	Following-list changes labeled added/removed/stable between runs
instagram-related-person-scraper-by-niche-content-creator-search	Related/suggested-profile discovery, filtered and ranked into an influencer shortlist
instagram-profile-scraper-with-bio-link-email-extraction	Profile bio plus extracted emails, phone numbers, and social handles
instagram-comments-scraper-with-engagement-analytics	Post comments with engagement metrics
instagram-hashtag-engagement-scraper	Hashtag-level engagement statistics
instagram-b2b-email-scraper-business-type-leads	Business-account email lead lists

How to integrate Instagram Followers Scraper: Multi-Profile Analysis with your stack

Instagram Followers Scraper: Multi-Profile Analysis works with any language or tool that can call the Apify API — there's no proprietary SDK requirement beyond Apify's own official clients.

Python

import csv
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

profiles = ["cristiano", "nike", "adidas"]
run_input = {
    "startUrls": [{"url": p} for p in profiles],
    "maxData": 500,
    "computeOverlap": True,
    "minSharedProfiles": 2,
    "sessionId": "<YOUR_IG_SESSIONID>",
}

run = client.actor("Scrapio/instagram-followers-scraper-multi-profile-analysis").call(run_input=run_input)
items = list(client.dataset(run["defaultDatasetId"]).iterate_items())

with open("followers.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=list(items[0].keys()))
    writer.writeheader()
    writer.writerows(items)

print(f"Saved {len(items)} follower rows to followers.csv")

Node.js

import { ApifyClient } from 'apify-client';
import fs from 'fs';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });

const input = {
    startUrls: [{ url: 'cristiano' }, { url: 'nike' }],
    maxData: 500,
    computeOverlap: true,
    minSharedProfiles: 2,
    sessionId: '<YOUR_IG_SESSIONID>',
};

const run = await client.actor('Scrapio/instagram-followers-scraper-multi-profile-analysis').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();

fs.writeFileSync('followers.json', JSON.stringify(items, null, 2));
console.log(`Saved ${items.length} follower rows`);

Async and scheduled pipelines

There's no webhook-payload delivery beyond Apify's standard run-event webhooks. For fire-and-forget large jobs, start the run asynchronously via client.actor(...).start(run_input=...), register an Apify webhook on ACTOR.RUN.SUCCEEDED to trigger your own downstream job, and use an Apify Schedule for recurring runs instead of managing cron infrastructure yourself. Poll client.dataset(datasetId).iterate_items() once the webhook fires.

🎯 Who Needs Instagram Followers Scraper: Multi-Profile Analysis? (Use Cases & Industries)

🏢 Brand, agency, and influencer marketing teams

An agency vetting five influencer partnership candidates runs all five as startUrls in one job, then reads the overlap matrix to see that two candidates already share 38% of their followers — meaning a joint campaign would largely reach the same people rather than expanding total unique reach.

📊 AI/ML and data teams

Teams building an audience-similarity model index the overlapCount and sharedWithProfiles fields per creator pair as training features, avoiding the need to write their own set-intersection logic across raw follower exports.

📱 Competitive intelligence analysts

An analyst tracking three competitor brand accounts re-runs the same startUrls monthly and watches sharedFollowerCount in the overlap matrix to see whether a competitor's audience is converging with the analyst's own brand account over time.

🔬 Researchers

Academic researchers studying online community structure use the follower rows and overlap matrix as a dataset for network-clustering analysis across public Instagram profiles, without needing private-account access.

🎥 Product and SaaS builders

Teams building an audience-overlap or influencer-vetting SaaS product use this Actor as their data-collection layer, calling it per customer request and passing the overlapCount/matrix fields straight into their own dashboard.

Is it legal to scrape Instagram?

Scraping publicly accessible Instagram data is generally lawful in the United States; courts have distinguished this from unauthorized computer access. In hiQ Labs, Inc. v. LinkedIn Corp., 938 F.3d 985 (9th Cir. 2019), the Ninth Circuit held that scraping data a website makes publicly available does not violate the Computer Fraud and Abuse Act. Separately, scraping in a way that violates a platform's Terms of Service can expose the scraper to civil breach-of-contract claims from the platform — a contractual risk, not a criminal one. Because follower rows contain personal data (usernames, full names, profile pictures — potentially identifying real individuals), anyone storing or processing this data should consider GDPR, CCPA, or other applicable data-protection obligations for their jurisdiction and use case. Instagram Followers Scraper: Multi-Profile Analysis returns only publicly accessible data. What you do with that data is your responsibility — consult legal counsel for commercial applications involving personal data.

❓ Frequently asked questions

Does Instagram Followers Scraper: Multi-Profile Analysis work without an Instagram account?

You can start a run without one, but the real followers endpoint requires an authenticated sessionid cookie of at least 10 characters. Without it, the Actor falls back to padding results from post commenters (sourceType: "comment_fallback") or returns 0 rows for that profile.

How does it handle Instagram's anti-scraping measures?

The Actor retries on HTTP 429 with exponential backoff, and escalates proxies automatically on 403/429 responses: no proxy by default, then a datacenter proxy, then a sticky residential proxy with up to 3 retries if blocks persist.

Can I run it at scale without getting blocked?

maxData supports up to 100,000 followers per profile, and startUrls accepts any number of profiles in one run. There's no published uptime or success-rate figure for this Actor — actual throughput depends on Instagram's response to your session and proxy configuration at the time of the run.

How fresh is the data it returns?

Every row is fetched live from Instagram during the run and stamped with a scrapedAt ISO-8601 UTC timestamp — nothing is served from a cache.

Which fields work best for AI training and RAG indexing?

For RAG, index username, full_name, and the overlap-summary's sharedWithProfiles/overlapCount fields — they answer audience-relationship questions directly. For training data, use the follower row's full field set: it's structurally identical across every profile and platform, with every value returned as a typed primitive (string, boolean, or integer) requiring no normalization.

What does sourceType mean?

follower means the row came from Instagram's authenticated followers endpoint. comment_fallback means the Actor padded the list using commenters on the target's own posts, which happens only when the followers endpoint is unavailable or returns fewer results than requested — filter on this field if you need confirmed followers only.

Does using follower personal data carry data-protection obligations?

Follower rows include usernames, full names, and profile pictures, which can constitute personal data under regulations like GDPR and CCPA. The Actor returns only publicly available Instagram data; the lawful basis for storing, processing, and using that data rests with you as the data controller for your specific use case and jurisdiction.

Does it work with Claude, ChatGPT, and other AI agent tools?

There's no MCP server for this Actor. It's callable as a standard HTTP/Apify API endpoint by any agent framework — every response is typed JSON, including the overlap-analysis fields, ready to drop into an LLM context window without parsing.

Where do I find the overlap-summary and overlap-matrix results?

In two named per-run datasets, overlap-summary-<runId> and overlap-matrix-<runId>, whose exact names are also written to the run's key-value store under OVERLAP_ANALYSIS_INFO alongside the list of profiles analyzed and the row count.

ℹ️ Disclaimer

Instagram Followers Scraper: Multi-Profile Analysis extracts only publicly available data from Instagram. This tool is intended for lawful use cases only. Users are responsible for complying with Instagram's terms of service and applicable data protection laws in their jurisdiction.