# Xbox Scraper (`solidcode/xbox-scraper`) Actor

\[💰 $1.0 / 1K] Extract Xbox game catalog data — titles, prices, discounts, content ratings, genres, platforms, release dates, developers, publishers. Search by keyword, region, or Xbox URLs. Clean JSON/CSV/Excel for market research and price monitoring.

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

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Xbox Scraper

Pull the Xbox games catalog at scale — titles, structured pricing, ESRB/PEGI content ratings, genres, platforms, release dates, developers, publishers, and box-art image URLs for every game in the store. Localize to any of 24 regional storefronts to read region-accurate prices and currencies. Built for game market analysts, price-tracking teams, and games-industry researchers who need clean, structured Xbox catalog data without clicking through thousands of store tiles by hand.

### Why This Scraper?

- **24 regional storefronts with region-accurate pricing** — read prices, currency, and text from any of 24 Xbox markets (US, UK, Germany, France, Japan, Korea, Brazil, Mexico, and 16 more), each returning its native currency (USD, GBP, EUR, JPY, KRW, BRL, and more).
- **Structured pricing, not a price string** — every game carries a numeric `price`, `originalPrice` (MSRP), `discountPercent`, ISO `currency` code, and a ready-to-display `priceText` ("Free" for free-to-play), so sale math is done for you.
- **ESRB / PEGI content ratings** — the age-rating label ships on every game, whichever board applies to the region you scrape.
- **Developer AND publisher names** — both `developer` and `publisher` are captured separately, not merged into one credit line.
- **Box-art and gallery image URLs** — a primary `imageUrl` plus an `images` gallery of box art, hero art, and video poster frames, ready to embed.
- **Five sort orders** — order the games your run collects by Best Match, Title A–Z, Release Date (Newest), Price: Low to High, or Price: High to Low, so the cheapest titles or newest releases in your pull land at the top.
- **Availability across every Xbox platform** — the `platforms` list shows whether each game runs on Xbox Series X\|S, Xbox One, PC, and Cloud.
- **Whole-catalog coverage** — browse the full ~17,000-game Xbox catalog for a region in one run, or narrow to a keyword, franchise, or pasted store URL.
- **Clean, deduplicated rows** — one flat row per game, deduplicated by product ID, with camelCase fields and ISO release dates — no duplicate titles across pages.

### Use Cases

**Game Market Research**
- Map the full catalog of a regional store by genre, platform, or release date
- Track how many new titles launch on Xbox Series X\|S versus Xbox One each month
- Compare catalog size and genre mix across US, EU, and Asian storefronts
- Identify which publishers are most active in a given market

**Price Monitoring & Deal Tracking**
- Track list price, MSRP, and discount percentage on target titles over time
- Build a live feed of on-sale games sorted Price: Low to High
- Compare the same title's price across 24 regions to spot regional bargains
- Flag free-to-play and newly discounted titles as they appear

**Competitive Catalog Analysis**
- Benchmark a studio's catalog footprint against competing publishers
- Analyze genre saturation and pricing bands across the store
- Monitor a rival's new releases by sorting on Release Date (Newest)
- Compare content-rating distribution (ESRB/PEGI) across genres

**Lead Generation for Studios & Publishers**
- Build contact-ready lists of developer and publisher names by genre
- Identify indie publishers active in specific regional markets
- Surface up-and-coming studios shipping into new territories

**Content & Catalog Enrichment**
- Enrich a games database with box art, descriptions, and release dates
- Power a price-comparison or deals site with structured Xbox pricing
- Feed catalog data into dashboards, newsletters, and market reports

### Getting Started

#### Search by Keyword

The simplest way to start — search a franchise or title:

```json
{
    "searchTerms": ["Halo"],
    "maxResults": 50
}
````

#### Browse a Region with Sort and Limit

Collect from the UK store and order the results cheapest first:

```json
{
    "market": "en-GB",
    "sortBy": "priceLow",
    "maxResults": 500
}
```

#### Paste Xbox Store URLs

Point the scraper at exact browse, category, or game pages:

```json
{
    "startUrls": [
        "https://www.xbox.com/de-DE/games/browse",
        "https://www.xbox.com/en-US/games/store/forza-horizon-5/9NKX70BBCDRN"
    ],
    "maxResults": 200
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchTerms` | string\[] | `["Halo"]` | Games or franchises to search the Xbox store for, e.g. "Halo", "Forza", "Minecraft". Each term is searched separately. Keyword search returns at most ~50 results per term. Leave empty to browse the full catalog. |
| `startUrls` | string\[] | `[]` | Paste Xbox store URLs directly — a browse/category page or an individual game page. Any filters already in the URL are respected. |

#### Search Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `market` | select | `United States (English)` | Which regional Xbox store to read prices and text from. Determines currency and language. 24 regions available, from United States (English) to Japan (Japanese), Germany (German), Brazil (Portuguese), and more. |
| `sortBy` | select | `Best Match` | How to order the games your run collects: Best Match, Title (A–Z), Release Date (Newest), Price: Low to High, or Price: High to Low. The order is applied to the games gathered in the run (bounded by `maxResults`) — raise `maxResults` to rank a larger slice of the catalog. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum number of games to collect across all search terms and URLs combined. Set to 0 to collect the whole catalog for a region (up to an internal safety limit of 20,000). Start with 20–50 to test, then increase. |

### Output

Each game is one flat row. Here's a representative result:

```json
{
    "productId": "9NKX70BBCDRN",
    "title": "Forza Horizon 5",
    "url": "https://www.xbox.com/en-US/games/store/forza-horizon-5/9nkx70bbcdrn",
    "description": "Your Ultimate Horizon Adventure awaits! Explore the vibrant open world landscapes of Mexico.",
    "price": 59.99,
    "originalPrice": 59.99,
    "discountPercent": 0,
    "currency": "USD",
    "priceText": "59.99 USD",
    "contentRating": "ESRB Everyone 10+",
    "genres": ["Racing & flying", "Sports"],
    "categories": ["Racing & flying", "Sports"],
    "platforms": ["Xbox Series X|S", "Xbox One", "PC", "Cloud"],
    "availableOn": ["Xbox Series X|S", "Xbox One", "PC", "Cloud"],
    "releaseDate": "2021-11-09",
    "developer": "Playground Games",
    "publisher": "Xbox Game Studios",
    "averageRating": 4.7,
    "ratingCount": 128400,
    "imageUrl": "https://store-images.s-microsoft.com/image/apps.example.boxart.png",
    "images": [
        "https://store-images.s-microsoft.com/image/apps.example.boxart.png",
        "https://store-images.s-microsoft.com/image/apps.example.hero.png"
    ],
    "market": "en-US"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `productId` | string | Unique Xbox store product identifier |
| `title` | string | Game title |
| `url` | string | Direct Xbox store link for the game |
| `description` | string | Game description or short description |
| `releaseDate` | string | Release date, ISO `YYYY-MM-DD` |
| `market` | string | Store region the row was collected from (e.g. `en-US`) |

#### Pricing

| Field | Type | Description |
|-------|------|-------------|
| `price` | number | Current list price in the region's currency |
| `originalPrice` | number | Original price (MSRP) before any discount |
| `discountPercent` | number | Discount percentage off the original price |
| `currency` | string | ISO currency code (USD, GBP, EUR, JPY, …) |
| `priceText` | string | Ready-to-display price label ("Free" for free-to-play titles) |

#### Classification

| Field | Type | Description |
|-------|------|-------------|
| `contentRating` | string | Age-rating label (ESRB / PEGI depending on region) |
| `genres` | string\[] | Genre / category labels for the game |
| `categories` | string\[] | Same as `genres` — provided under both keys for convenience |
| `platforms` | string\[] | Platforms the game runs on (Xbox Series X|S, Xbox One, PC, Cloud) |
| `availableOn` | string\[] | Same as `platforms` — provided under both keys for convenience |
| `developer` | string | Developer studio name |
| `publisher` | string | Publisher name |
| `averageRating` | number | Average user rating (when published by the store) |
| `ratingCount` | number | Number of user ratings behind the average |

#### Media

| Field | Type | Description |
|-------|------|-------------|
| `imageUrl` | string | Primary box-art image URL |
| `images` | string\[] | Gallery of box art, hero art, and video poster frames |

### Tips for Best Results

- **Start small** — set `maxResults` to 20–50 on your first run to confirm the data matches your needs, then scale up.
- **Keyword search caps at ~50 games per term** — the store's search view isn't paginated. For a full-catalog pull, browse a region (leave `searchTerms` empty) or paste a browse URL instead.
- **Set `maxResults` to 0 for the whole catalog** — a region's full games catalog is around 17,000 titles; unlimited runs collect all of them (up to a 20,000 safety limit), which takes longer and costs more.
- **Combine region + Price: Low to High to surface deals** — this is the fastest way to find regional free-to-play titles and the deepest discounts in a market.
- **Sorting orders the games collected in your run** — raise `maxResults` to rank a larger slice of the catalog by price or release date; a small run orders only the games it gathers.
- **Switch `market` to compare prices across regions** — run the same title or franchise in `en-US`, `en-GB`, and `ja-JP` to spot regional price gaps in native currency.
- **Sort on Release Date (Newest) to track launches** — ideal for monitoring a competitor's or publisher's newest titles as they ship.
- **Mix inputs freely** — search terms, pasted URLs, and a browse region can all run together in a single job; results are deduplicated by product ID.

### Pricing

**From $1.00 per 1,000 results** — one of the most affordable ways to pull structured Xbox catalog data at scale. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.12 | $0.115 | $0.105 | $0.10 |
| 1,000 | $1.20 | $1.15 | $1.05 | $1.00 |
| 10,000 | $12.00 | $11.50 | $10.50 | $10.00 |
| 100,000 | $120.00 | $115.00 | $105.00 | $100.00 |

A "result" is any game row in the output dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate market research, price monitoring, and catalog analysis. Users are responsible for complying with applicable laws and the Xbox store's Terms of Service. Collect only publicly available catalog information, and do not use extracted data for spam, misrepresentation, or any illegal purpose. </content> </invoke>

# Actor input Schema

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

Games or franchises to search the Xbox store for, e.g. 'Halo', 'Forza', 'Minecraft'. Each term is searched separately. Note: the Xbox store returns at most ~50 results per search term (its search view is not paginated) — to collect large catalogs, browse a region or paste a browse URL instead. Leave empty to browse the full catalog.

## `startUrls` (type: `array`):

Paste Xbox store URLs directly — a browse/category page (e.g. https://www.xbox.com/en-US/games/browse) or an individual game page. Any filters already in the URL are respected. Useful when you have the exact pages you want.

## `market` (type: `string`):

Which regional Xbox store to read prices and text from. Determines currency and language. This is the easiest way to localize — no need to build regional URLs by hand.

## `sortBy` (type: `string`):

How to order the games your run collects. The chosen order is applied to the games gathered in this run (bounded by Max Games) — so to rank a larger slice of the catalog by price or release date, raise Max Games. Best Match keeps the store's own relevance order.

## `maxResults` (type: `integer`):

Maximum number of games to collect across all search terms and URLs combined. Set to 0 to collect all available games, up to an internal safety limit of 20,000 (the full Xbox browse catalog is around 17,000 games, so 0 collects everything for a region — this may take longer and cost more). Tip: start with 20–50 to test, then increase.

## Actor input object example

```json
{
  "searchTerms": [
    "Halo"
  ],
  "startUrls": [],
  "market": "en-US",
  "sortBy": "relevance",
  "maxResults": 100
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of games with key fields like title, price, content rating, genres, and release date.

## `details` (type: `string`):

Full per-game rows including description, developer, publisher, platforms, discounts, and images.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchTerms": [
        "Halo"
    ],
    "startUrls": [],
    "market": "en-US",
    "sortBy": "relevance",
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/xbox-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchTerms": ["Halo"],
    "startUrls": [],
    "market": "en-US",
    "sortBy": "relevance",
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/xbox-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchTerms": [
    "Halo"
  ],
  "startUrls": [],
  "market": "en-US",
  "sortBy": "relevance",
  "maxResults": 100
}' |
apify call solidcode/xbox-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Xbox Scraper",
        "description": "[💰 $1.0 / 1K] Extract Xbox game catalog data — titles, prices, discounts, content ratings, genres, platforms, release dates, developers, publishers. Search by keyword, region, or Xbox URLs. Clean JSON/CSV/Excel for market research and price monitoring.",
        "version": "1.0",
        "x-build-id": "jSTHobrhz3Yhukhvr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~xbox-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-xbox-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/solidcode~xbox-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-xbox-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/solidcode~xbox-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-xbox-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",
                "properties": {
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "Games or franchises to search the Xbox store for, e.g. 'Halo', 'Forza', 'Minecraft'. Each term is searched separately. Note: the Xbox store returns at most ~50 results per search term (its search view is not paginated) — to collect large catalogs, browse a region or paste a browse URL instead. Leave empty to browse the full catalog.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Xbox URLs",
                        "type": "array",
                        "description": "Paste Xbox store URLs directly — a browse/category page (e.g. https://www.xbox.com/en-US/games/browse) or an individual game page. Any filters already in the URL are respected. Useful when you have the exact pages you want.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "market": {
                        "title": "Store Region",
                        "enum": [
                            "en-US",
                            "en-GB",
                            "en-CA",
                            "en-AU",
                            "en-IE",
                            "en-NZ",
                            "de-DE",
                            "fr-FR",
                            "es-ES",
                            "it-IT",
                            "nl-NL",
                            "pt-PT",
                            "pt-BR",
                            "es-MX",
                            "ja-JP",
                            "ko-KR",
                            "zh-CN",
                            "zh-TW",
                            "pl-PL",
                            "sv-SE",
                            "da-DK",
                            "nb-NO",
                            "fi-FI",
                            "tr-TR"
                        ],
                        "type": "string",
                        "description": "Which regional Xbox store to read prices and text from. Determines currency and language. This is the easiest way to localize — no need to build regional URLs by hand.",
                        "default": "en-US"
                    },
                    "sortBy": {
                        "title": "Sort Games By",
                        "enum": [
                            "relevance",
                            "title",
                            "releaseDate",
                            "priceLow",
                            "priceHigh"
                        ],
                        "type": "string",
                        "description": "How to order the games your run collects. The chosen order is applied to the games gathered in this run (bounded by Max Games) — so to rank a larger slice of the catalog by price or release date, raise Max Games. Best Match keeps the store's own relevance order.",
                        "default": "relevance"
                    },
                    "maxResults": {
                        "title": "Max Games",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of games to collect across all search terms and URLs combined. Set to 0 to collect all available games, up to an internal safety limit of 20,000 (the full Xbox browse catalog is around 17,000 games, so 0 collects everything for a region — this may take longer and cost more). Tip: start with 20–50 to test, then increase.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
