# Social Blade Scraper — YouTube, TikTok, Instagram, Twitch Stats (`rl1987/social-blade-lookup`) Actor

Scrape Social Blade stats for YouTube, TikTok, Instagram and Twitch creators: subscribers or followers, views, uploads, engagement, SB grade and ranks, about a month of daily history, and 1-365 day growth deltas. One row per creator, no login or API key needed.

- **URL**: https://apify.com/rl1987/social-blade-lookup.md
- **Developed by:** [R.L.](https://apify.com/rl1987) (community)
- **Categories:** Social media, Developer tools, Automation
- **Features:** Limited permissions
- **Stats:** 201 total users, 52 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.70 / 1,000 user search + profile lookups

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Social Blade Scraper — YouTube, TikTok, Instagram & Twitch Stats

Pull **Social Blade** statistics for any creator without an account, an API key, or a browser.
This Actor talks directly to Social Blade's live backend and returns clean, structured JSON for
**YouTube, TikTok, Instagram and Twitch** — including profile summaries, daily historical data, and
multi-window growth deltas.

> One batched request per creator fetches the profile, ~30 days of history **and** the growth
> section together — the same trick the official Social Blade mobile app uses.

### What can you scrape from Social Blade?

| Result type | What you get | Accepts |
|---|---|---|
| **Profile** *(recommended)* | Resolves a handle, then returns profile + daily history + growth in a single batched call. | handle, ID or URL |
| **Search** | Social Blade's top matches for a term — **6 on YouTube, 5 on TikTok** (measured), with no paging. Use it to find an account's ID, not to enumerate a niche. | search term |
| **User** | Profile / summary stats only (avatar, country, ranks, totals, grade…). | handle or ID (a YouTube `UC…` ID only) |
| **History** | Daily historical data points — about **31 days**, which is all Social Blade serves anonymously. | handle, ID or URL |
| **Growth** | Multi-window growth deltas (3–365 days). | handle, ID or URL |

> **What can I paste, and what gets refused?** A handle, a platform ID, a profile URL on
> `youtube.com`, `tiktok.com`, `instagram.com`, `twitch.tv` (subdomains included, so
> `m.youtube.com` and `music.youtube.com` work) or a `socialblade.com` account URL. The
> account is taken from the *start* of the path, so `tiktok.com/@khaby.lame/video/7123…`
> and `twitch.tv/ninja/clips` both resolve to the account.
>
> Refused, with a message naming the reason and charged nothing: a share link
> (`youtu.be/…`, `vm.tiktok.com/…`) because it names a video or a redirect code rather
> than an account; a video, post or listing page (`youtube.com/watch?v=…`,
> `instagram.com/p/…`, `twitch.tv/videos/…`); and any other host, including lookalikes
> such as `youtube.com.evil.example`. Nothing is guessed from an unrecognised URL — it
> used to become a handle built from the last path segment, which turned a pasted TikTok
> share link into a YouTube lookup.

> **How far back does history go?** About **31 days**. Measured 2026-10-21, one run per
> rung: `historyLimit` 10 returned 10 rows and 30 returned 30, while 32, 60, 120 and 365 all
> returned **31** — identically on YouTube, TikTok and Twitch. That is Social Blade's
> retention for anonymous callers, and nothing in its response says it truncated, so a run
> that asks for more says so in its status message. **Growth deltas are not affected**: those
> windows really do run 1, 3, 7, 14, 30, 60, 90, 180 and 365 days plus year-to-date.

> **`user`, `history` and `growth` require a resolved platform ID** (e.g. a YouTube
> channel ID `UCX6OQ3DkcsbYNE6H8uQQuVA`, not the handle `mrbeast`) — a handle or URL returns
> an error. Only **`profile`** and **`search`** accept handles/URLs. To get history or growth
> from a handle, use **`profile`** (which resolves the handle first, then fetches both); you
> can pick exactly the layers you want with `mode` (see the mode table). `history` and
> `growth` are id-only upstream, but the Actor resolves a handle or URL for you first and
> does **not** charge for that lookup — so `{"mode": "history", "queries": ["mkbhd"]}` works.
> `user` is the one mode that needs the platform's own ID on YouTube; a **`search`** run
> returns it in each result's `id` field.

### Which platforms and fields are covered?

| Platform | Headline count field | Daily history | Growth deltas | ID format the `user`/`history`/`growth` modes need |
|---|---|---|---|---|
| **YouTube** | `subscribers` | yes | yes | channel ID, e.g. `UCX6OQ3DkcsbYNE6H8uQQuVA` |
| **TikTok** | `followers` | yes | yes | the `id` from a `search` result (a numeric string) |
| **Instagram** | `followers` | **gated by Social Blade** | **gated by Social Blade** | the `id` from a `search` result (a numeric string) |
| **Twitch** | `followers` | yes | yes | the `id` from a `search` result |

Every platform fills `id`, `displayName`, `username`, `sbGrade`, `avatar` and `rankSb`. The rest
differ, because Social Blade publishes different things per platform — measured 2026-10-21
over **42 live accounts** (12 YouTube, 10 TikTok, 10 Instagram, 10 Twitch):

| Column | YouTube | TikTok | Instagram | Twitch |
|---|:--:|:--:|:--:|:--:|
| `subscribers` | ✅ | | | |
| `followers` | | ✅ | ✅ | ✅ |
| `views` | ✅ | | | |
| `likes` | | ✅ | | |
| `uploads` | ✅ | ✅ | ✅ | |
| `following` | | ✅ | ✅ | |
| `verified` | | ✅ | | ✅ |
| `engagementRate`, `averageLikes`, `averageComments` | | | ✅ | |
| `category`, `madeForKids` | ✅ | | | |
| `country` | usually — 10/12 | | | |
| `createdAt` | ✅ | about half | | ✅ |
| `socials` | ✅ | | | |
| Ranks | `rankSubscribers`, `rankViews`, `rankCategory`, `rankCountry` (10/12) | `rankFollowers`, `rankLikes`, `rankVideos` | `rankFollowers`, `rankEngagementRate` (9/10) | `rankFollowers` |

A blank cell is an honest `null`, not a missing column: the column set is the same for every row
of a given mode, so an export never changes shape between accounts.

**`createdAt` is null on about half of TikTok accounts.** Social Blade answers with a 1970
epoch artifact for some of them (measured: `1970-12-11` for khaby.lame, `1970-07-04` for
zachking, both of whom joined after 2015), so the Actor drops any date earlier than 2000
rather than shipping an account age that is wrong by half a century. Of 10 TikTok accounts
measured, 2 were artifacts dropped this way, 3 were null at the source, and 5 carried real
dates (2018–2019) and kept them. YouTube (12/12) and Twitch (10/10) are correct to the day.

**`statsHidden` has not been seen `true` yet.** It is `false` on every Twitch account measured
and null elsewhere, so treat it as "Twitch tells us, the others do not" until an account with
withheld counts turns up — across 42 accounts, none did.

*(Social Blade removed Twitter/X data, so it is not available. Facebook is not covered by this
Actor.)*

> **Instagram history & growth are gated by Social Blade.** Social Blade only serves
> Instagram's daily-history and growth sections to logged-in/premium accounts (its public
> backend answers `401 UNAUTHORIZED`). For Instagram, `profile` runs still return the full
> profile summary, but the `history`/`growth` fields come back `null` — and you are **not
> charged** for a section that wasn't delivered. YouTube, TikTok and Twitch are unaffected.

