# PlayStation Store Scraper — Games & Prices (`khadinakbar/playstation-store-scraper`) Actor

Scrape PlayStation Store games, prices, discounts, platforms, availability, and product metadata. Use for catalog research and price tracking, not PlayStation Direct hardware. Returns one game per record. $0.003 per game plus a $0.00005 start fee.

- **URL**: https://apify.com/khadinakbar/playstation-store-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, Automation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 game scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## PlayStation Store Scraper — Games & Prices

Scrape public PlayStation Store catalog, category, search, concept, and product pages into clean game records. It is for game-market researchers, price trackers, catalog builders, and AI agents that need public Store pricing and metadata without a PlayStation account. It returns one validated record per game with its Store URL, current and original price, discount, availability label, platforms, artwork, and public description when available.

Use this actor for the digital **PlayStation Store**. Do not use it for consoles, controllers, accessories, or inventory from PlayStation Direct, and do not expect sign-in-only PlayStation Plus member prices, checkout data, user libraries, or private account information.

### What data does it extract?

Each dataset item has a stable, agent-friendly shape:

| Field | Description |
| --- | --- |
| `gameId`, `title`, `productUrl` | Store concept/product identifier, displayed title, and direct Store page |
| `storefront` | Store locale used to retrieve the public listing, such as `en-us` |
| `currentPrice`, `currentPriceText`, `currency` | Visible current price in both normalized and displayed forms |
| `originalPrice`, `discountPercent`, `isOnSale` | Pre-sale price and calculated promotion information when the Store provides it |
| `isFree`, `availability`, `productType` | Free/included status plus labels such as Pre-order, Game trial, or PlayStation Plus |
| `platforms`, `description`, `imageUrl` | Public platform labels, description, and artwork when available |
| `sourceUrl`, `scrapedAt` | Discovery page or direct input URL and the ISO-8601 extraction time |

The actor never adds diagnostic rows to the dataset. Instead, every run writes compact `OUTPUT` and detailed `RUN_SUMMARY` JSON records in the default key-value store, so downstream workflows can distinguish a complete run, partial data, a valid empty response, invalid input, and an upstream outage.

### When should I use it?

Use it to build a game catalog from a public browse/category page, collect a targeted list from a Store search URL, monitor displayed pricing on a list of direct concept URLs, or export Store metadata into your own analytics workflow. Pass the specific PlayStation Store URLs you care about when you need a focused result set. Leave **Start URLs** blank to begin from the selected storefront's Browse page.

For a fast listing-only export, set `enrichDetails` to `false`. For the fuller public detail-page data, leave it enabled. This two-stage approach retrieves catalog tiles first and then enriches discovered games from their concept/product pages while respecting the maximum result cap.

### Input

Only six inputs are exposed, with safe defaults:

| Input | Default | Purpose |
| --- | --- | --- |
| `startUrls` | Selected storefront Browse page | Public PlayStation Store browse, category, search, concept, or product URLs |
| `storefront` | `en-us` | Default Browse locale if no URL is supplied |
| `maxResults` | `20` | Maximum persisted and billable game records, from 1 to 100 |
| `maxListingPages` | `1` | Maximum numbered Browse pages to follow, from 1 to 10 |
| `enrichDetails` | `true` | Visit direct game pages for description and fuller public metadata |
| `useResidentialProxy` | `false` | Enable Apify Residential Proxy only if direct Store access is blocked |

#### Browse-page example

