Instagram Following Scraper — Common Connections & Enrichment

Instagram Shared Following Scraper — Common Connections & Enrichment

Instagram Shared-Following / Common-Connections Mapper takes two or more public Instagram accounts and computes the accounts they actually have in common — a deterministic set-intersection over real scraped follow edges, ranked by overlap_count, not an estimate or a sample. Unlike a plain followers/following exporter that hands back one flat list per account, this actor cross-references every input's follow graph itself and returns one row per unique shared account, each carrying which of your inputs follow it and how many. Every response is typed JSON — ready for a spreadsheet, a graph tool, an outreach list, or an LLM context window without any HTML parsing. This guide covers every input and output field, how the overlap engine and optional profile enrichment work under the hood, and three concrete ways teams put shared-following data to use.

🧭 What Does Instagram Shared Following Scraper Do?

Instagram Shared Following Scraper reads the public following (or followers) list of every account you give it, then intersects those lists to surface the accounts shared by two or more of your inputs — the actual "common connections," not just a merged dump. No Instagram account is required to start a run, but the source code checks for the sessionId cookie on every fetch and logs a warning when it is missing, because unauthenticated requests are scraped far less reliably.

Key capabilities:

• 🔗 Multi-account intersection — feed 2+ profiles in urls; the actor computes the exact accounts followed (or followed-by) 2 or more of them
• 🔢 Overlap ranking — every shared account carries overlap_count and the literal followed_by_inputs list, sorted highest overlap first
• 🔀 Following or followers mode — scrapeMode switches between "who do my inputs follow" (common connections) and "who follows my inputs" (shared audience)
• 🧮 Cross-input deduplication — one row per unique account (pk), even if it appears in every input's follow list
• 🧩 Optional profile enrichment — bio, follower/following counts, external URL, business contact fields, and regex-parsed bio contacts, fetched once per unique shared account, never per raw follow-list row
• 🤖 Optional AI niche labelling — an LLM assigns a short niche tag to each enriched account based on its real bio text
• 🕸️ Graph edge-list export — the underlying bipartite source → target edges are written out separately for network-analysis tools

⚡ Features & Capabilities

Core features

• Set-intersection overlap engine. aggregate_overlap() merges every input's scraped follow list by Instagram's numeric pk, counts how many distinct inputs follow each account, and keeps only accounts meeting minOverlap — this is the actor's reason for existing, not a bolt-on filter.
• Two scrape modes. scrapeMode: "following" intersects who your inputs follow; scrapeMode: "followers" intersects who follows your inputs, for shared-audience analysis instead of shared-interest analysis.
• Verified/private filters. onlyVerified keeps only blue-check accounts in the output; excludePrivate drops private accounts from the shared list — both applied after aggregation, on the deduplicated rows.
• Bio contact extraction. When enrichment is on, parse_bio_contacts() regex-parses emails, phone numbers (7–15 digits), and URLs directly out of each account's biography text into bio_emails, bio_phones, and bio_links — independent of the platform's own declared business_email / business_phone_number fields.
• Stable schema. Every row carries all 22 output keys whether or not enrichment ran — unavailable enrichment fields are emitted as null, never omitted or faked, so downstream code never has to branch on which mode produced the row.
• Graph edge-list output. Every kept source input handle → target followed handle edge, plus the target's pk, is written to the run's Key-Value Store (record edges) and to a separate per-run dataset (edges-<runId>) — ready to load straight into Gephi or networkx.

How Instagram Shared Following Scraper compares to other Instagram scrapers

