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

Scrape PlayStation Store listings from category, browse, deals, search and product pages: prices, discounts, star ratings, genres, publisher, release date and media for PS5 and PS4 games in any regional store. Export to CSV, JSON, Excel or XML.

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

## Pricing

$2.00 / 1,000 product scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### PlayStation Store Scraper

**Scrape PlayStation Store game listings, prices, discounts and ratings from any category, deals, search or product page.** Get the title, current and original price, discount percentage, star rating and rating count, genres, publisher, release date, age rating, descriptions, screenshots and trailer for PS5 and PS4 games in any regional store. Export to CSV, JSON, Excel, or XML.

The PlayStation Store web interface is built for browsing, not bulk data collection. Manually copying game details across hundreds of pages is slow and error-prone. This Actor reads the store's own catalogue API (the same one the website calls), pages through it 100 products at a time, and opens each product page for the details the listing does not carry. One row per product, in a flat schema you can filter and analyze immediately.

| Who uses it | What they scrape PlayStation Store for |
|---|---|
| Game publishers and developers | Monitor competitor pricing and discount patterns across the PlayStation Store catalog. |
| Price comparison websites | Feed a live database of PlayStation digital game prices and deals for their users. |
| Deal hunters and bloggers | Find the deepest discounts and free-to-play promotions to feature in roundup articles. |
| Market analysts | Track genre popularity, rating distributions, and release trends on the platform. |

### What it does

This Actor collects PlayStation Store products from the URLs and search terms you give it and returns each game, edition or add-on as a flat row.

- 🕹️ **Full catalogue extraction:** Category, browse and deals pages are read through the store API, 100 products per request, up to the store's own limit of 10,000 products per category.
- 📄 **Pagination handling:** Follows every page automatically, honouring a page number in the URL (`/category/<id>/3` starts at page 3).
- 💲 **Price parsing:** Returns the displayed sale price and original price, a numeric value for each, the currency code, and the discount percentage.
- ⭐ **Rating collection:** Opens each product page to read the average star rating and the total number of ratings.
- 🏷️ **Platform, genre and age rating:** PS5, PS4 or both; genres; publisher; release date; edition; ESRB, PEGI, CERO or USK rating with its descriptors.
- 🖼️ **Media:** Cover image, screenshots and the trailer URL.
- 🌍 **Any regional store:** The locale in the URL (`en-us`, `en-gb`, `de-de`, `ja-jp`, `pt-br`, ...) selects the store, so prices come back in that region's currency.
- 🔀 **Sorting and filters:** Sort category pages by best selling, most downloaded, price, release date or name. Filters applied on the website travel in the URL and are honoured.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### Output

