# JACKROAD Japan Watch Prices — New, Used, Vintage, In Stock (`jpmarketdata/jackroad-watch-price-checker`) Actor Type a watch model or reference number like 116500LN and get what JACKROAD in Tokyo asks for it. Returns the typical price and lowest–highest in yen, how many are new, used or vintage, how many are in stock, and how many are already sold out. $0.02 per keyword, no results = no charge. Unofficial. - **URL**: https://apify.com/jpmarketdata/jackroad-watch-price-checker.md - **Developed by:** [h ichi](https://apify.com/jpmarketdata) (community) - **Categories:** E-commerce, Automation, Developer tools - **Stats:** 2 total users, 1 monthly users, 80.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 ## JACKROAD Japan Watch Prices — New, Used, Vintage, In Stock **What it does:** Type a watch model or reference number and get what JACKROAD in Tokyo asks for it — the typical price, the range, and what is still in stock. **You enter:** one or more watch names, e.g. `116500LN`, `daytona`, or `ロレックス`. **You get:** JACKROAD's own count of matching listings, the typical price and lowest–highest in yen and USD (from the first 120 listings), how many are new, used or vintage, and how many are in stock, on request or already sold out. **Price:** $0.02 per keyword. +$0.002 per row if you also want the list. No results = no charge. **Example:** enter `daytona` → 231 listings, 120 read · typical ¥2,980,000, from ¥1,380,000 to ¥40,800,000 · 221 new, 7 used, 3 vintage · 25 in stock, 201 already sold out (87%) (real run, 2026-09-08) > Unofficial — not affiliated with JACKROAD. Reads public pages only. ### Pricing — $0.02 per keyword | Event | Price | When | |---|---|---| | Keyword market summary | **$0.02** | Per keyword looked up | | Individual listing | **$0.002** | Only if you turn on **Include individual listings** | A default run (1 keyword, summary only) costs **$0.02** and reads 6 pages of the shop. You pay per keyword; there is no monthly fee. **A keyword that returns zero listings is never charged.** ### Input | Field | Example | Notes | |---|---|---| | `keywords` | `["daytona"]` | A reference number (`116500LN`), a model name (`daytona`) or a brand (`rolex`, `ロレックス`). Japanese and Latin spellings both work. Each keyword costs $0.02 | | `watchesOnly` | `true` | On by default: only the watch section is counted, so jewellery, bags and apparel that match the same word stay out | | `conditionFilter` | `"all"` | `all` / `new` / `used` / `vintage`. Narrows what the prices describe. The three counts come back either way | | `availabilityFilter` | `"all"` | `all` / `in_stock` / `sold_out`. Narrows what the prices describe. The three counts come back either way | | `maxItemsPerKeyword` | `120` | 1–360, read 120 at a time. How many listings the price figures are measured on, and the cap on rows (+$0.002 each) | | `itemOrder` | `"price_asc"` | `price_asc` / `price_desc` / `newest`. Which listings are read first, so it moves the price figures on a keyword with more listings than you measure | | `priceLadder` | `[3000000]` | Up to 6 yen limits. Each one returns the shop's own count of everything at or below it, as `priceBands`. Empty = no bands | | `includeIndividualItems` | `false` | Turn on to also get one row per listing (+$0.002 each) | | `convertToUsd` | `true` | Adds USD figures at the current exchange rate. A failed lookup never fails the run | ### Which numbers cover every listing, and which cover only the ones read? The record says so itself, field by field: | Field | What it covers | |---|---| | `totalListingsFound`, `conditionMix`, `availability`, `inStockCount`, `soldOutShare`, `priceBands` | **Every matching listing.** These are JACKROAD's own counts, each read from the shop's own filtered result, not tallied from the listings read | | `priceJpy` / `priceUsd` | The listings actually read — `priceBasis` is `sample` when there are more than you measured, and `population` when the read covered them all | | `inStockPriceJpy` | The in-stock listings among those read — `inStockPriceBasis` says `population` when every in-stock listing was covered | | `brandMix`, `topReferences`, `genderMix` | The listings actually read (`sampledListings` says how many) | `countsConsistent` is the cross-check: it is `true` when the new/used/vintage counts and the in-stock/on-request/sold-out counts both still add up to `totalListingsFound`, which is what they did on every measurement so far (231 = 221 + 7 + 3 = 25 + 5 + 201). ### When a keyword comes back empty `keywordStatus` is `ok` as soon as JACKROAD returns listings, `not_found` when the shop itself says there are none, and `unknown` in the rare case where it reports listings but none of the cards read carried a price. `hint` then names the next thing to try in one sentence, and is `null` otherwise. **A keyword that returns nothing is never charged.** ### Output example (`type: "watch_market_summary"`) Measured on 2026-09-08 (real run, `{"keywords": ["daytona"], "watchesOnly": true, "conditionFilter": "all", "availabilityFilter": "all", "maxItemsPerKeyword": 120, "itemOrder": "price_asc", "priceLadder": [], "includeIndividualItems": false}`). The whole record, nothing shortened. ```json { "type": "watch_market_summary", "keyword": "daytona", "keywordStatus": "ok", "watchesOnly": true, "conditionFilter": "all", "availabilityFilter": "all", "totalListingsFound": 231, "measuredListingsFound": 231, "sampledListings": 120, "sortUsed": "price_asc", "currency": "JPY", "priceIncludesTax": true, "priceJpy": { "min": 1380000, "p25": 2300000, "median": 2980000, "p75": 4380000, "max": 40800000, "average": 5381483 }, "priceBasis": "sample", "priceUsd": { "min": 8936.88, "p25": 14894.8, "median": 19298.48, "p75": 28364.88, "max": 264220.8, "average": 34850.48 }, "exchangeRateJpyUsd": 0.006476, "conditionMix": { "new": 221, "used": 7, "vintage": 3 }, "availability": { "inStock": 25, "onRequest": 5, "soldOut": 201 }, "inStockCount": 25, "soldOutShare": 0.8701, "inStockPriceJpy": { "min": 3980000, "median": 9180000, "max": 35000000 }, "inStockPriceBasis": "population", "priceBands": [], "brandMix": [ { "brand": "ロレックス", "count": 120 } ], "topReferences": [ { "referenceNo": "116519", "count": 11, "medianPriceJpy": 2380000 }, { "referenceNo": "116518", "count": 8, "medianPriceJpy": 2100000 }, { "referenceNo": "116528", "count": 7, "medianPriceJpy": 2980000 }, { "referenceNo": "126518LN", "count": 7, "medianPriceJpy": 9180000 }, { "referenceNo": "116523", "count": 6, "medianPriceJpy": 1380000 }, { "referenceNo": "116503", "count": 5, "medianPriceJpy": 3580000 }, { "referenceNo": "116509", "count": 4, "medianPriceJpy": 3580000 }, { "referenceNo": "116515", "count": 4, "medianPriceJpy": 2580000 }, { "referenceNo": "116518G", "count": 3, "medianPriceJpy": 2300000 }, { "referenceNo": "116519G", "count": 3, "medianPriceJpy": 2780000 } ], "genderMix": { "mens": 120, "ladies": 0, "boys": 0, "unisex": 0 }, "countsConsistent": true, "hint": null, "sourceUrl": "https://www.jackroad.co.jp/shop/goods/search.aspx?search=x&keyword=daytona&type=0&sort=sp-gn-ic1d-gd&ps=120", "checkedAt": "2026-09-08T17:06:17.813748+00:00", "truncatedForTimeLimit": false } ``` `priceBands` is empty here because the example run asked for no price limits; with `priceLadder: [3000000]` the same keyword returns `[{"upToJpy": 3000000, "count": 62, "cumulativeShare": 0.2684}]` — JACKROAD's own count of everything at or below ¥3,000,000, which matched the 62 such listings counted one by one across all 231 results on 2026-09-08. ### What this Actor does not do - **No sold prices.** These are asking prices. A watch marked sold out is a listing JACKROAD had up at that price and no longer sells — the shop never publishes what it actually went for, and a listing withdrawn for any other reason looks the same - **No arrival dates and no pre-discount price.** Those live on the individual product pages, which this Actor does not open — the numbers all come from search result pages - **No listing rows by default.** The product is the summary; individual listings are opt-in and separately priced - **No images, no product descriptions, no reviews.** Only brand, model name, reference number, condition, availability, price, case size, movement, gender and the product link - **Nothing is stored.** Every run reads the site live; nothing is kept between runs - **No personal data.** JACKROAD is a single dealer — there are no third-party sellers to profile ### Notes on the data - **The shop's pages and its search box use Japan's Shift\_JIS character set, and so does the search text it is sent.** A Japanese word sent the ordinary way (UTF-8) comes back as HTTP 200 with **zero results** — a silently wrong answer. This Actor converts every keyword for you (measured 2026-09-08: `ロレックス` converted → 2,788 listings, the same word unconverted → 0), and a character that character set cannot carry stops the run with a message instead of being quietly swapped for another one - **Asking for a page past the last one also returns "0 results"** — the same shape as a keyword that genuinely matches nothing (measured on page 3 of a 231-listing result at 120 per page). The last page is worked out from page 1 and never exceeded, so an empty answer here always means an empty result - **The hit count is the shop's own.** It is read from the count the search page prints (twice, in two different places); a page carrying neither stops the run rather than being reported as zero - **"In stock" includes the watches marked 商談中 (under negotiation)** — that is how JACKROAD's own in-stock count works, and `inStockCount` matches it exactly (25 of 231 for `daytona`, checked card by card). Cheapest-first order is four availability groups one after another, each sorted inside itself, so the in-stock watches are **not** all at the top of the list - **Sold-out listings are the majority and stay visible.** 201 of the 231 `daytona` listings (87%) had already sold and still carry the price they were asking, which is the point: you can see what this dealer asked and what moved - **New / used / vintage are the shop's own three sections** and every listing is in exactly one of them; grey-market new watches sit next to used and vintage ones under the same reference number (221 / 7 / 3 for `daytona`) - **Speed:** one search page is about 1.1 MB and takes 4-5 seconds, so reads run three at a time, at least 1.5 s apart (the site's `robots.txt` asks for no particular spacing). The example run above made 6 reads in 15 seconds. A run carries a wall-clock budget; if it is reached, later keywords are measured over fewer pages and say so via `truncatedForTimeLimit` - **Page size is 120, the largest the shop offers**, so 120 listings is one read, 360 is three. A reference number usually returns fewer than 120 and is then covered completely (`priceBasis: "population"`) - **The site caps a search at 20,000 listings**; a single brand word can approach that (`ロレックス` returned 2,788), so a reference number or a model name gives a sharper answer than a brand ### 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) - [Kakaku.com Japan Lowest Prices — Shops, Rank, Rating](https://apify.com/jpmarketdata/kakaku-japan-price-checker) - [KOMEHYO Japan Luxury Resale Prices by Condition](https://apify.com/jpmarketdata/komehyo-luxury-market-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): ### Disclaimer Unofficial, independent tool — **not affiliated with, endorsed by, or sponsored by JACKROAD**. 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 ## `keywords` (type: `array`): One line per watch to look up at JACKROAD: a reference number (`116500LN`), a model name (`daytona`), or a brand (`rolex` or `ロレックス`). Japanese and Latin spellings both work, and Japanese words are sent in the shop's own Japanese character set for you. Each keyword is charged $0.02, and a keyword that finds nothing is not charged. ## `watchesOnly` (type: `boolean`): On by default: only JACKROAD's watch section is counted, so the jewellery, bags and apparel that happen to match the same word stay out of every number. Turn it off to count the whole shop, which usually raises the item count and widens the lowest-highest range. Does not change what a run costs. ## `conditionFilter` (type: `string`): Which listings the price figures are measured on. Every condition covers the whole result; the other three narrow it to JACKROAD's own new, used or vintage section. The new / used / vintage counts come back either way, so narrowing only changes what the prices describe. Does not change what a run costs. ## `availabilityFilter` (type: `string`): Which listings the price figures are measured on. Everything listed includes the sold-out watches, which stay on the site with the price they were asking. The in stock / on request / sold out counts come back either way, so narrowing only changes what the prices describe. Does not change what a run costs. ## `maxItemsPerKeyword` (type: `integer`): How many listings the price figures are measured on, 1 to 360, read 120 at a time. With Include individual listings on it is also the cap on how many rows come back, and each row is charged $0.002 on top of the $0.02 for the keyword; 360 rows stays far below the $3.00 Maximum cost per run. Every extra 120 is one more read, so a high number makes the run slower. ## `itemOrder` (type: `string`): The order JACKROAD returns the listings in; it comes back as `sortUsed`. It decides which listings are read first and so which ones fall inside the limit above, which moves the price figures whenever a keyword has more listings than you measure. The shop's own default order is never used, because it is not a price order. Does not change what a run costs. ## `priceLadder` (type: `array`): Upper limits in yen, at most 6, e.g. `[1000000, 3000000, 10000000]`. For each one you get JACKROAD's own count of every listing at or below that price, as `priceBands` — a count of the whole result, not of the listings read. Leave it empty for no bands. Each limit is one more read, so a long list makes the run slower. Does not change what a run costs. ## `includeIndividualItems` (type: `boolean`): Off by default: a run costs a flat $0.02 per keyword summary. Turn it on to also get one row per listing — brand, model name, reference number, new / used / vintage, in stock or sold out, price in yen, case size, movement 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 { "keywords": [ "daytona" ], "watchesOnly": true, "conditionFilter": "all", "availabilityFilter": "all", "maxItemsPerKeyword": 120, "itemOrder": "price_asc", "priceLadder": [], "includeIndividualItems": false, "convertToUsd": true } ``` # Actor output Schema ## `watchMarketSummaries` (type: `string`): What JACKROAD in Tokyo is asking for one model or reference number: how many are listed, the typical price and the lowest-highest range in yen and USD, how many are new, used or vintage, and how many are in stock or already sold out. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "keywords": [ "daytona" ], "watchesOnly": true, "conditionFilter": "all", "availabilityFilter": "all", "maxItemsPerKeyword": 120, "itemOrder": "price_asc", "priceLadder": [], "includeIndividualItems": false, "convertToUsd": true }; // Run the Actor and wait for it to finish const run = await client.actor("jpmarketdata/jackroad-watch-price-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "keywords": ["daytona"], "watchesOnly": True, "conditionFilter": "all", "availabilityFilter": "all", "maxItemsPerKeyword": 120, "itemOrder": "price_asc", "priceLadder": [], "includeIndividualItems": False, "convertToUsd": True, } # Run the Actor and wait for it to finish run = client.actor("jpmarketdata/jackroad-watch-price-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 '{ "keywords": [ "daytona" ], "watchesOnly": true, "conditionFilter": "all", "availabilityFilter": "all", "maxItemsPerKeyword": 120, "itemOrder": "price_asc", "priceLadder": [], "includeIndividualItems": false, "convertToUsd": true }' | apify call jpmarketdata/jackroad-watch-price-checker --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,jpmarketdata/jackroad-watch-price-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 ` 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/TSv0Gaq9yP2A5cU1F/builds/6N8AgGITgZAHRkRRx/openapi.json