# Nintendo eShop Scraper (`crawlerbros/nintendo-eshop-scraper`) Actor

Scrape the Nintendo eShop - search for games by title, browse by platform/genre, or look up games by ID. Returns pricing, age rating, release dates, publishers, images, and availability.

- **URL**: https://apify.com/crawlerbros/nintendo-eshop-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (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

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Nintendo eShop Scraper

Scrape the Nintendo eShop to extract game data — titles, publishers, platforms, pricing, age ratings, release dates, and cover images. Supports searching by title, browsing the full catalog, and looking up games by ID.

### What you can do

- **Search by title** — find games matching a keyword (e.g. "mario", "zelda", "pokemon")
- **Browse all games** — paginate through the entire Nintendo eShop catalog with optional platform and price filters
- **Look up by game ID** — retrieve a specific game by its eShop `fs_id`

### Output fields

| Field | Description |
|-------|-------------|
| `gameId` | Unique Nintendo eShop identifier (`fs_id`) |
| `title` | Game title |
| `description` | Product description |
| `publisher` | Publisher name |
| `platform` | Primary platform (e.g. "Nintendo Switch") |
| `platforms` | All platforms this game is available on |
| `releaseDate` | Release date (ISO format, e.g. "2017-03-03") |
| `releaseDateFormatted` | Human-readable release date (e.g. "15/11/2019") |
| `lowestPrice` | Lowest available price in EUR |
| `priceSort` | Effective price used for sorting, in EUR |
| `discountPercentage` | Current discount percentage (if on sale) |
| `ageRating` | PEGI/USK age rating value (e.g. "12") |
| `ageRatingLabel` | Full age rating label (e.g. "PEGI 12") |
| `ageRatingSystem` | Age rating system, e.g. "pegi" / "usk" / "esrb" |
| `genres` | Game categories/genres (e.g. ["Action", "Adventure", "Platformer"]) |
| `downloadSize` | Download / data size (e.g. "13.4 GB") |
| `minPlayers` | Minimum number of players |
| `maxPlayers` | Maximum number of players |
| `isDigital` | Available as a digital download |
| `isPhysical` | Available as a physical copy |
| `hasDemo` | Free demo available |
| `playableOn` | Hardware/system codes the game runs on (e.g. "HAC" = Switch) |
| `supportsGameVoucher` | Eligible for the Nintendo Switch Game Voucher program |
| `requiresOnlineSubscription` | Requires Nintendo Switch Online for online features |
| `requiresPaidSubscription` | Requires a paid subscription |
| `removedFromEShop` | Present and `true` only for titles removed from the eShop (returned when `includeRemovedFromShop` is enabled) |
| `thumbnailUrl` | Square product image URL |
| `bannerUrl` | Banner/header image URL |
| `wishlistSquareImageUrl` | Alternate square promotional image URL |
| `wishlistBannerUrl` | Wishlist banner promotional image URL |
| `copyright` | Copyright / rights-holder text |
| `originalPlatform` | System the game was originally released for (e.g. Virtual Console re-releases like NES/Game Boy Advance titles now on Switch) |
| `listingUpdatedAt` | UTC timestamp when the eShop listing itself was last updated |
| `languages` | Available languages |
| `gameUrl` | Link to the game on nintendo.com |
| `sourceUrl` | URL of the API request |
| `scrapedAt` | UTC timestamp when scraped |
| `recordType` | Always `"game"` |

### Input options

#### Mode: `search` (default)

Search for games by title keyword.

