Instagram Following Scraper

Instagram Following Scraper — Full Account IDs, Not Just Usernames

Instagram Following Scraper extracts the full following list of any Instagram profile your logged-in session can view — every account it follows, as clean, structured JSON. Enter one profile or dozens in one run, and each row carries Instagram's raw numeric identifiers (pk, id, fbid_v2) alongside the username and verification flags thinner following scrapers stop at. Every response is ready to pass to an LLM, load into a spreadsheet, or feed a monitoring pipeline — and rows save to your dataset as they're collected, not at the run's end.

What is Instagram Following Scraper?

Instagram Following Scraper is a query-driven Actor that takes one or more Instagram profiles and returns everyone that profile follows, paginated through Instagram's internal friendship API rather than a browser. A logged-in sessionId cookie is required — Instagram's following list is login-gated, and without a valid session the endpoint returns a login wall and no data. Where most following scrapers stop at username and profile picture, this one preserves the full raw identifier set Instagram's API actually returns, so results can be de-duplicated and cross-referenced reliably even if a username later changes.

• Scrapes the Following list of any profile (public, or private if your session can view it)
• Accepts full profile URLs, plain @handle, or bare handle — mixed freely in one list
• Runs multiple profiles in one job, tagging every row with the seed profile it came from
• Caps results per profile with maxItems, or set 0 to collect the entire list
• Filters the list as it is collected — skipPrivateAccounts and onlyVerifiedAccounts apply before the cap, so asking for 50 verified accounts returns 50 verified accounts
• Optionally enriches every row with the account's real follower/following/post counts, bio, website and category (enrichProfileDetails)
• Streams rows to the dataset in real time instead of waiting for the run to finish
• Stops cleanly at a configurable wall-clock budget (maxRunTimeSecs) instead of running into the platform timeout
• Escalates proxies automatically (direct → datacenter → residential) when Instagram pushes back

What data can you get with Instagram Following Scraper?

Every run returns one result type — the accounts a seed profile follows — but each row carries far more than a name and a picture.

Result Type	Extracted Fields	Primary Use Case
Followed account	username, full_name, is_verified, is_private, pk, pk_id, id, strong_id__, fbid_v2, profile_pic_id, profile_pic_url, has_anonymous_profile_picture, account_badges, latest_reel_media, is_favorite, third_party_downloads_enabled, sourceProfile, profileUrl, scrapedAt (plus followersCount, followingCount, postsCount, biography, externalUrl, category, isBusiness when enrichProfileDetails is on)	Audience mapping, creator/competitor research, list-building for outreach or analytics

Full Instagram account identifiers, not just a name

Most following scrapers hand back a username, a display name, and maybe a profile picture URL. This Actor keeps Instagram's complete identifier set for every row: pk, pk_id, and id (the account's stable numeric IDs, which don't change even if the person renames their handle), strong_id__, and fbid_v2 (the Facebook-linked account ID). It also carries account_badges (any badge Instagram attaches to the account), has_anonymous_profile_picture (default-avatar flag), is_favorite (whether the session account starred this user), and latest_reel_media (a raw activity timestamp). A minimal row looks like:

{
  "pk": "232192182",
  "id": "232192182",
  "fbid_v2": "17841400000000000",
  "strong_id__": "232192182",
  "username": "nasa",
  "account_badges": []
}

That numeric-ID persistence is what makes repeat runs and de-duplication reliable — matching on pk/id survives a handle change that would break a username-only join.

Bulk seed attribution with sourceProfile

Every row is tagged with sourceProfile — the exact seed profile whose following list it came from. Run ten creator accounts in one job and the output stays queryable: group by sourceProfile to rebuild each account's list individually, or pivot on username across groups to find accounts multiple seeds follow in common — the basis of any following-overlap or shared-network analysis.

How does Instagram Following Scraper differ from the official Instagram API?

Meta's Instagram Graph API does not expose a following-list endpoint for any account, including your own — it returns a follows_count integer and, for accounts with 100+ followers, aggregated audience percentages, but never the individual accounts behind those numbers. Instagram Following Scraper returns the actual list.

Feature	Instagram Graph API	Instagram Following Scraper
Individual following list	Not available for any account	Full list for any profile your session can view
Eligible accounts	Business/Creator accounts only; personal accounts have no API access	Any public profile, or private profiles your session follows
Setup	Meta app review, business verification, linked Facebook Page, token refresh	One Instagram sessionid cookie
Bulk profiles per request	Not applicable — no such endpoint exists	Any number of profiles in one run, each tagged with sourceProfile
Output detail	Aggregate counts and audience percentages only	Per-account identifiers, verification, privacy, and badge flags

The Graph API is the right tool if you only need your own account's aggregate follow counts and already run a verified Business account. Use Instagram Following Scraper when you need the actual list of accounts a profile follows, for any profile, without a Meta developer application.

