# Instagram Profile Scraper – Links & Stats (`chronometrica/instagram-channel-scraper`) Actor

Get clean public Instagram profile rows from URLs and handles, with stable IDs, audience stats, bio links, business details, and clear status.

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

## Pricing

from $1.60 / 1,000 profiles

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 Profile Scraper – Links & Stats

### 📊 What does Instagram Profile Scraper do?

Paste public Instagram profile URLs or handles and get clean profile data in
bulk. Use it to enrich creator lists, compare audiences, collect public bio
links, and connect public identity records.

Every unique input gets one flat, matched row. The row keeps the original
`input`, canonical `channelUrl`, stable IDs, profile facts, public links,
audience counts, quality labels, and a clear `status` and `statusReason`.

This Actor does not log in, use cookies, collect posts, access private profile
content, return follower lists, or bypass Instagram access controls. It reads
public profile surfaces only.

With Instagram Profile Scraper, you can:

- 🆔 Match profiles with Instagram IDs, EIMU IDs, Meta-linked IDs, and handles.
- 📈 Compare follower, following, post, and highlight counts.
- 🔎 Detect email-like text and web links in the public bio.
- 🔗 Find public bio links, mentions, and outside identity links.
- 🏢 Keep public business address, category, and account settings.
- 🛡️ Keep public business, professional, verification, and privacy signals.
- 🚦 Get clear status rows when a profile is missing or unavailable.
- 📦 Export results as JSON, JSONL, CSV, Excel, XML, RSS, or HTML.

### 📦 What Instagram profile data can I extract?

Each dataset row represents one attempted Instagram profile input.

| Data group      | Example fields                                                        |
| --------------- | --------------------------------------------------------------------- |
| 🆔 Identity     | `channelId`, `eimuId`, `fbid`, `channelUrl`, `handle`                 |
| 🧾 Profile      | `displayName`, `description`, `pronouns`, `category`                  |
| 🔎 Detected     | `detectedEmails`, `detectedLinks`                                     |
| 🔗 Public links | `externalUrl`, `bioLinks`, `biographyEntities`                        |
| 🏢 Business     | `businessAddress`, `businessContactMethod`, public account settings   |
| 🛡️ Flags        | business, professional, verified, private, embed, and channel signals |
| 📊 Counts       | `followersCount`, `followingCount`, `postsCount`, `highlightsCount`   |
| 🚦 Result       | `status`, `statusReason`, `observedAt`                                |

Missing public values stay `null`. Instagram's `fbid` is a Meta-linked value;
it is not a Facebook Page ID.

### ⚙️ Can I use this Actor through an API?

Yes. Run it in Apify Console or through the Apify API, Python SDK, Node.js SDK,
webhooks, schedules, and Apify integrations.

### 🎯 Why collect Instagram creator profiles?

| Use case              | How the data helps                                                   |
| --------------------- | -------------------------------------------------------------------- |
| 📋 Creator enrichment | Add stable IDs, audience size, bio, and links to creator records.    |
| 📣 Campaign planning  | Compare public reach, category, account type, and profile links.     |
| 🛍️ Creator commerce   | Find public business and professional signals for partnership work.  |
| 🔗 Identity matching  | Use bio links and Meta-linked IDs as evidence across public systems. |
| 🧱 Data products      | Load normalized creator rows into CRMs, dashboards, and databases.   |

### 💵 Pricing

Each useful profile row triggers one `profile` event. Prices per 1,000 useful
rows are:

| Plan                    | Price |
| ----------------------- | ----: |
| Free                    | $2.50 |
| Bronze                  | $2.20 |
| Silver                  | $1.90 |
| Gold, Platinum, Diamond | $1.60 |

Apify platform usage is charged separately. There is no paid Actor start event.
One useful row is an `ok` or `partial` profile snapshot written to the default
dataset. Invalid, missing, blocked, and failed inputs are not charged as profile
results. Each dataset row includes `isBillable` so this rule is visible.

### 🚀 How do I use Instagram Profile Scraper?

1. Open **Instagram Profile Scraper – Links & Stats** in Apify Console.
2. Paste one or more public profile URLs or handles.
3. Click **Start**.
4. Open **Output** to inspect the rows and run summary.
5. Download the dataset or connect it to your workflow.

### ⬇️ Input

Add 1 to 1,000 values in `startUrls`:

