# Steam Live Player Count Monitor (`automation-lab/steam-live-player-count-monitor`) Actor ๐ŸŽฎ Monitor live Steam concurrent players, enrich app-ID watchlists with official game metadata, and measure audience changes between scheduled snapshots. - **URL**: https://apify.com/automation-lab/steam-live-player-count-monitor.md - **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community) - **Categories:** Games - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing Pay per event 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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Actors are written with capital "A". ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. The best way to integrate Actors is as follows. In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md): ```bash pip install apify-client ``` In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md): ````bash # MacOS / Linux curl -fsSL https://apify.com/install-cli.sh | bash # Windows irm https://apify.com/install-cli.ps1 | iex ```bash In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md). If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README ## Steam Live Player Count Monitor Track live concurrent players for any Steam game, enrich each app with official Store metadata, and compare every observation with the previous saved snapshot. Use a list of Steam app IDs or Store URLs, run the Actor once or on an Apify schedule, and receive analysis-ready rows for audience spikes, launch performance, update impact, and player decay. The Actor uses official public Steam JSON endpoints. It needs no Steam account, API key, browser, or proxy. ### What does Steam Live Player Count Monitor do? Steam Live Player Count Monitor turns a game watchlist into timestamped audience observations. For every unique Steam app ID, it can: - ๐ŸŽฎ fetch the current concurrent-player count; - ๐Ÿท๏ธ enrich the record with name, type, developer, publisher, and genres; - ๐Ÿ“… include release metadata and recommendation totals; - ๐Ÿ“ˆ compare the count with the previous saved observation; - ๐Ÿ”— include official source URLs for traceability; - โš ๏ธ preserve a per-game error without losing successful watchlist rows. Run it repeatedly with the same `snapshotStoreName` to populate `previousPlayerCount`, `absoluteChange`, and `percentChange`. ### Who is it for? #### Game publishers and studios Watch your own title and comparable games before and after launches, updates, sales, esports events, or content drops. #### Investors and market researchers Build a timestamped alternative-data series for audience momentum, durability, and portfolio comparison. #### Agencies and analysts Monitor client and competitor titles without maintaining custom Steam API polling infrastructure. #### Community operators Trigger dashboards, alerts, Discord posts, or editorial workflows when a game gains or loses a meaningful share of players. #### Data engineering teams Export typed JSON, CSV, Excel, or API data into warehouses and BI systems. ### Why use this Actor? - **Official data route:** counts and metadata come from public Steam endpoints. - **No credentials:** no Steam Web API key or user login is required. - **Schedule ready:** named snapshot storage supports comparisons across runs. - **Watchlist focused:** supply exactly the apps relevant to your workflow. - **Partial-failure safe:** one unavailable app does not discard other games. - **Low overhead:** HTTP-only execution with 256 MB memory and no browser. - **Export friendly:** use Apify datasets, webhooks, integrations, API clients, or MCP. ### Data you can extract | Field | Type | Description | |---|---|---| | `appId` | number | Numeric Steam application ID | | `name` | string | Steam Store game or app name | | `appType` | string | Steam content type, such as `game` | | `isFree` | boolean | Whether Steam marks the app free to play | | `developers` | string[] | Listed developers | | `publishers` | string[] | Listed publishers | | `genres` | string[] | Steam genre labels | | `releaseDate` | string | Localized Store release date | | `comingSoon` | boolean | Store coming-soon status | | `recommendationCount` | number | Recommendation total when available | | `currentPlayerCount` | number | Live concurrent-player count | | `previousPlayerCount` | number | Count saved by the previous successful run | | `absoluteChange` | number | Current count minus previous count | | `percentChange` | number | Percentage change from the prior count | | `observedAt` | string | UTC ISO timestamp for this observation | | `storeUrl` | string | Steam Store app page | | `playerCountSourceUrl` | string | Official current-player endpoint | | `appDetailsSourceUrl` | string | Official Store metadata endpoint | | `headerImageUrl` | string | Steam header image when available | | `error` | string | Per-app source error when a request failed | Optional fields are omitted when Steam does not provide them. ### How to monitor live Steam player counts 1. Open the Actor input page. 2. Add Steam app IDs or Store URLs to `appIds`. 3. Keep **Include game metadata** enabled for rich records. 4. Choose a stable `snapshotStoreName`. 5. Click **Start**. 6. Review the default dataset. 7. Run again later with the same store name to get delta fields. 8. Add an Apify schedule for recurring monitoring. A first run has no prior observation, so delta fields are naturally absent. The second and later runs can calculate them. ### Input ```json { "appIds": [ "730", "570", "https://store.steampowered.com/app/440/Team_Fortress_2/" ], "includeAppDetails": true, "country": "us", "language": "english", "snapshotStoreName": "my-studio-steam-watchlist", "maxConcurrency": 4, "maxRequestRetries": 3 } ```` #### Input options | Option | Default | Notes | |---|---:|---| | `appIds` | required | 1โ€“100 app IDs or Store URLs | | `includeAppDetails` | `true` | Disable for count-only polling | | `country` | `us` | Two-letter Store country code | | `language` | `english` | Steam language name | | `snapshotStoreName` | `steam-live-player-count-snapshots` | Named KV store for prior counts | | `maxConcurrency` | `4` | Allowed range 1โ€“10 | | `maxRequestRetries` | `3` | Allowed range 1โ€“5 | ### Output example ```json { "appId": 730, "name": "Counter-Strike 2", "appType": "game", "isFree": true, "developers": ["Valve"], "publishers": ["Valve"], "genres": ["Action", "Free To Play"], "releaseDate": "Aug 21, 2012", "currentPlayerCount": 569110, "previousPlayerCount": 550000, "absoluteChange": 19110, "percentChange": 3.47, "observedAt": "2026-07-15T02:30:00.000Z", "storeUrl": "https://store.steampowered.com/app/730/", "playerCountSourceUrl": "https://api.steampowered.com/ISteamUserStats/GetNumberOfCurrentPlayers/v1/?appid=730" } ``` Live counts vary continuously. The values above illustrate the output shape, not a guaranteed current value. ### How snapshot deltas work The Actor opens the named Apify key-value store in `snapshotStoreName`. After a successful count request, it stores the app ID, count, and observation timestamp. On the next run using that same store name, it compares the new count with the stored value. Use different store names for independent clients, portfolios, environments, or alerting baselines. If a count request fails, the previous good value remains in the snapshot store. If the previous count is zero, `absoluteChange` is available but percentage change is omitted because division by zero is undefined. ### How much does it cost to monitor Steam player counts? The Actor uses pay-per-event pricing: - one small **monitor start** charge per run; - one **game snapshot** event for each dataset row. Tiered per-snapshot prices decrease on higher Apify plans. The exact active price is shown on the Actor pricing tab before you run it. A three-game watchlist creates three snapshot events. Duplicate IDs are removed before requests and charges. For cost-efficient scheduling, place related games in one watchlist rather than starting many one-game runs. ### Scheduling and alerts Create an Apify schedule to run the same input hourly, daily, or around a known event. Useful patterns include: - hourly launch-week audience monitoring; - before/after game update comparisons; - daily competitor portfolio snapshots; - weekend versus weekday audience analysis; - webhook alerts when `percentChange` crosses your threshold. The Actor calculates deltas; your webhook, automation, or BI tool can decide what constitutes an alert. ### Accuracy and freshness `currentPlayerCount` is the integer returned by Steam's official current-player endpoint at request time. Games in one watchlist are fetched concurrently, so their `observedAt` timestamps can differ slightly. Store metadata is localized according to `country` and `language`. Release-date text can therefore vary by locale. The Actor does not estimate historical players or reconstruct missing intervals. For a time series, schedule and retain your datasets. ### Reliability and error handling Transient 429 and 5xx responses are retried with exponential backoff. Concurrency is capped at 10 to avoid unnecessarily aggressive polling. If player count or metadata fails for one app, the Actor emits the available fields and adds an `error` string. Invalid app-ID entries are skipped with a warning. A run fails clearly when no valid app IDs remain. ### Tips for better monitoring - Reuse the same `snapshotStoreName` across comparable runs. - Keep separate store names for unrelated watchlists. - Use numeric app IDs when generating inputs programmatically. - Keep `includeAppDetails` enabled for human-readable reports. - Disable metadata enrichment for high-frequency count-only polling. - Use conservative concurrency for large watchlists. - Archive datasets externally if you need long retention or custom aggregation. ### Integrations #### Google Sheets Send each scheduled dataset to Sheets for lightweight watchlist dashboards and charts. #### Slack or Discord Use an Apify webhook plus Make, Zapier, or custom code to post large percentage changes. #### BigQuery, Snowflake, or PostgreSQL Load snapshots into a warehouse keyed by `appId` and `observedAt` for trend analysis. #### Tableau, Power BI, or Looker Connect exported datasets to audience-performance dashboards. #### Webhooks Trigger downstream processing when a run succeeds, then fetch dataset rows through the Apify API. ### API usage #### JavaScript example ```javascript import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: process.env.APIFY_TOKEN }); const run = await client.actor('automation-lab/steam-live-player-count-monitor').call({ appIds: ['730', '570', '440'], snapshotStoreName: 'weekly-steam-watchlist' }); const { items } = await client.dataset(run.defaultDatasetId).listItems(); console.log(items); ``` ### Python API example ```python from apify_client import ApifyClient client = ApifyClient("YOUR_APIFY_TOKEN") run = client.actor("automation-lab/steam-live-player-count-monitor").call(run_input={ "appIds": ["730", "570", "440"], "snapshotStoreName": "weekly-steam-watchlist" }) items = client.dataset(run["defaultDatasetId"]).list_items().items print(items) ``` ### cURL API example ```bash curl -X POST \ "https://api.apify.com/v2/acts/automation-lab~steam-live-player-count-monitor/runs?token=$APIFY_TOKEN" \ -H "Content-Type: application/json" \ -d '{"appIds":["730","570","440"],"snapshotStoreName":"weekly-steam-watchlist"}' ``` Poll the returned run ID or use the synchronous API endpoint when appropriate for your application. ### Use with Apify MCP Connect Claude and other MCP clients to Apify, then expose this Actor as a tool. MCP server URL: ```text https://mcp.apify.com?tools=automation-lab/steam-live-player-count-monitor ``` #### Claude Code ```bash claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/steam-live-player-count-monitor" ``` #### Claude Desktop and Cursor Add this `mcpServers` JSON to Claude Desktop or Cursor and authenticate when prompted: ```json { "mcpServers": { "apify": { "url": "https://mcp.apify.com?tools=automation-lab/steam-live-player-count-monitor" } } } ``` #### VS Code Add the same HTTP MCP server URL through the VS Code MCP server configuration UI, then sign in to Apify. Example prompts: - โ€œRun the Steam live player count monitor for app IDs 730, 570, and 440.โ€ - โ€œCompare todayโ€™s Counter-Strike 2 and Dota 2 player counts with the prior snapshot.โ€ - โ€œFetch current players and publisher metadata for this list of Steam URLs.โ€ ### Limits - A run accepts up to 100 unique app inputs. - Steam can throttle clients during high request volume. - Some apps are delisted, unavailable by region, or do not expose a count. - Store metadata can be missing for tools, demos, DLC, or unreleased apps. - The Actor observes current players; it does not provide Steam's private ownership or revenue data. - Snapshot state is per named KV store, not automatically shared across different store names. ### Legality The Actor accesses public official Steam endpoints without bypassing login or access controls. You are responsible for using data in accordance with Steam's terms, Apify's terms, applicable laws, and your organization's policies. Do not use the Actor to overload Steam services. Choose reasonable schedules and conservative concurrency. This documentation is general information, not legal advice. ### Troubleshooting #### Why are previous and delta fields missing? They are expected to be missing on the first successful observation. Run again with exactly the same `snapshotStoreName`. #### Why does one row contain an error? Steam may have throttled a request, the app may be unavailable, or an endpoint may not expose the requested record. Check the source URL and run logs. #### Why is metadata missing but the player count exists? The Store metadata endpoint can fail or return no data independently of the player-count endpoint. The Actor preserves the useful count. #### Why did the run skip an input? Use a positive numeric Steam app ID or a URL containing `/app//`. Other Steam URLs, text names, and search queries are not app identifiers. ### FAQ #### Does this require a Steam API key? No. The exact endpoints used by this Actor are anonymously accessible. #### Can I monitor games from Store URLs? Yes. Paste standard `store.steampowered.com/app//...` URLs into `appIds`. #### Can I monitor free-to-play and paid games? Yes, when Steam exposes a current-player response for the app. #### Does the Actor store historical time series? Each run writes a dataset and stores only the latest successful count for delta calculation. Retain datasets or export them to build a long-term series. #### Can I turn off metadata requests? Yes. Set `includeAppDetails` to `false` for count-only polling. #### Are duplicate IDs charged twice? No. Normalized app IDs are de-duplicated before output. ### Related actors - [Steam Scraper](https://apify.com/automation-lab/steam-scraper) โ€” discover Steam games by keyword and collect prices, discounts, and review summaries. - [Twitch Scraper](https://apify.com/automation-lab/twitch-scraper) โ€” complement game audience signals with Twitch channel and stream data. - [YouTube Scraper](https://apify.com/automation-lab/youtube-scraper) โ€” collect video and channel signals for game-marketing analysis. Choose Steam Live Player Count Monitor when you already know the app IDs and need repeatable live audience snapshots and deltas. ### Start monitoring Add a small game watchlist, run the Actor once, and inspect the official live counts. Then schedule the same input with the same snapshot store to turn isolated observations into useful player-audience changes. # Actor input Schema ## `appIds` (type: `array`): Steam app IDs or Store URLs to monitor. Duplicate IDs are removed. ## `includeAppDetails` (type: `boolean`): Fetch names, developers, publishers, genres, release metadata, recommendations, and images from Steam Store. ## `country` (type: `string`): Two-letter country code used for localized Steam Store metadata. ## `language` (type: `string`): Steam language name, for example english, german, french, or spanish. ## `snapshotStoreName` (type: `string`): Named key-value store used to persist previous counts across scheduled runs. Reuse the same name for comparable deltas. ## `maxConcurrency` (type: `integer`): Number of games polled concurrently. Keep this conservative to reduce Steam throttling. ## `maxRequestRetries` (type: `integer`): Maximum attempts per Steam endpoint for transient failures. ## Actor input object example ```json { "appIds": [ "730", "570", "https://store.steampowered.com/app/440/Team_Fortress_2/" ], "includeAppDetails": true, "country": "us", "language": "english", "snapshotStoreName": "steam-live-player-count-snapshots", "maxConcurrency": 4, "maxRequestRetries": 3 } ``` # Actor output Schema ## `overview` (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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "appIds": [ "730", "570", "https://store.steampowered.com/app/440/Team_Fortress_2/" ], "includeAppDetails": true, "country": "us", "language": "english", "snapshotStoreName": "steam-live-player-count-snapshots", "maxConcurrency": 4, "maxRequestRetries": 3 }; // Run the Actor and wait for it to finish const run = await client.actor("automation-lab/steam-live-player-count-monitor").call(input); // Fetch and print Actor results from the run's dataset (if any) console.log('Results from dataset'); console.log(`๐Ÿ’พ Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`); const { items } = await client.dataset(run.defaultDatasetId).listItems(); items.forEach((item) => { console.dir(item); }); // ๐Ÿ“š Want to learn more ๐Ÿ“–? Go to โ†’ https://docs.apify.com/api/client/js/docs ``` ## Python example ```python from apify_client import ApifyClient # Initialize the ApifyClient with your Apify API token # Replace '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "appIds": [ "730", "570", "https://store.steampowered.com/app/440/Team_Fortress_2/", ], "includeAppDetails": True, "country": "us", "language": "english", "snapshotStoreName": "steam-live-player-count-snapshots", "maxConcurrency": 4, "maxRequestRetries": 3, } # Run the Actor and wait for it to finish run = client.actor("automation-lab/steam-live-player-count-monitor").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print("๐Ÿ’พ Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"]) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item) # ๐Ÿ“š Want to learn more ๐Ÿ“–? Go to โ†’ https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "appIds": [ "730", "570", "https://store.steampowered.com/app/440/Team_Fortress_2/" ], "includeAppDetails": true, "country": "us", "language": "english", "snapshotStoreName": "steam-live-player-count-snapshots", "maxConcurrency": 4, "maxRequestRetries": 3 }' | apify call automation-lab/steam-live-player-count-monitor --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=automation-lab/steam-live-player-count-monitor", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Steam Live Player Count Monitor", "description": "๐ŸŽฎ Monitor live Steam concurrent players, enrich app-ID watchlists with official game metadata, and measure audience changes between scheduled snapshots.", "version": "0.1", "x-build-id": "6fuhOcOZxuSFchlPO" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/automation-lab~steam-live-player-count-monitor/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-automation-lab-steam-live-player-count-monitor", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } }, "/acts/automation-lab~steam-live-player-count-monitor/runs": { "post": { "operationId": "runs-sync-automation-lab-steam-live-player-count-monitor", "x-openai-isConsequential": false, "summary": "Executes an Actor and returns information about the initiated run in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK", "content": { "application/json": { "schema": { "$ref": "#/components/schemas/runsResponseSchema" } } } } } } }, "/acts/automation-lab~steam-live-player-count-monitor/run-sync": { "post": { "operationId": "run-sync-automation-lab-steam-live-player-count-monitor", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } } }, "components": { "schemas": { "inputSchema": { "type": "object", "required": [ "appIds" ], "properties": { "appIds": { "title": "๐ŸŽฎ Steam app IDs or URLs", "minItems": 1, "maxItems": 100, "type": "array", "description": "Steam app IDs or Store URLs to monitor. Duplicate IDs are removed.", "items": { "type": "string" } }, "includeAppDetails": { "title": "Include game metadata", "type": "boolean", "description": "Fetch names, developers, publishers, genres, release metadata, recommendations, and images from Steam Store.", "default": true }, "country": { "title": "๐ŸŒ Store country", "minLength": 2, "maxLength": 2, "type": "string", "description": "Two-letter country code used for localized Steam Store metadata.", "default": "us" }, "language": { "title": "Store language", "type": "string", "description": "Steam language name, for example english, german, french, or spanish.", "default": "english" }, "snapshotStoreName": { "title": "๐Ÿ’พ Snapshot store name", "type": "string", "description": "Named key-value store used to persist previous counts across scheduled runs. Reuse the same name for comparable deltas.", "default": "steam-live-player-count-snapshots" }, "maxConcurrency": { "title": "Maximum concurrency", "minimum": 1, "maximum": 10, "type": "integer", "description": "Number of games polled concurrently. Keep this conservative to reduce Steam throttling.", "default": 4 }, "maxRequestRetries": { "title": "Request attempts", "minimum": 1, "maximum": 5, "type": "integer", "description": "Maximum attempts per Steam endpoint for transient failures.", "default": 3 } } }, "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 } } } } } } } } } } ```