# SocialBlade Creator Stats Scraper (`automation-lab/socialblade-creator-stats-scraper`) Actor

📈 Extract public creator statistics, grades, ranks, linked socials, and 15-day history from SocialBlade across five major social platforms.

- **URL**: https://apify.com/automation-lab/socialblade-creator-stats-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Creator Stats Scraper

Track public creator growth without manually copying numbers from SocialBlade.

SocialBlade Creator Stats Scraper turns creator profile pages into analysis-ready JSON, CSV, Excel, or API output. Supply SocialBlade URLs or platform and username pairs and receive one structured record per creator.

It supports **YouTube, TikTok, Instagram, Twitch, and Facebook** creator profiles.

Each successful record can include audience size, views, uploads, SocialBlade grade, global and category ranks, profile metadata, linked social accounts, and optional 15-day history.

### What does SocialBlade Creator Stats Scraper do?

The Actor visits public SocialBlade creator profiles and extracts the structured profile state used by the page.

Use it to:

- 📈 snapshot subscriber or follower counts;
- 🏆 compare SocialBlade grades and ranks;
- 🎬 collect views and upload totals;
- 🌍 segment creators by country and category;
- 🔗 discover linked public social profiles;
- 🗓️ retain the available 15-day daily history;
- 🔁 run the same watchlist on a schedule.

The Actor returns source facts rather than modeled sponsorship or earnings claims.

### Who is it for?

#### Influencer agencies

Refresh a client or prospect watchlist before campaign planning and reporting.

#### Brand partnership teams

Compare potential partners by audience, momentum, country, category, and rank.

#### Talent managers

Monitor creators across platforms and preserve snapshots for negotiations.

#### Creator economy analysts

Build repeatable datasets for growth, ranking, and market research.

#### Data and automation teams

Feed normalized creator statistics into warehouses, dashboards, alerts, and enrichment workflows.

### Why use this SocialBlade scraper?

Manual profile checks do not scale and are difficult to reproduce.

This Actor provides:

- one stable record shape across five platforms;
- URL input and structured platform/username input;
- canonical URL deduplication;
- typed success and error records;
- nested history that stays attached to its creator;
- conservative request concurrency;
- browser-like HTTP requests with proxy fallback;
- pay-per-successful-profile charging.

### Supported creator platforms

| Platform | Structured lookup | Example SocialBlade route |
|---|---|---|
| YouTube | `{ "platform": "youtube", "username": "mrbeast" }` | `/youtube/handle/mrbeast` |
| TikTok | `{ "platform": "tiktok", "username": "creator" }` | `/tiktok/user/creator` |
| Instagram | `{ "platform": "instagram", "username": "creator" }` | `/instagram/user/creator` |
| Twitch | `{ "platform": "twitch", "username": "ninja" }` | `/twitch/user/ninja` |
| Facebook | `{ "platform": "facebook", "username": "page" }` | `/facebook/page/page` |

YouTube channel IDs beginning with `UC` are converted to SocialBlade channel routes.

### What data can you extract?

| Field | Type | Description |
|---|---|---|
| `status` | string | `ok` or `error` |
| `platform` | string | YouTube, TikTok, Instagram, Twitch, or Facebook |
| `username` | string | Resolved public creator identifier |
| `profileId` | string | Source platform or SocialBlade creator ID |
| `displayName` | string | Public creator or channel name |
| `profileUrl` | string | Canonical SocialBlade profile URL |
| `avatarUrl` | string | Public avatar image URL |
| `bannerUrl` | string | Public banner image URL when available |
| `description` | string | Public profile description |
| `country` | string | Country code when available |
| `category` | string | Creator or channel category |
| `createdAt` | string | Source account creation date when exposed |
| `audience` | number | Subscribers or followers |
| `views` | number | Total view count when supported |
| `uploads` | number | Video, upload, or post count when supported |
| `grade` | string | SocialBlade grade |
| `ranks` | object | SocialBlade, audience, views, country, and category ranks |
| `linkedSocials` | array | Linked public social profiles |
| `history` | array | Available daily audience, views, and upload snapshots |
| `scrapedAt` | string | UTC extraction time |

Fields unavailable for a particular platform remain absent or null rather than being guessed.

### How to scrape creator statistics

1. Open the Actor input page.
2. Add one or more SocialBlade profile URLs.
3. Alternatively, add platform and username pairs.
4. Keep **Include 15-day history** enabled for trend snapshots.
5. Set a small maximum profile count for your first run.
6. Start the Actor.
7. Export the dataset or connect it to your workflow.

