# SocialBlade Scraper Stats, Grade, Rank & Growth (`memo23/socialblade-scraper`) Actor

Scrape public SocialBlade creator stats for YouTube, TikTok, Instagram, Twitch and Facebook — subscribers/followers, views, grade, rank, 15-day growth. Flags risky /user/ lookups that can silently resolve to the wrong creator. Mix profile and rankings URLs. JSON/CSV/Excel

- **URL**: https://apify.com/memo23/socialblade-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Social media, AI, Automation
- **Stats:** 22 total users, 21 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.00 / 1,000 results

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

## SocialBlade Stats Scraper

Turn any [SocialBlade](https://socialblade.com) creator page or rankings list into structured data. Paste a profile URL or a YouTube rankings URL — or mix both in one run — and get one clean row per creator with subscribers/followers, views, SocialBlade grade, global/country/category rank, 15-day growth, and platform-specific metrics.

Covers **YouTube, TikTok, Instagram, Twitch and Facebook**.

#### How it works

![How the SocialBlade scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-socialblade.png)

#### ✨ Why use this scraper?

- **Catches the wrong-channel trap other scrapers miss** — SocialBlade's legacy `/user/{username}` URL form can silently resolve to a same-named decoy instead of the creator you meant (verified: `/youtube/user/mrbeast` returns a 2K-subscriber channel, not the real 506M-subscriber MrBeast). Every row from a `/user/`/`/page/` lookup is flagged `legacyUrlForm: true` so you know to double-check it — use `/handle/` or `/youtube/channel/{id}` for guaranteed-correct resolution.
- **15-day history and growth, at a fraction of the cost** — SocialBlade embeds the daily history snapshot in the same page as the profile, so `includeHistory` costs zero extra HTTP requests; you're only billed the small `additional-data` fee, and only when history actually comes back. Growth (absolute/percent/average-daily change) is computed for you.
- **Mix profiles and rankings in one run** — paste creator URLs and a YouTube rankings URL together; both are auto-classified. No rigid mode switch.
- **One schema, five platforms** — every creator row has the same shape; platform-specific fields (subscribers vs followers vs page likes, engagement rate, average likes/comments) are simply `null` when a platform doesn't expose them.
- **Deduped across the whole run** — the same creator found via a direct lookup and inside a rankings list is only billed once.

#### 🎯 Use cases

| Audience | What they pull |
|---|---|
| **Talent agencies / management** | Growth trends and grades across a roster of creators, any platform |
| **Marketing / sponsorship teams** | Audience size, growth trajectory and engagement to vet influencer partnerships |
| **Competitive analysts** | Rankings by category/country to track who's rising in a niche |
| **Researchers / data scientists** | Clean, comparable creator-economy datasets across 5 platforms |
| **Creators themselves** | Track their own grade, rank and 15-day growth trend programmatically |

#### 📥 Supported inputs

| Input | Example | Behaviour |
|---|---|---|
| Profile URL (handle — reliable) | `https://socialblade.com/youtube/handle/mrbeast` | Scrapes that creator; `legacyUrlForm: false` |
| Profile URL (channel ID — reliable) | `https://socialblade.com/youtube/channel/UCX6...` | Scrapes that creator; always exact |
| Profile URL (legacy — flagged) | `https://socialblade.com/tiktok/user/khaby.lame` | Scrapes the resolved creator but sets `legacyUrlForm: true` |
| Rankings URL (YouTube only) | `https://socialblade.com/youtube/top/100/mostsubscribed` | Up to 100 full creator rows in one request |
| Bare identifiers | `profiles: ["mrbeast", "khaby.lame"]` + `platform: "youtube"` | Alternative to URLs — no need to build one, always resolved via the reliable handle form |

**Not supported:** rankings for TikTok/Instagram/Twitch/Facebook (SocialBlade only exposes `/top/` for YouTube — other platforms 404), and per-request rankings beyond 100 creators (SocialBlade's own ceiling regardless of the tier requested).

#### 🔄 How it works

1. **Classify** every input URL as a creator profile or a rankings page.
2. **Fetch** the page and read the tRPC-hydrated JSON embedded in `__NEXT_DATA__` — no DOM scraping.
3. **Flag** any `/user/`/`/page/`-form lookup as `legacyUrlForm: true` (the wrong-channel guard).
4. **Compute** 15-day growth from the already-fetched history, when enabled.
5. **Dedup** by creator ID across profile lookups and rankings rows in the same run.
6. **Push** one normalized row per creator (JSON / CSV / Excel).

#### ⚙️ Input parameters

| Field | Type | Default | Description |
|---|---|---|---|
| `startUrls` | array | `["…/handle/mrbeast"]` | SocialBlade profile and/or rankings URLs. Mix freely. |
| `profiles` | array | — | Alternative to URLs: bare identifiers, resolved via the reliable handle form. |
| `platform` | select | `youtube` | Default platform for bare-string entries in `profiles`. |
| `includeHistory` | boolean | `true` | Add 15-day history + computed growth. No extra HTTP request; billed a small `additional-data` fee only when history is actually returned. |
| `rankLimit` / `rankMetric` / `rankCountry` / `rankCategory` | — | — | Rankings filter builder (YouTube only). Leave all empty to skip rankings. |
| `maxItems` | integer | `50` | Hard cap on creator rows (controls billing). |
| `proxy` | object | Apify proxy | SocialBlade's Cloudflare check passes on TLS fingerprint alone — no residential IPs needed for normal volumes. |

#### 📊 Output overview

Each row is one creator. Core identity and metrics come from SocialBlade's own hydrated page data — no field is guessed or DOM-scraped. Platform-appropriate metrics are top-level (`subscribers` for YouTube, `followers` for TikTok/Instagram/Twitch, `likes` for Facebook) with `primaryMetricName`/`primaryMetricValue` giving you a normalized way to compare across platforms. `legacyUrlForm` and `identifierMismatch` are trust signals — see the FAQ.

#### 📦 Output sample

```json
{
  "type": "creator",
  "platform": "youtube",
  "creatorId": "UCX6OQ3DkcsbYNE6H8uQQuVA",
  "displayName": "MrBeast",
  "handle": "mrbeast",
  "country": "US",
  "category": "entertainment",
  "createdAt": "2012-02-20T00:00:00.000Z",
  "primaryMetricName": "subscribers",
  "primaryMetricValue": 506000000,
  "subscribers": 506000000,
  "videos": 990,
  "views": 131964361536,
  "grade": "A++",
  "ranks": { "sb": 2, "subscribers": 1, "views": 6, "country": 1, "category": 1 },
  "profileUrl": "https://socialblade.com/youtube/handle/mrbeast",
  "requestedUrlForm": "handle",
  "legacyUrlForm": false,
  "identifierMismatch": false,
  "historyAvailable": true,
  "growth": {
    "metric": "subscribers",
    "days": 14,
    "first": 502000000,
    "last": 506000000,
    "absoluteChange": 4000000,
    "percentChange": 0.8,
    "avgDailyChange": 285714.29
  },
  "scrapedAt": "2026-07-02T13:30:19.549Z"
}
````

#### 🗂 Key output fields

| Category | Fields |
|---|---|
| **Identity** | `creatorId`, `displayName`, `username`, `handle`, `avatar`, `banner`, `createdAt`, `country`, `verified`, `disabled` |
| **Metrics (platform-appropriate, others null)** | `subscribers`, `followers`, `following`, `likes`, `talkingAbout`, `mediaCount`, `videos`, `views`, `engagementRate`, `averageLikes`, `averageComments` |
| **Normalized comparison** | `primaryMetricName`, `primaryMetricValue` |
| **SocialBlade ranking** | `grade`, `ranks` (site/subscribers/views/country/category — varies by platform) |
| **History** *(opt-in)* | `history[]` (up to 15 daily snapshots), `historyAvailable`, `growth` (absolute/percent/avg-daily change) |
| **Trust signals** | `requestedIdentifier`, `requestedUrlForm`, `legacyUrlForm`, `identifierMismatch` |
| **Social** | `socialLinks[]`, `website` |

#### ❓ FAQ

**What's `legacyUrlForm` and why does it matter?**
SocialBlade's legacy `/user/{username}` (and Facebook `/page/{name}`) URL form resolves through a separate, older identifier namespace than the modern `/handle/{handle}` form. A username-squatter can legitimately hold the exact username you searched for while the creator you actually meant only exists under a different handle — we verified this with `/youtube/user/mrbeast`, which resolves to an unrelated 2K-subscriber channel. We can't algorithmically prove this from a single fetch (the squatter's data legitimately contains the identifier you searched), so instead every `/user/`/`/page/`-sourced row is flagged `legacyUrlForm: true` — treat those as needing a sanity check (e.g. against an expected follower count), and prefer `/handle/` or `/youtube/channel/{id}` whenever you know them.

**What's the difference between `legacyUrlForm` and `identifierMismatch`?**
`legacyUrlForm` is a structural risk flag — always accurate, fires on every `/user/`/`/page/` request regardless of outcome. `identifierMismatch` is a weaker, single-fetch signal that only catches total misses (the requested identifier doesn't appear anywhere in the response at all — e.g. a suspended or renamed account). It will NOT catch username-squatting, since the squatter's data genuinely contains the identifier.

**Do I get daily follower/subscriber history?**
Yes, up to 15 days, when `includeHistory` is on (default). It costs no extra HTTP request — already embedded in the same page fetch as the profile — and is billed a small `additional-data` fee only when it's actually returned. Some platforms gate the full history behind a paid SocialBlade tier (seen on Instagram); when that happens `historyAvailable` is `false`, `growth` is `null`, and nothing is charged.

**Can I get more than 100 creators from rankings in one request?**
No — SocialBlade caps a single rankings request at 100 creators regardless of the tier requested (even `/top/5000/...` returns the same 100). Run multiple rankings requests with different filters (category, country) to cover more ground.

**Does it work for TikTok/Instagram/Twitch/Facebook rankings?**
No — SocialBlade only exposes `/top/` rankings for YouTube; the same path 404s for every other platform. Profile lookups work for all 5 platforms.

**Do I need a proxy?**
No for normal volumes. SocialBlade's Cloudflare check verifies TLS fingerprint and headers, not IP reputation — it passes on a direct connection with a real-browser fingerprint.

#### 💬 Support

Found a bug or need an extra field? Open an issue from the actor's **Issues** tab on the Apify Console and it'll be looked at quickly.

#### 🛠 Additional services

Need a custom social-analytics scraper, scheduled monitoring runs, or a push integration into your own database / sheet / webhook? Get in touch through Apify — bespoke builds and modifications are welcome.

#### 🔎 Explore more scrapers

Looking for other data-extraction actors (social media, real estate, classifieds, jobs)? Browse the rest of the publisher's actors on the Apify Store.

***

### ⚠️ Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by SocialBlade or any of its subsidiaries or affiliates. All trademarks mentioned are the property of their respective owners.

The scraper accesses only publicly available creator-statistics pages — no authenticated endpoints, paid-tier-only features, or content behind a SocialBlade login. Users are responsible for ensuring their use complies with SocialBlade's Terms of Service, applicable data-protection law (GDPR, CCPA, etc.), and any contractual obligations of their own organisation.

***

### SEO Keywords

socialblade scraper, scrape socialblade, socialblade api, apify socialblade, youtube stats scraper, tiktok stats scraper, instagram analytics scraper, twitch stats scraper, facebook page stats scraper, creator analytics api, influencer data scraper, youtube subscriber count api, social media growth tracker, creator ranking scraper, youtube rankings scraper, socialblade grade scraper, influencer vetting data, creator economy dataset, socialblade alternative scraper, social media analytics api

# Actor input Schema

## `startUrls` (type: `array`):

Full socialblade.com URLs. Prefer /handle/ or /youtube/channel/{id} over the legacy /user/ form — see the note on identifierMismatch below.

## `profiles` (type: `array`):

Alternative to Start URLs — paste plain creator usernames or handles, one per box, e.g. mrbeast or khaby.lame. No need to build a URL. Every identifier here uses the Default Platform below and is resolved via the reliable handle URL form. Need different platforms mixed together? Paste full URLs into Start URLs instead.

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

Platform used for bare-string entries in Profiles.

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

Adds the last 15 daily snapshots plus a computed growth object (absolute/percent/avg-daily change) for the platform's primary metric. No extra HTTP request — already embedded in the same page fetch — but billed a small additional-data fee, and only when history is actually returned. Some platforms gate full history behind a paid SocialBlade tier; when that happens historyAvailable is false, growth is null, and nothing is charged.

## `rankLimit` (type: `string`):

SocialBlade's rankings tier. Not a literal creator count — SocialBlade caps a single request at 100 creators regardless of tier (100 and 500 both return the same 100; 10 actually returns 50). Leave empty (along with the other rankings fields) to skip rankings entirely — setting this is what triggers a rankings fetch, so it intentionally has no default.

## `rankMetric` (type: `string`):

Metric to sort the ranking by.

## `rankCountry` (type: `string`):

Two-letter ISO country code, or leave as global for worldwide rankings.

## `rankCategory` (type: `string`):

Filter rankings to a content category.

## `maxItems` (type: `integer`):

Hard cap on the number of creator rows collected (controls billing).

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

Maximum number of profile pages fetched in parallel.

## `minConcurrency` (type: `integer`):

Minimum number of pages processed in parallel.

## `maxRequestRetries` (type: `integer`):

Number of retries before a failed request is given up.

## `proxy` (type: `object`):

Leave empty — the actor already routes all traffic through its own built-in residential proxy at no extra cost to you. Only set this if you want to use your own proxies.

## Actor input object example

```json
{
  "startUrls": [
    "https://socialblade.com/youtube/handle/mrbeast"
  ],
  "profiles": [],
  "platform": "youtube",
  "includeHistory": true,
  "maxItems": 50,
  "maxConcurrency": 10,
  "minConcurrency": 1,
  "maxRequestRetries": 5
}
```

# 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 = {
    "startUrls": [
        "https://socialblade.com/youtube/handle/mrbeast"
    ],
    "profiles": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/socialblade-scraper").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 = {
    "startUrls": ["https://socialblade.com/youtube/handle/mrbeast"],
    "profiles": [],
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/socialblade-scraper").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 '{
  "startUrls": [
    "https://socialblade.com/youtube/handle/mrbeast"
  ],
  "profiles": []
}' |
apify call memo23/socialblade-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=memo23/socialblade-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SocialBlade Scraper Stats, Grade, Rank & Growth",
        "description": "Scrape public SocialBlade creator stats for YouTube, TikTok, Instagram, Twitch and Facebook — subscribers/followers, views, grade, rank, 15-day growth. Flags risky /user/ lookups that can silently resolve to the wrong creator. Mix profile and rankings URLs. JSON/CSV/Excel",
        "version": "0.0",
        "x-build-id": "ueA3st5nGG75VlYXq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~socialblade-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-socialblade-scraper",
                "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/memo23~socialblade-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-socialblade-scraper",
                "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/memo23~socialblade-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-socialblade-scraper",
                "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",
                "properties": {
                    "startUrls": {
                        "title": "SocialBlade URLs",
                        "type": "array",
                        "description": "Full socialblade.com URLs. Prefer /handle/ or /youtube/channel/{id} over the legacy /user/ form — see the note on identifierMismatch below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "profiles": {
                        "title": "Profiles (alternative to Start URLs)",
                        "type": "array",
                        "description": "Alternative to Start URLs — paste plain creator usernames or handles, one per box, e.g. mrbeast or khaby.lame. No need to build a URL. Every identifier here uses the Default Platform below and is resolved via the reliable handle URL form. Need different platforms mixed together? Paste full URLs into Start URLs instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Default platform",
                        "enum": [
                            "youtube",
                            "tiktok",
                            "instagram",
                            "twitch",
                            "facebook"
                        ],
                        "type": "string",
                        "description": "Platform used for bare-string entries in Profiles.",
                        "default": "youtube"
                    },
                    "includeHistory": {
                        "title": "Include 15-day history + growth rate",
                        "type": "boolean",
                        "description": "Adds the last 15 daily snapshots plus a computed growth object (absolute/percent/avg-daily change) for the platform's primary metric. No extra HTTP request — already embedded in the same page fetch — but billed a small additional-data fee, and only when history is actually returned. Some platforms gate full history behind a paid SocialBlade tier; when that happens historyAvailable is false, growth is null, and nothing is charged.",
                        "default": true
                    },
                    "rankLimit": {
                        "title": "Rankings tier",
                        "enum": [
                            "10",
                            "100",
                            "500"
                        ],
                        "type": "string",
                        "description": "SocialBlade's rankings tier. Not a literal creator count — SocialBlade caps a single request at 100 creators regardless of tier (100 and 500 both return the same 100; 10 actually returns 50). Leave empty (along with the other rankings fields) to skip rankings entirely — setting this is what triggers a rankings fetch, so it intentionally has no default."
                    },
                    "rankMetric": {
                        "title": "Rank by",
                        "enum": [
                            "mostsubscribed",
                            "mostviewed",
                            "mostuploads"
                        ],
                        "type": "string",
                        "description": "Metric to sort the ranking by."
                    },
                    "rankCountry": {
                        "title": "Rank country",
                        "enum": [
                            "global",
                            "us",
                            "gb",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "nl",
                            "ja",
                            "kr",
                            "in",
                            "br",
                            "mx",
                            "ca",
                            "au",
                            "ru",
                            "tr"
                        ],
                        "type": "string",
                        "description": "Two-letter ISO country code, or leave as global for worldwide rankings."
                    },
                    "rankCategory": {
                        "title": "Rank category",
                        "enum": [
                            "all",
                            "autos",
                            "comedy",
                            "education",
                            "entertainment",
                            "film",
                            "games",
                            "howto",
                            "music",
                            "news",
                            "nonprofits",
                            "people",
                            "pets",
                            "science",
                            "sports",
                            "tech",
                            "travel"
                        ],
                        "type": "string",
                        "description": "Filter rankings to a content category."
                    },
                    "maxItems": {
                        "title": "Maximum items to scrape",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on the number of creator rows collected (controls billing).",
                        "default": 50
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of profile pages fetched in parallel.",
                        "default": 10
                    },
                    "minConcurrency": {
                        "title": "Min concurrency",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Minimum number of pages processed in parallel.",
                        "default": 1
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Number of retries before a failed request is given up.",
                        "default": 5
                    },
                    "proxy": {
                        "title": "Proxy configuration (optional override)",
                        "type": "object",
                        "description": "Leave empty — the actor already routes all traffic through its own built-in residential proxy at no extra cost to you. Only set this if you want to use your own proxies."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