Feature	This actor	scraping_solutions/instagram-scraper-followers-following-no-cookies	louisdeconinck/instagram-following-scraper
Multi-account overlap / intersection	✅ core function	❌ not documented	❌ not documented
Output shape	One row per shared account across inputs	One row per follower/following, per input	One row per following, per input
Profile enrichment (bio, contacts)	✅ optional, on deduped shared list	❌ not documented	❌ not documented
Graph edge-list export	✅ KV store + per-run dataset	❌ not documented	❌ not documented
Login/cookie required	Optional (sessionId), recommended	❌ "No login, no cookies" (as observed on the Apify Store on 2026-07-26)	❌ "No Login Needed" (as observed on the Apify Store on 2026-07-26)
AI niche labelling	✅ optional, multi-provider	❌ not documented	❌ not documented

As observed on the Apify Store on 2026-07-26, neither scraping_solutions/instagram-scraper-followers-following-no-cookies nor louisdeconinck/instagram-following-scraper document computing overlap across multiple input accounts — both return one row per follower/following entry for a single account at a time, leaving any cross-account comparison to be done manually after export. If your use case is "who do these five accounts have in common," the output-shape row above is the decision-maker: joining and de-duplicating five raw export files yourself is a reliability failure mode this actor removes by doing the set-math server-side.

When another tool might suit you better

If you need the complete, unfiltered follower or following list of a single account — every row, not just the accounts shared with other inputs — a plain followers/following exporter such as scraping_solutions/instagram-scraper-followers-following-no-cookies (which, as observed on the Apify Store on 2026-07-26, documents continuation tokens for exports beyond one run) is a more direct fit. This actor's maxItems caps how many follow-edges are fetched per input, and its dataset only surfaces the accounts that clear your minOverlap threshold — a single-input, full-export use case gets no benefit from the intersection engine.

Instagram Shared Following Scraper within the Scrapio data stack

Instagram Shared Following Scraper covers shared/overlapping following and follower accounts across multiple inputs. For a single account's full follower list with lead-style enrichment, use Instagram Followers Lead Scraper. For that account's related-accounts network (Instagram's own "suggested profiles"), use Instagram Related Profiles Network Scraper. For hashtag-level post, like, and comment stats instead of accounts, use Instagram Hashtag Stats Scraper Plus.

Why do developers and data teams scrape Instagram?

🏢 Influencer marketing and partnerships

Marketing teams feed a shortlist of candidate influencers or brand accounts into urls, run in following mode, and read overlap_count / followed_by_inputs to find accounts multiple candidates already follow — a fast way to surface adjacent creators or brand-safe partners genuinely connected to a niche, instead of guessing from follower counts alone. With includeProfileDetails on, business_email and bio_emails land in the same row, so outreach can start straight from the dataset.

📊 AI training data and RAG indexing

The biography field is the highest-information free text this actor returns — a short, first-person description of the account's niche, business, or identity — which makes it a natural fit for RAG enrichment (grounding an agent's answer about an account in its own stated description) and for lightweight classification training data alongside the structural fields (overlap_count, is_verified, category). Every field returns as a typed primitive (string, int, bool, or array), so no parsing or normalization step is needed before it enters a prompt or a training row.

📱 Competitive and market intelligence

Point urls at a set of competitor or category-leading accounts and use scrapeMode: "followers" to find who follows all of them — a shared-audience signal that's harder to fake than any single account's raw follower count. Track overlap_count over repeated runs to see whether a competitor's audience overlap with a market is growing.

🔬 Research and academic use

Social-network researchers use the graph edge-list output (edges in the Key-Value Store, or the per-run edges-<runId> dataset) directly as bipartite edges for community-detection or network-centrality analysis in tools like networkx or Gephi, without writing their own crawler. Scope is limited to publicly accessible follow relationships — private accounts' lists are not reachable.

🎥 Product and SaaS development

Teams building an influencer-discovery tool, a lead-enrichment API, or an audience-overlap dashboard can run this actor on a schedule and treat its dataset as the backing data source, since the output schema is stable across runs whether or not enrichment or AI labelling is enabled.

🍚 Input Parameters

All parameters are read from .actor/actor.json. Only urls is required.

