Instagram Followers & Following Scraper: 3 Practical Use Cases

Direct answer

The Instagram Followers & Following Scraper extracts follower and following lists from public Instagram profiles into structured datasets. The Actor retrieves key account parameters including username, full display name, numeric user ID, verification badge status, privacy state, profile picture CDN URL, profile picture ID, target profile URL, source profile username, collection type, timestamp, and run status. It supports single or bulk profile extraction, operates in three collection modes (followers, following, or both), and allows custom profile extraction caps. Authentication runs automatically through a managed session pool, via pasted JSON cookies, or using a saved session name from key-value storage. Operators use this scraper for competitive benchmarking, lead discovery, and audience mapping.

Practical use cases

These playbooks illustrate practical ways to implement the Actor based on documented feature capabilities and output structures.

Use case 1: Competitor audience analysis

Question to answer: Which comparable groups differ in a way that could change a product, positioning, or market decision?

Outcome: Identify engaged followers and prospective buyers across competing Instagram profiles.

Configure: Set usernames to ["target_competitor_1", "target_competitor_2"], set scrapeType to "followers", and cap maxFollowersPerProfile at 200 for an initial sample run.

Working method: Collect follower samples from accounts offering similar products. Filter out private accounts where is_private is true if public outreach is required, and flag verified accounts where is_verified is true as potential industry influencers or brand partners. Cross-reference handles against existing records to evaluate prospective market demand.

Deliverable: A competitor follower matrix categorizing handles by verification status, privacy settings, and target profile alignment.

Stop condition: Halt the extraction if more than 30 percent of harvested profiles return non-existent profile statuses or if rate limits prevent complete pagination across targeted competitor lists.

Use case 2: B2B lead generation from community hubs

Question to answer: Which candidates satisfy the qualification rule, and what evidence makes each one worth a closer look?

Outcome: Extract target prospect profiles from relevant industry associations, niche influencers, or regional trade hubs on Instagram.

Configure: Input target industry hub handles in usernames, choose "followers" for scrapeType, set maxFollowersPerProfile to 500, and pass a valid sessionName to load previously saved authentication cookies from key-value storage.

Working method: Gather follower records from high-affinity community accounts. Evaluate user handles and full names against ideal customer profiles. Filter out accounts with default profile picture URLs or blank display names to isolate actionable prospects before passing records to outbound sales teams.

Deliverable: A prospective lead sheet containing username, full_name, profile_url, verification state, and qualification flags.

Stop condition: Pause execution if the ratio of unverified, private, or non-existent profiles exceeds the acceptance threshold defined for campaign research.

Use case 3: Audience overlap and community mapping

Question to answer: Which returned records satisfy the stated decision rule, and what should happen to each accepted record?

Outcome: Determine shared audience density between co-marketing partners or complementary brands by analyzing following lists.

Configure: List partner handles under usernames, set scrapeType to "following", set maxFollowersPerProfile to 300, and leave cookies blank to rely on automatic managed session handling.

Working method: Extract account following lists for both entities. Run deduplication on user_id and username to calculate exact intersection rates across the retrieved lists. Compare shared handles to identify mutual ecosystem connections and key industry nodes.

Deliverable: An audience overlap matrix detailing unique versus shared profile IDs alongside calculated percentage overlap metrics for strategic co-branding decisions.

Stop condition: Discontinue the run if sample sizes are insufficient to draw clear overlap conclusions or if non-existent account errors dominate the output dataset.

Instagram extraction configuration and parameters

Configuring the Actor correctly depends on understanding its core input controls. The Actor accepts input parameters designed to tailor profile collection jobs to specific technical requirements:

usernames: An array of Instagram handles, @username formatted strings, or full profile URLs such as https://www.instagram.com/natgeo/. At least one profile handle must be provided.
scrapeType: A string parameter defining list collection behavior. Accepted values are followers (extracts followers only), following (extracts following list only), or both (extracts both followers and following lists for each specified account). The default value is followers.
maxFollowersPerProfile: An integer capping the maximum number of account records retrieved per profile list. The default value is 100 records. Setting this parameter to 0 enables unlimited pagination until the full list is captured.
cookies: An optional JSON string containing active Instagram session cookies. When left blank, the Actor uses Apify's managed session pool.
sessionName: An optional string specifying a key to load previously saved session cookies stored in key-value storage for persistent authentication across multiple runs.

