# Kick Chat Scraper & Real-Time Archive (`devilscrapes/kick-chat-archive`) Actor

Archive live Kick.com chat via the Kick chat API — subscribe to one or more channels and capture every message with sender, role, badges, and timestamp, export to JSON or CSV. Kick has no native chat history, so this is the way to keep a record.

- **URL**: https://apify.com/devilscrapes/kick-chat-archive.md
- **Developed by:** [DevilScrapes](https://apify.com/devilscrapes) (community)
- **Categories:** Social media, Videos
- **Stats:** 2 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

<div align="center">
  <img src=".actor/icon.svg" width="160" alt="Devil Scrapes mark" />

## Kick Chat Scraper & Real-Time Archive

_We do the dirty work so your dataset stays clean._ 😈

**$1.05 / 1,000 messages** &nbsp;·&nbsp; pay only for messages that land &nbsp;·&nbsp; no credit card to try

Subscribe to one or more Kick.com channels and archive every chat message in real time, with sender, role, badges, color, and timestamps. Kick has no public API for past chat and no native chat history — this kick chat scraper is the only way to keep what was said.

</div>

---

### 🎯 What this scrapes

Kick.com is the 4th-largest live-streaming platform (Q3 2025), but unlike Twitch and YouTube it has no public API for past chat. Once a stream ends, the conversation is gone from every Kick surface.

This Actor connects to Kick's public Pusher WebSocket — the same one the kick.com website uses to render chat — subscribes to one or more chatrooms by channel slug, and archives every `App\Events\ChatMessageEvent` it sees until either a duration window or a message-count cap is reached.

Each archived row carries the message text, the sender's username, slug, chat color, derived role (broadcaster / moderator / VIP / subscriber / user), raw badge list, Kick's message UUID, the original send timestamp, and the scrape timestamp. Think of it as a Kick chat logger that runs while you sleep, then hands you a clean structured dataset when you wake up.

### 🔥 Features

- 🛡️ **Browser fingerprint rotation** — we rotate `curl-cffi` browser TLS fingerprints (Chrome / Firefox / Safari) on the REST channel-lookup hop so the target sees real-browser traffic, not Python scripts. Reconnects automatically on transient drops.
- 🌐 **Proxy-routed REST hop** — Apify Proxy on the channel lookup; the Pusher WebSocket itself is direct, low-latency, and unproxied for sub-second message delivery.
- 🔁 **Retries with exponential backoff** on `408 / 429 / 5xx` — `Retry-After` honoured; up to 5 attempts per request.
- 🧱 **Deterministic stop** — exits cleanly when either the time cap or the message-count cap fires; partial successes surface via `Actor.set_status_message`, never silent exits.
- 🧊 **Clean, typed dataset rows** — Pydantic-validated schema, ISO-8601 timestamps, stable UUIDs, canonical `sender_role` derived per message with raw badge list preserved.
- ⚡ **Real-time multiplex** — direct Pusher WebSocket connection, sub-second latency, up to 20 channels on a single socket. No polling.
- 💰 **Pay-Per-Event pricing** — you pay only for messages that hit your dataset. No data, no charge.

### 💡 Use cases

- **Brand monitoring** — capture every mention of your product across a list of Kick channels while a launch streams live.
- **Toxicity / sentiment model training** — record real chat at scale for supervised fine-tuning, with role + badge metadata as features.
- **Stream highlight detection** — surge in messages per minute is a strong proxy for an in-stream moment worth clipping.
- **Moderator coverage audits** — diff message counts against moderator actions, see which channels need more coverage.
- **Streamer self-archive** — keep a permanent record of your own community's chat for VOD highlights, AMAs, and giveaways.
- **Esports / event coverage** — archive multiple tournament channels in parallel.

### ⚙️ How to use it

1. Click **Try for free** at the top of the page.
2. Enter one or more Kick channel slugs (the part after `kick.com/`). Lowercase preferred; full URLs are accepted and normalised.
3. Set `maxDurationSeconds` (default 5 minutes) and `maxMessagesTotal` (default 1,000). The run exits as soon as **either** cap is hit.
4. Click **Start**. Messages stream into the run's dataset as they arrive.
5. Export from **Storage → Dataset** as JSON, CSV, or Excel — or fetch via the Apify API.

### 📥 Input

| Field | Type | Required | Default | Notes |
|---|---|:--:|---|---|
| `channelSlugs` | `array` | **yes** | `["xqc"]` | 1–20 Kick channel slugs (lowercase). URLs accepted and normalised. |
| `maxDurationSeconds` | `integer` | no | `300` | 5–3,600 seconds. Hard 1-hour ceiling per run. |
| `maxMessagesTotal` | `integer` | no | `1000` | 1–50,000 messages across **all** channels combined. |
| `proxyConfiguration` | `object` | no | Apify Proxy on | Used for Kick's Cloudflare-protected REST channel lookup only — the Pusher WebSocket bypasses the proxy. |

#### Example input

```json
{
  "channelSlugs": ["xqc", "trainwreckstv"],
  "maxDurationSeconds": 600,
  "maxMessagesTotal": 5000,
  "proxyConfiguration": {"useApifyProxy": true}
}
````

### 📤 Output

Every row is one archived chat message.

| Field | Type | Notes |
|---|---|---|
| `channel_slug` | `string` | The input slug this message came from. |
| `chatroom_id` | `integer` | Pusher chatroom identifier. |
| `message_id` | `string` | Kick's message UUID. |
| `sender_id` | `integer \| null` | Sender's Kick user id (null on system events). |
| `sender_username` | `string` | Sender display name. |
| `sender_slug` | `string \| null` | Sender URL-safe handle. |
| `sender_color` | `string \| null` | Hex color the sender picked. |
| `sender_role` | `string` | Canonical role: `broadcaster`, `moderator`, `staff`, `founder`, `og`, `vip`, `subscriber`, `user`. |
| `sender_badges` | `array` | Raw badge type strings exactly as Kick sends them. |
| `content` | `string` | Message text. May contain `[emote:N:name]` tokens. |
| `message_type` | `string` | Kick's `type` field — usually `message`. |
| `sent_at` | `string` | ISO 8601 UTC timestamp Kick stamped the message with. |
| `scraped_at` | `string` | ISO 8601 UTC timestamp this row was written. |

#### Example output

```json
{
  "channel_slug": "abuswe7l",
  "chatroom_id": 31118945,
  "message_id": "8049a026-5c2e-4619-b60d-393b7217f4da",
  "sender_id": 5666938,
  "sender_username": "Soud_x5",
  "sender_slug": "soud-x5",
  "sender_color": "#FF9D00",
  "sender_role": "moderator",
  "sender_badges": ["moderator", "subscriber"],
  "content": "[emote:2506823:azzzjh] hello chat",
  "message_type": "message",
  "sent_at": "2026-05-16T20:40:16+00:00",
  "scraped_at": "2026-05-16T20:40:17+00:00"
}
```

### 💰 Pricing

Pay-Per-Event — you pay only when these events fire:

| Event | USD | What it is |
|---|---:|---|
| `actor-start` | $0.05 | One-off warm-up charge per run. |
| `result-row` | $0.001 | Per archived message. |

Example: a 5-minute archive of a popular streamer that captures 1,000 messages costs **$1.05**. A quieter channel with 100 messages over the same window costs **$0.15**.

### 🚧 Limitations

- **Real-time only.** Kick has no public chat-history API. This kick chat scraper archives only chat that is sent **while the run is active**. There is no way to recover messages sent before the Actor started or after it stopped.
- **Public chatrooms only.** Followers-only or subscribers-only chat modes require a Kick login and Bearer token; that scope is out of v1.
- **Single Pusher cluster.** Kick currently uses `ws-us2.pusher.com` exclusively. If Kick migrates clusters, this Actor will need a version bump.
- **No moderation events.** Bans, deletions, slow-mode toggles, and pinned-message events are received but deliberately ignored; only `App\Events\ChatMessageEvent` produces rows. A future sibling Actor will cover moderation.
- **No emote image resolution.** `[emote:N:name]` tokens are preserved verbatim in `content`. Resolve them via Kick's emote endpoints if you need the PNG/SVG.
- **20-channel ceiling per run.** The Pusher socket supports up to 20 concurrent chatroom subscriptions. For wider coverage, run multiple Actors in parallel and merge datasets downstream.

### ❓ FAQ

**Is there a Kick API alternative for chat history?**

No official one exists. Kick has not published a public API. This Actor is the practical Kick API alternative for chat data — it connects directly to the same Pusher WebSocket your browser uses and archives messages as they arrive. For truly historical data (before this run started) there is no upstream to query; Kick does not store chat after a stream ends.

**Why can't I get yesterday's chat or download Kick chat history?**

Kick does not store chat. Twitch and YouTube both expose past chat through their APIs; Kick does not. To download Kick chat from a future stream, schedule this Actor to run **during** the stream and messages are archived as they happen.

**Do I need a Kick account or API key?**

No. Kick's chat WebSocket is a public Pusher app — the same one your browser uses. This Actor reads it without any authentication. We never log in to Kick.

**Is this against Kick's TOS?**

We only read what Kick delivers to every public viewer's browser. We do not pose as users, send messages, cast votes, or touch private surfaces. For commercial-scale or sensitive use cases please review Kick's Terms before deploying.

**Why is `sender_role` only one value when the user has multiple badges?**

We pick the highest-priority role per message (`broadcaster > moderator > staff > founder > og > vip > subscriber > user`) so each row carries a single clean label suitable for grouping and filtering. The full badge list is also preserved in `sender_badges` if you need it.

**The run finished with zero rows. What happened?**

Either the channel was offline (no live stream means no chat) or it was silent for the configured window. The Actor exits non-zero with a clear status message so you never get a green run hiding an empty dataset.

**Can I archive a private or subscribers-only chatroom?**

Not in this Actor. That would require a Kick login token; v1 is read-only on public chatrooms. Request a sibling Actor if you need that coverage.

### 💬 Your feedback

Spotted a bug, want a new field, or need a moderation-events sibling Actor? Open an issue on the Actor's **Issues** tab on Apify Console — we ship fixes weekly.

***

Built by **[Devil Scrapes](https://apify.com/DevilScrapes)** 😈 — a small fleet of
opinionated public-data Actors. Honest pricing, real engineering, zero fine print.

# Actor input Schema

## `channelSlugs` (type: `array`):

Kick channel slugs to archive (lowercase, no <code>kick.com/</code> prefix). One per line. 1–20 channels per run. All multiplex over a single WebSocket.

## `maxDurationSeconds` (type: `integer`):

How long to listen before exiting. The run also exits early if <code>maxMessagesTotal</code> is reached first. Range 5–3600 (1 hour cap per run).

## `maxMessagesTotal` (type: `integer`):

Hard cap on total messages archived across all channels. Whichever cap fires first (duration or this) ends the run. Range 1–50000.

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

Apify Proxy is used for Kick's Cloudflare-protected REST channel lookup. The Pusher WebSocket itself bypasses the proxy.

## Actor input object example

```json
{
  "channelSlugs": [
    "xqc"
  ],
  "maxDurationSeconds": 300,
  "maxMessagesTotal": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

All dataset items as JSON.

## `datasetItemsCsv` (type: `string`):

Same data exported to CSV.

## `datasetView` (type: `string`):

Open the run dataset in the Console.

# 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 = {
    "channelSlugs": [
        "xqc"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("devilscrapes/kick-chat-archive").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 = {
    "channelSlugs": ["xqc"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("devilscrapes/kick-chat-archive").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 '{
  "channelSlugs": [
    "xqc"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call devilscrapes/kick-chat-archive --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=devilscrapes/kick-chat-archive",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Kick Chat Scraper & Real-Time Archive",
        "description": "Archive live Kick.com chat via the Kick chat API — subscribe to one or more channels and capture every message with sender, role, badges, and timestamp, export to JSON or CSV. Kick has no native chat history, so this is the way to keep a record.",
        "version": "0.3",
        "x-build-id": "k60DKnRzxO5cvwBAO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/devilscrapes~kick-chat-archive/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-devilscrapes-kick-chat-archive",
                "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/devilscrapes~kick-chat-archive/runs": {
            "post": {
                "operationId": "runs-sync-devilscrapes-kick-chat-archive",
                "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/devilscrapes~kick-chat-archive/run-sync": {
            "post": {
                "operationId": "run-sync-devilscrapes-kick-chat-archive",
                "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": [
                    "channelSlugs"
                ],
                "properties": {
                    "channelSlugs": {
                        "title": "Channel slugs",
                        "minItems": 1,
                        "maxItems": 20,
                        "type": "array",
                        "description": "Kick channel slugs to archive (lowercase, no <code>kick.com/</code> prefix). One per line. 1–20 channels per run. All multiplex over a single WebSocket.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxDurationSeconds": {
                        "title": "Max duration (seconds)",
                        "minimum": 5,
                        "maximum": 3600,
                        "type": "integer",
                        "description": "How long to listen before exiting. The run also exits early if <code>maxMessagesTotal</code> is reached first. Range 5–3600 (1 hour cap per run).",
                        "default": 300
                    },
                    "maxMessagesTotal": {
                        "title": "Max messages total",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Hard cap on total messages archived across all channels. Whichever cap fires first (duration or this) ends the run. Range 1–50000.",
                        "default": 1000
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy is used for Kick's Cloudflare-protected REST channel lookup. The Pusher WebSocket itself bypasses the proxy.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```