# Suruga-ya Price Scraper (駿河屋) — Edition Flags & Arbitrage Data (`turbulent_noodle/surugaya-price-scraper`) Actor

Scrape Suruga-ya (駿河屋) prices for Japanese collectibles: trading cards, anime figures, games, CDs, books. Structured edition flags (obi, unopened, first press, Suruga-ya limited) that other scrapers can't read. Combine with TCGPlayer/PriceCharting for JP↔US arbitrage.

- **URL**: https://apify.com/turbulent\_noodle/surugaya-price-scraper.md
- **Developed by:** [T K](https://apify.com/turbulent_noodle) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 results

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.

- **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

## Suruga-ya Scraper — Japanese Collectibles Price Data (駿河屋)

Get **live prices from Suruga-ya (suruga-ya.jp)**, Japan's biggest second-hand store for **anime figures, Pokémon & trading cards, video games, CDs, manga, and collectibles** — as clean, normalized JSON.

If you source from Japan and resell on eBay, TCGPlayer, or Amazon, this Actor gives you the **Japanese supply-side price** for any keyword in seconds: new & used prices in JPY (tax included), stock status, marketplace offers, and — unique to this Actor — **structured edition flags** parsed from Japanese listing titles.

Works as a **Suruga-ya API**: run it from the Apify console, via REST API, on a schedule, or from an AI agent through [MCP](#use-with-ai-agents-mcp).

### Why this Actor (and not a generic scraper)

Suruga-ya listings encode the details that decide resale value **in Japanese, inside the title**: 帯付き (obi strip included), 未開封 (factory sealed), 初回限定盤 (first-press limited), 駿河屋限定 (Suruga-ya exclusive), ポケモンセンター限定 (Pokémon Center exclusive), 箱説なし (no box/manual)…

Generic scrapers hand you a Japanese string. **This Actor reads it for you:**

```json
"edition_flags": {
  "obi": true,
  "unopened": true,
  "first_press": true,
  "limited_edition": true,
  "surugaya_limited": false,
  "store_exclusive": false,
  "with_bonus": null,
  "junk": false
},
"condition_notes": ["箱説なし"]
```

A sealed first-press CD with obi and a loose disc are different products with 5–10× price gaps. Filtering on these flags is the difference between profitable sourcing and expensive mistakes.

It also handles every Suruga-ya price situation correctly: time sales (regular vs. discounted price), used price ranges, out-of-stock items, and third-party marketplace (マケプレ) offers.

### Input

```json
{
  "keyword": "ポケモンカード 151",
  "category": "toys_hobby",
  "maxResults": 100,
  "inStockOnly": true
}
```

- **keyword** — Japanese works best (`初音ミク フィギュア`), but romaji often matches too (`gundam`, `pokemon`).
- **category** — `all`, `toys_hobby` (figures, trading cards, plamo), `games`, `music`, `video`, `books`, `goods_fashion`, `pc_smartphone`, `doujin`. Advanced: pass a raw `categoryCode` from any suruga-ya.jp URL.
- **inStockOnly** — only items buyable right now from Suruga-ya's main store.

### Output — one normalized record per product

```json
{
  "id": "112000012",
  "title": "ゼルダの伝説 ティアーズ オブ ザ キングダム Nintendo Switch 2 Edition",
  "product_url": "https://www.suruga-ya.jp/product/detail/112000012",
  "image_url": "https://www.suruga-ya.jp/database/photo.php?shinaban=112000012&size=m",
  "category_label": "ニンテンドースイッチ2ソフト",
  "brand": "任天堂",
  "release_date": "2025-06-05",
  "price_new": 7180,
  "price_new_regular": null,
  "price_used": 6600,
  "price_used_max": null,
  "price_used_regular": 6880,
  "price_list": null,
  "is_on_time_sale": true,
  "in_stock": true,
  "stock_status": "in_stock",
  "marketplace": null,
  "edition_flags": {
    "obi": null,
    "unopened": null,
    "first_press": false,
    "limited_edition": false,
    "surugaya_limited": false,
    "store_exclusive": false,
    "with_bonus": null,
    "junk": false
  },
  "condition_notes": [],
  "search_keyword": "ゼルダの伝説",
  "category": "games",
  "page": 1,
  "position": 3,
  "fetched_at": "2026-08-09T01:32:10.676Z"
}
```

| Field | Meaning |
|---|---|
| `id` | Suruga-ya product code (品番) — stable, use it for monitoring |
| `price_new` / `price_used` | Current buy price in JPY, tax included (integer). `price_used` is the low end; `price_used_max` set when a range is shown |
| `price_new_regular` / `price_used_regular` | Pre-discount price during time sales (`is_on_time_sale: true`) |
| `price_list` | Publisher list price (定価) when shown |
| `stock_status` | `in_stock` / `out_of_stock` / `marketplace_only` |
| `marketplace` | Cheapest third-party (マケプレ) offer `{price, item_count}` when the main store is sold out |
| `edition_flags` | See above. `true` = stated, `false` = explicitly negated, `null` = not mentioned |
| `condition_notes` | Raw Japanese condition caveats found in the title (no box, no manual, sun-fading, …) |

### Recipe: JP↔US price-gap (arbitrage) screening

Combine this Actor with a US-side price Actor (TCGPlayer, PriceCharting, eBay sold listings) to compute the spread in one pipeline:

1. Run this Actor: `keyword: "ポケモンカード 151", inStockOnly: true` → Japanese supply price.
2. Run your TCGPlayer/PriceCharting Actor for the same set → US market price.
3. Join and filter, e.g. in a spreadsheet or a few lines of code:

```js
const spreadPct = (usPriceUsd * jpyPerUsd - jp.price_used) / jp.price_used * 100;
// keep rows where spreadPct > 40 && jp.stock_status === 'in_stock'
//   && jp.edition_flags.unopened !== false
```

Typical proxy-buying overhead from Japan (agent fee + domestic + international shipping) is 15–30%, so screen for gaps comfortably above that. `edition_flags` keeps the comparison apples-to-apples — a sealed Japanese box vs. a sealed US box, not a loose one.

### What does it cost?

You pay per result. Examples at $4 per 1,000 results:

| Use case | Results | Cost |
|---|---|---|
| Spot-check one product line | 100 | $0.40 |
| Daily in-stock sweep of a category keyword | 500/day | $2.00/day |
| Full sourcing scan across 20 keywords | 20 × 300 | $2.40 |

One search page fetch yields up to 24 results, so runs are fast and cheap.

### Use with AI agents (MCP)

This Actor works with the [Apify MCP server](https://mcp.apify.com), so Claude, or any MCP-capable agent, can call it as a tool: *"Check what a sealed first-press of X costs at Suruga-ya right now."* The structured output (integer yen, booleans) is designed to be consumed by agents without prompt gymnastics.

### Fair use & legality

- Scrapes only **public product data** (prices, stock, titles). No personal data, no login, no paywalled content.
- Polite by default: sequential fetching with a configurable delay (default 3 s between pages).
- You are responsible for complying with suruga-ya.jp's terms and your local laws when using the data.

### Support

Issues and feature requests are answered quickly — open an issue on the Actor's Issues tab. Planned next: product-code (品番) batch lookup for price/stock monitoring, and product-URL input.

***

## 駿河屋 価格スクレイパー(日本語)

駿河屋(suruga-ya.jp)の検索結果から、**新品・中古価格(税込・整数円)、在庫状況、マケプレ出品、版・状態情報**を正規化した JSON で取得する Apify Actor です。

特徴は、タイトル中の日本語表記(帯付き/未開封/初回限定/駿河屋限定/ポケモンセンター限定/箱説なし 等)を **`edition_flags` / `condition_notes` として構造化**する点です。海外転売・せどりの仕入れ判断や、eBay・TCGPlayer との価格差分析にそのまま使えます。

- 入力: `keyword`(日本語推奨)、`category`、`maxResults`、`inStockOnly`
- タイムセール(通常価格と割引価格の両方)、価格レンジ、品切れ、マケプレにも対応
- リクエスト間隔はデフォルト3秒の逐次アクセス。公開データのみを取得します

# Actor input Schema

## `keyword` (type: `string`):

What to search for on suruga-ya.jp. Japanese works best (e.g. ポケモンカード, 初音ミク フィギュア), but romaji/English often matches too (e.g. pokemon, gundam).

## `category` (type: `string`):

Top-level Suruga-ya category to search within.

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

Overrides Category with a raw suruga-ya.jp category code, e.g. 200 = TV games, 501 = hobby, 700 = books. Find codes in suruga-ya.jp search URLs (?category=...).

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

Stop after this many product records. You are charged per result.

## `inStockOnly` (type: `boolean`):

Skip listings that are out of stock at Suruga-ya's main store (marketplace-only offers are also skipped).

## `requestDelaySecs` (type: `integer`):

Politeness delay between page fetches. One page yields up to 24 results.

## `maxPages` (type: `integer`):

Hard cap on the number of search result pages fetched.

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

Proxies are usually NOT needed — leave disabled. Enable if your runs start getting blocked.

## Actor input object example

```json
{
  "keyword": "ポケモンカード 151",
  "category": "all",
  "maxResults": 100,
  "inStockOnly": false,
  "requestDelaySecs": 3,
  "maxPages": 200,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "keyword": "ポケモンカード 151"
};

// Run the Actor and wait for it to finish
const run = await client.actor("turbulent_noodle/surugaya-price-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 = { "keyword": "ポケモンカード 151" }

# Run the Actor and wait for it to finish
run = client.actor("turbulent_noodle/surugaya-price-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 '{
  "keyword": "ポケモンカード 151"
}' |
apify call turbulent_noodle/surugaya-price-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,turbulent_noodle/surugaya-price-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/W21fa6fm1EFgSHxIl/builds/VL8RcMDp9eEOxHcKy/openapi.json