# Mercari Japan Products Scraper (`automation-lab/mercari-jp-marketplace-listings`) Actor

Export public Mercari Japan C2C listing titles, JPY asking prices, IDs, images and seller links. Search by keyword or item URL; optionally include public descriptions for recurring resale comparisons.

- **URL**: https://apify.com/automation-lab/mercari-jp-marketplace-listings.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.44 / 1,000 japanese listings

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Products Scraper

Export public Mercari Japan products for recurring resale price and assortment comparisons. Search Japanese C2C inventory by keyword or paste supported search and item URLs. Get listing titles, JPY asking prices, stable IDs, canonical links, image URLs and public seller identifiers. Optionally include public item descriptions.

### Who is it for?

Resellers comparing candidate purchases, analysts studying current assortment, and collectors watching model-specific inventory can export the same searches repeatedly. Use Japanese product names and exact model numbers to improve source relevance.

### Why use it?

The Actor reads structured search responses rather than guessing prices from card text. Pagination follows Mercari's cursor, and deduplication uses the item ID across the whole run. An observed price is an asking price or current auction bid, not proof of a realized sale. Search relevance remains controlled by Mercari.

### Getting started

1. Enter a product phrase in **Search keywords**, for example `nintendo switch`.
2. Set **Maximum unique listings**, initially 50.
3. Enable **Include item descriptions** only when needed.
4. Run and inspect the default dataset.
5. Export JSON, CSV or Excel using Apify's dataset export options.

```json
{"keywords":["nintendo switch"],"maxItems":50,"includeDetails":false}
```

### Inputs

| Field | Behavior |
| --- | --- |
| `keywords` | Independent source searches; surrounding whitespace is trimmed. Not exact-match title filters. |
| `startUrls` | URL objects for supported public search or item pages, processed before keywords. |
| `maxItems` | Global accepted unique-row limit, default 50, range 1–5000. No unlimited mode. |
| `includeDetails` | Add descriptions and item images to search records. Explicit item URLs always receive details. |

Provide 1–20 sources total across keywords and URLs. At least one is required. When multiple sources overlap, the first occurrence supplies the source context. Later sources may not run when the global limit is reached.

### Search and explicit item URLs

Search URLs must use `https://jp.mercari.com/search?keyword=...`. The only additional supported parameter is `status=on_sale` or `status=sold_out`. Other filters are rejected rather than silently ignored. Mercari's sold-out search may contain trading or completed status values; inspect `status` rather than assuming a sale date.

```json
{"startUrls":[{"url":"https://jp.mercari.com/search?keyword=sony%20camera&status=sold_out"}],"maxItems":25}
```

Explicit public `/item/m...` URLs must have no query parameters. They always receive item details. Seller and condition fields may be null where public item data does not expose them. Mercari Shops records are excluded: this product exports Japanese C2C `m...` identifiers, not shop inventory.

### Output fields

| Field | Meaning |
| --- | --- |
| `itemId`, `itemUrl` | Stable public listing identity and link |
| `title`, `price`, `currency` | Public title and observed JPY asking price/current bid |
| `status` | Raw source status: search codes such as `ITEM_STATUS_ON_SALE`, or item API values such as `on_sale` after enrichment; not a normalized enum or sale date |
| `conditionId` | Source condition identifier, not translated text |
| `sellerId`, `sellerUrl` | Public seller identity/profile link when exposed |
| `brand` | Public brand when exposed |
| `imageUrls` | Search thumbnails or enriched item images |
| `description`, `detailsStatus` | Public description and whether details were loaded |
| `sourceUrl`, `keyword` | First source context; keyword is null for explicit items |
| `scrapedAt` | ISO extraction timestamp |

Missing optional fields are null. No private contacts, buyer identities, purchase actions, messages or seller reviews are collected.

### Example output

This redacted example follows the tested output shape; listing and seller identifiers are illustrative.

