# Twitch Scraper — Streams, Games, Channels & Clips API (`logiover/twitch-scraper`) Actor

Unofficial Twitch data API via Twitch's own GraphQL — no key, no login, no browser. Scrape top games, live streams, streamer/channel info, past videos (VODs) and top clips, plus channel & game search. Export Twitch datasets to JSON, CSV or Excel for creator discovery, gaming analytics & lead-gen.

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

## Pricing

from $3.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 — Live Streams, Top Games, Channels, Videos & Clips Data API

An **unofficial Twitch scraper** and structured **Twitch data API** in a single Apify actor. Pull the top games, live streams, streamer and channel profiles, past broadcasts (VODs) and top clips, plus channel & game search — powered directly by **Twitch's own public GraphQL** endpoint. No API key, no OAuth login, no developer app, no headless browser — just fast HTTP and clean, flat JSON you can export to CSV, Excel or JSON.

This **Twitch API alternative** is built for growth teams, gaming and esports analysts, influencer-marketing agencies, recommendation-engine developers, data scientists and AI agents who need reliable, structured **Twitch data** on demand. Seven modes share one input form, and every result is tagged with `_mode` so you can mix modes in a single dataset and filter later.

### What you get

- **Top live streams** — sweep the whole live directory: the top games and up to 100 live streams each, aggregated into one high-volume dataset (thousands of streams per run).
- **Top games / categories** — the games directory ranked by current viewers, with `viewersCount`, box art and a directory URL.
- **Live streams by game** — every visible live stream for a category with `title`, `viewersCount`, start time, freeform tags, game and full broadcaster details.
- **Channel / streamer profiles** — `login`, `displayName`, `description`, `followers`, partner/affiliate flags, account age, live status, current game and avatar/banner.
- **Videos (VODs)** — a channel's past broadcasts with `title`, `viewCount`, duration, publish date and game.
- **Clips** — a channel's top clips with `title`, `viewCount`, duration, creator (curator) and game, filterable by time window.
- **Search** — free-text search across channels (streamers) or games (categories).
- **Universal** — clean `twitchUrl`, plus `_mode` and `scrapedAt` (ISO 8601) on every item.

Export everything as **CSV, JSON, Excel (XLSX)**, HTML, RSS or JSON Lines. Six pre-built dataset views (Overview, Streams, Games, Channels, Videos, Clips) let you slice the data with zero post-processing.

#### The 7 modes

| Mode | What it returns |
|---|---|
| `topStreams` | Sweep the top games and pull their live streams — the whole live directory (highest volume) |
| `topGames` | Top games / categories ranked by current viewers |
| `streamsByGame` | Live streams for one or more specific games |
| `user` | Channel / streamer profile for one or many logins (batch) |
| `videos` | A channel's past broadcasts / VODs |
| `clips` | A channel's top clips |
| `search` | Free-text search across channels or games |

### Use cases

- **Creator & influencer discovery** — find streamers by game or keyword, rank channels by followers and live viewers, and build outreach lists for sponsorships and brand deals.
- **Gaming & esports analytics** — track which games top the directory over time, measure category viewership, and benchmark titles by concurrent viewers.
- **Live stream monitoring** — snapshot who is live in a category right now, with viewer counts, titles and tags, on a schedule.
- **Lead-gen for streamers** — export channel profiles (followers, partner status, current game, bio) as a clean CSV for sales and talent scouting.
- **Recommendation engines & ML** — bulk-ingest streams, games, clips and channels to train content or collaborative recommenders.
- **AI agents & RAG** — wrap the actor as a tool so an LLM can answer "who are the top VALORANT streamers live now?" or embed clip and VOD metadata.

### How to use

1. Open the actor and pick a **Mode**.
2. Fill the fields that mode needs — the input form shows which apply:
   - **topStreams**: optionally set `gameFanout` (how many games to sweep) and `gameSort`.
   - **topGames**: optionally set `gameSort`.
   - **streamsByGame**: set `game` like `Just Chatting` (or a batch in `games`).
   - **user**: set a `login` like `shroud` (or a batch in `logins`).
   - **videos / clips**: set a `login`; clips also take `clipPeriod` and `clipSort`.
   - **search**: set `query` and `searchIndex` (`CHANNEL` or `GAME`).
3. Optionally set `maxResults`.
4. Run the actor and export results as CSV, JSON or Excel — or pull them via the Apify API.

Example — sweep the top games for live streams (high-volume default):

