# Mercari Japan Scraper — Listings, Sold Prices & Sellers (`scrapesage/mercari-japan-scraper`) Actor

Scrape Mercari Japan by keyword, category, brand, seller or URL: live & sold prices, item condition, photos, full descriptions, comments and seller reputation. New-item, price-drop & sold monitoring. Keyless, no login, no browser.

- **URL**: https://apify.com/scrapesage/mercari-japan-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 item scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

## Mercari Japan Scraper — Listings, Sold Prices, Conditions & Seller Data

Extract **complete data from Mercari Japan** (jp.mercari.com) — Japan's #1 secondhand / C2C marketplace. Search **live *and* sold listings** by keyword, category, brand or seller and get **real prices, exact item condition, full-resolution photos, complete descriptions, shipping details and seller reputation**. Sold-out search returns **recently-sold comparables (real sale prices)** — the data resellers and arbitrage buyers actually pay for.

No login, no cookies, no browser, no API key — fast JSON extraction with condition, category and shipping labels translated to **clear English**.

### Why this Mercari scraper?

Most marketplace scrapers stop at the search card and leave the valuable fields empty. This actor pulls from Mercari's own signed JSON API and ships the **richest dataset in the category**, plus **sold-price comps** and **seller intelligence**.

| Data | Typical scrapers | This actor |
|---|---|---|
| Live listing price + currency | ✅ | ✅ |
| **Sold-out comps (real sale prices)** | ❌ | ✅ filter by status |
| Exact item condition (1–6, English) | partial | ✅ |
| Full-resolution photo gallery | partial | ✅ all photos |
| Full description + hashtags + attributes | ❌ | ✅ opt-in |
| Category hierarchy (root → leaf) | ❌ | ✅ |
| Shipping method, origin & delivery time | ❌ | ✅ |
| Likes & comment count (demand signal) | ❌ | ✅ |
| Buyer/seller comments | ❌ | ✅ opt-in |
| Seller reputation (ratings, items sold, stars) | ❌ | ✅ opt-in |
| Seller trust score (0–100) | ❌ | ✅ |
| New-item / price-drop / sold **monitoring** | ❌ | ✅ |

### Use cases

- **Reselling & arbitrage** — source cheap items on Mercari Japan and check what they actually sell for. Filter to **sold-out** to pull real sale prices (comps), then resell on eBay, Poshmark, Vinted or Mercari US. Condition, shipping and photos come ready to relist.
- **Price & market research** — track price distributions for a brand, product or category (e.g. `pokemon card`, `nintendo switch`, `supreme`, `vintage camera`), monitor sell-through and spot trends.
- **Sneaker / trading-card / collectible intelligence** — follow specific brands or keywords and get alerted to new listings and price drops.
- **Sourcing reliable sellers** — score every seller by items sold, rating breakdown, star rating and official-shop / quick-shipper status to find trustworthy, high-volume supply.
- **Demand signals** — likes and comment counts reveal which items buyers want, for pricing and inventory decisions.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **Mercari Japan Scraper**, enter search keywords (or paste Mercari URLs / item IDs / seller IDs), pick a status (on sale or **sold comps**), and click **Start**.
3. Watch results stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "searchQueries": ["pokemon card", "nintendo switch"],
    "itemStatus": "sold",
    "minPrice": 3000,
    "conditions": ["1", "2", "3"],
    "sortBy": "priceDesc",
    "maxResults": 200,
    "includeItemDetails": true,
    "includeSellerLeads": true,
    "monitorMode": false
}
````

- **searchQueries** — keywords (English or Japanese). Each is scraped as its own feed.
- **startUrls** — Mercari search pages (`/search?keyword=…`), item pages (`/item/m…`) or seller profiles (`/user/profile/…`).
- **itemIds / sellerIds** — fetch specific items or all of a seller's items directly.
- **categoryId / brandId** — scope the search to a Mercari category or brand (combine with a keyword or browse the whole node).
- **itemStatus** — `onSale` (default), `sold` (sold comps / real sale prices) or `all`.
- **minPrice / maxPrice / conditions / excludeKeyword / sortBy** — source-side filters (prices in Japanese yen ¥; conditions 1–6).
- **includeItemDetails** *(default true)* — full description, all photos, exact condition, category hierarchy, shipping method/origin/delivery time, likes, comment count, hashtags and item attributes (one extra request per item).
- **includeComments** *(default false)* — output buyer/seller Q\&A comments as separate records.
- **includeSellerLeads** *(default false)* — one deduplicated record per seller: items sold, rating breakdown, star rating, official / quick-shipper flags, sample items and a 0–100 trust score.
- **monitorMode / monitorKey** — emit only new / price-changed items across runs (see below).

