# Steam Reviews Scraper (`fetch_cat/steam-reviews-scraper`) Actor

🎮 Extract public Steam game reviews with review text, sentiment, votes, playtime, language, purchase flags, and author metadata.

- **URL**: https://apify.com/fetch\_cat/steam-reviews-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Games, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.12 / 1,000 review saveds

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

## Steam Reviews Scraper

Extract public Steam game reviews into clean, analysis-ready datasets.

Steam Reviews Scraper helps studios, publishers, market researchers, agencies, and data teams monitor what players say about any public Steam game. Add Steam app IDs or store URLs, choose review filters, and export review text together with recommendation status, votes, playtime, purchase flags, language, timestamps, and author profile signals.

### What does Steam Reviews Scraper do?

This actor collects public review records for Steam apps and saves one dataset item per review.

Use it to:

- 🎮 Track new reviews for your own game
- 🧭 Compare player sentiment across competitors
- 📈 Build dashboards for review volume and helpful votes
- 🌍 Analyze language mix across Steam communities
- ⏱️ Segment reviews by playtime at review time
- 💬 Export review text for NLP and sentiment workflows

### Who is it for?

#### Game studios

Monitor launch feedback, patch reactions, and long-term player satisfaction.

#### Publishers

Compare portfolio titles, competitor games, and campaign impact across markets.

#### Market researchers

Create repeatable datasets for genre, pricing, reputation, and player behavior analysis.

#### Reputation-monitoring teams

Detect spikes in negative reviews, refund-related feedback, and language-specific issues.

#### Data analysts

Load normalized review rows into BI tools, notebooks, warehouses, or dashboards.

### Why use this actor?

- ✅ Works with Steam app IDs and Steam app URLs
- ✅ Supports review filters and sentiment filters
- ✅ Captures review text and metadata in one row
- ✅ Includes playtime, author, purchase, vote, and timestamp fields
- ✅ Uses a low-cost HTTP workflow suitable for regular monitoring
- ✅ Exports to JSON, CSV, Excel, XML, RSS, and API endpoints through Apify

### Typical use cases

- Daily review monitoring for a game launch
- Competitor reputation tracking by app ID
- Player feedback export before roadmap planning
- Negative-review analysis after a patch
- Language-specific sentiment reporting
- Dataset creation for ML/NLP labeling
- Helpful-vote and funny-vote analysis
- Early-access feedback monitoring

### Input overview

The actor accepts one or more Steam app IDs or Steam app URLs.

Example app ID:

```text
730
````

Example Steam URL:

```text
https://store.steampowered.com/app/730/CounterStrike_2/
```

### Input fields

| Field | Type | Description |
| --- | --- | --- |
| `appIdsOrUrls` | array | Steam app IDs or Steam store app URLs |
| `maxReviewsPerApp` | integer | Maximum reviews to save for each app |
| `filter` | string | Review ordering: recent, updated, or all |
| `language` | string | Steam language code, such as english or all |
| `reviewType` | string | all, positive, or negative |
| `purchaseType` | string | all, steam, or non\_steam\_purchase |
| `cursor` | string | Optional pagination cursor for continuation |
| `includeAuthor` | boolean | Include public author ID, profile URL, review counts, and playtime metadata |
| `proxyConfiguration` | object | Optional proxy settings |

### Example input

```json
{
  "appIdsOrUrls": ["730", "https://store.steampowered.com/app/570/Dota_2/"],
  "maxReviewsPerApp": 50,
  "filter": "recent",
  "language": "english",
  "reviewType": "all",
  "purchaseType": "all",
  "cursor": "*",
  "includeAuthor": true,
  "proxyConfiguration": { "useApifyProxy": false }
}
```

### Output overview

Each dataset item represents one Steam review.

### Output data table

| Field | Description |
| --- | --- |
| `appId` | Steam app ID |
| `appUrl` | Steam app URL |
| `recommendationId` | Unique Steam review/recommendation ID |
| `review` | Review text |
| `language` | Review language |
| `votedUp` | Whether the player recommends the game |
| `votesUp` | Helpful vote count |
| `votesFunny` | Funny vote count |
| `weightedVoteScore` | Steam weighted vote score |
| `commentCount` | Number of review comments |
| `steamPurchase` | Whether the game was purchased on Steam |
| `receivedForFree` | Whether the reviewer marked it as received for free |
| `refunded` | Whether the review is associated with a refund flag |
| `writtenDuringEarlyAccess` | Early-access review flag |
| `primarilySteamDeck` | Steam Deck related flag when available |
| `timestampCreated` | Review creation date/time |
| `timestampUpdated` | Review update date/time |
| `authorSteamId` | Review author Steam ID |
| `authorPersonaName` | Public Steam persona name when returned |
| `authorProfileUrl` | Author profile URL |
| `playtimeForeverMinutes` | Total recorded playtime in minutes |
| `playtimeAtReviewMinutes` | Playtime at the time of review |
| `lastPlayed` | Last played timestamp |
| `querySummaryTotalReviews` | Total reviews reported by Steam for the query |
| `nextCursor` | Cursor that can be used for continuation |
| `scrapedAt` | When the item was collected |

### Example output item

```json
{
  "appId": "730",
  "appUrl": "https://store.steampowered.com/app/730/",
  "recommendationId": "123456789",
  "review": "Great competitive game with a strong community.",
  "language": "english",
  "votedUp": true,
  "votesUp": 12,
  "votesFunny": 0,
  "weightedVoteScore": 0.72,
  "steamPurchase": true,
  "playtimeAtReviewMinutes": 2400,
  "authorProfileUrl": "https://steamcommunity.com/profiles/7656119...",
  "timestampCreated": "2026-06-27T10:30:00.000Z"
}
```

### How much does it cost to scrape Steam reviews?

The actor uses pay-per-event pricing.

- Start event: `$0.005` once per run.
- Review saved event (BRONZE): `$0.0002` per saved review (about `$0.20` per 1,000 reviews).
- Lower per-review prices are available on higher Apify tiers.

For most monitoring jobs, the cost scales with the number of reviews you request.

### How to run

1. Open the actor on Apify.
2. Add one or more Steam app IDs or app URLs.
3. Set `maxReviewsPerApp` to the number of reviews you need.
4. Choose language and sentiment filters.
5. Click **Start**.
6. Export results from the Dataset tab.

### Tips for best results

- Start with `maxReviewsPerApp: 25` for a quick sample.
- Use `filter: recent` for monitoring new reviews.
- Use `reviewType: negative` to triage player complaints.
- Use `language: all` for global studies.
- Keep the returned `nextCursor` if you want to continue from a later page.
- Run separate jobs for different games when you need independent schedules.

### Steam language examples

Common language values include:

- `english`
- `german`
- `french`
- `spanish`
- `schinese`
- `japanese`
- `koreana`
- `russian`
- `all`

### Integrations

Use the dataset with:

- 📊 Google Sheets or Excel exports for quick analysis
- 🧠 NLP pipelines for topic extraction and sentiment labels
- 🗄️ BigQuery, Snowflake, or Postgres via Apify integrations
- 🔔 Slack or email alerts triggered by scheduled runs
- 📈 BI dashboards tracking review volume and recommendation ratio
- 🧪 QA workflows that compare reactions before and after game updates

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/steam-reviews-scraper').call({
  appIdsOrUrls: ['730'],
  maxReviewsPerApp: 25,
  filter: 'recent',
  language: 'english'
});

console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/steam-reviews-scraper').call(run_input={
    'appIdsOrUrls': ['730'],
    'maxReviewsPerApp': 25,
    'filter': 'recent',
    'language': 'english',
})

print(run['defaultDatasetId'])
```

#### cURL

