# Mandarake Japan Collectibles — Price & Stock Market Stats (`jpmarketdata/mandarake-market-checker`) Actor

Price & availability stats for any keyword on Mandarake, Japan's biggest secondhand anime/manga/figure/TCG store: in-stock ask prices, sold-out (realized) prices, stock split, top shops. For overseas collectors, proxy buyers & resellers. From $0.02 — no subscription. まんだらけの相場を1コールで。

- **URL**: https://apify.com/jpmarketdata/mandarake-market-checker.md
- **Developed by:** [h ichi](https://apify.com/jpmarketdata) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 keyword market summaries

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/platform/actors/running/actors-in-store#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.

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Mandarake Japan Collectibles — Price & Stock Market Stats

Market statistics for any keyword on [Mandarake](https://order.mandarake.co.jp/order/?lang=en) — Japan's biggest secondhand store for anime, manga, figures, doujinshi, toys and trading cards (30+ physical shops, one web catalog). One call per keyword returns:

- **In-stock ask prices** — median / quartiles / min / max of everything currently buyable
- **Sold-out (realized) prices** — Mandarake sells at fixed prices, so a sold-out item's listed price is the price it actually sold for. This is the closest public thing to *sold comps* for Japanese collectibles retail
- **Stock split** — how many listings are in stock vs. sold out (market depth & sell-through)
- **Top shops** — which Mandarake stores hold the stock (Nakano, Shibuya, Sahra, Grandchaos…)
- Optionally, every sampled item (title, price, shop, stock status, item URL)

Prices are reported in JPY and (optionally) USD. Data is fetched on demand from Mandarake's public English web shop — no login, nothing stored between runs.

Built for **overseas collectors, proxy-buying services and resellers**: Mandarake has no public API, and its prices are the reference point for Japanese collectibles worldwide.

### Pricing — from $0.02 per keyword, no subscription

| Event | Price | When |
|---|---|---|
| Keyword market summary | $0.02 | Per keyword analyzed |
| Individual item | $0.002 | Only if you enable **Include individual items** |

A default run (1 keyword, summary only) costs **$0.02**. You are never charged for a keyword that returns zero listings.

### Input

| Field | Example | Notes |
|---|---|---|
| `keywords` | `["ガンダム"]` | Japanese keywords match best; English often works (titles are bilingual) |
| `categoryCode` | `"02"` | Optional category filter: 11=Comics, 12=Goods, 02=Toys, 05=Cards/Stickers, 04=Anime, 03=Doujins… |
| `maxItemsPerKeyword` | `120` | Newest listings sampled per keyword (30–360) |
| `includeIndividualItems` | `false` | Enable to get each item as a record |
| `convertToUsd` | `true` | Adds USD stats at the current exchange rate |

### Output example (summary)

```json
{
  "type": "market_summary",
  "keyword": "ガンダム",
  "totalListingsFound": 71934,
  "inStockTotal": 22848,
  "soldOutTotal": 49086,
  "sampledListings": 120,
  "sampledInStock": 78,
  "sampledSoldOut": 42,
  "askPriceJpy": {"min": 250, "p25": 1200, "median": 4000, "p75": 7000, "max": 45000, "average": 5480},
  "askPriceUsd": {"median": 25.48, "...": "..."},
  "soldPriceJpy": {"min": 250, "median": 1800, "max": 12000, "...": "..."},
  "shopTop": [["Nakano", 34], ["Sahra", 21], ["Grandchaos", 12]],
  "exchangeRateJpyUsd": 0.00637
}
````

### Use cases

- **Sourcing & arbitrage** — compare Mandarake's ask prices against eBay/Mercari sold prices before ordering through a proxy service
- **Pricing your inventory** — the sold-out price distribution tells you what the Japanese market actually pays, not what sellers hope for
- **Collection tracking** — check market depth and price level for a series or character in one call

### Notes & limits

- `totalListingsFound` includes sold-out items; `inStockTotal` (exact, from a separate filtered count) is what you can buy now
- Sold-out listings carry no sold *date*, so no time-series is possible — the split and the two price distributions are the signal
- Adult-flagged items are included in counts and marked `isAdult` on individual records
- Read-only and throttled (~1 request / 1.5 s). No login, no personal data, nothing stored between runs

***

### 日本語ガイド

**まんだらけ通販の相場をキーワード単位で1コールで返す Actor です。**

- **概要**: キーワードごとに、販売中商品の価格統計(中央値・四分位)、**売切商品の価格統計**(まんだらけは定価販売のため売切価格≒実売価格)、在庫/売切の件数内訳、在庫を持つ店舗トップ5を集計します。海外コレクター・代購業者・リセーラー向けに英語フィールド名+USD換算付き。
- **使い方**: `keywords` に検索キーワード(日本語推奨)を入力してください。`categoryCode` でカテゴリを絞れます(02=おもちゃ、05=カード類 など)。
- **料金**: キーワードサマリー1件 $0.02。個別商品データが必要な場合のみ `includeIndividualItems` を ON(+$0.002/件)。0件のキーワードには課金されません。サブスクリプション不要です。

# Actor input Schema

## `keywords` (type: `array`):

One or more search keywords (Japanese works best, English often works too). Examples: ガンダム, セーラームーン, ポケモンカード, Gundam MG, Evangelion figure.

## `categoryCode` (type: `string`):

Restrict the search to one Mandarake category. Common codes: 00=All, 11=Comics/Light Novels, 12=Goods, 01=Books, 10=Magazines, 02=Toys, 03=Doujins, 06=AV/Games, 07=Idols/Voice Actors, 05=Cards/Stickers, 04=Anime. Leave empty for all categories.

## `maxItemsPerKeyword` (type: `integer`):

How many newest listings to sample per keyword. 120 = one result page. More items = better statistics. Affects cost only when 'Include individual items' is enabled (+$0.002 per item).

## `includeIndividualItems` (type: `boolean`):

Off by default: a run costs a flat $0.02 per keyword summary. Enable to also get every sampled item (title, price, shop, in-stock/sold-out, item URL) at +$0.002 per item.

## `convertToUsd` (type: `boolean`):

Adds USD statistics next to JPY using the current exchange rate (open.er-api.com).

## Actor input object example

```json
{
  "keywords": [
    "ガンダム"
  ],
  "maxItemsPerKeyword": 120,
  "includeIndividualItems": false,
  "convertToUsd": true
}
```

# 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 = {
    "keywords": [
        "ガンダム"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jpmarketdata/mandarake-market-checker").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 = { "keywords": ["ガンダム"] }

# Run the Actor and wait for it to finish
run = client.actor("jpmarketdata/mandarake-market-checker").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 '{
  "keywords": [
    "ガンダム"
  ]
}' |
apify call jpmarketdata/mandarake-market-checker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mandarake Japan Collectibles — Price & Stock Market Stats",
        "description": "Price & availability stats for any keyword on Mandarake, Japan's biggest secondhand anime/manga/figure/TCG store: in-stock ask prices, sold-out (realized) prices, stock split, top shops. For overseas collectors, proxy buyers & resellers. From $0.02 — no subscription. まんだらけの相場を1コールで。",
        "version": "0.1",
        "x-build-id": "jNvtYWBftY6poShgB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jpmarketdata~mandarake-market-checker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jpmarketdata-mandarake-market-checker",
                "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/jpmarketdata~mandarake-market-checker/runs": {
            "post": {
                "operationId": "runs-sync-jpmarketdata-mandarake-market-checker",
                "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/jpmarketdata~mandarake-market-checker/run-sync": {
            "post": {
                "operationId": "run-sync-jpmarketdata-mandarake-market-checker",
                "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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "One or more search keywords (Japanese works best, English often works too). Examples: ガンダム, セーラームーン, ポケモンカード, Gundam MG, Evangelion figure.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categoryCode": {
                        "title": "Category code (optional)",
                        "type": "string",
                        "description": "Restrict the search to one Mandarake category. Common codes: 00=All, 11=Comics/Light Novels, 12=Goods, 01=Books, 10=Magazines, 02=Toys, 03=Doujins, 06=AV/Games, 07=Idols/Voice Actors, 05=Cards/Stickers, 04=Anime. Leave empty for all categories."
                    },
                    "maxItemsPerKeyword": {
                        "title": "Max items per keyword",
                        "minimum": 30,
                        "maximum": 360,
                        "type": "integer",
                        "description": "How many newest listings to sample per keyword. 120 = one result page. More items = better statistics. Affects cost only when 'Include individual items' is enabled (+$0.002 per item).",
                        "default": 120
                    },
                    "includeIndividualItems": {
                        "title": "Include individual items",
                        "type": "boolean",
                        "description": "Off by default: a run costs a flat $0.02 per keyword summary. Enable to also get every sampled item (title, price, shop, in-stock/sold-out, item URL) at +$0.002 per item.",
                        "default": false
                    },
                    "convertToUsd": {
                        "title": "Convert prices to USD",
                        "type": "boolean",
                        "description": "Adds USD statistics next to JPY using the current exchange rate (open.er-api.com).",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```