# Instagram User Followers Scraper ✅ (`datamagnet/instagram-followers-export`) Actor

Collect Instagram follower profiles from a username, user ID, or profile URL in a simple export. Choose how many followers to fetch, and get the raw follower records exactly as returned, with pagination handled automatically until your limit is reached.

- **URL**: https://apify.com/datamagnet/instagram-followers-export.md
- **Developed by:** [Datamagnet](https://apify.com/datamagnet) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 3 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 Followers Export Scraper

Instagram Followers Export is a simple Instagram followers scraper and data collector for anyone who needs follower profiles in a clean export. Enter a username, user ID, or profile URL, choose how many followers you want, and get the records back exactly as they are provided by the source. It is ideal for marketers, creators, agencies, and researchers who want to analyze Instagram audience data without manual copying or spreadsheet work. Use it to quickly collect Instagram follower data for reporting, audience research, lead qualification, or competitive analysis.

### Key Features

- **Extract** follower profiles from any Instagram username, user ID, or profile URL.
- **Collect** only the number of followers you need, from a small sample to a larger export.
- **Export** follower records in a format that is easy to review, filter, and share.
- **Preserve** the original follower details exactly as they are returned, so you see the source data without changes.
- **Handle** pagination automatically, so the actor keeps gathering followers until your target amount is reached or no more results are available.
- **Support** practical audience research workflows for marketing, sales, creator analysis, and brand monitoring.
- **Save** time by replacing manual profile checking with a fast, repeatable follower export.

### Use Cases

#### Audience Research
Marketing teams use this Instagram followers extractor to understand who follows a creator, brand, or public profile. The exported fields like `username`, `full_name`, `is_verified`, and `is_private` help teams spot audience patterns, identify public versus private accounts, and get a clearer picture of the follower base.

#### Influencer Vetting
Agencies and brands can review follower profiles before partnering with a creator. By looking at `username`, `full_name`, `profile_pic_url`, and verification status, they can quickly assess whether the audience looks relevant and whether the follower list appears consistent with the creator’s niche.

#### Lead List Building
Sales and partnership teams often need a starting point for outreach research. This export gives them follower profile records they can review manually to find accounts that may be relevant to their campaign, event, or collaboration goals, using visible profile details to prioritize the best prospects.

#### Competitive Analysis
Businesses tracking competitors can collect follower profiles from competitor accounts to understand audience overlap and community makeup. Fields such as `id`, `username`, and `is_verified` make it easier to compare follower groups across multiple profiles and spot notable accounts in the audience.

#### Community Monitoring
Social media managers can use the export to keep an eye on follower changes around launches, campaigns, or viral posts. The data helps them see the kinds of accounts engaging with a profile and gives them a practical way to review follower quality over time.

#### Research and Reporting
Analysts and consultants can use the raw follower records in reports, dashboards, or internal studies. Because the actor returns the follower data as provided, it is useful when you want a straightforward export for documentation, trend analysis, or audience segmentation.

### Input

| Field | Type | Required | Description | Example |
|---|---|---:|---|---|
| Username, user ID, or profile URL | string | Yes | Enter the Instagram account you want followers from. You can paste a username, numeric user ID, or profile URL. | mrbeast |
| Max results | integer | No | Set the maximum number of followers to collect. The actor keeps fetching more followers until it reaches this number or runs out of results. | 50 |

### Output

| Field | Type | Description |
|---|---|---|
| full_name | string | The follower’s display name, which can help you recognize the person or account at a glance. |
| id | string | The follower’s unique account identifier, useful for matching records or comparing audiences. |
| is_private | boolean | Shows whether the follower’s account is private, which helps you understand how visible the profile is. |
| is_verified | boolean | Shows whether the follower has a verified account, which can be useful for spotting notable profiles. |
| latest_story_ts | number | A timestamp related to the follower’s latest story activity, if available from the source. |
| profile_pic_url | string | The follower’s profile picture link, useful for visual review or record enrichment. |
| username | string | The follower’s Instagram handle, which is the easiest way to identify and search for the account. |

### Sample Output

```json
{
  "full_name": "Janna Tul",
  "id": "69702325211",
  "is_private": false,
  "is_verified": false,
  "latest_story_ts": 0,
  "profile_pic_url": "https://scontent-cph2-1.cdninstagram.com/v/t51.82787-19/670005525_17920000122325212_7882711924163456377_n.jpg?stp=dst-jpg_e0_s150x150_tt6&efg=eyJ2ZW5jb2RlX3RhZyI6InByb2ZpbGVfcGljLmRqYW5nby4xMDgwLmMyIn0&_nc_ht=scontent-cph2-1.cdninstagram.com&_nc_cat=100&_nc_oc=Q6cZ2gG2An63S8bScwCUL1daO7NxDEHe0tbPMhT...",
  "username": "janna.tul39"
}
````

### How It Works

1. You enter the Instagram username, user ID, or profile URL you want to collect followers from.
2. You choose how many follower records you want, or leave the default if you only need a small export.
3. The actor gathers follower profiles automatically and keeps going until it reaches your requested amount.
4. If there are more followers available, it continues collecting them without you needing to do anything.
5. When it finishes, you receive the follower records in a clean export that you can review, download, or use in your workflow.

### Getting Started

Getting started is easy and does not require coding. Click **Try for free**, paste the Instagram username, user ID, or profile URL you want to collect from, choose the maximum number of followers, and click **Run**. In a short time, your results will be ready for download and review. You can export the data as **JSON, CSV, or Excel**, making it simple to use in spreadsheets, reports, or other business tools.

### Frequently Asked Questions

#### Do I need technical skills?

No. This actor is designed for non-technical users. You only need to provide the Instagram account you want to collect from and choose how many followers you want.

#### How fast does it run?

Speed depends on how many follower records you request and how much data is available. Smaller exports finish quickly, while larger requests naturally take longer because the actor keeps collecting more followers until it reaches your limit.

#### What format is the output?

You can download the results in common formats such as JSON, CSV, or Excel. That makes it easy to open the data in a spreadsheet, share it with your team, or import it into your reporting workflow.

#### Is this legal to use?

You should always use data collection tools in a way that follows applicable laws, platform rules, and your organization’s policies. This actor is intended for legitimate research, analysis, and business workflows, and you are responsible for using the results appropriately.

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

Yes. If you want regular follower exports, you can schedule runs so the actor collects data on a recurring basis. This is useful for ongoing audience tracking, campaign monitoring, and periodic reporting.

# Actor input Schema

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

Set the maximum number of followers to collect.

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

Enter the Instagram account you want followers from. You can paste a username, numeric user ID, or profile URL.

## 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-followers-export").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-followers-export").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-followers-export --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram User Followers Scraper ✅",
        "description": "Collect Instagram follower profiles from a username, user ID, or profile URL in a simple export. Choose how many followers to fetch, and get the raw follower records exactly as returned, with pagination handled automatically until your limit is reached.",
        "version": "0.0",
        "x-build-id": "Hoyddp2DyOT16zfxm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datamagnet~instagram-followers-export/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datamagnet-instagram-followers-export",
                "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-followers-export/runs": {
            "post": {
                "operationId": "runs-sync-datamagnet-instagram-followers-export",
                "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-followers-export/run-sync": {
            "post": {
                "operationId": "run-sync-datamagnet-instagram-followers-export",
                "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": "Max results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Set the maximum number of followers to collect."
                    },
                    "username_or_id_or_url": {
                        "title": "Username, user ID, or profile URL",
                        "type": "string",
                        "description": "Enter the Instagram account you want followers from. You can paste a username, numeric user ID, or profile URL."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```