### Why use this Social Blade scraper?

- **No login, no API key.** Works against Social Blade's public web backend.
- **Multi-platform in one Actor.** Switch between YouTube, TikTok, Instagram and Twitch with a single input field — or mix them in one run by pasting profile URLs.
- **Accepts what identifies an account.** Handles (`mrbeast`), platform IDs, profile URLs (`https://youtube.com/@PewDiePie`, `https://m.youtube.com/@MrBeast`, `https://tiktok.com/@khaby.lame/video/7123…` — the account is read out of the path) and Social Blade URLs all work, and the platform is detected from the URL. A link that names a *video* or a host the Actor does not read is refused by name instead of being guessed at.
- **Batched profile lookups.** Profile mode pulls summary + history + growth in **one** request, so you spend fewer proxy hits and finish faster.
- **Headline fields surfaced.** SB grade, ranks, country, category, total views/uploads, engagement, linked socials and multi-window growth are named top-level columns rather than a nested blob to parse — so they export to CSV and filter in a spreadsheet.
- **Beats Cloudflare without a browser.** Social Blade JA3-fingerprints the TLS handshake, so plain Python HTTP clients get a 403 "Just a moment" page. The Actor impersonates a real Chrome TLS/HTTP2 fingerprint (via `curl_cffi`) and retries with a **fresh proxy IP** on any remaining challenge — no slow headless browser needed.

