# Steam Store Game Scraper (`parseforge/steam-store-scraper`) Actor

Pull live game data from the Steam store by keyword or app ID. Returns title, price, discount, developer, genres, release date, platforms, Metacritic score, and the aggregate review rating with positive and negative counts. Useful for price tracking, market research, and game analytics.

- **URL**: https://apify.com/parseforge/steam-store-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** E-commerce, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🎮 Steam Store Game Scraper

> 🚀 **Turn any Steam search into structured game data.** Search "rpg" and Steam returns 60,673 titles. This Actor pulls price, genres, ratings, and review counts for every game you target.

> 🕒 **Last updated:** 2026-06-02 · **📊 30 fields** per game · keyword or app ID input · live pricing and review scores

Pull clean, structured data from the Steam store by keyword or app ID. For every game the Actor returns price and discount, developer and publisher, genres and categories, release date, platforms, Metacritic score, and the full Steam review breakdown with positive and negative counts.

**Coverage:** the entire public Steam store. Pass search terms (for example "hollow knight", "roguelike", "racing"), specific app IDs, or both, and choose your pricing region.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Game studios and publishers | Track competitor pricing and reception |
| Market analysts | Study genres, ratings, and release trends |
| Deal and price trackers | Monitor discounts across titles |
| Data scientists | Build gaming datasets for analysis |

### 📋 What the Steam Store Game Scraper does

- Runs any number of search terms against the Steam store and paginates the results.
- Accepts direct Steam app IDs for targeted pulls.
- Returns 30 structured fields per game, including the full review breakdown.
- Captures live price, discount percentage, and currency for your chosen region.
- Includes Metacritic score, developer, publisher, genres, and platforms.
- Exports to CSV, Excel, JSON, XML, or via API.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `searchTerms` | array | Game search queries to run on the Steam store. |
| `appIds` | array | Optional. Specific Steam app IDs to scrape directly. |
| `maxItems` | integer | Cap on total games returned. Free plan is limited to 10. |
| `countryCode` | string | Two-letter region for pricing and currency. |
| `language` | string | Language for store text fields. |
| `includeReviews` | boolean | Fetch the aggregate review summary per game. |