```json
{
  "storefront": "en-us",
  "maxResults": 20,
  "maxListingPages": 1,
  "enrichDetails": true
}
````

#### Direct-game URL example

```json
{
  "startUrls": [
    { "url": "https://store.playstation.com/en-us/concept/10017658" }
  ],
  "maxResults": 1,
  "enrichDetails": true,
  "useResidentialProxy": true
}
```

### Output

The following is representative output; values depend on the selected Store locale and public page state.

```json
{
  "gameId": "10017658",
  "title": "Call of Duty®: Black Ops II",
  "productUrl": "https://store.playstation.com/en-us/concept/10017658",
  "storefront": "en-us",
  "currentPrice": 19.99,
  "currentPriceText": "$19.99",
  "originalPrice": 39.99,
  "originalPriceText": "$39.99",
  "currency": "USD",
  "discountPercent": 50,
  "isFree": false,
  "isOnSale": true,
  "availability": null,
  "productType": null,
  "platforms": ["PS5", "PS4"],
  "description": "A public Store description when available.",
  "imageUrl": "https://image.api.playstation.com/example.png",
  "sourceUrl": "https://store.playstation.com/en-us/pages/browse",
  "scrapedAt": "2026-07-14T12:00:00.000Z"
}
```

Use the `games` view for spreadsheet-style output. AI agents should page the dataset through Apify's `get-actor-output` capability when the run returns more than the preview. `OUTPUT` contains the terminal outcome and charged-event count; `RUN_SUMMARY` adds processed-page counts and safe warnings.

### Pricing

This actor uses **Pay per event + usage**. A game event is charged only after a complete game record passes validation and is stored in the dataset. No record is charged before it is persisted.

| Event | Price | Trigger |
| --- | ---: | --- |
| Actor start | $0.00005 | Once per run |
| Game scraped | $0.003 | One complete, persisted game record |

Platform compute and proxy usage are additional and passed through by Apify. The actor logs the maximum event charge before collecting data: 20 games cost at most $0.060 in game events plus the start event and platform usage. `maxResults` is also a hard guard against writing or charging beyond your intended cap.

### API usage

Run the private actor from JavaScript after deploying it to your Apify account:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('khadinakbar/playstation-store-scraper').call({
  startUrls: [{ url: 'https://store.playstation.com/en-us/pages/browse' }],
  maxResults: 10,
  enrichDetails: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Reliability and limits

The Store currently returns catalog tiles as server-rendered HTML while deeper catalog content is served by PlayStation infrastructure that can change without notice. The actor uses low concurrency, retries, page-level warnings, optional detail enrichment, and optional residential routing to keep runs predictable. A temporary partial scrape succeeds with the data that was safely persisted; a target outage with no usable data is reported honestly as `UPSTREAM_FAILED`.

Only public, anonymous Store data is collected. Storefront prices, availability, promotions, and descriptions can differ by country, account, age gating, or time. The actor does not infer hidden prices and does not crawl private account data. Use small, focused URL batches when monitoring pricing, especially during large Store promotions.

### FAQ

#### How many results can I scrape with PlayStation Store Scraper?

Set `maxResults` from 1 through 100. The default is 20, and the actor never intentionally persists or charges more game records than this limit.

#### Can I integrate PlayStation Store Scraper with other apps?

Yes. Dataset records export through the Apify API in JSON, CSV, Excel, and other supported formats, and they can be consumed by your own analytics, alerting, or database workflow.

#### Can I use PlayStation Store Scraper with the Apify API?

Yes. Use an Actor API call with direct Store URLs or a storefront/default Browse input, then retrieve its default dataset and `OUTPUT` record.

#### Can I use PlayStation Store Scraper through an MCP Server?

Yes. It is designed for Apify MCP discovery and returns a flat, consistent dataset shape. Use it for public game catalog and pricing extraction, not account, trophy, social, or PlayStation Direct data.

#### Do I need proxies to scrape PlayStation Store data?

Direct access is the low-cost default for public catalog pages. If a run receives Store blocking or repeated 403/429 errors, enable Residential Proxy and retry with a small URL batch.

#### Is it legal to scrape PlayStation Store data?

You are responsible for ensuring your use complies with applicable law, PlayStation's terms, and any data-use restrictions. This actor is limited to public pages and must not be used to access accounts, circumvent authentication, or collect private data.

### Your feedback

If a Store page exposes a public field that is not returned consistently, include the exact public URL, storefront, and expected field in an issue so it can be reproduced and tested.

# Actor input Schema

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

Use this when you already have Store browse, category, search, concept, or product URLs to scrape. Pass URLs such as 'https://store.playstation.com/en-us/pages/browse' or 'https://store.playstation.com/en-us/concept/10017658'. Defaults to the selected storefront browse page when empty. This is not for PlayStation Direct hardware URLs or PlayStation.com editorial pages.

## `storefront` (type: `string`):

Use this when no Start URLs are supplied and you want the actor to open a supported PlayStation Store locale. Choose a locale such as 'en-us' for the United States; prices use that storefront's visible currency. Defaults to 'en-us'. This does not compare prices across countries in one run.

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

Use this to cap persisted and billable game records for one run. Enter an integer such as 20; valid values are 1 through 100. Defaults to 20, so game-event charges are capped at $0.060 before platform usage. This is not a request-count or page-count setting.

## `maxListingPages` (type: `integer`):

Use this when a PlayStation browse URL should follow its numbered catalog pages. Enter an integer such as 2; valid values are 1 through 10. Defaults to 1 to keep runs fast and predictable. This does not override the maximum game-record charge cap.

## `enrichDetails` (type: `boolean`):

Use this when you need each listing enriched from its PlayStation Store concept or product page. Set true to retrieve detail-page metadata such as descriptions and fuller platform information; false returns listing-level data faster. Defaults to true. This does not access sign-in-only or PlayStation Plus member-only data.

## `useResidentialProxy` (type: `boolean`):

Use this when a direct PlayStation Store run is blocked and you want to route requests through Apify Residential Proxy. Direct access is the normal low-cost default for public catalog pages, while residential routing can help with some Akamai challenges. Defaults to false so a basic run does not add proxy usage. This is not a custom proxy credential field.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://store.playstation.com/en-us/pages/browse"
    }
  ],
  "storefront": "en-us",
  "maxResults": 20,
  "maxListingPages": 1,
  "enrichDetails": true,
  "useResidentialProxy": true
}
```