Parameter	Required	Type	Description	Example Value
urls	Yes	array (stringList)	Full profile links, @handle, or plain handle — one per line. Add 2 or more to compute overlap.	["https://www.instagram.com/nasa/", "nasaearth"]
scrapeMode	No	string (enum)	following = accounts each input follows (common connections). followers = accounts that follow each input (shared audience). Default "following".	"following"
maxItems	No	integer (min 0)	Caps how many follow-edges to pull per input account. The shared/overlap rows are derived from these and are not capped by this value. 0 = no cap. Default 0.	300
minOverlap	No	integer (min 1)	Only emit accounts followed by at least this many inputs. 1 = every account seen; 2+ = true common connections. Default 1.	2
onlyVerified	No	boolean	Keep only accounts with the blue-verified badge (is_verified). Default false.	false
excludePrivate	No	boolean	Drop private accounts (is_private) from the results. Default false.	false
includeProfileDetails	No	boolean	For each unique shared account, fetch biography, follower/following counts, external URL, business email/phone, category. Bio contacts are regex-parsed from the biography. Adds one request per unique shared account. Default false.	true
aiEnhancement	No	boolean	With enrichment on, an LLM assigns each enriched account a short niche label from its real bio. Requires an API key. Default false.	false
aiModel	No	string (enum)	Provider auto-detected from the name: claude-*=Anthropic, gpt-*/o1/o3=OpenAI, gemini-*=Google, grok-*=xAI, deepseek-*=DeepSeek, sonar*=Perplexity, mistral-*=Mistral. Cheaper mini/flash/haiku/lite models recommended. Default "claude-haiku-4-5". Enum: claude-haiku-4-5, claude-sonnet-5, claude-opus-4-8, gpt-4o-mini, gpt-4o, gpt-4.1-mini, gemini-2.0-flash-lite, gemini-2.0-flash, gemini-2.5-flash, grok-3-mini, deepseek-chat, sonar, mistral-small-latest.	"claude-haiku-4-5"
aiApiKey	No	string (secret)	API key for the selected provider. Falls back to the matching env var if empty (ANTHROPIC_API_KEY / OPENAI_API_KEY / GEMINI_API_KEY / XAI_API_KEY / DEEPSEEK_API_KEY / PERPLEXITY_API_KEY / MISTRAL_API_KEY). Only used when AI niche labelling is on.	—
sessionId	No	string (secret)	The sessionid cookie value from a browser logged into Instagram. Kept private to your run. Can be left empty, but runs may be blocked more often.	—
proxyConfiguration	No	object (proxy editor)	Proxy settings. Default runs direct ({"useApifyProxy": false}), with automatic datacenter → residential Apify Proxy fallback when Instagram blocks the request.	{"useApifyProxy": false}

Example JSON input

{
  "urls": ["https://www.instagram.com/nasa/", "nasaearth", "nasahubble"],
  "scrapeMode": "following",
  "maxItems": 300,
  "minOverlap": 2,
  "onlyVerified": false,
  "excludePrivate": false,
  "includeProfileDetails": true,
  "aiEnhancement": false,
  "aiModel": "claude-haiku-4-5",
  "sessionId": "YOUR_SESSIONID_COOKIE",
  "proxyConfiguration": { "useApifyProxy": false }
}

Supported URL types and input formats

urls accepts three interchangeable formats, normalized by the same parser (_extract_username in src/main.py) before scraping starts:

• Full profile URL — https://www.instagram.com/nasa/ (path is parsed, query/fragment ignored)
• @handle — @nasaearth (leading @ stripped)
• Plain handle — nasahubble (used as-is)

Duplicate handles resolved from urls are removed before scraping. At least one valid handle is required — a run with an empty or entirely unresolvable urls list raises "No valid input in 'urls'" before any request is made.

📦 Output Format

Results are typed, normalized JSON with a stable 22-field schema on every row — enrichment and AI fields are present as null when their toggle is off, never omitted. Export as JSON, CSV, Excel, or XML from the Dataset tab, or read it programmatically via the Apify API or apify_client.

