# Tiktok Trending Videos Scraper (`scrapelabsapi/tiktok-trending-videos-scraper`) Actor

- **URL**: https://apify.com/scrapelabsapi/tiktok-trending-videos-scraper.md
- **Developed by:** [ScrapeLabs](https://apify.com/scrapelabsapi) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## 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 Trending Videos Scraper — The Ultimate Tool to Extract Viral TikTok Data Effortlessly 🚀

The TikTok Trending Videos Scraper is a powerful tool that extracts real-time viral TikTok videos along with detailed metadata like titles, descriptions, engagement stats, and creator info. Perfect for marketers, creators, and analysts, it helps you track trends, study competitors, and build data-driven content strategies—far more effectively than basic TikTok scraper extensions or GitHub scripts. 🚀

### 🤔 What does TikTok Trending Videos Scraper do? / What is TikTok Trending Videos Scraper?

The TikTok Trending Videos Scraper is a powerful tool designed to extract real-time trending TikTok videos, along with enriched metadata like video titles, descriptions, durations, author details, and engagement statistics. Whether you're a marketer, creator, analyst, or growth strategist, this scraper allows you to track what’s trending and why—helping you make smarter, data-driven decisions.

Using this tool, you can effortlessly analyze viral trends, compare competitor performance, and gather insights for campaigns or TikTok content strategies. It also integrates seamlessly with platforms like Apify, making it perfect for workflow automation.

This tool is also ideal for users searching for:  
tiktok scraper, tiktok scraper python, tiktok-scraper github, tiktok scraper extension, tiktok scraper apify, tiktok-scraper npm, and even clockworks tiktok scraper—because it offers a more powerful, modern, and reliable solution. ✨

* * *

### 📊 What TikTok Trending Videos Scraper can I extract?

Here is a clear breakdown of the data you can extract using our TikTok Trending Videos Scraper:

| Data Type | Description |
| --- | --- |
| Video ID | Unique video identifier |
| Video URL | Direct link to the TikTok video |
| Thumbnail / Cover | Video cover image |
| Title | Video title including emoji or hashtags |
| Description | Full TikTok post description |
| Duration | Length in seconds |
| Author Name | Creator’s username |
| Author Profile URL | Link to creator’s page |
| Engagement Stats | Likes, comments, shares, plays, saves |
| Country / Region | Geographic source of trending data |
| Sorting Metrics | Views, likes, reposts, etc. |
| More Metadata | Additional scraped video info |

This powerful extractor helps businesses and content creators keep up with TikTok’s fast-moving environment while simplifying research, trend discovery, and competitor tracking. 🔍✨

* * *

#### ⭐ Key Features of TikTok Trending Videos Scraper

Our TikTok Trending Videos Scraper comes packed with advanced capabilities you won’t find in typical tiktok scraper, tiktok scraper python, tiktok scraper extension, or tiktok scraper GitHub projects. Here’s why it stands out:

*   🎯 Real-Time Trending Data — Capture the hottest videos from any country instantly.  
      
    
*   🔍 Advanced Filters — Sort by likes, views, comments, reposts, or time period (7 or 30 days).  
      
    
*   📈 Rich Metadata Extraction — Includes author details, engagement stats, video performance insights, and more.  
      
    
*   🧩 Easy Input Structure — No technical knowledge required—just plug in your country and run.  
      
    
*   🧠 Designed for Trend Analysis — Perfect for marketers, influencer researchers, and brand strategists.  
      
    
*   ⚙️ Automation-Ready — Integrates with Apify workflows, webhooks, and third-party tools.  
      
    
*   🔗 Multi-format Export — Download results in JSON, CSV, XML, Excel, or HTML.  
      
    
*   🛠 Better Than GitHub or NPM Scrapers — Unlike simple tiktok-scraper npm packages or tiktok scraper python repos, this tool provides stable, reliable scraping with enriched data.  
      
    

With all these features, it’s a robust alternative to clockworks TikTok scraper, browser extensions, or outdated GitHub projects.

* * *

### 🧭 How to use TikTok Trending Videos Scraper

Using the scraper is incredibly simple—even if you’ve never used a tiktok scraper apify tool before. Follow this step-by-step guide:

1.  Log in to Apify  
    Create a free account or sign in. 🌐  
      
    
2.  Select the Actor  
    Search for “TikTok Trending Videos Scraper” in the Apify Store.  
      
    
3.  Enter Input Data  
    Add your desired inputs—such as the country, time period, or sorting method.  
      
    
4.  Choose Options  
    Customize filters (likes, views, comments, etc.).  
      
    
5.  Run the Actor  
    Click Start, and the TikTok Trending Videos Scraper will extract the data automatically. ⚡  
      
    
6.  Download Results  
    Export your data in CSV, JSON, Excel, HTML, JSONL, or XML format.  
      
    

This intuitive process makes it far superior to manual scraping or unstable tiktok scraper extensions or unsupported GitHub scripts.

* * *

### 🎯 Use Cases

The TikTok Trending Videos Scraper is an indispensable tool across industries. Here’s how businesses and creators are using it:

*   📊 Trend Analysis — Understand what formats, sounds, and topics are exploding in popularity.  
      
    
*   🧠 Content Strategy — Create high-performance videos by modeling what’s currently going viral.  
      
    
*   🧩 Influencer Research — Identify breakout creators in your niche.  
      
    
*   📝 Competitive Benchmarking — Track competitor performance over time.  
      
    
*   🚀 Marketing Campaign Optimization — Build campaigns around trending content styles.  
      
    
*   🧬 AI + Data Pipelines — Feed structured TikTok data into machine learning or analytics systems.  
      
    
*   🎧 Sound & Hashtag Discovery — Capture which audios and hashtags dominate the platform.  
      
    

This makes it an essential tool for brands, media agencies, creators, and SaaS companies.

* * *

### 💎 Why choose us?

Our TikTok Trending Videos Scraper is built for performance, accuracy, and ease of use.

*   ⚡ Fast & Reliable — Engineered for stable, high-volume scraping.  
      
    
*   🔍 Ultra-Detailed Metadata — Extracts significantly more data than basic TikTok APIs or extensions.  
      
    
*   🧰 Better Than DIY Tools — Avoid the complexity of tiktok scraper python, github scrapers, or npm packages.  
      
    
*   🧩 Plug-and-Play Simplicity — No coding required—ideal for beginners and professionals.  
      
    
*   🛡 Secure & Compliant — Does not extract private or sensitive user data.  
      
    
*   🔄 Integrates With Everything — Zapier, Make, Google Sheets, CRMs, automation tools, and more.  
      
    
*   🏆 Built for Scale — Whether you need 100 videos or 100k, the scraper handles it seamlessly.  
      
    

* * *

### 📈 How many results can you scrape with TikTok Trending Videos Scraper?

Scalability is one of the scraper’s strengths. Depending on your filters and country selection, you can scrape:

*   🔥 Dozens to hundreds of trending videos per country  
      
    
*   🌍 Multiple countries in a single run  
      
    
*   📊 High-volume trend datasets for extended tracking  
      
    
*   ⏳ Time-Based Trends — Retrieve trends for the past 7 or 30 days  
      
    
*   📌 Massive engagement datasets for ML models, analytics teams, or dashboards  
      
    

Unlike browser extensions or open-source tools like tiktok scraper GitHub repos, this scraper handles:

*   Large datasets reliably  
      
    
*   Parallel runs  
      
    
*   Automated triggers  
      
    
*   Scheduled scraping  
      
    

You can extract up to thousands of videos depending on limits, region, and performance settings. Perfect for agencies, big data projects, and enterprise workflows.

* * *

### ⚖️ Is it legal to scrape TikTok trends?

Yes—scraping TikTok trending data is legal when done properly.

Here’s what you must know:

*   ✔ This scraper only extracts publicly available information.  
      
    
*   ✔ It does NOT scrape private data such as emails, addresses, or hidden information.  
      
    
*   ✔ TikTok’s Terms of Service should always be followed.  
      
    
*   ✔ Regulations like GDPR and CCPA apply if personal data appears (e.g., usernames).  
      
    

If you’re unsure about the legality for your specific use case, consult legal counsel. For general trend extraction, you’re safe.

* * *

### 🎛 Input Parameters

#### Example Input (JSON)
```json
{
  "countryCode": "AU",
  "sortOrder": "share",
  "maxItems": 100,
  "period": 7,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

### 📤 Output Format

#### Example Output (JSON)

```json
[
 {
   "country_code": "AU",
   "cover": "https://p16-sign-sg.tiktokcdn.com/...",
   "duration": 5,
   "id": "7567957332919913736",
   "item_id": "7567957332919913736",
   "item_url": "https://www.tiktok.com/@mnm_pipi/video/7567957332919913736",
   "region": "Australia",
   "title": "Hips don't lie #halloween #shakira #shake #wiggle #boxerdog"
 }
]
```

### ❓ FAQ

#### 1. Is this the best TikTok Trending Videos Scraper?

Yes—compared to tiktok-scraper npm, GitHub scripts, or extensions, this tool provides richer data, stability, and ease of use.

#### 2. Do I need coding skills?

No. It works without programming, unlike tiktok scraper python tools.

#### 3. Can I scrape multiple countries?

Absolutely—run multiple inputs to scrape global TikTok trends.

#### 4. Is this safe and legal?

Yes—only public TikTok data is scraped in compliance with data regulations.

#### 5. What formats can I export?

CSV, Excel, JSON, HTML, XML, and JSONL.

#### 6. Is this better than TikTok extensions?

Yes—extensions break often, while this scraper is stable and scalable.

#### 7. Can I automate scraping?

Yes—use APIs, schedules, webhooks, Make, or Zapier.

#### 8. Can I integrate this with Python?

Yes! Works perfectly with any Python + Apify Client workflow.

### 🏁 Conclusion

The TikTok Trending Videos Scraper is your all-in-one solution for discovering trends, analyzing performance, and gathering high-quality TikTok insights. With rich metadata, automation options, and multi-format exports, it outperforms traditional TikTok scrapers. Whether for content strategy, influencer research, or trend tracking, this tool ensures you stay ahead in the fast-moving TikTok landscape. 🌟

# Actor input Schema

## `countryCode` (type: `string`):

Country code to scrape

## `sortBy` (type: `string`):

Sort the results by (same options as maain.py: hot/view→vv, like, share→repost, comment)

## `period` (type: `string`):

Period to scrape (last 7 or 30 days)

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

Maximum number of items to scrape

## `includeDetailedVideoData` (type: `boolean`):

If enabled, the scraper will include detailed video data such as engagement statistics (likes, comments, bookmarks, shares) and expiring video links when available.

## Actor input object example

```json
{
  "countryCode": "US",
  "sortBy": "vv",
  "period": "7",
  "maxItems": 10,
  "includeDetailedVideoData": false
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapelabsapi/tiktok-trending-videos-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("scrapelabsapi/tiktok-trending-videos-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 '{}' |
apify call scrapelabsapi/tiktok-trending-videos-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tiktok Trending Videos Scraper",
        "version": "0.1",
        "x-build-id": "TyPc8S0A0IllNaFl7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapelabsapi~tiktok-trending-videos-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapelabsapi-tiktok-trending-videos-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/scrapelabsapi~tiktok-trending-videos-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapelabsapi-tiktok-trending-videos-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/scrapelabsapi~tiktok-trending-videos-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapelabsapi-tiktok-trending-videos-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",
                "required": [
                    "countryCode",
                    "sortBy"
                ],
                "properties": {
                    "countryCode": {
                        "title": "Country Code",
                        "enum": [
                            "AU",
                            "BR",
                            "CA",
                            "EG",
                            "FR",
                            "DE",
                            "ID",
                            "IL",
                            "IT",
                            "JP",
                            "MY",
                            "PH",
                            "RU",
                            "SA",
                            "SG",
                            "KR",
                            "ES",
                            "TW",
                            "TH",
                            "TR",
                            "AE",
                            "GB",
                            "US",
                            "VN"
                        ],
                        "type": "string",
                        "description": "Country code to scrape",
                        "default": "US"
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "vv",
                            "like",
                            "comment",
                            "repost"
                        ],
                        "type": "string",
                        "description": "Sort the results by (same options as maain.py: hot/view→vv, like, share→repost, comment)",
                        "default": "vv"
                    },
                    "period": {
                        "title": "Period Type",
                        "enum": [
                            "7",
                            "30"
                        ],
                        "type": "string",
                        "description": "Period to scrape (last 7 or 30 days)",
                        "default": "7"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of items to scrape",
                        "default": 10
                    },
                    "includeDetailedVideoData": {
                        "title": "Include Detailed Video Data",
                        "type": "boolean",
                        "description": "If enabled, the scraper will include detailed video data such as engagement statistics (likes, comments, bookmarks, shares) and expiring video links when available.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```