A successful profile is charged only after useful source data is extracted.

### Input example: profile URLs

```json
{
  "profileUrls": [
    { "url": "https://socialblade.com/youtube/handle/mrbeast" },
    { "url": "https://socialblade.com/twitch/user/ninja" }
  ],
  "includeHistory": true,
  "maxProfiles": 2,
  "maxConcurrency": 2
}
````

SocialBlade URLs must use a supported creator profile route.

### Input example: platform and username

```json
{
  "profiles": [
    { "platform": "youtube", "username": "mrbeast" },
    { "platform": "twitch", "username": "ninja" }
  ],
  "includeHistory": true,
  "maxProfiles": 2
}
```

The Actor deduplicates targets that resolve to the same canonical SocialBlade URL.

### Output example

```json
{
  "status": "ok",
  "input": "youtube:mrbeast",
  "platform": "youtube",
  "username": "mrbeast",
  "profileId": "UCX6OQ3DkcsbYNE6H8uQQuVA",
  "displayName": "MrBeast",
  "profileUrl": "https://socialblade.com/youtube/handle/mrbeast",
  "country": "US",
  "category": "entertainment",
  "audience": 508000000,
  "views": 133786496664,
  "uploads": 993,
  "grade": "A++",
  "ranks": {
    "socialBlade": 1,
    "audience": 1,
    "views": 6,
    "country": 1,
    "category": 1
  },
  "linkedSocials": [
    { "url": "https://instagram.com/mrbeast", "title": "Follow" }
  ],
  "historyIncluded": true,
  "history": [
    {
      "date": "2026-07-05T00:00:00.000Z",
      "subscribers": 506000000,
      "views": 132387923880,
      "videos": 991
    }
  ],
  "fetchRoute": "proxy",
  "scrapedAt": "2026-07-19T00:00:00+00:00"
}
```

Counts change over time; this example demonstrates the output shape, not guaranteed current values.

### How much does it cost to scrape SocialBlade creator stats?

The Actor uses pay-per-event pricing:

- a small one-time run-start charge;
- one creator-profile event for each successfully extracted profile;
- no profile charge for validation or fetch error records.

The formula-derived BRONZE profile price is **$0.00442 per successful profile**, or about $4.42 per 1,000 profiles, before ordinary platform usage. Higher Apify plans receive tiered discounts; the canonical curve is sized so even the DIAMOND tier covers measured compute and residential fallback cost at sustained volume.

Check the live Pricing tab before a production run because platform pricing is authoritative.

Residential proxy fallback may contribute ordinary platform proxy usage billed by Apify.

### Scheduling creator watchlists

A scheduled watchlist turns snapshots into monitoring data.

Recommended workflow:

1. save a fixed profile list in an Apify Task;
2. run it daily or weekly with an Apify Schedule;
3. export each run to a warehouse or spreadsheet;
4. calculate change from previous snapshots;
5. alert when audience or rank movement crosses a threshold.

The source normally exposes about 15 daily history rows, but availability varies by creator.

### Growth and ranking analysis tips

- Compare snapshots captured at the same time of day.
- Keep `profileId` as the durable join key.
- Treat ranks as directional signals, not absolute performance scores.
- Separate platform-specific comparisons when audience semantics differ.
- Preserve `scrapedAt` for reproducibility.
- Inspect `historyIncluded` before calculating history-based growth.
- Do not treat missing optional history as a failed profile.

### Error handling and data quality

Invalid inputs produce uncharged error records with `status: "error"`.

The run fails when every supplied target fails extraction. This prevents automation pipelines from silently accepting an empty success.

Common error causes include:

- unsupported SocialBlade routes;
- deleted or unavailable creators;
- temporary Cloudflare changes;
- a changed embedded application-state shape;
- disabled or misconfigured proxy access.

Successful rows and error rows can coexist in a watchlist run.

### Proxy and concurrency guidance

SocialBlade frequently blocks direct and datacenter traffic.

The default configuration tries a direct request and then uses an Apify residential US proxy fallback.

Keep concurrency at 1–2 for ordinary watchlists. The maximum is intentionally limited to 5.

If a custom proxy is used, choose a stable geography and avoid rotating a creator through many retries.

### Export and integrations

Apify datasets support JSON, CSV, Excel, XML, and RSS exports.

Useful integration patterns include:

- Google Sheets for campaign shortlists;
- Slack alerts for rank changes;
- Make or Zapier for no-code enrichment;
- BigQuery or Snowflake for historical analysis;
- webhooks for run-completion processing;
- Python or Node.js for custom scoring;
- Apify Schedules for recurring watchlists.

### Use with the Apify API: cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~socialblade-creator-stats-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "profiles": [{"platform":"youtube","username":"mrbeast"}],
    "includeHistory": true,
    "maxProfiles": 1
  }'
```