**Example 1: search by keyword**
```json
{
  "searchTerms": ["hollow knight", "celeste"],
  "maxItems": 50,
  "countryCode": "us"
}
````

**Example 2: target specific games by app ID**

```json
{
  "searchTerms": [],
  "appIds": ["367520", "1245620", "413150"],
  "includeReviews": true
}
```

> ⚠️ **Good to Know:** prices and currency follow the `countryCode` you set. Free games return a null price with `isFree` set to true. Metacritic score and website appear only for games that publish them.

### 📊 Output

Each record contains the following fields:

| Field | Description |
|---|---|
| 🖼 `imageUrl` | Game header image |
| 🎮 `name` | Game title |
| 🔗 `appUrl` | Store page link |
| 🆔 `appId` | Steam app ID |
| 📦 `type` | App type (game, dlc, music) |
| 🆓 `isFree` | Free to play flag |
| 💲 `price` | Current price |
| 💱 `currency` | Price currency |
| 🏷 `discountPercent` | Active discount percentage |
| 🧾 `priceFormatted` | Display price string |
| 🧑‍💻 `developers` | Developer studios |
| 🏢 `publishers` | Publishers |
| 📅 `releaseDate` | Release date |
| ⏳ `comingSoon` | Unreleased flag |
| 🔞 `requiredAge` | Required age |
| 🎭 `genres` | Genre list |
| 🧩 `categories` | Store feature categories |
| 💻 `platforms` | Supported platforms |
| 🏆 `metacriticScore` | Metacritic score |
| 👍 `recommendationsTotal` | Steam recommendations |
| ⭐ `reviewScoreDesc` | Review rating label |
| 🗣 `totalReviews` | Total reviews |
| ✅ `totalPositive` | Positive reviews |
| ❌ `totalNegative` | Negative reviews |
| 🌐 `website` | Official website |
| 📝 `shortDescription` | Short description |
| 🔎 `searchTerm` | Query that surfaced this game |
| 🖼 `screenshots` | Screenshot URLs |
| 🕒 `scrapedAt` | Collection timestamp |
| ❌ `error` | Error message, null on success |

**Real sample records:**

```json
{
  "imageUrl": "https://shared.akamai.steamstatic.com/store_item_assets/steam/apps/367520/header.jpg",
  "name": "Hollow Knight",
  "appUrl": "https://store.steampowered.com/app/367520",
  "appId": 367520,
  "isFree": false,
  "price": 14.99,
  "currency": "USD",
  "discountPercent": 0,
  "developers": ["Team Cherry"],
  "publishers": ["Team Cherry"],
  "releaseDate": "Feb 24, 2017",
  "genres": ["Action", "Adventure", "Indie"],
  "platforms": ["windows", "mac", "linux"],
  "metacriticScore": 87,
  "recommendationsTotal": 486777,
  "reviewScoreDesc": "Overwhelmingly Positive",
  "totalReviews": 543708,
  "totalPositive": 526931,
  "totalNegative": 16777,
  "error": null
}
```

```json
{
  "imageUrl": "https://shared.akamai.steamstatic.com/store_item_assets/steam/apps/1030300/header.jpg",
  "name": "Hollow Knight: Silksong",
  "appUrl": "https://store.steampowered.com/app/1030300",
  "appId": 1030300,
  "isFree": false,
  "price": 19.99,
  "currency": "USD",
  "discountPercent": 0,
  "developers": ["Team Cherry"],
  "publishers": ["Team Cherry"],
  "releaseDate": "Sep 4, 2025",
  "genres": ["Action", "Adventure", "Indie"],
  "platforms": ["windows", "mac", "linux"],
  "metacriticScore": 90,
  "recommendationsTotal": 374084,
  "reviewScoreDesc": "Very Positive",
  "totalReviews": 408296,
  "totalPositive": 364510,
  "totalNegative": 43786,
  "error": null
}
```

```json
{
  "imageUrl": "https://shared.akamai.steamstatic.com/store_item_assets/steam/apps/598190/header.jpg",
  "name": "Hollow Knight - Official Soundtrack",
  "appUrl": "https://store.steampowered.com/app/598190",
  "appId": 598190,
  "isFree": false,
  "price": 9.99,
  "currency": "USD",
  "discountPercent": 0,
  "developers": ["Team Cherry"],
  "publishers": ["Team Cherry"],
  "releaseDate": "Feb 24, 2017",
  "genres": ["Action", "Adventure", "Indie"],
  "platforms": ["windows", "mac", "linux"],
  "metacriticScore": null,
  "recommendationsTotal": 583,
  "reviewScoreDesc": "Overwhelmingly Positive",
  "totalReviews": 595,
  "totalPositive": 572,
  "totalNegative": 23,
  "error": null
}
```

### ✨ Why choose this Actor

- **Whole-store reach.** Search any keyword and paginate thousands of titles.
- **Full review breakdown.** Rating label plus positive and negative counts on every game.
- **Region-aware pricing.** Set the country code and get local price and currency.
- **No always-null fields.** Optional fields like Metacritic are kept only when the game publishes them.
- **Ready to export.** CSV, Excel, JSON, XML, or API, with a clean table view.

### 📈 How it compares to alternatives

| | Steam Store Game Scraper | Manual browsing | Generic web scrapers |
|---|---|---|---|
| Structured 30-field output | ✅ | ❌ | ⚠️ Needs setup |
| Full review breakdown | ✅ | ⚠️ Per page | ❌ |
| Region pricing | ✅ | ⚠️ | ❌ |
| Keyword and app ID input | ✅ | ❌ | ⚠️ |
| Export to CSV/Excel/JSON/XML | ✅ | ❌ | ⚠️ |

### 🚀 How to use

1. Create a free Apify account using [this sign-up link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the Steam Store Game Scraper.
3. Enter `searchTerms` or `appIds`, set `maxItems`, and pick a `countryCode`.
4. Click **Start** and watch the dataset fill in real time.
5. Export your results as CSV, Excel, JSON, or XML, or pull them via API.

### 💼 Business use cases

**🎯 Competitive pricing**
| Goal | How |
|---|---|
| Track competitor prices | Pull titles by genre or studio |
| Watch discounts | Re-run on a schedule and compare |

**📊 Market research**
| Goal | How |
|---|---|
| Map a genre | Aggregate search results across terms |
| Gauge reception | Compare review counts and ratings |

**📈 Trend analysis**
| Goal | How |
|---|---|
| Study releases | Group games by release date |
| Find breakouts | Sort by recommendations and positive reviews |

**🧮 Dataset building**
| Goal | How |
|---|---|
| Build catalogs | Export names, genres, and images |
| Feed models | Use ratings and prices as features |

### 🔌 Automating Steam Store Game Scraper

Connect this Actor to your stack with Apify integrations: **Make**, **Zapier**, **Slack**, **Airbyte**, **GitHub**, and **Google Drive**. Schedule runs and push fresh game data into spreadsheets, databases, or alerts.

### 🌟 Beyond business use cases

- **Research:** analyze pricing and rating patterns across the catalog.
- **Personal:** build a wishlist tracker for price drops.
- **Non-profit:** study accessibility and platform support trends.
- **Experimentation:** create datasets for gaming analytics projects.

### 🤖 Ask an AI assistant

Paste your dataset into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Copilot](https://copilot.microsoft.com) and ask for top-rated games, average prices by genre, or release trends.

### ❓ Frequently Asked Questions

**1. Can I scrape by keyword and by app ID?**
Yes. Provide `searchTerms`, `appIds`, or both in the same run.

**2. How many games can a search return?**
As many as Steam lists. "rpg" returns over 60,000 results. Use `maxItems` to cap output.

**3. Does it include review data?**
Yes. Each game carries the rating label plus total, positive, and negative review counts.

**4. How is pricing handled?**
Pricing follows the `countryCode` you choose, with the matching currency.

**5. What about free games?**
Free games return a null price and `isFree` set to true.

**6. Do I need a Steam account or API key?**
No. The Actor only uses publicly available store data.

**7. What export formats are supported?**
CSV, Excel, JSON, XML, and API.

**8. Is Metacritic always present?**
No. It appears only for games that publish a Metacritic score.

**9. Can I run it on a schedule?**
Yes, with Apify Schedules and integrations.

**10. Is there a free option?**
Yes. Free runs are limited to 10 items as a preview. Paid plans unlock up to 1,000,000.

### 🔌 Integrate with any app

Use the Apify API, webhooks, and 5,000-plus integrations to push Steam data into Make, Zapier, Google Sheets, Airtable, databases, and more.

### 🔗 Recommended Actors

- [RAWG Games Scraper](https://apify.com/parseforge/rawg-scraper)
- [OpenCritic Games Scraper](https://apify.com/parseforge/opencritic-games-scraper)
- [Metacritic Scraper](https://apify.com/parseforge/metacritic-scraper)
- [itch.io Scraper](https://apify.com/parseforge/itch-io-scraper)
- [Twitch Live Streams Scraper](https://apify.com/parseforge/twitch-live-streams-scraper)

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with Valve or Steam. Only publicly available data is collected.

# Actor input Schema

## `searchTerms` (type: `array`):

Game search queries to run on the Steam store (e.g. "elden ring", "roguelike"). One result set per term.

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

Optional. Specific Steam app IDs to scrape directly (e.g. "1245620", "570").

## `maxItems` (type: `integer`):

Free users: limited to 10 items (preview). Paid users: optional, max 1,000,000.

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

Two-letter country code used for store pricing and currency.

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

Language for store text fields.

## `includeReviews` (type: `boolean`):

Fetch the aggregate review summary for each game (one extra request per game).

## Actor input object example

```json
{
  "searchTerms": [
    "elden ring"
  ],
  "maxItems": 10,
  "countryCode": "us",
  "language": "english",
  "includeReviews": true
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchTerms": [
        "elden ring"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/steam-store-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 = {
    "searchTerms": ["elden ring"],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/steam-store-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 '{
  "searchTerms": [
    "elden ring"
  ],
  "maxItems": 10
}' |
apify call parseforge/steam-store-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Steam Store Game Scraper",
        "description": "Pull live game data from the Steam store by keyword or app ID. Returns title, price, discount, developer, genres, release date, platforms, Metacritic score, and the aggregate review rating with positive and negative counts. Useful for price tracking, market research, and game analytics.",
        "version": "0.1",
        "x-build-id": "1o07A31dkWHB81jOx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~steam-store-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-steam-store-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/parseforge~steam-store-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-steam-store-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/parseforge~steam-store-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-steam-store-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": [
                    "searchTerms"
                ],
                "properties": {
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "Game search queries to run on the Steam store (e.g. \"elden ring\", \"roguelike\"). One result set per term.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "appIds": {
                        "title": "Steam App IDs",
                        "type": "array",
                        "description": "Optional. Specific Steam app IDs to scrape directly (e.g. \"1245620\", \"570\").",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: limited to 10 items (preview). Paid users: optional, max 1,000,000."
                    },
                    "countryCode": {
                        "title": "Country (pricing)",
                        "enum": [
                            "us",
                            "gb",
                            "de",
                            "fr",
                            "ca",
                            "au",
                            "br",
                            "in",
                            "jp",
                            "mx"
                        ],
                        "type": "string",
                        "description": "Two-letter country code used for store pricing and currency.",
                        "default": "us"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "english",
                            "spanish",
                            "french",
                            "german",
                            "portuguese",
                            "italian",
                            "japanese"
                        ],
                        "type": "string",
                        "description": "Language for store text fields.",
                        "default": "english"
                    },
                    "includeReviews": {
                        "title": "Include review scores",
                        "type": "boolean",
                        "description": "Fetch the aggregate review summary for each game (one extra request per game).",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```