# Steam Market Intelligence: Top Sellers & Opportunity Tracker (`lokki/steam-top-sellers-scraper`) Actor

Go beyond raw Steam scraping. Track top sellers, popular new releases, coming soon, specials, or custom Steam searches, then score each game with market intelligence: demand, quality, commercial strength, momentum, opportunity type, risk flags, and recommended actions.

- **URL**: https://apify.com/lokki/steam-top-sellers-scraper.md
- **Developed by:** [Ian Dikhtiar](https://apify.com/lokki) (community)
- **Categories:** Automation, E-commerce, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.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.

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

## Steam Market Intelligence: Top Sellers & Opportunity Tracker

Stop staring at Steam spreadsheets. This actor turns Steam rankings into **decision-ready game market intelligence**: what is winning, why it is winning, where competitors look vulnerable, and which games deserve deeper research.

Use it to track top sellers, new releases, discounts, coming-soon games, niche searches, and custom Steam search pages — then get scores, positioning, risk flags, and recommended actions for every result.

### Why this actor is different

Most Steam scrapers give you rows.

This one gives you **signals**.

Instead of only returning title, price, reviews, and URL, the actor adds a smart intelligence layer that helps answer questions like:

- Which games are true breakout leaders?
- Which competitors have demand but weak sentiment?
- Which niches have passionate audiences but less competition?
- Which games are ranking because of heavy discounts?
- Which titles should be benchmarked for positioning, pricing, capsule art, tags, and launch strategy?
- Which results should be ignored because they are hardware, DLC-like, or missing enough market data?

### Best use cases

- **Indie game research** — find promising genres, pricing patterns, and underserved player demand.
- **Publisher scouting** — monitor early momentum, new releases, and breakout signals.
- **Competitor intelligence** — benchmark top games by reviews, player count, tags, pricing, and monetization.
- **Launch planning** — study what Steam rewards in your category before releasing.
- **Discount analysis** — spot aggressive promotions and price-pressure patterns.
- **Market dashboards** — feed clean Steam intelligence into BI tools, Google Sheets, Airtable, Notion, or your own database.

### What you get

#### Core Steam fields

- Rank
- App ID
- Title
- Steam URL
- Release date
- Price text and final price cents
- Discount percentage
- Review summary
- Positive review percentage
- Review count
- Supported platforms
- Capsule image URL
- Scrape timestamp

#### Enriched public app details

Enabled by default.

- Developer
- Publisher
- Genres
- Categories
- Recommendations total
- Metacritic score, when available
- Short description
- App type, such as game or hardware
- Free-to-play flag

#### Live demand signals

Enabled by default.

- Current player count, when Steam exposes it
- Multiplayer/community indicators
- In-app purchase indicators
- Fresh release signals
- Discount pressure signals

### The intelligence layer

The actor calculates five scores from public Steam signals.

#### `demandScore`

Measures market pull using rank, review count, recommendations, and current players.

High demand means the game is attracting attention now or has strong accumulated traction.

#### `qualityScore`

Measures player satisfaction using review percentage, review summary, Metacritic where available, and review-count confidence.

This helps separate "popular because discounted" from "popular because players love it."

#### `commercialScore`

Measures commercial strength using pricing, discount level, free-to-play status, multiplayer/co-op signals, and in-app purchase indicators.

Useful for spotting games with strong monetization or aggressive pricing.

#### `momentumScore`

Measures current market movement using rank, feed type, recent release timing, and live player count.

Great for launch tracking and early trend detection.

#### `opportunityScore`

The headline score. Combines demand, quality, commercial strength, and momentum into a 0-100 opportunity rating.

Use this to sort the dataset fast and decide which games deserve deeper research.

### Intelligence classifications

Each row can include:

- `marketPosition` — e.g. Breakout leader, Loved niche title, High demand with vulnerable sentiment.
- `opportunityType` — e.g. Benchmark competitor, Displacement opportunity, Watchlist candidate.
- `pricingPosition` — e.g. Free-to-play, Budget, Mid-market, Premium, Promotional discount.
- `audienceSignal` — e.g. Community/multiplayer audience, Solo/narrative audience, Strategy/systems audience.
- `monetizationSignal` — e.g. Paid upfront, Free acquisition funnel, Base game plus in-app purchases.
- `competitiveSignal` — plain-English competitor interpretation.
- `intelligenceTags` — sortable tags like `high-demand`, `loved-by-players`, `fresh-release`, `social-retention-loop`.
- `riskFlags` — warnings like missing review data, hidden price, weak sentiment, or non-game listing.
- `insightSummary` — one-sentence summary of why the game matters.
- `recommendedAction` — what to do next.

### Example output

```json
{
  "rank": 2,
  "appId": 730,
  "title": "Counter-Strike 2",
  "url": "https://store.steampowered.com/app/730/CounterStrike_2/",
  "priceText": "Free",
  "reviewSummary": "Very Positive",
  "reviewPercent": 86,
  "reviewCount": 2531502,
  "currentPlayers": 1226698,
  "developer": "Valve",
  "publisher": "Valve",
  "genres": ["Action", "Free To Play"],
  "demandScore": 85,
  "qualityScore": 96,
  "commercialScore": 88,
  "momentumScore": 90,
  "opportunityScore": 89,
  "marketPosition": "Breakout leader",
  "opportunityType": "Benchmark competitor",
  "pricingPosition": "Free-to-play",
  "audienceSignal": "Community / multiplayer audience",
  "monetizationSignal": "Base game plus in-app purchases",
  "competitiveSignal": "Strong incumbent - study positioning and retention loops",
  "intelligenceTags": [
    "tier-1-opportunity",
    "high-demand",
    "loved-by-players",
    "massive-live-audience",
    "free-to-play",
    "iap-monetized"
  ],
  "riskFlags": [],
  "insightSummary": "Counter-Strike 2 is a breakout leader, opportunity score 89/100, 86% positive from 2,531,502 reviews, 1,226,698 current players.",
  "recommendedAction": "Use as a benchmark for capsule, pricing, tags, update cadence, and review themes."
}
````

### Quick start

For most users, the default settings are the best starting point:

```json
{
  "filter": "topsellers",
  "maxItems": 100,
  "country": "US",
  "language": "english",
  "includeIntelligence": true
}
```

That will scrape Steam top sellers and automatically include app details, current players, and intelligence scoring.

### Input guide

#### Pick a Steam feed

Choose the ranking list you want to study:

- **Top sellers** — best default for market research and competitor benchmarking.
- **Popular new releases** — use for launch tracking and early momentum.
- **Coming soon** — use for upcoming-market watchlists. Some fields may be missing because Steam has not exposed them yet.
- **Specials / discounted games** — use for discount and price-pressure analysis.
- **New releases** — use to monitor newly launched games.

#### Add a search query

Optional. Combine a keyword with the selected feed.

Good examples:

- `survival`
- `cozy`
- `horror`
- `automation`
- `deckbuilder`
- `roguelike`

#### Use custom Steam search URLs

For advanced research, paste one or more public Steam search URLs.

This is useful when you already filtered Steam by tags, price, category, discount, platform, or release window.

Example workflow:

1. Open Steam search in your browser.
2. Apply tags or filters.
3. Copy the Steam search URL.
4. Paste it into `steamSearchUrls`.

The actor will use those URLs instead of the basic feed/query builder.

#### Choose max items

- `25` — fast sample / sanity check
- `100` — good market snapshot
- `250+` — broader category research
- `1000` — maximum allowed per run

#### Country and language

Use country for localized prices and language for Steam text.

Common country examples:

- `US`
- `GB`
- `CA`
- `AU`
- `DE`

Default language is `english`.

#### Enrichment toggles

The actor defaults to intelligence mode, so these are on by default:

- **Include public app details** — developer, publisher, genres, categories, recommendations, Metacritic, description.
- **Include current player count** — live Steam player count when exposed.
- **Add Steam Market Intelligence** — scores, classifications, summaries, and recommended actions.

Turn enrichment off only if you want a faster raw scrape.

#### Request delay

Default: `250 ms`

Increase this for larger runs if you want to be extra conservative with public Steam endpoints.

### Recommended presets

#### Competitor benchmark

```json
{
  "filter": "topsellers",
  "query": "survival",
  "maxItems": 100,
  "country": "US",
  "language": "english"
}
```

#### Launch tracking

```json
{
  "filter": "popularnew",
  "maxItems": 100,
  "country": "US",
  "language": "english"
}
```

#### Discount intelligence

```json
{
  "filter": "specials",
  "maxItems": 150,
  "country": "US",
  "language": "english"
}
```

#### Niche opportunity research

```json
{
  "filter": "topsellers",
  "query": "cozy automation",
  "maxItems": 100,
  "country": "US",
  "language": "english"
}
```

#### Raw scrape mode

```json
{
  "filter": "topsellers",
  "maxItems": 100,
  "includeAppDetails": false,
  "includeCurrentPlayers": false,
  "includeIntelligence": false
}
```

### Notes and limitations

- Uses public Steam Store endpoints.
- Does not log in.
- Does not scrape private user data.
- Does not bypass age gates, login walls, or account pages.
- Some games, demos, hardware listings, DLC-like items, unreleased games, or small apps may not expose player count, reviews, price, developer, or publisher data.
- `currentPlayers` can be `0` for valid apps with no active players at scrape time.

### Output destinations

Results are saved to the default Apify dataset.

A `SUMMARY` record is also saved to the default key-value store with run settings, counts, and generated fields.

# Actor input Schema

## `filter` (type: `string`):

Which public Steam ranking should the actor analyze? Top sellers is the strongest default for market research.

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

Narrow the feed to a market niche. Examples: survival, cozy, horror, automation, roguelike, deckbuilder, city builder. Leave blank for the full feed.

## `steamSearchUrls` (type: `array`):

Optional. Paste public store.steampowered.com/search URLs when you already filtered Steam by tags, category, discount, platform, price, or release window. If provided, these URLs override the feed/query builder.

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

Maximum number of Steam results to save. Recommended: 100 for most market research runs.

## `country` (type: `string`):

Steam country code for localized pricing. Common examples: US, GB, CA, AU, DE.

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

Language used for Steam text, review summaries, genres, and categories. Default: english.

## `includeIntelligence` (type: `boolean`):

Adds demand, quality, commercial, momentum, and opportunity scores, plus market position, opportunity type, pricing/audience/monetization signals, intelligence tags, risk flags, insight summaries, and recommended actions.

## `includeAppDetails` (type: `boolean`):

Recommended on. Adds developer, publisher, genres, categories, recommendations, Metacritic score, short description, free-to-play status, and app type from Steam's public appdetails endpoint. Intelligence mode keeps this on automatically.

## `includeCurrentPlayers` (type: `boolean`):

Recommended on. Adds Steam's public current player count when available. Some apps, hardware listings, demos, and unreleased games do not expose this value. Intelligence mode keeps this on automatically.

## `requestDelayMs` (type: `integer`):

Polite delay in milliseconds between optional enrichment requests. Recommended: 250. Use 500-1000 for larger runs.

## Actor input object example

```json
{
  "filter": "topsellers",
  "query": "survival",
  "steamSearchUrls": [
    "https://store.steampowered.com/search/?tags=1662&filter=topsellers"
  ],
  "maxItems": 100,
  "country": "US",
  "language": "english",
  "includeIntelligence": true,
  "includeAppDetails": true,
  "includeCurrentPlayers": true,
  "requestDelayMs": 250
}
```

# Actor output Schema

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

Default dataset items produced by the actor.

## `summary` (type: `string`):

Summary JSON stored in the default key-value store.

# 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 = {
    "query": "survival",
    "steamSearchUrls": [
        "https://store.steampowered.com/search/?tags=1662&filter=topsellers"
    ],
    "country": "US",
    "language": "english"
};

// Run the Actor and wait for it to finish
const run = await client.actor("lokki/steam-top-sellers-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 = {
    "query": "survival",
    "steamSearchUrls": ["https://store.steampowered.com/search/?tags=1662&filter=topsellers"],
    "country": "US",
    "language": "english",
}

# Run the Actor and wait for it to finish
run = client.actor("lokki/steam-top-sellers-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 '{
  "query": "survival",
  "steamSearchUrls": [
    "https://store.steampowered.com/search/?tags=1662&filter=topsellers"
  ],
  "country": "US",
  "language": "english"
}' |
apify call lokki/steam-top-sellers-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Steam Market Intelligence: Top Sellers & Opportunity Tracker",
        "description": "Go beyond raw Steam scraping. Track top sellers, popular new releases, coming soon, specials, or custom Steam searches, then score each game with market intelligence: demand, quality, commercial strength, momentum, opportunity type, risk flags, and recommended actions.",
        "version": "1.0",
        "x-build-id": "ReAm1K9xi9OZPAt4S"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lokki~steam-top-sellers-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lokki-steam-top-sellers-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/lokki~steam-top-sellers-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lokki-steam-top-sellers-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/lokki~steam-top-sellers-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lokki-steam-top-sellers-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": [
                    "maxItems"
                ],
                "properties": {
                    "filter": {
                        "title": "Steam feed to analyze",
                        "enum": [
                            "topsellers",
                            "popularnew",
                            "comingsoon",
                            "specials",
                            "newreleases"
                        ],
                        "type": "string",
                        "description": "Which public Steam ranking should the actor analyze? Top sellers is the strongest default for market research.",
                        "default": "topsellers"
                    },
                    "query": {
                        "title": "Optional niche or genre keyword",
                        "type": "string",
                        "description": "Narrow the feed to a market niche. Examples: survival, cozy, horror, automation, roguelike, deckbuilder, city builder. Leave blank for the full feed.",
                        "default": ""
                    },
                    "steamSearchUrls": {
                        "title": "Advanced: custom Steam search URLs",
                        "type": "array",
                        "description": "Optional. Paste public store.steampowered.com/search URLs when you already filtered Steam by tags, category, discount, platform, price, or release window. If provided, these URLs override the feed/query builder.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Games to analyze",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of Steam results to save. Recommended: 100 for most market research runs.",
                        "default": 100
                    },
                    "country": {
                        "title": "Pricing country",
                        "type": "string",
                        "description": "Steam country code for localized pricing. Common examples: US, GB, CA, AU, DE.",
                        "default": "US"
                    },
                    "language": {
                        "title": "Steam language",
                        "type": "string",
                        "description": "Language used for Steam text, review summaries, genres, and categories. Default: english.",
                        "default": "english"
                    },
                    "includeIntelligence": {
                        "title": "Add Steam Market Intelligence",
                        "type": "boolean",
                        "description": "Adds demand, quality, commercial, momentum, and opportunity scores, plus market position, opportunity type, pricing/audience/monetization signals, intelligence tags, risk flags, insight summaries, and recommended actions.",
                        "default": true
                    },
                    "includeAppDetails": {
                        "title": "Add developer, publisher, genres, and app metadata",
                        "type": "boolean",
                        "description": "Recommended on. Adds developer, publisher, genres, categories, recommendations, Metacritic score, short description, free-to-play status, and app type from Steam's public appdetails endpoint. Intelligence mode keeps this on automatically.",
                        "default": true
                    },
                    "includeCurrentPlayers": {
                        "title": "Add live current player count",
                        "type": "boolean",
                        "description": "Recommended on. Adds Steam's public current player count when available. Some apps, hardware listings, demos, and unreleased games do not expose this value. Intelligence mode keeps this on automatically.",
                        "default": true
                    },
                    "requestDelayMs": {
                        "title": "Delay between enrichment requests",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Polite delay in milliseconds between optional enrichment requests. Recommended: 250. Use 500-1000 for larger runs.",
                        "default": 250
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```