# TikTok Video Downloader (`scrapevanta/tiktok-video-downloader`) Actor

TikTok Video Downloader enables fast and easy downloading of public TikTok videos in high quality. Save videos for content research, trend analysis, marketing, archiving, and offline viewing. Ideal for creators, agencies, researchers, and social media professionals.

- **URL**: https://apify.com/scrapevanta/tiktok-video-downloader.md
- **Developed by:** [ScrapeVanta](https://apify.com/scrapevanta) (community)
- **Categories:** Videos, Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.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 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 Video Downloader Actor ⚡
Trying to save TikTok videos one by one is slow, and copy-pasting download links quickly turns into a time sink. **TikTok Video Downloader Actor** processes a list of TikTok video URLs for you and returns download links plus video metadata in a single run—ideal for TikTok video downloader workflows, TikTok to MP4 downloader tasks, and bulk “download TikTok videos MP4” projects. It’s built for marketers, data analysts, and researchers who want TikTok download video online results fast. In practice, you can start with a handful of URLs today and scale to larger batches without manually collecting each video.

---

### See the Data: Sample Output
Here's a real record from a single run:

```json
{
  "original_url": "https://www.tiktok.com/@therock/video/7473147398718573866",
  "title": "Sample TikTok Title",
  "channel": "therock",
  "duration": "1m 12s",
  "thumbnail": "https://example.com/thumbnail.jpg",
  "video_type": "reel",
  "Download video": "https://api.apify.com/v2/key-value-stores/default/records/Sample_TikTok_Title.mp4"
}
````

**Example failure record:**

```json
{
  "original_url": "https://www.tiktok.com/@mrbeast/video/7476529277253635374",
  "error": "Some error message",
  "status": "FAILED"
}
```

| Field | Type | What It Tells You |
|---|---|---|
| `original_url` | string | The exact TikTok URL you provided, so you can trace each result back to its source. |
| `title` | string | null | The video title that’s useful for cataloging and sorting outputs. |
| `channel` | string | null | The creator/handle associated with the video—handy for organizing collections. |
| `duration` | string | A human-readable duration (e.g., `1m 12s`) for quick review and filtering. |
| `thumbnail` | string | null | A thumbnail URL you can use in dashboards or preview tiles. |
| `video_type` | string | Helps you understand whether it’s classified as `reel` or `long video`. |
| `Download video` | string | A link to the downloadable video (or a direct “not available” value when it can’t be generated). |
| `status` | string | null | Included on failure records to indicate `FAILED`. |
| `error` | string | null | The error message when a URL can’t be processed successfully. |

Export your full dataset as JSON, CSV, or Excel from the Apify dashboard.

***

### Setting It Up

Drop this into your `input.json` and you're ready to go:

```json
{
  "video_urls": [
    {
      "url": "https://www.tiktok.com/@therock/video/7473147398718573866"
    },
    {
      "url": "https://www.tiktok.com/@mrbeast/video/7476529277253635374"
    }
  ],
  "desired_resolution": "1080p"
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `video_urls` | ✅ | List of TikTok video URLs to process. Each URL is handled and written as a separate output record. |
| `desired_resolution` | ⬜ | Choose the target quality setting for the downloaded result (supports `1080p`, `720p`, `480p`, `360p`). |

***

### What It Does

This TikTok Video Downloader Actor processes your provided TikTok links and outputs metadata and a downloadable video link per input URL.

#### Uses your input list to produce one record per video

You send `video_urls`, and the actor processes each URL and pushes a result record with the fields defined in the dataset overview. This makes it easy to run TikTok video downloader services-style workflows for multiple videos in one go.

#### Produces metadata you can organize immediately

For each TikTok video URL, the actor returns `original_url`, `title`, `channel`, `duration`, `thumbnail`, and `video_type`. That means your TikTok video save app workflow can start from structured fields instead of screenshots or manual notes.

#### Includes a “Download video” link for each processed item

Each successful record includes a `Download video` field you can use to fetch the video result directly from Apify’s stored content. If a valid link can’t be produced, you’ll see `Download video` set to `not available`.

#### Handles errors without breaking the whole run

If something goes wrong for a specific URL, the actor returns an error record including `original_url`, `error`, and `status`: `FAILED`. Your batch still yields results for other videos even when one URL fails.

#### Resolution choice is controlled via `desired_resolution`

The actor supports selecting `desired_resolution` among `1080p`, `720p`, `480p`, and `360p`. This lets you balance output quality with file size needs when downloading TikTok videos MP4.

Overall, TikTok Video Downloader Actor helps you go from “link list” to usable download links and metadata quickly—exactly what you need for TikTok download video online projects.

***

### Why TikTok Video Downloader Actor?

There are plenty of ways to pull data from TikTok—here’s why TikTok Video Downloader Actor stands out.

#### Batch-friendly results for download and review

Instead of one-off manual steps, this actor processes your list and returns a consistent record for each video (including `Download video`). That makes it well-suited for TikTok video downloader actor-style bulk workflows.

#### Clean, structured output ready for downstream work

The dataset fields are built for immediate use: `title`, `channel`, `duration`, `thumbnail`, `video_type`, and the `Download video` link. If you’re building a catalog, a review queue, or an automation pipeline, you don’t need custom parsing.

#### Clear failure handling per URL

When an item fails, you get `status: "FAILED"` with an `error` message for that specific `original_url`. This makes debugging and re-runs much easier in TikTok to MP4 downloader pipelines.

***

### Real-World Use Cases

Here's how different teams put TikTok Video Downloader Actor to work:

**Marketing teams** use it to quickly build a reference library of competitor or campaign creatives. They run a set of TikTok video URLs, review titles and durations, and then download the videos for internal presentations without repeating manual steps.

**Content curators and researchers** rely on the structured `channel`, `title`, `duration`, and `thumbnail` fields to organize discoveries. Instead of saving links and opening them one by one, they generate a consistent dataset for analysis and archiving.

**Agencies running TikTok video downloader services** batch client requests by collecting TikTok video URLs into one run. They get download links plus metadata back in a predictable format, which helps them deliver faster and with less back-and-forth.

**Automation specialists and developers** integrate TikTok Video Downloader Actor into their workflows by consuming dataset records as JSON via the Apify API. They can trigger follow-up actions once the run finishes and map fields like `original_url`, `video_type`, and `Download video` into their systems.

**Educators and training teams** use downloaded results to build offline examples and slides. The ability to set `desired_resolution` helps them match quality to training needs, whether they’re preparing quick demonstrations or longer materials.

***

### How to Run It

No code required. Here's how to get your first results in under 5 minutes:

1. **Open the actor on Apify**\
   Go to the actor page on Apify via: <https://console.apify.com>.

2. **Enter your inputs**\
   Add one or more entries under `video_urls` (your TikTok video URLs). Optionally set `desired_resolution` to `1080p`, `720p`, `480p`, or `360p`.

3. **Configure proxy settings (optional)**\
   If you want enhanced reliability for larger batches, configure proxy settings using Apify’s built-in options.

4. **Start the run and watch the live log**\
   Launch the run, then monitor progress in the Logs tab while each input URL is processed.

5. **Open the Dataset tab to see live results**\
   Results appear as records with fields like `original_url`, `title`, `channel`, `duration`, `video_type`, and `Download video`.

6. **Export in your preferred format**\
   Download your dataset from the Apify dashboard as JSON, CSV, or Excel.

7. **Copy the downloadable link if needed**\
   If the downloadable link behaves unexpectedly (for example, only audio plays or no video shows), copy the link and paste it into another browser or device. If it persists, try opening it on a mobile device browser.

The whole setup takes under 5 minutes — results start appearing within seconds of launch.

***

### Export & Integration Options

Once your data is collected, TikTok Video Downloader Actor fits directly into your existing workflow.

You can export your dataset from the Apify dashboard as JSON, CSV, or Excel, using the dataset tab for the run.

For automation, you can connect TikTok video downloader outputs to tools like Zapier/Make, use Apify’s API to retrieve results programmatically, or trigger downstream steps when the run completes (webhooks). For more details, refer to the Apify documentation for dataset export, API access, and integrations.

***

### Pricing

TikTok Video Downloader Actor runs on Apify, which includes a **free tier** — no credit card needed to start.

Free tier includes `$5 platform credits on sign-up`, enough for several real test runs. After that, you pay **pay-as-you-go** billed per Actor compute unit (CU) with no monthly fee lock-in. For heavier workloads, use Apify’s subscription plans—check the latest options on the Apify pricing page.

Start free at <https://apify.com> — scale up when you need to.

***

### Reliability & Limitations

| What We Handle | How |
|---|---|
| Per-URL failures | If a specific video can’t be processed, you get a record with `status: "FAILED"` and an `error` message while other URLs can still complete. |
| Output consistency | Successful records include `original_url`, `title`, `channel`, `duration`, `thumbnail`, `video_type`, and `Download video` in the same structure. |
| Download validation | The actor checks that the candidate download link returns a video `Content-Type` before treating it as valid. |
| Scale of batch inputs | Designed to process a list of `video_urls` in one run and push each record as it completes. |

Limitations: this actor works with TikTok video links you provide and returns `Download video` as `not available` when a downloadable result can’t be generated for a given URL. Private or login-gated content is outside the scope of publicly available data access.

For enterprise-scale needs or custom configurations, reach out and we'll help.

***

### Frequently Asked Questions

#### Is there a free plan?

Yes. Apify offers a free tier with sign-up credits, which is typically enough for several real test runs.

#### Do I need to log in or create an account on TikTok?

No. You provide `video_urls`, and the actor works from publicly accessible video links without requiring a TikTok login.

#### How accurate is the extracted data?

The output fields like `title`, `channel`, `duration`, `thumbnail`, and `video_type` are derived from the video metadata the actor can extract for each URL. The `Download video` link is produced when a valid downloadable video result is available.

#### How many results can I get per run?

You can process as many `video_urls` as you include in the input list. Practical limits depend on the length and complexity of videos and the amount of compute your run consumes.

#### How fresh is the data?

Results reflect what the video metadata and downloadable content look like at the time the actor processes each `video_url`, since everything is collected during the run.

#### Is this legal? Does it comply with GDPR / CCPA?

Yes for the data-access pattern: the actor works with **publicly available data**. However, compliance (including GDPR/CCPA and any platform terms) depends on how you store and use the downloaded content—make sure your use case is lawful and compliant.

#### Can I export to Google Sheets or Excel?

Yes. You can export the dataset from the Apify dashboard as JSON, CSV, or Excel, then import it into Google Sheets or other tools. For no-code options, you can also use automation integrations.

#### Can I schedule this to run automatically?

Yes. On Apify, you can schedule actor runs using Apify’s scheduling features so your TikTok download workflows run automatically on a timetable.

#### Can I access results via the API?

Yes. You can pull dataset results programmatically via the Apify API after or during your run, depending on how you integrate.

#### What happens when the actor encounters an error?

If an error occurs for a specific URL, that input produces a result record containing `original_url`, an `error` message, and `status: "FAILED"`. Other URLs in your batch can still be processed.

***

### Get Help & Use Responsibly

Got a question about TikTok Video Downloader Actor or a feature you'd like added? Reach out at <dataforleads@gmail.com>. We welcome feedback like support for additional output fields or better handling when `Download video` is `not available`, and we actively maintain this actor.

**Important:** this actor collects **publicly available data**. It does not access private accounts, login-gated pages, or password-protected content. You’re responsible for following GDPR, CCPA, and TikTok’s Terms of Service when using downloaded content. For data-removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

## `video_urls` (type: `array`):

List of TikTok video URLs to process.

## `desired_resolution` (type: `string`):

Select the desired resolution (e.g., 1080p, 720p, 480p, 360p).

## Actor input object example

```json
{
  "video_urls": [
    {
      "url": "https://www.tiktok.com/@therock/video/7473147398718573866"
    },
    {
      "url": "https://www.tiktok.com/@mrbeast/video/7476529277253635374"
    }
  ],
  "desired_resolution": "1080p"
}
```

# 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 = {
    "video_urls": [
        {
            "url": "https://www.tiktok.com/@therock/video/7473147398718573866"
        },
        {
            "url": "https://www.tiktok.com/@mrbeast/video/7476529277253635374"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapevanta/tiktok-video-downloader").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 = { "video_urls": [
        { "url": "https://www.tiktok.com/@therock/video/7473147398718573866" },
        { "url": "https://www.tiktok.com/@mrbeast/video/7476529277253635374" },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scrapevanta/tiktok-video-downloader").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 '{
  "video_urls": [
    {
      "url": "https://www.tiktok.com/@therock/video/7473147398718573866"
    },
    {
      "url": "https://www.tiktok.com/@mrbeast/video/7476529277253635374"
    }
  ]
}' |
apify call scrapevanta/tiktok-video-downloader --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Video Downloader",
        "description": "TikTok Video Downloader enables fast and easy downloading of public TikTok videos in high quality. Save videos for content research, trend analysis, marketing, archiving, and offline viewing. Ideal for creators, agencies, researchers, and social media professionals.",
        "version": "1.0",
        "x-build-id": "RBMOln1FG3hNWloWt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapevanta~tiktok-video-downloader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapevanta-tiktok-video-downloader",
                "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/scrapevanta~tiktok-video-downloader/runs": {
            "post": {
                "operationId": "runs-sync-scrapevanta-tiktok-video-downloader",
                "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/scrapevanta~tiktok-video-downloader/run-sync": {
            "post": {
                "operationId": "run-sync-scrapevanta-tiktok-video-downloader",
                "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": [
                    "video_urls"
                ],
                "properties": {
                    "video_urls": {
                        "title": "TikTok Video URLs",
                        "type": "array",
                        "description": "List of TikTok video URLs to process.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "desired_resolution": {
                        "title": "Desired Resolution",
                        "enum": [
                            "1080p",
                            "720p",
                            "480p",
                            "360p"
                        ],
                        "type": "string",
                        "description": "Select the desired resolution (e.g., 1080p, 720p, 480p, 360p).",
                        "default": "1080p"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