### Output

One record per item (`type: "item"`), plus optional comment records (`type: "comment"`) and seller lead records (`type: "sellerLead"`):

```json
{
    "type": "item",
    "itemId": "m39107576864",
    "name": "ゲッコウガex SAR SV5a クリムゾンヘイズ 090/066",
    "url": "https://jp.mercari.com/item/m39107576864",
    "price": 28000,
    "currency": "JPY",
    "status": "on_sale",
    "isSold": false,
    "conditionId": 4,
    "condition": "Some scratches and marks",
    "conditionDetail": "Has wear and/or defects",
    "categoryName": "Pokémon Trading Card Game",
    "parentCategoryName": "Trading Cards",
    "rootCategoryName": "Games, Toys & Merchandise",
    "categoryPath": ["Games, Toys & Merchandise", "Trading Cards", "Pokémon Trading Card Game"],
    "brandId": "8417",
    "brandName": "Pokemon Card Game",
    "shippingPayer": "seller",
    "shippingMethod": "RakuRaku Mercari Shipping",
    "shippingFromArea": "Hokkaido",
    "shippingDurationMinDays": 1,
    "shippingDurationMaxDays": 2,
    "numLikes": 10,
    "numComments": 5,
    "registeredPricesCount": 3,
    "description": "ご覧いただきありがとうございます…",
    "photos": ["https://static.mercdn.net/item/detail/orig/photos/m39107576864_1.jpg", "…"],
    "imageCount": 10,
    "hashTags": ["ポケカ"],
    "attributes": [{ "name": "Card type", "value": "Pokémon" }],
    "sellerId": "910638190",
    "sellerName": "田中さん",
    "sellerUrl": "https://jp.mercari.com/user/profile/910638190",
    "createdAt": "2026-05-02T11:00:00.000Z",
    "updatedAt": "2026-06-18T01:22:00.000Z",
    "searchQuery": "pokemon card",
    "detailScraped": true,
    "scrapedAt": "2026-06-19T22:00:00.000Z"
}
```

Seller lead record (`type: "sellerLead"`): `sellerId`, `sellerName`, `sellerUrl`, `memberSince`, `numSellItems`, `numRatings`, `ratingsGood` / `ratingsNormal` / `ratingsBad`, `starRatingScore`, `isOfficial`, `isQuickShipper`, `smsVerified`, `sampleItems`, and a 0–100 `leadScore`.

### Monitor mode (new / changed only)

Turn on **Monitor mode** to remember items across runs in a named key-value store and emit **only** items that are new or whose price changed since the last run. Each carries a `changeType`: `new`, `price_drop` or `price_rise`.

It is built to **complement** the platform scheduler, not conflict with it: an [Apify Schedule](https://docs.apify.com/platform/schedules) *starts* the run on your cadence; monitor mode *dedupes* each run against prior runs so you only ever pay for and process fresh data. Use a different `monitorKey` per keyword/feed to run several independent monitors in parallel.

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it hourly/daily to catch new listings and price drops for a keyword, brand or seller; perfect with monitor mode.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (relist to eBay, Slack alert, spreadsheet append) the moment a run finishes.

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/mercari-japan-scraper').call({
    searchQueries: ['nintendo switch'],
    itemStatus: 'sold',
    sortBy: 'priceDesc',
    maxResults: 200,
    includeItemDetails: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} Mercari records`);
```

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new listings or price drops straight into a sheet or CRM.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored search finds new items.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. You can call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "find sold Pokémon cards over ¥10,000 on Mercari Japan and list their sale prices" and let it run this scraper for you.

### More scrapers from scrapesage

Build a complete **resale & sourcing stack** — buy low on one marketplace, sell high on another:

