# Mercari Japan Scraper (`w3crawler/mercari-japan-scraper`) Actor

Collect public Mercari Japan listings with prices, brands, conditions, sellers, shipping, images, and timestamps.

- **URL**: https://apify.com/w3crawler/mercari-japan-scraper.md
- **Developed by:** [w3crawler](https://apify.com/w3crawler) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 listings

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Scraper

Collect bounded **public Mercari Japan listings** through the anonymous public search API used by the Mercari Japan web page. Each saved row can include the item ID and canonical URL, title, JPY price, sale and listing status, brand, seller and shipping identifiers, category, images, timestamps, and source provenance when Mercari publishes them.

### Get started

1. Open the [Actor Store page](https://apify.com/w3crawler/mercari-japan-scraper) and select **Try for free** or open the **Input** tab.
2. Supply either a `keyword` such as `iphone` or one or more public `startUrls`. URLs take precedence over the keyword.
3. Leave `limit` at 50 for a normal run, or lower it for a first test. Keep `maxPages` at 1 while checking result quality.
4. Start the Actor, open the dataset, and export the saved listings as JSON, CSV, or Excel. Open **Run summary** (`OUTPUT`) to check the outcome and counts.

### Input

All fields are optional, but a run needs a `keyword` or at least one `startUrls` entry to have a source. Unsupported field names and out-of-range values are rejected before requests start.

| Field | Type | Required? | Default | Meaning |
| --- | --- | --- | --- | --- |
| `startUrls` | object array | Optional | Not supplied | Public `jp.mercari.com` search or item URLs; these take precedence over `keyword`. 1–20 entries. |
| `keyword` | string | Optional | Not supplied | Search keyword used when `startUrls` is empty, up to 300 characters. |
| `sort` | string | Optional | `""` | Public search sort value: `score`, `created_time`, or `price`. Empty leaves the source order unchanged. |
| `order` | string | Optional | `""` | Public order value: `asc` or `desc`. Empty leaves the source order unchanged. |
| `status` | string array | Optional | Not supplied | Listing status filters: `on_sale`, `sold_out`, or `trading`, up to 3 values. |
| `priceMin` | integer | Optional | Not supplied | Lower price bound, 0–1,000,000,000. |
| `priceMax` | integer | Optional | Not supplied | Upper price bound, 0–1,000,000,000. |
| `limit` | integer | Optional | `50` | Maximum listing records emitted across all sources, 1–500. |
| `maxPages` | integer | Optional | `1` | Maximum public search API pages requested per source, 1–20. |
| `timeoutSecs` | integer | Optional | `30` | Maximum wait for each public request, 5–120 seconds. |
| `maxBytes` | integer | Optional | `5000000` | Maximum response size accepted for parsing, 1,000–15,000,000 bytes. |
| `proxyConfiguration` | object | Optional | `{"useApifyProxy":false}` | Optional standard Apify Proxy routing. It does not bypass access challenges. |

Example input matching the saved `iphone` run:

```json
{
  "keyword": "iphone",
  "sort": "",
  "order": "",
  "limit": 3,
  "maxPages": 1,
  "timeoutSecs": 30,
  "maxBytes": 5000000,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

The Actor reads the anonymous public Mercari Japan search API. It does not use an account token, login, private endpoint, browser impersonation, or CAPTCHA bypass.

### Output

The dataset contains one row per saved listing. Optional values are omitted when Mercari does not publish them; they are not inferred. No diagnostic or placeholder rows are written.

| Field | Type | Availability | Meaning |
| --- | --- | --- | --- |
| `recordType` | string enum | Always | Listing record type; always `listing`. |
| `recordId` | string | Always | Stable anonymized row identifier. |
| `id` | integer | Always | Numeric Mercari listing identifier. |
| `url` | string | Always | Normalized public Mercari Japan item URL. |
| `listing_id` | string | Always | Mercari listing identifier with the `m` prefix. |
| `title` | string | Always | Public listing title. |
| `description` | string | When published | Public listing description when exposed. |
| `price` | number | Always | Public listing price in JPY. |
| `currency` | string | Always | Currency published by Mercari Japan. |
| `brand_name` | string | When published | Readable brand name when exposed. |
| `brand` | object | When published | Bounded brand object with identifiers and names. |
| `listing_status` | string | Always | Sale status such as `on_sale` or `sold_out`. |
| `listing_type` | string | Always | Mercari listing type, such as `ITEM_TYPE_MERCARI`. |
| `condition_id` | string | Always | Published condition identifier; the label is not invented. |
| `seller` | object | Always | Bounded seller object, usually `seller_id`. |
| `shipping` | object | Always | Published shipping payer and method identifiers. |
| `catalog` | object | Always | Bounded catalog identifiers. |
| `store` | object | When published | Store data when the listing belongs to a shop. |
| `category_id` | string | Always | Published category identifier. |
| `category_name` | string | When published | Category label when exposed. |
| `images` | string array | Always | Bounded public listing image URLs. |
| `created_at` | string | Always | Listing creation timestamp when parseable. |
| `updated_at` | string | Always | Last listing update timestamp when parseable. |
| `position` | integer | Always | One-based position after source order and deduplication. |
| `sourceUrl` | string | Always | Public search URL that produced the row. |
| `finalUrl` | string | Always | Final public request URL. |
| `httpStatus` | integer | Always | HTTP status observed for the API response. |
| `contentType` | string | Always | Response content type. |
| `contentLength` | integer | Always | Bounded response size in bytes. |
| `sourceTransport` | string enum | Always | `official_public_api`, `apify_proxy`, or `fixture`. |
| `proxyConfigured` | boolean | Always | Whether standard Apify Proxy routing was configured. |
| `fingerprintApplied` | boolean | Always | Whether a browser fingerprint was applied; this Actor does not apply one. |
| `accessStatus` | string | Always | Normalized access outcome, such as `success` or `blocked`. |
| `success` | boolean | Always | Whether the row is a successful listing extraction. |
| `dataAvailable` | boolean | Always | Whether usable listing data is present. |
| `status` | string | Always | Row status. |
| `inventoryRank` | integer | Always | Catalog inventory rank recorded for provenance. |
| `actorName` | string | Always | Display name of this Actor. |
| `actorSlug` | string | Always | Store slug of this Actor. |
| `actorStoreUrl` | string | Always | Store URL recorded for provenance. |
| `targetHint` | string | Always | Public target scope recorded for provenance. |
| `accessPolicy` | string | Always | Public-access and no-bypass policy recorded for the row. |
| `observedAt` | string | Always | UTC time at which the row was observed. |
| `scrapedAt` | string | Always | UTC extraction timestamp. |
| `generatedBy` | string | Always | Generator metadata for the row. |
| `fieldCoverage` | string array | Always | Top-level fields populated in the row. |
| `dataQuality` | object | Always | Bounded non-empty field quality metadata. |

`dataQuality` contains `recordStatus`, `targetSpecificFieldsClaimed`, `nonEmptyTopLevelFields`, `emptyTopLevelFields`, and `nullTopLevelFields`.

The example below is a real saved row from the 2026-10-25 run. `fieldCoverage`, `actorStoreUrl`, `targetHint`, and `accessPolicy` are omitted for length; every value shown is unchanged.

```json
{
  "recordType": "listing",
  "recordId": "listing:e1f66e3859c5e6a7b47f5d1a",
  "id": 92330019632,
  "url": "https://jp.mercari.com/item/m92330019632",
  "listing_id": "m92330019632",
  "title": "Apple iPhone SE 16GB 本体",
  "price": 5200,
  "currency": "JPY",
  "brand_name": "Apple",
  "brand": {
    "id": "3272",
    "name": "Apple",
    "subName": "Apple"
  },
  "listing_status": "on_sale",
  "listing_type": "ITEM_TYPE_MERCARI",
  "condition_id": "4",
  "seller": {
    "seller_id": "325342832"
  },
  "shipping": {
    "payer_id": "2",
    "method_id": "17"
  },
  "catalog": {
    "category_id": "859"
  },
  "category_id": "859",
  "images": [
    "https://static.mercdn.net/item/detail/webp/photos/m92330019632_1.jpg?1792921578",
    "https://static.mercdn.net/thumb/item/webp/m92330019632_1.jpg?1792921578"
  ],
  "created_at": "2026-10-25T09:46:18.000Z",
  "updated_at": "2026-10-25T09:47:32.000Z",
  "position": 1,
  "sourceUrl": "https://jp.mercari.com/search?keyword=iphone",
  "finalUrl": "https://jp.mercari.com/search?keyword=iphone",
  "httpStatus": 200,
  "contentType": "application/json",
  "contentLength": 17419,
  "sourceTransport": "official_public_api",
  "proxyConfigured": false,
  "fingerprintApplied": false,
  "accessStatus": "success",
  "success": true,
  "dataAvailable": true,
  "status": "success",
  "inventoryRank": 94,
  "actorName": "Mercari Japan Scraper",
  "actorSlug": "mercari-japan-scraper",
  "observedAt": "2026-10-25T20:47:50.972Z",
  "scrapedAt": "2026-10-25T20:47:50.972Z",
  "generatedBy": "Codex with GPT-5.6 Luna",
  "dataQuality": {
    "recordStatus": "non_empty",
    "targetSpecificFieldsClaimed": true,
    "nonEmptyTopLevelFields": 44,
    "emptyTopLevelFields": 0,
    "nullTopLevelFields": 0
  }
}
```

### Run summary

**Run summary** is stored separately from the dataset in the run's key-value store under `OUTPUT`.

| Field | Meaning |
| --- | --- |
| `status` | Run outcome: `SUCCEEDED` or `FAILED`. |
| `runStatus` | Canonical run status; matches `status`. |
| `dataStatus` | Dataset completeness: `COMPLETE`, `PARTIAL`, `NO_RESULTS`, or `FAILED`. |
| `actorName` | Actor display name. |
| `actorSlug` | Actor store slug. |
| `inventoryRank` | Catalog inventory rank recorded for provenance. |
| `recordCount` | Listing rows saved to the dataset. |
| `resultCount` | Alias of `recordCount`. |
| `listingCount` | Alias of `recordCount`. |
| `diagnosticCount` | Request or extraction issues recorded outside the dataset. |
| `diagnosticCodes` | Diagnostic codes collected during the run. |
| `sourceCount` | Unique public source URLs processed. |
| `queryCount` | Search queries represented by the source URLs. |
| `uniqueRecordCount` | Distinct listing URLs after deduplication. |
| `duplicateCount` | Rows discarded as duplicate URLs. |
| `requestedLimit` | Configured global listing cap. |
| `requestedMaxPages` | Configured page cap per source. |
| `requestCount` | Public API requests attempted. |
| `successfulRequests` | Successful public API responses. |
| `pagesFetched` | Successful search pages fetched. |
| `sourceTransport` | Transport used for the run. |
| `proxyConfigured` | Whether standard Apify Proxy routing was configured. |
| `fixtureMode` | Whether a repository-local fixture was used. |
| `fingerprintApplied` | Whether a browser fingerprint was applied; always `false` here. |
| `apiEndpoint` | Anonymous public API endpoint used for live requests. |
| `sourceUrls` | Unique public source URLs processed. |
| `generatedBy` | Generator metadata. |
| `generatedAt` | UTC summary creation time. |

| Status | Data status | Meaning |
| --- | --- | --- |
| `SUCCEEDED` | `COMPLETE` | Listings were saved without an extraction problem. |
| `SUCCEEDED` | `PARTIAL` | Listings were saved, but a later problem prevented a complete run. Saved rows remain available. |
| `SUCCEEDED` | `NO_RESULTS` | The source completed cleanly and returned no matching listings. |
| `FAILED` | `FAILED` | A fatal error occurred before any usable listing was saved. |

Example `OUTPUT` from the 2026-10-25 run:

```json
{
  "status": "SUCCEEDED",
  "runStatus": "SUCCEEDED",
  "dataStatus": "COMPLETE",
  "actorName": "Mercari Japan Scraper",
  "actorSlug": "mercari-japan-scraper",
  "inventoryRank": 94,
  "recordCount": 3,
  "resultCount": 3,
  "listingCount": 3,
  "diagnosticCount": 0,
  "diagnosticCodes": [],
  "sourceCount": 1,
  "queryCount": 1,
  "uniqueRecordCount": 3,
  "duplicateCount": 0,
  "requestedLimit": 3,
  "requestedMaxPages": 1,
  "requestCount": 1,
  "successfulRequests": 1,
  "pagesFetched": 1,
  "sourceTransport": "official_public_api",
  "proxyConfigured": false,
  "fixtureMode": false,
  "fingerprintApplied": false,
  "apiEndpoint": "https://api.mercari.jp/v2/entities:search",
  "sourceUrls": [
    "https://jp.mercari.com/search?keyword=iphone"
  ],
  "generatedBy": "Codex with GPT-5.6 Luna",
  "generatedAt": "2026-10-25T20:47:51.175Z"
}
```

### Coverage and limitations

The Actor queries the anonymous public Mercari Japan search API with bounded pages, a response-size cap, and deduplication by item URL. It does not crawl every Mercari category, read private seller data, or bypass access controls. Numeric condition, shipping, and category identifiers are retained exactly as published; labels are not guessed and no extra private request is made. Prices are point-in-time JPY values and can change after the run. Optional fields are omitted when the source does not publish them, and blocked, empty, or partial responses are reported in the run summary rather than written as data rows.

### Usage and support

Apify charges standard Actor compute, network, and storage usage. Start with a small `limit` and one source, inspect the dataset and `OUTPUT`, then scale pages and sources gradually. See the Actor's Pricing tab for current account rates. Use the [Actor Issues page](https://apify.com/w3crawler/mercari-japan-scraper/issues) to report a problem. Include the run ID, the input used, and the run summary; do not include tokens, cookies, or private data. This Actor is not affiliated with or endorsed by Mercari. Use it only for public data and in accordance with Mercari's terms, robots guidance, and applicable law.

# Actor input Schema

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

Public jp.mercari.com search or item URLs; these take precedence over keyword.

## `keyword` (type: `string`):

Search keyword used when startUrls is empty.

## `sort` (type: `string`):

Optional public search sort: score, created_time, or price.

## `order` (type: `string`):

Optional ascending or descending order: asc or desc.

## `status` (type: `array`):

Optional listing status filters: on_sale, sold_out, or trading.

## `priceMin` (type: `integer`):

Optional lower price bound from 0 through 1000000000.

## `priceMax` (type: `integer`):

Optional upper price bound from 0 through 1000000000.

## `limit` (type: `integer`):

Maximum listing records to emit across all sources.

## `maxPages` (type: `integer`):

Maximum public search API pages to request per source.

## `timeoutSecs` (type: `integer`):

Maximum wait for each public request.

## `maxBytes` (type: `integer`):

Maximum response size accepted for parsing.

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

Optional standard Apify Proxy routing; it does not bypass access challenges.

## Actor input object example

```json
{
  "sort": "",
  "order": "",
  "limit": 50,
  "maxPages": 1,
  "timeoutSecs": 30,
  "maxBytes": 5000000,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

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

Run status and counters stored by the Actor.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("w3crawler/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 = {}

# Run the Actor and wait for it to finish
run = client.actor("w3crawler/mercari-japan-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 '{}' |
apify call w3crawler/mercari-japan-scraper --silent --output-dataset

```

## MCP server setup

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