# Instagram Bot Detector (`scrapers-hub/instagram-bot-detector`) Actor

Scan and identify automated accounts, bots, and fake profiles on Instagram using advanced Instagram Bot Detector, engagement heuristics and profile analysis.

- **URL**: https://apify.com/scrapers-hub/instagram-bot-detector.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:** Social media, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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 Bot Detector

The Instagram Bot Detector is a focused Instagram bot detection tool that analyzes public profiles to flag likely automation using engagement heuristics and profile signals. It helps you identify bot accounts and detect fake followers on Instagram with data-driven metrics, making it a practical Instagram bot checker for marketers, analysts, and researchers. Use it to run an Instagram follower audit at scale and make faster decisions about audience quality and campaign partners.

### What Datas Can you Extract from it?

This actor outputs a structured JSON record for each Instagram username you analyze. It focuses on clear, actionable metrics that help you identify bot-like patterns and assess follower quality.

| Data type | Description | Example value |
| --- | --- | --- |
| userId | The account’s internal Instagram ID | "1234567890" |
| username | Handle of the analyzed profile | "authentic_user" |
| fullName | Public display name | "Jane Doe" |
| followers | Number of followers | 15400 |
| following | Number of accounts followed | 850 |
| posts | Total posts on the profile | 420 |
| isVerified | Official verification (blue check) | false |
| isPrivate | Whether the account is private | false |
| followerFollowingRatio | Followers divided by following (or followers if following is 0) | 18.12 |
| usernameEntropy | Normalized Shannon entropy of the username (randomness) | 0.24 |
| averageEngagementRate | Average (likes + comments) per post divided by followers | 0.045 |
| isLikelyBot | Quick boolean flag summarizing the signals | false |

You can export results to JSON directly from the Apify dataset and easily convert to CSV or Excel for reporting.

### Key features

Get fast, reliable signals to identify bot accounts on Instagram and run authenticity audits at scale.

| Feature | Description |
| --- | --- |
| 🔐 No Login Needed | Analyzes public profiles without cookies or account authentication, making it safe and simple to run. |
| 🧠 Username Entropy Analytics | Calculates normalized Shannon entropy to spot procedurally generated usernames often used by bots. |
| 📈 Engagement & Timing Analysis | Computes average engagement and post timing variance from up to 12 recent posts to flag suspicious patterns. |
| 🧮 Follower Ratio Scoring | Measures follower/following balance to identify follow-unfollow patterns and low-quality networks. |
| 🛰️ Dynamic APP_ID Extraction | Automatically fetches the latest Instagram APP_ID before requests for better stability. |
| 🕵️ Chrome-like Session | Uses a Chrome-impersonated HTTP session for more reliable access to public endpoints. |
| 🌐 Proxy-Friendly | Integrates with Apify Proxy; supports residential or datacenter proxies configured at run time. |
| 🧳 Bulk Username Input | Accepts an array of usernames in one run, ideal for batch Instagram follower audits. |
| 🕒 Rate-Limit Aware | Adds randomized 2–5 second delays between profiles to reduce blocking risk. |
| 🧾 Clean JSON Output | Pushes structured records to the Apify dataset for easy integration with dashboards and BI tools. |

### How to use Instagram Bot Detector - Step By Step

1. Sign in to Apify and open the Instagram Bot Detector actor.
2. Prepare a list of target Instagram handles (without “@”). Example: ["instagram", "therock"].
3. In the actor’s Input tab, paste your list into the usernames field (string list editor).
4. Optional: In run settings, enable Apify Proxy (residential or datacenter) for higher stability on larger batches.
5. Start the run. The actor will fetch profile data, analyze engagement and timing for up to 12 recent posts, and compute risk metrics.
6. Monitor the live logs to see progress as each handle is analyzed.
7. When finished, open the Dataset tab to view results. Export JSON for APIs or download CSV/Excel for analysis.
8. Pro Tip: Schedule runs or connect the dataset to your pipeline via the Apify API to automate your Instagram follower audit tool workflow.

