# KOMEHYO Japan Luxury Resale Prices by Condition (`jpmarketdata/komehyo-luxury-market-checker`) Actor

Type a brand or model and get what KOMEHYO, Japan's largest second-hand luxury chain, asks for it today. Returns typical price and lowest–highest, in-stock count, new vs used (S/A/B) mix, how many just sold out, and which stores hold them. $0.02 per keyword, no results = no charge. Unofficial.

- **URL**: https://apify.com/jpmarketdata/komehyo-luxury-market-checker.md
- **Developed by:** [h ichi](https://apify.com/jpmarketdata) (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 $20.00 / 1,000 keyword analyzeds

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

## KOMEHYO Japan Luxury Resale Prices by Condition

> **Unofficial** — independent tool, **not affiliated with, endorsed by, or sponsored by KOMEHYO**. It reads only publicly visible pages. Support, reliability guarantees and the full disclaimer are at the bottom of this page.

**What it does:** Type a brand or model and get what KOMEHYO, Japan's largest second-hand luxury chain, is asking for it today.

**You enter:** one brand or model, Japanese or Latin — `ロレックス` or `Hermes Birkin`. Both find the same items.

**You get:** how many are in stock, the typical price and the lowest–highest range in yen and USD, how many just sold out, exact new / used S / A / B counts, new arrivals and reduced items, and how many each of the 19 branches holds. Optional: one row per listing.

**Price:** $0.02 per keyword. +$0.002 per listing if you also want the list. No results = no charge.

**Example:** enter `ロレックス` → 1,179 in stock · typical ¥1,200,000 (about $7,771) · range ¥330,000–11,500,000 · 220 more had sold out in the same search · 14 new, 3 used S, 811 used A, 351 used B · 321 of them at the Nagoya flagship (real run, 2026-09-08)

> Unofficial — not affiliated with KOMEHYO. Reads public pages only.

### Pricing — $0.02 per keyword

| Event | Price | When |
|---|---|---|
| Keyword summary | **$0.02** | Once per keyword, when the search returned something |
| Individual listing | **$0.002** | Only if you turn on **Include individual listings** |

A default run is one keyword, summary only, and costs **$0.02** — six page reads, about 10 seconds. You pay per keyword; there is no monthly fee. **A keyword that returns zero listings is never charged.**

### Input

| Field | Example | Notes |
|---|---|---|
| `keyword` | `"ロレックス"` | One brand or model. Japanese and Latin spellings hit the same index (`rolex` and `ロレックス` both returned 1,179 items on 2026-09-08). Charged $0.02 |
| `condition` | `"all"` | `all`, `new`, `used_s`, `used_a`, `used_b`. Narrows every number in the record to one of KOMEHYO's own condition labels |
| `includeSoldOut` | `false` | Off: sold-out items are counted but stay out of the price figures. On: they join them. Either way `totalListingsFound` counts only what is in stock and `totalIncludingSoldOut` counts both |
| `maxItems` | `50` | 1–250 listing rows, read 50 at a time. Only matters when the row toggle is on (+$0.002 each) |
| `itemOrder` | `"price_asc"` | `price_asc`, `price_desc`, `newest` — the order of the listing rows. The summary is always read cheapest-first |
| `includeIndividualItems` | `false` | Turn on to also get every listing as its own row (+$0.002 each) |
| `convertToUsd` | `true` | Adds USD figures at the current rate. A failed lookup never fails the run |

### Do the numbers cover everything, or only what was read?

Every record carries **`priceBasis`**, so you never have to guess:

| `priceBasis` | What it means |
|---|---|
| **`population`** | The price figures describe **every matching listing**, not a sample. Either the whole result set fitted on the page read, or the middle values were read at their exact position in KOMEHYO's cheapest-first order |
| **`sample`** | The figures cover only the listings actually read (`sampledListings` says how many). You get this when KOMEHYO's cheapest-first order stops being cheapest-first, or when the run hits its time limit |
| **`null`** | Nothing had a price — there is nothing for a label to cover |

The counts are a separate matter and are always exact: `totalListingsFound`, `totalIncludingSoldOut`, `soldOutCount`, `conditionMix`, `newArrivalsCount`, `onSaleCount`, `priceBands` and `storeCounts` are KOMEHYO's own numbers for the whole search, printed next to its own filters, not tallies of the listings read. Measured on 2026-09-08 for `ロレックス`: the four condition counts added up to 1,179 — the hit count, to the item. The run re-checks that on every keyword and reports the result as `conditionMixMatchesTotal`.

`average` inside `priceJpy` is `null` whenever `priceBasis` is `population`. The middle values are read at their exact position in the price order, which gives the typical price and the range for every listing — but an average cannot be recovered that way, and averaging the pages that happened to be read would be a smaller number wearing a bigger label.

### What "sold out" means here

Running the same search with sold-out items included returns a larger count; the difference is `soldOutCount`. On 2026-09-08, `ロレックス` had 1,179 in stock and 1,399 including sold-out ones — 220 pieces, 15.7% of the wider set, had left the shelf. KOMEHYO does not publish a sale date, and how long a sold-out item stays listed has not been measured, so read this as **turnover pressure on that keyword**, not as "220 sold this week".

The two counts keep their meaning whatever the toggle says: `totalListingsFound` is what is on the shelf and `totalIncludingSoldOut` is that plus what has left it. What the toggle moves is which of the two the **price** figures describe, and `soldOutIncludedInPrices` says which it was.

### Output example (`type: "luxury_market_summary"`)

Measured on 2026-09-08 (real run, `{"keyword": "ロレックス", "condition": "all", "includeSoldOut": false, "maxItems": 50, "itemOrder": "price_asc", "includeIndividualItems": false}`). The whole record, nothing shortened.

```json
{
  "type": "luxury_market_summary",
  "keyword": "ロレックス",
  "keywordStatus": "ok",
  "conditionFilter": "all",
  "soldOutIncludedInPrices": false,
  "totalListingsFound": 1179,
  "totalIncludingSoldOut": 1399,
  "soldOutCount": 220,
  "soldOutShare": 0.1573,
  "sampledListings": 250,
  "sortUsed": "price_asc",
  "currency": "JPY",
  "priceIncludesTax": true,
  "priceJpy": {
    "min": 330000,
    "p25": 950000,
    "median": 1200000,
    "p75": 1850000,
    "max": 11500000,
    "average": null
  },
  "priceBasis": "population",
  "priceUsd": {
    "min": 2137.08,
    "p25": 6152.2,
    "median": 7771.2,
    "p75": 11980.6,
    "max": 74474.0,
    "average": null
  },
  "exchangeRateJpyUsd": 0.006476,
  "conditionMix": {
    "new": 14,
    "usedS": 3,
    "usedA": 811,
    "usedB": 351
  },
  "conditionMixMatchesTotal": true,
  "newArrivalsCount": 129,
  "onSaleCount": 103,
  "priceBands": [
    {
      "label": "¥250,001〜¥500,000",
      "minJpy": 250001,
      "maxJpy": 500000,
      "count": 15
    },
    {
      "label": "¥500,001〜",
      "minJpy": 500001,
      "maxJpy": null,
      "count": 1164
    }
  ],
  "storeCounts": [
    {
      "store": "名古屋本館",
      "count": 321
    },
    {
      "store": "KOMEHYO SHINJUKU",
      "count": 313
    },
    {
      "store": "梅田店",
      "count": 123
    },
    {
      "store": "【新店】KOMEHYO OSAKA SHINSAIBASHI",
      "count": 78
    },
    {
      "store": "KOMEHYO GINZA",
      "count": 75
    },
    {
      "store": "心斎橋店",
      "count": 50
    },
    {
      "store": "【新店】KOMEHYO YOKOHAMA",
      "count": 49
    },
    {
      "store": "KOMEHYO SHIBUYA",
      "count": 40
    },
    {
      "store": "【新店】KOMEHYO FUKUOKA TENJIN",
      "count": 40
    },
    {
      "store": "神戸三宮店",
      "count": 28
    },
    {
      "store": "名駅店",
      "count": 20
    },
    {
      "store": "天神店",
      "count": 16
    },
    {
      "store": "ららぽーと愛知東郷店",
      "count": 7
    },
    {
      "store": "京都新京極店",
      "count": 5
    },
    {
      "store": "広島本通店",
      "count": 4
    },
    {
      "store": "【新店】KOMEHYO VINTAGE TOKYO atelier",
      "count": 3
    },
    {
      "store": "あべの店",
      "count": 3
    },
    {
      "store": "日本橋店",
      "count": 3
    },
    {
      "store": "KOMEHYO GINZA PLUS",
      "count": 1
    }
  ],
  "hint": null,
  "sourceUrl": "https://komehyo.jp/search/?q=%E3%83%AD%E3%83%AC%E3%83%83%E3%82%AF%E3%82%B9&sortKey=02",
  "checkedAt": "2026-09-08T12:38:29.802205+00:00",
  "truncatedForTimeLimit": false
}
```

With **Include individual listings** on you also get one `type: "luxury_listing"` row per item: `goodsNo`, `productId`, `url`, `name`, `brand`, `conditionLabel` + `conditionCode`, `priceJpy`, `originalPriceJpy`, `discountPct`, `store`, `isSoldOut`, `isNewArrival`, `isOnSale`.

### When a keyword comes back empty

`keywordStatus` is `ok` as soon as KOMEHYO returns items, `not_found` when the shop's own page says there are none, and `unknown` in the rare case where items exist but not one of the listings read carried a price. The two empty answers each get a `hint` naming the next thing to try (`null` otherwise). **Neither is charged.** Measured 2026-09-08: `zzzqqxnotarealproduct` finished in one page read with `totalListingsFound: 0`, `keywordStatus: "not_found"` and no charge.

### What this Actor does not do

- **No sold prices.** KOMEHYO is a shop: these are **asking** prices including tax, what a buyer pays today. `soldOutCount` says how many listings left the shelf, not what they went for
- **No images and no item descriptions.** KOMEHYO reserves those; this Actor returns statistics plus the plain facts of a listing (name, brand, condition, price, branch) and the product link
- **No listing dumps by default.** The product is the statistic; individual listings are opt-in and separately priced
- **No login-only data.** Everything comes from public search pages — no account, no cookie
- **No buyer or seller details.** KOMEHYO sells its own stock; there are no third-party sellers, and nothing beyond the branch name identifies anyone
- **Nothing is stored.** Every run reads the site live; nothing is kept between runs
- **One keyword per run.** Two brands means two runs

### Notes on the data

- **Everything is measured live and nothing is guessed.** The default run makes six page reads: page 1 of the cheapest-first order, the same search with sold-out items included, three jumps to the pages holding the middle values, and page 1 of the most-expensive-first order for the maximum. 250 listing rows in the least favourable order takes it to 11 reads (measured 2026-09-08, 22 seconds)
- **Prices include tax** (`priceIncludesTax: true`); the site prints them as `￥930,000(税込)`. `currency` is `JPY`, and USD figures are added at the rate in `exchangeRateJpyUsd`
- **50 listings per page, and the shop offers no way to change that.** Page size is fixed, so a bigger row limit costs more page reads, not bigger pages
- **The order matters and is always stated.** KOMEHYO's default order is a recommendation order whose first page ran ¥800,000–6,300,000 — not a price order at all. This Actor always asks for cheapest-first for the summary and reports it as `sortUsed`, and it re-checks that the order really is cheapest-first before calling the price figures `population`
- **The condition labels are KOMEHYO's own** (`新品` / `中古品S` / `中古品A` / `中古品B`), returned per listing as both the label and the code the site filters on, so a re-labelling on the shop's side shows up instead of quietly changing what a number means
- **Branch counts can fall a little short of the total.** Measured 2026-09-08 with sold-out items included, in the same capture as the example above: the branches added up to 1,396 against 1,399 — three sold pieces no longer name a branch. In stock they matched exactly (1,179). Only the condition counts are checked against the total, and a branch whose count cannot be read comes back as `null` rather than dropping out of the list
- **UTF-8 throughout**, no login and no cookie. Requests are spaced 1.5 s apart (`robots.txt` sets no delay for general readers and disallows nothing), and the run carries a wall-clock limit; if it is reached the price figures fall back to the listings read and the record says `truncatedForTimeLimit: true`

### If something goes wrong

- **Wrong number or a failed run?** Open a ticket on the **Issues** tab. I read every one and reply within 2 business days (Japan time).
- **You never get a fake "empty" result.** If the site can't be read, the run fails and says so.
- **No results = no charge.** You only pay for results you actually get.
- **Checked every week.** An automatic test runs this tool weekly; if the site changes, I fix it.
- **Public pages only.** No login, no personal data, and it goes easy on the site.

### More tools by the same author

- [BookOff Japan Used Manga, Books, CDs — Price & Stock](https://apify.com/jpmarketdata/bookoff-market-checker)
- [@cosme Japan Beauty Ranking — Top 50 Ratings & Prices](https://apify.com/jpmarketdata/cosme-beauty-market-checker)
- [Digimart Japan Used Guitar & Instrument Prices](https://apify.com/jpmarketdata/digimart-instrument-market-checker)
- [Fujiya Camera Japan Used Camera Prices by Condition](https://apify.com/jpmarketdata/fujiya-camera-market-checker)
- [HobbyLink Japan Gunpla & Figure Prices + Stock Status](https://apify.com/jpmarketdata/hlj-hobby-market-checker)
- [Iosys Japan Used iPhone & Phone Prices by Condition](https://apify.com/jpmarketdata/iosys-phone-market-checker)
- [JACKROAD Japan Watch Prices — New, Used, Vintage, In Stock](https://apify.com/jpmarketdata/jackroad-watch-price-checker)
- [Kakaku.com Japan Lowest Prices — Shops, Rank, Rating](https://apify.com/jpmarketdata/kakaku-japan-price-checker)
- [Mercari Japan Sold Prices — What Items Really Sell For](https://apify.com/jpmarketdata/mercari-japan-price-checker)
- [Yahoo! Auctions Japan Sold Prices — Median, Range, Bids](https://apify.com/jpmarketdata/yahoo-auction-sold-comps)

All tools (Japan marketplaces, real estate, jobs, racing, prediction markets): <https://apify.com/jpmarketdata>

### Disclaimer

Unofficial, independent tool — **not affiliated with, endorsed by, or sponsored by KOMEHYO**. Product names and logos belong to their owners and only say where the data comes from. Data is read from public pages, for market research; check before you act on it.

# Actor input Schema

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

What to look up at KOMEHYO, in Japanese or in Latin letters: `ロレックス`, `rolex` and `Hermes Birkin` all work, and the Japanese and the Latin spelling of a brand return the same items. This word decides everything the run reports — the number in stock, the price figures, the new/used split and the branch list. Each keyword is charged $0.02, and a keyword that finds nothing is not charged.

## `condition` (type: `string`):

Which items get measured. Every condition covers the whole search; the other four narrow it to one of KOMEHYO's own condition labels, and then the item count, the price figures and the branch list all describe that condition alone. Narrowing does not change what a run costs.

## `includeSoldOut` (type: `boolean`):

Off by default: items that have already sold are counted for you (`soldOutCount` and `soldOutShare`) but stay out of the price figures. Turn it on to fold them in, so the typical price and the lowest-highest range describe what recently sold as well as what is still on the shelf. Does not change what a run costs.

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

How many listing rows come back when Include individual listings is on, 1 to 250, read 50 at a time. Each row is charged $0.002 on top of the $0.02 for the keyword; 250 rows stays far below the $3.00 Maximum cost per run. Every extra 50 rows is one more page read, so a high number makes the run slower. With the toggle off this changes nothing: the summary is always read the same way.

## `itemOrder` (type: `string`):

The order of the listing rows when Include individual listings is on. It decides which listings you see first and which ones fall outside the row limit. The summary is always read cheapest-first whatever you pick here, so this does not move the price figures, and it does not change what a run costs.

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

Off by default: a run costs a flat $0.02 for the keyword summary. Turn it on to also get one row per listing — name, brand, condition label, price, pre-discount price, branch, sold-out and new-arrival marks and the product link — at +$0.002 per row.

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

Adds USD figures next to the yen ones at the current exchange rate (open.er-api.com). A failed rate lookup never fails the run — the yen numbers simply come back on their own.

## Actor input object example

```json
{
  "keyword": "ロレックス",
  "condition": "all",
  "includeSoldOut": false,
  "maxItems": 50,
  "itemOrder": "price_asc",
  "includeIndividualItems": false,
  "convertToUsd": true
}
```

# Actor output Schema

## `marketSummaries` (type: `string`):

One row per keyword: how many pieces KOMEHYO has in stock, the typical price and the range in yen and USD, how many just sold out, and the new / used S / A / B split.

# 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": "ロレックス",
    "condition": "all",
    "includeSoldOut": false,
    "maxItems": 50,
    "itemOrder": "price_asc",
    "includeIndividualItems": false,
    "convertToUsd": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("jpmarketdata/komehyo-luxury-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 = {
    "keyword": "ロレックス",
    "condition": "all",
    "includeSoldOut": False,
    "maxItems": 50,
    "itemOrder": "price_asc",
    "includeIndividualItems": False,
    "convertToUsd": True,
}

# Run the Actor and wait for it to finish
run = client.actor("jpmarketdata/komehyo-luxury-market-checker").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": "ロレックス",
  "condition": "all",
  "includeSoldOut": false,
  "maxItems": 50,
  "itemOrder": "price_asc",
  "includeIndividualItems": false,
  "convertToUsd": true
}' |
apify call jpmarketdata/komehyo-luxury-market-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jpmarketdata/komehyo-luxury-market-checker"
        }
    }
}

```

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/40g7dXsEzKhV0QSOw/builds/xD9vgOtjca4Sjwgd3/openapi.json