# Rakuma Japan Sold and Asking Prices — Median, Range (`jpmarketdata/rakuma-japan-price-checker`) Actor

Look up any keyword on Rakuma, Rakuten's flea market in Japan. You get one row: the typical price and the lowest-to-highest range, how many of the listings found are already sold, and the shop versus private seller mix. $0.02 per keyword, no results = no charge. Unofficial.

- **URL**: https://apify.com/jpmarketdata/rakuma-japan-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, 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

## Rakuma Japan Sold and Asking Prices — Median, Range

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

**What it does:** Look up any word on Rakuma, Rakuten's flea market in Japan, and get both what it sold for and what it is listed for today.

**You enter:** one or more search words, in Japanese (`ポケモンカード リザードン`) or English (`leica m6`).

**You get:** from the listings read (40 a page, 3 pages by default, spread over the whole result list): typical price and lowest–highest range in yen and US$, the sold and the still-listed price apart, how many already sold, the shop-versus-private mix, Rakuten point-back.

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

**Example:** enter `leica m6` → 398 matches on Rakuma, 118 listings read from pages 1, 6 and 10, of which 35 are really that camera · typical ¥355,555 · range ¥6,780–3,241,000 · the 15 already sold typically ¥290,000, the 20 still listed ¥576,000 · 43% of them listed by shops (real run, 2026-09-08)

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

### Pricing — $0.02 per keyword

| Event | Price | When |
|---|---|---|
| Keyword price summary | **$0.02** | Per keyword measured |
| Individual listing | **$0.002** | Only if you enable **Include individual listings** |

A default run (1 keyword, summary only) costs **$0.02**. You pay per keyword; there is no monthly fee. **A keyword that returns zero listings of your item is never charged** — and that matters more here than on most sites, because Rakuma answers a word it does not know with unrelated goods rather than with an empty page (see *The word that finds nothing* below). When a keyword is not charged, its listing rows are not produced or charged either. About 12 keywords fit one run at the default depth — after that the run's sampling budget is spent and the remaining words are measured on their first page only (`truncatedForTimeLimit: true`) — and a run also stops at the **$3.00 Maximum cost per run**. Raise either in the run options, or split the list across runs.

### Input

| Field | Example | Notes |
|---|---|---|
| `keywords` | `["leica m6"]` | One or more search words. Japanese and English both work well (`ポケモンカード リザードン`, `leica m6`). Each word costs $0.02 |
| `maxItemsPerKeyword` | `120` | 40–800. Rakuma serves 40 listings a page and has no page-size setting, so this ÷ 40 is the number of pages read per word — 120 is three. Also caps the listing rows |
| `titleMatch` | `"all"` | `all` (default) keeps listings whose title carries every word you typed, `any` keeps those carrying at least one, `off` keeps everything returned. `all` widens to `any` by itself when it keeps none; the row says which was used in `matchMode` |
| `includeSoldOut` | `true` | On by default: already-sold items count towards the headline price. Off prices only what is still on sale — sold items are still counted and still get `soldPriceJpy` |
| `includeIndividualItems` | `false` | Enable to also get one row per listing read (+$0.002 each) |
| `convertToUsd` | `true` | Adds US$ figures at the current exchange rate. A failed lookup never fails the run |

### Sold price and asking price, from the same search

Most Japan flea-market tools give you one or the other. Mercari's public search shows sold items; PayPay Flea's shows only what is on sale. Rakuma's default search returns **both, mixed together**, and marks the sold ones — so one read gives you:

- **`soldPriceJpy`** — what buyers actually paid, over the sold listings among your matches
- **`askingPriceJpy`** — what sellers are asking right now, over the rest
- **`priceJpy`** — both together (or only the still-listed ones if you turn `includeSoldOut` off; `soldOutIncludedInPrice` says which)

Two warnings about reading them:

- **`soldShare` is not a speed of sale.** Nothing on a Rakuma card says *when* it sold, so this is the share of the listings you read that had already gone — not how fast the item moves. It also moves with how deep into the result list you look.
- **The sold and asking figures can cross over.** In the measured run below the sold price (¥290,000) is *below* the asking price (¥576,000), because the recommended order puts expensive unsold stock near the top. That is a fact about the listings, not a discount rate — do not divide one by the other.

### The word that finds nothing

**Rakuma never returns an empty page.** Type a word it does not know and it answers with a few hundred unrelated goods and a perfectly healthy count — measured 2026-09-08, `zzzqqxnotarealproduct` returned 199 matches and forty pairs of earrings. Reported naively that is a confident price for the wrong thing, charged for.

So every listing read is checked against the words you typed, and the row tells you what happened:

| `keywordStatus` | What it means |
|---|---|
| `ok` | Listings matched your words and carried prices — this row has figures, and it is charged |
| `not_found` | Rakuma returned listings, but none of them is your item. `hint` names the next thing to try. **Not charged** |
| `unknown` | Listings matched your words but none showed a price at all. `hint` says so. **Not charged** |

