# Instagram Scraper Followers Following ✅ (`scraping_solutions/instagram-scraper-followers-following`) Actor

Download an Instagram account’s followers or following. Input a username or a list of usernames (array). The actor auto-paginates, adds safe delays to reduce blocks, and returns clean JSON/CSV with id, username, full name, profile link, and privacy flags—ideal for research and growth.

- **URL**: https://apify.com/scraping_solutions/instagram-scraper-followers-following.md
- **Developed by:** [Scraping Solutions](https://apify.com/scraping_solutions) (community)
- **Categories:** Social media, Lead generation, Marketing
- **Stats:** 716 total users, 114 monthly users, 99.8% runs succeeded, 11 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.65 / 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Instagram Followers & Following Scraper - No Login / No Cookies

Download followers or following lists from public Instagram profiles and export structured audience data to JSON, CSV, Excel, XML, or the Apify API.

For deeper audience analysis, optional profile enrichment adds current follower, following, and post counts plus biography and other available profile details to each discovered user.

No Instagram login or cookies are required.

### What you can do

- Download followers from one or multiple public Instagram accounts.
- Download the accounts followed by each source profile.
- Continue large exports using a protected continuation token.
- Deduplicate profiles before they are delivered and charged.
- Enrich discovered profiles with current audience and profile metrics.
- Keep partial results when Instagram ends pagination or a later request fails.
- Export the dataset or connect it to automated Apify workflows.

### Input

| Field | Type | Required | Description |
|---|---|---:|---|
| `Account` | String array | Yes | Instagram usernames or profile URLs, one per line. |
| `resultsLimit` | Integer | Yes | Maximum number of results per source account. This is a maximum, not a guarantee. |
| `dataToScrape` | Select | Yes | Choose `Followers` or `Followings`. |
| `enrichProfileDetails` | Boolean | No | Adds profile metrics and details. Each successful enrichment creates an additional paid event. Default: `false`. |
| `continuationToken` | String | No | Continues a previous extraction for the same single account and relationship type. |

### Basic example

```json
{
  "Account": ["public_account"],
  "resultsLimit": 500,
  "dataToScrape": "Followers",
  "enrichProfileDetails": false
}
```

### Enriched audience example

```json
{
  "Account": ["public_account"],
  "resultsLimit": 100,
  "dataToScrape": "Followers",
  "enrichProfileDetails": true
}
```

Start enriched runs with 25 to 100 results. Enrichment requires an additional profile lookup for every discovered user and therefore increases both duration and cost.

### Output without enrichment

Each dataset row includes the relationship and the basic profile information available in the followers or following response:

```json
{
  "username_scrape": "public_account",
  "type": "Followers",
  "id": "123456789",
  "username": "discovered_user",
  "full_name": "Discovered User",
  "is_private": false,
  "is_verified": false,
  "profile_pic_url": "https://..."
}
```

### Output with enrichment

Successful enrichment can add the following fields:

```json
{
  "username_scrape": "public_account",
  "type": "Followers",
  "id": "123456789",
  "username": "discovered_creator",
  "full_name": "Discovered Creator",
  "is_private": false,
  "is_verified": false,
  "profile_pic_url": "https://...",
  "profile_enriched": true,
  "biography": "Creator and photographer",
  "follower_count": 18420,
  "following_count": 715,
  "media_count": 326,
  "country": "US"
}
```

| Enriched field | Description |
|---|---|
| `profile_enriched` | Whether useful enrichment data was returned. |
| `biography` | Current public profile biography. |
| `follower_count` | Current number of followers. |
| `following_count` | Current number of accounts followed. |
| `media_count` | Current number of published posts. |
| `country` | Country returned by the profile lookup, when available. |
| `date_joined` | Join information returned by the profile lookup, when available. |

Existing fields such as `full_name`, `is_private`, `is_verified`, and `profile_pic_url` are refreshed when current values are available.

If enrichment fails for an individual profile, the Actor keeps the basic row and sets `profile_enriched` to `false`. That row is not charged as an enrichment.

### Continuation tokens

When more pages are available, the run `OUTPUT` contains a `nextContinuationToken`. Use it in a new run with:

- exactly one source account;
- the same account that generated the token;
- the same `dataToScrape` value; and
- a new `resultsLimit` for the next batch.

```json
{
  "Account": ["the_same_public_account"],
  "resultsLimit": 1000,
  "dataToScrape": "Followers",
  "continuationToken": "cursor_xxxxxxxxxxxxxxxxx",
  "enrichProfileDetails": true
}
```

Provider cursors are never exposed. The public continuation token references protected state stored by the Actor.

### Pricing

The Actor uses two value-based events:

| Event | When it is charged |
|---|---|
| Dataset result | Once when a valid follower or following row is written to the default dataset. |
| Profile enrichment | Once when useful additional profile data is successfully returned for that row. |

The enrichment event is used only when `enrichProfileDetails` is enabled. Failed lookups, retries, empty responses, and base-only rows are not charged as enrichments. A backup lookup does not create a second enrichment charge.

The Actor checks the available run budget before starting paid enrichment and stops safely when the charge limit cannot fund the next operation.

Review the Actor Pricing tab for the current event prices and plan discounts.

### Free users and API usage

To reduce automated abuse of the free tier, free users who start the Actor through the API can receive at most 1,000 results per run. Run it from the Apify Console to use the full free budget available to the account. Paid users are governed by their configured result limit and available run charge budget.

### Current Instagram limitations

Instagram controls the availability and pagination of follower and following lists.

- Verified profiles may return only an initial partial follower list without a cursor.
- Public non-verified profiles can normally paginate, but the number of available rows can still be lower than the displayed follower count.
- Private, restricted, deleted, or unavailable profiles can return no results.
- Instagram can change page sizes, cursors, and availability without notice.

The Actor preserves every unique row already delivered, avoids charging duplicate rows, and stops instead of repeatedly requesting an unavailable cursor.

### Recommended workflow

1. Test one target account with 25 to 100 results.
2. Confirm that Instagram supplies pagination for that profile.
3. Enable enrichment only when profile-level metrics are needed.
4. Increase the result limit gradually for larger exports.
5. Use the continuation token to split very large downloads across controlled runs.

### Responsible use

Use the Actor only for legitimate research, analytics, and business workflows. Process personal data according to applicable laws, Instagram terms, and your own privacy obligations. Do not use the output for spam, harassment, discrimination, or unauthorized profiling.

### Support

When reporting an issue, include the Actor run ID, the public input, and the exported full log. Never publish continuation tokens or private credentials in an issue.

# Actor input Schema

## `Account` (type: `array`):

Instagram usernames or profile URLs to process, one per line.

## `resultsLimit` (type: `integer`):

Maximum followers or following profiles to return per source account. Instagram availability and pagination can produce fewer results.

## `dataToScrape` (type: `string`):

Choose whether to download followers or accounts followed by each source profile.

## `enrichProfileDetails` (type: `boolean`):

Add current follower and following counts, biography, post count, and other available profile details. Each successfully enriched profile creates an additional paid event. Failed lookups are not charged.

## `continuationToken` (type: `string`):

Optional. Continue a previous extraction using the token returned in OUTPUT. Only one account is allowed when a continuation token is used.

## Actor input object example

```json
{
  "Account": [
    "mrbeast"
  ],
  "resultsLimit": 200,
  "dataToScrape": "Followers",
  "enrichProfileDetails": false
}
```

# Actor output Schema

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

Scraped Instagram followers/following records stored in the 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 = {
    "Account": [
        "mrbeast"
    ],
    "resultsLimit": 200
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraping_solutions/instagram-scraper-followers-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 = {
    "Account": ["mrbeast"],
    "resultsLimit": 200,
}

# Run the Actor and wait for it to finish
run = client.actor("scraping_solutions/instagram-scraper-followers-following").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 '{
  "Account": [
    "mrbeast"
  ],
  "resultsLimit": 200
}' |
apify call scraping_solutions/instagram-scraper-followers-following --silent --output-dataset

```

## MCP server setup

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

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/8e6Zw7mxkzJlo1fAA/builds/wg9mTywBJAV4PY2vK/openapi.json