- **[eBay Scraper](https://apify.com/scrapesage/ebay-scraper)** — listings, **sold prices** & seller leads (the classic resale exit).
- **[Poshmark Scraper](https://apify.com/scrapesage/poshmark-scraper)** — listings, sold comps & seller leads.
- **[Vinted Scraper](https://apify.com/scrapesage/vinted-scraper)** — EU secondhand fashion listings, prices & sellers.
- **[Reverb Scraper](https://apify.com/scrapesage/reverb-scraper)** — music gear listings, price guide & seller leads.
- **[Discogs Scraper](https://apify.com/scrapesage/discogs-scraper)** — records & CDs, marketplace prices & seller leads.
- **[AliExpress Scraper](https://apify.com/scrapesage/aliexpress-scraper)** — products, prices, orders & supplier leads for sourcing.
- **[Amazon Scraper](https://apify.com/scrapesage/amazon-scraper)** — products, prices, reviews & sellers.

### Tips

- **Sold comps**: set `itemStatus` to `sold` and `sortBy` to `priceDesc` to see the highest recent sale prices for a search — the fastest way to value an item before buying.
- **Big feeds**: a keyword can return up to ~15,000 results. Use `categoryId`, `brandId`, price bands and `conditions` to slice a large search into precise, exhaustive runs.
- **Cost control**: turn `includeItemDetails` off for a quick price/condition sweep (the card already has name, price, condition, brand and seller); turn it on when you need descriptions, full photo galleries and shipping.
- **Proxies**: keep the default RESIDENTIAL (Japan) proxy — Mercari serves its API cleanly to Japanese residential IPs.

### FAQ

**Can I get the price something actually sold for?** Yes. Set `itemStatus` to `sold` — the actor returns recently-sold listings with their final price, condition and photos, so you can build accurate comps.

**Does it work without the Mercari API key / login?** Yes. There is no public Mercari API; this actor talks to Mercari's own web JSON endpoints with the same request signing the website uses — no key, no account, no browser.

**Are the labels in English or Japanese?** Item *titles* and *descriptions* are in Japanese (that's how sellers write them), but condition, category and shipping labels are returned in **English** for easy filtering and relisting.

**Does it cover Mercari Shops?** Yes — Mercari Shops ("beyond") products appear in search results with price, brand, condition and photos. Full-detail enrichment applies to standard C2C items.

**Can I export to Google Sheets, CSV, or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**How do I monitor new listings automatically?** Turn on **Monitor mode**, create a [Schedule](https://docs.apify.com/platform/schedules), and optionally add a [webhook](https://docs.apify.com/platform/integrations/webhooks) or [Zapier zap](https://docs.apify.com/platform/integrations/zapier) to push new items into your tools as they appear.

**Is scraping Mercari legal?** This actor collects publicly available data only. You are responsible for using the data in compliance with applicable laws and Mercari's terms.

**A field is null — why?** Some items genuinely don't set a value (e.g. no brand, no hashtags). Fields are `null` only when the data doesn't exist, not because the scraper skipped them. Turn on `includeItemDetails` for the fullest record.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords to search Mercari Japan for, e.g. <code>nintendo switch</code>, <code>pokemon card</code>, <code>supreme</code>, <code>iphone 15</code>, <code>vintage camera</code>. Each keyword is scraped as its own feed. Japanese keywords work too (e.g. <code>ポケモンカード</code>). Leave empty if you only use a category, brand or Start URLs.

## `startUrls` (type: `array`):

Mercari Japan URLs to scrape directly: search pages (<code>jp.mercari.com/search?keyword=...</code>), item pages (<code>jp.mercari.com/item/m12345...</code>) and seller profiles (<code>jp.mercari.com/user/profile/123...</code>). Used in addition to the keyword search.

## `itemIds` (type: `array`):

Mercari item IDs (<code>m12345678901</code>) or item URLs to fetch full detail for directly.

## `sellerIds` (type: `array`):

Mercari seller IDs (numeric, e.g. <code>695366700</code>) or profile URLs (<code>jp.mercari.com/user/profile/695366700</code>) to scrape all of a seller's items and (optionally) build a seller lead.

## `categoryId` (type: `string`):

Optional Mercari category ID to scope the search (e.g. <code>7</code> = Electronics, <code>5</code> = Toys/Games/Goods). Find it in any category URL (<code>category\_id=</code>). Combine with a keyword or leave the keyword empty to browse the whole category.

## `brandId` (type: `string`):

Optional Mercari brand ID to scope the search (e.g. <code>7572</code> = Nintendo Switch). Find it in the <code>brandName</code>/<code>brandId</code> of any result.

## `itemStatus` (type: `string`):

Which listings to return. <b>Sold out</b> is the killer feature for resellers — it returns recently-sold comparables (real sale prices) for pricing research and arbitrage.

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

Only return items priced at least this many Japanese yen.

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

Only return items priced at most this many Japanese yen.

## `conditions` (type: `array`):

Keep only items in these conditions. Leave empty for any condition.

## `excludeKeyword` (type: `string`):

Hide items whose title contains this word (e.g. <code>ジャンク</code> = junk, <code>broken</code>).

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

How Mercari orders the results.

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

Maximum number of item records to scrape across all searches/URLs.

## `maxPagesPerSearch` (type: `integer`):

Pagination cap per keyword/feed (120 items per page).

## `includeItemDetails` (type: `boolean`):

Open each item to add the full description, complete category hierarchy, full-resolution photo gallery, exact condition, shipping method / origin / delivery time, likes, comment count, hashtags and item attributes (size, model…). Turn OFF for a faster/cheaper run (the search card already includes name, price, condition, brand, seller and a thumbnail). Adds one request per item.

## `includeComments` (type: `boolean`):

Also output buyer/seller Q\&A comments on each item as separate records (requires full item details). Useful for demand signals and negotiation insight.

## `includeSellerLeads` (type: `boolean`):

Output one deduplicated record per seller seen in the run: member-since date, items-sold count, rating breakdown (good/normal/bad), star rating, official-shop / quick-shipper flags, sample items and a 0-100 trust score. Best for sourcing reliable sellers and power-seller research.

## `maxSellerLeads` (type: `integer`):

Maximum number of seller lead records to output.

## `deduplicateItems` (type: `boolean`):

Drop duplicate items that appear in more than one search/page in the same run.

## `monitorMode` (type: `boolean`):

Remember items across runs in a named key-value store and emit ONLY items that are new OR whose price changed since the last run (each carries a <code>changeType</code>: new / price\_drop / price\_rise). Pair with Apify Schedules for new-listing & price-drop alerts — it complements the scheduler (the schedule starts the run; monitor mode dedupes against prior runs).

## `monitorKey` (type: `string`):

Names the monitor's memory store so you can run several independent monitors (e.g. one per keyword). Reuse the same key to keep tracking the same feed.

## `maxConcurrency` (type: `integer`):

Parallel detail/seller request fetches. Keep moderate (3–6).

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

Proxies to use. Mercari serves its API cleanly to Apify residential proxies — keep the default (residential, Japan).

## Actor input object example

```json
{
  "searchQueries": [
    "nintendo switch"
  ],
  "itemStatus": "onSale",
  "conditions": [],
  "sortBy": "relevance",
  "maxResults": 100,
  "maxPagesPerSearch": 50,
  "includeItemDetails": true,
  "includeComments": false,
  "includeSellerLeads": false,
  "maxSellerLeads": 200,
  "deduplicateItems": true,
  "monitorMode": false,
  "monitorKey": "default",
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "JP"
  }
}
```

# Actor output Schema

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

All scraped Mercari item records, plus optional comment and seller lead records, as JSON items in the default dataset.

# 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 = {
    "searchQueries": [
        "nintendo switch"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "JP"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/mercari-japan-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 = {
    "searchQueries": ["nintendo switch"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "JP",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/mercari-japan-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "nintendo switch"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "JP"
  }
}' |
apify call scrapesage/mercari-japan-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapesage/mercari-japan-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mercari Japan Scraper — Listings, Sold Prices & Sellers",
        "description": "Scrape Mercari Japan by keyword, category, brand, seller or URL: live & sold prices, item condition, photos, full descriptions, comments and seller reputation. New-item, price-drop & sold monitoring. Keyless, no login, no browser.",
        "version": "0.1",
        "x-build-id": "2Ig0fngDYZaI7KOLj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesage~mercari-japan-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesage-mercari-japan-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapesage~mercari-japan-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesage-mercari-japan-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapesage~mercari-japan-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesage-mercari-japan-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQueries": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Keywords to search Mercari Japan for, e.g. <code>nintendo switch</code>, <code>pokemon card</code>, <code>supreme</code>, <code>iphone 15</code>, <code>vintage camera</code>. Each keyword is scraped as its own feed. Japanese keywords work too (e.g. <code>ポケモンカード</code>). Leave empty if you only use a category, brand or Start URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Mercari Japan URLs to scrape directly: search pages (<code>jp.mercari.com/search?keyword=...</code>), item pages (<code>jp.mercari.com/item/m12345...</code>) and seller profiles (<code>jp.mercari.com/user/profile/123...</code>). Used in addition to the keyword search.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "itemIds": {
                        "title": "Item IDs / URLs (direct detail)",
                        "type": "array",
                        "description": "Mercari item IDs (<code>m12345678901</code>) or item URLs to fetch full detail for directly.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sellerIds": {
                        "title": "Seller IDs / URLs",
                        "type": "array",
                        "description": "Mercari seller IDs (numeric, e.g. <code>695366700</code>) or profile URLs (<code>jp.mercari.com/user/profile/695366700</code>) to scrape all of a seller's items and (optionally) build a seller lead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categoryId": {
                        "title": "Category ID",
                        "type": "string",
                        "description": "Optional Mercari category ID to scope the search (e.g. <code>7</code> = Electronics, <code>5</code> = Toys/Games/Goods). Find it in any category URL (<code>category_id=</code>). Combine with a keyword or leave the keyword empty to browse the whole category."
                    },
                    "brandId": {
                        "title": "Brand ID",
                        "type": "string",
                        "description": "Optional Mercari brand ID to scope the search (e.g. <code>7572</code> = Nintendo Switch). Find it in the <code>brandName</code>/<code>brandId</code> of any result."
                    },
                    "itemStatus": {
                        "title": "Item status",
                        "enum": [
                            "onSale",
                            "sold",
                            "all"
                        ],
                        "type": "string",
                        "description": "Which listings to return. <b>Sold out</b> is the killer feature for resellers — it returns recently-sold comparables (real sale prices) for pricing research and arbitrage.",
                        "default": "onSale"
                    },
                    "minPrice": {
                        "title": "Min price (¥)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return items priced at least this many Japanese yen."
                    },
                    "maxPrice": {
                        "title": "Max price (¥)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return items priced at most this many Japanese yen."
                    },
                    "conditions": {
                        "title": "Item condition",
                        "type": "array",
                        "description": "Keep only items in these conditions. Leave empty for any condition.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5",
                                "6"
                            ],
                            "enumTitles": [
                                "1 · New, unused",
                                "2 · Almost unused",
                                "3 · No noticeable scratches or marks",
                                "4 · Some scratches and marks",
                                "5 · Scratched and scuffed",
                                "6 · Overall poor condition"
                            ]
                        },
                        "default": []
                    },
                    "excludeKeyword": {
                        "title": "Exclude keyword",
                        "type": "string",
                        "description": "Hide items whose title contains this word (e.g. <code>ジャンク</code> = junk, <code>broken</code>)."
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "newest",
                            "priceAsc",
                            "priceDesc",
                            "mostLiked"
                        ],
                        "type": "string",
                        "description": "How Mercari orders the results.",
                        "default": "relevance"
                    },
                    "maxResults": {
                        "title": "Max items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of item records to scrape across all searches/URLs.",
                        "default": 100
                    },
                    "maxPagesPerSearch": {
                        "title": "Max pages per search",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Pagination cap per keyword/feed (120 items per page).",
                        "default": 50
                    },
                    "includeItemDetails": {
                        "title": "Include full item details",
                        "type": "boolean",
                        "description": "Open each item to add the full description, complete category hierarchy, full-resolution photo gallery, exact condition, shipping method / origin / delivery time, likes, comment count, hashtags and item attributes (size, model…). Turn OFF for a faster/cheaper run (the search card already includes name, price, condition, brand, seller and a thumbnail). Adds one request per item.",
                        "default": true
                    },
                    "includeComments": {
                        "title": "Include item comments",
                        "type": "boolean",
                        "description": "Also output buyer/seller Q&A comments on each item as separate records (requires full item details). Useful for demand signals and negotiation insight.",
                        "default": false
                    },
                    "includeSellerLeads": {
                        "title": "Output seller leads",
                        "type": "boolean",
                        "description": "Output one deduplicated record per seller seen in the run: member-since date, items-sold count, rating breakdown (good/normal/bad), star rating, official-shop / quick-shipper flags, sample items and a 0-100 trust score. Best for sourcing reliable sellers and power-seller research.",
                        "default": false
                    },
                    "maxSellerLeads": {
                        "title": "Max seller leads",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of seller lead records to output.",
                        "default": 200
                    },
                    "deduplicateItems": {
                        "title": "Deduplicate items",
                        "type": "boolean",
                        "description": "Drop duplicate items that appear in more than one search/page in the same run.",
                        "default": true
                    },
                    "monitorMode": {
                        "title": "Monitor mode (only new / changed)",
                        "type": "boolean",
                        "description": "Remember items across runs in a named key-value store and emit ONLY items that are new OR whose price changed since the last run (each carries a <code>changeType</code>: new / price_drop / price_rise). Pair with Apify Schedules for new-listing & price-drop alerts — it complements the scheduler (the schedule starts the run; monitor mode dedupes against prior runs).",
                        "default": false
                    },
                    "monitorKey": {
                        "title": "Monitor key",
                        "type": "string",
                        "description": "Names the monitor's memory store so you can run several independent monitors (e.g. one per keyword). Reuse the same key to keep tracking the same feed.",
                        "default": "default"
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Parallel detail/seller request fetches. Keep moderate (3–6).",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxies to use. Mercari serves its API cleanly to Apify residential proxies — keep the default (residential, Japan).",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "JP"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