Output for a shared account

This is the actor's default dataset — one row per unique account shared by your inputs, built by aggregate_overlap() in src/aggregate.py and extended with enrichment fields in src/main.py. All 22 keys the actor's row-building code writes:

{
  "type": "shared_account",
  "pk": "25025320",
  "username": "natgeo",
  "full_name": "National Geographic",
  "is_private": false,
  "is_verified": true,
  "profile_pic_url": "https://scontent.cdninstagram.com/v/t51.2885-19/example_profile_pic.jpg",
  "profile_url": "https://www.instagram.com/natgeo/",
  "followed_by_inputs": ["nasa", "nasaearth"],
  "overlap_count": 2,
  "scrapedAt": "2026-07-26T09:14:02Z",
  "biography": "Taking the world in through pictures.",
  "follower_count": 283000000,
  "following_count": 140,
  "external_url": "https://on.natgeo.com/2Sw8ykr",
  "business_email": null,
  "business_phone_number": null,
  "category": "Media/News Company",
  "bio_emails": [],
  "bio_phones": [],
  "bio_links": ["https://on.natgeo.com/2Sw8ykr"],
  "ai_niche": null
}

biography through ai_niche come back null (and bio_emails/bio_phones/bio_links come back []) whenever includeProfileDetails (or aiEnhancement) is off, or when enrichment was attempted but Instagram genuinely didn't return that field — never a guessed value.

Output for a graph edge

Every source-input → target-account edge that survives your filters is written separately — not to the charged dataset — to the Key-Value Store record edges, and to a per-run dataset named edges-<runId> when a run ID is available:

{
  "source": "nasa",
  "target": "natgeo",
  "target_pk": "25025320"
}

Use this list to reconstruct the bipartite "who follows whom" graph in networkx or Gephi — source is the input handle you supplied, target/target_pk identify the shared account each edge points at.

Schema stability and export options

Field names for the shared-account row are fixed by aggregate_overlap() and the ENRICHMENT_KEYS list in src/enrich.py; they do not change based on which inputs you scrape. If Instagram's own front end changes shape, the parsers in src/enrich.py (three separate paths — mobile private API, embedded profile HTML, and the web_profile_info JSON endpoint) update independently of the dataset schema, so a field simply returns null rather than breaking the row shape. Export the default dataset as JSON, CSV, Excel, or XML from the Apify Console Dataset tab, or via apify_client / the REST API; the edge list is available from the Key-Value Store tab (edges record) and, when a run ID exists, from its own per-run dataset.

💡 Instagram Shared Following Scraper Strategy Guide

🎯 Strategy 1: Real-time enrichment pipeline

Trigger a run whenever a new candidate list is ready (webhook, manual start, or an upstream automation), passing the candidate handles as urls with includeProfileDetails: true. Read back overlap_count, business_email, and bio_emails for each row and write them into your CRM or spreadsheet as soon as the run finishes — since enrichment only hits the deduplicated shared list, the extra request cost stays proportional to unique accounts found, not to how many inputs you scraped.

🎯 Strategy 2: Scheduled monitoring and alerting

Set up an Apify Schedule (Console → Schedules → Create new, pointed at this actor) to re-run the same urls and minOverlap weekly. Diff the new run's overlap_count per username against the previous run's dataset — a jump in overlap_count for an account flags a genuinely growing common connection across your tracked accounts, worth alerting on. The actor itself has no built-in webhook or diffing step; pair the Schedule with an Apify webhook on run completion, or poll the dataset from your own automation.

🎯 Strategy 3: Bulk dataset build

For a research or training dataset, run the actor once per group of accounts you want intersected (or with a long urls list and a low minOverlap to capture the full connection graph), aggregate each run's dataset export to CSV or a database, and merge on pk. There is no documented concurrency-limit property on this actor to cite — inputs inside a single run are processed one at a time in src/main.py, so parallelizing multiple independent runs (rather than expecting a single run to fan out internally) is the pattern to use for large batches.