# Actor output Schema

## `games` (type: `string`):

Structured PlayStation Store game, price, discount, availability, and product metadata.

## `runOutput` (type: `string`):

Stable terminal outcome, item counts, warnings, and charged-event counts.

## `runSummary` (type: `string`):

Detailed lifecycle diagnostics, page counts, warnings, and terminal outcome.

# 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 = {
    "startUrls": [
        {
            "url": "https://store.playstation.com/en-us/pages/browse"
        }
    ],
    "storefront": "en-us",
    "maxResults": 20,
    "enrichDetails": true
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "startUrls": [{ "url": "https://store.playstation.com/en-us/pages/browse" }],
    "storefront": "en-us",
    "maxResults": 20,
    "enrichDetails": True,
}

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

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://store.playstation.com/en-us/pages/browse"
    }
  ],
  "storefront": "en-us",
  "maxResults": 20,
  "enrichDetails": true
}' |
apify call khadinakbar/playstation-store-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "PlayStation Store Scraper — Games & Prices",
        "description": "Scrape PlayStation Store games, prices, discounts, platforms, availability, and product metadata. Use for catalog research and price tracking, not PlayStation Direct hardware. Returns one game per record. $0.003 per game plus a $0.00005 start fee.",
        "version": "1.0",
        "x-build-id": "TIta16M2fzJrGYLSJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~playstation-store-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-playstation-store-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/khadinakbar~playstation-store-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-playstation-store-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/khadinakbar~playstation-store-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-playstation-store-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "PlayStation Store URLs",
                        "type": "array",
                        "description": "Use this when you already have Store browse, category, search, concept, or product URLs to scrape. Pass URLs such as 'https://store.playstation.com/en-us/pages/browse' or 'https://store.playstation.com/en-us/concept/10017658'. Defaults to the selected storefront browse page when empty. This is not for PlayStation Direct hardware URLs or PlayStation.com editorial pages.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "storefront": {
                        "title": "Storefront",
                        "enum": [
                            "en-us",
                            "en-gb",
                            "en-ca",
                            "en-au",
                            "de-de",
                            "fr-fr",
                            "es-es",
                            "it-it",
                            "ja-jp"
                        ],
                        "type": "string",
                        "description": "Use this when no Start URLs are supplied and you want the actor to open a supported PlayStation Store locale. Choose a locale such as 'en-us' for the United States; prices use that storefront's visible currency. Defaults to 'en-us'. This does not compare prices across countries in one run.",
                        "default": "en-us"
                    },
                    "maxResults": {
                        "title": "Maximum game records",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Use this to cap persisted and billable game records for one run. Enter an integer such as 20; valid values are 1 through 100. Defaults to 20, so game-event charges are capped at $0.060 before platform usage. This is not a request-count or page-count setting.",
                        "default": 20
                    },
                    "maxListingPages": {
                        "title": "Maximum listing pages",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Use this when a PlayStation browse URL should follow its numbered catalog pages. Enter an integer such as 2; valid values are 1 through 10. Defaults to 1 to keep runs fast and predictable. This does not override the maximum game-record charge cap.",
                        "default": 1
                    },
                    "enrichDetails": {
                        "title": "Enrich game details",
                        "type": "boolean",
                        "description": "Use this when you need each listing enriched from its PlayStation Store concept or product page. Set true to retrieve detail-page metadata such as descriptions and fuller platform information; false returns listing-level data faster. Defaults to true. This does not access sign-in-only or PlayStation Plus member-only data.",
                        "default": true
                    },
                    "useResidentialProxy": {
                        "title": "Use residential proxy",
                        "type": "boolean",
                        "description": "Use this when a direct PlayStation Store run is blocked and you want to route requests through Apify Residential Proxy. Direct access is the normal low-cost default for public catalog pages, while residential routing can help with some Akamai challenges. Defaults to false so a basic run does not add proxy usage. This is not a custom proxy credential field.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```