# Fast Tiktok Downloader Without Watermark (`solid-scraper/fast-tiktok-downloader-without-watermark`) Actor

🚀 Download TikTok videos instantly with the Fast TikTok Downloader Without Watermark. 📥 HD quality, fast speed, and simple one-click use—no hassle, no watermark. Perfect for sharing, saving, and reposting! 🔥

- **URL**: https://apify.com/solid-scraper/fast-tiktok-downloader-without-watermark.md
- **Developed by:** [SolidScraper](https://apify.com/solid-scraper) (community)
- **Categories:** Videos, Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### Fast Tiktok Downloader Without Watermark ⬇️

**Fast Tiktok Downloader Without Watermark** is an Apify actor that helps you quickly fetch TikTok video details from a single TikTok URL and saves the results into a structured dataset you can analyze or export. Whether you’re looking for a **fast tiktok downloader without watermark**, a **tiktok video downloader no watermark**, or a **tiktok mp4 downloader without watermark** workflow, this tool is designed for marketers, analysts, and researchers who want reliable, ready-to-use output—saving you hours of manual work.

---

### Why choose Fast Tiktok Downloader Without Watermark?

| Feature | Benefit |
|---|---|
| ✅ **Single-URL TikTok scraping** | Process one TikTok video URL at a time and get consistent output |
| ✅ **API version control (`apiVersion`)** | Choose between `v1` and `v2` output mappings based on your needs |
| ✅ **Residential proxy support** | Improves reliability when accessing public web data |
| ✅ **Built-in retry logic (up to 3 attempts)** | Includes retries and fallbacks for resilience if requests fail |
| ✅ **Structured dataset output** | Returns clearly labeled fields like author, description, and video links |
| ✅ **Apify Console-friendly workflow** | Run from the Apify UI and export results from the dataset when done |

---

### Key features

- ⚡ **Fast tiktok video download (data fetching):** Pulls video metadata and direct links for the requested TikTok URL in one run  
- 🛡️ **Residential proxy support by default:** Uses residential proxy configuration to help requests succeed more often  
- 🔄 **Robust retries for resilience:** Attempts up to 3 times when failures occur  
- 📊 **Complete video info mapping (v2):** Includes fields such as `author_nickname`, `author_avatar`, `desc`, `videoSD`, `videoHD`, and counts  
- 💾 **Dataset-ready JSON output:** Saves results immediately to the **TikTok Video Data** dataset in a table-friendly structure  
- 🌐 **URL support from input:** Accepts a `url` field containing a single TikTok video link  
- 🎛️ **API format selection:** Switch between `v1` and `v2` using the `apiVersion` input for different mappings  

*(Note: This actor focuses on downloading-related video metadata and links for publicly accessible sources, not on bypassing access controls.)*

---

### Input

Provide input via an `input.json` file. Example structure:

```json
{
  "url": "https://www.tiktok.com/@ntventertainment.bd/video/7586268250355322133",
  "apiVersion": "v2"
}
````

#### Input fields

| Field | Required | Description |
|---|---:|---|
| `url` | ✅ | Enter a single TikTok video URL to scrape. |
| `apiVersion` | ✅ | Select the API version for the output mapping. Choose `v1` or `v2` (default is `v2`). |

***

### Output

The actor saves each scraped video’s data in JSON format into the **TikTok Video Data** dataset.

Example successful output item:

```json
{
  "original_url": "https://www.tiktok.com/@ntventertainment.bd/video/7586268250355322133",
  "status": "success",
  "result": {
    "type": "video",
    "author": {
      "avatar": "https://example.com/avatar.jpg",
      "nickname": "@someuser"
    },
    "desc": "Video description text",
    "videoSD": "https://example.com/video-sd.mp4",
    "videoHD": "https://example.com/video-hd.mp4",
    "statistics": {
      "likeCount": "12.3K",
      "commentCount": "456",
      "shareCount": "78K"
    },
    "music": "https://example.com/music",
    "video": "https://example.com/video-hd.mp4"
  }
}
```

Example error output item:

```json
{
  "original_url": "https://www.tiktok.com/@ntventertainment.bd/video/7586268250355322133",
  "status": "error",
  "error_message": "Connection error: ... "
}
```

#### Output fields

| Field | Type | Description |
|---|---|---|
| `original_url` | string | The TikTok URL that was processed. |
| `status` | string | Either `success` or `error` depending on whether scraping succeeded. |
| `type` | string | The content type. (Set to `video` when successful.) |
| `author_nickname` | string | The author’s nickname (mapped from the selected API version). |
| `author_avatar` | string | The author avatar URL. |
| `desc` | string | The video description/title text. |
| `videoSD` | string | Link to the SD video (when available in the selected mapping). |
| `videoHD` | string | Link to the HD video (when available in the selected mapping). |
| `likeCount` | string | Like count formatted (e.g., `1.2K`, `3.4M`) when available. |
| `commentCount` | string | Comment count formatted when available. |
| `shareCount` | string | Share count formatted when available. |
| `music` | string | Music link/value returned by the API mapping. |
| `video` | string | Link used for “Watch” in the dataset view. |
| `error_message` | string | Error details when `status` is `error`. |

You can export the dataset from Apify Console in common formats like JSON and CSV (depending on your chosen workflow).

***

### How to use Fast Tiktok Downloader Without Watermark (via Apify Console)

1. **Open Apify Console**\
   Log in at https://console.apify.com.

2. **Find the actor**\
   Search for **Fast Tiktok Downloader Without Watermark** in the Actors marketplace.

3. **Go to the Input section**\
   You’ll see a form aligned to the actor’s `url` and `apiVersion` fields.

4. **Enter your TikTok video URL**\
   Paste a single video URL into `url` (for example, a link like `https://www.tiktok.com/@username/video/...`).

5. **Choose `apiVersion` (`v2` recommended)**\
   Select `v2` for the refined output mapping, or switch to `v1` if that format better matches your downstream needs.

6. **Run the actor**\
   Click **Run**. During execution, you’ll see logs indicating the selected API version and whether data was pushed successfully.

7. **Review results in the dataset**\
   When finished, open the **TikTok Video Data** dataset and view the table (URL, status, author, video links, and counts).

8. **Export your results**\
   Export from the dataset UI (typically JSON/CSV) and plug into your reporting, CRM enrichment, or analysis pipeline.

No coding required — get fast tiktok downloader without watermark results in minutes.

***

### Advanced features & SEO optimization

- 🏎️ **Engineered for fast tiktok downloader without watermark workflows:** Designed to fetch a complete set of video metadata and links per provided TikTok URL quickly
- 🔄 **Supports “tiktok video downloader no watermark” use cases in analysis pipelines:** Output is structured for table viewing and dataset export, making it easier to compare videos at scale
- 🧩 **API mapping flexibility (`v1` vs `v2`):** Lets you align your “tiktok mp4 downloader without watermark” expectations with the data fields returned
- 🛡️ **Resilient scraping setup:** Built-in retries and residential proxy support help with reliability on public web data
- 🧾 **Clear error handling:** When something fails, the actor returns `status: error` with an `error_message` so you can retry or inspect failures

***

### Best use cases

- 📈 **Marketing teams building quick video references:** Gather video descriptions, author info, and watch links to support campaign planning and creative reviews
- 🔎 **Data analysts comparing creator performance:** Use formatted `likeCount`, `commentCount`, and `shareCount` to compare engagement patterns across TikTok videos
- 🧪 **Researchers studying public content metadata:** Collect author nickname, avatar, and video link fields from publicly accessible sources for structured analysis
- 🧠 **Lead research workflows:** Combine author/video context with your own enrichment data to speed up outreach research (where legally appropriate)
- 🛠️ **Automation builders integrating into pipelines:** Pull results into downstream ETL steps using dataset exports and the structured JSON fields
- 💾 **Content moderation and auditing support:** Store standardized video metadata for audits and review logs based on `status` and `error_message`

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `url` (string): Enter a single TikTok video URL
  - ✅ `apiVersion` (string): `v1` or `v2` (default `v2`)

- **Proxy Support**
  - ✅ Residential proxy support via Apify proxy configuration
  - ✅ Includes a fallback approach if proxy URL acquisition fails

- **Retry Mechanism**
  - ✅ Up to **3 retries** per URL on connection/request failures

- **Dataset Structure**
  - ✅ Saves results into the **TikTok Video Data** dataset
  - ✅ Dataset table includes: `original_url`, `status`, `type`, `author_nickname`, `author_avatar`, `desc`, `videoSD`, `videoHD`, `likeCount`, `commentCount`, `shareCount`, `music`, `video`, `error_message`

- **Rate Limits & Performance**
  - ✅ Uses randomized delays and request timeouts for steadier execution (varies by environment and response)
  - ✅ Sequential processing for the provided URL

- **Limitations**
  - ❌ If `url` is missing, the actor logs a warning and exits
  - ❌ If the API request fails, the dataset entry is saved with `status: error` and an `error_message`

***

### FAQ

#### Does Fast Tiktok Downloader Without Watermark download video files directly?

It provides video-related links and metadata in the dataset (for example, `videoSD`, `videoHD`, and `video`) rather than exposing a dedicated “save file” interface in the actor input.

#### What does `apiVersion` do?

`apiVersion` selects how the actor maps returned data into the dataset fields. You can choose `v1` or `v2`, with `v2` being the default and using the refined mapping structure.

#### What happens if the TikTok URL fails to scrape?

If scraping fails, the actor pushes an entry with `status: error` along with `error_message` to the **TikTok Video Data** dataset.

#### Do I need coding to run this actor?

No. You can run it directly in Apify Console by providing the `url` and `apiVersion` inputs, then exporting the dataset results.

#### Is there a free plan / pricing for this actor?

Pricing and plan details depend on your Apify account and the pricing model for runs. Check the actor page in Apify Console for the most up-to-date information.

#### Can I use this for bulk scraping?

This actor is designed around processing the provided `url` input. For bulk scenarios, you can run multiple executions or build a workflow around repeated runs and dataset exports.

#### How do I integrate the results into my workflow?

Use the dataset output fields such as `author_nickname`, `desc`, `videoHD`, and the formatted engagement counts (`likeCount`, `commentCount`, `shareCount`) to feed your analysis, reporting, or CRM enrichment steps.

#### Is this compliant with platform rules and privacy regulations?

✅ The actor works with publicly accessible sources, but compliance (including privacy laws and platform terms) is your responsibility. Always follow applicable laws and the source platform’s rules.

***

### Support & feature requests

Want to improve Fast Tiktok Downloader Without Watermark (including ideas for faster tiktok downloader without watermark workflows)? We’d love to hear from you.

- 💡 **Feature Requests:** Request enhancements like additional output fields, alternative export-friendly formatting, or integrations with your pipeline steps for “tiktok video downloader no watermark” use cases.
- 📧 **Contact:** For help or suggestions, email <dataforleads@gmail.com>.

Your feedback helps shape future improvements to Fast Tiktok Downloader Without Watermark.

***

### *Fast Tiktok Downloader Without Watermark* — Final thoughts

If you want a fast, structured way to work with TikTok video metadata and links, this **SEO-optimized Fast Tiktok Downloader Without Watermark** actor is a great fit for your next run.

***

### Disclaimer

**The actor only accesses publicly accessible sources.** It does not access private profiles, authenticated data, or password-protected pages. Legal compliance (including GDPR, CCPA, spam regulations, and platform terms) is your responsibility.

For data removal requests, contact <dataforleads@gmail.com>. Please use Fast Tiktok Downloader Without Watermark responsibly, ethically, and for legitimate purposes only.

# Actor input Schema

## `url` (type: `string`):

Enter single TikTok video URL.

## `apiVersion` (type: `string`):

Select the API version.

## Actor input object example

```json
{
  "url": "https://www.tiktok.com/@ntventertainment.bd/video/7586268250355322133",
  "apiVersion": "v2"
}
```

# 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 = {
    "url": "https://www.tiktok.com/@ntventertainment.bd/video/7586268250355322133"
};

