# TikTok Profile Scraper — Followers, Bio, Engagement & Videos (`khadinakbar/tiktok-profile-scraper`) Actor

Extract TikTok profile data in bulk: followers, bio, verified status, video count, hearts, engagement rate & recent video stats. Input usernames or URLs, get structured JSON. Export scraped data, run via API, schedule and monitor runs, or integrate with other tools.

- **URL**: https://apify.com/khadinakbar/tiktok-profile-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Social media, Lead generation, AI
- **Stats:** 4 total users, 3 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 scraped tiktok profiles

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## TikTok Profile Scraper — Followers, Bio, Engagement Rate, Influencer Score & Video Stats

### What does TikTok Profile Scraper do?

TikTok Profile Scraper extracts complete profile data from TikTok accounts in bulk. Give it a list of usernames or profile URLs and get back structured JSON with followers, following count, total hearts, verified status, bio, bio link, region, recent video stats, a pre-calculated engagement rate, and an exclusive **Influencer Score (0–100)** — everything you need for influencer research, vetting, or lead generation without writing a single line of code.

### Why use TikTok Profile Scraper?

- **Purpose-built for profiles** — unlike general TikTok scrapers, this actor focuses exclusively on profile data, making it faster and simpler to use for bulk profile research
- **Influencer Score included** — a composite 0–100 score combining follower tier, audience loyalty, verified status, content volume, and engagement. Compare creators at a glance without building your own formula
- **Engagement rate when available** — computed from recent video performance and returned as a clean percentage where TikTok allows it. Always null-safe — your pipeline won't break if it's unavailable
- **Bio links decoded** — TikTok wraps external links through their redirect system. This actor decodes them so you get the actual destination URL
- **Cheaper than the competition** — see pricing comparison below
- **Bulk-first design** — paste a list of 100+ usernames and scrape them all in one run

### What data can TikTok Profile Scraper extract?

| Field | Type | Description |
|-------|------|-------------|
| `username` | string | TikTok handle (without @) |
| `display_name` | string | Public display name |
| `bio` | string\|null | Profile bio text |
| `bio_link` | string\|null | Decoded clickable link from bio |
| `follower_count` | number | Total followers |
| `following_count` | number | Accounts this user follows |
| `heart_count` | number | Cumulative likes across all videos |
| `video_count` | number | Total videos posted |
| `verified` | boolean | Has verification badge |
| `is_private` | boolean | Private account |
| `avatar_url` | string\|null | Profile picture URL |
| `region` | string\|null | 2-letter country code |
| `engagement_rate` | number\|null | `(avg likes+comments+shares) / followers × 100` |
| `avg_views_per_video` | number\|null | Average views across recent videos |
| `influencer_score` | number | Composite score 0–100 (see below) |
| `recent_videos` | array | Recent video stats (see below) |
| `profile_url` | string | Full TikTok profile URL |
| `scraped_at` | string | ISO 8601 timestamp |

**Each `recent_videos` item contains:** `video_id`, `title`, `description`, `play_count`, `like_count`, `comment_count`, `share_count`, `duration` (seconds), `hashtags` (array), `create_time` (ISO 8601), `cover_url`.

> **Note:** Video stats are returned on a best-effort basis. TikTok restricts video list access for some accounts depending on region and rate limits. When video data is unavailable, `recent_videos` will be an empty array and `engagement_rate` will be `null`. The `influencer_score` is always calculated from available profile data.

#### Influencer Score (0–100)

A composite metric that captures true influence beyond raw follower count:

| Component | Max Points | What it measures |
|-----------|-----------|-----------------|
| Follower tier | 30 | Account reach (nano → mega) |
| Heart/follower ratio | 20 | Audience loyalty over lifetime |
| Verified badge | 10 | Platform recognition |
| Video activity | 20 | Content consistency |
| Engagement rate | 20 | Recent content performance |

Score of 70+ = strong influencer. Score below 30 = low reach or low engagement.

### How to use TikTok Profile Scraper

#### Step 1 — Provide usernames

In the **TikTok usernames or profile URLs** field, enter one username per line:

````

charlidamelio
@khaby.lame
https://www.tiktok.com/@mrbeast

````

The `@` symbol and full URLs are both accepted.

#### Step 2 — Set limits