Poll the returned run ID, then read the run's default dataset.

### Use with the Apify API: JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const input = {
  profiles: [{ platform: 'youtube', username: 'mrbeast' }],
  includeHistory: true,
  maxProfiles: 1,
};

const run = await client.actor(
  'automation-lab/socialblade-creator-stats-scraper'
).call(input);

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Keep API tokens in environment variables or a secret manager.

### Use with the Apify API: Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor(
    "automation-lab/socialblade-creator-stats-scraper"
).call(run_input={
    "profiles": [{"platform": "youtube", "username": "mrbeast"}],
    "includeHistory": True,
    "maxProfiles": 1,
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

The same dataset view is available through the Console and API.

### Use with MCP and AI assistants

Connect Apify's MCP server to Claude Code or another compatible client.

#### Claude Code

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/socialblade-creator-stats-scraper"
```

#### Claude Desktop

Add this server to your Claude Desktop configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/socialblade-creator-stats-scraper"
    }
  }
}
```

#### Cursor

Open **Cursor Settings → MCP**, add a remote HTTP server, and use the same `https://mcp.apify.com?tools=automation-lab/socialblade-creator-stats-scraper` URL.

#### VS Code

Open the MCP server configuration in VS Code, add an HTTP server named `apify`, and use the same actor-scoped MCP URL.

Example prompts:

- “Get the latest SocialBlade stats and ranks for these five creators.”
- “Compare available 15-day audience growth across this YouTube watchlist.”
- “Return creators with an A or better SocialBlade grade.”
- “Export the results as a table grouped by country.”

### Responsible and legal use

The Actor extracts publicly available creator-profile data.

You are responsible for complying with applicable laws, platform terms, and contractual obligations.

Do not use the output for harassment, discrimination, invasive profiling, or decisions that require consent or protected personal data.

Use reasonable schedules and avoid unnecessary repeated requests.

SocialBlade and the supported social platforms are trademarks of their respective owners. This Actor is not affiliated with or endorsed by them.

### Limitations

- SocialBlade may change its page or embedded state without notice.
- Optional history can be absent for an otherwise valid profile.
- Not every metric exists on every platform.
- Private, deleted, disabled, or unsupported profiles may return errors.
- This Actor does not access paid SocialBlade dashboards or private APIs.
- It does not estimate sponsorship value or earnings.
- It does not search SocialBlade rankings or discover creators in v1.
- Platform counts may be rounded or delayed by the source.

### Troubleshooting

#### Why did I receive an error record?

Check that the URL is a creator profile on `socialblade.com` and that its platform is supported. Open the URL manually to confirm the creator exists.

#### Why did the run fail instead of returning an empty dataset?

All targets failed. The Actor deliberately exits non-zero on total extraction failure so scheduled pipelines can alert rather than silently continue.

#### Why is history empty?

The creator profile was useful, but SocialBlade did not expose history for that target. Check `historyIncluded` and preserve the current snapshot.

#### Why is the proxy route shown?

Direct traffic was blocked and the residential fallback delivered the public profile state.

### FAQ

#### Can I mix platforms in one run?

Yes. URL and structured inputs can include all five supported platforms.

#### Are duplicate profiles charged twice?

No. Targets resolving to the same canonical SocialBlade URL are deduplicated before extraction.

#### Are failed records charged as creator profiles?

No. The profile event is emitted only after useful profile data is parsed.

#### Can I disable history?

Yes. Set `includeHistory` to `false` for smaller output records.

#### Can I disable the direct attempt?

Yes. Set `directFirst` to `false` when you want to go directly to the configured proxy.

#### Does it require a SocialBlade login?

No. The Actor uses public creator profile pages only.

### Related scrapers

Combine creator snapshots with other Automation Lab actors when a workflow needs source-specific content:

- [YouTube Channel Search Scraper](https://apify.com/automation-lab/youtube-channel-search-scraper) for creator discovery;
- [YouTube Channel Scraper](https://apify.com/automation-lab/youtube-channel-scraper) for platform-native channel metrics;
- [Instagram Scraper](https://apify.com/automation-lab/instagram-scraper) for platform-native profile and content enrichment;
- [Twitch Channel Stream Schedule Scraper](https://apify.com/automation-lab/twitch-channel-stream-schedule-scraper) for stream planning data.

Choose related actors only when their current Store scope matches your workflow.

### Support

For reproducible support requests, include:

- the Actor run ID;
- a redacted example input;
- the affected SocialBlade URL;
- whether the issue affects every target or one creator;
- the error record and relevant log message.

Do not include your Apify token in support messages.

# Actor input Schema

## `profileUrls` (type: `array`):

Public SocialBlade creator profile URLs for YouTube, TikTok, Instagram, Twitch, or Facebook.

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

Optional creator lookups such as {"platform":"twitch","username":"ninja"}.

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

Include the public daily audience, view, and upload history when SocialBlade provides it.

## `maxProfiles` (type: `integer`):

Maximum number of unique valid profiles to fetch in this run.

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

Parallel SocialBlade requests. Keep this conservative to reduce blocking.

## `directFirst` (type: `boolean`):

Try a free direct request before using the configured proxy fallback.

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

Residential US is recommended because SocialBlade commonly blocks datacenter traffic.

## Actor input object example

```json
{
  "profileUrls": [
    {
      "url": "https://socialblade.com/youtube/handle/mrbeast"
    }
  ],
  "profiles": [
    {
      "platform": "youtube",
      "username": "mrbeast"
    }
  ],
  "includeHistory": true,
  "maxProfiles": 2,
  "maxConcurrency": 2,
  "directFirst": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "profileUrls": [
        {
            "url": "https://socialblade.com/youtube/handle/mrbeast"
        }
    ],
    "profiles": [
        {
            "platform": "youtube",
            "username": "mrbeast"
        }
    ],
    "includeHistory": true,
    "maxProfiles": 2,
    "maxConcurrency": 2,
    "directFirst": true,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/socialblade-creator-stats-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 = {
    "profileUrls": [{ "url": "https://socialblade.com/youtube/handle/mrbeast" }],
    "profiles": [{
            "platform": "youtube",
            "username": "mrbeast",
        }],
    "includeHistory": True,
    "maxProfiles": 2,
    "maxConcurrency": 2,
    "directFirst": True,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/socialblade-creator-stats-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 '{
  "profileUrls": [
    {
      "url": "https://socialblade.com/youtube/handle/mrbeast"
    }
  ],
  "profiles": [
    {
      "platform": "youtube",
      "username": "mrbeast"
    }
  ],
  "includeHistory": true,
  "maxProfiles": 2,
  "maxConcurrency": 2,
  "directFirst": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call automation-lab/socialblade-creator-stats-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SocialBlade Creator Stats Scraper",
        "description": "📈 Extract public creator statistics, grades, ranks, linked socials, and 15-day history from SocialBlade across five major social platforms.",
        "version": "0.1",
        "x-build-id": "HuNK7n3kb8oskwzmz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~socialblade-creator-stats-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-socialblade-creator-stats-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/automation-lab~socialblade-creator-stats-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-socialblade-creator-stats-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/automation-lab~socialblade-creator-stats-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-socialblade-creator-stats-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": {
                    "profileUrls": {
                        "title": "SocialBlade profile URLs",
                        "type": "array",
                        "description": "Public SocialBlade creator profile URLs for YouTube, TikTok, Instagram, Twitch, or Facebook.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "profiles": {
                        "title": "Platform and username pairs",
                        "type": "array",
                        "description": "Optional creator lookups such as {\"platform\":\"twitch\",\"username\":\"ninja\"}."
                    },
                    "includeHistory": {
                        "title": "Include 15-day history",
                        "type": "boolean",
                        "description": "Include the public daily audience, view, and upload history when SocialBlade provides it.",
                        "default": true
                    },
                    "maxProfiles": {
                        "title": "Maximum profiles",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of unique valid profiles to fetch in this run.",
                        "default": 20
                    },
                    "maxConcurrency": {
                        "title": "Maximum concurrency",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Parallel SocialBlade requests. Keep this conservative to reduce blocking.",
                        "default": 2
                    },
                    "directFirst": {
                        "title": "Try a direct request first",
                        "type": "boolean",
                        "description": "Try a free direct request before using the configured proxy fallback.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential US is recommended because SocialBlade commonly blocks datacenter traffic.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