```json
{
  "itemId": "m12345678901",
  "itemUrl": "https://jp.mercari.com/item/m12345678901",
  "title": "Nintendo Switch用ソフト「ピクミン4」",
  "price": 3500,
  "currency": "JPY",
  "status": "ITEM_STATUS_ON_SALE",
  "conditionId": "3",
  "sellerId": "123456789",
  "sellerUrl": "https://jp.mercari.com/user/profile/123456789",
  "brand": "Nintendo Switch",
  "imageUrls": ["https://static.mercdn.net/example.jpg"],
  "description": null,
  "detailsStatus": "not_requested",
  "sourceUrl": "https://jp.mercari.com/search?keyword=nintendo+switch",
  "keyword": "nintendo switch",
  "scrapedAt": "2026-10-03T15:00:00.000Z"
}
```

### How much does it cost to extract Mercari Japan products?

Pay-per-event pricing charges one `start` event and one `item` event for each accepted listing saved. There is no separate enrichment charge. The start event is $0.003. Per-listing prices are FREE $0.0027554, BRONZE $0.002396, SILVER $0.0018689, and GOLD/PLATINUM/DIAMOND $0.0014376. These are qualifying monthly Store spend tiers, not private per-Actor volume discounts. On BRONZE, estimated event totals are $0.005396 for 1 listing, $0.02696 for 10, $0.1228 for 50 and $0.2426 for 100. Estimates exclude taxes and account-specific adjustments. Duplicate, excluded and empty rows do not generate item events. A genuine empty search still incurs the start event.

### Coverage and limitations

This is a current public inventory snapshot, not a historical transaction database. Search ranking, availability and public fields can change. Exported prices do not prove sale amounts or dates. Auctions can expose current bids. Filters are limited to the documented keyword and status search route.

The Actor stops after source exhaustion or the global accepted-row limit. A source safety bound of 100 pages prevents runaway pagination; reaching it produces a failed run with a partial dataset. Removed or unavailable item details fail the run rather than masquerading as complete enrichment.

### Reliability and troubleshooting

The implementation uses an anonymous Japanese-locale browser session for search bootstrap and a structured API cursor for pagination. Item enrichment bootstraps an anonymous public item browser session, then reuses ephemeral headers for sequential HTTP item requests, refreshing the session only under bounded conditions. Images, fonts and media are not downloaded; URLs remain in output. No login or customer cookies are required, and there is no automatic paid residential fallback.

A genuine source-confirmed empty search succeeds with zero rows. A blocked page, changed API response, unavailable detail or failed pagination fails the run. Any rows already saved are partial. Inspect the run log before treating a partial dataset as a completed export. Try a narrow keyword without enrichment to isolate a disappeared item page from a search issue.

### Integrations

Export CSV to spreadsheets for sorting JPY prices and grouping brands. Use Apify schedules to repeat a stable input and compare `itemId` values downstream. Join exports by item ID to observe changing asking prices; the Actor itself does not provide history, alerts or a change feed.

Use dataset webhooks with your own downstream automation, or retrieve completed datasets through the API. Keep full datasets outside model context when using AI analysis.

### API usage

Keep your Apify token private. Start one run and retain its run ID and dataset ID; do not restart merely to poll status.

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~mercari-jp-marketplace-listings/runs" \
  -H "Authorization: Bearer $APIFY_TOKEN" -H "Content-Type: application/json" \
  -d '{"keywords":["sony camera"],"maxItems":25}'
```

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/mercari-jp-marketplace-listings').call({ keywords: ['sony camera'], maxItems: 25 });
const rows = await client.dataset(run.defaultDatasetId).listItems({ limit: 25 });
console.log(rows.items);
```

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/mercari-jp-marketplace-listings').call(run_input={'keywords': ['sony camera'], 'maxItems': 25})
rows = client.dataset(run['defaultDatasetId']).list_items(limit=25)
print(rows.items)
```

### MCP use

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/mercari-jp-marketplace-listings"
```

Claude Desktop, Cursor, and VS Code: use the equivalent remote HTTP server configuration supported by your client. Client authentication and transport setup can vary.

```json
{"mcpServers":{"apify":{"url":"https://mcp.apify.com?tools=automation-lab/mercari-jp-marketplace-listings"}}}
```

Discover actual schemas with `tools/list`. Actor selection also adds run and dataset tools; it does not expose exactly one tool. Example prompt (authorized consumer invocation): “Export 25 Mercari Japan camera listings, then summarize asking prices in JPY.”

Start once, retain the run/storage IDs and follow the same run. A call can return before completion. Poll the same run with bounded 2, 4, 8-second backoff capped at 10 seconds and a 120-second deadline; report pending at the deadline. On timeout, recover the known run instead of blindly restarting. Terminal failures mean partial data, not a complete export.

