# Steam Review Monitor - Game Review, Score & Player Tracker (`constant_quadruped/steam-review-monitor`) Actor

Monitor Steam games for recent reviews (positive/negative split, text, author playtime), review-score deltas, live concurrent-player counts + recent peak, and a 'what changed since last run' digest. Track your game and competitors side by side. Pure HTTP on Steam's official zero-auth public APIs.

- **URL**: https://apify.com/constant\_quadruped/steam-review-monitor.md
- **Developed by:** [CQ](https://apify.com/constant_quadruped) (community)
- **Categories:** Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 game record returneds

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Steam Review Monitor — Game Review, Score & Player-Count Tracker

Monitor any **Steam** game's reviews, review score, and live player base — built for **indie game studios** who need to know what changed since yesterday without babysitting the Steam page.

Point it at your own game's appid (plus any competitors), schedule it, and every run you get:

- **Recent reviews** — newest-first, with positive/negative split, full review text, and the **author's playtime** (total, at time of review, and last two weeks). Playtime is the single best signal for separating a 0.2-hour rage-review from a 400-hour veteran's verdict.
- **Review-score delta** — Steam's official rating bucket (`Very Positive`, `Mixed`, …), all-time positive/negative counts, positive share, and **how each of those moved since your last run**.
- **Live players + recent peak** — current concurrent-player count from Steam's official API, plus the peak this monitor has seen across runs, and the change since last run.
- **"What changed since last run" digest** — new reviews (positive vs negative), player-count swing, whether the review-score bucket flipped, and **spiking complaint themes** (e.g. `cheaters` mentions jumped from 1 → 9).
- **Negative-spike flag** — automatically raised when the negative share of the recent window jumps past your threshold, so a review-bombing or a bad patch is flagged in the dataset as soon as your next run sees it.
- **Competitor tracking** — pass competitor appids and get the exact same intelligence side-by-side in one dataset.

### 100% real data — no mocks, no browser

Every field comes from Steam's official, zero-auth public endpoints:

| Endpoint | What it provides |
| --- | --- |
| `store.steampowered.com/appreviews/<appid>` | Recent reviews + global review-score summary |
| `api.steampowered.com/ISteamUserStats/GetNumberOfCurrentPlayers` | Live concurrent-player count |
| `store.steampowered.com/api/appdetails` | Name, developers, genres, price, release date |

No headless browser, no proxies, no API key. Pure HTTP, which keeps it fast and cheap.

### Input

| Field | Type | Description |
| --- | --- | --- |
| `appIds` | array | Steam appids (e.g. `730`) or store URLs to monitor. |
| `competitorAppIds` | array | Competitor games to track side-by-side. |
| `language` | string | Review language (`all`, `english`, `schinese`, …). Default `all`. |
| `reviewType` | string | `all`, `positive`, or `negative`. |
| `purchaseType` | string | `all`, `steam`, or `non_steam_purchase`. |
| `maxReviewPages` | integer | Recent-review pages per game (1–10; 100/page). Default `3`. |
| `dayRange` | integer | Limit recent reviews to the last N days (1–365). |
| `countryCode` | string | Country for store pricing. Default `us`. |
| `sinceLastRun` | boolean | Report only what's new since the previous run. Default `true`. |
| `includeReviewText` | boolean | Include the raw review body. Default `true`. |
| `themeKeywords` | object | Custom `theme -> [keywords]` map for tagging. |
| `negativeSpikeThreshold` | number | Negative-share jump that trips the spike flag. Default `0.15`. |

#### Example input

```json
{
  "appIds": ["730"],
  "competitorAppIds": ["570"],
  "language": "english",
  "maxReviewPages": 3,
  "sinceLastRun": true
}
````

### Output

One dataset item per game. Key fields:

```json
{
  "appId": "730",
  "name": "Counter-Strike 2",
  "role": "primary",
  "developers": ["Valve"],
  "genres": ["Action", "Free To Play"],
  "currentPlayerCount": 597217,
  "recentPeakPlayerCount": 612004,
  "playerCountDelta": 14787,
  "reviewScoreDesc": "Very Positive",
  "totalReviews": 2559796,
  "totalPositive": 2209859,
  "positiveShareAllTime": 0.8633,
  "reviewScoreDelta": {
    "reviewScoreDescChanged": false,
    "totalReviewsChange": 412,
    "totalPositiveChange": 360
  },
  "windowSummary": {
    "windowReviews": 300,
    "windowPositive": 251,
    "windowPositiveShare": 0.837,
    "medianAuthorPlaytimeAtReviewHours": 187.4
  },
  "themeBreakdown": [
    { "theme": "cheaters", "count": 41, "negativeMentions": 38, "sampleSnippets": ["..."] }
  ],
  "reviews": [
    {
      "reviewId": "...",
      "votedUp": true,
      "review": "...",
      "authorPlaytimeForeverHours": 1284.5,
      "authorPlaytimeAtReviewHours": 1190.2,
      "createdAt": "2026-06-21T18:42:00.000Z"
    }
  ],
  "isNegativeSpike": false,
  "changeDigest": {
    "isFirstRun": false,
    "newReviewsCount": 27,
    "newPositive": 22,
    "newNegative": 5,
    "playerCountDelta": 14787,
    "spikingThemes": [{ "theme": "cheaters", "was": 12, "now": 41 }],
    "isNegativeSpike": false
  },
  "scrapedAt": "2026-06-22T20:10:00.000Z"
}
```

The **Overview** dataset view gives a one-row-per-game table: game, players now, recent peak, review score, total/new reviews, and the negative-spike flag.

### Recommended use

- **Schedule it daily** (or hourly around a patch/launch). `sinceLastRun: true` makes each run a clean changelog of new reviews, player swings, and theme spikes.
- **Wire the digest to alerts** — push the `changeDigest` and `isNegativeSpike` fields to Slack/Discord/email via an Apify integration so a review-bomb or bad patch surfaces as soon as your next scheduled run picks it up. (The Actor writes data and flags; it does not send notifications itself.)
- **Watch competitors** to see how a rival's launch or sale moves their player count and review score relative to yours.

### Pricing

This Actor is lightweight — pure HTTP against Steam's public endpoints, with no headless browser and no proxies — so runs are cheap in compute. Your actual cost depends on the pricing model configured for the Actor on the Apify platform (e.g. pay-per-result or platform compute usage) and on how many games you monitor: adding more apps or raising `maxReviewPages` increases run time and the number of dataset records.

### Limitations

- **Global figures.** Reviews and player counts are **global**; `countryCode` only changes the store price returned by `appdetails`, not the reviews or player numbers.
- **Baseline on second run.** The first run establishes a baseline in the Actor's key-value store (`RUN_STATE`); deltas, the change digest, and score/player comparisons only populate from the **second** run onward. Running against a fresh or reset storage resets that baseline.
- **"Recent peak" is monitor-local.** `recentPeakPlayerCount` is the highest concurrent count *this monitor* has observed across its own runs — not Steam's all-time peak.
- **Bounded review depth.** `maxReviewPages` caps the recent-review sweep at up to 10 pages × 100 = ~1,000 newest reviews per game per run. This is a rolling recent-review monitor, not a full historical review export; older reviews beyond that window are not fetched.
- **No proxies / rate limits.** Requests go directly from the Apify server IP. The Actor self-throttles (~1 request every 0.9s) and backs off on HTTP 429/503, but very frequent runs or large app lists can still be rate-limited by Steam, in which case some fields for a game may come back partial or `null` for that run.
- **Graceful on outages — expect nulls.** If Steam is unreachable, rate-limits, or an app simply has no data, the Actor still writes that app's record with `null`/empty fields instead of failing the run. Downstream consumers should handle missing values.
- **Store metadata can be missing.** `name`, `developers`, `publishers`, `genres`, and price come from Steam `appdetails`, which can return nothing for unreleased, delisted, or region-restricted apps. `currentPlayerCount` is `null` for apps Steam does not report a player count for (e.g. some non-game apps).
- **Not a notifier.** The Actor produces data and flags (`isNegativeSpike`, `changeDigest`); delivering alerts requires wiring the dataset to an Apify integration, and detection is only as timely as your run schedule.

# Actor input Schema

## `appIds` (type: `array`):

Steam numeric appids (e.g. 730) or full store URLs (e.g. https://store.steampowered.com/app/730/Counter\_Strike\_2/) for the games you want to monitor.

## `competitorAppIds` (type: `array`):

Competitor games to include in the same run for side-by-side review-score, player-count and complaint-theme comparison.

## `language` (type: `string`):

Steam review language filter (e.g. 'english', 'all', 'schinese', 'german'). 'all' returns reviews in every language.

## `reviewType` (type: `string`):

Which reviews to pull from the recent feed.

## `purchaseType` (type: `string`):

Filter by how the reviewer obtained the game. 'steam' = bought on Steam; 'non\_steam\_purchase' = activated a key.

## `maxReviewPages` (type: `integer`):

Each page is up to 100 newest reviews; 3 pages ~= 300 newest reviews. Raise for a deeper sweep of a busy game.

## `dayRange` (type: `integer`):

Limit recent reviews to the last N days (Steam supports up to 365). Leave empty for newest-first regardless of age.

## `countryCode` (type: `string`):

2-letter country code used for store pricing in appdetails (e.g. us, gb, de). Reviews/players are global.

## `sinceLastRun` (type: `boolean`):

When true, the review window and digest report only what is new since the previous run (using the key-value store state). Turn off for a full snapshot every run.

## `includeReviewText` (type: `boolean`):

When false, omits the raw review body (keeps ratings, playtime, votes, themes) for a smaller, lighter dataset.

## `themeKeywords` (type: `object`):

Map of theme -> array of keywords to tag in review text. Defaults cover crash/performance/bug/cheaters/matchmaking/monetization/content/praise.

## `negativeSpikeThreshold` (type: `number`):

Flag isNegativeSpike when the negative share of the recent-review window jumps by at least this fraction vs last run (0-1).

## Actor input object example

```json
{
  "appIds": [
    "730",
    "https://store.steampowered.com/app/570/Dota_2/"
  ],
  "language": "all",
  "reviewType": "all",
  "purchaseType": "all",
  "maxReviewPages": 3,
  "countryCode": "us",
  "sinceLastRun": true,
  "includeReviewText": true,
  "negativeSpikeThreshold": 0.15
}
```

# Actor output Schema

## `overview` (type: `string`):

One row per game: name, appid, role, current players, recent peak, review score, total reviews, new reviews, and negative-spike flag.

# 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 = {
    "appIds": [
        "730"
    ],
    "language": "all",
    "countryCode": "us"
};

// Run the Actor and wait for it to finish
const run = await client.actor("constant_quadruped/steam-review-monitor").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 = {
    "appIds": ["730"],
    "language": "all",
    "countryCode": "us",
}

# Run the Actor and wait for it to finish
run = client.actor("constant_quadruped/steam-review-monitor").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 '{
  "appIds": [
    "730"
  ],
  "language": "all",
  "countryCode": "us"
}' |
apify call constant_quadruped/steam-review-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Steam Review Monitor - Game Review, Score & Player Tracker",
        "description": "Monitor Steam games for recent reviews (positive/negative split, text, author playtime), review-score deltas, live concurrent-player counts + recent peak, and a 'what changed since last run' digest. Track your game and competitors side by side. Pure HTTP on Steam's official zero-auth public APIs.",
        "version": "1.0",
        "x-build-id": "QQVLhYYPFNTkrvEwd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/constant_quadruped~steam-review-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-constant_quadruped-steam-review-monitor",
                "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/constant_quadruped~steam-review-monitor/runs": {
            "post": {
                "operationId": "runs-sync-constant_quadruped-steam-review-monitor",
                "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/constant_quadruped~steam-review-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-constant_quadruped-steam-review-monitor",
                "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",
                "properties": {
                    "appIds": {
                        "title": "Steam app IDs or store URLs",
                        "type": "array",
                        "description": "Steam numeric appids (e.g. 730) or full store URLs (e.g. https://store.steampowered.com/app/730/Counter_Strike_2/) for the games you want to monitor.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "competitorAppIds": {
                        "title": "Competitor app IDs/URLs (optional)",
                        "type": "array",
                        "description": "Competitor games to include in the same run for side-by-side review-score, player-count and complaint-theme comparison.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "language": {
                        "title": "Review language",
                        "type": "string",
                        "description": "Steam review language filter (e.g. 'english', 'all', 'schinese', 'german'). 'all' returns reviews in every language.",
                        "default": "all"
                    },
                    "reviewType": {
                        "title": "Review type",
                        "enum": [
                            "all",
                            "positive",
                            "negative"
                        ],
                        "type": "string",
                        "description": "Which reviews to pull from the recent feed.",
                        "default": "all"
                    },
                    "purchaseType": {
                        "title": "Purchase type",
                        "enum": [
                            "all",
                            "steam",
                            "non_steam_purchase"
                        ],
                        "type": "string",
                        "description": "Filter by how the reviewer obtained the game. 'steam' = bought on Steam; 'non_steam_purchase' = activated a key.",
                        "default": "all"
                    },
                    "maxReviewPages": {
                        "title": "Max recent-review pages per game (1-10)",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Each page is up to 100 newest reviews; 3 pages ~= 300 newest reviews. Raise for a deeper sweep of a busy game.",
                        "default": 3
                    },
                    "dayRange": {
                        "title": "Recent-review day range (optional, 1-365)",
                        "minimum": 1,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Limit recent reviews to the last N days (Steam supports up to 365). Leave empty for newest-first regardless of age."
                    },
                    "countryCode": {
                        "title": "Store country code",
                        "type": "string",
                        "description": "2-letter country code used for store pricing in appdetails (e.g. us, gb, de). Reviews/players are global.",
                        "default": "us"
                    },
                    "sinceLastRun": {
                        "title": "Only new reviews/changes since last run",
                        "type": "boolean",
                        "description": "When true, the review window and digest report only what is new since the previous run (using the key-value store state). Turn off for a full snapshot every run.",
                        "default": true
                    },
                    "includeReviewText": {
                        "title": "Include full review text",
                        "type": "boolean",
                        "description": "When false, omits the raw review body (keeps ratings, playtime, votes, themes) for a smaller, lighter dataset.",
                        "default": true
                    },
                    "themeKeywords": {
                        "title": "Custom theme keyword groups (optional)",
                        "type": "object",
                        "description": "Map of theme -> array of keywords to tag in review text. Defaults cover crash/performance/bug/cheaters/matchmaking/monetization/content/praise."
                    },
                    "negativeSpikeThreshold": {
                        "title": "Negative-spike threshold",
                        "minimum": 0,
                        "maximum": 1,
                        "type": "number",
                        "description": "Flag isNegativeSpike when the negative share of the recent-review window jumps by at least this fraction vs last run (0-1).",
                        "default": 0.15
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```