Instagram Followers With Mutual Connections Profile

Instagram Scraper — Followers, Following & Mutual Connections

Instagram Followers With Mutual Connections Profile extracts follower and following lists from any public Instagram profile, then layers on two connection-analysis features most scrapers skip entirely: Instagram's own related/suggested-profile graph, and locally-computed mutual "follows-back" connections plus shared-follower overlap across multiple profiles. Every row returns as typed JSON — no HTML parsing, no regex, no brittle selectors. Feed it one username or a list of profile URLs, pick followers or following mode, and it paginates, deduplicates, and tags every account it finds. This guide documents every input, every output field, and how teams actually deploy it.

🧭 What Does Instagram Followers With Mutual Connections Profile Do?

This actor scrapes the followers or following list of one or more public Instagram profiles, using Instagram's own internal web API rather than the official Graph API (which does not expose this data for arbitrary third-party profiles). It returns four kinds of rows in one dataset: base follower/following records, related profile records (Instagram's own "suggested accounts" graph), mutual connection records (accounts that follow back, diffed against a prior opposite-mode run), and shared-follower overlap records (accounts following 2+ of your input profiles in the same run). No Instagram login is strictly required — the sessionId input is optional but recommended, since running without one lowers success rates per the actor's own input description.

Key capabilities:

• Scrape followers or following for any public profile, given a URL or a bare username
• Process multiple seed profiles in a single run, including for overlap analysis
• Cap collection per profile with maxData (0 = unlimited, up to 100,000)
• Discover Instagram's own related/suggested profiles per seed with one extra request per profile
• Compute a cross-run mutual/follows-back diff using a persistent named key-value store
• Compute same-run shared-follower overlap across 2+ profiles with zero extra HTTP requests
• Automatic proxy escalation (direct → datacenter → residential) when Instagram blocks a request
• Supplement followers mode with accounts harvested from a profile's own posts and comments

⚡ Features & Capabilities

Instagram Followers With Mutual Connections Profile groups its capabilities into base scraping, network-discovery, and connection-analysis layers — all in one actor run.

Core features