#### How does it compare to the other Social Blade Actors?

Drawn from each Actor's own store listing on 2026-09-27; pricing and features change, so check
their pages before deciding.

| | This Actor | `radeance/socialblade-api` | `parseforge/socialblade-scraper` |
|---|---|---|---|
| Platforms | YouTube, TikTok, Instagram, Twitch | those four **+ Facebook** | those four **+ Facebook** |
| Look up one creator by handle / ID / URL | yes | yes | profile pages and top lists |
| Daily history time-series (~31 days) | yes (Instagram gated) | subscriber growth stats | not listed |
| Multi-window growth deltas (3–365 d) | yes (Instagram gated) | subscriber growth | not listed |
| Top-100 / leaderboard lists | **no** | yes | yes |
| Estimated earnings | **no** | yes | not listed |
| SB grade, ranks, socials | yes | yes | rank, counts, country |
| Mixed-platform URLs in one run | yes | — | — |
| Pricing model | pay-per-event, no subscription | see its pricing tab (it changed model in 2026) | per result |

**Pick a different Actor if** you need Facebook data, Social Blade's Top-100 leaderboards, or
estimated-earnings figures — this Actor does none of those. **Pick this one if** you already know
which creators you care about and want their full profile, daily history and growth deltas per
creator, with no subscription.

### How much does a Social Blade lookup cost?

This Actor uses **pay-per-event** pricing — no monthly subscription. You only pay for the
data you actually receive (failed/empty queries are never charged). The live per-event
prices, which vary by your Apify plan, are on the Actor's store page and in the cost
estimate shown before you start a run — they are not repeated here, so this page cannot
disagree with what you are actually billed.

| Event | Charged when |
|---|---|
| User search + profile lookup | A `search`, `user`, or `profile` query returns its profile/summary data. |
| Historical data | A daily history time-series is returned (in `history` or `profile` mode). |
| Growth data | A multi-window growth section is returned (in `growth` or `profile` mode). |

**Pick your layers with `mode`.** The three layers are charged separately, so asking for
only the layers you need is the cheapest way to run this Actor — and the two add-on layers
are priced below the base lookup, so depth costs less than three separate queries:

| `mode` | What you get | Events charged |
|---|---|---|
| `profile` | Stats snapshot only | profile lookup |
| `history` | Daily history rows only | historical data |
| `growth` | Multi-window growth only | growth data |
| `profile-history` | Snapshot + daily history | profile lookup + historical data |
| `profile-growth` | Snapshot + growth windows | profile lookup + growth data |
| `all` | Snapshot + history + growth | all three |
| `search` | Account search results | profile lookup |
| `user` | Profile summary only, by platform ID | profile lookup |

**Platform coverage** (verified 2026-10-06):

| Platform | `profile` | `history` | `growth` |
|---|---|---|---|
| YouTube | ✅ | ✅ | ✅ |
| TikTok | ✅ | ✅ | ✅ |
| Twitch | ✅ | ✅ | ✅ |
| Instagram | ✅ | ❌ | ❌ |