Running test jobs with smaller limits helps refine filters and verify cookie validity before launching larger audience collection tasks.

Output data structure and record validation

Every record output by the Actor is delivered as structured JSON. Key standard fields present in valid returned records include:

username: The unique Instagram account handle.
user_id: The underlying numeric Instagram user ID string.
full_name: The display name listed on the user profile.
is_verified: A boolean (true or false) indicating if the account holds a blue verification badge.
is_private: A boolean indicating whether profile details are restricted to approved followers.
profile_pic_url: CDN image link pointing to the profile avatar.
profile_pic_id: Internal media ID string associated with the profile avatar.
profile_url: Full web URL of the target profile being scraped.
profile_username: Handle of the source profile from which the follower or following entry was collected.
scrape_type: Clarifies whether the record originates from followers or following lists.
scraped_at: ISO 8601 formatted timestamp recording the collection time.
status: String state returning success for standard valid entries or This profile doesn't exist when an invalid handle is queried.

When an input handle does not exist on Instagram, the Actor retains full batch tracking by producing an output record where string fields are empty, boolean values are false, and status explicitly states This profile doesn't exist.

Step-by-step extraction workflow

To establish a reliable pipeline for Instagram follower and following collection, follow this structured process:

Define target profile handles and clarify target filters such as verification status or public accessibility.
Configure input parameters in the Apify Console, setting usernames and picking the required scrapeType mode.
Choose authentication settings by either leaving cookies blank to leverage managed sessions or providing custom session cookies.
Execute an initial run with maxFollowersPerProfile set to a small limit like 50 to test output quality.
Inspect returned dataset records to check for expected schema keys and isolate missing profile status indicators.
Scale the extraction by setting maxFollowersPerProfile to 0 for complete pagination across target profiles.

Following this systematic approach prevents unnecessary computing costs and ensures downstream databases receive fully validated data.

Quality controls and operational best practices

Maintaining dataset integrity requires proactive verification routines. Operators should adopt these operational practices:

Perform pilot test runs before launching large batch extractions across multiple accounts.
Monitor the status field to isolate missing or mistyped handles before passing dataset records to analytical models.
Perform deduplication using user_id instead of handle strings to account for potential handle changes over time.
Separate private profile records (is_private: true) when building public outreach pipelines, as private profiles restrict public content audits.
Retain original timestamps (scraped_at) and source metadata (profile_username) to preserve data lineage during automated warehouse ingestion.
If cookies expire mid-run, re-export fresh session cookies from a logged-in browser session and resume the Actor job.

Frequently asked questions

Do I need an Instagram account to run this scraper?

An active login is required by Instagram to view follower and following lists. However, you do not need to provide personal credentials directly. Leaving the cookies parameter blank allows the Actor to use its built-in managed session pool automatically. Alternatively, you can supply your own session cookies formatted as a JSON string.

Why does the scraped follower count differ from the count shown on the profile header?

Instagram displays a public aggregate count on profile headers that includes deactivated, suspended, and soft-deleted accounts. Those inactive accounts are excluded from the actual scrollable follower list. As a result, the scraped record count will often be slightly lower than the number on the public profile page.

How does the Actor handle non-existent or deleted handles?

When a requested handle cannot be found on Instagram, the Actor outputs a record with string fields set to empty strings, boolean fields set to false, and sets status to This profile doesn't exist. This ensures input tracking remains intact without dropping records silently.

Can this scraper extract follower lists from private Instagram accounts?

To retrieve follower or following lists from a private account, the active session used by the Actor must already be an approved follower of that private account. If the session does not follow the target private profile, the run returns zero records for that account.

Is there a limit to how many followers I can extract in a single run?

There is no strict software limit imposed by the Actor. Setting maxFollowersPerProfile to 0 enables unlimited pagination. However, processing accounts with hundreds of thousands of followers requires longer run times to navigate Instagram pagination safely.

Resources

Instagram Followers & Following Scraper on Apify