👥🔗 Instagram Followers ∩ Following — Mutuals & Fans

Instagram Followers & Following Scraper — Mutuals, Fans, Reciprocity

Extract an Instagram profile's followers, following, or both lists in one run, and get back structured JSON rows carrying username, full_name, is_verified, relationship, and — in both mode — computed set-relationship labels (mutual, fan, non_follower_back) plus a run-level reciprocity summary. No HTML parsing on your side, no spreadsheet math. Run it on Apify and pull results as JSON or CSV the moment the run finishes.

What is the Instagram Followers & Following Scraper?

It's an Apify Actor that crawls Instagram's friendships lists for one or more public profiles and, when run in both mode, cross-references the followers list against the following list to compute who's a mutual, a fan (follows the target but isn't followed back), and a non-follower-back (the target follows them, they don't follow back). An Instagram sessionid cookie is effectively required — the friendships and enrichment endpoints Instagram exposes are login-walled, so the Actor needs a session to read them the same way a logged-in browser would. It's built for growth marketers, competitive researchers, and developers who need audience-relationship data as clean JSON rather than a browser export.

What Instagram follower/following data is publicly available to scrape?

A logged-out visitor to an Instagram profile page can see basic identity information and aggregate counts, but the follower and following lists themselves are gated behind an active Instagram login — Instagram's friendships API returns nothing to an unauthenticated request. This Actor does not bypass that gate; it uses the sessionId you supply to read the same lists a logged-in browser session could see.

Data category	Visible without login	Requires an Instagram session (sessionId)
Username, full name, verified badge, avatar	✅ shown on the profile page	—
Aggregate follower / following / post counts	✅ shown on the profile page	—
Individual followers list membership	❌ blocked by Instagram	✅
Individual following list membership	❌ blocked by Instagram	✅
Mutual / fan / non-follower-back labels	❌ n/a — derived, not scraped directly	✅ (computed from the two lists above)
Bio, external URL, business category, counts (enrichProfiles)	Partially shown on profile page	✅ for consistent, structured access
Public email / phone / geo (enrichProfiles)	Only if Instagram renders a "Contact" button	✅ for consistent, structured access
Private-account content	❌ never	❌ never — this Actor does not access private accounts it isn't authorized to see

The Instagram Followers & Following Scraper only returns data reachable through the session you provide — the same lists that session could browse manually — and it never attempts to read a private account it has no access to.

What data can I extract with the Instagram Followers & Following Scraper?

Every row is a strict superset of the underlying Instagram API user object plus the Actor's own relationship, source, and enrichment fields — nothing is renamed or dropped, and enrichment keys are always present (null when not requested or not found).

Identity and profile fields

Field	Description
pk	Instagram's numeric user ID (the canonical dedup key)
pk_id	Same numeric ID (falls back to pk if Instagram omits it)
id	Same numeric ID again (falls back to pk)
username	Instagram handle
full_name	Display name
is_private	Whether the account is private
is_verified	Whether the account carries the verified badge
profile_pic_url	Standard-resolution avatar URL
profileUrl	https://www.instagram.com/<username>/, built by the Actor
account_badges	Instagram badge array (empty list when none)
has_anonymous_profile_picture	Whether the account uses Instagram's default avatar
latest_reel_media	Timestamp of the account's latest story/reel, when present
fbid_v2	Instagram's Facebook-linked ID field, as returned
third_party_downloads_enabled	Raw field as returned by the friendships API
strong_id__	Raw field as returned by the friendships API
profile_pic_id	Raw field as returned by the friendships API
is_favorite	Raw field as returned by the friendships API
followed_by	Raw field as returned by the friendships API (kept for compatibility)
success	Always true on an emitted row (kept for compatibility)

Relationship and run fields

Field	Description
record_type	"user" for a person row, "summary" for the run-level summary row
relationship	follower, following, mutual, fan, or non_follower_back
is_mutual	true/false when derivable, null when the underlying crawl is incomplete
follows_target	Whether this user follows the target profile
followed_by_target	Whether the target profile follows this user back
source_profile	The target username this row was scraped for
enrichment_status	enriched, private, rate_limited, failed, or not_requested
scrapedAt	ISO-8601 UTC timestamp shared by every row in the run

Enrichment fields (only populated when enrichProfiles is on)

Field	Description
biography	Profile bio text
external_url	Link-in-bio URL
follower_count / following_count / media_count	Aggregate counts from the profile
is_business_account / is_professional_account	Account-type flags
category	Business/creator category label
public_email / public_phone_number	Contact button fields, when Instagram exposes them
business_email / business_phone_number	Business contact fields, when present
address_street / city_name / zip / latitude / longitude	Business address fields, when present
profile_pic_url_hd	High-resolution avatar URL
bio_emails / bio_phones / bio_links	Emails, phone-like strings, and URLs regex-extracted from the bio text ([] when enriched but none found, null when enrichment wasn't requested)

🤖 Add-on: need more Instagram data?

Pair this Actor with Instagram Tagged Posts Scraper Plus for the posts an account is tagged in, Instagram Reel Virality Intelligence Scraper for engagement analytics on a specific Reel, or Instagram B2B Lead & Contact Scraper for outreach-ready contact data from a broader account list.

Why not build this yourself?

Instagram has no official API that returns a third-party account's followers or following list — the Instagram Graph API is scoped to a business/creator account's own connected data, not arbitrary public profiles, so there is no comparable public endpoint to benchmark against here. Building this in-house means reverse-engineering the web_profile_info and friendships endpoints, tracking Instagram's rotating web APP_ID, handling cursor pagination via next_max_id, managing sticky vs. rotating residential proxy sessions, retrying soft-blocks with backoff, and then writing and maintaining the set-membership logic for mutuals/fans/non-followers-back yourself — and re-testing all of it every time Instagram changes its response shape. This Actor does that work once, keeps the output schema stable, and lets you run it from a scheduled Apify job instead of a maintained scraper repo.

How to use the Instagram Followers & Following Scraper

1. Open the Actor's page on the Apify Store and click Run, or call it from apify_client.
2. Provide the required input: startUrls (one or more profile URLs or usernames) and scrapeMode (followers, following, or both).
3. Add sessionId — without it, the login-walled friendships endpoints will mostly return blocks. Optionally set maxData, enrichProfiles, pageSize, and proxyConfiguration.
4. Start the run from the Console, a schedule, or the API.
5. Pull results from the dataset as JSON, CSV, Excel, or via the API the moment the run finishes.

How to scale to bulk followers/following extraction

startUrls accepts an array, so one run can process multiple profiles — pass a list of URLs or bare usernames and the Actor works through them one at a time (there's a short randomized pause between profiles to reduce block risk, so profiles are processed sequentially, not in parallel). For very large accounts, leave maxData at 0 for a complete, mathematically exact both-mode crawl, or set it to cap runtime and cost per profile.

What can you do with Instagram followers and following data?

• 📈 A growth marketer auditing reciprocity uses is_mutual and the summary's reciprocity_rate to see what share of the accounts they follow actually follow back.
• 🕵️ A competitive researcher studying a rival's audience uses relationship and (with enrichProfiles) follower_count to gauge the quality of a competitor's follower base rather than just its size.
• 📧 An outreach or lead-gen team uses public_email and bio_emails (from enrichProfiles) to build a contactable list from a creator's or business's follower base.
• 🎯 A social-media manager uses relationship: "fan" rows to find engaged accounts who follow the brand but aren't followed back yet, as a shortlist for community engagement.
• 🤖 An AI engineer building an audience-analysis agent feeds the typed mutual/fan/non_follower_back rows directly into an LLM prompt or a vector store as structured context, with no scraping or HTML parsing logic of their own.

How does the Instagram Followers & Following Scraper handle rate limits and blocking?

Your proxyConfiguration is honored from the very first request — there's no "direct-first" mode that quietly skips your proxy. When you supply a sessionId, the Actor uses one sticky exit IP for the whole run, because rotating IPs under a single login cookie is a strong checkpoint trigger on Instagram; without a session, the exit IP rotates per request. Every request retries up to 4 times with exponential backoff (capped at 8 seconds). On a soft-block — an HTTP 401/403/429, or a response body containing a checkpoint, challenge, or login-required token — the Actor automatically escalates to the Apify RESIDENTIAL proxy group while preserving your configured country, then retries. If a specific profile still fails after retries (private, deleted, rate-limited, or otherwise unresolvable), that profile is logged as failed and the run moves on to the next one in startUrls — no row is emitted for a profile that couldn't be resolved.

⬇️ Input

Parameter	Required	Type	Description	Example Value
startUrls	Yes	array	Instagram profile URLs or bare usernames to analyze. Multiple profiles are processed sequentially.	["https://www.instagram.com/nasa/", "spacex"]
scrapeMode	Yes	string (enum: followers, following, both)	followers = inbound audience only. following = outbound interests only. both = fetch both lists and compute mutuals/fans/non-followers-back. Default "both".	"both"
maxData	No	integer (0–1,000,000)	Cap per list; 0 = unlimited. For exact set math in both mode, leave at 0 — a nonzero cap flags the run completeness: "partial" and downgrades the uncertain labels. Default 0.	0
enrichProfiles	No	boolean	When true, fetches one extra request per user for bio, counts, business flags, category, public email/phone, geo, and HD avatar. Adds cost and ban-risk. Default false.	false
pageSize	No	integer (1–100)	Users fetched per API page. Larger values mean fewer requests. Default 50.	50
sessionId	No (effectively required)	string (secret)	Instagram sessionid cookie value. The friendships and enrichment endpoints are login-walled, so this is required in practice; it also enables the sticky-IP anti-ban path.	"58012345678%3AAbCdEf..."
proxyConfiguration	No	object	Apify Proxy configuration. Honored from the first request. RESIDENTIAL is recommended for Instagram. Default {"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}.	{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}

Example input

{
  "startUrls": ["https://www.instagram.com/nasa/"],
  "scrapeMode": "both",
  "maxData": 0,
  "enrichProfiles": true,
  "pageSize": 50,
  "sessionId": "58012345678%3AAbCdEfGhIjKlMn%3A25%3AAY...",
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}

⬆️ Output

Results land in the default dataset as typed JSON, exportable as JSON, CSV, Excel, or XML from the Apify Console or API. Two dataset views are provided: Users + Relationship (per-user rows) and Run Summary (set analytics) (the run-level record in both mode).

Example output

A per-user row (scrapeMode: "both", enrichProfiles: true):

{
  "pk": "25025320",
  "pk_id": "25025320",
  "id": "25025320",
  "full_name": "NASA Astronauts",
  "is_private": false,
  "fbid_v2": null,
  "third_party_downloads_enabled": null,
  "strong_id__": null,
  "profile_pic_id": null,
  "profile_pic_url": "https://scontent.cdninstagram.com/v/t51.2885-19/...",
  "is_verified": true,
  "username": "nasa_astronauts",
  "has_anonymous_profile_picture": false,
  "account_badges": [],
  "latest_reel_media": 0,
  "is_favorite": false,
  "followed_by": null,
  "success": true,
  "record_type": "user",
  "source_profile": "nasa",
  "profileUrl": "https://www.instagram.com/nasa_astronauts/",
  "relationship": "mutual",
  "is_mutual": true,
  "follows_target": true,
  "followed_by_target": true,
  "enrichment_status": "enriched",
  "biography": "Astronauts of NASA 🚀",
  "external_url": "https://www.nasa.gov/astronauts",
  "follower_count": 412300,
  "following_count": 58,
  "media_count": 640,
  "is_business_account": true,
  "is_professional_account": true,
  "category": "Government Organization",
  "public_email": null,
  "public_phone_number": null,
  "business_email": null,
  "business_phone_number": null,
  "address_street": null,
  "city_name": null,
  "zip": null,
  "latitude": null,
  "longitude": null,
  "profile_pic_url_hd": "https://scontent.cdninstagram.com/v/t51.2885-19/...hd.jpg",
  "bio_emails": [],
  "bio_phones": [],
  "bio_links": ["https://www.nasa.gov/astronauts"],
  "scrapedAt": "2026-07-26T14:02:11.485213+00:00"
}

The run-level summary row emitted once per profile in both mode:

{
  "record_type": "summary",
  "source_profile": "nasa",
  "target_user_id": "528817151",
  "scrapeMode": "both",
  "followers_scraped": 12480321,
  "following_scraped": 312,
  "mutuals_count": 287,
  "fans_count": 12480034,
  "non_followers_back_count": 25,
  "reciprocity_rate": 0.9199,
  "fan_rate": 1.0,
  "completeness": "complete",
  "followers_completeness": "complete",
  "following_completeness": "complete",
  "enrichment_coverage": {
    "enrichment_counts": { "enriched": 12480321, "private": 0, "rate_limited": 0, "failed": 0, "not_requested": 0 },
    "enriched_profiles": 12480321,
    "email_coverage": 0.0021,
    "phone_coverage": 0.0009,
    "biography_coverage": 0.61,
    "geo_coverage": 0.0004
  },
  "scrapedAt": "2026-07-26T14:02:11.485213+00:00"
}

In followers-only or following-only mode, a summary row (rows, completeness, enrichment_coverage, scrapedAt) is only emitted when enrichProfiles is true — a non-enriched single-list run produces user rows only, with no summary record.

How does it work?

For each username in startUrls, the Actor first resolves the profile's numeric Instagram user ID via the web_profile_info endpoint (falling back to parsing the profile page HTML if that call fails), then pages through the friendships/<user_id>/followers and/or following endpoints using Instagram's own max_id cursor until the list is exhausted or maxData is hit. In both mode, the following list is collected first, then the followers list is streamed against it to label mutuals and fans on the fly, and any remaining following entries not seen in followers are labeled non-followers-back. Requests go through your configured Apify Proxy from the first call, with a sticky session when you supply sessionId. Only data reachable through the friendships and profile endpoints is returned — the output schema (field names and types) stays the same run to run regardless of changes to Instagram's own page layout, since the Actor reads Instagram's JSON API rather than parsing rendered HTML for the friendships data itself.

Integrations

The Actor runs on Apify like any other Actor, so it works with anything that can call the Apify API or the apify-client SDK.

Calling the Instagram Followers & Following Scraper programmatically

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
    "startUrls": ["https://www.instagram.com/nasa/"],
    "scrapeMode": "both",
    "sessionId": "<YOUR_INSTAGRAM_SESSIONID>",
}

run = client.actor("instagram-followers-following-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

Works in Go, Ruby, Node.js, cURL — any language that can make an HTTP request to the Apify API.

No-code tools (n8n, Make)

In n8n, use the HTTP Request node (or the Apify community node) pointed at this Actor's run endpoint with your API token, then feed the returned dataset items into downstream nodes. In Make, the Apify app's "Run an Actor" module followed by "Get Dataset Items" gives you the same rows inside a scenario, ready to route into a spreadsheet, CRM, or notification step.

Is it legal to scrape Instagram followers and following data?

Scraping publicly reachable Instagram profile and relationship data is generally lawful, but the usernames, full names, bios, and (with enrichProfiles) email addresses and phone numbers this Actor returns are personal data about identifiable people, so GDPR (if you or the data subjects are in the EU/UK) and CCPA (California residents) can apply to how you store and use it. This Actor returns only data reachable through the Instagram session you provide, and it does not access private accounts. You are responsible for having a lawful basis for collecting and processing that data, complying with Instagram's Terms of Use for how you use your session credentials, and honoring deletion/access requests where applicable. Consult legal counsel if your use case involves bulk storage of personal data.

❓ Frequently asked questions

What Instagram followers/following fields does this Actor return?

It returns Instagram's own identity fields (username, full_name, is_verified, is_private, profile_pic_url) plus the Actor's derived relationship fields (relationship, is_mutual, follows_target, followed_by_target) and, when enrichProfiles is on, bio and contact fields like biography, follower_count, and public_email. See the full field tables above.

Does this Actor require an Instagram account or login?

Yes, in practice. sessionId isn't marked required by the input schema, but the friendships and enrichment endpoints are login-walled by Instagram, so without a valid sessionid cookie value the Actor mostly receives blocked responses instead of data.

How many followers or following can I extract in one run?

maxData accepts any value from 0 (unlimited) up to 1,000,000 per list, per profile. Leaving it at 0 in both mode gives an exact, complete crawl for correct set math; capping it flags the run completeness: "partial" and downgrades the fan/non-follower-back labels to plain follower/following.

What happens if a profile is private or doesn't exist?

Profile-ID resolution fails for that username (no accessible user ID is found), the Actor logs the failure, and it moves on to the next profile in startUrls. No dataset row is written for a profile that couldn't be resolved, so failed profiles don't appear in the output at all — check the run log to see which usernames failed and why.

Can I scrape multiple Instagram profiles at once?

Yes. startUrls accepts an array of profile URLs or usernames, and the Actor processes them one after another within a single run, with a short randomized pause between profiles.

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

It's callable as a standard Apify Actor via the Apify API or the apify-client SDK from any agent framework that can make HTTP requests; there is no dedicated MCP server documented for this Actor.

How does this Actor compare to other Instagram followers/following scrapers?

As observed on the Apify Store on 2026-07-26, scraping_solutions/instagram-scraper-followers-following-no-cookies and coderx/instagram-followers-following-scraper-no-cookies-login scrape followers or following separately and support continuation tokens or cursors to resume a list across multiple runs, while figue/instagram-followers-and-following-scrapper requires pasted browser cookies and claims roughly 1,000 users per minute on its own listing. None of the three document computing mutuals, fans, or non-followers-back — this Actor's both mode fetches both lists in one run and derives those set-relationship labels and a reciprocity summary directly, with completeness-aware downgrading when a crawl is truncated.

Does this Actor return data in a format LLMs can use directly?

Yes. Every row is typed, normalized JSON with consistent field names across runs — no HTML parsing or CSS selectors required. Pass it directly to an LLM prompt, index it into a vector store, or feed it to an agent tool as structured context.

What happens when Instagram changes its layout or anti-bot system?

The Actor reads Instagram's own JSON API endpoints rather than parsing rendered page HTML for the friendships data, and its output schema is maintained to stay stable across runs. No specific update turnaround time is published.

Can I use this Actor without managing proxies or browser infrastructure myself?

Yes. Apify Proxy (RESIDENTIAL by default), sticky-vs-rotating session handling, retry backoff, and soft-block escalation are all handled by the Actor — you only need to supply a proxy configuration and, in practice, a sessionId.

Which fields work best for RAG indexing or audience-analysis training data?

For RAG or LLM context, index biography, full_name, and username as the high-information text fields, paired with the structured relationship label. For training or analytics data, is_mutual, follows_target, followed_by_target, follower_count, and enrichment_status return as consistent typed primitives (booleans, integers, or fixed enum strings) across every row.

Related scrapers

Scraper	What it extracts
📸 Instagram Tagged Posts Scraper Plus	Posts an Instagram account is tagged in, with comments, media, and metadata
🎬 Instagram Reel Virality Intelligence Scraper	Engagement analytics and media archive for a single Instagram Reel
📸 Instagram B2B Lead & Contact Scraper	Outreach-ready contact data from Instagram accounts
🔎 LinkedIn Lead & Contact Finder	Lead and contact data from LinkedIn profiles, for the same lead-gen workflow on a different platform

💬 Your feedback

Found a bug or missing a field? Let us know through the Actor's issue tracker on its Apify Store page, or leave a review — it helps us prioritize fixes and confirms the Actor is actively maintained.