// Run the Actor and wait for it to finish
const run = await client.actor("solid-scraper/fast-tiktok-downloader-without-watermark").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 = { "url": "https://www.tiktok.com/@ntventertainment.bd/video/7586268250355322133" }

# Run the Actor and wait for it to finish
run = client.actor("solid-scraper/fast-tiktok-downloader-without-watermark").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 '{
  "url": "https://www.tiktok.com/@ntventertainment.bd/video/7586268250355322133"
}' |
apify call solid-scraper/fast-tiktok-downloader-without-watermark --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Fast Tiktok Downloader Without Watermark",
        "description": "🚀 Download TikTok videos instantly with the Fast TikTok Downloader Without Watermark. 📥 HD quality, fast speed, and simple one-click use—no hassle, no watermark. Perfect for sharing, saving, and reposting! 🔥",
        "version": "0.1",
        "x-build-id": "gvtOl4J5Cl2TUNBEN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~fast-tiktok-downloader-without-watermark/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-fast-tiktok-downloader-without-watermark",
                "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/solid-scraper~fast-tiktok-downloader-without-watermark/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-fast-tiktok-downloader-without-watermark",
                "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/solid-scraper~fast-tiktok-downloader-without-watermark/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-fast-tiktok-downloader-without-watermark",
                "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": [
                    "url",
                    "apiVersion"
                ],
                "properties": {
                    "url": {
                        "title": "TikTok URL",
                        "type": "string",
                        "description": "Enter single TikTok video URL."
                    },
                    "apiVersion": {
                        "title": "API Version",
                        "enum": [
                            "v1",
                            "v2"
                        ],
                        "type": "string",
                        "description": "Select the API version.",
                        "default": "v2"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