Strategy comparison at a glance

Strategy	Best for	Run pattern	Output format
Real-time enrichment pipeline	Lead/influencer outreach lists	Triggered, single run per candidate list	Dataset rows → CRM/spreadsheet
Scheduled monitoring and alerting	Tracking a common-connection signal over time	Apify Schedule, recurring	Dataset diff between runs
Bulk dataset build	Research, network-graph datasets	Multiple parallel runs, one per account group	CSV/database export + edge list

🌴 Related Instagram Scrapers & Tools

Scraper	What it extracts
Instagram Followers Lead Scraper	A single account's full follower list with lead-style enrichment
Instagram Related Profiles Network Scraper	Instagram's own "related accounts" network for a profile
Instagram Hashtag Stats Scraper Plus	Posts, likes, and comments for a hashtag
Instagram Highlights Scraper Plus	Story highlight metadata for a profile
Twitter Profile & Tweets Scraper	Profile and tweet data on X/Twitter, for cross-platform audience comparison
TikTok Trending Scraper With Trend Insights	Trending-content data on TikTok, for adjacent-platform research
Website Contact & Email Extractor	Business contact details from an account's linked website, complementary to bio_emails/business_email

How to integrate Instagram Shared Following Scraper with your stack

Instagram Shared Following Scraper works with any language or tool that can make an HTTP request.

Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_API_TOKEN>")

run_input = {
    "urls": ["https://www.instagram.com/nasa/", "nasaearth", "nasahubble"],
    "scrapeMode": "following",
    "minOverlap": 2,
    "includeProfileDetails": True,
    "sessionId": "YOUR_SESSIONID_COOKIE",
}

run = client.actor("instagram-shared-following-mapper").call(run_input=run_input)

rows = []
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    rows.append(item)
    print(item["username"], item["overlap_count"], item["followed_by_inputs"])

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

Node.js

import { ApifyClient } from 'apify-client';

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

const runInput = {
    urls: ['https://www.instagram.com/nasa/', 'nasaearth', 'nasahubble'],
    scrapeMode: 'following',
    minOverlap: 2,
    includeProfileDetails: true,
};

const run = await client.actor('instagram-shared-following-mapper').call(runInput);
const { items } = await client.dataset(run.defaultDatasetId).listItems();

for (const row of items) {
    console.log(row.username, row.overlap_count, row.followed_by_inputs);
}

Async and scheduled pipelines

This actor has no webhook or notification mechanism of its own. For fire-and-forget large jobs, start the run via apify_client's call() (which blocks until finished) or start() (which returns immediately) and poll client.run(runId).get() for status, or attach an Apify webhook on run completion to push the dataset URL to your own endpoint. For recurring jobs, an Apify Schedule re-runs the same input on a cadence you set in Console.

🎯 Who Needs Instagram Shared Following Scraper? (Use Cases & Industries)

🏢 Influencer marketing teams

Feed a shortlist of candidate creators into urls, run in following mode with minOverlap: 2, and use the resulting overlap_count / followed_by_inputs rows to find adjacent accounts multiple candidates already follow — a data-backed way to expand a shortlist beyond names sourced by hand.

📊 Competitive and market analysts

Run scrapeMode: "followers" against a set of competitor accounts to surface the audience they share, tracking overlap_count across scheduled runs to see whether that shared audience is growing or shrinking over time.

📱 Growth and outreach teams

With includeProfileDetails on, business_email, bio_emails, and bio_phones land directly on the shared-account rows, turning a common-connections list into a ready-to-contact lead list without a separate enrichment step.

🔬 Researchers

Social-network researchers use the edges Key-Value Store record or per-run edges-<runId> dataset as bipartite graph edges for community-detection and network-centrality analysis in networkx or Gephi, scoped to publicly accessible follow relationships only.

