# Instagram User Following Scraper ✅ (`datamagnet/instagram-following`) Actor

Extract the accounts followed by any Instagram profile using a username, user ID, or profile URL. Set a result limit and let the actor paginate automatically, returning raw following data that is ready for analysis, research, and export.

- **URL**: https://apify.com/datamagnet/instagram-following.md
- **Developed by:** [Datamagnet](https://apify.com/datamagnet) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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 Following Scraper

Instagram Following Scraper helps you quickly collect the accounts followed by any Instagram profile, making it ideal for marketers, researchers, creators, and growth teams who need reliable Instagram following data. Enter a username, user ID, or profile URL, and the actor gathers followed accounts automatically with no manual scrolling. It is built for people who want to analyze audience interests, discover competitor relationships, or build clean Instagram data lists for outreach and research. Results are returned in a ready-to-use format so you can review, filter, and export the data with ease.

### Key Features

- Extract the accounts followed by a specific Instagram profile in one run.
- Collect as many results as you need, up to your chosen limit.
- Accept a username, numeric user ID, or profile URL for flexible targeting.
- Continue collecting automatically until the requested amount is reached.
- Return raw followed-account details exactly as provided by the source.
- Include useful profile fields such as username, full name, verification status, and profile picture.
- Save time by avoiding manual profile-by-profile checking and copying.

### Use Cases

#### Competitor Audience Research
Marketing teams use this actor to see which accounts a competitor follows and identify patterns in their interests, partnerships, and content strategy. The returned fields like `username`, `full_name`, `is_verified`, and `is_private` help teams understand whether the followed accounts are creators, brands, or private profiles.

#### Influencer Discovery
Agencies and brands can review the followed accounts of a creator or public figure to find related influencers and niche communities. Fields such as `username`, `profile_pic_url`, and `latest_reel_media` help teams quickly spot active accounts worth investigating further.

#### Partnership and Outreach Planning
Business development teams can use the data to build smarter outreach lists based on the accounts a target profile follows. Seeing `is_verified`, `full_name`, and `username` helps them prioritize credible accounts and identify potential collaborators.

#### Audience Interest Mapping
Researchers and social media analysts can study followed accounts to understand what topics, brands, or personalities a profile is connected to. The combination of `id`, `username`, and `is_private` makes it easier to group accounts and compare audience behavior across multiple profiles.

#### Content Strategy Benchmarking
Creators and social teams can compare the followed accounts of successful profiles to learn what kinds of accounts they pay attention to. This can reveal inspiration sources, industry peers, and emerging trends that may influence future content planning.

### Input

| Field | Type | Required | Description | Example |
|---|---|---:|---|---|
| amount | integer | No | Set how many followed accounts you want to collect. The actor will keep gathering results until it reaches this number or runs out of accounts. | 50 |
| pagination_token | string | No | Use this only if you want to continue from a previous result page. Leave it empty for a fresh start. |  |
| username_or_id_or_url | string | Yes | Enter the Instagram username, numeric user ID, or profile URL for the account whose following list you want to get. | mrbeast |

### Output

| Field | Type | Description |
|---|---|---|
| full_name | string | The person or account name shown on the profile, which helps you recognize who the account belongs to. |
| id | string | The account’s unique identifier, useful for matching records and keeping data organized. |
| is_private | boolean | Shows whether the account is private, which helps you understand how visible the profile is. |
| is_verified | boolean | Shows whether the account has a verified badge, which can help you spot notable or official profiles. |
| latest_reel_media | number | A recent activity marker that can help indicate whether the account has posted recently. |
| profile_pic_url | string | The profile picture link, useful for visual review or matching accounts by image. |
| username | string | The Instagram handle, which is usually the easiest way to identify and search for the account. |

### Sample Output

```json
{
  "full_name": "riley\uaa5c",
  "id": "4544032269",
  "is_private": false,
  "is_verified": false,
  "latest_reel_media": 0,
  "profile_pic_url": "https://scontent-arn2-1.cdninstagram.com/v/t51.82787-19/730837140_18411179806144270_9019499784346223806_n.jpg?stp=dst-jpg_e0_s150x150_tt6&efg=eyJ2ZW5jb2RlX3RhZyI6InByb2ZpbGVfcGljLmRqYW5nby4xMDgwLmMyIn0&_nc_ht=scontent-arn2-1.cdninstagram.com&_nc_cat=110&_nc_oc=Q6cZ2gHAhH3tL6FyEFmIodWCw2wKGz4p8XVXeI0...",
  "username": "rileycabrall"
}
````

### How It Works

1. You enter the Instagram username, user ID, or profile URL you want to inspect.
2. You choose how many followed accounts you want to collect.
3. The actor starts gathering the followed accounts automatically.
4. If there are more results available, it continues until it reaches your limit or there is nothing left to collect.
5. You receive the results in a clean format that is easy to review and export.

### Getting Started

Getting started is simple and does not require coding knowledge. Click **Try for free**, fill in the target Instagram account and the number of results you want, then click **Run**. The actor will do the rest and return the followed-account data automatically. You can then download the results as **JSON, CSV, or Excel** depending on how you want to use the data.

### Frequently Asked Questions

#### Do I need technical skills?

No. This actor is designed for business users, marketers, researchers, and creators who want Instagram following data without dealing with complicated setup. Just enter the target account and run it.

#### How fast does it run?

Speed depends on how many followed accounts you request and how much data is available for the target profile. Smaller requests finish quickly, while larger requests may take longer because the actor keeps collecting results until it reaches your chosen limit.

#### What format is the output?

The results are available in formats that are easy to work with, including JSON, CSV, and Excel. That makes it simple to review the data in spreadsheets, share it with teammates, or import it into your own workflow.

#### Is this legal to use?

You should always use the data responsibly and in line with applicable laws, platform rules, and your organization’s policies. This actor is intended for legitimate research, analysis, and business workflows, so make sure your use case respects privacy and compliance requirements.

#### Can I schedule it to run automatically?

Yes, you can set it up to run on a schedule if you want regular updates. This is useful for tracking changes over time, monitoring competitor behavior, or refreshing your research lists without manual work.

# Actor input Schema

## `amount` (type: `integer`):

How many followed accounts to return. Minimum 1, maximum 1000. Default is 50.

## `username_or_id_or_url` (type: `string`):

Enter an Instagram username, user ID, or profile URL for the account whose following list you want to get.

## Actor input object example

```json
{
  "amount": 50,
  "username_or_id_or_url": "mrbeast"
}
```

# 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 = {
    "amount": 50,
    "username_or_id_or_url": "mrbeast"
};

// Run the Actor and wait for it to finish
const run = await client.actor("datamagnet/instagram-following").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 = {
    "amount": 50,
    "username_or_id_or_url": "mrbeast",
}

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

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

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

```

## CLI example

```bash
echo '{
  "amount": 50,
  "username_or_id_or_url": "mrbeast"
}' |
apify call datamagnet/instagram-following --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=datamagnet/instagram-following",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram User Following Scraper ✅",
        "description": "Extract the accounts followed by any Instagram profile using a username, user ID, or profile URL. Set a result limit and let the actor paginate automatically, returning raw following data that is ready for analysis, research, and export.",
        "version": "0.0",
        "x-build-id": "ED5FwDbMkOJDAks9U"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datamagnet~instagram-following/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datamagnet-instagram-following",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/datamagnet~instagram-following/runs": {
            "post": {
                "operationId": "runs-sync-datamagnet-instagram-following",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/datamagnet~instagram-following/run-sync": {
            "post": {
                "operationId": "run-sync-datamagnet-instagram-following",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "username_or_id_or_url"
                ],
                "properties": {
                    "amount": {
                        "title": "Number of accounts to retrieve",
                        "type": "integer",
                        "description": "How many followed accounts to return. Minimum 1, maximum 1000. Default is 50."
                    },
                    "username_or_id_or_url": {
                        "title": "Instagram user",
                        "type": "string",
                        "description": "Enter an Instagram username, user ID, or profile URL for the account whose following list you want to get."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```