```json
{
  "mode": "topStreams",
  "gameFanout": 30,
  "gameSort": "VIEWER_COUNT",
  "maxResults": 500
}
````

Example — pull profiles for a batch of channels:

```json
{
  "mode": "user",
  "logins": ["shroud", "pokimane", "xqc", "ninja"]
}
```

Call it from your stack via the Apify API (`run-sync-get-dataset-items`), the JavaScript/Python clients, or no-code tools like Make, n8n and Zapier.

### FAQ

#### Can I scrape Twitch without login or an API key?

Yes. This unofficial Twitch scraper reads publicly available data through Twitch's own public GraphQL endpoint, using the same anonymous web Client-ID your browser uses. You only need an Apify account — no Twitch API key, no OAuth, no registered developer app, no login.

#### Is this a Twitch API or a Twitch API alternative?

Both, effectively. It works as an **unofficial Twitch API** and a practical **Twitch API alternative**: you send structured input and get structured JSON back, without registering a Helix developer app, managing OAuth tokens, or hitting the official rate limits.

#### How do I get a Twitch top games API / directory data?

Use `topGames` for the categories ranked by current viewers, or `topStreams` to also pull the live streams inside each of those games. Both return `viewersCount` so you can chart directory trends over time.

#### How do I find streamers by game?

Use `streamsByGame` with the category name (e.g. `VALORANT`) to list everyone live in that game right now, with viewer counts and full broadcaster details. For keyword or name lookups, use `search` with `searchIndex: "CHANNEL"`.

#### How do I export Twitch streamer / channel data?

Use `user` mode with one login or a batch of logins to get a **Twitch streamer data export**: followers, partner/affiliate status, account age, live status, current game and avatar. Download it as CSV, JSON or Excel, or pull it via the Apify API — ideal for influencer-marketing and lead-gen.

#### Can I scrape Twitch clips and VODs?

Yes. `clips` returns a channel's top clips (filter by last day/week/month/all time and sort by views or date), and `videos` returns past broadcasts / VODs with view counts, duration and game.

#### How much data can one run return?

The `topStreams` mode sweeps many games and pulls up to 100 live streams per game, so a single run easily yields thousands of live-stream rows. Note that Twitch caps each request at 100 items and gates deep cursor pagination for guests, so this actor maximises volume by fanning out across games and channels rather than paging one endless list.

#### How do I export Twitch data to CSV, JSON or Excel?

Run any mode and download the dataset as CSV, JSON, Excel (XLSX), HTML, RSS or JSON Lines from the run page, or pull it via the Apify API. This makes it a simple Twitch data export and streaming dataset tool.

#### Does it work for esports / brand-safety monitoring?

Yes. Snapshot live streams in a category on a schedule to monitor who is broadcasting, their titles, tags and viewer counts — useful for esports tracking, sponsorship measurement and brand-safety review.

### Support

Open an issue on the actor page for bugs, feature requests, or custom modifications. Responses typically within 24 hours.

### 📝 Changelog

#### 2026-07-01

- Initial release: seven Twitch modes (top streams, top games, streams by game, channel profiles, videos, clips, search) over Twitch's public GraphQL — no key, no login, no browser.

# Actor input Schema

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

Which Twitch endpoint to run.

• **topStreams** — sweep the top games and pull live streams for each; aggregates the whole live directory (highest volume)
• **topGames** — top games / categories ranked by current viewers
• **streamsByGame** — live streams for one or more specific games
• **user** — channel / streamer profile for one or more logins (batch)
• **videos** — a channel's past broadcasts / VODs
• **clips** — a channel's top clips
• **search** — free-text search across channels or games

## `gameSort` (type: `string`):

Ordering for the games directory.

## `gameFanout` (type: `integer`):

How many top games **topStreams** should sweep for live streams. More games = more streams. 1-100.

## `game` (type: `string`):

Category name for **streamsByGame**, e.g. `Just Chatting`, `Minecraft`, `League of Legends`, `VALORANT`. Use the exact Twitch category name.

## `games` (type: `array`):

Array of category names for batch **streamsByGame**.

## `login` (type: `string`):

Twitch channel login / username for **user**, **videos**, **clips**, e.g. `shroud`. A full URL like `https://twitch.tv/shroud` or an `@handle` also works.

## `logins` (type: `array`):

Array of Twitch channel logins for batch **user** lookups, e.g. `["shroud", "pokimane", "xqc"]`.

## `videoSort` (type: `string`):

Ordering for a channel's videos.

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

Time window for a channel's clips.

## `clipSort` (type: `string`):

Ordering for a channel's clips.

## `query` (type: `string`):

Free-text term for **search** mode (a streamer name, keyword or game title).

## `searchIndex` (type: `string`):

Search **channels** (streamers) or **games** (categories).

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