```json
{
  "mode": "search",
  "searchQuery": "mario",
  "platform": "Nintendo Switch",
  "maxItems": 50
}
````

#### Mode: `browse`

Browse the full eShop catalog with optional filters.

```json
{
  "mode": "browse",
  "sortBy": "date_from desc",
  "minPrice": 0,
  "maxPrice": 30,
  "ageRatingMax": "12",
  "maxItems": 100
}
```

#### Mode: `byId`

Look up specific games by their eShop ID.

```json
{
  "mode": "byId",
  "gameIds": ["1173609", "267409"]
}
```

### Filters

| Filter | Type | Description |
|--------|------|-------------|
| `platform` | select | Filter by platform (Nintendo Switch, Wii U, 3DS, etc.) |
| `sortBy` | select | Sort order (relevance, release date, price) |
| `minPrice` | integer | Minimum price in EUR |
| `maxPrice` | integer | Maximum price in EUR |
| `ageRatingMax` | select | Maximum PEGI age rating |
| `includeRemovedFromShop` | boolean | Include games removed from the eShop |
| `maxItems` | integer | Maximum number of records (1–2000) |

### Example output

```json
{
  "gameId": "1173609",
  "title": "The Legend of Zelda: Breath of the Wild",
  "publisher": "Nintendo",
  "platform": "Nintendo Switch",
  "platforms": ["Nintendo Switch"],
  "releaseDate": "2017-03-03",
  "lowestPrice": 59.99,
  "ageRating": "12",
  "ageRatingLabel": "PEGI 12",
  "genres": ["Action", "Adventure"],
  "downloadSize": "13.4 GB",
  "minPlayers": 1,
  "maxPlayers": 1,
  "isPhysical": true,
  "thumbnailUrl": "https://www.nintendo.com/eu/media/images/11_square_images/games_18/wii_u_20/SQ_WiiU_TheLegendOfZeldaBreathOfTheWild_image500w.jpg",
  "originalPlatform": "Nintendo Switch",
  "listingUpdatedAt": "2022-01-17T10:56:57Z",
  "gameUrl": "https://www.nintendo.com/en-gb/Games/Nintendo-Switch-games/The-Legend-of-Zelda-Breath-of-the-Wild-1173609.html",
  "languages": ["japanese", "english", "spanish", "french", "german", "italian", "dutch", "russian", "korean", "chinese"],
  "sourceUrl": "https://searching.nintendo-europe.com/en/select?q=*&fq=type%3AGAME%20AND%20fs_id%3A1173609&rows=1",
  "scrapedAt": "2026-07-01T13:17:20.918803+00:00",
  "recordType": "game"
}
```

### Use cases

- **Game market research** — track Nintendo's catalog, pricing trends, new releases
- **Parental controls tools** — filter games by age rating for family-safe lists
- **Price monitoring** — monitor when games go on sale
- **Content discovery** — find games by platform, genre, or price range
- **Competitive analysis** — understand Nintendo's eShop pricing strategy

### FAQ

**Is this free to use?**
Yes. The Nintendo eShop public search API used by this actor requires no authentication.

**Which regions are covered?**
This actor uses the Nintendo Europe eShop API, which includes games for all European markets with PEGI ratings. Titles and pricing reflect the EU/UK eShop.

**How many games are available?**
The Nintendo eShop EU catalog contains thousands of titles. Use `mode=browse` without filters to iterate the full catalog.

**Are prices in EUR?**
Yes. All prices (`lowestPrice`) are in EUR as returned by the Nintendo Europe eShop API.

**Why are some games missing prices?**
Games that are free, unavailable for purchase, or whose pricing data is not yet indexed will not have a `lowestPrice` field.

**Can I filter by genre?**
Genre filtering is not directly supported by the API. Use `searchQuery` with genre keywords (e.g. "platformer", "RPG") to find related games.

**Data source**: Nintendo eShop EU public Solr search API (`searching.nintendo-europe.com`).

# Actor input Schema

## `mode` (type: `string`):

What to fetch from the Nintendo eShop.

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

Game title to search for (mode=search). Example: 'mario', 'zelda', 'pokemon'.

## `gameIds` (type: `array`):

List of Nintendo eShop EU internal game IDs (fs\_id) to look up. Find these in search results (the 'gameId' field). Example: \['267409', '2915270'].

## `platform` (type: `string`):

Filter to a specific Nintendo platform.

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

How to sort search/browse results.

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

Only include games with a price at or above this value (EUR). 0 = include free games.

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

Only include games with a price at or below this value (EUR).

## `ageRatingMax` (type: `string`):

Only include games with an age rating at or below this value.

## `includeRemovedFromShop` (type: `boolean`):

Include games that have been removed from the eShop.

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

Hard cap on the number of game records to emit.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "mario",
  "gameIds": [],
  "platform": "",
  "sortBy": "score desc",
  "ageRatingMax": "",
  "includeRemovedFromShop": false,
  "maxItems": 20
}
```

# Actor output Schema

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

Dataset containing all scraped Nintendo eShop game records.

# 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 = {
    "mode": "search",
    "searchQuery": "mario",
    "gameIds": [],
    "sortBy": "score desc",
    "includeRemovedFromShop": false,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/nintendo-eshop-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 = {
    "mode": "search",
    "searchQuery": "mario",
    "gameIds": [],
    "sortBy": "score desc",
    "includeRemovedFromShop": False,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/nintendo-eshop-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 '{
  "mode": "search",
  "searchQuery": "mario",
  "gameIds": [],
  "sortBy": "score desc",
  "includeRemovedFromShop": false,
  "maxItems": 20
}' |
apify call crawlerbros/nintendo-eshop-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Nintendo eShop Scraper",
        "description": "Scrape the Nintendo eShop - search for games by title, browse by platform/genre, or look up games by ID. Returns pricing, age rating, release dates, publishers, images, and availability.",
        "version": "1.0",
        "x-build-id": "wj8L6c4YXwUtasTek"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~nintendo-eshop-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-nintendo-eshop-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/crawlerbros~nintendo-eshop-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-nintendo-eshop-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/crawlerbros~nintendo-eshop-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-nintendo-eshop-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "browse",
                            "byId"
                        ],
                        "type": "string",
                        "description": "What to fetch from the Nintendo eShop.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Game title to search for (mode=search). Example: 'mario', 'zelda', 'pokemon'.",
                        "default": "mario"
                    },
                    "gameIds": {
                        "title": "Game IDs (mode=byId)",
                        "type": "array",
                        "description": "List of Nintendo eShop EU internal game IDs (fs_id) to look up. Find these in search results (the 'gameId' field). Example: ['267409', '2915270'].",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform filter",
                        "enum": [
                            "",
                            "Nintendo Switch",
                            "Nintendo Switch 2",
                            "Nintendo 3DS",
                            "Wii U",
                            "Nintendo DS",
                            "Game Boy Advance",
                            "Smart device"
                        ],
                        "type": "string",
                        "description": "Filter to a specific Nintendo platform.",
                        "default": ""
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "score desc",
                            "date_from desc",
                            "date_from asc",
                            "price_sorting_f asc",
                            "price_sorting_f desc",
                            "title asc"
                        ],
                        "type": "string",
                        "description": "How to sort search/browse results.",
                        "default": "score desc"
                    },
                    "minPrice": {
                        "title": "Minimum price (EUR)",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only include games with a price at or above this value (EUR). 0 = include free games."
                    },
                    "maxPrice": {
                        "title": "Maximum price (EUR)",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only include games with a price at or below this value (EUR)."
                    },
                    "ageRatingMax": {
                        "title": "Max age rating",
                        "enum": [
                            "",
                            "3",
                            "7",
                            "12",
                            "16",
                            "18"
                        ],
                        "type": "string",
                        "description": "Only include games with an age rating at or below this value.",
                        "default": ""
                    },
                    "includeRemovedFromShop": {
                        "title": "Include removed games",
                        "type": "boolean",
                        "description": "Include games that have been removed from the eShop.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Hard cap on the number of game records to emit.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
