# Twitch Scraper: Channels, Streams, Clips & Games (`getascraper/twitch-scraper`) Actor

Scrape Twitch channel profiles, live streams, top games, clips, and videos. No login, no API key. Covers channel lookup, channel search, top live streams, per-game streams, top games, clips, and VODs.

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

## Pricing

from $0.97 / 1,000 twitch records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## 🎮 Twitch Scraper: channels, live streams, clips and games

**Get live Twitch channel stats, viewer counts, and top clips ready for your spreadsheet in under 60 seconds.** No login, no account, no waiting for approval.

### 🔍 What does the Twitch Scraper do?

The Twitch Scraper reads Twitch's own public data feed, the same one that powers [twitch.tv](https://www.twitch.tv), and turns it into clean, structured rows. Point it at a channel, a game, or a search phrase, pick a mode, and press start.

Because it runs on the Apify platform, you also get scheduling, ready-made integrations, automatic proxy rotation, run monitoring, and clean exports in JSON, CSV, Excel, XML, or RSS.

### 💡 Why use the Twitch Scraper?

* **I am a brand sponsorship manager** checking a streamer's follower count and live viewer numbers before signing a deal, so I can compare candidates side by side in one sheet.
* **I am an esports analyst** tracking which games are drawing the most viewers right now, so I can spot rising titles before my competitors do.
* **I am a content agency owner** pulling a streamer's top clips from the last month, so I can find their best moments for a highlight reel without watching hours of footage.
* **I am a market researcher** building a leaderboard of the biggest channels in a category, so I can size an audience before pitching a campaign.

### 🚀 How to use the Twitch Scraper

1. Click **Try for free** at the top of this page.
2. Pick a **mode**: Channels, Search channels, Top live streams, Streams by game, Top games, Clips, or Videos.
3. Fill in **Targets**: channel names, search phrases, or game names, depending on the mode.
4. Set **Max results** to cap how many rows you want back.
5. Press **Start** and watch the results fill the Output tab in seconds.
6. Download the dataset in JSON, CSV, or Excel, or connect it to Google Sheets, Make, Zapier, or your own app.

New here? A first run of 5 to 10 results is a great way to see the output shape before scaling up.

### 📥 Input

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `mode` | enum | Yes | What to scrape: `channels`, `searchChannels`, `topStreams`, `gameStreams`, `topGames`, `clips`, or `videos`. |
| `targets` | array of strings | No | Channel names or profile links, search phrases, or game names, depending on the mode. Not used by Top live streams or Top games. |
| `clipPeriod` | enum | No | Time window for ranking clips by views: last day, last week, last month, or all time. Used by Clips mode and the clip enrichment toggle below. Defaults to all time. |
| `includeRecentVideos` | boolean | No | Attach each channel's most recent videos as a nested list on the channel row. Channels mode only. Defaults to false. |
| `recentVideosLimit` | integer | No | How many recent videos to attach per channel, from 0 to 10. Defaults to 5 once the toggle above is on. |
| `includeTopClips` | boolean | No | Attach each channel's top clips as a nested list on the channel row. Channels mode only. Defaults to false. |
| `topClipsLimit` | integer | No | How many top clips to attach per channel, from 0 to 10. Defaults to 5 once the toggle above is on. |
| `maxResults` | integer | No | Maximum number of rows to return. Twitch caps a single request at 30 for Top live streams and 100 for the other list modes, so higher values are trimmed to that cap. Defaults to 30. |
| `proxyConfiguration` | object | No | Proxy settings. The default works fine for this Actor. |

### 📤 Output

Every row carries a common set of tracking fields plus mode-specific data. Here is a shortened example from **Channels** mode:

```json
{
  "rowType": "channel",
  "sourceMode": "channels",
  "sourceTarget": "shroud",
  "sourceUrl": "https://www.twitch.tv/shroud",
  "channelId": "37402112",
  "login": "shroud",
  "displayName": "shroud",
  "description": "I'm back baby",
  "followerCount": 11300579,
  "isPartner": true,
  "isAffiliate": false,
  "isLive": false,
  "profileImageUrl": "https://static-cdn.jtvnw.net/jtv_user_pictures/c754eebf-745b-4e0a-814a-10bcaecaabbc-profile_image-300x300.png"
}
````

A **Top live streams** result looks like this:

```json
{
  "rowType": "stream",
  "sourceMode": "topStreams",
  "sourceUrl": "https://www.twitch.tv/zackrawrr",
  "streamId": "319223724254",
  "channelLogin": "zackrawrr",
  "channelDisplayName": "zackrawrr",
  "title": "BIG DAY HUGE DRAMA DAY",
  "viewersCount": 37020,
  "gameName": "Just Chatting",
  "startedAt": "2026-07-02T18:16:11Z",
  "thumbnailUrl": "https://static-cdn.jtvnw.net/previews-ttv/live_user_zackrawrr-440x248.jpg"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel. The Output tab has four ready-made views: Channels, Live Streams, Clips & Videos, and Games.

### 📊 Data table

Main fields returned across the seven modes. Empty fields are dropped, so every value you see is real.

| Field | Type | Description |
| --- | --- | --- |
| rowType | string | Row kind: `channel`, `stream`, `game`, `clip`, or `video`. |
| sourceMode | string | Which mode produced this row. |
| sourceTarget | string | The channel, game, or search phrase that produced this row. |
| sourceUrl | string | Direct link to the channel, game directory, clip, or video. |
| scrapedAt | string | When this row was collected, in ISO 8601 UTC. |
| channelId / login / displayName | string | Channel identifiers. |
| followerCount | number | Total followers on the channel. |
| isPartner / isAffiliate | boolean | Twitch partner or affiliate status. |
| isLive | boolean | Whether the channel is currently streaming. |
| liveTitle / liveViewersCount / liveGameName | string / number | Current stream details, present only when the channel is live. |
| streamId / channelLogin / title / viewersCount | string / number | Live stream details for stream rows. |
| gameName / gameId | string | Game or category the stream or row belongs to. |
| tags | array | Stream tags such as language or content descriptors. |
| broadcastersCount | number | Number of channels currently streaming a game. |
| boxArtUrl | string | Cover art for a game or category. |
| clipId / clipTitle / clipUrl | string | Clip identifiers and link. |
| viewCount | number | Views on a clip or video. |
| durationSeconds | number | Length of a clip or video, in seconds. |
| broadcasterLogin / curatorLogin | string | Who streamed a clip, and who created it. |
| videoId / videoTitle / videoUrl | string | Video (VOD) identifiers and link. |
| publishedAt | string | When a video was published, in ISO 8601 UTC. |

### 💰 Pricing

This Actor uses **pay per result**, so you only pay for the rows you actually receive. Runs that return nothing cost nothing, and there are no monthly subscriptions or hidden fees. Set **Max results** to keep any run within your budget, and start small to preview the data before scaling up.

### ❓ FAQ

##### Does it get blocked?

No. Twitch's public data feed has no anti-bot walls for this kind of read-only lookup, so runs are fast and reliable without needing residential proxies.

##### Do I need a Twitch account or login?

No. The Actor needs no login, no password, and no account. Just pick a mode and press start.

##### How fresh is the data?

Every run reads live from Twitch at the moment it runs, so viewer counts, follower counts, and live status are always current.

##### Which modes are supported?

Seven: channel lookup, channel search, top live streams sitewide, live streams for a specific game, the top games directory, clips, and videos. Chat messages and full follower lists are out of scope, as they need different infrastructure.

### 🛟 Support

Found a bug, or need an extra field? Open an issue on the **Issues** tab of this Actor and it will be reviewed. Custom versions and larger data pulls are available on request.

# Actor input Schema

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

What to scrape. 'Channels' looks up specific channels by login or URL. 'Search channels' finds channels matching a search phrase. 'Top live streams' returns the sitewide live directory. 'Streams by game' returns live streams for specific games. 'Top games' returns the sitewide game directory. 'Clips' and 'Videos' return a channel's clips or VODs.

## `targets` (type: `array`):

What to look up. Channels/Clips/Videos: channel logins or twitch.tv URLs (e.g. "shroud" or "https://www.twitch.tv/shroud"). Search channels: search phrases (e.g. "speedrun"). Streams by game: game or category names (e.g. "VALORANT"). Not used by Top live streams or Top games.

## `clipPeriod` (type: `string`):

Time window for ranking clips by views. Used by Clips mode, and by the 'Include top clips' enrichment on Channels mode.

## `includeRecentVideos` (type: `boolean`):

Attach each channel's most recent videos (VODs) as a nested list on the channel row. Channels mode only.

## `recentVideosLimit` (type: `integer`):

How many recent videos to attach per channel, when enabled above.

## `includeTopClips` (type: `boolean`):

Attach each channel's top clips (ranked by views over the clip period above) as a nested list on the channel row. Channels mode only.

## `topClipsLimit` (type: `integer`):

How many top clips to attach per channel, when enabled above.

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

Maximum number of records to return. Twitch caps a single request at 30 for Top live streams and 100 for Streams by game / Top games / Clips / Videos, so higher values are trimmed to that cap. Channels and Search channels return up to one row (or one page of matches) per target regardless of this value.

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

Twitch's public data feed has no anti-bot defenses, so a plain datacenter proxy is enough. Residential is not required.

## Actor input object example

```json
{
  "mode": "channels",
  "targets": [
    "shroud"
  ],
  "clipPeriod": "ALL_TIME",
  "includeRecentVideos": false,
  "recentVideosLimit": 5,
  "includeTopClips": false,
  "topClipsLimit": 5,
  "maxResults": 30,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

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

// Run the Actor and wait for it to finish
const run = await client.actor("getascraper/twitch-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 = {
    "targets": ["shroud"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("getascraper/twitch-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 '{
  "targets": [
    "shroud"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call getascraper/twitch-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Twitch Scraper: Channels, Streams, Clips & Games",
        "description": "Scrape Twitch channel profiles, live streams, top games, clips, and videos. No login, no API key. Covers channel lookup, channel search, top live streams, per-game streams, top games, clips, and VODs.",
        "version": "0.1",
        "x-build-id": "xJrWpTeVU8Kz6E4G4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/getascraper~twitch-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-getascraper-twitch-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/getascraper~twitch-scraper/runs": {
            "post": {
                "operationId": "runs-sync-getascraper-twitch-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/getascraper~twitch-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-getascraper-twitch-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": [
                            "channels",
                            "searchChannels",
                            "topStreams",
                            "gameStreams",
                            "topGames",
                            "clips",
                            "videos"
                        ],
                        "type": "string",
                        "description": "What to scrape. 'Channels' looks up specific channels by login or URL. 'Search channels' finds channels matching a search phrase. 'Top live streams' returns the sitewide live directory. 'Streams by game' returns live streams for specific games. 'Top games' returns the sitewide game directory. 'Clips' and 'Videos' return a channel's clips or VODs.",
                        "default": "channels"
                    },
                    "targets": {
                        "title": "Targets",
                        "type": "array",
                        "description": "What to look up. Channels/Clips/Videos: channel logins or twitch.tv URLs (e.g. \"shroud\" or \"https://www.twitch.tv/shroud\"). Search channels: search phrases (e.g. \"speedrun\"). Streams by game: game or category names (e.g. \"VALORANT\"). Not used by Top live streams or Top games.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "clipPeriod": {
                        "title": "Clip period",
                        "enum": [
                            "LAST_DAY",
                            "LAST_WEEK",
                            "LAST_MONTH",
                            "ALL_TIME"
                        ],
                        "type": "string",
                        "description": "Time window for ranking clips by views. Used by Clips mode, and by the 'Include top clips' enrichment on Channels mode.",
                        "default": "ALL_TIME"
                    },
                    "includeRecentVideos": {
                        "title": "Include recent videos",
                        "type": "boolean",
                        "description": "Attach each channel's most recent videos (VODs) as a nested list on the channel row. Channels mode only.",
                        "default": false
                    },
                    "recentVideosLimit": {
                        "title": "Recent videos limit",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many recent videos to attach per channel, when enabled above.",
                        "default": 5
                    },
                    "includeTopClips": {
                        "title": "Include top clips",
                        "type": "boolean",
                        "description": "Attach each channel's top clips (ranked by views over the clip period above) as a nested list on the channel row. Channels mode only.",
                        "default": false
                    },
                    "topClipsLimit": {
                        "title": "Top clips limit",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many top clips to attach per channel, when enabled above.",
                        "default": 5
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of records to return. Twitch caps a single request at 30 for Top live streams and 100 for Streams by game / Top games / Clips / Videos, so higher values are trimmed to that cap. Channels and Search channels return up to one row (or one page of matches) per target regardless of this value.",
                        "default": 30
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Twitch's public data feed has no anti-bot defenses, so a plain datacenter proxy is enough. Residential is not required.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
