# TikTok Scraper - Profiles, Videos, Comments & Followers (`scrape-lads/tiktok-scraper`) Actor

Scrape TikTok profiles, videos, comments and hashtag results. Pay per result.

- **URL**: https://apify.com/scrape-lads/tiktok-scraper.md
- **Developed by:** [Scrape Lads](https://apify.com/scrape-lads) (community)
- **Categories:** Social media
- **Stats:** 4 total users, 1 monthly users, 88.9% runs succeeded, 3 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

$3.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Scraper

Extract **profiles, videos, comments, and followers** from any public TikTok account or video — no login, no API key, no rate limits from TikTok's official API. Get clean structured JSON you can download, schedule, or pipe straight into your own tools.

> **Pay only for results.** $1 per 1,000 items scraped (profile videos: $0.50 per 1,000). One of the lowest prices on the platform.

---

### What can it scrape?

<table>
<thead>
<tr><th>Mode</th><th>Input</th><th>Data you get</th></tr>
</thead>
<tbody>
<tr>
<td><b>Profile info</b></td>
<td>@handles or profile URLs</td>
<td>Followers, following, total likes, post count, bio, verified status, avatar</td>
</tr>
<tr>
<td><b>Profile videos</b></td>
<td>@handles or profile URLs</td>
<td>Every video with views, likes, comments, shares, saves, caption, hashtags, upload date</td>
</tr>
<tr>
<td><b>Video metrics</b></td>
<td>Video URLs</td>
<td>Full engagement stats for specific videos — views, likes, shares, comments, saves, duration</td>
</tr>
<tr>
<td><b>Video comments</b></td>
<td>Video URLs</td>
<td>Comment text, author, likes, reply count, pinned/liked-by-author flags, timestamp</td>
</tr>
<tr>
<td><b>Followers list</b></td>
<td>@handles or profile URLs</td>
<td>Follower profiles — username, display name, follower count, verified status</td>
</tr>
</tbody>
</table>

---

### Why use this scraper?

- **No TikTok account needed.** Runs headlessly against public data — no cookies to manage, no sessions to refresh.
- **Cheaper than alternatives.** At $1 per 1,000 results, it costs up to 40% less than comparable TikTok scrapers on the platform.
- **Five modes in one actor.** Profile stats, full video catalogs, per-video metrics, comments, and followers — all from a single integration.
- **Structured output every time.** Every field has a consistent name and type across all runs. No post-processing required to normalize the data.
- **Schedule it.** Run on a cron schedule to track an account or video weekly without writing any code.

---

### How to use it

**In the Console (no code):**
1. Click **Try for free** above
2. Choose a **Scrape mode** from the dropdown
3. Paste your handles or video URLs
4. Set **Max results** and click **Start Run**
5. Download results as JSON, CSV, or Excel from the **Output** tab

**Via API:**

```javascript
// JavaScript / Node.js
import { ApifyClient } from 'apify-client';

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

const run = await client.actor('scrape-lads/tiktok-scraper').call({
    mode: 'profile',
    handles: ['@charlidamelio', '@khaby.lame', '@zachking'],
    maxResults: 50,
});

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

```python
## Python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')

run = client.actor('scrape-lads/tiktok-scraper').call(run_input={
    'mode': 'profileVideos',
    'handles': ['@zachking'],
    'maxResults': 100,
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item['caption'], item['views'])
```

***

### Input reference

| Field | Type | Required | Description |
|---|---|---|---|
| `mode` | string | Yes | `profile` · `profileVideos` · `video` · `comments` · `followers` |
| `handles` | string\[] | For profile / profileVideos / followers modes | TikTok handles — `@tiktok`, `tiktok`, or full profile URL |
| `videoUrls` | string\[] | For video / comments modes | Full TikTok video URLs |
| `maxResults` | integer | No | Max items to collect. Default: `100`. Max: `1000` |
| `maxConcurrency` | integer | No | Parallel requests (1–5). Default: `1`. Keep at 1 for large runs |

Handles accept any format: `@tiktok`, `tiktok`, or `https://www.tiktok.com/@tiktok` — all work the same.

***

### Output reference

#### Profile

```json
{
  "username": "charlidamelio",
  "displayName": "charli d'amelio",
  "bio": "probably dancing :)",
  "followers": 155400000,
  "following": 1642,
  "likes": 11100000000,
  "postCount": 2341,
  "verified": true,
  "privateAccount": false,
  "avatarUrl": "https://p16-sign.tiktokcdn-us.com/...",
  "profileUrl": "https://www.tiktok.com/@charlidamelio",
  "scrapedAt": "2026-06-29T12:00:00.000Z"
}
```

#### Video (profile videos + video metrics)

```json
{
  "videoId": "6768504823336815877",
  "videoUrl": "https://www.tiktok.com/@zachking/video/6768504823336815877",
  "authorUsername": "zachking",
  "authorName": "Zach King",
  "caption": "They rejected my application to Hogwarts but I still found a way in",
  "hashtags": ["magic", "harrypotter", "fyp"],
  "views": 2373556960,
  "likes": 28492049,
  "comments": 312041,
  "shares": 1872930,
  "saves": 4201882,
  "duration": 14,
  "coverUrl": "https://p16-sign.tiktokcdn-us.com/...",
  "musicTitle": "original sound - zachking",
  "uploadedAt": "2019-12-09T00:00:00.000Z",
  "scrapedAt": "2026-06-29T12:00:00.000Z"
}
```

#### Comment

```json
{
  "commentId": "7112196704363414273",
  "videoUrl": "https://www.tiktok.com/@zachking/video/6768504823336815877",
  "authorUsername": "user_example",
  "text": "This is genuinely the most viewed TikTok ever and it deserves it",
  "likes": 48201,
  "replyCount": 234,
  "isReply": false,
  "pinned": false,
  "likedByAuthor": true,
  "postedAt": "2021-04-12T17:42:00.000Z",
  "scrapedAt": "2026-06-29T12:00:00.000Z"
}
```

#### Follower

```json
{
  "sourceProfile": "charlidamelio",
  "connectionType": "follower",
  "username": "user_example",
  "displayName": "Example User",
  "bio": "just here for the content",
  "followers": 3820,
  "following": 941,
  "verified": false,
  "privateAccount": false,
  "profileUrl": "https://www.tiktok.com/@user_example",
  "scrapedAt": "2026-06-29T12:00:00.000Z"
}
```

***

### Use cases

**Influencer vetting before a campaign**
Pull profile stats for 50 creator candidates in a single run. Compare follower counts, posting frequency, and total engagement to shortlist based on real numbers — not self-reported media kits.

**Track competitor content over time**
Run profile videos mode weekly on a competitor's account. Watch which formats, captions, and hashtags drive their best numbers — before the trend peaks.

**Audience research from comments**
Scrape 500–1,000 comments from your category's viral videos. Feed the text into a sentiment model to understand what your potential customers care about and how they talk.

**Lead generation from follower lists**
If your target buyer persona follows specific niche accounts, export their follower list. Filter by follower count or bio keywords to build a qualified outreach list.

**Content strategy reverse engineering**
Scrape the full video catalog of the top 10 creators in your niche. Analyze upload timing, caption length, hashtag choice, and engagement rate to see exactly what drives views.

**Social listening and brand monitoring**
Pull comments mentioning your brand, product, or keywords from relevant videos. Track sentiment shifts in real time without manual searching.

***

### Pricing

| What | Cost |
|---|---|
| Actor start (per run) | $0.005 |
| Profile, video, comment, or follower result | **$0.001** |
| Profile video result | **$0.0005** |

**Example costs:**

- Scrape stats for 1,000 TikTok accounts → **$1.00**
- Pull 500 comments from a video → **$0.50**
- Get 200 videos from a creator's profile → **$0.10**
- Export 1,000 follower profiles → **$1.00**

Gold, Platinum, and Diamond subscribers get automatic discounts applied on top of these rates.

***

### Scheduling and automation

**Set up a weekly tracker:** Actor page → **Schedules** → add a cron expression like `0 9 * * 1` (every Monday at 9 AM). Results accumulate in the dataset so you can diff week over week.

**Connect to your stack:**

| Tool | What you can do |
|---|---|
| **Zapier / Make** | Push new results to Google Sheets, Airtable, Notion, Slack, or 1,000+ other apps |
| **Webhooks** | POST results to your own endpoint the moment a run finishes |
| **REST API** | Trigger runs and retrieve data from any backend or script |
| **MCP** | Use this scraper directly inside Claude or other AI agents via the Apify MCP server |

***

### FAQ

**Is scraping TikTok legal?**
This actor collects only publicly visible data — the same information anyone can see on TikTok.com without an account. It does not bypass authentication, access private content, or violate any access controls. That said, you are responsible for how you use the data and for complying with TikTok's Terms of Service, GDPR, CCPA, and any other laws that apply in your jurisdiction.

**Why are some fields null?**
TikTok doesn't expose every field for every piece of content. Some creators hide their like counts; some older videos have no music metadata. When a field isn't available, it returns `null` rather than an incorrect value.

**Can I scrape private accounts?**
No. Private profiles and their content are not visible without being an approved follower. This actor only works on fully public accounts and videos.

**I got fewer results than my maxResults limit. Why?**
TikTok limits how many comments or videos are accessible on some content — particularly older videos or accounts with low engagement. The actor collects everything available up to your limit.

**What happens if a video is deleted mid-run?**
That URL is skipped and logged. The run continues with the remaining URLs and still exits successfully.

**How do I track a creator week over week?**
Use the Schedules feature to run the same task on a cron schedule. Each run appends to the same dataset, so you can export and compare results across dates.

**Something looks broken or the data is wrong.**
TikTok updates its site regularly. Open an issue on the **Issues** tab with your input configuration and we will investigate and push a fix fast.

# Actor input Schema

## `mode` (type: `string`):

What to scrape:

- **Profile info** - account stats (followers, likes, post count) for one or more handles.
- **Profile videos** - all videos with full metrics posted by one or more handles.
- **Video metrics** - stats for specific video URLs you provide.
- **Video comments** - comments for specific video URLs you provide.
- **Followers list** - follower profiles for one or more handles.

## `handles` (type: `array`):

Usernames (e.g. @tiktok) or full profile URLs (e.g. https://www.tiktok.com/@tiktok). Used when mode is Profile info, Profile videos, or Followers list.

## `videoUrls` (type: `array`):

Full TikTok video URLs (e.g. https://www.tiktok.com/@user/video/123). Used when mode is Video metrics or Video comments.

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

Maximum number of items to collect (1-1000).

## `maxConcurrency` (type: `integer`):

Parallel requests (1-5). Keep at 1 for TikTok to avoid bans.

## Actor input object example

```json
{
  "mode": "profile",
  "handles": [
    "@tiktok"
  ],
  "videoUrls": [
    "https://www.tiktok.com/@tiktok/video/7106594312292453675"
  ],
  "maxResults": 100,
  "maxConcurrency": 1
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "handles": [
        "@tiktok"
    ],
    "videoUrls": [
        "https://www.tiktok.com/@tiktok/video/7106594312292453675"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrape-lads/tiktok-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 = {
    "handles": ["@tiktok"],
    "videoUrls": ["https://www.tiktok.com/@tiktok/video/7106594312292453675"],
}

# Run the Actor and wait for it to finish
run = client.actor("scrape-lads/tiktok-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 '{
  "handles": [
    "@tiktok"
  ],
  "videoUrls": [
    "https://www.tiktok.com/@tiktok/video/7106594312292453675"
  ]
}' |
apify call scrape-lads/tiktok-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Scraper - Profiles, Videos, Comments & Followers",
        "description": "Scrape TikTok profiles, videos, comments and hashtag results. Pay per result.",
        "version": "1.0",
        "x-build-id": "xRywJeUIZdqQT1Gwx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrape-lads~tiktok-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrape-lads-tiktok-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/scrape-lads~tiktok-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrape-lads-tiktok-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/scrape-lads~tiktok-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrape-lads-tiktok-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Scrape mode",
                        "enum": [
                            "profile",
                            "profileVideos",
                            "video",
                            "comments",
                            "followers"
                        ],
                        "type": "string",
                        "description": "What to scrape:\n- **Profile info** - account stats (followers, likes, post count) for one or more handles.\n- **Profile videos** - all videos with full metrics posted by one or more handles.\n- **Video metrics** - stats for specific video URLs you provide.\n- **Video comments** - comments for specific video URLs you provide.\n- **Followers list** - follower profiles for one or more handles.",
                        "default": "profile"
                    },
                    "handles": {
                        "title": "TikTok handles or profile URLs",
                        "type": "array",
                        "description": "Usernames (e.g. @tiktok) or full profile URLs (e.g. https://www.tiktok.com/@tiktok). Used when mode is Profile info, Profile videos, or Followers list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "videoUrls": {
                        "title": "Video URLs",
                        "type": "array",
                        "description": "Full TikTok video URLs (e.g. https://www.tiktok.com/@user/video/123). Used when mode is Video metrics or Video comments.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of items to collect (1-1000).",
                        "default": 100
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Parallel requests (1-5). Keep at 1 for TikTok to avoid bans.",
                        "default": 1
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