```bash
curl "https://api.apify.com/v2/acts/fetch_cat~steam-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"appIdsOrUrls":["730"],"maxReviewsPerApp":25}'
```

### MCP: use Steam reviews in AI tools

You can connect Apify actors to Claude Desktop, Claude Code, and other MCP clients.

Example MCP server URL:

```text
https://mcp.apify.com/?tools=fetch_cat/steam-reviews-scraper
```

Claude Code setup:

```bash
claude mcp add apify-steam-reviews "https://mcp.apify.com/?tools=fetch_cat/steam-reviews-scraper"
```

Claude Desktop JSON setup:

```json
{
  "mcpServers": {
    "apify-steam-reviews": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/steam-reviews-scraper"
    }
  }
}
```

Example prompts:

- "Scrape the latest 50 negative Steam reviews for app 730 and summarize the top complaints."
- "Compare positive and negative review themes for this Steam game."
- "Extract recent English reviews and identify recurring performance issues."

### Scheduling

Set up an Apify schedule to monitor reviews daily or weekly.

Good scheduled inputs:

- 25 recent reviews every day for launch monitoring
- 100 negative reviews after each patch
- Weekly competitor review samples across 5 app IDs

### Data quality notes

Steam review text is user-generated, so it may contain profanity, emojis, links, formatting, or multiple languages. The actor preserves the review text as provided and adds normalized metadata fields for easier filtering.

### Limits

- Only public Steam app reviews are supported.
- Private account-only data is not collected.
- Very large backfills should be split into multiple runs.
- Availability depends on Steam keeping the public review pages accessible.

### FAQ

#### Can I scrape reviews for multiple Steam games?

Yes. Add multiple app IDs or Steam app URLs and set the per-app review limit.

#### Does this collect private Steam account data?

No. It only returns public review fields that are visible for Steam app reviews.

### Troubleshooting

#### I got fewer reviews than requested. Why?

The selected app/filter/language combination may have fewer available reviews than your limit. Try `language: all` or broaden the sentiment and purchase filters.

#### My Steam URL was skipped. Why?

Use a URL containing `/app/<id>/`, or provide the numeric app ID directly.

#### Can I continue from a previous run?

Yes. Copy a `nextCursor` value from the dataset and use it as the `cursor` input in the next run.

### Legality

This actor extracts publicly available Steam review information. Use the data responsibly, respect Steam's terms, avoid abusive request volumes, and do not use the results to identify or harass individual users.

### Related scrapers