What is the difference between a followers scraper and a following scraper?

A followers scraper returns who follows a profile — the inbound edge. A following scraper, like this Actor, returns who that profile follows — the outbound edge. Instagram exposes these as two separate API endpoints with two separate response shapes, so a tool built for one cannot silently return the other. The distinction matters because the two answer different questions: followers tell you who already found an account, while following tells you whose content that account actively consumes, which is the more useful signal for mapping who a creator or brand pays attention to. Instagram Following Scraper is purpose-built for the outbound edge only, using the friendships/{user_id}/following/ endpoint; the fields it returns (account_badges, is_favorite, latest_reel_media, and the rest) reflect that endpoint's real response, not a followers response relabeled. If you need the inbound list instead, that is a separate scraper against a separate endpoint.

How to scrape Instagram with Instagram Following Scraper?

1. Open Instagram Following Scraper on the Apify Store (or find it under Actors in Apify Console).
2. Enter one or more profiles in urls — full links, @handle, or plain handle.
3. Paste a logged-in Instagram sessionid cookie into sessionId — this is required; there is no logged-out mode.
4. Set maxItems to cap accounts per profile (0 for no cap), and optionally configure proxyConfiguration.
5. Start the run and download results as JSON, CSV, or Excel, or stream them from the dataset via the Apify API.

{
  "urls": ["https://www.instagram.com/mrbeast/"],
  "sessionId": "YOUR_SESSIONID_COOKIE_VALUE"
}

How to run multiple profiles in one job

Add every profile you want to urls as additional list entries — one per line, mixing full URLs and bare handles freely. The Actor works through them sequentially in a single run, applies the same maxItems cap to each, and tags every output row with sourceProfile so the combined dataset stays attributable back to its seed profile.

⬇️ Input

Parameter	Required	Type	Description	Example Value
urls	Yes	array	Instagram profile links, @handle, or bare handle — one per entry.	["https://www.instagram.com/mrbeast/", "nasa"]
sessionId	Yes	string	Logged-in Instagram sessionid cookie value. Required — the following list is login-gated and returns nothing without it.	"YOUR_SESSIONID_COOKIE_VALUE"
maxItems	No	integer	Accounts to collect per profile. 0 = no cap (collect the whole list). Default 100.	300
skipPrivateAccounts	No	boolean	Drop every followed account whose profile is private. Default false.	true
onlyVerifiedAccounts	No	boolean	Keep only accounts with the blue verified badge. Default false.	true
enrichProfileDetails	No	boolean	Add real follower/following/post counts, bio, website, category and public contact fields to each row. Costs one extra Instagram request per row, so keep the list small. Default false.	true
maxRunTimeSecs	No	integer	Wall-clock budget for the whole run. When it is reached the Actor stops cleanly and keeps everything already collected. Default 3600.	900
proxyConfiguration	No	object	Apify Proxy configuration. Default is direct (no proxy); the Actor escalates to datacenter then residential automatically if Instagram blocks the request.	{ "useApifyProxy": false }

Example input:

{
  "urls": [
    "https://www.instagram.com/mrbeast/",
    "nasa"
  ],
  "maxItems": 300,
  "sessionId": "YOUR_SESSIONID_COOKIE_VALUE",
  "proxyConfiguration": { "useApifyProxy": false }
}

Common pitfall: the default maxItems is 100 per profile, not per run — leaving it unset on a bulk job of many urls returns only the first 100 followed accounts for each profile. Set it explicitly (or 0 for the full list) whenever you expect complete results.

⬆️ Output

Output is typed, normalized JSON — the same 19 core fields on every row, across every profile in the run (plus the enrichment fields when enrichProfileDetails is on). Anything Instagram does not return is null or simply absent — never a placeholder 0 or empty string. Export from the dataset as JSON, CSV, Excel, or pull it through the Apify API.

Scraped results

Real rows from a live run against https://www.instagram.com/nasa/ (profile-picture query strings trimmed for readability):

