# Mercari Japan & Yahoo Auctions Scraper – メルカリ ヤフオク Sold Prices (`deadc0dex/mercari-yahoo-auctions-scraper`) Actor

Japan resale scraper API, no login: Mercari Japan listings & sold items, Mercari Shops, Yahoo Auctions live & sold (ヤフオク落札), Yahoo Flea Market, Rakuma. Item details, seller items & profiles, sold comps (median, p25/p75, days to sell). Filters, JPY→USD, delta. $0.002/listing.

- **URL**: https://apify.com/deadc0dex/mercari-yahoo-auctions-scraper.md
- **Developed by:** [AsiaData](https://apify.com/deadc0dex) (community)
- **Categories:** E-commerce, Automation, AI
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 listings

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Mercari Japan & Yahoo Auctions Scraper – メルカリ ヤフオク Sold Prices

**Japan resale data in one API call, no login:** Mercari Japan listings and sold items (incl. Mercari Shops), Yahoo! Auctions live and sold (ヤフオク 落札相場), Yahoo! Flea Market (PayPayフリマ) and Rakuma (ラクマ). Item details, seller items and profiles (Mercari and Yahoo! Auctions), Mercari seller reviews, and **sold comps**: median, p25/p75, days to sell and sell-through per keyword and market.

| What it returns | What you give it | Price |
|---|---|---|
| `listing` rows: market, title, price (JPY + converted), status, condition, brand, seller, sold date, bids, end time, url | `keywords` (Japanese or English) + `markets` + `status` (on_sale / sold / all) | **$0.002 / listing** |
| `item` rows: + description, photos (`imageCount` = total), shipping, seller rating, bids, auction end | `urls` / `ids` of any of the 5 markets | **$0.004 / item** |
| `seller` rows: ratings good/normal/bad, rating %, listings, verified (+ followers on Mercari) | `users` (Mercari or Yahoo! Auctions seller id or profile URL) | **$0.005 / seller** |
| `comps` rows: sample size, median, mean, p25, p75, min, max, median days to sell, sold/day, active listings, sell-through | `operation: "sold_comps"` + `keywords` | **$0.01 / keyword × market** |
| `review` rows: good/normal/bad, message, date | `operation: "seller_reviews"` + `users` | **$0.0012 / review** |
| `insight` row: recommended / quick-sale / premium price, best market after fees, cheapest buyable listing, arbitrage spread, deals found | `operation: "market_research"` + `keywords` | **free** |

Fast and light: 256 MB, direct HTTP (no browser), a 20-listing call returns in about 2 seconds and the first of 500 Mercari rows arrives in under a second. Errors come back as free `type: "error"` rows with a fix, never as a silent empty run.

### Mercari Japan search

Search Mercari Japan by keyword with every Mercari filter: price range, condition, brand, category, shipping payer, exclude words, sort. Mercari Shops listings are included (`sellerType: "shop"`); use `markets: ["mercari_shops"]` for Shops only.

```json
{ "keywords": ["ポケモンカード"], "markets": ["mercari"], "minPrice": 1000, "maxPrice": 5000, "condition": ["new", "like_new"], "maxItemsPerInput": 50 }
```

### Mercari sold prices

`status: "sold"` returns sold and in-trade items with `soldAt` and `daysToSell`.

```json
{ "keywords": ["nintendo switch"], "markets": ["mercari"], "status": "sold", "currency": "USD" }
```

### Yahoo Auctions sold (落札相場) and live auctions

Live auctions show current bid, bids, buy-now price, end time and seconds left; sold rows show the winning price, bids and watchers. Filters: `buyNowOnly`, `minBids`, `endingWithinMinutes`, `sortBy: "ending_soon"`.

```json
{ "keywords": ["ロレックス"], "markets": ["yahoo_auctions"], "status": "sold", "maxItemsPerInput": 100 }
```

### Yahoo Flea Market & Rakuma

Sold Yahoo! Flea Market rows carry `soldAt` and `daysToSell`, so Flea Market comps have days-to-sell and sell-through too.

```json
{ "keywords": ["ゲームボーイ"], "markets": ["yahoo_flea", "rakuma"], "status": "all" }
```

### Sold comps for resellers

One row per keyword × market plus one cross-market row: what it actually sells for, how fast, and how much competition is listed now.

```json
{ "operation": "sold_comps", "keywords": ["ロレックス サブマリーナ", "sony a7 iii"], "markets": ["mercari", "yahoo_auctions"], "currency": "USD" }
```

`mixedKeywordLikely: true` (p75/p25 > 5) means the keyword mixes different products (e.g. watches and watch parts): refine it or add `minPrice`. Add `include: ["evidence"]` to get the sold listings behind each row.

### Market research: sold comps + priced live listings + insight in one call

`operation: "market_research"` runs the whole reseller workflow per keyword: sold comps per market (+ a cross-market row), live listings priced against the sold median (`soldMedianRef`, `vsSoldMedianPct`, `dealFlag` = deal / below_p25 / fair / above_p75 / too_cheap_check_item) and one free computed `insight` row.

```json
{ "operation": "market_research", "keywords": ["ポケモンカード 151 BOX"], "markets": ["mercari", "yahoo_flea"], "titleMatch": "all", "dealsOnly": true, "maxListingsPerKeyword": 5 }
```

- `dealsOnly: true` scans up to max(5 × `maxListingsPerKeyword`, 100) live listings per market (scanning is not billed) and returns only deal / below_p25 rows, cheapest vs the sold median first. You pay for the comps rows and the listings returned.
- `titleMatch` (default `any` here): `all` keeps only titles that contain every keyword word; use it for specific products, otherwise a "151 BOX" search mixes single cards into the sold median.
- Listing rows priced against a mixed sold sample carry `collectionWarnings: ["sold_reference_mixed_keyword"]`; the insight row then says `arbitrageVerdict: "unreliable_mixed_keyword"`.
- Fees (`sellerFeesPct`, defaults checked 2026-10-13) and `shippingCostJpy` feed the net-after-fee figures. All insight values are computed from the collected rows (`computed: true`, `heuristic: true`), not marketplace data.

### Item details, sellers and reviews

```json
{ "operation": "item_details", "urls": ["https://jp.mercari.com/item/m67495430008", "https://auctions.yahoo.co.jp/jp/auction/x1248072300", "https://paypayfleamarket.yahoo.co.jp/item/z633136770", "https://item.fril.jp/fe06b0caf820d8ce027fd4d6df80acd7"] }
```

```json
{ "operation": "seller_items", "users": ["684797252"], "status": "all" }
```

```json
{ "operation": "seller_profiles", "users": ["https://jp.mercari.com/user/profile/684797252"] }
```

Yahoo! Auctions sellers work the same way (live listings + rating summary): pass the `sellerId` of a Yahoo! Auctions row or its seller page URL.

```json
{ "operation": "seller_profiles", "users": ["https://auctions.yahoo.co.jp/seller/3UC93wYwb7qvoqVWhjM1R8rtbBxgo"] }
```

```json
{ "operation": "seller_reviews", "users": ["684797252"], "reviewFame": ["bad"] }
```

### Price-drop and sold tracking

Give a `deltaKey` and schedule the run. Each row gets `changeType` (`new`, `price_drop`, `price_up`, `sold`, `relisted`, `unchanged`) and `previousPrice`; unchanged rows are skipped and not billed (`onlyChanges`). Use `status: "all"` to see items that sold.

```json
{ "keywords": ["ワンピース 初版"], "markets": ["mercari", "yahoo_auctions"], "status": "all", "deltaKey": "op-first-ed", "maxPrice": 20000 }
```

### For AI agents

MCP tool: `deadc0dex--mercari-yahoo-auctions-scraper` (Apify MCP server). Nothing is required; every primary input is an array; enum values are explained in each field description.

| Task | Input | Rows | Cost | Time |
|---|---|---|---|---|
| Quick look | `{"keywords":["ポケモンカード"],"maxItemsPerInput":10,"outputMode":"lean"}` | 20 listing | $0.04 | ~2 s |
| Sold across 4 markets | `{"operation":"search","keywords":["nintendo switch"],"markets":["mercari","yahoo_auctions","yahoo_flea","rakuma"],"status":"sold","maxItemsPerInput":25,"currency":"USD"}` | 100 listing | $0.20 | ~5 s |
| Price check | `{"operation":"sold_comps","keywords":["sony a7 iii"],"markets":["mercari","yahoo_auctions"]}` | 3 comps | $0.03 | ~4 s |
| Research + deals | `{"operation":"market_research","keywords":["nintendo switch oled"],"maxListingsPerKeyword":5,"dealsOnly":true}` | 3 comps + 1 insight + up to 10 listing | ≤ $0.05 | ~3 s |
| Full item | `{"operation":"item_details","urls":["https://jp.mercari.com/item/m67495430008"]}` | 1 item | $0.004 | ~1 s |
| Seller check | `{"operation":"seller_profiles","users":["684797252"]}` | 1 seller | $0.005 | ~1 s |
| Yahoo! seller's live items | `{"operation":"seller_items","users":["3UC93wYwb7qvoqVWhjM1R8rtbBxgo"],"outputMode":"lean"}` | up to 50 listing | $0.10 | ~2 s |
| What can it do? | `{"operation":"capabilities"}` | 1 (free) | $0 | <1 s |
| Cost first | add `"dryRun": true` to any input | plan rows (free) | $0 | <1 s |

**Operations:** `auto` (default: keywords → search, urls/ids → item_details, users → seller_items), `search`, `market_research`, `item_details`, `seller_items`, `seller_profiles`, `sold_comps`, `seller_reviews`, `capabilities`.

**Markets:** `mercari` (includes Mercari Shops), `mercari_shops`, `yahoo_auctions`, `yahoo_flea`, `rakuma`, or `all`. Default `["mercari","yahoo_auctions"]`.

**Lean output:** `outputMode: "lean"` drops empty values and the url (rebuild it from `summary.urlPatterns[market]` + `id`): about 75 tokens per listing with Japanese titles; `table` packs all rows into one TSV (about 80 tokens per listing).

**Item rows** carry the first 3 photos in compact mode (`maxImagesPerItem`, 1-50; all in `full`), and `imageCount` always gives the total.

**Control:** `fields` (projection), `include` (`details`, `seller`, `evidence`, `comments`), `outputMode` (`compact`, `full`, `lean`, `table`), `maxItems`, `maxItemsPerInput`, `maxCostUsd`, `dryRun`, `currency`, `expandQuery`, `dedupe`, `deltaKey` (+ `trackMetrics` for price / likes / bids / watch deltas between runs), `matchTerms`, `titleMatch`.

**English keywords:** with `expandQuery` (default on) an English keyword that the built-in dictionary knows (400+ resale terms: brands, franchises, item types, condition words) is searched as given **and** in Japanese (`pokemon card` → `ポケモンカード`, `rolex submariner` → `ロレックス サブマリーナ`); results are merged and de-duplicated, and `queryUsed` shows both.

**Every row** has `type, operation, input, queryUsed, id, url, fetchedAt` plus flat fields (null when unknown) and trust fields: `isPartial`, `unavailableFields` (fields this marketplace never exposes for that row, null on purpose) and `collectionWarnings`. Comps rows add `requestedSampleSize`, `sampleComplete`, `totalAvailable`, `pagesFetched` and `stopReason`. The **last row** is `type: "summary"`: rows per type and market, billed events, cost, stop reason, filtered counts, warnings and next steps. The run status message says rows, errors, cost and the first fix.

**Error rows** (free): `MISSING_INPUT`, `INVALID_INPUT`, `INVALID_URL`, `NOT_FOUND`, `NO_RESULTS`, `UNSUPPORTED_OPERATION`, `BUDGET_REACHED`, `BLOCKED`, `RATE_LIMITED`, `UPSTREAM_ERROR` — each with `message` and `fix`. The run fails only if every request was blocked and nothing was returned.

### Output example (compact listing)

```json
{
  "type": "listing", "operation": "search", "input": "nintendo switch", "queryUsed": "nintendo switch | ニンテンドースイッチ",
  "id": "j1248076949", "url": "https://auctions.yahoo.co.jp/jp/auction/j1248076949", "market": "yahoo_auctions",
  "title": "未開封 リズム天国 ミラクルスターズ Nintendo Switch", "price": 5300, "currency": "JPY", "priceConverted": 33.44, "convertedCurrency": "USD",
  "status": "sold", "condition": "new", "categoryName": "ニンテンドースイッチソフト", "soldAt": "2026-10-13T05:51:00.000Z", "daysToSell": 0.57,
  "bidCount": 14, "buyNowPrice": 5300, "watchCount": 12, "isFixedPrice": false
}
```

### Pricing

Pay per event, only for rows you can see. Insight, error, summary, plan (dryRun) and capabilities rows are free.

| Event | Price |
|---|---|
| Listing | $0.002 |
| Item detail | $0.004 |
| Seller profile | $0.005 |
| Sold comps row | $0.01 |
| Seller review | $0.0012 |
| Actor start | $0.00005 |

### Limits

- Mercari totals (`activeListings`) are capped at 15,000 by Mercari; sell-through is then null.
- Rakuma search rows have no sale date, so `soldAt`/`daysToSell` are null there and `windowDays` does not cut them. Rakuma search rows have no condition (item rows do).
- Live Yahoo! Auctions search rows show condition only for unused items; `include: ["details"]` fills it.
- Filters that a marketplace cannot apply server-side (`minBids`, `endingWithinMinutes`, condition on some markets) are applied to the fetched pages, so very strict filters may return fewer rows than `maxItemsPerInput`.
- Sold Yahoo! Flea Market items that appear in Yahoo! Auctions results link to their Flea Market page.
- Seller items / profiles: Mercari and Yahoo! Auctions (Yahoo! Auctions = live listings only; no public sold history per seller). Seller reviews: Mercari only.

### FAQ

**Do I need a Mercari or Yahoo! account, cookies or proxies?** No. Public pages and the public web APIs only.

**What does 1,000 rows cost?** 1,000 listings = $2. 1,000 item details = $4. 100 sold-comps rows = $1. Error, summary, dry-run and capabilities rows are free.

**How fresh is the data?** Fetched live on every run; `fetchedAt` is on every row. Schedule the run with `deltaKey` to get only new, sold or re-priced items.

**English keywords?** Yes, searched as given and in Japanese (`expandQuery`). Japanese keywords give the most results.

### Notes

Public listing data only: no account, no cookies, no buyer data (buyer ids are never exported; reviewer and commenter ids are hashed). Unofficial; not affiliated with Mercari, Inc., LY Corporation (Yahoo! JAPAN) or Rakuten Group.

# Changelog

This Actor's version history is a separate document: https://apify.com/deadc0dex/mercari-yahoo-auctions-scraper/changelog.md

# Actor input Schema

## `operation` (type: `string`):

auto (default): keywords -> search, urls/ids -> item_details, users -> seller_items. search = listings (status on_sale/sold/all). market_research = keyword -> sold comps per market + live listings priced vs the sold median + one insight row (recommended price, best market after fees, arbitrage spread, deals). sold_comps = price stats per keyword x market. item_details, seller_items, seller_profiles, seller_reviews (Mercari). capabilities = free.

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

Keywords for search and sold_comps, one per item. Japanese works best; English is searched as given AND in Japanese when expandQuery knows the term (pokemon card -> ポケモンカード, rolex -> ロレックス). Each row shows queryUsed. Example: \["ポケモンカード", "nintendo switch"].

## `urls` (type: `array`):

Item URLs for item_details: jp.mercari.com/item/m…, jp.mercari.com/shops/product/…, auctions.yahoo.co.jp/jp/auction/…, paypayfleamarket.yahoo.co.jp/item/…, item.fril.jp/…. Marketplace search URLs (jp.mercari.com/search?keyword=…, auctions.yahoo.co.jp/closedsearch/…) run a search; seller profile URLs (Mercari, Yahoo! Auctions) run seller_items. Bad ones return an INVALID_URL error row (free).

## `ids` (type: `array`):

Bare item ids for item_details: Mercari m12345678901, Yahoo! Auctions x1234567890 / 1234567890 (a Yahoo! Flea Market id when markets is only yahoo_flea), Mercari Shops 22-char ids, Rakuma 32-hex ids. Use the itemId field of listing rows.

## `users` (type: `array`):

Seller ids for seller_items, seller_profiles, seller_reviews: the sellerId of a listing row. Numeric = Mercari (684797252) or https://jp.mercari.com/user/profile/<id>. Letters+digits = Yahoo! Auctions (3UC93wYwb7qvoqVWhjM1R8rtbBxgo) or https://auctions.yahoo.co.jp/seller/<id>. Yahoo! Auctions: live listings + profile; seller_reviews is Mercari-only.

## `markets` (type: `array`):

Which marketplaces to search: mercari (Mercari Japan, includes Mercari Shops rows), mercari_shops (Shops only), yahoo_auctions (ヤフオク live + sold), yahoo_flea (Yahoo! Flea Market / PayPayフリマ), rakuma (楽天ラクマ), or all. Default: mercari + yahoo_auctions. Example: \["mercari", "yahoo_auctions", "yahoo_flea", "rakuma"].

## `status` (type: `string`):

on_sale (default) = active listings / live auctions. sold = sold items (Mercari sold + in trade, Yahoo! Auctions closed/落札, Flea Market and Rakuma sold out). all = both. sold_comps always uses sold items.

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

Total billable rows for the run, 1-10000 (clamped). Default 100. A default call costs at most 100 x $0.002 = $0.20 (listings).

## `maxItemsPerInput` (type: `integer`):

Rows per keyword per market (search), per seller (seller_items, seller_reviews), or sold sample size per keyword x market (sold_comps 120, market_research 60). 1-1000 (clamped). Defaults: search 50, seller_items 50, seller_reviews 50.

## `maxListingsPerKeyword` (type: `integer`):

market_research only: live (on-sale) listings returned per keyword per market, each annotated with soldMedianRef, vsSoldMedianPct and dealFlag (deal / below_p25 / fair / above_p75 / too_cheap_check_item). 0-200 (clamped), default 20; 0 = comps + insight only.

## `fields` (type: `array`):

Return only these fields (plus type), e.g. \["title", "price", "status", "url", "soldAt"]. Leave empty for the outputMode default. The capabilities row lists every field per row type.

## `include` (type: `array`):

details = open every listing for the full item (description, all photos, condition, shipping, seller rating; billed as item-detail $0.004 instead of listing). seller = one seller row per unique Mercari or Yahoo! Auctions seller ($0.005). evidence = sold_comps / market_research also return the sold listings behind each stat ($0.002 each). insights = sold_comps adds the computed insight row (free). comments = latest Mercari comments on item rows (free).

## `outputMode` (type: `string`):

compact (default) = stable flat rows. full = every field. lean = minimal rows for LLMs (listing: market, title, price, status, condition, soldAt, bids, end time; empty values dropped; url rebuilt from summary.urlPatterns + id). table = lean + one TSV table per row type in key-value record LEAN_TABLE (fewest tokens).

## `sortBy` (type: `string`):

newest (default) = newest listed (sold: newest sold on Yahoo! Auctions). price_asc / price_desc = by price. likes = most liked (Mercari, Flea Market). ending_soon = Yahoo! Auctions ending soonest. relevance = marketplace best match. Markets without a sort fall back to newest.

## `minPrice` (type: `integer`):

Lowest price in yen. Applied by the marketplace where supported, then checked on every row.

## `maxPrice` (type: `integer`):

Highest price in yen. Applied by the marketplace where supported, then checked on every row.

## `excludeKeywords` (type: `array`):

Drop listings whose title contains any of these words (e.g. \["ジャンク", "まとめ"]). Mercari also applies it server-side.

## `currency` (type: `string`):

JPY (default) or any ISO code such as USD, EUR, GBP: adds priceConverted and converted comps using the day's ECB rate (api.frankfurter.dev). price always stays in JPY.

## `maxCostUsd` (type: `number`):

Stop before the run's charges exceed this amount; rows so far are kept and a BUDGET_REACHED row (free) explains it. Example: 0.5.

## `dryRun` (type: `boolean`):

Return one plan row per task (markets, queries, estimated rows, cost, seconds) and a summary, without fetching or billing anything.

## `condition` (type: `array`):

Keep only these conditions: new (新品、未使用), like_new (未使用に近い), good (目立った傷や汚れなし), fair (やや傷や汚れあり), poor (傷や汚れあり), bad (全体的に状態が悪い). Rows whose condition is unknown (Rakuma search, most live Yahoo! Auctions rows) are dropped unless include has details.

## `matchTerms` (type: `array`):

Keep only rows whose title contains every term (case/width-insensitive), e.g. \["本体", "lite"]. Filters after fetch: it does not reduce pages fetched or cost of comps; billed rows only include matches.

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

Drop rows whose title has none (any) or not all (all) of the keyword's words (either query variant). Default any for market_research (marketplace search is fuzzy), off elsewhere. Filters after fetch.

## `compsFilter` (type: `string`):

sold_comps / market_research: off (default) = raw stats. outliers = drop prices outside p25-1.5 IQR .. p75+1.5 IQR (>= 8 rows). accessories = also drop accessory / part / empty-box titles (case, film, charger, dock, 空箱, 部品 ...) while collecting, so the sample refills; live research listings too. Comps rows always carry cleanMedian / cleanP25 / cleanP75 / accessoryShare.

## `yahooFleaCrossListings` (type: `string`):

Yahoo! Auctions search now mixes in Yahoo! Flea Market fixed-price items (rows say collectionWarnings yahoo_flea_market_cross_listing). include (default) = keep, exclude = real auctions only (comps = auction prices), only = cross-listings only. Filtered after fetch; more pages are read to refill.

## `dealThresholdPct` (type: `integer`):

A live listing is a deal when its buyable price is at least this % below the sold median (1-90, default 20). Rows under 35% of the median are flagged too_cheap_check_item instead (usually a different or partial item).

## `dealsOnly` (type: `boolean`):

market_research: scan up to max(5 x maxListingsPerKeyword, 100) live listings per market (max 300, scanning is not billed) and return only those flagged deal or below_p25, cheapest vs the sold median first, max maxListingsPerKeyword. You pay only for returned rows. Default false.

## `sellerFeesPct` (type: `object`):

Override seller fees used for net-after-fee prices, e.g. {"rakuma": 6}. Defaults (checked 2026-10-13): mercari 10, mercari_shops 10, yahoo_auctions 10, yahoo_flea 5, rakuma 10 (4.5-9 for high-volume sellers).

## `shippingCostJpy` (type: `integer`):

Optional shipping cost subtracted from every market's net sale price in the insight row (default 0 = not included; the row then warns shipping_not_included).

## `insights` (type: `boolean`):

market_research: add the computed insight row per keyword (free). Default true.

## `trackMetrics` (type: `boolean`):

With deltaKey: rows get snapshotAt, previousSnapshotAt and deltas vs the previous run (listings: priceDelta, likesDelta, bidCountDelta, watchCountDelta; comps: medianDelta, activeListingsDelta, soldPerDayDelta, sellThroughRateDelta). onlyChanges then defaults to false. Only compact numbers are stored.

## `categoryIds` (type: `array`):

Native category ids: Mercari categoryId (e.g. 1289 = ポケモンカードゲーム) or one Yahoo! Auctions category id (auccat). Take them from the categoryId field of earlier rows.

## `brandIds` (type: `array`):

Mercari brand ids (server-side filter).

## `buyNowOnly` (type: `boolean`):

Keep only Yahoo! Auctions rows with a buy-now (即決) price or fixed price.

## `minBids` (type: `integer`):

Keep only Yahoo! Auctions rows with at least this many bids.

## `endingWithinMinutes` (type: `integer`):

Keep only live Yahoo! Auctions ending within N minutes (combine with sortBy ending_soon).

## `shippingPayer` (type: `string`):

seller = free shipping (送料込み) only; buyer = buyer pays (着払い). Leave empty for any.

## `windowDays` (type: `integer`):

sold_comps: only sales from the last N days count (1-3650, default 90). Rakuma rows have no sale date and are not cut.

## `deltaKey` (type: `string`):

Name for change tracking between runs (e.g. "switch-watch"). Rows get changeType new / price_drop / price_up / sold / relisted / unchanged and previousPrice. State lives in a named key-value store in your account. Use status all to catch items that sold.

## `onlyChanges` (type: `boolean`):

With deltaKey: skip unchanged rows (not billed). Default true (false when trackMetrics is on).

## `expandQuery` (type: `boolean`):

Search English keywords as given AND in Japanese when the dictionary knows the term (400+ resale terms: brands, franchises, item types, condition words). Results are merged and de-duplicated. Default true.

## `dedupe` (type: `boolean`):

Drop repeated items across queries and markets (a Flea Market item also listed on Yahoo! Auctions counts once). Default true.

## `reviewFame` (type: `array`):

seller_reviews: keep only good, normal and/or bad reviews.

## `reviewSubject` (type: `string`):

seller (default) = reviews the user got as a seller; buyer = as a buyer; all = both.

## `commentsPerItem` (type: `integer`):

Latest Mercari comments per item row with include comments (0-50, default 5). Commenter ids are hashed.

## `maxImagesPerItem` (type: `integer`):

item rows: return the first N photo URLs in imageUrls (1-50; default 3 in compact, all in full). imageCount always gives the total, so nothing is hidden.

## `maxTextChars` (type: `integer`):

Cut description / introduction / review text to N characters (0 = no cut; lean default 300).

## Actor input object example

```json
{
  "operation": "auto",
  "keywords": [
    "ポケモンカード"
  ],
  "status": "on_sale",
  "maxItems": 100,
  "outputMode": "compact",
  "sortBy": "newest",
  "currency": "JPY",
  "dryRun": false,
  "dealsOnly": false,
  "insights": true,
  "trackMetrics": false,
  "buyNowOnly": false,
  "windowDays": 90,
  "expandQuery": true,
  "dedupe": true,
  "reviewSubject": "seller",
  "commentsPerItem": 5
}
```

# Actor output Schema

## `results` (type: `string`):

All dataset rows; filter by type. The last row is type summary.

## `listings` (type: `string`):

Listing rows as a table.

## `insights` (type: `string`):

Computed insight rows: recommended price, best market after fees, arbitrage, deals.

## `comps` (type: `string`):

Sold price statistics rows.

## `runSummary` (type: `string`):

RUN_SUMMARY record: rowsByType, rowsByMarket, billedEvents, costUsd, stopReason, warnings, nextSteps.

## `leanTable` (type: `string`):

Only with outputMode table: all rows as one tab-separated table per row type.

# 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("deadc0dex/mercari-yahoo-auctions-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 = { "keywords": ["ポケモンカード"] }

# Run the Actor and wait for it to finish
run = client.actor("deadc0dex/mercari-yahoo-auctions-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 '{
  "keywords": [
    "ポケモンカード"
  ]
}' |
apify call deadc0dex/mercari-yahoo-auctions-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,deadc0dex/mercari-yahoo-auctions-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/T2QcCLVzGJNd5qbOd/builds/odVPaOCysvmEwn687/openapi.json