• Followers or following extraction — set scrapeMode to "followers" or "following"; every row carries a type field (follower or following) matching the mode
• URL or bare-username input — startUrls accepts full profile URLs (https://www.instagram.com/cristiano/) or plain usernames (cristiano) in the same list
• Full identity fields per account — username, full_name, profile_pic_url, is_verified, is_private, is_favorite, has_anonymous_profile_picture, account_badges, plus internal identifiers pk, pk_id, id, fbid_v2, strong_id__, profile_pic_id
• Related/suggested-profile expansion — fetchRelatedProfiles=true pulls Instagram's edge_related_profiles/edge_chaining graph for each seed profile, tagged type="related"
• Mutual connections (follows-back) — computeMutualConnections persists each run's collected set to a named key-value store (ig-mutual-connections-state); once both followers and following have been scraped for the same profile across separate runs, the intersection is emitted as type="mutualConnection" rows with mutualFollow=true
• Shared-follower overlap — when 2+ profiles are scraped in the same run, accounts appearing in 2+ result sets are emitted as type="sharedFollowerOverlap" rows with sharedWithProfiles and sharedFollowerCount
• Comment-sourced follower fallback — in followers mode, if the direct followers-list surface returns a limited set, the actor also harvests followers from the profile's own posts/comments, tagging those rows isSourcedFromComments=true
• Automatic proxy fallback — no proxy → Apify datacenter proxy → Apify residential proxy (sticky, 3 retries), triggered on 401/403/429 or challenge-page detection

Instagram Followers With Mutual Connections Profile within the Scrapio data stack

This actor covers follower/following list extraction with network analysis layered on top. For a fast follower/following count only (no full list), use Instagram Followers Count: Multiple Accounts Follower Counts. For daily unfollower tracking on the following side, use Instagram Following Scraper With Daily Unfollowers Report. For bio, email, and phone-number enrichment on a profile once you have a username, use Instagram Profile Scraper With Bio Link & Email Extraction or Instagram Phone Number Scraper & Email Lead Finder.

Why do developers and data teams scrape Instagram?

Instagram's follower and following graph is one of the few public, structured signals of real social relationships at scale. The audiences below cover the workflows this specific actor's network-analysis features were built for.

🏢 Audience overlap analysis, influencer network mapping & lead research

Marketing and partnerships teams use startUrls with 2+ competitor or influencer profiles in one run to trigger shared-follower overlap — accounts appearing in sharedWithProfiles across multiple profiles reveal genuine audience overlap between brands or creators, scored by sharedFollowerCount. Combined with fetchRelatedProfiles, teams also pull Instagram's own suggested-account graph per seed to expand a candidate list of adjacent creators or accounts for outreach, without manually browsing Instagram's UI. The mutualFollow field, populated once both followers and following have been scraped for a profile, flags accounts that follow back — useful for prioritizing warm outreach over cold accounts.

📊 AI training data and RAG indexing

The username, full_name, account_badges, and is_verified fields give RAG pipelines structured identity signals for entity resolution and deduplication when building a knowledge base of social accounts, while mutualFollow, sharedFollowerCount, and sharedWithProfiles provide relationship-graph edges that plain profile scrapers don't produce. For training data, the consistent 18-field base user record across every follower/following row (same keys, same types, run after run) means no per-record schema drift to normalize before loading into a vector store or fine-tuning set. Every field returns as a typed primitive — strings, booleans, or arrays — not raw HTML.

📱 Competitive and market intelligence

Track a competitor account's followed_by relationships and is_verified/account_badges composition over successive scheduled runs to see how its audience is shifting, or run computeMutualConnections shared-overlap analysis across a competitor set to identify which brand actually shares the most audience with a target account — the metric to watch is sharedFollowerCount, not raw follower totals.

🔬 Research and academic use

Social network researchers use the mutualConnection and sharedFollowerOverlap row types as ready-made graph edges for network analysis (e.g., community detection, homophily studies) without writing their own graph-diff code. This actor only returns data from public profiles; private-account followers/following are not accessible without that account's own authenticated session.

🎥 Product and SaaS development

Growth and influencer-marketing SaaS products build on this actor's output to power creator-discovery tools (using related rows), follow-back/CRM enrichment features (using mutualFollow), or audience-overlap dashboards for ad-buying decisions (using sharedFollowerCount and sharedWithProfiles) without maintaining their own Instagram scraping and anti-block infrastructure.

🍚 Input Parameters

The actor accepts 9 input parameters, 2 of them required (startUrls, scrapeMode), read directly from .actor/input_schema.json.

Parameter	Required	Type	Description	Example Value
startUrls	Yes	array	List of Instagram profile URLs or usernames to scrape. Add 2+ profiles in one run to also unlock shared-follower overlap analysis.	["https://www.instagram.com/cristiano/", "nike"]
scrapeMode	Yes	string	Choose what to scrape: "followers" or "following". Default "followers".	"followers"
maxData	No	integer	Maximum items to collect per profile. Range 0–100,000. 0 = unlimited (collect until pagination ends). Default 100.	100
pageSize	No	integer	Users requested per pagination page from Instagram's internal API. Lower = gentler on rate limits, higher = fewer requests. Range 5–50. Default 12 (Instagram's own web client default).	12
fetchRelatedProfiles	No	boolean	For each seed profile (not per follower), fetch Instagram's own suggested-accounts graph — exactly 1 extra request per seed profile. Emits type="related" rows. Default false.	true
relatedProfilesLimit	No	integer	Cap on related/suggested profiles kept per seed profile. 0 = keep all returned (Instagram typically returns ~10–80). Range 0–100. Default 10.	10
computeMutualConnections	No	boolean	Pure local set-intersection, zero extra HTTP requests. Computes cross-run mutual/follows-back diff and same-run shared-follower overlap. Default true.	true
sessionId	No	string	Instagram sessionid cookie value. Optional but strongly recommended — without it, success rates are lower.	"58012345678%3AabCDefGhIJklmn%3A..."
proxyConfiguration	No	object	Proxy settings. Smart fallback: no proxy (default) → datacenter proxy → residential proxy (automatic on block, 3 retries).	{"useApifyProxy": false}

Complete input example:

{
  "startUrls": [
    "https://www.instagram.com/cristiano/",
    "https://www.instagram.com/nike/"
  ],
  "scrapeMode": "followers",
  "maxData": 500,
  "pageSize": 12,
  "fetchRelatedProfiles": true,
  "relatedProfilesLimit": 10,
  "computeMutualConnections": true,
  "sessionId": "",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}

Supported URL types and input formats

startUrls accepts, in the same list, any mix of:

• Full profile URLs: https://www.instagram.com/cristiano/
• Full profile URLs without trailing slash: https://www.instagram.com/nike
• Bare usernames: cristiano or nike
• @-prefixed handles: @cristiano (the leading @ is stripped automatically)

Each entry is normalized by extracting the path segment or the string itself, stripped of @ and trailing slashes, before being used as the Instagram username for scraping. Invalid or empty entries are silently skipped; if none of the provided entries resolve to a usable username, the run fails with a validation error.

📦 Output Format

Output is typed, normalized JSON pushed to the Actor's default dataset as each row is collected — not batched at the end. Every row carries a type discriminator (follower, following, related, mutualConnection, or sharedFollowerOverlap) so downstream code can filter one dataset into four logical outputs without separate runs. Data can be exported from the dataset in any format Apify supports for datasets (JSON, CSV, Excel, etc.) or read directly via the Apify API/SDK.

Output for follower / following rows

The base row type, emitted once per unique account found in the followers or following list. 23 fields:

{
  "type": "follower",
  "isChild": false,
  "isSourcedFromComments": false,
  "pk": "173560420",
  "pk_id": "173560420",
  "id": "173560420",
  "username": "leomessifanpage",
  "full_name": "Leo Messi Fan Page",
  "profile_pic_url": "https://scontent.cdninstagram.com/v/t51.2885-19/44884218_345707096001271_2446069589734326272_n.jpg",
  "is_verified": false,
  "is_private": false,
  "is_favorite": false,
  "has_anonymous_profile_picture": false,
  "account_badges": [],
  "fbid_v2": "17865432198765432",
  "third_party_downloads_enabled": 0,
  "strong_id__": "173560420",
  "profile_pic_id": "3234567890123456789",
  "latest_reel_media": 0,
  "followed_by": "cristiano",
  "profileUrl": "https://www.instagram.com/leomessifanpage/",
  "success": true,
  "scrapedAt": "2026-07-25T09:14:02Z"
}

isSourcedFromComments is true only for followers-mode rows harvested via the posts/comments fallback rather than the direct followers-list API. followed_by holds the seed username this row was collected against.

Output for related, mutual connection & shared-overlap rows

These three row types share a common base shape (the same 18 base user fields, populated where the source data provides them and left null otherwise) but differ in which relationship fields are populated.

type="related" — from Instagram's own suggested-accounts graph, one seed profile shown:

{
  "type": "related",
  "isChild": true,
  "isSourcedFromComments": false,
  "pk": "9988776655",
  "pk_id": "9988776655",
  "id": "9988776655",
  "username": "ronaldinho",
  "full_name": "Ronaldinho Gaúcho",
  "profile_pic_url": "https://scontent.cdninstagram.com/v/t51.2885-19/related_sample.jpg",
  "is_verified": true,
  "is_private": false,
  "followed_by": "cristiano",
  "sourceProfile": "cristiano",
  "profileUrl": "https://www.instagram.com/ronaldinho/",
  "success": true,
  "scrapedAt": "2026-07-25T09:15:41Z"
}

type="mutualConnection" — emitted once the opposite scrapeMode was already scraped for the same profile in a prior run:

{
  "type": "mutualConnection",
  "isChild": true,
  "isSourcedFromComments": false,
  "pk": "173560420",
  "pk_id": "173560420",
  "id": "173560420",
  "username": "leomessifanpage",
  "full_name": "Leo Messi Fan Page",
  "profile_pic_url": "https://scontent.cdninstagram.com/v/t51.2885-19/44884218_345707096001271_2446069589734326272_n.jpg",
  "is_verified": false,
  "is_private": false,
  "followed_by": "cristiano",
  "sourceProfile": "cristiano",
  "mutualFollow": true,
  "profileUrl": "https://www.instagram.com/leomessifanpage/",
  "success": true,
  "scrapedAt": "2026-07-25T09:16:03Z"
}