One case sits outside the table: with **Include sold items in the price** turned off, a word whose every match has already sold keeps `keywordStatus: "ok"` — the prices are real and are right there in `soldPriceJpy` — but the headline `priceJpy` comes back empty, `hint` says to turn the switch on, and the row is **not charged**.

`matchedListings` is how many of `sampledListings` counted as your item, so you can always see how much of what came back was noise.

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

Measured on 2026-09-08 (real run, `{"keywords": ["leica m6"], "maxItemsPerKeyword": 120, "titleMatch": "all", "includeSoldOut": true, "includeIndividualItems": false, "convertToUsd": true}`). The whole record, nothing shortened. Three pages were read — 1, 6 and 10 of the ten pages the result set has — and all 35 matching listings turned out to sit on page 1: Rakuma returns 398 listings for those words, but only 35 of them are the camera.

```json
{
  "type": "price_summary",
  "keyword": "leica m6",
  "keywordStatus": "ok",
  "matchMode": "all",
  "currency": "JPY",
  "priceIncludesTax": true,
  "totalListingsFound": 398,
  "totalListingsShownOnPage": 300,
  "reachableListings": 398,
  "pagesSampled": [1, 6, 10],
  "sampledListings": 118,
  "matchedListings": 35,
  "pricedListings": 35,
  "soldOutIncludedInPrice": true,
  "priceBasis": "sample",
  "priceJpy": { "min": 6780, "p25": 18400, "median": 355555, "p75": 611000, "max": 3241000, "average": 507008 },
  "priceUsd": { "min": 43.91, "p25": 119.16, "median": 2302.57, "p75": 3956.84, "max": 20988.72, "average": 3283.38 },
  "exchangeRateJpyUsd": 0.006476,
  "soldPriceJpy": { "min": 6780, "p25": 93950, "median": 290000, "p75": 469000, "max": 1299000, "average": 329186 },
  "askingPriceJpy": { "min": 6780, "p25": 21200, "median": 576000, "p75": 829500, "max": 3241000, "average": 640374 },
  "soldListings": 15,
  "soldShare": 0.4286,
  "shopSellerListings": 15,
  "shopSellerShare": 0.4286,
  "pointBackListings": 10,
  "pointBackMaxRatePct": 3,
  "priceCrossCheckOk": true,
  "relatedKeywords": ["leica フィルムカメラ 一眼レフ", "leica m6 bundled_item", "s2", "s2 新品", "rolex 1908", "rolex", "dior homme"],
  "hint": null,
  "sourceUrl": "https://fril.jp/s?query=leica+m6",
  "checkedAt": "2026-09-08T17:29:20.373799+00:00",
  "truncatedForTimeLimit": false
}
```

With **Include individual listings** on, each listing read is also returned as its own row: `itemId`, `url`, `name`, `priceJpy`, `isSoldOut`, `sellerType` (`shop` or `person`), `pointBackRatePct`, `categoryId` and `matchesQuery`.

### What this Actor does not do

- **No numbers covering every listing.** Rakuma's search cannot be ordered by price — that setting is closed to automated readers by the site's own `robots.txt` — so no position in the result list stands for the whole set. Every price figure covers the listings actually read and says so (`priceBasis: "sample"`)
- **No filtering by price, category, brand, condition or "sold only".** All of those are the same closed settings. What you can narrow is the search word itself and `titleMatch`
- **No sale dates, so no time-to-sell.** A Rakuma card carries no date; `soldShare` is a share of what was read, not a speed
- **No seller identity.** The markup carries the seller's user number; this Actor throws it away and keeps only whether the seller is a business or a private person. No names, no contact details, no seller pages
- **No images and no description text.** Only the listing's own facts (name, price, sold mark, seller type, point-back, category) and the aggregate figures
- **No login-only data.** Everything comes from public search pages, with no account and no cookie
- **Nothing is stored.** Every run reads the site live; nothing is kept between runs

### Notes on the data