Upper bound on rows returned. For topStreams/streamsByGame this drives the multi-game sweep; for topGames/videos/clips a single page caps at 100 (Twitch's per-request limit).

## Actor input object example

```json
{
  "mode": "topStreams",
  "gameSort": "VIEWER_COUNT",
  "gameFanout": 30,
  "game": "Just Chatting",
  "games": [],
  "login": "shroud",
  "logins": [
    "shroud",
    "pokimane",
    "xqc"
  ],
  "videoSort": "TIME",
  "clipPeriod": "ALL_TIME",
  "clipSort": "VIEWS_DESC",
  "query": "valorant",
  "searchIndex": "CHANNEL",
  "maxResults": 300
}
```

# Actor output Schema

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

Full results dataset. Use the Streams view for stream modes, Games for top games, Channels for user/search, Videos for VOD lists and Clips for clip lists.

# 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 = {
    "mode": "topStreams",
    "gameSort": "VIEWER_COUNT",
    "gameFanout": 30,
    "game": "Just Chatting",
    "login": "shroud",
    "logins": [
        "shroud",
        "pokimane",
        "xqc"
    ],
    "maxResults": 300
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/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 = {
    "mode": "topStreams",
    "gameSort": "VIEWER_COUNT",
    "gameFanout": 30,
    "game": "Just Chatting",
    "login": "shroud",
    "logins": [
        "shroud",
        "pokimane",
        "xqc",
    ],
    "maxResults": 300,
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/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 '{
  "mode": "topStreams",
  "gameSort": "VIEWER_COUNT",
  "gameFanout": 30,
  "game": "Just Chatting",
  "login": "shroud",
  "logins": [
    "shroud",
    "pokimane",
    "xqc"
  ],
  "maxResults": 300
}' |
apify call logiover/twitch-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Twitch Scraper — Streams, Games, Channels & Clips API",
        "description": "Unofficial Twitch data API via Twitch's own GraphQL — no key, no login, no browser. Scrape top games, live streams, streamer/channel info, past videos (VODs) and top clips, plus channel & game search. Export Twitch datasets to JSON, CSV or Excel for creator discovery, gaming analytics & lead-gen.",
        "version": "1.0",
        "x-build-id": "EhYD4ZUOBvd6NNy8p"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~twitch-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-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/logiover~twitch-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-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/logiover~twitch-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-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": "Mode",
                        "enum": [
                            "topStreams",
                            "topGames",
                            "streamsByGame",
                            "user",
                            "videos",
                            "clips",
                            "search"
                        ],
                        "type": "string",
                        "description": "Which Twitch endpoint to run.\n\n• **topStreams** — sweep the top games and pull live streams for each; aggregates the whole live directory (highest volume)\n• **topGames** — top games / categories ranked by current viewers\n• **streamsByGame** — live streams for one or more specific games\n• **user** — channel / streamer profile for one or more logins (batch)\n• **videos** — a channel's past broadcasts / VODs\n• **clips** — a channel's top clips\n• **search** — free-text search across channels or games",
                        "default": "topStreams"
                    },
                    "gameSort": {
                        "title": "Game sort (topStreams / topGames)",
                        "enum": [
                            "VIEWER_COUNT",
                            "RELEVANCE",
                            "NUM_FOLLOWERS"
                        ],
                        "type": "string",
                        "description": "Ordering for the games directory.",
                        "default": "VIEWER_COUNT"
                    },
                    "gameFanout": {
                        "title": "Games to sweep (topStreams)",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many top games **topStreams** should sweep for live streams. More games = more streams. 1-100.",
                        "default": 30
                    },
                    "game": {
                        "title": "Game / category",
                        "type": "string",
                        "description": "Category name for **streamsByGame**, e.g. `Just Chatting`, `Minecraft`, `League of Legends`, `VALORANT`. Use the exact Twitch category name."
                    },
                    "games": {
                        "title": "Games / categories (batch)",
                        "type": "array",
                        "description": "Array of category names for batch **streamsByGame**.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "login": {
                        "title": "Channel login",
                        "type": "string",
                        "description": "Twitch channel login / username for **user**, **videos**, **clips**, e.g. `shroud`. A full URL like `https://twitch.tv/shroud` or an `@handle` also works."
                    },
                    "logins": {
                        "title": "Channel logins (batch, user)",
                        "type": "array",
                        "description": "Array of Twitch channel logins for batch **user** lookups, e.g. `[\"shroud\", \"pokimane\", \"xqc\"]`.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "videoSort": {
                        "title": "Video sort (videos)",
                        "enum": [
                            "TIME",
                            "VIEWS"
                        ],
                        "type": "string",
                        "description": "Ordering for a channel's videos.",
                        "default": "TIME"
                    },
                    "clipPeriod": {
                        "title": "Clip period (clips)",
                        "enum": [
                            "LAST_DAY",
                            "LAST_WEEK",
                            "LAST_MONTH",
                            "ALL_TIME"
                        ],
                        "type": "string",
                        "description": "Time window for a channel's clips.",
                        "default": "ALL_TIME"
                    },
                    "clipSort": {
                        "title": "Clip sort (clips)",
                        "enum": [
                            "VIEWS_DESC",
                            "VIEWS_ASC",
                            "CREATED_AT_DESC",
                            "CREATED_AT_ASC"
                        ],
                        "type": "string",
                        "description": "Ordering for a channel's clips.",
                        "default": "VIEWS_DESC"
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text term for **search** mode (a streamer name, keyword or game title)."
                    },
                    "searchIndex": {
                        "title": "Search target",
                        "enum": [
                            "CHANNEL",
                            "GAME"
                        ],
                        "type": "string",
                        "description": "Search **channels** (streamers) or **games** (categories).",
                        "default": "CHANNEL"
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Upper bound on rows returned. For topStreams/streamsByGame this drives the multi-game sweep; for topGames/videos/clips a single page caps at 100 (Twitch's per-request limit).",
                        "default": 300
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