type="sharedFollowerOverlap" — emitted when an account appears in 2+ input profiles' result sets in the same run:

{
  "type": "sharedFollowerOverlap",
  "isChild": true,
  "isSourcedFromComments": false,
  "pk": "554433221",
  "pk_id": "554433221",
  "id": "554433221",
  "username": "sportsfan2024",
  "full_name": "Sports Fan",
  "profile_pic_url": "https://scontent.cdninstagram.com/v/t51.2885-19/overlap_sample.jpg",
  "is_verified": false,
  "is_private": false,
  "sharedWithProfiles": ["cristiano", "nike"],
  "sharedFollowerCount": 2,
  "profileUrl": "https://www.instagram.com/sportsfan2024/",
  "success": true,
  "scrapedAt": "2026-07-25T09:16:55Z"
}

Schema stability and export options

All four row types share one 27-column dataset schema (type, isChild, isSourcedFromComments, pk, pk_id, id, username, full_name, profile_pic_url, is_verified, is_private, is_favorite, has_anonymous_profile_picture, account_badges, fbid_v2, third_party_downloads_enabled, strong_id__, profile_pic_id, latest_reel_media, followed_by, profileUrl, sourceProfile, sharedWithProfiles, sharedFollowerCount, mutualFollow, success, scrapedAt); each row only carries the keys relevant to its type, so relationship-analysis columns (sourceProfile, mutualFollow, sharedWithProfiles, sharedFollowerCount) render blank on plain follower/following rows rather than as literal nulls. Field names are pulled directly from Instagram's response payload and this actor's own derived fields, so they stay stable across a front-end redesign on Instagram's side — a breaking change would only occur if Instagram itself changed its internal API response shape. The dataset can be exported to JSON, CSV, Excel, or XML directly from the Apify Console, or pulled programmatically via the Apify API/SDK — there is no separate webhook-delivery feature built into this actor.

💡 Instagram Followers With Mutual Connections Profile Strategy Guide

🎯 Strategy 1: Real-time enrichment pipeline

Trigger a run per incoming record — e.g., a new lead, signup, or support ticket that includes an Instagram handle. Call the actor with startUrls=[handle], scrapeMode="followers", maxData set low (e.g. 50) for speed, and fetchRelatedProfiles=true if you also want adjacent-account suggestions. Read back username, full_name, is_verified, account_badges, and the related-type rows from the returned dataset, then write them to your CRM or lead-scoring table as enrichment fields the moment the run completes. Because rows are pushed live as they're collected rather than batched at the end, a downstream worker can start reading partial results before the run finishes. This turns a raw handle into a scored, network-aware lead record without a human ever opening Instagram.

🎯 Strategy 2: Scheduled monitoring and alerting

Schedule alternating runs on the same profile — scrapeMode="followers" one day, scrapeMode="following" the next — using Apify's built-in Scheduler rather than a custom cron worker. Because computeMutualConnections persists each run's collected set to a named, cross-run key-value store (ig-mutual-connections-state), the second run automatically emits type="mutualConnection" rows the moment both sides exist for that profile — no separate diff script required. Alert on new mutualFollow=true accounts (a fresh follow-back), or diff two same-mode runs on username to detect unfollows. The same pattern scales to a watch-list of competitor or partner accounts by looping the schedule over multiple startUrls entries.

🎯 Strategy 3: Bulk dataset build

Pass a large startUrls list (2+ profiles) in a single run with computeMutualConnections=true to get sharedFollowerOverlap rows for free — zero extra HTTP requests, computed locally after collection finishes. Aggregate the resulting dataset to CSV or load it into a database for audience-overlap or social-network research. Raise maxData toward its 100,000 ceiling for a fuller per-profile crawl, and tune pageSize (5–50) if you need to trade fewer requests against gentler rate-limit pressure. maxData and pageSize are the only documented per-profile collection limits; no run-level concurrency limit is published for this actor, so parallelism across profiles is bounded by your own orchestration, not by a stated actor constraint.

Strategy comparison at a glance