Social Blade's API answers `401 UNAUTHORIZED` for Instagram history and growth, so those
modes stop with an explanatory message and charge nothing; `profile-history` /
`profile-growth` / `all` on Instagram deliver and charge the profile layer only.

`history` and `growth` are standalone: give them a handle or a profile URL and the Actor
resolves the platform ID for you, **at no extra charge** — you pay for the one layer you
asked for. Previously those modes rejected anything that was not already a platform ID.

> If you are migrating: the old default (`resultType: "profile"` with `includeHistory` and
> `includeGrowth` both `true`) charged all three layers for a request most people make to
> get a snapshot. That combination is now `mode: "all"`, and `mode: "profile"` gives the
> snapshot alone and charges one layer instead of three. Saved tasks that set the old
> inputs keep working exactly as before.

> Platform usage (compute, Apify Proxy, data transfer) is **absorbed by this Actor**, not
> billed to you on top of the events above.

### What input does it take?

| Field | Type | Default | Description |
|---|---|---|---|
| `platform` | string | `youtube` | `youtube`, `tiktok`, `instagram` or `twitch`. |
| `queries` | array of strings | — | Handles / IDs / profile URLs (or search terms for `search`). Every mode accepts a handle or URL — `history` and `growth` resolve the platform ID themselves at no extra charge. Required. |
| `mode` | string | `profile` | Which data layers to fetch — see the mode table above. One of `profile`, `history`, `growth`, `profile-history`, `profile-growth`, `all`, `search`, `user`. |
| `resultType` | string | `profile` | **Deprecated** — use `mode`. Honoured only when `mode` is left empty, so saved tasks are unaffected. |
| `includeHistory` | boolean | `true` | **Deprecated** — use `mode` (`profile-history` / `all`). Honoured only when `mode` is left empty. |
| `includeGrowth` | boolean | `true` | **Deprecated** — use `mode` (`profile-growth` / `all`). Honoured only when `mode` is left empty. |
| `historyLimit` | integer | `30` | Daily data points for `history` / `profile`. Values above ~31 are accepted but return ~31 rows — see the note under *Result types*. |
| `maxConcurrency` | integer | `5` | Queries processed in parallel (1–50). |
| `maxRetries` | integer | `6` | Retries (with IP rotation) per request when Cloudflare challenges (1–20). |
| `proxyConfiguration` | object | Residential Apify Proxy | Proxy settings. Residential is the default; datacenter IPs get hard-blocked by Cloudflare under load. |

#### Example input

