# 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:** 3 total users, 2 monthly users, 97.5% 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 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 & 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

Download the OpenAPI definition: https://api.apify.com/v2/actors/E9r4lYUKJ72Mkeafa/builds/34BnAxeRZ0areKHsa/openapi.json