- **The count is exact.** `totalListingsFound` comes from Rakuten's own counter, not from the rounded 「約300件中」 the page prints — that rounded number is reported separately as `totalListingsShownOnPage` purely so a divergence between the two shows up instead of passing silently. Verified 2026-09-08: a search declaring 3,158 matches ended on page 79 with 38 cards, and 78 × 40 + 38 = 3,158 exactly
- **Counts drift within the hour** (763,874 → 763,974 on the same word an hour apart), which is why every row is stamped with `checkedAt`
- **Only the first 4,000 matches are readable.** Rakuma stops at page 100; `reachableListings` is `totalListingsFound` capped at 4,000
- **Pages are spread, not taken from the top.** The pages read are stretched evenly over the whole result list, because both the price and the sold share change sharply with depth: measured 2026-09-08 on a 3,158-match search, page 1 was 1 sold out of 40 at a typical ¥97,780 and page 79 was 32 of 38 at ¥8,900. `pagesSampled` lists exactly which pages the row is built from
- **Titles are cut short by the site**, so a word sitting late in a long listing name can be missing from the card. That is why `titleMatch: "all"` widens to `any` on its own when it would otherwise keep nothing, and why the row reports the `matchMode` it ended up using
- **"Sold" means the listing carries Rakuma's own SOLD OUT ribbon.** Flea-market prices are fixed, so that price is what the item actually went for (or its last price, if the seller marked it down first)
- **Prices are in yen and include tax**, and each one is read twice — from the analytics attribute and from the price the page prints — so that a change to Rakuten's tags is reported (`priceCrossCheckOk: false`) rather than quietly returning a wrong number
- **`pointBackMaxRatePct`** is the highest Rakuten point return, in percent, among the matching listings. It is a discount in points, not off the price
- **`relatedKeywords`** is Rakuma's own 「他のお客様はこちらも検索」 list for your word — useful for finding the spelling Japanese sellers actually use. It appears on the first page only, so it can be empty
- Pages are UTF-8 and fully server-rendered; requests are spaced at least 1.5 seconds apart and a run carries a wall-clock budget. If the budget is reached, later keywords are measured on fewer pages and their rows carry `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

- [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)
- [Japan Used Camera & Lens — Dealer Price vs Sold Price](https://apify.com/jpmarketdata/japan-camera-gear-sold-comps)
- [Japan Figure & Gunpla — New Price vs Used Sold Price](https://apify.com/jpmarketdata/japan-figure-gunpla-resale-value)
- [Used iPhone & Android Prices Japan — Dealer vs Sold](https://apify.com/jpmarketdata/japan-phone-resale-value)
- [Yahoo, Mercari & PayPay Japan — Same Item, 3 Prices](https://apify.com/jpmarketdata/japan-resale-cross-market-checker)
- [Mercari & Yahoo Japan Demand — Sold vs Still Listed](https://apify.com/jpmarketdata/japan-sell-through-rate)
- [Pokemon Card Japan Sold Prices — Raw vs Graded per Card](https://apify.com/jpmarketdata/japan-tcg-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 Rakuma**. 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`):

Words to look up on Rakuma, one per entry — Japanese or Latin (`ポケモンカード`, `leica m6`). Each gets a row and is charged $0.02; one that finds nothing is not charged. About 12 fit a run at the default depth, two at 800 listings each; the rest are read from page 1 and marked `truncatedForTimeLimit`. A run also stops at the $3.00 Maximum cost per run — raise that in the run options, or split the run.

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

How many listings each price figure is measured on, 40 to 800. Rakuma serves 40 listings per page and offers no setting for that, so this divided by 40 is the number of pages read per word — 120 is three. A bigger number is a steadier price and a slower run. It is also the cap on listing rows, and each row is charged $0.002 when Include individual listings is on.

## `titleMatch` (type: `string`):

Which listings count as your item and feed the price figures — and the guard on your money: Rakuma answers a word it does not know with a few hundred unrelated goods instead of an empty page, so a word matching none of them comes back marked `not_found` and is not charged. Card titles are cut short by the site, so `all` widens to `any` when it keeps none.

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

On by default: items that have already sold are folded into the headline price, so it covers what buyers paid as well as what sellers are asking. Turn it off to price only what is still on sale. Sold items are counted for you either way (`soldListings`, `soldShare`) and keep their own price figures in `soldPriceJpy`. 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 read — item number, link, name, price, sold mark, shop or private seller, point-back rate, category and whether the title matched your words — at +$0.002 per row. Listings read per keyword sets how many rows that is. A word that finds nothing returns no rows and is charged nothing.

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

Adds US dollar 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. Does not change what a run costs.

## Actor input object example

```json
{
  "keywords": [
    "leica m6"
  ],
  "maxItemsPerKeyword": 120,
  "titleMatch": "all",
  "includeSoldOut": true,
  "includeIndividualItems": false,
  "convertToUsd": true
}
```

# Actor output Schema

## `priceSummaries` (type: `string`):

One row per search word: the typical price and the lowest-to-highest range in yen and US$, the price of what already sold and of what is still listed side by side, how many of the listings read had already sold, and how many came from shops rather than private sellers.

# 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": [
        "leica m6"
    ],
    "maxItemsPerKeyword": 120,
    "titleMatch": "all",
    "includeSoldOut": true,
    "includeIndividualItems": false,
    "convertToUsd": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("jpmarketdata/rakuma-japan-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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": ["leica m6"],
    "maxItemsPerKeyword": 120,
    "titleMatch": "all",
    "includeSoldOut": True,
    "includeIndividualItems": False,
    "convertToUsd": True,
}

# Run the Actor and wait for it to finish
run = client.actor("jpmarketdata/rakuma-japan-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": [
    "leica m6"
  ],
  "maxItemsPerKeyword": 120,
  "titleMatch": "all",
  "includeSoldOut": true,
  "includeIndividualItems": false,
  "convertToUsd": true
}' |
apify call jpmarketdata/rakuma-japan-price-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jpmarketdata/rakuma-japan-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 <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/7Pn7dLwG0iXhcFySF/builds/nZKts43aMNdlVvSwH/openapi.json