[
  {
    "pk": "354812686",
    "pk_id": "354812686",
    "id": "354812686",
    "username": "nasaearth",
    "full_name": "NASA Earth",
    "is_verified": true,
    "is_private": false,
    "fbid_v2": "17841401820585543",
    "strong_id__": "354812686",
    "profile_pic_id": "3867189445212959230_354812686",
    "profile_pic_url": "https://scontent-iad6-1.cdninstagram.com/v/t51.82787-19/657806651_18576784678060687_8183754551405765709_n.jpg",
    "has_anonymous_profile_picture": false,
    "account_badges": [],
    "latest_reel_media": 1785776550,
    "is_favorite": false,
    "third_party_downloads_enabled": 1,
    "sourceProfile": "nasa",
    "profileUrl": "https://www.instagram.com/nasaearth/",
    "scrapedAt": "2026-08-04T08:08:29Z"
  },
  {
    "pk": "5951848929",
    "pk_id": "5951848929",
    "id": "5951848929",
    "username": "nasahubble",
    "full_name": "Hubble Space Telescope",
    "is_verified": true,
    "is_private": false,
    "fbid_v2": "17841405787893981",
    "strong_id__": "5951848929",
    "profile_pic_id": "1593519810350997639_5951848929",
    "profile_pic_url": "https://scontent-iad6-1.cdninstagram.com/v/t51.2885-19/21224535_842046619287423_6058376272399040512_a.jpg",
    "has_anonymous_profile_picture": false,
    "account_badges": [],
    "latest_reel_media": 1785783938,
    "is_favorite": false,
    "third_party_downloads_enabled": 1,
    "sourceProfile": "nasa",
    "profileUrl": "https://www.instagram.com/nasahubble/",
    "scrapedAt": "2026-08-04T08:08:29Z"
  },
  {
    "pk": "47617339510",
    "pk_id": "47617339510",
    "id": "47617339510",
    "username": "astro_illini",
    "full_name": "Mike Hopkins",
    "is_verified": true,
    "is_private": false,
    "fbid_v2": "17841447625312167",
    "strong_id__": "47617339510",
    "profile_pic_id": "2563413792514801812_47617339510",
    "profile_pic_url": "https://scontent-iad3-1.cdninstagram.com/v/t51.2885-19/178557266_572360540393360_7244587800802775424_n.jpg",
    "has_anonymous_profile_picture": false,
    "account_badges": [],
    "latest_reel_media": 0,
    "is_favorite": false,
    "third_party_downloads_enabled": 0,
    "sourceProfile": "nasa",
    "profileUrl": "https://www.instagram.com/astro_illini/",
    "scrapedAt": "2026-08-04T08:08:29Z"
  }
]

With enrichProfileDetails turned on, each row additionally carries the account's live stats, e.g.:

{
  "username": "cristiano",
  "full_name": "Cristiano Ronaldo",
  "followersCount": 678250471,
  "followingCount": 634,
  "postsCount": 4115,
  "isBusiness": false
}

How can I use the data extracted with Instagram Following Scraper?

• Audience and influencer research: run a creator's or brand's profile through the Actor to see exactly which accounts they follow, then filter by is_verified and account_badges to shortlist notable names for a partnership pitch or media list.
• Influencer and partnership discovery: feed a list of prospective partners' profiles through urls in one bulk run, group the output by sourceProfile, and find accounts that show up in multiple creators' following lists — a concrete signal of an established, cross-promoted network.
• AI engineers and LLM developers: call the Actor from an agent, hand the resulting JSON straight to an LLM as grounding context, and let it answer questions like "which of these accounts follows both X and Y" without the model ever touching Instagram directly.
• Market researchers: track which brands, tools, and competitors a set of industry accounts follows in common, using sourceProfile and username to build a shared-network map across a whole niche rather than one profile at a time.

How do you monitor an Instagram profile's following list over time?

Following-list monitoring means running the same seed profiles on a schedule and diffing the results, rather than treating one run as a final answer. Each run returns the full following list as it stands at that moment; comparing today's username and pk set against the previous run's set for the same sourceProfile tells you exactly which accounts were newly followed (present now, absent before) and which were unfollowed (present before, absent now) — a diff that a single snapshot can't give you.

Because pk and id are Instagram's stable numeric identifiers, diff on those rather than username alone: a renamed account keeps the same pk, so keying on the numeric ID avoids false "unfollow" signals from a simple handle change. is_verified, is_private, and account_badges are also worth tracking per account, since a followed account's status can change between runs.

