# Instagram Creator & Influencer Marketing Intel (`seibs.co/instagram-creator-intel`) Actor

Influencer analytics from public Instagram profiles (+ optional TikTok/YouTube): follower count, engagement rate, avg likes/comments, posting cadence, audience-quality / fake-follower heuristics, and top content. The Modash/HypeAuditor layer without Meta App Review. For brands, DTC, and agencies.

- **URL**: https://apify.com/seibs.co/instagram-creator-intel.md
- **Developed by:** [Seibs.co](https://apify.com/seibs.co) (community)
- **Categories:** Business, Marketing, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.00 / 1,000 creator records

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/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 Creator & Influencer Marketing Intel

> **TL;DR for brands, DTC, and influencer-marketing agencies:** Pull a creator's **public Instagram** profile and recent posts and get the influencer-analytics layer that **Modash / HypeAuditor ($299+/mo) and Upfluence ($478+/mo)** charge for - **engagement rate, avg likes/comments, posting cadence, top content, category, and an audience-quality / fake-follower estimate** - with no Meta App Review. Optionally cross-reference the same creator on **TikTok and YouTube** for a multi-platform reach view. The official path (Instagram Graph API) is a 4-6 week App-Review + Business-Verification gauntlet most never clear, and only works on accounts you manage; this needs no application. Logged-out public profiles only, no login, no account creation, PII minimized to the public creator/business identity.

### Run it in 30 seconds

```python
## Via the Apify Python SDK
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("seibs.co/instagram-creator-intel").call(run_input={
    "mode": "audience_quality",
    "creators": ["@natgeo", "nasa"],
    "platforms": ["instagram"]
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
````

Or via curl:

```bash
curl -X POST "https://api.apify.com/v2/acts/seibs.co~instagram-creator-intel/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"mode": "creator_profile", "creators": ["natgeo"], "platforms": ["instagram"]}'
```

Or click "Try for free" on this page if you prefer the no-code UI.

### What you get

Each run produces:

- A clean dataset, filterable in the Apify console and downloadable as CSV or JSON
- An `access_notes` record up top documenting each surface's access method, anti-bot tier, escalation telemetry, and the legal posture
- A sample-output preview at [`.actor/sample-output.json`](./.actor/sample-output.json)

### What does Creator Intel do?

It looks up each creator's **public profile** and recent posts, then normalizes everything into one schema: `platform`, `username`, `canonical_handle` (the cross-platform join key), `full_name`, `biography`, `category`, `is_verified`, `account_type`, `followers`, `following`, `posts_count`, `follower_tier` (nano / micro / mid / macro / mega), and a `recent_posts` stream with per-post like/comment counts. Then it runs the **value layer** - the part influencer platforms gate behind a subscription:

- **Engagement analysis** - engagement rate, avg/median likes & comments, like:comment ratio, **posting cadence per week**, format mix (image/video/carousel), **top content**, a **follower-tier benchmark comparison** (above / in-band / below the typical engagement for that follower size), and inferred **category**.
- **Audience quality** - a **fake-follower / audience-credibility estimate** computed from public signals only: engagement rate vs the follower-tier band, like:comment ratio, following ratio, and engagement uniformity, scored into a 0-100 credibility band with explained flags. This is the premium authenticity signal Modash/HypeAuditor sell. It is clearly labeled a **heuristic estimate** - a prioritization aid for manual vetting, never a definitive verdict.
- **Cross-platform + roster** - group a creator across Instagram/TikTok/YouTube into a **multi-platform reach rollup**, and rank a set of creators in a **roster-comparison** table (best engagement, best credibility, category mix).

### Modes

| Mode | What it returns |
|---|---|
| `creator_profile` (default) | Each creator's public profile + recent posts + the engagement-analysis layer. |
| `audience_quality` | `creator_profile` plus the fake-follower / audience-credibility estimate (the premium signal). |
| `roster_compare` | `creator_profile` for a set of creators plus a cross-creator ranking table for influencer-roster selection. |

### Platform coverage + access notes

Instagram is the primary surface; TikTok and YouTube are optional cross-reference footprints. Coverage is honestly described per surface:

| Platform | Surface | Access | Notes |
|---|---|---|---|
| **instagram** | Public profile (`web_profile_info`) | http-first, browser fallback | The logged-out JSON endpoint returns the profile + the ~12 most-recent posts with like/comment counts, gated by an `X-IG-App-ID` header + a `datr` cookie a real page load mints. curl\_cffi clears the TLS fingerprint; the browser tier loads the public profile page and captures the page's *own* `web_profile_info` XHR (no forged token, no login). |
| **tiktok** | Public profile (`__UNIVERSAL_DATA_FOR_REHYDRATION__`) | http-first, browser fallback | The profile page embeds follower / heart / video counts; used as a cross-platform reach reference (per-post engagement is approximated from total likes ÷ video count). |
| **youtube** | Public channel (`ytInitialData`) | http-first, browser fallback | The channel page embeds subscriber + video counts; cross-platform reach reference. |

Where a logged-out request is blocked, the account is private, or the shape can't be parsed, the platform fails soft with a documented `platform_pending` / `fetch_error` note (the run still finishes SUCCEEDED) rather than fabricating data.

### Anti-bot escalation (residential + browser)

Each profile request runs an automatic escalation ladder:

1. **httpx** over the DATACENTER proxy - cheapest, used first.
2. **curl\_cffi** with real Chrome TLS impersonation over the RESIDENTIAL proxy - defeats JA3/TLS-fingerprint WAFs (Instagram's edge).
3. **Playwright** (patchright stealth) over RESIDENTIAL - loads the public profile page and captures/replays its own `web_profile_info` XHR (carrying the live cookies). This is what makes Instagram's token-locked endpoint return data.
4. **Fail-soft** - documented note, run stays SUCCEEDED.

Set `use_browser_fallback=false` to use plain httpx only (Instagram then returns a `platform_pending` note). For the most reliable Instagram clearance, point the browser tier at a warm anti-detect browser via `browser_cdp_url` (or the `BROWSER_CDP_URL` env var); otherwise run on the `apify/actor-python-playwright` image so a headless Chromium is available.

### Monitor mode (roster tracking)

Run this actor on an Apify **Schedule** and it switches to monitor mode: it diffs this run's creators against the last scheduled run and emits a `monitor_digest` of **follower / engagement-rate movement** and **newly-added creators**, optionally posting the digest to a Slack-compatible `monitor_webhook_url`. Charges one `scheduled_delta_run` per scheduled run. This is the "track my influencer roster over time" use case.

### Responsible use / data scope

Logged-out **public profiles** only, no account creation, no login, no paid API token, no private/credentialed data. We minimize PII: the identity we keep is the **public creator/business profile** (handle, display name, bio, public counts, public post engagement) - we never resolve a private individual's contact details. Meta v. Bright Data (2024) held that logged-off scraping of public Meta data is not barred by its terms. Use creator data responsibly, respect each platform's terms and your local regulations, and treat the audience-quality estimate as a vetting aid, not a verdict.

### AI / RAG / Agent

The `overview` dataset view is a narrow, token-efficient slice for LLM tool responses. A paired **MCP server** (`mcp-instagram-creator-intel`) exposes these as agent tools (`get_creator_profile`, `analyze_engagement`, `check_audience_quality`, `compare_creators`, `cross_platform_lookup`) and is x402 (USDC on Base) + Skyfire ready for token-less agentic payments.

### Features

- The Modash / HypeAuditor analytics layer (engagement rate, fake-follower estimate) without Meta App Review
- Engagement rate, avg/median likes & comments, posting cadence, format mix, top content
- Audience-quality / fake-follower heuristic estimate with explained flags (no LLM key required)
- Follower-tier benchmark comparison + category inference
- Multi-platform reach rollups (Instagram + TikTok + YouTube) and roster-comparison ranking
- Roster-tracking monitor mode with Slack webhook
- Anti-bot escalation (curl\_cffi + browser XHR capture) with fail-soft notes
- Pay-per-event pricing that undercuts the $299+/mo influencer-platform stack

### Use cases

- **Influencer vetting** - is this creator's engagement real, or are the followers bought? Check before you pay for a campaign.
- **Roster selection** - rank a shortlist of creators by engagement rate and audience credibility.
- **Creator discovery QA** - validate a list of handles' follower size, niche, and engagement in bulk.
- **Multi-platform reach** - one creator's combined Instagram + TikTok + YouTube footprint.
- **Roster monitoring** - track follower / engagement movement across your influencer roster over time.

### Pricing (Pay Per Event)

| Event | Price | When |
|---|---|---|
| `creator_record` | $0.006 | Per normalized public creator profile |
| `engagement_analysis` | $0.010 | Per creator's engagement layer (rate, cadence, top content, benchmark) |
| `audience_quality_flag` | $0.015 | Per fake-follower / credibility estimate |
| `scheduled_delta_run` | $0.050 | Per scheduled monitor-mode delta digest |

A run that returns nothing costs nothing. The free Apify plan covers exploration runs on your $5 platform credit.

### Related actors

Part of the Seibs.co intelligence portfolio. Distinct from `ad-library-intel` (paid **ads** across Meta/Google/TikTok) and `tiktok-shop-creator-intel` (TikTok **shop/commerce** creators) - this is **organic influencer-marketing analytics**. Pairs well with `ad-library-intel` (a creator's organic reach + a brand's paid ads) and the MCP twin `mcp-instagram-creator-intel`.

# Actor input Schema

## `mode` (type: `string`):

creator\_profile = pull each creator's public profile + recent posts and compute the engagement-analysis layer. audience\_quality = creator\_profile plus the fake-follower / audience-credibility estimate (the premium signal). roster\_compare = creator\_profile for a set of creators plus a cross-creator ranking table for roster selection.

## `creators` (type: `array`):

Instagram @handles, bare usernames, or profile URLs to analyze, e.g. \['@natgeo', 'nike', 'https://instagram.com/glossier']. When TikTok / YouTube are included, the same handle is looked up on each platform for a multi-platform view. Hard cap of 50.

## `platforms` (type: `array`):

Which public creator surfaces to query: instagram (primary), tiktok (cross-reference footprint), youtube (cross-reference footprint). Aliases like 'ig', 'tt', 'yt' are accepted. Leave empty for Instagram only.

## `include_cross_platform` (type: `boolean`):

Shortcut to look the same handle up on Instagram + TikTok + YouTube and emit a multi-platform reach rollup (overrides the platforms list).

## `include_engagement_analysis` (type: `boolean`):

Compute engagement rate, avg/median likes & comments, like:comment ratio, posting cadence, format mix, top content, follower-tier benchmark, and inferred category. Adds an engagement\_analysis PPE charge per creator. This is the core analytics layer.

## `include_audience_quality` (type: `boolean`):

Compute the fake-follower / audience-credibility estimate (credibility score + band + flags) from public signals. Adds an audience\_quality\_flag PPE charge per creator. Forced on in audience\_quality mode. This is the premium authenticity signal Modash / HypeAuditor gate behind subscriptions.

## `max_posts` (type: `integer`):

How many recent posts to factor into the engagement math. Instagram exposes ~12 logged-out; default 12.

## `monitor_webhook_url` (type: `string`):

When this actor runs under an Apify Schedule (monitor mode), post the change digest (follower / engagement movement, newly-added creators) to this Slack-compatible webhook URL.

## `contact_email` (type: `string`):

Optional. Sent as an X-Contact header so a platform can reach you - a good-citizen signal. Not a credential and never used to log in.

## `use_apify_proxy` (type: `boolean`):

Route requests through Apify Proxy. DATACENTER handles the first (httpx) pass; a RESIDENTIAL tier is provisioned for the anti-bot escalation legs (Instagram fingerprints datacenter IPs).

## `use_browser_fallback` (type: `boolean`):

When a surface serves an anti-bot / login challenge (Instagram's profile JSON is token-locked), automatically escalate: switch to the RESIDENTIAL proxy and retry with curl\_cffi Chrome TLS impersonation, then a headless browser that loads the public profile page and captures the page's own web\_profile\_info XHR. Turn off to use plain httpx only (Instagram then returns a documented platform\_pending note).

## `browser_cdp_url` (type: `string`):

Optional. CDP/WebSocket endpoint of an already-running, anti-detect (UC-mode / real Chrome) browser. When set, the browser tier connects to it (inheriting its session + fingerprint) so it clears Instagram's edge reliably. Without it a plain headless Chromium is launched (works on the apify/actor-python-playwright image; weaker against managed challenges). Can also be set as the BROWSER\_CDP\_URL env var.

## `apify_proxy_groups` (type: `array`):

Override the auto-selected proxy group. Leave empty to let the actor pick DATACENTER for the first pass and RESIDENTIAL for escalation.

## `concurrency` (type: `integer`):

Parallel profile fetches. The surfaces are rate-sensitive; default 4.

## Actor input object example

```json
{
  "mode": "creator_profile",
  "creators": [
    "natgeo",
    "nasa"
  ],
  "platforms": [
    "instagram"
  ],
  "include_cross_platform": false,
  "include_engagement_analysis": true,
  "include_audience_quality": false,
  "max_posts": 12,
  "monitor_webhook_url": "",
  "contact_email": "",
  "use_apify_proxy": true,
  "use_browser_fallback": true,
  "browser_cdp_url": "",
  "apify_proxy_groups": [],
  "concurrency": 4
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

Narrow, token-efficient slice of every record. Consumer: LLM agents (Claude, GPT, LangChain tools), MCP hosts, dashboards. Fields: platform, handle, followers, engagement rate, follower tier, credibility band, category, verified.

## `datasetItemsCreators` (type: `string`):

All fields for every creator: profile, recent posts, full engagement analysis, audience-quality estimate. Consumer: humans browsing the dataset, RAG ingest, full backups. Larger payload - not recommended as a direct LLM tool response.

## `datasetItemsRoster` (type: `string`):

Cross-creator ranking tables and multi-platform reach rollups. Consumer: influencer-roster selection, agency reporting.

## `datasetItemsMcp` (type: `string`):

First 50 overview records as a clean JSON array. Wrap on the agent side in an MCP tool-call response envelope, e.g. `{ "ok": true, "data": <this array>, "meta": { "actor": "instagram-creator-intel", "count": <len>, "view": "overview" } }`. Consumer: MCP servers, Claude Desktop, Cursor, OpenAI Assistants tool calls.

## `datasetItemsCsv` (type: `string`):

Spreadsheet-friendly export of the overview view. Consumer: humans, marketing-ops teams, Excel / Google Sheets users.

# 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 = {
    "mode": "creator_profile",
    "creators": [
        "natgeo",
        "nasa"
    ],
    "platforms": [
        "instagram"
    ],
    "max_posts": 12
};

// Run the Actor and wait for it to finish
const run = await client.actor("seibs.co/instagram-creator-intel").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 = {
    "mode": "creator_profile",
    "creators": [
        "natgeo",
        "nasa",
    ],
    "platforms": ["instagram"],
    "max_posts": 12,
}

# Run the Actor and wait for it to finish
run = client.actor("seibs.co/instagram-creator-intel").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 '{
  "mode": "creator_profile",
  "creators": [
    "natgeo",
    "nasa"
  ],
  "platforms": [
    "instagram"
  ],
  "max_posts": 12
}' |
apify call seibs.co/instagram-creator-intel --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Creator & Influencer Marketing Intel",
        "description": "Influencer analytics from public Instagram profiles (+ optional TikTok/YouTube): follower count, engagement rate, avg likes/comments, posting cadence, audience-quality / fake-follower heuristics, and top content. The Modash/HypeAuditor layer without Meta App Review. For brands, DTC, and agencies.",
        "version": "0.1",
        "x-build-id": "pgYBuTGq3SZx2qRFs"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/seibs.co~instagram-creator-intel/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-seibs.co-instagram-creator-intel",
                "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/seibs.co~instagram-creator-intel/runs": {
            "post": {
                "operationId": "runs-sync-seibs.co-instagram-creator-intel",
                "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/seibs.co~instagram-creator-intel/run-sync": {
            "post": {
                "operationId": "run-sync-seibs.co-instagram-creator-intel",
                "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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "creator_profile",
                            "audience_quality",
                            "roster_compare"
                        ],
                        "type": "string",
                        "description": "creator_profile = pull each creator's public profile + recent posts and compute the engagement-analysis layer. audience_quality = creator_profile plus the fake-follower / audience-credibility estimate (the premium signal). roster_compare = creator_profile for a set of creators plus a cross-creator ranking table for roster selection.",
                        "default": "creator_profile"
                    },
                    "creators": {
                        "title": "Creators (@handles, usernames, or profile URLs)",
                        "maxItems": 50,
                        "type": "array",
                        "description": "Instagram @handles, bare usernames, or profile URLs to analyze, e.g. ['@natgeo', 'nike', 'https://instagram.com/glossier']. When TikTok / YouTube are included, the same handle is looked up on each platform for a multi-platform view. Hard cap of 50.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "platforms": {
                        "title": "Platforms",
                        "maxItems": 3,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Which public creator surfaces to query: instagram (primary), tiktok (cross-reference footprint), youtube (cross-reference footprint). Aliases like 'ig', 'tt', 'yt' are accepted. Leave empty for Instagram only.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "instagram",
                                "tiktok",
                                "youtube"
                            ]
                        },
                        "default": [
                            "instagram"
                        ]
                    },
                    "include_cross_platform": {
                        "title": "Cross-platform view (add TikTok + YouTube)",
                        "type": "boolean",
                        "description": "Shortcut to look the same handle up on Instagram + TikTok + YouTube and emit a multi-platform reach rollup (overrides the platforms list).",
                        "default": false
                    },
                    "include_engagement_analysis": {
                        "title": "Engagement analysis",
                        "type": "boolean",
                        "description": "Compute engagement rate, avg/median likes & comments, like:comment ratio, posting cadence, format mix, top content, follower-tier benchmark, and inferred category. Adds an engagement_analysis PPE charge per creator. This is the core analytics layer.",
                        "default": true
                    },
                    "include_audience_quality": {
                        "title": "Audience quality (fake-follower estimate)",
                        "type": "boolean",
                        "description": "Compute the fake-follower / audience-credibility estimate (credibility score + band + flags) from public signals. Adds an audience_quality_flag PPE charge per creator. Forced on in audience_quality mode. This is the premium authenticity signal Modash / HypeAuditor gate behind subscriptions.",
                        "default": false
                    },
                    "max_posts": {
                        "title": "Max recent posts to analyze",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "How many recent posts to factor into the engagement math. Instagram exposes ~12 logged-out; default 12.",
                        "default": 12
                    },
                    "monitor_webhook_url": {
                        "title": "Monitor webhook URL (Slack / email, optional)",
                        "type": "string",
                        "description": "When this actor runs under an Apify Schedule (monitor mode), post the change digest (follower / engagement movement, newly-added creators) to this Slack-compatible webhook URL.",
                        "default": ""
                    },
                    "contact_email": {
                        "title": "Contact email (polite-scraping signal, optional)",
                        "type": "string",
                        "description": "Optional. Sent as an X-Contact header so a platform can reach you - a good-citizen signal. Not a credential and never used to log in.",
                        "default": ""
                    },
                    "use_apify_proxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Route requests through Apify Proxy. DATACENTER handles the first (httpx) pass; a RESIDENTIAL tier is provisioned for the anti-bot escalation legs (Instagram fingerprints datacenter IPs).",
                        "default": true
                    },
                    "use_browser_fallback": {
                        "title": "Anti-bot escalation (curl_cffi + browser)",
                        "type": "boolean",
                        "description": "When a surface serves an anti-bot / login challenge (Instagram's profile JSON is token-locked), automatically escalate: switch to the RESIDENTIAL proxy and retry with curl_cffi Chrome TLS impersonation, then a headless browser that loads the public profile page and captures the page's own web_profile_info XHR. Turn off to use plain httpx only (Instagram then returns a documented platform_pending note).",
                        "default": true
                    },
                    "browser_cdp_url": {
                        "title": "Warm browser CDP endpoint (for token-locked Instagram)",
                        "type": "string",
                        "description": "Optional. CDP/WebSocket endpoint of an already-running, anti-detect (UC-mode / real Chrome) browser. When set, the browser tier connects to it (inheriting its session + fingerprint) so it clears Instagram's edge reliably. Without it a plain headless Chromium is launched (works on the apify/actor-python-playwright image; weaker against managed challenges). Can also be set as the BROWSER_CDP_URL env var.",
                        "default": ""
                    },
                    "apify_proxy_groups": {
                        "title": "Proxy groups (optional override)",
                        "type": "array",
                        "description": "Override the auto-selected proxy group. Leave empty to let the actor pick DATACENTER for the first pass and RESIDENTIAL for escalation.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "concurrency": {
                        "title": "Max concurrent requests",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "Parallel profile fetches. The surfaces are rate-sensitive; default 4.",
                        "default": 4
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