### Use cases

| Use case name | Description |
| --- | --- |
| Influencer marketing – Instagram follower audit tool | Evaluate partners by reviewing followerFollowingRatio, averageEngagementRate, and fakeInfluencerScore before you spend budget. |
| Brand safety – Instagram spam account detector | Identify and remove low-quality followers to improve reach and protect brand integrity. |
| Campaign QA – Instagram engagement authenticity checker | Validate engagement patterns with post timing variance and entropy-based signals. |
| Competitive research – Instagram bot activity analyzer | Compare profiles in your niche to spot inorganic growth and automation patterns. |
| Data ops – API pipeline for audits | Feed JSON results into BI dashboards or CRMs and trigger actions when isLikelyBot is true. |
| Academic studies – identify bot accounts on Instagram | Analyze usernameEntropy and network ratios to study platform health across cohorts. |
| Fraud screening – Instagram fake follower checker | Flag high fakeInfluencerScore profiles to avoid inflated reach in sponsorships. |

### Why choose Instagram Bot Detector?

Built for precision, automation, and reliability, this Instagram bot detection tool delivers clean, structured signals without browser add-ons or risky hacks.

- ✅ Accurate public-signal analysis: entropy, ratios, engagement, and timing
- 🔄 Stable requests with dynamic APP_ID extraction and Chrome-like sessions
- 🌐 Scales with Apify Proxy for larger batches and fewer blocks
- 🧳 Bulk input and one-click exports to JSON, CSV, or Excel
- 🧩 Developer-friendly datasets for API, Python, or automation workflows
- 🛡️ No cookies or login needed, reducing risk and complexity
- 💸 Cost-effective alternative to unstable browser extensions and manual checks

In short: a robust Instagram bot checker vs fragile extension-based approaches.

### Is it legal / ethical to use Instagram Bot Detector?

Yes—when used responsibly. This actor analyzes publicly available Instagram profile data and does not access private profiles or require authentication.

Guidelines for responsible use:
- Collect and use only public information; avoid private or gated data.
- Comply with data protection laws such as GDPR and CCPA.
- Respect Instagram’s terms and applicable regulations in your jurisdiction.
- Consult your legal team for edge cases or large-scale deployments.

The actor does not log into accounts, scrape private content, or bypass authentication.

### Input parameters & output format

