# Instagram Creator Analyzer — Influencer Intelligence & Engag... (`apricot_blackberry/instagram-creator-analyzer`) Actor

Vet any Instagram creator before you pay them. One username returns engagement rate, audience authenticity, niche, posting cadence, and a per-post sponsorship estimate — merged across 7 sources so one site change can’t blind you. No login, no cookies.

- **URL**: https://apify.com/apricot\_blackberry/instagram-creator-analyzer.md
- **Developed by:** [Creator Fusion](https://apify.com/apricot_blackberry) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 100 total users, 13 monthly users, 100.0% runs succeeded, 3 bookmarks
- **User rating**: No ratings yet

## Pricing

from $80.00 / 1,000 profile analyzeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Creator Analyzer — Engagement, Niche & Sponsorship Data API for AI Agents

Instagram creator and influencer analytics without login, cookies, or an official API key. Give it usernames or profile URLs; it returns **typed JSON rows — schema below** — with profile stats (followers, following, posts), engagement rate, content mix, posting cadence, detected niche, and a per-post sponsorship value estimate. Extraction survives Instagram changes by falling back across 7 independent sources (Google, Social Blade, Instagram direct, Ninjalitics, Bing, DuckDuckGo, Wayback Machine) and merging the results with outlier rejection — most single-source Instagram scrapers break the moment one site changes its markup.

### Why AI agents use this Instagram creator analyzer

- **Deterministic typed output** — every row follows the dataset schema (`profile` / `analysis` / `meta` objects); no HTML, no free-text parsing needed.
- **Honest degradation** — when post data cannot be fetched, `posting.frequency` is `"unknown"` and engagement-based sponsorship adjustments are skipped, never faked. `meta.dataCompleteness` (0–100) tells you exactly how much was recovered.
- **Clear error semantics** — failures are per-profile rows with `analysis: null` and a `Fatal error: ...` warning; the per-method attempt log (`meta.methodResults`) shows what was tried and why it failed.
- **No auth needed** — no Instagram account, session cookies, or API keys. Multi-source fallback keeps working when any single source blocks.
- **Rate-limit handling built in** — randomized delays between profiles and sources, per-method and per-profile time budgets, rotating browser fingerprints.

### Input schema

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `usernames` | array of strings | yes | – | Instagram usernames or profile URLs to analyze (e.g. `"natgeo"` or `"https://instagram.com/natgeo"`) |
| `includeRecentPosts` | boolean | no | `true` | Fetch and analyze recent posts for engagement metrics |
| `maxPostsPerProfile` | integer | no | `12` | Maximum recent posts to analyze (1–12) |
| `proxyConfiguration` | object | no | Apify proxy, `RESIDENTIAL` group | Proxy settings. Residential proxy is **only** spent on the Instagram-direct method (Instagram blocks datacenter IPs); all search-engine and aggregator fallbacks run over the direct connection. Residential proxy traffic is billed to your Apify account. |

Minimal input:

```json
{ "usernames": ["natgeo"] }
```

### Output schema

One dataset row per input username. Row shape: `{ profile, analysis, meta }`.

#### `profile` — raw merged profile data

| Field | Type | Nullable | Description |
|---|---|---|---|
| `profile.username` | string | no | Handle, lowercase, no `@` |
| `profile.id` | string | yes | Instagram internal user ID (instagram\_direct only) |
| `profile.fullName` | string | yes | Display name |
| `profile.biography` | string | yes | Bio text (may be a search-snippet approximation from fallback sources) |
| `profile.externalUrl` | string | yes | Link-in-bio URL |
| `profile.externalUrls` | array | yes | `{ title, url }` objects |
| `profile.followersCount` | number | yes | Followers (consensus across sources, outlier-rejected) |
| `profile.followsCount` | number | yes | Accounts followed |
| `profile.postsCount` | number | yes | Total posts (abbreviated counts like `30K` are expanded to `30000`) |
| `profile.isBusinessAccount` | boolean | yes | Business account flag |
| `profile.businessCategoryName` | string | yes | Business category |
| `profile.isPrivate` | boolean | yes | Private account flag |
| `profile.isVerified` | boolean | yes | Verified badge |
| `profile.profilePicUrl` / `profilePicUrlHD` | string | yes | Avatar URLs |
| `profile.relatedProfiles` | array | yes | `{ username, fullName, isVerified }` (instagram\_direct only) |
| `profile.latestPosts` | array | yes | Up to 12 posts: `{ id, shortCode, type, caption, hashtags, mentions, likesCount, commentsCount, videoViewCount, videoDuration, timestamp, displayUrl }`. Rich fields require instagram\_direct; search fallbacks may yield shortcodes only. |

#### `analysis` — derived analytics (null if the profile failed entirely)

| Field | Type | Nullable | Description |
|---|---|---|---|
| `analysis.audienceTier` | string | via null `analysis` | `nano` | `micro` | `mid` | `macro` | `mega` | `celebrity` |
| `analysis.engagement.rate` | number | – | (avg likes + avg comments) / followers × 100. `0` when no post data exists — absence of data, not low engagement |
| `analysis.engagement.avgLikesPerPost` | number | – | Average likes per analyzed post |
| `analysis.engagement.avgCommentsPerPost` | number | – | Average comments per analyzed post |
| `analysis.engagement.avgViewsPerReel` | number | yes (omitted) | Average views across video/reel posts |
| `analysis.engagement.likeToCommentRatio` | number | – | Avg likes / avg comments |
| `analysis.contentMix` | object | – | `{ images, videos, reels, carousels }` percentages |
| `analysis.posting.frequency` | string | – | `daily` | `every_few_days` | `weekly` | `biweekly` | `monthly` | `inactive` | `unknown` (`unknown` = no post data available) |
| `analysis.posting.avgPostsPerWeek` | number | – | Average posts per week |
| `analysis.posting.lastPostDate` | string | yes (omitted) | ISO 8601 timestamp of latest analyzed post |
| `analysis.posting.daysSinceLastPost` | number | yes (omitted) | Days since latest analyzed post |
| `analysis.niche` | array | – | Up to 3 detected niches (fitness, beauty, tech, finance, ...) |
| `analysis.shortsFocused` | boolean | – | True if >50% of analyzed posts are reels |
| `analysis.sponsorshipEstimate` | object | – | `{ low, medium, high, currency: "USD", adjustments }`. Tier-based per-post rate with every applied adjustment listed as a string. When no post data exists, engagement adjustments are skipped and noted in `adjustments`. |

#### `meta` — extraction metadata (always present)

| Field | Type | Description |
|---|---|---|
| `meta.scrapedAt` | string | ISO 8601 row timestamp |
| `meta.methodsUsed` | array | Methods that succeeded: `google`, `socialblade`, `instagram_direct`, `ninjalitics`, `bing`, `duckduckgo`, `wayback` |
| `meta.methodResults` | array | Per-method attempt log: `{ method, success, data, error, latencyMs }` |
| `meta.dataCompleteness` | number | 0–100 field-coverage score; `0` = profile failed |
| `meta.warnings` | array | Per-method failure messages and fatal errors |

#### Example row (successful profile)

```json
{
  "profile": {
    "username": "natgeo",
    "fullName": "National Geographic",
    "biography": "See Instagram photos and videos",
    "profilePicUrl": "https://scontent.cdninstagram.com/v/...",
    "followersCount": 268796119,
    "followsCount": 194,
    "postsCount": 30400,
    "isVerified": true
  },
  "analysis": {
    "audienceTier": "celebrity",
    "engagement": { "rate": 0, "avgLikesPerPost": 0, "avgCommentsPerPost": 0, "likeToCommentRatio": 0 },
    "contentMix": { "images": 0, "videos": 0, "reels": 0, "carousels": 0 },
    "posting": { "frequency": "unknown", "avgPostsPerWeek": 0 },
    "niche": ["photography"],
    "shortsFocused": false,
    "sponsorshipEstimate": {
      "low": 25000,
      "medium": 75000,
      "high": 150000,
      "currency": "USD",
      "adjustments": ["no post data: engagement adjustments skipped"]
    }
  },
  "meta": {
    "scrapedAt": "2026-08-15T04:15:33.564Z",
    "methodsUsed": ["google", "socialblade", "instagram_direct"],
    "methodResults": [
      { "method": "google", "success": true, "data": { "username": "natgeo" }, "latencyMs": 1672 },
      { "method": "socialblade", "success": true, "data": { "username": "natgeo", "followersCount": 268796119, "postsCount": 30400, "followsCount": 194 }, "latencyMs": 190 },
      { "method": "instagram_direct", "success": true, "data": { "username": "natgeo", "fullName": "National Geographic", "followersCount": 268000000, "followsCount": 195, "postsCount": 30000, "isVerified": true }, "latencyMs": 15705 }
    ],
    "dataCompleteness": 84,
    "warnings": []
  }
}
```

#### Example row (failed profile)

```json
{
  "profile": { "username": "some_unreachable_user" },
  "analysis": null,
  "meta": {
    "scrapedAt": "2026-08-15T04:20:00.000Z",
    "methodsUsed": [],
    "methodResults": [],
    "dataCompleteness": 0,
    "warnings": ["Fatal error: All extraction methods failed"]
  }
}
```

### Error semantics

- **Bad input** (missing/empty `usernames`): the run logs an `Invalid input` error and produces zero dataset items. Treat a run with zero items as failed.
- **Invalid username format**: skipped with a log warning; no row is produced for it.
- **Per-profile failure**: the run continues to the next username; the failed profile still gets a row with `analysis: null`, `meta.dataCompleteness: 0`, and the error in `meta.warnings`. Retry logic: retry only usernames whose row has `dataCompleteness === 0`.
- **Partial data**: sources that failed are listed in `meta.warnings` / `meta.methodResults`; the row is still produced from whatever succeeded. Check `meta.dataCompleteness` before trusting derived analytics.
- **Zero results**: a run where every profile failed still completes; detect via item count or `dataCompleteness` values.

### Use from AI agents (MCP)

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=apricot_blackberry/instagram-creator-analyzer",
      "headers": { "Authorization": "Bearer <YOUR_APIFY_TOKEN>" }
    }
  }
}
```

Works in Claude, Cursor, ChatGPT deep research connectors, and any MCP client; the input schema above is the tool's parameter schema.

### Use from code

curl:

```bash
curl -X POST "https://api.apify.com/v2/acts/apricot_blackberry~instagram-creator-analyzer/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"usernames": ["natgeo"], "includeRecentPosts": true, "maxPostsPerProfile": 6}'
```

JavaScript (`apify-client`):

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('apricot_blackberry/instagram-creator-analyzer').call({
  usernames: ['natgeo'],
  includeRecentPosts: true,
  maxPostsPerProfile: 6,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

Python (`apify_client`):

```python
from apify_client import ApifyClient
client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("apricot_blackberry/instagram-creator-analyzer").call(run_input={
    "usernames": ["natgeo"],
    "includeRecentPosts": True,
    "maxPostsPerProfile": 6,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

### Use from automation platforms

- **n8n / Make / Zapier**: use the native Apify integration and pick `instagram-creator-analyzer` by name.
- **LangChain / LlamaIndex**: use the Apify tool wrappers (`ApifyActorsTool` / Apify Actor loader) with the actor id above.
- **Webhooks**: Apify can fire a webhook when a run finishes (or on other run-lifecycle events), so you can trigger a downstream pipeline step the moment fresh creator data lands — configure one from the actor's Integrations tab or the API.

### Pricing & performance

Pay-per-event, billed by the Apify platform:

| Event | Price | Charged |
|---|---|---|
| Actor start | $0.10 | Once per run (1 GB memory) |
| Profile analyzed | $0.08 | Per creator row in the dataset |

A typical profile analyzes in well under a minute; a batch of 50 creators completes in a few minutes for roughly $0.10 + 50 × $0.08 = **$4.10** (~$0.082/creator). Residential proxy traffic (used only for the Instagram-direct method) is billed to your Apify account additionally. Rotation, rate limiting, and clean JSON output are included.

### Instagram creator analytics use cases

- **Brand managers / influencer marketers**: vet creators' real follower counts, engagement, and niche before committing budget.
- **Agencies**: report accurate creator metrics to clients with a documented per-source audit trail (`meta.methodResults`).
- **Talent scouts**: find emerging creators by tier (`nano` → `celebrity`) and posting cadence before they get expensive.
- **AI research agents**: pull structured creator data on demand via MCP — audience tier, engagement rate, and sponsorship estimates in one typed row.

### Works great with

- **[TikTok Profile Scraper](https://apify.com/apricot_blackberry/tiktok-profile-scraper)** — compare Instagram performance to TikTok.
- **[Audience Authenticity Audit](https://apify.com/apricot_blackberry/audience-authenticity-audit)** — deeper follower-quality analysis.
- **[Creator Discovery Engine](https://apify.com/apricot_blackberry/creator-discovery-engine)** — find creators before analyzing them.

### FAQ

**Does it need my Instagram login?** No. It never logs in and only reads public data. Private accounts return profile-level stats only (`isPrivate: true`).

**Why is engagement 0 for some profiles?** Post-level data requires the Instagram-direct method to succeed. When it doesn't, engagement fields are `0`, `posting.frequency` is `"unknown"`, and no engagement-based sponsorship adjustment is applied — the row tells you what it doesn't know instead of guessing.

**How accurate are follower counts?** Counts are merged across up to 7 sources with outlier rejection; abbreviated figures (e.g. `268M`) are expanded and cross-checked against exact values when available.

**Are sponsorship estimates guaranteed?** They are tier-based market estimates with every adjustment documented in `sponsorshipEstimate.adjustments`. Use them as a negotiation baseline, not a quote.

### Changelog

#### 2026-08-14

- **Output dataset schema published** (`.actor/dataset_schema.json`) — rows are now validated and render a clean Overview table; README restructured for AI-agent consumption (MCP snippet, exact field tables, error semantics).
- **Fixed abbreviated-count parsing**: `30K` / `268M` / `1.2B` style figures in Instagram og-tags, Wayback snapshots, and Social Blade pages now parse correctly; fixed a Social Blade field mix-up that could report the *following* count as the *posts* count.
- **Honest sponsorship estimates**: when no post data is available, the engagement-based adjustment is skipped (previously an unwarranted "low engagement −15%" was applied) and noted in `adjustments`.

# Actor input Schema

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

List of Instagram usernames or profile URLs to analyze

## `includeRecentPosts` (type: `boolean`):

Fetch and analyze recent posts for engagement metrics

## `maxPostsPerProfile` (type: `integer`):

Maximum number of recent posts to analyze (1-12)

## `proxyConfiguration` (type: `object`):

Proxy settings. Defaults to Apify RESIDENTIAL proxy, which is only used for the Instagram-direct method (Instagram blocks datacenter IPs); search-engine and aggregator fallbacks run without proxy. Residential traffic is billed to your account.

## Actor input object example

```json
{
  "usernames": [
    "natgeo",
    "cristiano"
  ],
  "includeRecentPosts": true,
  "maxPostsPerProfile": 12
}
```

# Actor output Schema

## `results` (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 = {
    "usernames": [
        "natgeo",
        "cristiano"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("apricot_blackberry/instagram-creator-analyzer").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": [
        "natgeo",
        "cristiano",
    ] }

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

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

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

```

## CLI example

```bash
echo '{
  "usernames": [
    "natgeo",
    "cristiano"
  ]
}' |
apify call apricot_blackberry/instagram-creator-analyzer --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,apricot_blackberry/instagram-creator-analyzer"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/S7a0TFRSdM9roIPel/builds/a9LpJdqkZPG2Qzgsf/openapi.json