Strategy	Best for	Run pattern	Output format
Real-time enrichment	Per-lead, on-demand enrichment	Single profile, on-demand run	JSON via dataset/API
Scheduled monitoring	Follows-back and unfollow tracking	Recurring scheduled runs, alternating scrapeMode	mutualConnection diff rows
Bulk dataset build	Audience-overlap or network research	Multi-profile, single run	sharedFollowerOverlap rows + CSV export

🌴 Related Instagram Scrapers & Tools

Other Scrapio Instagram scrapers, cross-platform alternatives, and complementary tools for adjacent workflows:

Scraper Name	What it extracts
Instagram Followers Count: Multiple Accounts Follower Counts	Follower/following counts, no full list
Instagram Followers Scraper: Multi-Profile Analysis	Follower lists across multiple profiles
Instagram Following Scraper With Daily Unfollowers Report	Following lists plus daily unfollowers report
Instagram Related Person By Niche Content Creator Search	Creator discovery by niche, not by seed profile
Instagram Profile Scraper With Bio Link & Email Extraction	Bio, link, and email enrichment
LinkedIn Profile Scraper By Similar Profile Finder	Cross-platform similar-profile discovery
YouTube Channel Finder With Subscriber Counts	Cross-platform channel/subscriber data
Instagram Comments Scraper With Engagement Analytics	Post comments with engagement metrics

How to integrate Instagram Followers With Mutual Connections Profile with your stack

Instagram Followers With Mutual Connections Profile works with any language or tool that can make an HTTP request, via the Apify API or the official Apify SDKs.

Python

import csv
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

profiles = ["cristiano", "nike", "leomessi"]
all_rows = []

for profile in profiles:
    run_input = {
        "startUrls": [profile],
        "scrapeMode": "followers",
        "maxData": 200,
        "fetchRelatedProfiles": False,
        "computeMutualConnections": True,
    }
    run = client.actor("your-username/instagram-followers-with-mutual-connections-profile").call(run_input=run_input)
    items = list(client.dataset(run["defaultDatasetId"]).iterate_items())
    all_rows.extend(items)

fieldnames = ["type", "username", "full_name", "is_verified", "is_private",
              "followed_by", "sharedFollowerCount", "mutualFollow", "scrapedAt"]