- **Max profiles to scrape** — cap the total run (useful for cost control)
- **Max recent videos per profile** — how many recent videos to fetch for engagement rate calculation (default: 12)
- **Include recent video stats** — disable this if you only want profile-level data and want faster runs

#### Step 3 — Run and export

Hit **Start**. Results appear in the **Output** tab as they complete. Export as JSON, CSV, or Excel.

#### API usage

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

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

const run = await client.actor('USERNAME/tiktok-profile-scraper').call({
    profiles: ['charlidamelio', 'khaby.lame', 'mrbeast'],
    maxResults: 100,
    scrapeRecentVideos: true,
    maxVideosPerProfile: 12,
});

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

#### Python usage

```python
from apify_client import ApifyClient

client = ApifyClient(token="YOUR_API_TOKEN")

run = client.actor("USERNAME/tiktok-profile-scraper").call(run_input={
    "profiles": ["charlidamelio", "khaby.lame", "mrbeast"],
    "maxResults": 100,
    "scrapeRecentVideos": True,
    "maxVideosPerProfile": 12,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["username"], item["follower_count"], item["engagement_rate"], item["influencer_score"])
```

### Pricing

This actor uses **pay-per-event (PPE) pricing** at a flat **$0.003 per profile** scraped — no subscriptions, no minimums.

| Profiles | Cost |
|----------|------|
| 10 profiles | ~$0.03 |
| 100 profiles | ~$0.30 |
| 1,000 profiles | ~$3.00 |
| 10,000 profiles | ~$30.00 |

#### How we compare to competitors

| | **This actor** | clockworks/tiktok-scraper |
|--|--|--|
| Price per profile | **$0.003** | $0.0037 (FREE tier avg) |
| Actor start fee | **$0.00005** | $0.001 |
| Single profile via API | **$0.00305** | $0.0047 |
| 100 profiles | **$0.30** | $0.47 |
| 1,000 profiles | **$3.00** | $4.70 |
| Influencer Score (0–100) | ✅ **included** | ❌ not available |
| Bio link decoded | ✅ **included** | ❌ not available |
| Purpose-built for profiles | ✅ | ❌ general scraper |

**19% cheaper per profile. 97% cheaper on actor start fee. 35% cheaper for single-profile API lookups.**
Exclusive features: Influencer Score and decoded bio links are not available in any competing actor.

### Use cases

**Influencer marketing research** — Vet potential brand partners before outreach. Check follower count, engagement rate, Influencer Score, and bio link to verify they drive real traffic.

**Competitor analysis** — Monitor a competitor brand's top creator partners. Track their follower growth and video performance over time by scheduling weekly runs.

**Lead generation** — Build a list of TikTok creators in a niche for partnership outreach. Export to CSV and import into your CRM.

**Audience research** — Analyze which creators your target audience follows. Look at region, verified status, and content themes.

**Trend monitoring** — Track Influencer Scores across a set of creators to spot rising talent before they get expensive.

### FAQ

**Does this require a TikTok account or cookies?**
No. This actor scrapes TikTok's public web without requiring any login or authentication.

**What happens with private accounts?**
Private accounts return profile-level data (followers, bio, video count) but no video content since TikTok doesn't expose that publicly. The `is_private` field will be `true`.

**Why is the engagement rate null for some profiles?**
Engagement rate requires recent video stats. TikTok restricts unauthenticated access to video lists for many accounts — particularly large public accounts. When video data is unavailable, `engagement_rate` and `avg_views_per_video` will be `null`. The Influencer Score is still calculated from follower count, heart count, video count, and verified status.

**Can I scrape thousands of profiles in one run?**
Yes. Set `maxResults` to the number you need. For very large lists (10,000+), consider splitting into multiple runs with scheduled tasks.

**How fresh is the data?**
Data is scraped live at run time — it reflects TikTok's current state when you run the actor.

**What if a username doesn't exist?**
The actor logs a warning and skips it. It won't crash or count it as a billed result.

### Works great with

