# Steam Review Scraper & Analyzer (`alex_lavricheva/steamscrape`) Actor

Scrape Steam game reviews with optional Claude AI analysis, get the top praised and criticized aspects per game, keyword sentiment breakdowns, and playtime-based sentiment trends.

- **URL**: https://apify.com/alex\_lavricheva/steamscrape.md
- **Developed by:** [Alex Lavricheva](https://apify.com/alex_lavricheva) (community)
- **Categories:** AI, E-commerce, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.10 / 1,000 review 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

### What does Steam Review Scraper & Analyzer do?

**Steam Review Scraper & Analyzer** lets you scrape and analyze player reviews from [Steam](https://store.steampowered.com/) by game category or specific game IDs. It extracts structured review data and uses **Claude AI** to surface what players love and hate most, how sentiment shifts with playtime, and whether developers are engaging with their community. Run it on the Apify platform for easy scheduling, API access, proxy rotation, and dataset export in any format.

### Why use Steam Review Scraper & Analyzer?

- **Market research** - understand player pain points and praise before launching or updating a game
- **Competitor analysis** - see exactly what players love or hate about games in your category
- **Post-patch monitoring** - filter reviews by date to measure player reception after an update
- **Community health checks** - track whether sentiment worsens or improves as players accumulate hours
- **Dev engagement tracking** - surface only reviews where developers have replied
- **Choosing games** - Find the games per category you will like

### How to use Steam Review Scraper & Analyzer

1. Go to the **Input** tab and choose your scrape mode: by **category** or by one or more specific **Game IDs**
2. Set your filters (sentiment, min hours played, keyword, date range, etc.)
3. Choose a **run mode**: get AI-summarized top complaints/praise (`getMostCommon`), see how sentiment shifts by hours played (`groupByHours`), both. You can also get only reviews with dev replies
4. Click **Start** and wait for the run to finish
5. Go to the **Output** tab to view results, or download the dataset as JSON, CSV, HTML, or Excel


### Output

Results are saved to the default Apify dataset and can be downloaded in JSON, CSV, HTML, or Excel format.

**Example output item (`getMostCommon` mode):**

```json
{
    "gameId": "1245620",
    "title": "ELDEN RING",
    "url": "https://store.steampowered.com/app/1245620/ELDEN_RING/",
    "currentPrice": "$39.99",
    "tags": ["Souls-like", "RPG", "Open World", "Dark Fantasy"],
    "reviews": [
        { "votedUp": true, "hoursAtReview": 24.5, "text": "One of the greatest games ever made...", "timestamp": 1704067200 },
        { "votedUp": false, "hoursAtReview": 8.2, "text": "Performance issues killed it for me.", "timestamp": 1704153600 }
    ],
    "sentimentBreakdown": {
        "label": "Overwhelmingly Positive",
        "positive": "97%",
        "negative": "3%"
    },
    "topPraise": "Incredibly rewarding exploration and boss design",
    "topComplaint": "Performance issues and network instability in co-op"
}
````

**Example output item (`groupByHours` mode):**

```json
{
    "gameId": "1245620",
    "title": "ELDEN RING",
    "url": "https://store.steampowered.com/app/1245620/ELDEN_RING/",
    "currentPrice": "$39.99",
    "tags": ["Souls-like", "RPG", "Open World"],
    "reviews": [
        { "votedUp": true, "hoursAtReview": 24.5, "text": "One of the greatest games ever made...", "timestamp": 1704067200 }
    ],
    "sentimentBreakdown": {
        "label": "Overwhelmingly Positive",
        "positive": "97%",
        "negative": "3%"
    },
    "hoursBrackets": [
        {
            "hoursBracket": "0–20 hours",
            "positivePercent": 72,
            "negativePercent": 28,
            "reviewCount": 145
        },
        {
            "hoursBracket": "20–50 hours",
            "positivePercent": 65,
            "negativePercent": 35,
            "reviewCount": 267,
            "mostCommonPraise": "Satisfying difficulty curve",
            "mostCommonComplaint": "Confusing late-game progression"
        }
    ]
}
```

### Data table

| Field | Description |
|---|---|
| `gameId` | Steam App ID |
| `title` | Game title |
| `url` | Steam store page URL |
| `currentPrice` | Current Steam price (including sale price if applicable) |
| `tags` | Steam tags (e.g. Multiplayer, Story Rich, Co-op) |
| `reviews` | Array of filtered reviews. Each entry has `votedUp`, `hoursAtReview`, `text`, `timestamp`, and optionally `devReply` |
| `sentimentBreakdown` | Overall sentiment from Steam: `label` (e.g. `"Very Positive"`), `positive` %, and `negative` % |
| `topPraise` | AI-generated summary of most praised aspects (`getMostCommon` only) |
| `topComplaint` | AI-generated summary of most criticised aspects (`getMostCommon` only) |
| `keywordMentionCount` | Number of reviews mentioning the keyword (`keyword` set, no sentiment filter) |
| `keywordPraisedPercent` | % of keyword-mentioning reviews where the keyword is used positively |
| `keywordCriticizedPercent` | % of keyword-mentioning reviews where the keyword is used negatively |
| `devReplies` | Array of developer reply texts, one per matched review (`devReplied: true` only) |
| `hoursBrackets` | Array of sentiment breakdowns per hours-played bracket (`groupByHours` only). Each entry has `hoursBracket`, `positivePercent`, `negativePercent`, `reviewCount`, and optionally `mostCommonPraise`/`mostCommonComplaint` when `getMostCommon` is also enabled |

### Pricing / Cost estimation

### Tips and advanced options

- **Use `gameId` for precision** — if you know exactly which games you want, passing App IDs directly is faster and cheaper than scraping a whole category
- **Combine `getMostCommon` + `groupByHours`** — enabling both gives you AI-summarized feedback broken down by playtime bracket, ideal for understanding how player perception evolves
- **Post-patch analysis** — set `reviewsAfterDate` to the day of a patch release and `sentiment: "negative"` to quickly identify emerging complaints
- **Concurrency** — this Actor uses HTTP/Cheerio (not a browser), so it's fast and lightweight. Avoid setting very high concurrency to stay respectful of Steam's servers

### FAQ, disclaimers, and support

**What happens if `isOnSale: true` but no games are on sale?**
The Actor will return an empty dataset for that run. No error is thrown — it simply finds no matching games. Try running again during a Steam sale event.

**I need a custom feature or have found a bug.**
Please open an issue in the [Issues tab](../../issues). Custom solutions and bulk data needs can also be discussed there.

# Actor input Schema

## `category` (type: `string`):

Steam category or tag to scrape (e.g. 'RPG', 'Souls-like')

## `gameId` (type: `array`):

One or more Steam App IDs to target (e.g. '730', '570')

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

Two-letter country code used for localized pricing and game availability (e.g. 'US', 'GB', 'DE').

## `maxGames` (type: `integer`):

Maximum number of games to scrape from the category. Leave empty for no limit.

## `maxReviewsPerGame` (type: `integer`):

Stop collecting reviews for a game after this many reviews. Leave empty for no limit. Keeping this low reduces run time and storage.

## `onSaleOnly` (type: `boolean`):

Only include games currently on sale. Only applies in Category mode. If no games in the category are on sale, the dataset will be empty.

## `reviewSentiment` (type: `string`):

Filter reviews by sentiment.

## `minHoursPlayed` (type: `number`):

Only include reviews from players with at least this many hours played.

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

Only fetch reviews written in this language. Uses Steam language names: 'english', 'french', 'german', 'spanish', 'russian', 'schinese', 'tchinese', 'japanese', 'korean', 'brazilian', 'polish', etc. Defaults to 'all'.

## `reviewsAfterDate` (type: `string`):

Only include reviews posted after this date (YYYY-MM-DD). Useful for post-patch or post-launch analysis.

## `devReplied` (type: `boolean`):

If enabled, only include reviews where the developer has replied. The developer reply will be included in the output.

## `keyword` (type: `string`):

Only include reviews that mention this keyword.

## `keywordSentiment` (type: `string`):

When set to positive or negative, only counts reviews where the keyword is used in that context — and skips the AI breakdown (it would be 100% trivial). Leave as 'Any' to get the full praised/criticized % breakdown via AI.

## `anthropicApiKey` (type: `string`):

Your personal Anthropic API key for AI features (AI Sentiment Summary, Keyword Sentiment). If provided, takes priority over the ANTHROPIC\_API\_KEY preset.

## `usePresetKey` (type: `boolean`):

Use the preset key on Actor. At least one of this or the Anthropic API Key field above must be set for AI features to work.

## `getMostCommon` (type: `boolean`):

Use Claude AI to analyze reviews and output a summary of the most praised and most criticised aspects per game.

## `includeReviewsInOutput` (type: `boolean`):

When enabled, saves all scraped reviews as OUTPUT.csv to the key-value store. Columns: gameId, gameTitle, votedUp, hoursAtReview, timestamp, devReply, text.

## `groupByHours` (type: `boolean`):

Group reviews into hours-played brackets and show how the positive/negative sentiment split changes with playtime.

## `groupByHoursMin` (type: `number`):

Lower bound of the hours-played range.

## `groupByHoursMax` (type: `number`):

Upper bound of the hours-played range. Leave empty for no upper limit.

## Actor input object example

```json
{
  "category": "RPG",
  "gameId": [],
  "countryCode": "US",
  "maxGames": 10,
  "maxReviewsPerGame": 200,
  "onSaleOnly": false,
  "reviewSentiment": "all",
  "minHoursPlayed": 0,
  "language": "all",
  "reviewsAfterDate": "2024-01-01",
  "devReplied": false,
  "keyword": "",
  "keywordSentiment": "none",
  "usePresetKey": false,
  "getMostCommon": false,
  "includeReviewsInOutput": false,
  "groupByHours": false,
  "groupByHoursMin": 0,
  "groupByHoursMax": 1000
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "category": "RPG",
    "maxGames": 10,
    "maxReviewsPerGame": 200,
    "reviewsAfterDate": "2024-01-01",
    "groupByHoursMax": 1000
};

// Run the Actor and wait for it to finish
const run = await client.actor("alex_lavricheva/steamscrape").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 = {
    "category": "RPG",
    "maxGames": 10,
    "maxReviewsPerGame": 200,
    "reviewsAfterDate": "2024-01-01",
    "groupByHoursMax": 1000,
}

# Run the Actor and wait for it to finish
run = client.actor("alex_lavricheva/steamscrape").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 '{
  "category": "RPG",
  "maxGames": 10,
  "maxReviewsPerGame": 200,
  "reviewsAfterDate": "2024-01-01",
  "groupByHoursMax": 1000
}' |
apify call alex_lavricheva/steamscrape --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Steam Review Scraper & Analyzer",
        "description": "Scrape Steam game reviews with optional Claude AI analysis, get the top praised and criticized aspects per game, keyword sentiment breakdowns, and playtime-based sentiment trends.",
        "version": "0.0",
        "x-build-id": "kMohXeCa89FLCwNBy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/alex_lavricheva~steamscrape/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-alex_lavricheva-steamscrape",
                "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/alex_lavricheva~steamscrape/runs": {
            "post": {
                "operationId": "runs-sync-alex_lavricheva-steamscrape",
                "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/alex_lavricheva~steamscrape/run-sync": {
            "post": {
                "operationId": "run-sync-alex_lavricheva-steamscrape",
                "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": {
                    "category": {
                        "title": "Category",
                        "type": "string",
                        "description": "Steam category or tag to scrape (e.g. 'RPG', 'Souls-like')"
                    },
                    "gameId": {
                        "title": "Game IDs",
                        "type": "array",
                        "description": "One or more Steam App IDs to target (e.g. '730', '570')",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "countryCode": {
                        "title": "Country Code",
                        "type": "string",
                        "description": "Two-letter country code used for localized pricing and game availability (e.g. 'US', 'GB', 'DE').",
                        "default": "US"
                    },
                    "maxGames": {
                        "title": "Max Games",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of games to scrape from the category. Leave empty for no limit."
                    },
                    "maxReviewsPerGame": {
                        "title": "Max Reviews per Game",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Stop collecting reviews for a game after this many reviews. Leave empty for no limit. Keeping this low reduces run time and storage."
                    },
                    "onSaleOnly": {
                        "title": "On Sale Only",
                        "type": "boolean",
                        "description": "Only include games currently on sale. Only applies in Category mode. If no games in the category are on sale, the dataset will be empty.",
                        "default": false
                    },
                    "reviewSentiment": {
                        "title": "Review Sentiment",
                        "enum": [
                            "all",
                            "positive",
                            "negative"
                        ],
                        "type": "string",
                        "description": "Filter reviews by sentiment.",
                        "default": "all"
                    },
                    "minHoursPlayed": {
                        "title": "Minimum Hours Played",
                        "minimum": 0,
                        "type": "number",
                        "description": "Only include reviews from players with at least this many hours played.",
                        "default": 0
                    },
                    "language": {
                        "title": "Review Language",
                        "type": "string",
                        "description": "Only fetch reviews written in this language. Uses Steam language names: 'english', 'french', 'german', 'spanish', 'russian', 'schinese', 'tchinese', 'japanese', 'korean', 'brazilian', 'polish', etc. Defaults to 'all'.",
                        "default": "all"
                    },
                    "reviewsAfterDate": {
                        "title": "Reviews After Date",
                        "pattern": "^$|^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Only include reviews posted after this date (YYYY-MM-DD). Useful for post-patch or post-launch analysis."
                    },
                    "devReplied": {
                        "title": "Developer Replied Only",
                        "type": "boolean",
                        "description": "If enabled, only include reviews where the developer has replied. The developer reply will be included in the output.",
                        "default": false
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Only include reviews that mention this keyword.",
                        "default": ""
                    },
                    "keywordSentiment": {
                        "title": "Keyword Sentiment",
                        "enum": [
                            "none",
                            "positive",
                            "negative"
                        ],
                        "type": "string",
                        "description": "When set to positive or negative, only counts reviews where the keyword is used in that context — and skips the AI breakdown (it would be 100% trivial). Leave as 'Any' to get the full praised/criticized % breakdown via AI.",
                        "default": "none"
                    },
                    "anthropicApiKey": {
                        "title": "Anthropic API Key",
                        "type": "string",
                        "description": "Your personal Anthropic API key for AI features (AI Sentiment Summary, Keyword Sentiment). If provided, takes priority over the ANTHROPIC_API_KEY preset."
                    },
                    "usePresetKey": {
                        "title": "Use preset key for AI",
                        "type": "boolean",
                        "description": "Use the preset key on Actor. At least one of this or the Anthropic API Key field above must be set for AI features to work.",
                        "default": false
                    },
                    "getMostCommon": {
                        "title": "AI Sentiment Summary",
                        "type": "boolean",
                        "description": "Use Claude AI to analyze reviews and output a summary of the most praised and most criticised aspects per game.",
                        "default": false
                    },
                    "includeReviewsInOutput": {
                        "title": "Include Reviews in Output",
                        "type": "boolean",
                        "description": "When enabled, saves all scraped reviews as OUTPUT.csv to the key-value store. Columns: gameId, gameTitle, votedUp, hoursAtReview, timestamp, devReply, text.",
                        "default": false
                    },
                    "groupByHours": {
                        "title": "Group by Hours Played",
                        "type": "boolean",
                        "description": "Group reviews into hours-played brackets and show how the positive/negative sentiment split changes with playtime.",
                        "default": false
                    },
                    "groupByHoursMin": {
                        "title": "Min Hours",
                        "minimum": 0,
                        "type": "number",
                        "description": "Lower bound of the hours-played range.",
                        "default": 0
                    },
                    "groupByHoursMax": {
                        "title": "Max Hours",
                        "minimum": 0,
                        "type": "number",
                        "description": "Upper bound of the hours-played range. Leave empty for no upper limit."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
