# Twitch Streamer & Channel Analytics (`zhorex/twitch-scraper`) Actor

Extract Twitch streamer profiles, live streams, top games, clips, and VODs. 6 modes in one actor. No API key, no browser, no proxy needed. Pairs with our Kick.com Analytics for complete streaming intelligence. $3/1K results.

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

## Pricing

from $3.00 / 1,000 item scrapeds

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

## Twitch Streamer & Channel Analytics

The most comprehensive Twitch analytics actor on Apify. **6 modes, 1 actor, 0 API keys.** Extract streamer profiles, live streams, top games, clips, and VODs via Twitch's public API.

**No API key required. No browser. No proxy. Pure HTTP — fast and cheap.**

### How to scrape Twitch in 3 easy steps

1. **Go to the [Twitch Scraper](https://apify.com/zhorex/twitch-scraper) page** on Apify and click **"Try for free"**
2. **Configure your input** — choose a mode (`channel_details`, `live_streams`, `top_games`, `search`, `clips`, or `videos`), enter channel names or filters, and set the number of results
3. **Click "Run"**, wait for the scraper to finish, then **download your data** in JSON, CSV, or Excel format

No coding required. No API key. Works with Apify's free plan.

> **Streaming Intelligence Pair:** Use this alongside our [Kick.com Streamer & Channel Analytics](https://apify.com/zhorex/kick-scraper) for complete streaming platform coverage. The only developer on Apify offering both Twitch AND Kick.com analytics.

### What can this actor do?

| Mode | Description | Input needed |
|------|-------------|-------------|
| `channel_details` | Full streamer profiles with followers, stream status, partner status, clips | Channel names/URLs |
| `live_streams` | Currently live streams with viewers, game, tags | Optional game filter |
| `top_games` | Top categories ranked by viewers | Just maxResults |
| `search` | Find channels by keyword | Search query |
| `clips` | Top clips from specific channels | Channel names + time period |
| `videos` | VODs/past broadcasts from channels | Channel names + video type |

### Twitch API alternative

The official Twitch API requires OAuth registration, client IDs, and token management — and Twitch has been deprecating endpoints and tightening access since 2023. This Twitch Scraper is the best Twitch API alternative in 2026. It uses Twitch's public GraphQL endpoint to extract streamer profiles, live streams, top games, clips, and VODs — no API key, no OAuth, no token refresh. Just structured data, ready to use.

### Use cases

- **Influencer marketing** — Find streamers by game, viewer count, and follower count to identify partnership opportunities
- **Esports analytics** — Track competitive gaming viewership and tournament performance across categories
- **Brand sponsorship** — Evaluate streamer reach, engagement, and audience demographics for sponsorship decisions
- **Game publisher analytics** — Monitor your game's performance on Twitch: viewer trends, top streamers, clip virality
- **Content research** — Discover trending clips, rising categories, and emerging content formats
- **Talent scouting** — Identify rising streamers before they go mainstream using growth and engagement signals

### Scrape Twitch with Python, JavaScript, or no code

You can use the Twitch Scraper directly from the Apify Console (no code), or integrate it into your own scripts with Python or JavaScript.

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("zhorex/twitch-scraper").call(run_input={
    "mode": "channel_details",
    "channelLogins": ["shroud", "pokimane", "xqc"]
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
````

#### JavaScript

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('zhorex/twitch-scraper').call({
    mode: 'channel_details',
    channelLogins: ['shroud', 'pokimane', 'xqc'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => console.log(item));
```

### Input examples

#### Channel Details

```json
{
    "mode": "channel_details",
    "channelLogins": ["shroud", "pokimane", "xqc"]
}
```

#### Live Streams (filtered by game)

```json
{
    "mode": "live_streams",
    "gameFilter": "VALORANT",
    "minViewers": 100,
    "maxResults": 50
}
```

#### Top Games

```json
{
    "mode": "top_games",
    "maxResults": 25
}
```

#### Search Channels

```json
{
    "mode": "search",
    "searchQuery": "valorant",
    "maxResults": 20
}
```

#### Channel Clips

```json
{
    "mode": "clips",
    "channelLogins": ["shroud", "xqc"],
    "clipsPeriod": "LAST_WEEK",
    "maxResults": 50
}
```

#### Channel Videos (VODs)

```json
{
    "mode": "videos",
    "channelLogins": ["pokimane"],
    "videoType": "ARCHIVE",
    "maxResults": 20
}
```

### Output examples

#### Channel Details output

```json
{
    "login": "shroud",
    "displayName": "shroud",
    "url": "https://www.twitch.tv/shroud",
    "description": "Former CS:GO professional player...",
    "profileImageUrl": "https://...",
    "bannerImageUrl": "https://...",
    "followersCount": 10500000,
    "isPartner": true,
    "isAffiliate": false,
    "isLive": true,
    "currentStream": {
        "title": "VALORANT RANKED",
        "viewersCount": 25000,
        "game": "VALORANT",
        "startedAt": "2026-04-09T12:00:00Z",
        "tags": ["English", "FPS"]
    },
    "lastBroadcast": {
        "title": "VALORANT RANKED",
        "startedAt": "2026-04-09T12:00:00Z"
    },
    "totalVideos": 1500,
    "topClipsThisMonth": [...],
    "createdAt": "2014-06-15T00:00:00Z",
    "scrapedAt": "2026-04-09T15:00:00Z"
}
```

#### Live Streams output

```json
{
    "id": "12345678",
    "title": "RANKED GRIND",
    "viewersCount": 25000,
    "broadcasterLogin": "shroud",
    "broadcasterDisplayName": "shroud",
    "game": "VALORANT",
    "previewImageUrl": "https://...",
    "startedAt": "2026-04-09T12:00:00Z",
    "tags": ["English", "FPS"],
    "url": "https://www.twitch.tv/shroud",
    "scrapedAt": "2026-04-09T15:00:00Z"
}
```

#### Clips output

```json
{
    "id": "AbCdEfGh",
    "title": "INSANE 1v5 ACE",
    "viewCount": 500000,
    "createdAt": "2026-04-05T18:00:00Z",
    "durationSeconds": 30,
    "url": "https://clips.twitch.tv/...",
    "broadcasterLogin": "shroud",
    "game": "VALORANT",
    "curatorLogin": "viewer123",
    "scrapedAt": "2026-04-09T15:00:00Z"
}
```

### Technical advantages

- **No API key required** — Uses Twitch's public GraphQL endpoint, no OAuth setup
- **No browser/Playwright** — Pure HTTP requests = fast execution, low memory (256 MB)
- **No proxy needed** — Public API, no IP blocking
- **Cursor-based pagination** — Reliable extraction for large datasets up to 500 results
- **Resilient** — Each channel/query is independent; one failure doesn't crash the run

### Pricing

This actor uses pay-per-event pricing:

| Event | Price |
|-------|-------|
| 1 result scraped | $0.003 |
| 1,000 results | $3.00 |

Platform fee applies on top of actor usage cost.

### Limitations

- Twitch's public GraphQL API may change without notice (fields may be added/removed)
- Follower counts and viewer counts are real-time snapshots, not historical
- Maximum 500 results per run (use multiple runs for larger datasets)
- Some fields may return null if Twitch modifies their schema

### FAQ

#### Is there a Twitch API?

Twitch has an official API (Helix), but it requires OAuth app registration, client IDs, and ongoing token management. Twitch has also been deprecating endpoints and restricting access over time. This Twitch Scraper bypasses all that complexity — no API key, no OAuth, no tokens. Just configure and run.

#### How much does it cost to scrape Twitch?

The Twitch Scraper costs $0.003 per result ($3 per 1,000 results). You can start with Apify's free plan, which includes $5 of monthly credits — enough for over 1,600 Twitch data points.

#### Can I scrape Twitch in Python?

Yes. Install the Apify Python client (`pip install apify-client`), then use the `ApifyClient` to call the `zhorex/twitch-scraper` actor. See the Python code example above.

#### Is scraping Twitch legal?

This scraper uses Twitch's public GraphQL endpoint — the same one that powers the Twitch website. It only accesses publicly available data. Always review your local laws and Twitch's terms of service.

#### What is the best Twitch scraper in 2026?

The [Twitch Scraper by Zhorex](https://apify.com/zhorex/twitch-scraper) is the most comprehensive Twitch analytics actor on Apify in 2026. It supports 6 modes (channel details, live streams, top games, search, clips, and videos), requires no API key, and runs without a browser or proxy.

### Integrations & data export

The Twitch Scraper integrates with your existing workflow tools:

- **Google Sheets** — Send scraped Twitch data directly to a spreadsheet
- **Zapier / Make / n8n** — Automate workflows triggered by new Twitch data
- **REST API** — Call the actor programmatically and retrieve results via Apify's REST API
- **Webhooks** — Get notified when a scraping run finishes and process data in real time
- **Data formats** — Download results in JSON, CSV, Excel, XML, or RSS

### More scrapers by Zhorex

#### Streaming

- [Kick.com Streamer & Channel Analytics](https://apify.com/zhorex/kick-scraper) — The streaming pair: Kick.com profiles, live streams, clips, and categories

#### Chinese Digital Intelligence Suite

- [Bilibili Scraper](https://apify.com/zhorex/bilibili-scraper) — China's YouTube (video, danmaku, creator analytics)
- [RedNote (Xiaohongshu) Scraper](https://apify.com/zhorex/rednote-scraper) — China's Instagram + Pinterest (social commerce)
- [Weibo Scraper](https://apify.com/zhorex/weibo-scraper) — China's Twitter (microblogging, trending topics)
- [Zhihu Scraper](https://apify.com/zhorex/zhihu-scraper) — China's Quora (Q\&A, expert opinions)

#### B2B Reviews

- [G2 Reviews Scraper](https://apify.com/zhorex/g2-reviews-scraper) — B2B software reviews and ratings

#### Other Tools

- [Perplexity AI Scraper](https://apify.com/zhorex/perplexity-scraper) — AI-powered search results
- [Tech Stack Detector](https://apify.com/zhorex/tech-stack-detector) — Detect technologies used by websites
- [Telegram Channel Scraper](https://apify.com/zhorex/telegram-channel-scraper) — Public Telegram channel messages
- [Phone Number Validator](https://apify.com/zhorex/phone-number-validator) — Validate and format phone numbers
- [Sneaker Price Tracker](https://apify.com/zhorex/sneaker-price-tracker) — Track sneaker prices across platforms

***

💡 **Found this Actor useful?** Please [leave a star rating](https://apify.com/zhorex/twitch-scraper) — it helps other users discover this tool.

# Actor input Schema

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

Select what data to extract from Twitch.

## `channelLogins` (type: `array`):

Twitch usernames or full URLs (e.g., 'shroud' or 'https://www.twitch.tv/shroud'). Used in channel\_details, clips, and videos modes.

## `searchQuery` (type: `string`):

Keyword to search for channels (used in search mode only).

## `gameFilter` (type: `string`):

Filter live streams by game name (e.g., 'Fortnite', 'Just Chatting'). Used in live\_streams mode.

## `minViewers` (type: `integer`):

Only return live streams with at least this many viewers. Used in live\_streams mode.

## `clipsPeriod` (type: `string`):

Time range for fetching clips. Used in clips mode.

## `videoType` (type: `string`):

Type of videos to fetch. ARCHIVE = past broadcasts, HIGHLIGHT = highlights, UPLOAD = uploads. Used in videos mode.

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

Maximum number of results to return (up to 500).

## Actor input object example

```json
{
  "mode": "channel_details",
  "channelLogins": [
    "shroud",
    "pokimane",
    "xqc"
  ],
  "searchQuery": "valorant",
  "minViewers": 0,
  "clipsPeriod": "LAST_WEEK",
  "videoType": "ARCHIVE",
  "maxResults": 50
}
```

# 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 = {
    "channelLogins": [
        "shroud",
        "pokimane",
        "xqc"
    ],
    "searchQuery": "valorant"
};

// Run the Actor and wait for it to finish
const run = await client.actor("zhorex/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 = {
    "channelLogins": [
        "shroud",
        "pokimane",
        "xqc",
    ],
    "searchQuery": "valorant",
}

# Run the Actor and wait for it to finish
run = client.actor("zhorex/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 '{
  "channelLogins": [
    "shroud",
    "pokimane",
    "xqc"
  ],
  "searchQuery": "valorant"
}' |
apify call zhorex/twitch-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Twitch Streamer & Channel Analytics",
        "description": "Extract Twitch streamer profiles, live streams, top games, clips, and VODs. 6 modes in one actor. No API key, no browser, no proxy needed. Pairs with our Kick.com Analytics for complete streaming intelligence. $3/1K results.",
        "version": "1.0",
        "x-build-id": "vOXU6rEC0qPhnFcKU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/zhorex~twitch-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-zhorex-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/zhorex~twitch-scraper/runs": {
            "post": {
                "operationId": "runs-sync-zhorex-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/zhorex~twitch-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-zhorex-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": "Scraping mode",
                        "enum": [
                            "channel_details",
                            "live_streams",
                            "top_games",
                            "search",
                            "clips",
                            "videos"
                        ],
                        "type": "string",
                        "description": "Select what data to extract from Twitch.",
                        "default": "channel_details"
                    },
                    "channelLogins": {
                        "title": "Channel logins or URLs",
                        "type": "array",
                        "description": "Twitch usernames or full URLs (e.g., 'shroud' or 'https://www.twitch.tv/shroud'). Used in channel_details, clips, and videos modes.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Keyword to search for channels (used in search mode only)."
                    },
                    "gameFilter": {
                        "title": "Game/Category filter",
                        "type": "string",
                        "description": "Filter live streams by game name (e.g., 'Fortnite', 'Just Chatting'). Used in live_streams mode."
                    },
                    "minViewers": {
                        "title": "Minimum viewers",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return live streams with at least this many viewers. Used in live_streams mode.",
                        "default": 0
                    },
                    "clipsPeriod": {
                        "title": "Clips time period",
                        "enum": [
                            "LAST_DAY",
                            "LAST_WEEK",
                            "LAST_MONTH",
                            "ALL_TIME"
                        ],
                        "type": "string",
                        "description": "Time range for fetching clips. Used in clips mode.",
                        "default": "LAST_WEEK"
                    },
                    "videoType": {
                        "title": "Video type",
                        "enum": [
                            "ARCHIVE",
                            "HIGHLIGHT",
                            "UPLOAD"
                        ],
                        "type": "string",
                        "description": "Type of videos to fetch. ARCHIVE = past broadcasts, HIGHLIGHT = highlights, UPLOAD = uploads. Used in videos mode.",
                        "default": "ARCHIVE"
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of results to return (up to 500).",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