```json
{
  "startUrls": ["https://www.instagram.com/mrbeast/", "@hikakin"]
}
````

Accepted inputs include public profile URLs, `@handles`, and plain handles.
Post, Reel, Story, Explore, API, login, and site-navigation routes are rejected.
Exact duplicate values run once.

### ⬆️ Output sample

```json
{
  "platform": "instagram",
  "input": "https://www.instagram.com/mrbeast/",
  "channelId": "2278169415",
  "fbid": "17841402202464771",
  "channelUrl": "https://www.instagram.com/mrbeast/",
  "handle": "@mrbeast",
  "displayName": "MrBeast",
  "followersCount": 87783733,
  "countPrecision": {
    "followersCount": "exact"
  },
  "status": "ok",
  "statusReason": null,
  "observedAt": "2026-07-16T00:00:00.000Z"
}
```

#### 📌 Run summary

The `OUTPUT` record reports input counts, output rows, billable rows, status
counts, useful rates, and run time. It does not contain raw pages, cookies, or
private request details.

### 🎯 Status and quality fields

- `ok`: Instagram exposed full target profile identity.
- `partial`: useful public profile facts were found, but stable identity or
  other facts are missing.
- `private`, `login_required`, or `not_found`: the public profile could not be
  read as a normal useful row.
- `blocked`, `challenge`, or `rate_limited`: Instagram refused the public
  request at that time.
- `parser_miss`: a response loaded, but the Actor could not safely tie it to
  the requested profile.
- `invalid_input` or `failed`: the input was not a profile or the request failed.

### 🔒 Source boundary and limits

- Public logged-out profile surfaces only.
- `detectedEmails` and `detectedLinks` are unverified clues from the public bio
  and public link fields. They can be missing or wrong.
- The Actor does not open or crawl detected links.
- Direct email and phone fields stay `null` unless Instagram exposes them.
- Full follower and following lists are not returned.
- Public profiles can hide counts, links, categories, and business options.
- Instagram can change or limit public profile responses by time and region.

### ❓ FAQ

#### Does this Actor need login, cookies, or an API key?

No.

#### Is `fbid` the Facebook Page ID?

No. It is a Meta-linked Instagram value. Do not join it directly to a Facebook
Page ID without separate identity evidence.

#### How are duplicates handled?

Exact duplicate inputs are checked once. Use `channelId` as the strongest
cross-run dedupe key when it is present.

### 🛟 Support

Send the run ID, input URL, expected profile, and observed row. Do not send
passwords, cookies, or account credentials.

### 🔗 Related social media scrapers

Combine this Actor with our other social media scrapers for discovery,
performance tracking, comment research, and transcript collection.

#### YouTube

- [YouTube Search Scraper](https://apify.com/chronometrica/youtube-search-scraper)
  — find public videos, Shorts, channels, and metrics by keyword.
- [YouTube Metrics Scraper](https://apify.com/chronometrica/youtube-metrics-scraper)
  — collect public video, Short, channel, and engagement metrics.
- [YouTube Comments Scraper](https://apify.com/chronometrica/youtube-comments-scraper)
  — collect public comments, replies, authors, likes, pins, and creator hearts.
- [YouTube Transcript Scraper](https://apify.com/chronometrica/youtube-transcript-scraper)
  — extract public captions as clean text, timestamps, SRT, VTT, or LLM-ready
  output.

#### Facebook

- [Facebook Metrics Scraper](https://apify.com/chronometrica/facebook-metrics-scraper)
  — collect public post, Reel, video, and profile/page metrics.
- [Facebook Comments Scraper](https://apify.com/chronometrica/facebook-comments-scraper)
  — collect public comments, replies, authors, dates, and reactions from known
  Facebook content.

#### Instagram

- [Instagram Metrics Scraper](https://apify.com/chronometrica/instagram-metrics-scraper)
  — collect public post, Reel, carousel, profile, and collaboration metrics.
- [Instagram Comments Scraper](https://apify.com/chronometrica/instagram-comments-scraper)
  — collect public comments, authors, dates, likes, and reply counts from posts
  and Reels.

#### TikTok

- [TikTok Search Scraper](https://apify.com/chronometrica/tiktok-search-scraper)
  — find public TikTok videos, creators, and metrics by keyword.
- [TikTok Metrics Scraper](https://apify.com/chronometrica/tiktok-metrics-scraper)
  — collect public video, profile, engagement, hashtag, and music data.
- [TikTok Comments Scraper](https://apify.com/chronometrica/tiktok-comments-scraper)
  — collect public comments, replies, authors, likes, and thread links.
- [TikTok Transcript Scraper](https://apify.com/chronometrica/tiktok-transcript-scraper)
  — extract public caption text and timestamped segments from TikTok videos.

# Actor input Schema

## `startUrls` (type: `array`):

Add 1 to 1,000 public Instagram profile URLs or handles. Duplicate inputs are checked once. Each unique input creates one result row and adds usage.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.instagram.com/mrbeast/"
  ]
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `summary` (type: `string`):

No description

# 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 = {
    "startUrls": [
        "https://www.instagram.com/mrbeast/"
    ]
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = { "startUrls": ["https://www.instagram.com/mrbeast/"] }

# Run the Actor and wait for it to finish
run = client.actor("chronometrica/instagram-channel-scraper").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 '{
  "startUrls": [
    "https://www.instagram.com/mrbeast/"
  ]
}' |
apify call chronometrica/instagram-channel-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Profile Scraper – Links & Stats",
        "description": "Get clean public Instagram profile rows from URLs and handles, with stable IDs, audience stats, bio links, business details, and clear status.",
        "version": "0.1",
        "x-build-id": "LNkIzCeCgI5aSHibI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/chronometrica~instagram-channel-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-chronometrica-instagram-channel-scraper",
                "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/chronometrica~instagram-channel-scraper/runs": {
            "post": {
                "operationId": "runs-sync-chronometrica-instagram-channel-scraper",
                "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/chronometrica~instagram-channel-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-chronometrica-instagram-channel-scraper",
                "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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Instagram profile URLs or handles",
                        "minItems": 1,
                        "maxItems": 1000,
                        "type": "array",
                        "description": "Add 1 to 1,000 public Instagram profile URLs or handles. Duplicate inputs are checked once. Each unique input creates one result row and adds usage.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "https://www.instagram.com/mrbeast/"
                        ]
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
