# Instagram Followers Scraper & Related Profile Expansion (`simpleapi/instagram-followers-scraper`) Actor

📸 Instagram Followers Enrichment Scraper extracts public follower lists from any IG profile—usernames, names, bios, follower/following, verification & profile links. ⚡ Export CSV/JSON for growth, competitor research, influencer discovery & lead gen. ✅ Fast, accurate, scalable.

- **URL**: https://apify.com/simpleapi/instagram-followers-scraper.md
- **Developed by:** [SimpleAPI](https://apify.com/simpleapi) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 10 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period. You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#rental-actors

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

### Instagram Scraper — Followers, Related Profiles and Audience Overlap

Instagram Followers Scraper & Related Profile Expansion collects real followers for one or more seed Instagram profiles, then discovers each seed's related/suggested profiles and computes a genuine shared-audience percentage — how much of a related profile's own follower sample also follows the seed. It's built for influencer marketing teams vetting lookalike creators, agencies mapping competitive audiences, and researchers who need real overlap data instead of a guessed similarity score.

### What is Instagram Followers Scraper & Related Profile Expansion?

Instagram Followers Scraper & Related Profile Expansion is an Apify Actor that collects a seed profile's followers and, optionally, discovers and audience-fit-scores its related/suggested profiles. An Instagram `sessionid` cookie is optional but recommended for better success rates. Key capabilities:

- Collect real followers for one or many seed profiles in a single run
- Discover each seed's related/suggested profiles via Instagram's own related-profiles data
- Sample each related profile's own followers and compute a real `sharedAudiencePct` — the percentage that also follows the seed
- Rank related profiles by shared-audience percentage, descending
- Tune scoring depth with per-seed and per-related-profile sample-size caps

### What data can I extract with Instagram Followers Scraper & Related Profile Expansion?

| Field | Example Value | Use Case |
| --- | --- | --- |
| `username` / `full_name` | `"cristiano_fanpage"` / `"CR7 Fan Page"` | Identify the follower or related-profile account |
| `type` / `sourceType` | `"related_profile"` / `"related_profile"` | Distinguish a plain follower row from a scored related-profile row |
| `relatedToUsername` | `"cristiano"` | See which seed profile this related profile is scored against |
| `sharedAudiencePct` | `18.0` | The core differentiator — real percentage of sampled followers shared with the seed |
| `audienceOverlapTier` | `"medium"` | Quick bucket for prioritizing related profiles (high/medium/low) |
| `followerSampleSize` / `overlapCount` | `50` / `9` | See exactly how the percentage was computed |
| `is_verified` / `is_private` | `false` / `false` | Filter to verified or public-only accounts |
| `followed_by` | `null` on related-profile rows | Present only on genuine follower rows |
| `profile_pic_url` / `profileUrl` | CDN image URL / profile link | Visual and direct-link reference |
| `scrapedAt` | `"2026-07-26T14:02:11+00:00"` | Record when the row was collected |
| `success` | `true` | Confirm the row completed without error |

#### Shared-audience scoring

`sharedAudiencePct` is a real, computed metric, not an estimate: for each related/suggested profile discovered for a seed, the Actor samples up to `relatedFollowerSampleSize` of that related profile's own followers, then checks how many of those sampled follower IDs also appear in the seed's own collected follower set. `overlapCount` is the raw number of matches, `followerSampleSize` is exactly how many followers were sampled, and `sharedAudiencePct = overlapCount / followerSampleSize × 100`. `audienceOverlapTier` buckets that percentage into high/medium/low so results can be triaged at a glance, and every scored related-profile row is tagged `type: "related_profile"` so it's never confused with a genuine follower row in the same dataset.

#### Seed targeting and scoring depth

`targetProfiles` accepts one or many seed profiles in the same run. `maxFollowersPerProfile` caps how many followers are collected per seed. `enableRelatedProfileScoring` toggles the entire discovery-and-scoring pipeline on or off; when on, `maxRelatedToScore` caps how many related profiles per seed get scored, and `relatedFollowerSampleSize` controls how deep each related profile's own follower sample goes.

### Why not build this yourself?

Instagram's Graph API has no endpoint for pulling an arbitrary profile's follower list, its related/suggested profiles, or any cross-profile audience-overlap metric — none of that exists in any form for third-party access. Building an equivalent tool yourself means implementing Instagram's mobile-web followers pagination, the related-profiles discovery edge, a second-pass follower sample for every related profile you want to score, and the set-intersection math to turn two raw ID lists into a genuine overlap percentage. All of that is already implemented in this Actor's source.

### How to use data extracted from Instagram?

#### Influencer marketing and lookalike vetting

Run a target creator's `targetProfiles` with scoring enabled to get a ranked list of related creators by `sharedAudiencePct` — the ones with genuinely high shared audience are the most defensible lookalike candidates for a similar-audience partnership, rather than accounts that merely appear in Instagram's suggestion algorithm without real audience overlap.

#### Agencies mapping competitive audiences

Score a client's competitors as seed profiles and compare `audienceOverlapTier` distributions across them to see which competitor's audience most closely mirrors the client's own, informing where to focus competitive campaign spend.

#### Market and audience research

Track how `sharedAudiencePct` changes for a brand's related-profile set over repeated scheduled runs to see whether the brand's audience is converging with or diverging from its category peers over time.

#### AI agents and automated pipelines

An agent can call this Actor to pre-qualify lookalike accounts before triggering an outreach workflow — filtering on `audienceOverlapTier` to only surface related profiles with a defensible, real audience overlap.

### 🔼 Input sample

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `targetProfiles` | No | array | Seed profile URLs or usernames to collect followers and related profiles for | `["https://www.instagram.com/cristiano/"]` |
| `maxFollowersPerProfile` | No | integer (1-100,000) | Max followers to collect per seed profile | `100` (default) |
| `enableRelatedProfileScoring` | No | boolean | Toggle the related-profile discovery + scoring pipeline | `true` (default) |
| `maxRelatedToScore` | No | integer (1-50) | Cap on related profiles scored per seed | `10` (default) |
| `relatedFollowerSampleSize` | No | integer (10-200) | Followers sampled per related profile for overlap scoring | `50` (default) |
| `instagramSessionId` | No | string (secret) | Instagram `sessionid` cookie; optional but recommended | `"(your session cookie)"` |
| `proxyConfiguration` | No | object | Proxy settings; auto-escalates on repeated blocks | `{"useApifyProxy": true}` |

```json
{
  "targetProfiles": ["https://www.instagram.com/cristiano/"],
  "maxFollowersPerProfile": 500,
  "enableRelatedProfileScoring": true,
  "maxRelatedToScore": 15
}
```

**Common pitfall:** `maxRelatedToScore` and `relatedFollowerSampleSize` both add extra requests per seed (one discovery request plus one follower-sample request per related profile checked) — a high value on both, across many seeds, multiplies run time and request volume quickly.

### 🔽 Output sample

Output is typed, normalized JSON — one row per follower or scored related profile (exportable as JSON, CSV, or Excel).

```json
{
  "pk": "9871234567",
  "type": "related_profile",
  "sourceType": "related_profile",
  "username": "cristiano_fanpage",
  "full_name": "CR7 Fan Page",
  "is_verified": false,
  "is_private": false,
  "followed_by": null,
  "relatedToUsername": "cristiano",
  "sharedAudiencePct": 18.0,
  "audienceOverlapTier": "medium",
  "followerSampleSize": 50,
  "overlapCount": 9,
  "profile_pic_url": "https://scontent.cdninstagram.com/...",
  "profileUrl": "https://www.instagram.com/cristiano_fanpage/",
  "pk_id": "9871234567",
  "id": "9871234567",
  "fbid_v2": "",
  "third_party_downloads_enabled": 0,
  "strong_id__": "9871234567",
  "profile_pic_id": "",
  "has_anonymous_profile_picture": false,
  "account_badges": [],
  "latest_reel_media": 0,
  "is_favorite": false,
  "scrapedAt": "2026-07-26T14:02:11+00:00",
  "success": true
}
```

All 27 fields shown above are the Actor's real dataset columns — this is the full output shape, not a subset.

### How do you filter and target specific profiles?

`targetProfiles` is the core scope control — supply one or many seed profiles to process in the same run. `enableRelatedProfileScoring` is the category switch: off, you get a plain follower collection; on, every seed also produces scored related-profile rows. Quality thresholds come from `audienceOverlapTier`/`sharedAudiencePct` after the fact — filter your exported dataset to `audienceOverlapTier: "high"` for only the strongest lookalike candidates. Volume is controlled by three separate caps: `maxFollowersPerProfile` for the seed's own follower collection, `maxRelatedToScore` for how many related profiles get scored, and `relatedFollowerSampleSize` for how deep each related profile's own follower sample goes — tune the last two down first if you need faster, cheaper runs across many seeds.

```json
{ "targetProfiles": ["nike"], "maxFollowersPerProfile": 1000, "enableRelatedProfileScoring": true, "maxRelatedToScore": 20 }
```

```json
{ "targetProfiles": ["cristiano", "nike"], "enableRelatedProfileScoring": true, "relatedFollowerSampleSize": 100 }
```

```json
{ "targetProfiles": ["https://www.instagram.com/nike/"], "enableRelatedProfileScoring": false, "maxFollowersPerProfile": 5000 }
```

### ▶️ Want to try other Instagram scrapers?

| Scraper Name | What it extracts |
| --- | --- |
| Instagram Following Scraper: Related Profiles List | Following lists plus related-profile expansion |
| Instagram Related Person Scraper With Profile Enrichment | Related/lookalike networks for a given account |
| Instagram Followers: With Bot Profile checker | Follower/following lists with quality/authenticity scoring |
| Instagram Followers Count Scraper | A lightweight follower-count-only lookup |
| Instagram Profile Scraper & Account Privacy Checker | Full profile details plus privacy-status checking |
| LinkedIn Company Employees Scraper With Growth Tracker | Comparable audience-composition data for LinkedIn companies |

### How to extract Instagram data programmatically

Every run is a standard Apify Actor call — one API request with your token, JSON input, JSON results back.

#### Python example

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_API_TOKEN>")

run_input = {
    "targetProfiles": ["https://www.instagram.com/cristiano/"],
    "maxFollowersPerProfile": 500,
    "enableRelatedProfileScoring": True,
}

run = client.actor("<YOUR_USERNAME>/instagram-followers-scraper-related-profile-expansion").call(run_input=run_input)

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row.get("type") == "related_profile":
        print(row["username"], row["sharedAudiencePct"], row["audienceOverlapTier"])
```

#### Export to spreadsheets or CRM

Export the dataset directly as CSV or Excel, then map `username`/`profileUrl` to your CRM's contact fields and `sharedAudiencePct`/`audienceOverlapTier` to a scoring column for prioritizing lookalike outreach.

### Is it legal to scrape Instagram followers and related profiles?

Follower usernames, full names, and profile pictures are personal data, so GDPR and CCPA obligations apply to storing and using this data. Public Instagram follower and related-profile lists are visible to any logged-out visitor on the profile itself, but downstream storage for research or vetting purposes should follow applicable data-protection rules. Consult legal counsel for commercial applications involving bulk storage of personal data.

### ❓ FAQ

#### How is sharedAudiencePct actually calculated?

It's a real, computed set-intersection: the Actor samples a related profile's own followers, checks how many of those sampled IDs also appear in the seed's own collected follower list, and divides overlap count by sample size. It is not an estimate or a similarity guess — `overlapCount` and `followerSampleSize` are shown alongside the percentage so you can verify the math yourself.

#### Can I get related profiles without also collecting the seed's followers?

No — the seed's own follower list is collected first and used as the comparison set for scoring, so seed follower collection always runs when `enableRelatedProfileScoring` is on. Set `maxFollowersPerProfile` low if you want to minimize that cost.

#### How many related profiles can be scored per seed?

`maxRelatedToScore` (1-50, default 10) caps this. Each scored related profile costs one extra follower-sample request, so higher caps mean longer, costlier runs.

#### Do I need an Instagram account to use this?

No, but it's recommended — supplying your Instagram `sessionid` cookie via `instagramSessionId` improves success rates; the Actor still runs without one.

#### Does Instagram Followers Scraper & Related Profile Expansion work with Claude, ChatGPT, and AI agent frameworks?

It has no dedicated MCP server registration in this Actor's current setup, but it is callable as a standard Apify API endpoint by any agent framework that can make an authenticated HTTP request and parse JSON.

#### How does this compare to other Instagram related-profile scrapers?

No independently verifiable competitor listing could be confirmed at the time of writing, so no specific comparison is made here. This Actor's distinguishing feature is the real, sampled shared-audience percentage rather than just a list of Instagram's suggested profiles.

#### What does audienceOverlapTier mean exactly?

It's a bucket derived from `sharedAudiencePct` — high, medium, or low — that lets you triage related profiles at a glance without reading raw percentages for every row.

#### Can I use this without any Instagram credentials?

Yes — `instagramSessionId` is optional. The run will attempt without it, though Instagram may block requests more often.

### Conclusion

Instagram Followers Scraper & Related Profile Expansion turns a seed profile into both a real follower list and a ranked set of related profiles scored by genuine shared audience — computed overlap, not a guessed similarity score. It's built for influencer marketing teams, agencies, and researchers who need defensible lookalike data before committing outreach budget. Start a run with your seed profiles and scoring enabled to see which related accounts actually share the seed's audience.

# Actor input Schema

## `targetProfiles` (type: `array`):

List of Instagram profile URLs or usernames. Followers are collected for each, and related/suggested profiles are discovered and audience-fit scored against it.

Examples:
• https://www.instagram.com/cristiano/
• https://www.instagram.com/nike/
• cristiano
• nike

Also accepts the base field name 'startUrls' for backward compatibility.

## `maxFollowersPerProfile` (type: `integer`):

Maximum number of followers to collect per seed profile. Range: 1-100,000. Default: 100.

Also accepts the base field name 'maxData' for backward compatibility.

## `enableRelatedProfileScoring` (type: `boolean`):

When ON, for each seed profile the actor fetches its related/suggested profiles (via Instagram's edge\_related\_profiles/edge\_chaining), samples each related profile's own followers, and computes what percentage of that sample also follows the seed (sharedAudiencePct). Output rows are ranked by sharedAudiencePct descending.

## `maxRelatedToScore` (type: `integer`):

Caps how many of a seed's related/suggested profiles get their followers sampled and scored (1 request per seed for discovery, plus 1 follower-sample request per related profile checked, up to this cap). Default: 10.

## `relatedFollowerSampleSize` (type: `integer`):

How many of EACH related profile's own followers to fetch (single page, via the same followers engine used for seed profiles) to check for overlap with the seed's follower list. Default: 50.

## `instagramSessionId` (type: `string`):

Optional but strongly recommended for better success rates.

How to get your Session ID:

1. Log into Instagram in your browser
2. Open Developer Tools (F12 or Right-click → Inspect)
3. Go to Application/Storage → Cookies → https://www.instagram.com
4. Find and copy the 'sessionid' value

Without a session ID, the scraper may have limited access and lower success rates.

Also accepts the base field name 'sessionId' for backward compatibility.

## `proxyConfiguration` (type: `object`):

Configure proxy settings for enhanced reliability and bypassing restrictions.

Smart fallback: no proxy → datacenter proxy (if configured) → residential proxy (automatic on block, with retries).

## Actor input object example

```json
{
  "targetProfiles": [
    "https://www.instagram.com/cristiano/"
  ],
  "maxFollowersPerProfile": 100,
  "enableRelatedProfileScoring": true,
  "maxRelatedToScore": 10,
  "relatedFollowerSampleSize": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped items in the Actor's default dataset.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "targetProfiles": [
        "https://www.instagram.com/cristiano/"
    ],
    "maxFollowersPerProfile": 100,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("simpleapi/instagram-followers-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "targetProfiles": ["https://www.instagram.com/cristiano/"],
    "maxFollowersPerProfile": 100,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("simpleapi/instagram-followers-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "targetProfiles": [
    "https://www.instagram.com/cristiano/"
  ],
  "maxFollowersPerProfile": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call simpleapi/instagram-followers-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,simpleapi/instagram-followers-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/81eatITNvbMwdLp7s/builds/j5REgZCizilC6uWzs/openapi.json