- [Google Autocomplete Scraper](https://apify.com/fetch_cat/google-autocomplete-scraper) — collect search suggestions for game and brand keyword research.
- [Google Scholar Profiles Scraper](https://apify.com/fetch_cat/google-scholar-profiles-scraper) — export public researcher profiles and publication metrics.
- [YouTube Transcript Scraper](https://apify.com/fetch_cat/youtube-transcript-scraper) — collect video transcripts for creator or campaign analysis.
- [Bluesky Profile Feed Scraper](https://apify.com/fetch_cat/bluesky-profile-feed-scraper) — monitor public social posts from Bluesky profiles.
- [Google Flights Scraper](https://apify.com/fetch_cat/google-flights-scraper) — collect flight search results for travel market analysis.

### Changelog

#### 0.1

Initial version with app ID / URL input, review filters, language support, cursor pagination, and normalized review output.

### Support

If you need help, open an issue on the actor page with your input, expected result, and run ID.

# Actor input Schema

## `appIdsOrUrls` (type: `array`):

Steam app IDs or full Steam app URLs. Examples: 730, 570, or https://store.steampowered.com/app/730/CounterStrike\_2/

## `maxReviewsPerApp` (type: `integer`):

How many reviews to save for each Steam app.

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

Steam review feed filter. Recent is best for monitoring new reviews; all is useful for broad sampling.

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

Steam language code, such as english, german, spanish, schinese, or all.

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

Limit reviews by positive/negative recommendation or keep all reviews.

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

Limit reviews by Steam purchase status.

## `cursor` (type: `string`):

Optional Steam pagination cursor from a previous run. Leave empty to start from the beginning.

## `includeAuthor` (type: `boolean`):

Include public author Steam ID, profile URL, review counts, and playtime fields when Steam returns them.

## `proxyConfiguration` (type: `object`):

Optional Apify proxy settings. Steam review API usually works without a proxy.

## Actor input object example

```json
{
  "appIdsOrUrls": [
    "730"
  ],
  "maxReviewsPerApp": 20,
  "filter": "recent",
  "language": "english",
  "reviewType": "all",
  "purchaseType": "all",
  "cursor": "*",
  "includeAuthor": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "appIdsOrUrls": [
        "730"
    ],
    "maxReviewsPerApp": 20,
    "filter": "recent",
    "language": "english",
    "reviewType": "all",
    "purchaseType": "all",
    "cursor": "*",
    "includeAuthor": true,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/steam-reviews-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 = {
    "appIdsOrUrls": ["730"],
    "maxReviewsPerApp": 20,
    "filter": "recent",
    "language": "english",
    "reviewType": "all",
    "purchaseType": "all",
    "cursor": "*",
    "includeAuthor": True,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/steam-reviews-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 '{
  "appIdsOrUrls": [
    "730"
  ],
  "maxReviewsPerApp": 20,
  "filter": "recent",
  "language": "english",
  "reviewType": "all",
  "purchaseType": "all",
  "cursor": "*",
  "includeAuthor": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call fetch_cat/steam-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Steam Reviews Scraper",
        "description": "🎮 Extract public Steam game reviews with review text, sentiment, votes, playtime, language, purchase flags, and author metadata.",
        "version": "0.1",
        "x-build-id": "tvIHCwfec8fyIOJp0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~steam-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-steam-reviews-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/fetch_cat~steam-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-steam-reviews-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/fetch_cat~steam-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-steam-reviews-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": [
                    "appIdsOrUrls"
                ],
                "properties": {
                    "appIdsOrUrls": {
                        "title": "🎮 Steam app IDs or URLs",
                        "type": "array",
                        "description": "Steam app IDs or full Steam app URLs. Examples: 730, 570, or https://store.steampowered.com/app/730/CounterStrike_2/",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerApp": {
                        "title": "Maximum reviews per app",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "How many reviews to save for each Steam app.",
                        "default": 20
                    },
                    "filter": {
                        "title": "Review order/filter",
                        "enum": [
                            "recent",
                            "updated",
                            "all"
                        ],
                        "type": "string",
                        "description": "Steam review feed filter. Recent is best for monitoring new reviews; all is useful for broad sampling.",
                        "default": "recent"
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Steam language code, such as english, german, spanish, schinese, or all.",
                        "default": "english"
                    },
                    "reviewType": {
                        "title": "Review sentiment",
                        "enum": [
                            "all",
                            "positive",
                            "negative"
                        ],
                        "type": "string",
                        "description": "Limit reviews by positive/negative recommendation or keep all reviews.",
                        "default": "all"
                    },
                    "purchaseType": {
                        "title": "Purchase type",
                        "enum": [
                            "all",
                            "steam",
                            "non_steam_purchase"
                        ],
                        "type": "string",
                        "description": "Limit reviews by Steam purchase status.",
                        "default": "all"
                    },
                    "cursor": {
                        "title": "Pagination cursor",
                        "type": "string",
                        "description": "Optional Steam pagination cursor from a previous run. Leave empty to start from the beginning.",
                        "default": "*"
                    },
                    "includeAuthor": {
                        "title": "Include author metadata",
                        "type": "boolean",
                        "description": "Include public author Steam ID, profile URL, review counts, and playtime fields when Steam returns them.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy settings. Steam review API usually works without a proxy.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```