| Field | What it holds |
|---|---|
| 🖼 `imageUrl` | Cover art (the store's master or key art image) |
| 🎮 `title`, `url`, `id` | Product name, its `/product/` page in the chosen regional store, and the store product ID |
| 📦 `type` | Full Game, Premium Edition, Game Bundle, Add-On, Demo, Soundtrack, ... |
| 🕹 `platforms` | `["PS5"]`, `["PS4"]` or both |
| 💵 `price`, `originalPrice` | Displayed sale price and original price, as the store shows them (`"$69.99"`, `"€59,99"`, `"¥550"`, `"Free"`) |
| 🔢 `priceValue`, `originalPriceValue`, `currency` | Numeric prices and the ISO currency code of the regional store |
| 🔻 `discountPercent`, `discountText` | Discount computed from the two prices, and the badge text when the store shows one (`"-50%"`) |
| 🆓 `isFree`, `isSubscriptionOffer`, `serviceBranding` | Free-to-play flag, whether the price shown is a PlayStation Plus offer, and the service branding (PS Plus tier or EA Play) |
| ⭐ `rating`, `ratingCount` | Average star rating (0 to 5) and number of ratings from the product page |
| 🎭 `genres`, `publisher`, `releaseDate`, `edition` | From the product page |
| 🔞 `contentRating`, `contentRatingDescriptors` | Age rating of the region's board (`"ESRB Mature"`, `"PEGI 18"`, `"CERO A"`) and its descriptors |
| 📝 `shortDescription`, `description` | Tagline and full description, HTML removed |
| 🔗 `conceptId`, `npTitleId`, `locale` | Store concept (game) ID, title ID, and the regional store the row came from |
| 📸 `screenshots`, `videoUrl` | Screenshot URLs and the trailer URL |
| 🕒 `scrapedAt`, `error` | Timestamp, and an error message on rows that could not be scraped |

Fields the store does not publish for a product come back as `"N/A"` or `"Not Disclosed"`, never as an empty cell. With **Full product details** switched off, the rating, genres, publisher, release date, edition, age rating and descriptions are not fetched and stay `"N/A"`.

A real row from the US store:

```json
{
  "imageUrl": "https://image.api.playstation.com/vulcan/ap/rnd/202606/2913/4a31f711e2ff460cd44ad646983f36533278cea61f639be9.png",
  "title": "NBA 2K27",
  "url": "https://store.playstation.com/en-us/product/UP1001-PPSA35889_00-NBA2K27000000000",
  "id": "UP1001-PPSA35889_00-NBA2K27000000000",
  "type": "Full Game",
  "platforms": ["PS5"],
  "price": "$69.99",
  "originalPrice": "$69.99",
  "priceValue": 69.99,
  "originalPriceValue": 69.99,
  "currency": "USD",
  "discountPercent": 0,
  "discountText": "N/A",
  "isFree": "No",
  "isSubscriptionOffer": "No",
  "serviceBranding": "N/A",
  "rating": 2.72,
  "ratingCount": 2037,
  "genres": ["Sport"],
  "publisher": "2K",
  "releaseDate": "2026-09-04T04:00:00Z",
  "edition": "Standard Edition",
  "contentRating": "ESRB Everyone",
  "contentRatingDescriptors": [],
  "shortDescription": "Ball Over Everything",
  "description": "The hustle doesn't stop and the run never ends in NBA 2K27. ...",
  "conceptId": "10018502",
  "npTitleId": "PPSA35889_00",
  "locale": "en-us",
  "screenshots": ["https://image.api.playstation.com/vulcan/ap/rnd/202606/2913/....png", "..."],
  "videoUrl": "N/A",
  "scrapedAt": "2026-09-07T20:19:40.260Z",
  "error": null
}
```

And a discounted title from the UK store:

```json
{
  "title": "God of War™",
  "url": "https://store.playstation.com/en-gb/product/EP9000-CUSA07412_00-0000000GODOFWARN",
  "type": "Full Game",
  "platforms": ["PS4"],
  "price": "£7.99",
  "originalPrice": "£15.99",
  "priceValue": 7.99,
  "originalPriceValue": 15.99,
  "currency": "GBP",
  "discountPercent": 50,
  "discountText": "-50%",
  "rating": 4.74,
  "ratingCount": 310003,
  "genres": ["Action", "Adventure"],
  "publisher": "Sony Interactive Entertainment",
  "releaseDate": "2019-10-03T23:00:00Z",
  "contentRating": "PEGI 18",
  "contentRatingDescriptors": ["Language", "Violence"]
}
```

### What you can do with PlayStation Store data

**💰 Track competitor discounts.**

A game publisher runs the Actor on the deals page weekly to log every price change and discount duration, informing their own promotional calendar.

**📊 Build a price history database.**

A deal website schedules daily scrapes of `/pages/deals`, storing the current and original prices to show users a game's lowest-ever price trend.

**🎮 Audit a game catalog.**

A market researcher scrapes a genre category sorted by best selling to tally the number of titles, average rating, and price range, producing a competitive landscape report.

**🔍 Find free-to-play games.**

A content creator filters a category by price on the website, pastes the resulting URL, and gets a complete, up-to-date list of free games for a YouTube video or blog post.

### Why choose this scraper

|  | What you get |
|---|---|
| **Structured game data** | Titles, prices, discounts, ratings, genres, publishers and platforms in a consistent format ready for analysis. |
| **Product-page depth** | Star rating, rating count, release date, age rating and descriptions, not just the listing tile. |
| **Any regional store** | Change the locale in the URL and the same run returns prices in USD, GBP, EUR, JPY, BRL or any other store currency. |
| **Flexible export** | Download your results as CSV, JSON, Excel, or XML for use in any tool or database. |

### How it compares

Other PlayStation Store actors on the platform return the listing tile: title, price, discount and platform. This Actor adds the product page on top, so each row also carries the star rating and rating count, genres, publisher, release date, edition, age rating, descriptions, screenshots and trailer.

| | PlayStation Store Scraper | Build it in-house | By hand |
|---|---|---|---|
| Setup | Run it now, zero config | Days of engineering | None, but hours per pull |
| When PlayStation Store changes | Maintained for you | You fix it | You re-learn the page |
| Proxies, retries, anti-bot | Built in | Your problem | Browser only |
| Output | Fixed JSON schema, CSV/Excel export | Whatever you build | Copy-paste |
| Cost | Pay per result | Engineering time | Analyst hours |

Two ceilings come from the store itself and are reported honestly: a category page lists at most 10,000 products (narrow it with filters or sorting to reach the rest), and a search returns at most 128 results per term.

### Configure the run

Drive the Actor from any PlayStation Store category, browse, deals, search or product URL, or give it search terms and a regional store. Set a maximum item limit to control the size of your output dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
  "startUrls": [{ "url": "https://store.playstation.com/en-us/pages/browse" }],
  "maxItems": 10
}
```

The 200 best-selling PS5 games in the German store, with full details:

```json
{
  "startUrls": [{ "url": "https://store.playstation.com/de-de/category/44d8bb20-653e-431e-8ad0-c0a365f68d2f/1?PS5=targetPlatforms" }],
  "sortBy": "sales30:desc",
  "maxItems": 200
}
```

Search terms in the Japanese store, listing only, no product pages:

```json
{
  "searchTerms": ["racing", "rpg"],
  "locale": "ja-jp",
  "includeDetails": false,
  "maxItems": 100
}
```

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [PlayStation Store Scraper](https://apify.com/parseforge/playstation-store-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to PlayStation Store through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=parseforge/playstation-store-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**The Actor finishes but returns zero results.**

Check the URL type. Supported pages are `/category/<id>`, `/pages/<name>` (browse, deals, latest), `/search/<term>` and `/product/<id>`. Concept pages (`/concept/<id>`) render in the browser only, so paste one of the concept's `/product/` URLs instead. Unreleased games that have no purchasable edition yet are skipped and counted in the log.

**The prices are in the wrong currency.**

The currency follows the regional store in the URL. Use `en-gb` for GBP, `de-de` for EUR, `ja-jp` for JPY, and so on. For search terms, set the **Regional store** input.

**The Actor stops before scraping all items.**

A category lists at most 10,000 products and a search at most 128 results. These are limits of the store itself. Split a large category with the website's filters (platform, genre, price range, age rating) and paste each filtered URL as its own start URL, or use a sort order with Max Items to take the top N.

**Some product fields are N/A in the output.**

With **Full product details** off, only the listing fields are filled. With it on, a field is `N/A` when the store does not publish it for that product: many add-ons have no rating, and unreleased titles have no release date.

**I get a timeout or an error during the run.**

Every product page is one extra request, so a run with details over thousands of products takes minutes. Increase the run timeout in the advanced options, or turn **Full product details** off for a fast listing pull.

### FAQ

| Question | Answer |
|---|---|
| Can I scrape a specific search query on the PlayStation Store? | Yes. Add the term to **Search terms** and pick the regional store, or paste the search URL from the website. A search returns at most 128 results per term, so use several narrower terms to cover more ground. |
| Does this Actor handle pagination? | Yes. It pages through the store API automatically, 100 products per request, until it reaches your Max Items, the end of the list, or the store's 10,000-product ceiling. |
| What data fields does the Actor return? | Each row includes cover image, title, URL, product ID, type, platforms, sale and original price with numeric values and currency, discount percentage, star rating and rating count, genres, publisher, release date, edition, age rating, descriptions, screenshots and trailer. The full list is in the Output section above. |
| Can I limit how many items are scraped? | Yes, use the **Max Items** input field. The Actor stops as soon as it has collected that many products, even if more pages are available. |
| Does this scraper work for all regional PlayStation Stores? | Yes. Paste the URL from the regional store you want (for example `en-gb`, `fr-fr`, `pt-br`, `ja-jp`), and prices, genre names and age ratings come back in that region's currency and language. |
| Will I get blocked for scraping the PlayStation Store? | The store API answered every request in our tests, including bursts, from datacenter IPs. The default Apify proxy is enough; residential proxies are not needed. |
| Can I scrape only PS5 games and exclude PS4? | Yes. Apply the platform filter on the website and paste the resulting URL, for example `.../category/<id>/1?PS5=targetPlatforms`. Genre, price range, age rating and other website filters work the same way. |
| How do I get the discount percentage? | It is computed from the numeric sale and original prices and returned as `discountPercent`. The store's own badge text, when shown, is in `discountText`. |
| Why does a game appear once when the store sells several editions? | Browse and category pages list games, and the Actor returns the edition the store leads with. Search pages and product URLs return each edition separately. |
| Is a PlayStation Network login required? | No. The Actor reads the public store catalogue and product pages. No login, API key, or PSN account is needed. |
| Can I schedule this Actor to run daily? | Yes, once you have configured the Actor, you can set it up on a schedule (for example every day at 9 AM) using Apify's built-in scheduler to track price changes over time. |

### Related actors

- [steam-store-scraper](https://apify.com/parseforge/steam-store-scraper?fpr=vmoqkp): Use this if you need to scrape game listings, prices, and reviews from the Steam store instead of PlayStation.

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Sony Interactive Entertainment LLC. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

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

PlayStation Store pages to scrape: category pages (/category/<id>/1, filters in the URL are honoured), browse and deals pages (/pages/browse, /pages/deals, /pages/latest), search pages (/search/<term>) and single products (/product/<id>). The regional store comes from the URL (en-us, en-gb, de-de, ja-jp, ...).

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

Keywords to search on the store, e.g. "god of war" or "racing". Each term runs its own search in the regional store chosen below.

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `includeDetails` (type: `boolean`):

Open every product page to add the star rating and rating count, genres, publisher, release date, edition, age rating, descriptions, screenshots and trailer (one extra request per product). Turn off for a fast, lighter listing-only export with prices and discounts.

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

Order in which category, browse and deals pages are read. Useful with Max Items to take the top N by sales, downloads, price or release date. Search results keep the store's relevance order.

## `locale` (type: `string`):

Store locale used for search terms and for URLs without one, e.g. en-us, en-gb, de-de, fr-fr, es-es, ja-jp, pt-br. Prices come back in that region's currency.

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

The store API answers datacenter IPs, so the default Apify proxy is enough. Residential is not needed.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://store.playstation.com/en-us/pages/browse"
    }
  ],
  "searchTerms": [],
  "maxItems": 10,
  "includeDetails": true,
  "sortBy": "",
  "locale": "en-us",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Key identity, price, discount, rating and release fields

## `fullData` (type: `string`):

Complete dataset with all 33 fields, including descriptions, age rating, screenshots and trailer

# 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"
        }
    ],
    "searchTerms": [],
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/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" }],
    "searchTerms": [],
    "maxItems": 10,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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"
    }
  ],
  "searchTerms": [],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call parseforge/playstation-store-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/playstation-store-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/yb8QdLQ9mr3h6PzwF/builds/ZOPX3SEXS0vhCWaAK/openapi.json