# Creator Rate-Card Pricing Benchmark (`conceivable_extension/creator-rate-card-pricing-benchmark`) Actor

Real, live-fetched follower data for Instagram/TikTok/YouTube creators (not manually typed numbers) run through a transparent benchmark formula — an honestly-labeled estimated rate range, since real observed deal prices proved technically and legally inaccessible.

- **URL**: https://apify.com/conceivable\_extension/creator-rate-card-pricing-benchmark.md
- **Developed by:** [joseph fadero](https://apify.com/conceivable_extension) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 66.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 creator benchmark returneds

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

## Creator Rate-Card Pricing Benchmark

**Real, live-fetched follower data — not manually typed numbers — run through a transparent benchmark formula.** The existing Apify Store competitor in this space is a pure calculator: its own README states it runs "without third-party API keys, scraping, or private profile access," meaning you have to already know (and type in) the creator's follower count and engagement rate yourself. This actor fetches that data live from the creator's real public profile instead.

### A finding worth being direct about

**The build PRD's own stated goal was "observed pricing" — real, itemized deal prices — not a calculator.** Before writing any scraper code, three candidate sourcing paths were tested live:

1. **Public rate cards** individual creators publish themselves — real, but scattered across personal sites and media kits with no directory or discoverable URL pattern. Not viable for a general "look up any creator" tool.
2. **Marketplace-disclosed pricing** — tested four real creator marketplaces live. Collabstr has real per-creator rate data, but the entire site (even `robots.txt`) sits behind a Cloudflare managed JS challenge. Shoutcart returned a flat 403. influence.co requires a full Google OAuth login just to browse. Ainfluencer's public browse page loads but shows zero visible price data — rates are gated behind a contact/signup flow. **Dead end across every real marketplace tested.**
3. **Real, live public follower/engagement data** (the PRD's own suggested fallback) — confirmed technically working on all three platforms, see below.

Per the PRD's own explicit fallback instruction, this actor is built as **a benchmark calculator informed by real, live-fetched public data**, not observed deal prices — which are confirmed inaccessible, not merely inconvenient. Every record honestly reports `dataSource: "inferred_benchmark"`, since the other two paths didn't pan out.

### What's actually verified, per platform

| Platform | Follower data | Engagement signal | Confidence cap |
|---|---|---|---|
| **TikTok** | ✅ Real, live, no login — `followerCount` from the embedded `#__UNIVERSAL_DATA_FOR_REHYDRATION__` JSON | ✅ Real — average likes-per-video-ever ÷ followers (see caveat below) | high |
| **YouTube** | ✅ Real, live, no login — `subscriberCountText` from the channel's `/about` page | ❌ Not fetched in this build | medium |
| **Instagram** | ⚠️ Real when it works, but confirmed IP-dependent (see below) — parsed from the public `og:description` meta tag | ❌ Not available without login | medium |

None of these require logging in. `dataConfidence` is `high` only when both a real follower count and a real engagement signal were fetched (currently TikTok only); `medium` when only follower count was fetched; `low` when the live fetch failed and the run fell back to a manually-supplied `followerCount` input instead.

**Instagram specifically was confirmed working during local development, then confirmed *failing consistently* once deployed and run on the real Apify platform** — the same code, same handle, different result depending on where it runs. The real cause, found via diagnostic logging on a live platform run rather than guessed: Instagram returns a genuine HTTP-level failure (`net::ERR_HTTP_RESPONSE_CODE_FAILURE`) specifically to requests from Apify's cloud IP range, while the identical request succeeds from a non-cloud IP. This is a real, external IP-based block — not a bug in this actor, and not something a residential-proxy-free fix can solve. TikTok and YouTube were both tested from the same Apify cloud run and worked without issue, so this is Instagram-specific, not a platform-wide problem. A residential proxy would likely resolve it; that's out of scope for this build. `dataSource`/`dataConfidence` on a failed Instagram lookup are reported honestly as `failed`/`low` rather than silently retried into something that looks like success.

### Three things found while building, not assumed

- **Instagram needs a real browser; TikTok and YouTube don't, technically.** A plain `curl` request to an Instagram profile (even with a real browser User-Agent) gets an empty, generic-titled, login-walled shell with zero data. A real Playwright browser gets past this and the `og:description` meta tag reliably has real follower/following/post counts. TikTok and YouTube's data is present in raw HTML even via plain `curl` — Playwright is used for all three anyway, for one consistent code path rather than mixing HTTP clients.
- **YouTube's `/about` page routes through a real interactive cookie-consent page in a browser, not just a redirect.** `curl -L` auto-follows straight to the real content, landing on a URL with `?cbrd=1&ucbcb=1` appended. A real Playwright browser instead gets shown consent.youtube.com's actual interactive consent UI — confirmed by inspecting the captured HTML directly (a real, separate document, not an empty stub). Appending those same query params to the initial request URL skips the interstitial in Playwright too.
- **TikTok's public profile page has no per-video breakdown, only lifetime cumulative stats.** `heart` (total likes ever) and `videoCount` are both real and public, so `heart ÷ videoCount ÷ followerCount` gives a genuine average-engagement proxy — but it's a lifetime average, not a "last 10 posts" engagement rate. Documented here rather than presented as more granular than it is. Also found live: TikTok's own `stats.heartCount` field returned a nonsensical negative number on a real profile (an apparent counter-overflow bug on TikTok's end) while the newer `statsV2.heartCount` matched `heart` exactly — `statsV2` is used for this reason.

### Modes

| Mode | Input | Output |
|---|---|---|
| `creator_lookup` | `creatorHandle` (+ optional `followerCount` fallback, `niche`, `geography`) | One benchmark result for that creator |
| `niche_benchmark` | `niche` / `geography` (no handle) | One result per follower tier (nano/micro/mid/macro/mega), using a representative follower count per tier |

### The pricing formula — transparent, not a black box

Base rate: **$100 per 10,000 followers**, a widely-cited creator-economy rule of thumb (cross-checked during research against real published 2026 benchmark ranges — nano ~$25-$500, macro ~$10,000-$50,000+ — and lands within them). Then adjusted by:

- **Platform** — YouTube ×3.0 (a dedicated integration is real production effort, not a single post; Instagram/TikTok both ×1.0)
- **Niche** — a modest table (finance/B2B/SaaS ×1.8, beauty/fashion/luxury ×1.3, tech ×1.1, entertainment/comedy ×0.8, unrecognized or blank niches ×1.0 — no guessed penalty)
- **Geography** — a short list of premium ad markets (US/UK/Canada/Australia/NZ + several Western European countries) gets ×1.3; anything else, including blank, is ×1.0 — again no guessed penalty for unrecognized geographies
- **Engagement** — only applied when a real signal was fetched (TikTok); scales the estimate relative to what's typical for that creator's own follower tier, since smaller accounts genuinely have higher typical engagement rates than mega accounts, a well-known real industry pattern

Lower confidence **widens** the output range rather than pretending to more precision than the data supports: `high` confidence → ±15-20%, `medium` → ±30-40%, `low` → ±50-80%.

### Output schema

```json
{
  "creatorHandle": "string",
  "platform": "instagram | tiktok | youtube",
  "followerTier": "nano | micro | mid | macro | mega",
  "followerCount": "number | null",
  "estimatedRateRange": { "low": "number", "high": "number" } ,
  "currency": "USD",
  "dataConfidence": "high | medium | low",
  "dataSource": "inferred_benchmark",
  "niche": "string | null",
  "geography": "string | null",
  "checkedAt": "ISO timestamp",
  "status": "success | failed",
  "errorMessage": "string | null"
}
```

`currency` is always `USD` regardless of geography — no FX conversion is attempted, to avoid adding staleness risk for a figure that's already a directional estimate.

### Pricing

| Event | Price |
|---|---|
| Run started | £0.05 |
| Lookup success | £0.06 |
| Lookup, no data found | £0.02 |
| Lookup failed | free |

`niche_benchmark` mode charges the success event once per tier row produced (5 per run).

### Setup note

Playwright/Chrome base image (`apify/actor-node-playwright-chrome:20`) — required for Instagram specifically (see above); used for all three platforms for one consistent code path.

### n8n integration

- **Workflow A (trigger):** on-demand lookup triggered from a brand's creator shortlist.
- **Workflow B (processing):** side-by-side benchmark report comparing a shortlist of creators by estimated rate and follower tier — same alerting/reporting pattern as other actors in this portfolio.

# Actor input Schema

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

creator\_lookup: fetch real live follower data for one specific creator handle and estimate a rate range. niche\_benchmark: no specific creator — return one representative estimate per follower tier (nano/micro/mid/macro/mega) for a given niche/geography/platform.

## `platform` (type: `string`):

Which platform to look up. All three fetch real public follower counts live (no login) — see README for per-platform data-confidence notes (Instagram/YouTube are follower-count-only; TikTok also yields a real average-engagement signal).

## `creatorHandle` (type: `string`):

Username/handle without @ (e.g. 'mkbhd'). Required when mode is creator\_lookup.

## `followerCount` (type: `integer`):

Optional. Only used as a fallback if the live profile fetch fails (creator not found, profile blocked, etc.) — real fetched data is always preferred and this is ignored when the fetch succeeds. Using this fallback lowers dataConfidence to 'low' since it's a manually-supplied number, not verified live.

## `niche` (type: `string`):

Optional free text, e.g. 'finance', 'beauty', 'entertainment'. Adjusts the benchmark formula's niche multiplier — see README for the recognized niche list; unrecognized/blank niches use a neutral 1.0x multiplier, not a guess.

## `geography` (type: `string`):

Optional free text, e.g. 'US', 'UK', 'Germany'. A short list of premium ad markets gets a real, documented rate uplift; anything else (including blank) uses a neutral 1.0x multiplier rather than a guessed penalty — see README.

## Actor input object example

```json
{
  "mode": "creator_lookup",
  "platform": "tiktok",
  "creatorHandle": "khaby.lame"
}
```

# Actor output Schema

## `resultsDatasetUrl` (type: `string`):

Live-fetched creator follower and engagement data run through a transparent pricing-benchmark formula to estimate fair sponsorship rates, produced by this run.

# 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 = {
    "creatorHandle": "khaby.lame"
};

// Run the Actor and wait for it to finish
const run = await client.actor("conceivable_extension/creator-rate-card-pricing-benchmark").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 = { "creatorHandle": "khaby.lame" }

# Run the Actor and wait for it to finish
run = client.actor("conceivable_extension/creator-rate-card-pricing-benchmark").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 '{
  "creatorHandle": "khaby.lame"
}' |
apify call conceivable_extension/creator-rate-card-pricing-benchmark --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,conceivable_extension/creator-rate-card-pricing-benchmark"
        }
    }
}
```

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/ciL89GeSXSZ2rcJ0o/builds/KeihfC2PzChKSsGQU/openapi.json