```json
{
  "platform": "youtube",
  "queries": ["mrbeast", "pewdiepie"],
  "resultType": "profile",
  "historyLimit": 30,
  "maxConcurrency": 5,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

### What does each row contain?

One record is pushed to the dataset per query. Example (`profile`, abbreviated):

```json
{
  "platform": "youtube",
  "resultType": "profile",
  "query": "mrbeast",
  "id": "UCX6OQ3DkcsbYNE6H8uQQuVA",
  "displayName": "MrBeast",
  "username": "mrbeast",
  "verified": null,
  "subscribers": 502000000,
  "followers": null,
  "views": 130065447496,
  "likes": null,
  "uploads": 988,
  "following": null,
  "sbGrade": "A++",
  "country": "US",
  "category": "entertainment",
  "madeForKids": false,
  "statsHidden": null,
  "createdAt": "2012-02-20T00:00:00.000Z",
  "socials": [ "https://instagram.com/mrbeast", "https://x.com/MrBeast" ],
  "avatar": "https://yt3.ggpht.com/...",
  "rankSb": 13,
  "rankSubscribers": 1,
  "rankViews": 12,
  "rankCountry": 1,
  "rankCategory": 1,
  "scrapedAt": "2026-06-19T12:00:00+00:00",
  "history": [ { "date": "2026-06-18T00:00:00.000Z", "subscribers": 501000000, "views": 129900000000, "videos": 987 } ],
  "growth": {
    "subscribers": { "3d": 1000000, "7d": 3000000, "30d": 15000000, "90d": 30000000, "365d": 96000000 },
    "views":       { "3d": 509488425, "30d": 6576018368, "365d": 43252485950 },
    "videos":      { "3d": 1, "30d": 7, "365d": 111 }
  }
}
```

> `growth` groups subscriber, view and upload deltas by metric, each keyed by the day-window
> Social Blade returned it for (from `1d` up to `365d`, plus `ytd`); `history` is the daily
> time-series. Pick the sections with `mode` — `profile` for neither, `profile-history`,
> `profile-growth` or `all`.

**The column set belongs to the mode, not to the account.** Every row of a run carries exactly
the columns its mode can fill, with an explicit `null` where Social Blade publishes nothing — so
`row["displayName"]` is a null rather than a missing key, and a CSV keeps one shape for the whole
run. A `history` run therefore carries the six identity columns plus `history`, and *not* the
profile summary it could never fill. The dataset has one view per mode (Profile, Daily history,
Growth, Search results) so the Console shows the columns that mode actually uses.

A `search` record contains a `results` array; failed queries carry an `error` string instead of
data (the run continues — one bad query never aborts the batch) and are never charged.

> **Breaking change, 2026-10-21.** Three output fields changed shape, so update any workflow
> that reads them:
>
> | was | now |
> |---|---|
> | `user` — the whole upstream profile object, verbatim | **removed.** Every scalar worth having is a named column; `likes`, `following`, `verified`, `engagementRate`, `averageLikes`, `averageComments` and `statsHidden` are new ones lifted out of it. Dropped with it: `banner`, `description`, `website`, `secUid`, `identifiers`, `stats`, `hasAuthed`, `disabled`, `status`. |
> | `ranks` — an object keyed per metric | **`rankSb`, `rankSubscribers`, `rankFollowers`, `rankViews`, `rankVideos`, `rankLikes`, `rankEngagementRate`, `rankCountry`, `rankCategory`** — one scalar column each, so they export and filter. |
> | `socials` — a list of `{url, title, favicon}` objects | **a list of URL strings.** The `title` was UI chrome ("Follow") and the `favicon` a tracking URL. |
>
> It was half a YouTube row by weight, it restated the same counts in a `stats` sub-object as
> strings, and an upstream shape change altered the output with nobody touching a mapping. If you
> need a field that went with it, open an issue — it is a one-line addition.

### What do Social Blade's metrics actually mean?

- **SB grade** (`sbGrade`) — Social Blade's own letter grade for an account (`A++`, `B`, and so on). It is Social Blade's editorial summary of how the account is doing, not a figure YouTube or TikTok publishes; the Actor passes it through unchanged.
- **Ranks** (`rank…`) — position in Social Blade's league tables: `rankSb` is the overall SB rank, `rankSubscribers` / `rankFollowers` / `rankViews` / `rankLikes` / `rankVideos` / `rankEngagementRate` rank by those totals, and `rankCountry` / `rankCategory` rank the account within its own country and content category. Rank 1 is the top.
- **Growth deltas vs. projections** — the `growth` section is *historical*: how much a metric changed over the last 3, 7, … 365 days. These are measured differences between two past snapshots, not a forecast of future subscribers. If you want a projection, fit it yourself from `history`.
- **Daily history** (`history`) — one data point per day, each carrying that day's cumulative totals rather than that day's gain. The keys differ by platform (measured): YouTube `date, subscribers, views, videos`; TikTok `date, followers, following, likes, videos`; Twitch `date, followers`. Growth is the opposite — the same windows on every platform, with only the metric set differing. Day-over-day change is the difference between two consecutive points. `historyLimit` sets how many days you ask for; Social Blade serves about 31 to anonymous callers, and a run that asks for more says so in its status message.
- **Stats hidden** (`statsHidden`) — whether Social Blade is withholding this account's counts. It separates "this creator has no views" from "we are not shown them", which otherwise look identical.
- **Engagement** (`engagementRate`, `averageLikes`, `averageComments`) — Instagram only. The rate is a fraction, so `0.02` is 2%.
- **Subscribers vs. followers** — the same idea under two names. YouTube reports subscribers; TikTok, Instagram and Twitch report followers. The Actor keeps them in separate fields rather than merging them, so exactly one of the two is populated per row.
- **Handle vs. platform ID** — a handle (`mrbeast`) is the name in the URL and can be changed by its owner; the platform ID (`UCX6OQ3DkcsbYNE6H8uQQuVA`) is permanent and is what the `user` mode needs (`history` and `growth` resolve a handle for you, at no extra charge). `profile` mode resolves one to the other for you.
- **Category** (`category`) — Social Blade's content classification for the account (e.g. `entertainment`), which is also what the `category` rank is measured within.
- **Made for kids** (`madeForKids`) — the "made for kids" audience flag as Social Blade reports it for a YouTube channel, passed through as a boolean (null where Social Blade has no value).

### FAQ

**Do I need a Social Blade account, login, or API key?** No. The Actor calls the same public backend the Social Blade website uses, so there is no account, no premium subscription and no key to enter. The one exception is Instagram history and growth, which Social Blade itself serves only to logged-in premium accounts — those fields come back `null` and unbilled.

**Can I schedule it to build a growth time-series?** Yes — use Apify **Schedules** and it appends a fresh row per creator per run. A monthly schedule is enough to keep a continuous series, because one run already returns Social Blade's whole anonymous window (about 31 days) in a single call. Beyond that window, the scheduled runs *are* the archive: Social Blade does not serve older daily rows, so the series you keep is the one you collected.

**What does one row contain?** One creator per row for `profile`, `user`, `history` and `growth`: the summary fields as flat columns, the daily series under `history` and the per-metric deltas under `growth`. A `search` row instead holds a `results` array of matching accounts. Each mode emits only the columns it can fill, and the dataset carries one view per mode.

**How is the cost bounded?** Each event is charged only for a section actually delivered, so the worst case is three events per creator, in `mode: "all"`; a single-layer mode (`profile`, `history` or `growth`) charges one. Set **Max total charge** on the run and the Actor stops starting new queries once that cap is hit, and says in its status message how many queries it never attempted.

**Why did `search` return nothing / only a handful?** Social Blade's search returns its top matches — measured at 6 on YouTube and 5 on TikTok — and there is no paging, so it is a tool for finding an account's ID rather than for enumerating a niche. It also ignores very short or very common terms: measured 2026-10-21, `a` and `the` return nothing at all while `vlog` returns 6. An empty search is never charged, and the run's status message says which of the two happened.

**Why do I get a Cloudflare challenge or a 403?** Social Blade fingerprints the TLS handshake. The Actor already impersonates a real Chrome fingerprint and retries on a fresh IP up to `maxRetries` times, so the usual cause is the proxy: keep the default **residential** Apify Proxy, and lower `maxConcurrency` if challenges persist. Datacenter IPs work at low volume but get hard-blocked under concurrency.

**What happens if one creator fails or does not exist?** That row is written with an `error` field instead of data and the run carries on through the rest of the batch — one bad handle never aborts the job, and you are not charged for it.

**Does it cover Facebook or Twitter/X?** No. Social Blade dropped Twitter/X data entirely, and this Actor's platforms are YouTube, TikTok, Instagram and Twitch. If you need Facebook, use an Actor that lists it.

**Can I get Social Blade's Top-100 lists or estimated earnings?** No — this Actor is built for per-creator lookups by handle, ID or URL. Leaderboards and earnings estimates are not returned; another Social Blade Actor is the better fit for those.

**Can I mix platforms in one run?** Yes. Paste full profile URLs (`https://tiktok.com/@khaby.lame`, `https://twitch.tv/pokimane`) and the platform is detected per entry, overriding the `platform` field.