After success, use `get-dataset-items` with `datasetId` set to the run's `defaultDatasetId`, `offset: 0`, `limit: 20`, and needed `fields` (for example `itemId,title,price,currency,status,itemUrl`), using the argument types exposed by `tools/list`. Advance the source offset by each admitted page. Retrieve bounded untransformed JSON pages, at most 100 rows or 64 KiB admitted to model context. Track offsets and serialized bytes host-side; summarize or omit oversized rows with disclosure. If the client cannot intercept oversized responses, do not promise a hard byte guarantee. Report truncation and the continuation offset. Keep full exports in storage.

### Legality and diagnostics

Use only public data for authorized purposes and comply with applicable laws, source terms and privacy obligations. This Actor is independent of Mercari and is not an official API. It does not buy products or contact users.

Failed operations send sanitized diagnostic input, exceptions and actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL query strings are removed; reports are retained for 30 days. No AI model processes input or scraped data at runtime. Browser cookies and session headers remain in memory and are discarded when contexts close; there is no persistent cache. Apify hosts run logs and datasets under your account's storage retention settings; you can delete them in Console or through the API. Public seller identifiers are personal-data context: avoid unnecessary redistribution. No other paid API or proxy service is used. For help, open a Store issue with the run URL and expected behavior; never post credentials.

### FAQ

**Does sold-out mean a verified sale price?** No. It is a source search/status observation, not independently verified transaction evidence.

**Why fewer results than requested?** The source may be exhausted, duplicate records may be removed, or Shops IDs may be excluded. `maxItems` is a ceiling, not a minimum.

**Can I filter by category or seller?** Not in this version. Only keyword and optional URL status filters are supported.

**Why does enrichment take longer?** It adds an anonymous item-session browser bootstrap and an HTTP detail request per accepted listing, with bounded session refreshes. A removed item can cause a partial failed run.

### Related Actors

For the separate US marketplace and USD prices, see [Mercari US Listings Scraper](https://apify.com/automation-lab/mercari-us-listings-scraper). It is not a substitute for Japanese inventory or JPY comparisons.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/mercari-jp-marketplace-listings/changelog.md

# Actor input Schema

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

One to twenty nonempty searches across keywords and URLs combined. Whitespace is trimmed. Mercari controls relevance and ranking; phrases are not exact-match title filters. Searches are processed independently, not combined with ANY/ALL matching. Japanese product names and model numbers are useful.

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

Public HTTPS jp.mercari.com/search URLs with a nonempty keyword and optional status=on_sale or sold_out, or /item/m... URLs without query parameters. Other paths/filters are rejected. URLs run before keywords; global item-ID deduplication keeps the first occurrence. Explicit items are always enriched even when includeDetails is false. At least one URL or keyword is required.

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

Global limit of accepted unique Japanese C2C listing rows across all searches and explicit items. Default 50; 1–5000, zero/unlimited unsupported. Stops pagination and later sources when reached. Excludes Shops IDs and duplicates. Source exhaustion can yield fewer rows. At most 100 search pages per source; reaching the safety bound fails with partial rows.

## `includeDetails` (type: `boolean`):

For search rows, add public description and richer images/brand using an anonymous item-browser bootstrap followed by ephemeral HTTP item requests with bounded session refresh; this adds work. Default false. Explicit item URLs always receive details. Missing detail data fails the run rather than silently claiming complete enrichment. Seller fields and condition IDs are included only when public data exposes them.

## Actor input object example

```json
{
  "keywords": [
    "nintendo switch"
  ],
  "maxItems": 20,
  "includeDetails": false
}
```

# Actor output Schema

## `overview` (type: `string`):

Unique public listings with requested item details 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 = {
    "keywords": [
        "nintendo switch"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/mercari-jp-marketplace-listings").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": ["nintendo switch"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/mercari-jp-marketplace-listings").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": [
    "nintendo switch"
  ],
  "maxItems": 20
}' |
apify call automation-lab/mercari-jp-marketplace-listings --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/mercari-jp-marketplace-listings"
        }
    }
}
```

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/amix90zCManboudQY/builds/h2mTWLjgSbzzVWjXF/openapi.json