# PlayStation Store Scraper (`unfenced-group/playstation-store-scraper`) Actor

Scrape PlayStation Store games with localized pricing in any currency across 50+ storefronts. Get prices, discounts, ratings, content ratings, platforms, genres, screenshots, trailers, and editions. Search by keyword or scrape direct URLs.

- **URL**: https://apify.com/unfenced-group/playstation-store-scraper.md
- **Developed by:** [Unfenced Group](https://apify.com/unfenced-group) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.79 / 1,000 games

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

## PlayStation Store Scraper

![Banner](https://api.apify.com/v2/key-value-stores/lJlifu6C8YQfZMPKE/records/playstation-store-scraper)

Scrape games from the PlayStation Store with full localized pricing in any currency, across every PlayStation storefront worldwide. Search by keyword, target specific countries, or pass game URLs directly. No API key required.

---

### Why this scraper?

#### 🌍 Every country, every currency
Pull the same game across any of 79 PlayStation storefronts. Each result returns the price in that country's local currency — EUR, GBP, USD, JPY, BRL, TRY, and more — exactly as shown on the store.

#### 💸 Complete pricing data
Base price, discounted price, numeric values, currency code, sale status, discount text, and discount end time. Spot regional price differences and active sales at a glance.

#### 📦 Deep game detail
Publisher, platforms, genres, release date, star rating and rating count, content rating (ESRB / PEGI / USK / CERO), editions, screenshots, trailers, cover art, and full descriptions.

#### 🔑 Flexible discovery
Search by keyword, scrape the latest catalog per country, or feed exact game URLs. Mix and match to build whatever dataset you need.

#### 🎛️ Powerful filters
Narrow results by platform (PS4/PS5), price (free, paid, on sale), minimum star rating, age rating, genre, and release window — applied across every storefront in the run.

---

### Input parameters

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `searchQuery` | string | `""` | Keyword to search for (game title, franchise, or genre). Leave empty to pull the latest catalog per country. |
| `country` | dropdown | `en-us` | The storefront to scrape, picked from a list of 56 countries with flags. Prices come back in that country's local currency. |
| `countries` | multi-select | `[]` | Scrape several storefronts in one run — every game is returned once per country with its local price. Overrides the single country. |
| `allCountries` | boolean | `false` | Scrape every available storefront (56 countries) in one run. Overrides the country fields above. |
| `maxResults` | integer | `5` | Maximum games to return per country. |
| `startUrls` | array | `[]` | Specific PlayStation Store game URLs to scrape directly. Overrides search when provided. |
| `includeMedia` | boolean | `true` | Include cover art, screenshots, and trailers. Turn off for a smaller, price-focused dataset. |
| `includeDescription` | boolean | `true` | Include the full game description. |
| `platforms` | multi-select | `[]` | Only return games on PS5 and/or PS4. |
| `ps5ProEnhanced` | boolean | `false` | Only return PS5 Pro Enhanced games. |
| `experimentalOffersOnly` | boolean | `false` | Only return games whose public offer data is tagged with a Sony A/B-test campaign id. See note below. |
| `psPlusDeals` | boolean | `false` | Only return games with a PlayStation Plus member price or inclusion. |
| `vrSupport` | dropdown | `any` | Filter by VR: any, any VR, PSVR2 only, PSVR only, or non-VR only. |
| `priceFilter` | dropdown | `all` | Return all games, or only free / paid / on-sale titles. |
| `minPrice` | integer | — | Only return games priced at or above this amount (local currency, major units). |
| `maxPrice` | integer | — | Only return games priced at or below this amount (local currency, major units). |
| `minRating` | integer | — | Only return games with an average star rating at or above this value (0–5). |
| `ageRatings` | multi-select | `[]` | Only return games at or below the selected maturity level (works across ESRB / PEGI / USK / CERO). |
| `genres` | multi-select | `[]` | Only return games in the selected genre(s) — picked from a dropdown of PlayStation's genre list. |
| `releasedAfter` | date | — | Only return games released on or after this date. |
| `releasedBefore` | date | — | Only return games released on or before this date. |
| `useProxy` | boolean | `false` | Route requests through a proxy. Rarely needed. |

---

### Output schema

Every result contains the following fields.

| Field | Type | Description |
|-------|------|-------------|
| `conceptId` | string\|null | PlayStation concept ID (the game). |
| `productId` | string\|null | PlayStation product/SKU ID (the edition). |
| `titleId` | string\|null | Canonical title ID (e.g. `PPSA11386_00`), a stable join key. |
| `name` | string | Game title. |
| `url` | string | Source store URL. |
| `locale` | string | Storefront locale (e.g. `en-us`). |
| `country` | string | Country code derived from the locale. |
| `publisherName` | string\|null | Publisher. |
| `platforms` | array | Supported platforms (e.g. `["PS4","PS5"]`). |
| `genres` | array | Localized genres. |
| `classification` | string\|null | Store classification (e.g. `FULL_GAME`). |
| `releaseDate` | string\|null | ISO release date. |
| `isPreorder` | boolean\|null | Whether the title is a pre-order/announcement. |
| `basePrice` | string\|null | Display base price in local currency. |
| `discountedPrice` | string\|null | Display current price in local currency. |
| `basePriceValue` | integer\|null | Base price in minor units (e.g. cents). |
| `discountedValue` | integer\|null | Current price in minor units. |
| `currencyCode` | string\|null | ISO currency code. |
| `isFree` | boolean\|null | Whether the title is free. |
| `isOnSale` | boolean\|null | Whether the current price is below base price. |
| `discountText` | string\|null | Display discount label (e.g. `-50%`). |
| `discountEndTime` | string\|null | When the discount ends. |
| `campaignId` | string\|null | Offer campaign identifier, when present in the public response. |
| `rewardId` | string\|null | Offer reward identifier, when present. |
| `serviceBranding` | array | Offer service tags (e.g. `PS_PLUS`), excluding `NONE`. |
| `isExperimentalOffer` | boolean | Whether the public offer data carries a Sony A/B-test campaign id (`IPT_*`). See note below. |
| `experimentProgram` | string\|null | The detected experiment program (e.g. `IPT_PILOT`, `IPT_LTM`), if any. |
| `psPlusPrice` | string\|null | PlayStation Plus member price, if any. |
| `psPlusValue` | integer\|null | PS Plus price in minor units. |
| `psPlusTier` | string\|null | PS Plus tier for the offer (Essential / Extra / Premium). |
| `isPsPlusDeal` | boolean | Whether a PS Plus member price or inclusion applies. |
| `starRatingAverage` | number\|null | Average star rating. |
| `starRatingCount` | integer\|null | Number of ratings. |
| `contentRatingAuthority` | string\|null | Rating authority (ESRB, PEGI, USK, CERO). |
| `contentRatingName` | string\|null | Rating code (e.g. `ESRB_TEEN`). |
| `contentRatingDescription` | string\|null | Human-readable rating. |
| `ps5ProEnhanced` | boolean\|null | Whether the game is PS5 Pro Enhanced (improved graphics/performance on PS5 Pro). |
| `psvr` | boolean | Whether the game supports the original PSVR. |
| `psvr2` | boolean | Whether the game supports PSVR2. |
| `vrSupport` | string | VR support summary: `none`, `psvr`, `psvr2`, or `both`. |
| `maxPlayers` | integer\|null | Maximum number of players. |
| `onlinePlayRequired` | boolean\|null | Whether online play is required. |
| `inGamePurchases` | boolean\|null | Whether the game offers in-game purchases. |
| `descriptionHtml` | string\|null | Description, raw. |
| `descriptionText` | string\|null | Description, plain text. |
| `descriptionMarkdown` | string\|null | Description as clean Markdown — ready to feed to an LLM. |
| `coverImage` | string\|null | Cover art URL. |
| `backgroundImage` | string\|null | Background art URL. |
| `logoImage` | string\|null | Logo URL. |
| `screenshots` | array | Screenshot URLs. |
| `videos` | array | Trailer/preview video URLs. |
| `spokenLanguages` | array | Spoken audio languages. |
| `screenLanguages` | array | On-screen languages. |
| `editionsCount` | integer\|null | Number of editions. |
| `editions` | array | Editions, each `{ productId, name }`. |
| `scrapedAt` | string | ISO timestamp of extraction. |

#### Example record

```json
{
  "conceptId": "10006560",
  "productId": "EP3969-PPSA11386_00-007FIRSTLIGHT000",
  "name": "007 First Light",
  "url": "https://store.playstation.com/de-de/concept/10006560",
  "locale": "de-de",
  "country": "DE",
  "publisherName": "IO Interactive A/S",
  "platforms": ["PS5"],
  "genres": ["Adventure", "Action"],
  "classification": "FULL_GAME",
  "releaseDate": "2026-05-26T14:00:00Z",
  "isPreorder": false,
  "basePrice": "€69,99",
  "discountedPrice": "€69,99",
  "basePriceValue": 6999,
  "discountedValue": 6999,
  "currencyCode": "EUR",
  "isFree": false,
  "isOnSale": false,
  "discountText": null,
  "discountEndTime": null,
  "starRatingAverage": 4.67,
  "starRatingCount": 23093,
  "contentRatingAuthority": "USK",
  "contentRatingName": "USK_16",
  "contentRatingDescription": "USK 16",
  "coverImage": "https://image.api.playstation.com/...",
  "screenshots": ["https://image.api.playstation.com/...", "..."],
  "videos": ["https://vulcan.dl.playstation.net/...", "..."],
  "editionsCount": 2,
  "editions": [{ "productId": "EP3969-PPSA11386_00-007FIRSTLIGHT000", "name": "Standard" }],
  "scrapedAt": "2026-06-23T13:00:00.000Z"
}
````

***

### Examples

**1. Search one country**

```json
{ "searchQuery": "god of war", "countries": ["en-us"], "maxResults": 10 }
```

**2. Compare one franchise across currencies**

```json
{ "searchQuery": "the witcher 3", "countries": ["en-us", "en-gb", "de-de", "ja-jp", "pt-br"], "maxResults": 3 }
```

**3. Scrape specific games directly**

```json
{ "startUrls": [
  { "url": "https://store.playstation.com/en-us/concept/10006560" },
  { "url": "https://store.playstation.com/nl-nl/concept/221852" }
] }
```

**4. Latest catalog, every storefront**

```json
{ "allCountries": true, "maxResults": 5 }
```

**5. Filter: PS5 games on sale, rated 4+**

```json
{ "searchQuery": "racing", "country": "en-gb", "maxResults": 20, "platforms": ["PS5"], "priceFilter": "onSale", "minRating": 4 }
```

**6. Filter: free family games, descriptions off**

```json
{ "searchQuery": "kids", "country": "en-us", "priceFilter": "free", "ageRatings": ["everyone"], "includeDescription": false }
```

***

### 💰 Pricing

**$0.99 per 1,000 results** — you only pay for games successfully returned. Failed retries are never charged.

| Results | Cost |
|---------|------|
| 100 | ~$0.10 |
| 1,000 | ~$0.99 |
| 10,000 | ~$9.90 |
| 100,000 | ~$99.00 |

> Flat-rate alternatives typically charge $9.99–$49/month regardless of usage.

Use **Max results per country** to control your spend exactly.

***

### Performance

| Run size | Approx. time |
|----------|--------------|
| 10 games | under 30 seconds |
| 100 games | 1–2 minutes |
| 1,000 games | 10–15 minutes |

***

### Known limitations

- Prices reflect what each storefront displays at scrape time, including any active regional sale.
- A small number of titles (free-to-play, unreleased pre-orders) return no numeric price; the `isFree` and `isPreorder` flags indicate why.
- Search discovery returns the storefront's ranked results for a keyword; for an exhaustive catalog use the latest-catalog mode or supply start URLs.
- **A/B experimental pricing:** Sony's pricing experiments (`IPT_PILOT`, `IPT_OPR_TESTING`, `IPT_LTM`) are shown only to specific logged-in PlayStation accounts placed in test groups. This scraper runs anonymously and never logs in, so it sees the standard control-group price. The `isExperimentalOffer`, `experimentProgram`, and `campaignId` fields surface campaign tags only when they appear in the public, unauthenticated response — they will usually be empty. Detecting the per-account experimental prices themselves would require authenticated PlayStation sessions, which this actor deliberately does not use.

***

### Technical details

- **Source:** store.playstation.com — official PlayStation Store storefronts.
- **Coverage:** 79 country storefronts, each with local currency.
- **Memory:** 256 MB.
- **Retry:** Automatic retry on network errors, exponential backoff, 3 attempts per request.

### Related scrapers

Other scrapers in our **Game & App Stores** collection:

- [Nintendo eShop Scraper](https://apify.com/unfenced-group/nintendo-eshop-scraper)
- [Steam Store Scraper](https://apify.com/unfenced-group/steam-store-scraper)
- [Xbox Store Scraper](https://apify.com/unfenced-group/xbox-store-scraper)
- [iOS App Store Scraper](https://apify.com/unfenced-group/ios-app-store-scraper)

***

### Need a custom scraper?

**[Unfenced Group](https://www.unfencedgroup.nl)** builds Apify actors for any website — for free.

If the site you need isn't in our portfolio yet, just ask. We scope, build, and publish it at no cost to you. You only pay for results — we absorb the compute and proxy costs ourselves. Same pay-per-result pricing, same quality, same standards as every actor in this portfolio.

**Get in touch:** [www.unfencedgroup.nl](https://www.unfencedgroup.nl)

# Actor input Schema

## `searchQuery` (type: `string`):

Keyword to search the PlayStation Store for (game title, franchise, or genre). Leave empty to pull the latest catalog for the selected countries.

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

The PlayStation storefront to scrape. Prices are returned in this country's local currency. To scrape several countries in one run, use the "Multiple countries" field below instead.

## `countries` (type: `array`):

Scrape several storefronts in a single run — every game is returned once per selected country with its local price. Overrides the single country above when set. Use \["all"] for every storefront.

## `allCountries` (type: `boolean`):

Scrape every available storefront (56 countries) in one run. Overrides the country fields above. Warning: this multiplies your run by 56 — keep "Max results per country" low.

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

Maximum number of games to return per selected country.

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

Optional list of specific PlayStation Store game URLs to scrape directly (concept or product pages). Overrides search when provided.

## `includeMedia` (type: `boolean`):

Include cover art, screenshots, and trailer URLs in results. Turn off for a smaller, price-focused dataset.

## `includeDescription` (type: `boolean`):

Include the full game description. Turn off for a lighter dataset.

## `platforms` (type: `array`):

Only return games available on the selected platform(s). Leave empty to include all. OR filter — selecting both widens results.

## `ps5ProEnhanced` (type: `boolean`):

Only return games that are PS5 Pro Enhanced (improved graphics/performance on PS5 Pro). Leave off to include all titles.

## `experimentalOffersOnly` (type: `boolean`):

Only return games whose public offer data carries one of Sony's pricing-experiment campaign identifiers (IPT\_PILOT, IPT\_OPR\_TESTING, IPT\_LTM). Note: most experimental prices are shown only to logged-in test-group accounts and will not appear in an anonymous scrape; this surfaces only campaign-tagged offers present in the public response.

## `psPlusDeals` (type: `boolean`):

Only return games that have a PlayStation Plus member price or are included with a PS Plus tier.

## `vrSupport` (type: `string`):

Filter by virtual-reality support. PSVR2 (Caesar/Sense) vs original PSVR are detected from the store's hardware compatibility data.

## `priceFilter` (type: `string`):

Only return games matching this price condition.

## `minPrice` (type: `integer`):

Only return games priced at or above this amount, in the storefront's local currency (major units, e.g. 10 = $10 / €10 / ¥10). Leave empty for no lower bound.

## `maxPrice` (type: `integer`):

Only return games priced at or below this amount, in the storefront's local currency (major units). Leave empty for no upper bound.

## `minRating` (type: `number`):

Only return games with an average star rating at or above this value (0–5, decimals allowed, e.g. 4.5). Leave empty to include all (titles without a rating are kept).

## `ageRatings` (type: `array`):

Only return games at or below the selected maturity level(s), based on the storefront's rating board (ESRB / PEGI / USK / CERO). Leave empty to include all. OR filter.

## `genres` (type: `array`):

Only return games in the selected genre(s). Leave empty to include all. OR filter — selecting multiple widens results.

## `releasedAfter` (type: `string`):

Only return games released on or after this date (YYYY-MM-DD). Leave empty to include all.

## `releasedBefore` (type: `string`):

Only return games released on or before this date (YYYY-MM-DD). Leave empty to include all.

## `useProxy` (type: `boolean`):

Route requests through a proxy. Off by default — the PlayStation Store is reachable directly, so this is rarely needed.

## Actor input object example

```json
{
  "searchQuery": "",
  "country": "en-us",
  "countries": [],
  "allCountries": false,
  "maxResults": 5,
  "startUrls": [],
  "includeMedia": true,
  "includeDescription": true,
  "platforms": [],
  "ps5ProEnhanced": false,
  "experimentalOffersOnly": false,
  "psPlusDeals": false,
  "vrSupport": "any",
  "priceFilter": "all",
  "ageRatings": [],
  "genres": [],
  "useProxy": false
}
```

# Actor output Schema

## `results` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("unfenced-group/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 = {}

# Run the Actor and wait for it to finish
run = client.actor("unfenced-group/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 '{}' |
apify call unfenced-group/playstation-store-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "PlayStation Store Scraper",
        "description": "Scrape PlayStation Store games with localized pricing in any currency across 50+ storefronts. Get prices, discounts, ratings, content ratings, platforms, genres, screenshots, trailers, and editions. Search by keyword or scrape direct URLs.",
        "version": "0.0",
        "x-build-id": "4Mjafvit5FRal3bQL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/unfenced-group~playstation-store-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-unfenced-group-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/unfenced-group~playstation-store-scraper/runs": {
            "post": {
                "operationId": "runs-sync-unfenced-group-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/unfenced-group~playstation-store-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-unfenced-group-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": {
                    "searchQuery": {
                        "title": "🔍 Search query",
                        "type": "string",
                        "description": "Keyword to search the PlayStation Store for (game title, franchise, or genre). Leave empty to pull the latest catalog for the selected countries.",
                        "default": ""
                    },
                    "country": {
                        "title": "🌍 Country / storefront",
                        "enum": [
                            "en-us",
                            "en-ca",
                            "fr-ca",
                            "es-mx",
                            "pt-br",
                            "es-ar",
                            "es-cl",
                            "es-co",
                            "es-pe",
                            "en-gb",
                            "en-ie",
                            "nl-nl",
                            "fr-fr",
                            "de-de",
                            "es-es",
                            "it-it",
                            "pt-pt",
                            "nl-be",
                            "fr-be",
                            "de-at",
                            "de-ch",
                            "fr-ch",
                            "it-ch",
                            "da-dk",
                            "fi-fi",
                            "no-no",
                            "sv-se",
                            "pl-pl",
                            "tr-tr",
                            "en-cz",
                            "en-gr",
                            "uk-ua",
                            "ar-ae",
                            "en-ae",
                            "ar-sa",
                            "en-sa",
                            "ar-kw",
                            "en-kw",
                            "ar-qa",
                            "en-qa",
                            "ar-lb",
                            "en-lb",
                            "en-il",
                            "en-za",
                            "ja-jp",
                            "ko-kr",
                            "zh-hant-hk",
                            "en-hk",
                            "zh-hant-tw",
                            "en-sg",
                            "en-my",
                            "th-th",
                            "en-th",
                            "en-in",
                            "en-au",
                            "en-nz",
                            "en-bg",
                            "en-hr",
                            "en-mt",
                            "en-cy",
                            "fr-lu",
                            "de-lu",
                            "en-ro",
                            "en-sk",
                            "en-si",
                            "en-bh",
                            "ar-bh",
                            "en-om",
                            "ar-om",
                            "es-cr",
                            "es-ec",
                            "es-gt",
                            "es-hn",
                            "es-ni",
                            "es-pa",
                            "es-py",
                            "es-sv",
                            "es-uy",
                            "es-bo"
                        ],
                        "type": "string",
                        "description": "The PlayStation storefront to scrape. Prices are returned in this country's local currency. To scrape several countries in one run, use the \"Multiple countries\" field below instead.",
                        "default": "en-us"
                    },
                    "countries": {
                        "title": "🌐 Multiple countries (optional)",
                        "type": "array",
                        "description": "Scrape several storefronts in a single run — every game is returned once per selected country with its local price. Overrides the single country above when set. Use [\"all\"] for every storefront.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "en-us",
                                "en-ca",
                                "fr-ca",
                                "es-mx",
                                "pt-br",
                                "es-ar",
                                "es-cl",
                                "es-co",
                                "es-pe",
                                "en-gb",
                                "en-ie",
                                "nl-nl",
                                "fr-fr",
                                "de-de",
                                "es-es",
                                "it-it",
                                "pt-pt",
                                "nl-be",
                                "fr-be",
                                "de-at",
                                "de-ch",
                                "fr-ch",
                                "it-ch",
                                "da-dk",
                                "fi-fi",
                                "no-no",
                                "sv-se",
                                "pl-pl",
                                "tr-tr",
                                "en-cz",
                                "en-gr",
                                "uk-ua",
                                "ar-ae",
                                "en-ae",
                                "ar-sa",
                                "en-sa",
                                "ar-kw",
                                "en-kw",
                                "ar-qa",
                                "en-qa",
                                "ar-lb",
                                "en-lb",
                                "en-il",
                                "en-za",
                                "ja-jp",
                                "ko-kr",
                                "zh-hant-hk",
                                "en-hk",
                                "zh-hant-tw",
                                "en-sg",
                                "en-my",
                                "th-th",
                                "en-th",
                                "en-in",
                                "en-au",
                                "en-nz",
                                "en-bg",
                                "en-hr",
                                "en-mt",
                                "en-cy",
                                "fr-lu",
                                "de-lu",
                                "en-ro",
                                "en-sk",
                                "en-si",
                                "en-bh",
                                "ar-bh",
                                "en-om",
                                "ar-om",
                                "es-cr",
                                "es-ec",
                                "es-gt",
                                "es-hn",
                                "es-ni",
                                "es-pa",
                                "es-py",
                                "es-sv",
                                "es-uy",
                                "es-bo"
                            ],
                            "enumTitles": [
                                "🇺🇸 United States (USD)",
                                "🇨🇦 Canada — English (CAD)",
                                "🇨🇦 Canada — Français (CAD)",
                                "🇲🇽 Mexico (MXN)",
                                "🇧🇷 Brazil (BRL)",
                                "🇦🇷 Argentina (USD)",
                                "🇨🇱 Chile (CLP)",
                                "🇨🇴 Colombia (COP)",
                                "🇵🇪 Peru (PEN)",
                                "🇬🇧 United Kingdom (GBP)",
                                "🇮🇪 Ireland (EUR)",
                                "🇳🇱 Netherlands (EUR)",
                                "🇫🇷 France (EUR)",
                                "🇩🇪 Germany (EUR)",
                                "🇪🇸 Spain (EUR)",
                                "🇮🇹 Italy (EUR)",
                                "🇵🇹 Portugal (EUR)",
                                "🇧🇪 Belgium — Nederlands (EUR)",
                                "🇧🇪 Belgium — Français (EUR)",
                                "🇦🇹 Austria (EUR)",
                                "🇨🇭 Switzerland — Deutsch (CHF)",
                                "🇨🇭 Switzerland — Français (CHF)",
                                "🇨🇭 Switzerland — Italiano (CHF)",
                                "🇩🇰 Denmark (DKK)",
                                "🇫🇮 Finland (EUR)",
                                "🇳🇴 Norway (NOK)",
                                "🇸🇪 Sweden (SEK)",
                                "🇵🇱 Poland (PLN)",
                                "🇹🇷 Turkey (TRY)",
                                "🇨🇿 Czechia (CZK)",
                                "🇬🇷 Greece (EUR)",
                                "🇺🇦 Ukraine (UAH)",
                                "🇦🇪 UAE — العربية (AED)",
                                "🇦🇪 UAE — English (AED)",
                                "🇸🇦 Saudi Arabia — العربية (SAR)",
                                "🇸🇦 Saudi Arabia — English (SAR)",
                                "🇰🇼 Kuwait — العربية (USD)",
                                "🇰🇼 Kuwait — English (USD)",
                                "🇶🇦 Qatar — العربية (USD)",
                                "🇶🇦 Qatar — English (USD)",
                                "🇱🇧 Lebanon — العربية (USD)",
                                "🇱🇧 Lebanon — English (USD)",
                                "🇮🇱 Israel (USD)",
                                "🇿🇦 South Africa (ZAR)",
                                "🇯🇵 Japan (JPY)",
                                "🇰🇷 South Korea (KRW)",
                                "🇭🇰 Hong Kong — 繁體 (HKD)",
                                "🇭🇰 Hong Kong — English (HKD)",
                                "🇹🇼 Taiwan (TWD)",
                                "🇸🇬 Singapore (SGD)",
                                "🇲🇾 Malaysia (MYR)",
                                "🇹🇭 Thailand (THB)",
                                "🇹🇭 Thailand — English (THB)",
                                "🇮🇳 India (INR)",
                                "🇦🇺 Australia (AUD)",
                                "🇳🇿 New Zealand (NZD)",
                                "🇧🇬 Bulgaria (EUR)",
                                "🇭🇷 Croatia (EUR)",
                                "🇲🇹 Malta (EUR)",
                                "🇨🇾 Cyprus (EUR)",
                                "🇱🇺 Luxembourg — Français (EUR)",
                                "🇱🇺 Luxembourg — Deutsch (EUR)",
                                "🇷🇴 Romania (RON)",
                                "🇸🇰 Slovakia (EUR)",
                                "🇸🇮 Slovenia (EUR)",
                                "🇧🇭 Bahrain — English (USD)",
                                "🇧🇭 Bahrain — العربية (USD)",
                                "🇴🇲 Oman — English (USD)",
                                "🇴🇲 Oman — العربية (USD)",
                                "🇨🇷 Costa Rica (USD)",
                                "🇪🇨 Ecuador (USD)",
                                "🇬🇹 Guatemala (USD)",
                                "🇭🇳 Honduras (USD)",
                                "🇳🇮 Nicaragua (USD)",
                                "🇵🇦 Panama (USD)",
                                "🇵🇾 Paraguay (USD)",
                                "🇸🇻 El Salvador (USD)",
                                "🇺🇾 Uruguay (USD)",
                                "🇧🇴 Bolivia (USD)"
                            ]
                        },
                        "default": []
                    },
                    "allCountries": {
                        "title": "🌐 All countries",
                        "type": "boolean",
                        "description": "Scrape every available storefront (56 countries) in one run. Overrides the country fields above. Warning: this multiplies your run by 56 — keep \"Max results per country\" low.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "🔢 Max results per country",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of games to return per selected country.",
                        "default": 5
                    },
                    "startUrls": {
                        "title": "🔗 Start URLs",
                        "type": "array",
                        "description": "Optional list of specific PlayStation Store game URLs to scrape directly (concept or product pages). Overrides search when provided.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "includeMedia": {
                        "title": "🖼️ Include media",
                        "type": "boolean",
                        "description": "Include cover art, screenshots, and trailer URLs in results. Turn off for a smaller, price-focused dataset.",
                        "default": true
                    },
                    "includeDescription": {
                        "title": "📝 Include descriptions",
                        "type": "boolean",
                        "description": "Include the full game description. Turn off for a lighter dataset.",
                        "default": true
                    },
                    "platforms": {
                        "title": "🎮 Filter by platform",
                        "type": "array",
                        "description": "Only return games available on the selected platform(s). Leave empty to include all. OR filter — selecting both widens results.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "PS5",
                                "PS4"
                            ],
                            "enumTitles": [
                                "PS5",
                                "PS4"
                            ]
                        },
                        "default": []
                    },
                    "ps5ProEnhanced": {
                        "title": "✨ PS5 Pro Enhanced only",
                        "type": "boolean",
                        "description": "Only return games that are PS5 Pro Enhanced (improved graphics/performance on PS5 Pro). Leave off to include all titles.",
                        "default": false
                    },
                    "experimentalOffersOnly": {
                        "title": "🧪 Experimental A/B prices only",
                        "type": "boolean",
                        "description": "Only return games whose public offer data carries one of Sony's pricing-experiment campaign identifiers (IPT_PILOT, IPT_OPR_TESTING, IPT_LTM). Note: most experimental prices are shown only to logged-in test-group accounts and will not appear in an anonymous scrape; this surfaces only campaign-tagged offers present in the public response.",
                        "default": false
                    },
                    "psPlusDeals": {
                        "title": "➕ PlayStation Plus deals only",
                        "type": "boolean",
                        "description": "Only return games that have a PlayStation Plus member price or are included with a PS Plus tier.",
                        "default": false
                    },
                    "vrSupport": {
                        "title": "🥽 Filter by VR support",
                        "enum": [
                            "any",
                            "vr",
                            "psvr2",
                            "psvr",
                            "none"
                        ],
                        "type": "string",
                        "description": "Filter by virtual-reality support. PSVR2 (Caesar/Sense) vs original PSVR are detected from the store's hardware compatibility data.",
                        "default": "any"
                    },
                    "priceFilter": {
                        "title": "💸 Filter by price",
                        "enum": [
                            "all",
                            "free",
                            "paid",
                            "onSale"
                        ],
                        "type": "string",
                        "description": "Only return games matching this price condition.",
                        "default": "all"
                    },
                    "minPrice": {
                        "title": "💵 Minimum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return games priced at or above this amount, in the storefront's local currency (major units, e.g. 10 = $10 / €10 / ¥10). Leave empty for no lower bound."
                    },
                    "maxPrice": {
                        "title": "💵 Maximum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return games priced at or below this amount, in the storefront's local currency (major units). Leave empty for no upper bound."
                    },
                    "minRating": {
                        "title": "⭐ Minimum star rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Only return games with an average star rating at or above this value (0–5, decimals allowed, e.g. 4.5). Leave empty to include all (titles without a rating are kept)."
                    },
                    "ageRatings": {
                        "title": "👶 Filter by age rating",
                        "type": "array",
                        "description": "Only return games at or below the selected maturity level(s), based on the storefront's rating board (ESRB / PEGI / USK / CERO). Leave empty to include all. OR filter.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "everyone",
                                "teen",
                                "mature",
                                "adult"
                            ],
                            "enumTitles": [
                                "Everyone / E / PEGI 3-7",
                                "Teen / T / PEGI 12",
                                "Mature / M / PEGI 16",
                                "Adults Only / AO / PEGI 18"
                            ]
                        },
                        "default": []
                    },
                    "genres": {
                        "title": "🧭 Filter by genre",
                        "type": "array",
                        "description": "Only return games in the selected genre(s). Leave empty to include all. OR filter — selecting multiple widens results.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Action",
                                "Adventure",
                                "Arcade",
                                "Brain Training",
                                "Casual",
                                "Driving/Racing",
                                "Educational",
                                "Family",
                                "Fighting",
                                "Horror",
                                "Music/Rhythm",
                                "Party",
                                "Puzzle",
                                "Quiz",
                                "Role Playing Games",
                                "Shooter",
                                "Simulation",
                                "Sport",
                                "Strategy",
                                "Unique"
                            ],
                            "enumTitles": [
                                "Action",
                                "Adventure",
                                "Arcade",
                                "Brain Training",
                                "Casual",
                                "Driving/Racing",
                                "Educational",
                                "Family",
                                "Fighting",
                                "Horror",
                                "Music/Rhythm",
                                "Party",
                                "Puzzle",
                                "Quiz",
                                "Role Playing Games",
                                "Shooter",
                                "Simulation",
                                "Sport",
                                "Strategy",
                                "Unique"
                            ]
                        },
                        "default": []
                    },
                    "releasedAfter": {
                        "title": "📅 Released after",
                        "type": "string",
                        "description": "Only return games released on or after this date (YYYY-MM-DD). Leave empty to include all."
                    },
                    "releasedBefore": {
                        "title": "📅 Released before",
                        "type": "string",
                        "description": "Only return games released on or before this date (YYYY-MM-DD). Leave empty to include all."
                    },
                    "useProxy": {
                        "title": "🛡️ Use proxy",
                        "type": "boolean",
                        "description": "Route requests through a proxy. Off by default — the PlayStation Store is reachable directly, so this is rarely needed.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