- [TikTok Scraper](https://apify.com/clockworks/tiktok-scraper) — for scraping hashtags, search results, and individual videos

### Legal disclaimer

This actor is intended for lawful data collection from publicly available TikTok profiles. Users are responsible for compliance with applicable laws, TikTok's Terms of Service, and data protection regulations (GDPR, CCPA, etc.). Do not use this actor to collect data on minors or for purposes that violate TikTok's policies. Apify is not responsible for how users employ this tool.

***

*Export scraped data, run the scraper via API, schedule and monitor runs, or integrate with other tools.*

# Actor input Schema

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

Use this field when the user provides specific TikTok usernames (e.g. 'charlidamelio') or profile URLs (e.g. 'https://tiktok.com/@charlidamelio'). Enter one per line. The @ symbol is optional. Do NOT use this for keyword searches — use searchQuery for that.

## `maxResults` (type: `integer`):

Use this to cap total profiles processed. Useful for cost control. Set to a high number (e.g. 1000) to scrape all provided profiles.

## `scrapeRecentVideos` (type: `boolean`):

When enabled, fetches stats for the most recent videos (likes, views, comments, shares, hashtags). Enables engagement rate calculation. Disable to only get profile-level data and run faster.

## `maxVideosPerProfile` (type: `integer`):

Number of recent videos to fetch for engagement rate calculation and video stats. More videos = more accurate engagement rate but slower runs. Recommended: 12 (one page of TikTok profile).

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

Use Apify proxy (recommended) to avoid IP blocks. Datacenter proxies are used by default. Switch to residential if you get blocked consistently.

## Actor input object example

```json
{
  "profiles": [
    "charlidamelio",
    "khaby.lame"
  ],
  "maxResults": 10,
  "scrapeRecentVideos": true,
  "maxVideosPerProfile": 12,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset of scraped TikTok profile records. Each record contains full profile stats: username, display\_name, bio, bio\_link, follower\_count, following\_count, heart\_count, video\_count, verified, is\_private, avatar\_url, region, engagement\_rate, avg\_views\_per\_video, influencer\_score, recent\_videos, profile\_url, scraped\_at, source\_url.

# 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": [
        "charlidamelio",
        "khaby.lame"
    ],
    "maxResults": 10,
    "scrapeRecentVideos": true,
    "maxVideosPerProfile": 12,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/tiktok-profile-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 = {
    "profiles": [
        "charlidamelio",
        "khaby.lame",
    ],
    "maxResults": 10,
    "scrapeRecentVideos": True,
    "maxVideosPerProfile": 12,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/tiktok-profile-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 '{
  "profiles": [
    "charlidamelio",
    "khaby.lame"
  ],
  "maxResults": 10,
  "scrapeRecentVideos": true,
  "maxVideosPerProfile": 12,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call khadinakbar/tiktok-profile-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Profile Scraper — Followers, Bio, Engagement & Videos",
        "description": "Extract TikTok profile data in bulk: followers, bio, verified status, video count, hearts, engagement rate & recent video stats. Input usernames or URLs, get structured JSON. Export scraped data, run via API, schedule and monitor runs, or integrate with other tools.",
        "version": "1.0",
        "x-build-id": "52bhYZWQnKgLPLXWd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~tiktok-profile-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-tiktok-profile-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/khadinakbar~tiktok-profile-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-tiktok-profile-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/khadinakbar~tiktok-profile-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-tiktok-profile-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": {
                    "profiles": {
                        "title": "TikTok usernames or profile URLs",
                        "type": "array",
                        "description": "Use this field when the user provides specific TikTok usernames (e.g. 'charlidamelio') or profile URLs (e.g. 'https://tiktok.com/@charlidamelio'). Enter one per line. The @ symbol is optional. Do NOT use this for keyword searches — use searchQuery for that.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Maximum number of profiles to scrape",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Use this to cap total profiles processed. Useful for cost control. Set to a high number (e.g. 1000) to scrape all provided profiles.",
                        "default": 10
                    },
                    "scrapeRecentVideos": {
                        "title": "Include recent video stats",
                        "type": "boolean",
                        "description": "When enabled, fetches stats for the most recent videos (likes, views, comments, shares, hashtags). Enables engagement rate calculation. Disable to only get profile-level data and run faster.",
                        "default": true
                    },
                    "maxVideosPerProfile": {
                        "title": "Max recent videos per profile",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Number of recent videos to fetch for engagement rate calculation and video stats. More videos = more accurate engagement rate but slower runs. Recommended: 12 (one page of TikTok profile).",
                        "default": 12
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Use Apify proxy (recommended) to avoid IP blocks. Datacenter proxies are used by default. Switch to residential if you get blocked consistently.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```