Example input
```json
{
  "usernames": [
    "instagram",
    "therock"
  ]
}
````

Input parameters

| Field | Required | Description |
| --- | --- | --- |
| usernames | Yes | List of Instagram handles to analyze. Enter plain usernames without the “@” symbol. Works best with public profiles. |

Example JSON output

```json
{
  "userId": "1234567890",
  "username": "authentic_user",
  "fullName": "Jane Doe",
  "profilePicUrl": "https://scontent.cdninstagram.com/profilepic.jpg",
  "biography": "Coffee and code.",
  "externalUrl": "https://janedoe.com",
  "followers": 15400,
  "following": 850,
  "posts": 420,
  "isVerified": false,
  "isBusinessAccount": true,
  "isProfessionalAccount": true,
  "isPrivate": false,
  "highlightReelCount": 12,
  "hasClips": true,
  "defaultProfilePic": false,
  "followerFollowingRatio": 18.1176470588,
  "usernameEntropy": 0.245,
  "averageEngagementRate": 0.0452,
  "postTimingVariance": 86400.0,
  "profilePicScore": 0.0,
  "biographyScore": 0.0,
  "postsScore": 0.0,
  "highlightsScore": 0.0,
  "followersScore": 0.0,
  "followingScore": 0.1,
  "ratioScore": 0.0,
  "usernameScore": 0.1,
  "accountAgeScore": 0.0,
  "accountTypeScore": 0.0,
  "verifiedScore": 0.1,
  "postTimingScore": 0.0,
  "engagementScore": 0.52,
  "spamScore": 0.0,
  "fullNameScore": 0.0,
  "fakeInfluencerScore": 0.0,
  "botScore": 0.0,
  "humanScore": 1.0,
  "confidence": 1,
  "isLikelyBot": false
}
```

### FAQ

#### Do I need to log in or provide cookies to run this?

✅ No. The actor analyzes public Instagram profiles without login or cookies. It uses a Chrome-like HTTP session and public endpoints to retrieve data.

#### How many usernames can I analyze in one run?

✅ There’s no hard-coded limit in the actor. You can pass as many usernames as you need, but larger lists will take longer and may benefit from Apify Proxy to reduce blocking.

#### What does the tool check to detect bots?

🧠 It computes usernameEntropy, followerFollowingRatio, averageEngagementRate, and postTimingVariance from recent posts, plus a set of heuristic scores (e.g., verifiedScore, usernameScore, fakeInfluencerScore) to help identify automation patterns.

#### Can it detect fake followers on Instagram for influencer vetting?

✅ Yes. Use metrics like averageEngagementRate, followerFollowingRatio, and fakeInfluencerScore to assess authenticity. This makes it a practical Instagram follower quality checker and Instagram fake engagement detector.

#### Will it work on private accounts?

⚠️ Partially. The actor can retrieve high-level profile fields (e.g., isPrivate, counts), but it may not access post-level data for private profiles. As a result, engagement and timing metrics can be limited.

#### Is there an API or Python integration?

💻 Yes. Results are stored in the Apify dataset, which you can access via the Apify API. This supports downstream automation and Python-based pipelines for an Instagram account authenticity audit.

#### Do I need to use proxies?

🔌 Not strictly, but recommended for larger batches. The actor supports Apify Proxy and will use your configured proxy automatically to improve stability and reduce blocks.

#### What formats can I export to?

💾 You can export dataset results as JSON by default and download CSV or Excel for analysis and reporting. This supports audits, research, and integration into CRM/BI tools.

### Closing CTA / Final thoughts

The Instagram Bot Detector is built to identify bot accounts on Instagram using public signals and engagement heuristics. With entropy-based username checks, ratio analysis, and timing/engagement metrics, it functions as a reliable Instagram bot detection tool for marketers, analysts, and researchers. Run bulk audits, export clean datasets, and integrate via API for automation. Start now to detect fake followers on Instagram and keep your campaigns focused on authentic engagement.

# Actor input Schema

## `usernames` (type: `array`):

Enter the Instagram usernames you want to analyze.

## Actor input object example

```json
{
  "usernames": [
    "instagram",
    "therock"
  ]
}
```

# 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 = {
    "usernames": [
        "instagram",
        "therock"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/instagram-bot-detector").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 = { "usernames": [
        "instagram",
        "therock",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/instagram-bot-detector").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 '{
  "usernames": [
    "instagram",
    "therock"
  ]
}' |
apify call scrapers-hub/instagram-bot-detector --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Bot Detector",
        "description": "Scan and identify automated accounts, bots, and fake profiles on Instagram using advanced Instagram Bot Detector, engagement heuristics and profile analysis.",
        "version": "1.0",
        "x-build-id": "XA4p79BXRcXkTyOOz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapers-hub~instagram-bot-detector/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapers-hub-instagram-bot-detector",
                "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/scrapers-hub~instagram-bot-detector/runs": {
            "post": {
                "operationId": "runs-sync-scrapers-hub-instagram-bot-detector",
                "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/scrapers-hub~instagram-bot-detector/run-sync": {
            "post": {
                "operationId": "run-sync-scrapers-hub-instagram-bot-detector",
                "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": [
                    "usernames"
                ],
                "properties": {
                    "usernames": {
                        "title": "Usernames",
                        "type": "array",
                        "description": "Enter the Instagram usernames you want to analyze.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
