# Social Media Stats Checker (`automation-lab/social-media-stats-checker`) Actor

Check follower counts and profile stats across Instagram, TikTok, YouTube, and Twitter/X in one run. HTTP-only, no browser. Outputs unified stats: followers, following, posts, verified status, bio, and avatar. 📊

- **URL**: https://apify.com/automation-lab/social-media-stats-checker.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, NaN 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.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

## Social Media Stats Checker

Check follower counts, subscriber numbers, and full profile stats across **Instagram**, **TikTok**, **YouTube**, and **Twitter/X** — all in a single run. No API key, no browser overhead, no separate tools. Just paste in usernames or profile URLs and get unified stats back in seconds.

Unlike running four separate scrapers, Social Media Stats Checker gives you a **normalized output format** across all platforms in one dataset. Monitor influencers, research competitors, track brand growth across channels — without juggling multiple tools.

---

### What does Social Media Stats Checker do?

Social Media Stats Checker fetches public profile statistics from four major social platforms using their native APIs and HTML endpoints. You provide a list of usernames or profile URLs, and it returns a unified stats object per profile: followers, following, post count, verified status, bio, and avatar.

It uses **HTTP-only requests** (no browser), making it fast and cheap. YouTube stats come from the InnerTube API (no auth needed), TikTok stats from page HTML, and Twitter/X stats from the GraphQL API using a guest token. Try it directly on the [Apify Store page](https://apify.com/automation-lab/social-media-stats-checker).

**Platforms supported:**
- 🎬 **YouTube** — subscriber count, video count, channel description, avatar
- 🎵 **TikTok** — followers, following, likes, video count, verified status
- 🐦 **Twitter/X** — followers, following, tweet count, verified/blue check status
- 📸 **Instagram** — followers, following, post count (requires session cookie)

---

### Who is Social Media Stats Checker for?

**📊 Social media managers and marketing teams**
- Track follower growth across all brand channels weekly
- Monitor competitor account growth in one dashboard
- Export to Google Sheets for automated reporting

**🔍 Influencer marketers and talent scouts**
- Screen multiple creator profiles before outreach
- Compare audience sizes across platforms for the same creator
- Verify follower counts before signing partnerships

**📈 Researchers and data analysts**
- Collect social proof data at scale for academic studies
- Track public figures and organizations across platforms
- Build datasets linking usernames to audience sizes

**🤖 Developers and automation builders**
- Add social stats to CRM records via API
- Build influencer scorecards with Zapier or Make
- Schedule daily stat snapshots with Apify's cron scheduling

---

### Why use Social Media Stats Checker?

- ✅ **All 4 platforms in one run** — no juggling separate tools
- ✅ **Normalized output** — same field names across all platforms (followers, posts, isVerified)
- ✅ **HTTP-only, no browser** — 256 MB memory, completes in seconds
- ✅ **Graceful error handling** — failed profiles return an error field, don't stop the run
- ✅ **Accepts URLs or usernames** — paste YouTube.com/@ links, TikTok.com/@ links, x.com/ — it handles them all
- ✅ **No API key required** — works without authentication for YouTube, TikTok, Twitter
- ✅ **Apify platform included** — scheduling, JSON/CSV/Excel export, webhooks, 5,000+ integrations

---

### What data can you extract?

| Field | YouTube | TikTok | Twitter/X | Instagram* |
|-------|---------|--------|-----------|------------|
| `platform` | ✅ | ✅ | ✅ | ✅ |
| `username` | ✅ | ✅ | ✅ | ✅ |
| `displayName` | ✅ | ✅ | ✅ | ✅ |
| `followers` | ✅ subscribers | ✅ | ✅ | ✅ |
| `following` | ❌ | ✅ | ✅ | ✅ |
| `posts` | ✅ video count | ✅ | ✅ tweet count | ✅ |
| `likes` | ❌ | ✅ total likes | ✅ favorites | ❌ |
| `isVerified` | ❌ | ✅ | ✅ blue check | ✅ |
| `bio` | ✅ | ✅ | ✅ | ✅ |
| `avatar` | ✅ | ✅ | ✅ | ✅ |
| `profileUrl` | ✅ | ✅ | ✅ | ✅ |
| `subscriberCountText` | ✅ "475M subscribers" | ❌ | ❌ | ❌ |

*Instagram requires a valid session cookie (`instagramCookie` input field). Without it, Instagram blocks unauthenticated requests.

---

### How much does it cost to check social media stats?

This Actor uses **pay-per-event** pricing — you pay only for profiles successfully checked. No monthly subscription. All Apify platform costs are **included**.

| | Free | Starter ($29/mo) | Scale ($199/mo) | Business ($999/mo) | Professional ($499/mo) | Enterprise ($3,999/mo) |
|---|---|---|---|---|---|---|
| **Per profile** | $0.002 | $0.00174 | $0.00136 | $0.00104 | $0.0007 | $0.000487 |
| **100 profiles** | $0.21 | $0.18 | $0.14 | $0.11 | $0.07 | $0.05 |
| **1,000 profiles** | $2.01 | $1.74 | $1.36 | $1.04 | $0.70 | $0.49 |

Plus a one-time start fee of $0.001 per run.

**Real-world cost examples:**

| Task | Profiles | Duration | Cost (Free tier) |
|---|---|---|---|
| Check 3 creator profiles | 3 | ~8s | ~$0.007 |
| Weekly influencer audit | 50 | ~2min | ~$0.10 |
| Competitor monitoring | 200 | ~8min | ~$0.40 |

On the **free plan ($5 credits)**, you can check ~2,450 profiles before needing to upgrade.

---

### How to check social media stats

1. **Go to** [Social Media Stats Checker](https://apify.com/automation-lab/social-media-stats-checker) on Apify Store
2. **Click "Try for free"** — no credit card required
3. **Add profiles** in the input form. Each entry needs a `platform` and either a `username` or `url`:
   ```json
   [
       { "platform": "youtube", "username": "MrBeast" },
       { "platform": "tiktok", "url": "https://www.tiktok.com/@charlidamelio" },
       { "platform": "twitter", "username": "elonmusk" }
   ]
````

4. **Click "Save & Run"**
5. **Download results** as JSON, CSV, or Excel from the Dataset tab

For scheduled monitoring (e.g., weekly snapshots), click **Schedule** and set a cron expression.

**Example inputs for different use cases:**

```json
// Monitor a brand's presence across platforms
{
    "profiles": [
        { "platform": "youtube", "username": "Nike" },
        { "platform": "tiktok", "username": "Nike" },
        { "platform": "twitter", "username": "Nike" },
        { "platform": "instagram", "username": "nike" }
    ]
}
```

```json
// Batch check multiple influencers
{
    "profiles": [
        { "platform": "tiktok", "username": "MrBeast" },
        { "platform": "tiktok", "username": "charlidamelio" },
        { "platform": "tiktok", "username": "khaby.lame" },
        { "platform": "tiktok", "username": "bellapoarch" }
    ]
}
```

***

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `profiles` | Array | — | **Required.** List of profiles to check. Each entry must have `platform` and either `username` or `url`. |
| `instagramCookie` | String | — | Optional Instagram session cookie for Instagram stats. Format: `sessionid=YOUR_SESSION_ID`. |
| `continueOnError` | Boolean | `true` | When `true`, failed profiles are included in output with an error field. When `false`, the first error stops the run. |
| `requestTimeoutSecs` | Integer | `30` | Maximum seconds to wait for each HTTP request. Range: 5–120. |

**Profile entry format:**

```json
{
    "platform": "youtube" | "tiktok" | "twitter" | "instagram",
    "username": "channelname",
    "url": "https://www.youtube.com/@channelname"
}
```

You can use either `username` or `url` — the actor will extract the username from URLs automatically.

***

### Output examples

Each profile in the dataset follows this structure:

```json
{
    "platform": "youtube",
    "username": "MrBeast",
    "displayName": "MrBeast",
    "profileUrl": "https://www.youtube.com/@MrBeast",
    "followers": 475000000,
    "following": null,
    "posts": 968,
    "likes": null,
    "isVerified": null,
    "bio": "SUBSCRIBE OR I'LL CRY",
    "avatar": "https://yt3.googleusercontent.com/...",
    "subscriberCountText": "475M subscribers",
    "fetchedAt": "2026-04-07T10:30:00.000Z",
    "error": null
}
```

```json
{
    "platform": "twitter",
    "username": "elonmusk",
    "displayName": "Elon Musk",
    "profileUrl": "https://x.com/elonmusk",
    "followers": 237804494,
    "following": 1309,
    "posts": 100793,
    "likes": 92847,
    "isVerified": true,
    "bio": "X/Tesla/SpaceX/Boring/Neuralink",
    "avatar": "https://pbs.twimg.com/profile_images/...",
    "subscriberCountText": null,
    "fetchedAt": "2026-04-07T10:30:15.000Z",
    "error": null
}
```

**Failed profile** (e.g., private account or blocked request):

```json
{
    "platform": "instagram",
    "username": "privateaccount",
    "followers": null,
    "error": "Instagram requires authentication to retrieve profile stats.",
    "fetchedAt": "2026-04-07T10:30:20.000Z"
}
```

***

### Tips for best results

- 🎯 **Start small** — check 5–10 profiles first to verify the data looks correct before running larger batches
- 📊 **Mix platforms** — the actor handles multiple platforms in one run, so combine YouTube + TikTok + Twitter profiles freely
- 🔗 **Use URLs when in doubt** — if a username lookup fails, try the full profile URL instead
- 📅 **Schedule weekly runs** — use Apify's scheduling to capture weekly follower snapshots automatically
- 📸 **Instagram requires a cookie** — Instagram blocks unauthenticated stat requests. Provide your `sessionid` cookie for Instagram profiles
- ⚡ **HTTP-only = very fast** — expect 2–5 seconds per profile, so 100 profiles takes ~4 minutes
- 🔄 **Use `continueOnError: true`** (default) — this ensures one broken profile doesn't cancel the rest

***

### Integrations

**📊 Social Media Stats Checker → Google Sheets**
Use Apify's native Google Sheets integration to automatically append weekly follower counts. Perfect for brand managers tracking growth trends in a shared dashboard.

**🔔 Social Media Stats Checker → Slack / Discord**
Set up a webhook to post weekly follower milestone alerts. When any tracked profile crosses 1M followers, fire a Slack message to the marketing channel.

**⚙️ Social Media Stats Checker → Make / Zapier**
Run the actor on a schedule and pipe results into your CRM. When a prospect's TikTok following exceeds 100K, automatically add them to your influencer outreach list.

**📧 Social Media Stats Checker → Email via Apify webhooks**
Configure a webhook to email you when a run completes. Attach the CSV dataset to a weekly digest.

**🔌 Social Media Stats Checker → Custom database**
Use the Apify API to fetch dataset results as JSON and insert them into PostgreSQL, Airtable, or BigQuery for time-series analysis.

***

### Using the Apify API

#### Node.js

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('automation-lab/social-media-stats-checker').call({
    profiles: [
        { platform: 'youtube', username: 'MrBeast' },
        { platform: 'tiktok', username: 'charlidamelio' },
        { platform: 'twitter', username: 'elonmusk' },
    ],
    continueOnError: true,
});

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

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("automation-lab/social-media-stats-checker").call(run_input={
    "profiles": [
        {"platform": "youtube", "username": "MrBeast"},
        {"platform": "tiktok", "username": "charlidamelio"},
        {"platform": "twitter", "username": "elonmusk"},
    ],
    "continueOnError": True,
})

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

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~social-media-stats-checker/runs" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "profiles": [
      {"platform": "youtube", "username": "MrBeast"},
      {"platform": "tiktok", "username": "charlidamelio"},
      {"platform": "twitter", "username": "elonmusk"}
    ],
    "continueOnError": true
  }'
```

***

### Use with AI agents via MCP

Social Media Stats Checker is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).

Add the Apify MCP server to your AI client — this gives you access to all Apify actors, including this one:

#### Setup for Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/social-media-stats-checker"
```

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com?tools=automation-lab/social-media-stats-checker"
        }
    }
}
```

Your AI assistant will use OAuth to authenticate with your Apify account on first use.

#### Example prompts

Once connected, try asking your AI assistant:

- "Use automation-lab/social-media-stats-checker to check the follower counts for @MrBeast on YouTube and @charlidamelio on TikTok"
- "Check the Twitter follower counts for elonmusk, BarackObama, and BillGates and tell me who has the most followers"
- "Get the subscriber count and video count for the Veritasium YouTube channel"

Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

***

### Is it legal to check social media stats?

Yes — Social Media Stats Checker only accesses **publicly available profile statistics**. Follower counts, bio text, and verified status are displayed publicly on each platform without login. This actor does not access private messages, private posts, or any data behind authentication.

The actor operates in full compliance with ethical web scraping guidelines:

- Only reads data visible to any anonymous visitor
- Does not store credentials or session tokens beyond a single run
- Does not use scraped data to spam, harass, or impersonate anyone
- Complies with GDPR by only handling publicly visible, non-sensitive profile metadata

For Instagram specifically, session cookies are optional and user-provided — the actor does not generate or store credentials.

Users are responsible for ensuring their use of the data complies with each platform's Terms of Service and applicable data protection laws in their jurisdiction.

***

### FAQ

**How fast does it check profiles?**
Each profile takes 2–8 seconds depending on the platform (YouTube InnerTube API is fastest, Twitter GraphQL takes slightly longer due to token resolution). For a batch of 50 profiles, expect 3–5 minutes total.

**How much does it cost to check 1,000 social media profiles?**
On the Free tier: ~$2.01 ($0.002/profile + $0.001 start fee). On the Scale plan ($199/mo), that drops to ~$1.37. The first ~2,450 profiles are covered by Apify's $5 free credits.

**Why doesn't Instagram work without a cookie?**
Instagram deprecated public access to profile stats via unauthenticated HTTP requests in late 2023. Unlike TikTok and YouTube which still expose public data in page HTML or lightweight APIs, Instagram now requires a valid browser session. To use Instagram, provide your `sessionid` cookie in the `instagramCookie` input field. See: [How to get Instagram session ID](https://www.google.com/search?q=how+to+get+instagram+session+id+cookie).

**Is this different from the official social media APIs?**
Yes. Official APIs (YouTube Data API, Twitter API v2) have strict rate limits, require developer account registration, and charge per request at scale. This actor uses the same public endpoints as the browser — no API key, no rate limit registration, and no per-request API fees.

**Why are some fields null?**
Some platforms don't expose certain stats in their public APIs. For example, YouTube doesn't expose a "following" count (channels don't follow other channels publicly), and Instagram doesn't expose `likes`. Fields that aren't available are returned as `null` rather than omitted.

**What happens if a username doesn't exist?**
The profile is returned with `error` set to a human-readable message and all stat fields set to `null`. With `continueOnError: true` (default), the run continues to the next profile.

**Can I use profile URLs instead of usernames?**
Yes — the actor accepts full URLs like `https://www.youtube.com/@MrBeast`, `https://www.tiktok.com/@charlidamelio`, or `https://x.com/elonmusk`. It extracts the username automatically.

***

### Other social media tools

Looking for more detailed data from specific platforms? Check out our other automation-lab scrapers:

- [Instagram Scraper](https://apify.com/automation-lab/instagram-scraper) — full posts, stories, and profile data from Instagram
- [Instagram Comments Scraper](https://apify.com/automation-lab/instagram-comments-scraper) — extract comments from Instagram posts
- [TikTok Profile Scraper](https://apify.com/automation-lab/tiktok-profile-scraper) — detailed TikTok profile data and video lists
- [TikTok Scraper](https://apify.com/automation-lab/tiktok-scraper) — TikTok videos, hashtags, and user data
- [Twitter Scraper](https://apify.com/automation-lab/twitter-scraper) — tweets, profiles, and search results from X/Twitter
- [Twitter Followers Scraper](https://apify.com/automation-lab/twitter-followers-scraper) — extract follower/following lists from X profiles
- [YouTube Channel Scraper](https://apify.com/automation-lab/youtube-channel-scraper) — full video lists and channel metadata from YouTube
- [Social Media Profile Finder](https://apify.com/automation-lab/social-media-profile-finder) — find social media profiles by name or company

# Actor input Schema

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

Add one or more social media profiles to check. Each entry requires a platform and either a URL or username.

## `instagramCookie` (type: `string`):

Optional Instagram session cookie for fetching Instagram profile stats. Instagram now requires authentication for public profile data. Format: 'sessionid=YOUR\_SESSION\_ID'. Get it from browser DevTools → Application → Cookies → instagram.com.

## `continueOnError` (type: `boolean`):

When enabled, profiles that fail to load (private, deleted, or blocked) are included in the output with an error field instead of stopping the run.

## `requestTimeoutSecs` (type: `integer`):

Maximum time to wait for each HTTP request before timing out.

## Actor input object example

```json
{
  "profiles": [
    {
      "platform": "youtube",
      "username": "MrBeast"
    },
    {
      "platform": "tiktok",
      "username": "charlidamelio"
    },
    {
      "platform": "twitter",
      "username": "elonmusk"
    }
  ],
  "continueOnError": true,
  "requestTimeoutSecs": 30
}
```

# 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 = {
    "profiles": [
        {
            "platform": "youtube",
            "username": "MrBeast"
        },
        {
            "platform": "tiktok",
            "username": "charlidamelio"
        },
        {
            "platform": "twitter",
            "username": "elonmusk"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/social-media-stats-checker").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 = { "profiles": [
        {
            "platform": "youtube",
            "username": "MrBeast",
        },
        {
            "platform": "tiktok",
            "username": "charlidamelio",
        },
        {
            "platform": "twitter",
            "username": "elonmusk",
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/social-media-stats-checker").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 '{
  "profiles": [
    {
      "platform": "youtube",
      "username": "MrBeast"
    },
    {
      "platform": "tiktok",
      "username": "charlidamelio"
    },
    {
      "platform": "twitter",
      "username": "elonmusk"
    }
  ]
}' |
apify call automation-lab/social-media-stats-checker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Social Media Stats Checker",
        "description": "Check follower counts and profile stats across Instagram, TikTok, YouTube, and Twitter/X in one run. HTTP-only, no browser. Outputs unified stats: followers, following, posts, verified status, bio, and avatar. 📊",
        "version": "0.1",
        "x-build-id": "eJTVx7RZKW1qawHhD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~social-media-stats-checker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-social-media-stats-checker",
                "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~social-media-stats-checker/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-social-media-stats-checker",
                "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~social-media-stats-checker/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-social-media-stats-checker",
                "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",
                "required": [
                    "profiles"
                ],
                "properties": {
                    "profiles": {
                        "title": "📋 Profiles to check",
                        "type": "array",
                        "description": "Add one or more social media profiles to check. Each entry requires a platform and either a URL or username.",
                        "default": []
                    },
                    "instagramCookie": {
                        "title": "Instagram session cookie",
                        "type": "string",
                        "description": "Optional Instagram session cookie for fetching Instagram profile stats. Instagram now requires authentication for public profile data. Format: 'sessionid=YOUR_SESSION_ID'. Get it from browser DevTools → Application → Cookies → instagram.com."
                    },
                    "continueOnError": {
                        "title": "Continue on error",
                        "type": "boolean",
                        "description": "When enabled, profiles that fail to load (private, deleted, or blocked) are included in the output with an error field instead of stopping the run.",
                        "default": true
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Maximum time to wait for each HTTP request before timing out.",
                        "default": 30
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