Is it legal to scrape Instagram?

Scraping publicly accessible web pages is generally legal in the United States. hiQ Labs, Inc. v. LinkedIn Corp., 938 F.3d 985 (9th Cir. 2019), held that accessing and scraping data a website makes publicly available, without logging in, does not violate the Computer Fraud and Abuse Act. This actor reads only what a public profile already exposes; it does not access private accounts' follow lists.

Scraping in violation of a platform's Terms of Service can still expose you to civil claims (breach of contract) from the platform, separate from the criminal-statute question hiQ addressed — Instagram's terms restrict automated data collection, and using this actor may be a breach of those terms even where the underlying scraping is not itself unlawful.

The usernames, bios, and business contact fields this actor returns are personal data about identifiable individuals in many cases, so GDPR (if you or the data subjects are in the EU/EEA) and the CCPA/CPRA (for California residents) can apply to how you store, process, and reuse it — independent of whether the initial collection was lawful. Instagram Shared Following Scraper 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 Shared Following Scraper work without an Instagram account?

Partially. No Instagram account or login is required to start a run, but the actor logs a warning when sessionId is empty, and the source code raises an error for a specific input if its very first follow-list page comes back empty with no sessionId set — unauthenticated runs are more likely to fail per input than sessioned ones.

How does Instagram Shared Following Scraper handle Instagram's anti-scraping measures?

Every request escalates through a fixed chain: direct connection first, then Apify Proxy datacenter, then Apify Proxy residential (sticky for the rest of the run, with up to 3 retries and exponential back-off) — triggered whenever a response looks blocked (HTTP 401/403/429, a 3xx redirect, or body text containing checkpoint, challenge, login_required, or please wait). Requests are also spaced with a random 1–2 second delay between per-input scrapes and 0.5–1.2 seconds between enrichment calls.

Can I run Instagram Shared Following Scraper at scale without getting blocked?

There is no documented uptime or block-rate guarantee. maxItems bounds how many follow-edges are fetched per input, and inputs inside one run are processed one at a time (not in parallel), so very large urls lists or high maxItems values increase run time and exposure proportionally; no numeric concurrency limit is declared in the input schema to cite as a ceiling.

How fresh is the data Instagram Shared Following Scraper returns?

Every run performs a live fetch against Instagram's own following/followers and profile endpoints — nothing is cached or replayed from a previous run. scrapedAt on each row records the exact UTC timestamp the run computed its results.

Which fields work best for AI training and RAG indexing?

biography is the highest-information free-text field for RAG grounding or classification training, since it is the account's own self-description. For consistent structural fields across every row, use overlap_count, is_verified, is_private, and category — all return as typed primitives requiring no normalization before entering a prompt or a training row.

Does scraping Instagram involve data protection obligations?

Yes, where the account belongs to an identifiable individual: usernames, biographies, and business contact fields are personal data under GDPR/CCPA in many cases. The actor returns only what is already publicly visible; the lawful basis for storing and reusing that data afterward sits with you as the operator of the run.

Does Instagram Shared Following Scraper work with Claude, ChatGPT, and other AI agent tools?

It does not 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 can invoke to fetch shared-following data as grounded, typed JSON before generating an answer.

How does Instagram Shared Following Scraper compare to other Instagram scrapers?

As observed on the Apify Store on 2026-07-26, scraping_solutions/instagram-scraper-followers-following-no-cookies documents continuation tokens for splitting very large single-account exports across multiple runs — a capability this actor does not have, since it is built around intersecting several accounts rather than paginating one exhaustively. louisdeconinck/instagram-following-scraper's listing advertises speed and per-profile pricing but, as of that date, documents no cross-account overlap computation. Neither competitor's published README documents computing overlap_count or a shared-account intersection across multiple inputs — that computation is this actor's core function, not an add-on.

ℹ️ Disclaimer

Instagram Shared Following Scraper 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.