with open("instagram_followers.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=fieldnames, extrasaction="ignore")
    writer.writeheader()
    writer.writerows(all_rows)

print(f"Saved {len(all_rows)} rows across {len(profiles)} profiles.")

Node.js

import { ApifyClient } from 'apify-client';

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

const input = {
    startUrls: ['https://www.instagram.com/cristiano/', 'https://www.instagram.com/nike/'],
    scrapeMode: 'followers',
    maxData: 300,
    computeMutualConnections: true,
};

const run = await client.actor('your-username/instagram-followers-with-mutual-connections-profile').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();

for (const row of items) {
    if (row.type === 'sharedFollowerOverlap') {
        console.log(`${row.username} shared with: ${row.sharedWithProfiles.join(', ')}`);
    }
}

Async and scheduled pipelines

For large startUrls lists or high maxData values, start the run asynchronously (don't block on .call()), poll the run status via the Apify API, and read the dataset once it finishes. For recurring monitoring, use Apify's built-in Scheduler to fire runs on a cron-like schedule rather than polling from your own infrastructure — this actor has no separate webhook-delivery feature, so scheduled or polled runs are the supported fire-and-forget pattern.

🎯 Who Needs Instagram Followers With Mutual Connections Profile? (Use Cases & Industries)

🏢 Growth marketers and influencer/partnership teams

A partnership team scrapes 3 competitor or creator profiles in one run and reads the sharedFollowerOverlap rows to find which creator's audience overlaps most with their own brand's follower base (highest sharedFollowerCount), then uses fetchRelatedProfiles output to build an outreach shortlist of adjacent creators Instagram itself already considers similar.

📊 AI/data teams building enrichment and RAG pipelines

A data team runs this actor over a list of handles pulled from a CRM, appends username, full_name, is_verified, and account_badges as typed fields to each lead record, and indexes them into a RAG store for an internal "who is this account" agent tool — no HTML cleanup step required before embedding.

📱 Competitive intelligence analysts

An analyst schedules alternating followers/following runs on a competitor's account weekly, tracking how mutualFollow accounts and follower composition (is_verified, account_badges) shift over time to spot changes in audience quality or influencer partnerships.

🔬 Researchers

Academic and market researchers use mutualConnection and sharedFollowerOverlap rows as pre-computed graph edges for social-network studies on public Instagram data, without building their own follower-graph diffing pipeline.

🎥 Product and SaaS builders

Influencer-marketing and audience-analytics platforms run this actor behind their own UI to power creator-discovery and overlap-scoring features, using related, mutualFollow, and sharedFollowerCount as the underlying data layer instead of building Instagram scraping infrastructure in-house.

Is it legal to scrape Instagram?

Scraping publicly accessible data from Instagram is generally lawful in the United States: in hiQ Labs, Inc. v. LinkedIn Corp. (9th Cir. 2019), the court held that scraping data a website makes publicly available, without logging in, does not violate the Computer Fraud and Abuse Act. That precedent concerns public-data access, not Instagram's own Terms of Service — scraping while logged in, or in a way that breaches Instagram's Terms, is a separate civil-contract risk rather than a criminal one, and Instagram can still suspend accounts or take other enforcement action independent of the CFAA question. Because this actor returns personal data — usernames, full names, profile pictures, and follower/following relationships of real people — GDPR, CCPA, and similar data-protection laws govern how you may store, process, and use the collected data, particularly for EU or California residents; lawful basis for that processing is the responsibility of whoever runs the scrape, not the tool. Instagram Followers With Mutual Connections Profile 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 With Mutual Connections Profile work without an Instagram account?

Yes — the sessionId input is optional. Without it, the actor scrapes as an anonymous visitor, but per the input schema's own description, success rates are lower; providing a valid sessionid cookie value is recommended for more reliable runs.

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

It escalates through three request modes on a block (401/403/429, or a detected challenge/login page): direct request first, then Apify datacenter proxy, then Apify residential proxy with up to 3 retries and sticky routing for the rest of that profile's requests. It also rotates user-agent strings and adds small randomized delays between paginated requests.

Can I run it at scale without getting blocked?

The actor's proxy-escalation logic and comment-sourced fallback are designed to keep collecting even when Instagram's direct followers/following API pushes back, but no uptime or success-rate figure is published for this actor — results depend on Instagram's own rate-limiting behavior at the time of the run, which is outside this tool's control.

How fresh is the data it returns?

Fully live — every run makes real-time requests to Instagram's own API and returns whatever Instagram serves at that moment. Nothing is cached or replayed from a prior run, except the mutual-connections snapshot store, which intentionally persists a profile's prior-run result set solely to compute the follows-back diff.

Which fields work best for AI training and RAG indexing?

For RAG, index username, full_name, and account_badges as the high-information identity fields for an account. For training data, is_verified, is_private, mutualFollow, and sharedFollowerCount are the most consistently structured fields across every record, since they are booleans or integers rather than free text. All fields return as typed primitives — strings, booleans, integers, or arrays — requiring no normalization before use in an LLM context window.

Is follower and following data personal data, and who is responsible for handling it?

Yes — usernames, full names, profile pictures, and follow relationships are personal data under GDPR and similar frameworks. This actor returns only publicly available Instagram data; the lawful basis for storing, processing, or using that data rests with whoever runs the scrape, not with the tool itself.

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

It is callable as a standard Apify Actor run via the Apify API or SDK from any agent framework capable of making an HTTP request or invoking a tool — every response is typed JSON, so no HTML parsing step is needed before passing results into an LLM's context window.

What happens if a profile is private?

Only public profiles can be scraped without that account's own authenticated session. A private profile's followers/following list is not accessible through this actor, consistent with Instagram's own access rules for anonymous or third-party viewers.

Why does followers mode sometimes return fewer accounts than the requested limit?

Instagram's own followers-list API endpoint currently caps the directly-listable set at roughly 45–50 accounts per profile for cookie-authenticated web requests, regardless of the account's real follower total or the maxData/pageSize values supplied — a platform-side limitation, not a bug in this actor's pagination logic. To collect more, the actor supplements this with its posts/comments-harvesting fallback (tagged isSourcedFromComments=true); the following direction is not subject to this same cap and paginates normally up to the requested maxData.

ℹ️ Disclaimer

Instagram Followers With Mutual Connections Profile 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.