### Tips and limits

- **Use residential proxy (the default).** Residential IPs reliably succeed across all platforms; datacenter IPs work for low volume but get hard-blocked under concurrency.
- **`profile` is the cheapest way to get everything** — prefer it over running `user` + `history` + `growth` separately.
- **Ask for the history you need.** `historyLimit` accepts up to 365, but Social Blade serves about 31 days to anonymous callers, and fewer where it holds fewer — the run says so in its status message when it returns less than you asked for.
- This Actor reads publicly available data from Social Blade. Respect Social Blade's terms and applicable laws; use the data responsibly.

### How does it get past Cloudflare?

The Actor calls Social Blade's tRPC backend (`https://socialblade.com/api/trpc`) with GET requests —
the same endpoints the website itself uses. Cloudflare fingerprints the TLS handshake, so the Actor
uses `curl_cffi` to impersonate a real Chrome browser's TLS/HTTP2 fingerprint; this gets a normal JSON
response without the cost of a headless browser. When a challenge page is still returned instead of
JSON, the request is retried on a fresh proxy IP until it succeeds or `maxRetries` is exhausted.

### n8n integration

Use the [`n8n-nodes-social-blade-lookup`](https://www.npmjs.com/package/n8n-nodes-social-blade-lookup) community node ([source](https://github.com/rl1987/n8n-nodes-social-blade-lookup)) to run this Actor directly from an n8n workflow.

### Community research toolkit

Part of the **Community research toolkit** — research online communities and creators across forums, link-in-bio pages, and social platforms:

- [Reddit Scraper — Posts, Comments, Subreddits & Users](https://apify.com/rl1987/reddit-api-scraper) — Scrape Reddit posts, comments, search results, subreddits, and user profiles.
- [Linktree Profile Scraper](https://apify.com/rl1987/linktree-scraper) — Scrape profile info and all links from Linktree pages.
- [Discourse Community Scraper](https://apify.com/rl1987/discourse-community-scraper) — Generalised scraper for any Discourse-based community forum.
- [phpBB Forum Scraper](https://apify.com/rl1987/phpbb-forum-scraper) — Generic scraper for phpBB-powered forums.
- [Hacker News Scraper](https://apify.com/rl1987/hacker-news-scraper) — Scrape Hacker News by search, user, listing, or thread.

### Did you find this useful?

Rate this actor on Apify! Your feedback helps other users find it and helps us keep improving it.

# Actor input Schema

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

The social platform to look up. Note: Social Blade removed Twitter/X data.

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

Which data layers to fetch. Each layer is charged separately, so pick just the layers you need — the current per-event prices are on the Actor store page and in the run's cost estimate. 'History only' and 'Growth only' accept a platform ID and also accept a handle or profile URL, which the Actor resolves for you at no extra charge. Empty queries and failed lookups are never charged. Leave it empty to keep the deprecated resultType/includeHistory/includeGrowth behaviour (which bundles all three layers) - that is what existing saved tasks do. Platform limits, verified 2026-10-06: Instagram only serves the profile layer — Social Blade's API answers 401 for Instagram history and growth, so those modes stop with a message and charge nothing. YouTube, TikTok and Twitch serve all three.

## `queries` (type: `array`):

One entry per account to scrape. Accepts a handle/username (`mrbeast`), a platform ID (`UCX6OQ3DkcsbYNE6H8uQQuVA`), a profile URL on youtube.com, tiktok.com, instagram.com or twitch.tv — subdomains included, so `m.youtube.com/@MrBeast` works — or a Social Blade account URL. The account is read from the start of the path, so `tiktok.com/@khaby.lame/video/7123…` resolves to the account. A URL that identifies the platform overrides the `platform` field, so you can mix platforms in one run. In `search` mode these are search terms instead. ⚠️ Refused with an explanatory row and no charge: share links (`youtu.be/…`, `vm.tiktok.com/…`), video/post/listing pages (`youtube.com/watch?v=…`, `instagram.com/p/…`, `twitch.tv/videos/…`) and any other host — nothing is guessed from an unrecognised URL. `user` mode needs a platform ID on YouTube and accepts a handle on TikTok/Instagram/Twitch; `history` and `growth` resolve a handle or URL for you at no extra charge. **The prefilled examples are written for the default `profile` mode** (they also work in `search`): of them only the YouTube one is an ID, so in `user` mode on YouTube replace it with a UC… channel ID.

## `resultType` (type: `string`):

What to fetch for each query:

- **profile** — resolve the handle, then fetch profile + daily history + growth in one batched call (recommended; accepts handle/ID/URL).
- **search** — return matching accounts for the term (accepts a search term).
- **user** — profile/summary stats only. Accepts a handle on TikTok, Instagram and Twitch; on YouTube it needs a `UC…` channel ID.
- **history** — daily historical data points only. Requires a platform ID.
- **growth** — multi-window growth deltas only. Requires a platform ID.

⚠️ `history` and `growth` need a resolved platform ID (e.g. `UCX6OQ3DkcsbYNE6H8uQQuVA` for YouTube, a numeric id elsewhere), not a handle. For history/growth from a handle, use `profile`. DEPRECATED - use `mode` instead. Honoured only when `mode` is left empty, so existing saved tasks keep their current behaviour.

## `includeHistory` (type: `boolean`):

In `profile` result type, include the daily history section. Turn off to make a smaller, faster request when you only need the profile summary. Ignored for other result types. DEPRECATED - use `mode` (e.g. 'profile-history' or 'all'). Honoured only when `mode` is left empty. Note this defaulted to true, which is why a plain profile run used to charge all three layers.

## `includeGrowth` (type: `boolean`):

In `profile` result type, include the multi-window growth section. Turn off to make a smaller, faster request. Ignored for other result types. DEPRECATED - use `mode` (e.g. 'profile-growth' or 'all'). Honoured only when `mode` is left empty.

## `historyLimit` (type: `integer`):

Number of daily data points to fetch for `history` and `profile` result types. Social Blade serves only about 31 days to anonymous callers — measured 2026-10-21 on YouTube, TikTok and Twitch — so any larger value returns about 31 rows and the run reports it in the status message. Growth deltas are unaffected: those windows run up to 365 days.

## `maxConcurrency` (type: `integer`):

Maximum number of queries processed in parallel. Lower this if you hit Cloudflare challenges.

## `maxRetries` (type: `integer`):

How many times to retry a request (rotating proxy IP) when Cloudflare returns a challenge page instead of JSON.

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

Proxy settings. Residential Apify Proxy is the default and strongly recommended — Social Blade is behind Cloudflare, and datacenter IPs get hard-blocked under load while residential IPs reliably succeed.

## Actor input object example

```json
{
  "platform": "youtube",
  "mode": "profile",
  "queries": [
    "mrbeast",
    "https://www.youtube.com/@PewDiePie"
  ],
  "resultType": "profile",
  "includeHistory": true,
  "includeGrowth": true,
  "historyLimit": 30,
  "maxConcurrency": 5,
  "maxRetries": 6,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Social Blade records (profile / search / user / history / growth), one per input query, in the default dataset.

# 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": "profile",
    "queries": [
        "https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA",
        "https://www.tiktok.com/@brett.dev",
        "https://www.twitch.tv/pokimane",
        "https://www.instagram.com/nike"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("rl1987/social-blade-lookup").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": "profile",
    "queries": [
        "https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA",
        "https://www.tiktok.com/@brett.dev",
        "https://www.twitch.tv/pokimane",
        "https://www.instagram.com/nike",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("rl1987/social-blade-lookup").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 '{
  "mode": "profile",
  "queries": [
    "https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA",
    "https://www.tiktok.com/@brett.dev",
    "https://www.twitch.tv/pokimane",
    "https://www.instagram.com/nike"
  ]
}' |
apify call rl1987/social-blade-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rl1987/social-blade-lookup"
        }
    }
}
```

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/1KmezGkKhBRqRHakY/builds/19WEbBU0JuPLJ3jDO/openapi.json