A practical loop: schedule a run across your seed profiles (via Apify's built-in Scheduler), store each run's output keyed by sourceProfile and pk, and alert only on the set difference against the prior run — new follows for competitor-monitoring, or unfollows for churn signals on a partnership you're tracking. Because rows stream to the dataset as they're collected, a scheduled run doesn't need to finish before you can start comparing the partial output against your stored baseline, which matters when a seed profile follows a very large number of accounts.

Integrate Instagram Following Scraper and automate your workflow

Instagram Following Scraper works with any language or tool that can send an HTTP request, through the standard Apify API.

REST API with Python

import requests

TOKEN = "YOUR_APIFY_TOKEN"
url = f"https://api.apify.com/v2/acts/scrapier~instagram-following-scraper/run-sync-get-dataset-items?token={TOKEN}"

payload = {
    "urls": ["https://www.instagram.com/mrbeast/"],
    "sessionId": "YOUR_SESSIONID_COOKIE_VALUE",
    "maxItems": 100
}

response = requests.post(url, json=payload)
following = response.json()
print(f"Collected {len(following)} followed accounts")

MCP for query-grounded AI agents

Instagram Following Scraper is reachable through Apify's hosted MCP server at https://mcp.apify.com, or locally via npx @apify/actors-mcp-server --tools scrapier/instagram-following-scraper. Register it with an MCP-compatible client — Claude Desktop, Claude Code, Cursor, or VS Code — and an agent can call it as a tool: the user asks who an account follows, the agent invokes the Actor, and the agent answers grounded in the returned JSON instead of a guess.

Scheduled monitoring and delivery

Set up an Apify Scheduler to re-run the same urls list at a fixed interval, and pull each run's dataset through the API to diff against the last one. There is no built-in webhook push from the Actor itself, so delivery is either a scheduled poll of the dataset or an Apify webhook configured on the run's completion event.

Is it legal to scrape Instagram following lists?

Scraping data that a logged-in Instagram session can already view is generally treated like other automated collection of accessible web data, but a following list is personal data — it identifies real, named individuals and their connections — so data protection law applies, not just platform terms. If you or your users are in the EU/EEA or UK, GDPR governs storing or processing that data; if you serve California residents, CCPA applies. Both require a lawful basis for processing and give individuals rights over data concerning them, regardless of where it was collected. One-off research carries a different risk profile than scraping for AI training or bulk resale, which stores personal data about people who never consented to that use. Instagram's Terms of Service govern automated access separately from data-protection law. Consult your legal team before any commercial use case involving bulk storage or resale.

Frequently asked questions

Can I scrape multiple Instagram profiles in one run?

Yes — add each profile to the urls array as a separate entry, mixing full links and bare handles. The Actor processes them in sequence within one run and tags every output row with sourceProfile so the combined results stay attributable per profile.

How many results does Instagram Following Scraper return per profile?

By default, up to maxItems accounts per profile, which defaults to 100. Set maxItems to any number to raise the cap, or 0 to collect the entire following list with no cap — the run stops naturally once Instagram's pagination has no further next_max_id.

Can it access private accounts' following lists?

Only if the Instagram account behind your sessionId is already permitted to view that private profile — the Actor authenticates as that logged-in session, it does not bypass Instagram's own privacy controls. Without your session having access, a private profile's following list stays inaccessible, same as browsing it manually.

Does my sessionId expire, and is it safe to use here?

Instagram session cookies expire like any browser session and will eventually need refreshing from your logged-in browser. The value is passed only into your own Actor run as a secret input field and is never displayed back or shared — treat it like a password and use an account you control.

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

It starts every request direct (no proxy) and automatically escalates to a datacenter proxy, then a sticky residential proxy, if Instagram returns a block signal (401/403/429, a checkpoint, or a challenge page). Residential retries rotate to a fresh IP on each further block rather than retrying the same one.

Does Instagram Following Scraper extract more than just usernames?

Yes — every row includes Instagram's full identifier set (pk, pk_id, id, strong_id__, fbid_v2), verification and privacy flags, account_badges, sourceProfile seed attribution, profileUrl and scrapedAt — not just a username and picture. Turn on enrichProfileDetails and each row also carries the account's live followersCount, followingCount, postsCount, biography, externalUrl, category and isBusiness.

How do I use Instagram Following Scraper to monitor an account's following list over time?

Schedule the same urls list on a recurring run, key each run's output by sourceProfile and pk, and diff the current run's account set against the previous one. Accounts present now but absent before are new follows; accounts present before but missing now were unfollowed.

Does Instagram Following Scraper work with Claude, ChatGPT, and AI agent frameworks?

Yes — it's callable as an HTTP endpoint by any agent framework that can make a request, and it's also reachable directly through Apify's MCP server (https://mcp.apify.com) for MCP-compatible clients like Claude Desktop or Claude Code, letting an agent retrieve a live following list before answering a question.

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

As observed on their public Apify Store listings in July 2026, some following scrapers skip the login requirement but return only a handful of fields (username, image URL, bio text) with no numeric IDs at all; others require a result-count input and return a mid-sized field set (username, full name, verification, privacy) without the full ID set or badge data. Instagram Following Scraper trades the no-login convenience for a login-gated session in exchange for the complete raw field set Instagram's API actually returns, including stable numeric IDs and per-account badges.

Can I use Instagram Following Scraper without managing proxies myself?

Yes for proxies — the Actor handles the direct-to-datacenter-to-residential escalation automatically, so you don't configure or rotate anything unless you want to override it via proxyConfiguration. You do still need to supply your own Instagram sessionId, since the following list cannot be read without a logged-in session.

Your feedback

Found a bug or a field that doesn't match Instagram's current response? Open an issue on this Actor's Apify Store page or message Scrapier through Apify Console — reports like this are what keep the field list accurate as Instagram's API changes.