# Mercari JP $0.8💰 URL | Keyword | Review Scraper (`abotapi/mercari-jp-scraper`) Actor

Scrape items, sellers, and reviews from Mercari Japan (jp.mercari.com) at scale. Pull listing names, prices, conditions, all photos, shipping details, full seller descriptions, and rich seller profiles. Two input modes: keyword search with nine filters, or pass URLs directly.

- **URL**: https://apify.com/abotapi/mercari-jp-scraper.md
- **Developed by:** [AbotAPI](https://apify.com/abotapi) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 results

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/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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

Scrape items, sellers, and reviews from Mercari Japan (jp.mercari.com) at scale. Pull listing names, prices, conditions, all photos, shipping details, full seller bios, and rich seller profiles (rating breakdown, sell count, star rating, follower counts, official-shop flag). Three input modes: keyword search with nine filters, paste marketplace URLs directly, or harvest every review left for one or more seller IDs. Output is structured JSON, ready for spreadsheets, dashboards, and pricing analysis.

### Why This Scraper?

- **90+ fields per listing**, all flat: id, name, price, condition, brand, category breakdown, all photo URLs, full shipping block (payer, method, fee, duration), plus a complete seller-profile block (introduction text, rating breakdown, sell count, star rating, follower / following counts, KYC and SMS-verified flags).
- **Search-first input**: type a keyword, pick filters; no need to hand-build URLs. Multi-keyword runs return representation from every keyword (proportional budget split).
- **URL mode** for power users: paste any jp.mercari.com URL: search pages, item pages, or `/user/profile/<id>` and `/user/reviews/<id>` profile pages all work in one input list.
- **Reviews mode**: pass one or more seller IDs and the actor surfaces every review left for those sellers as separate rows. Filter by subject (seller / buyer / both) and rating bucket (good / normal / bad).
- **Detail enrichment toggle**: turn on `fetchDetails` to pull full descriptions, all photos at original resolution, comments, hashtags, full category breakdown, and rich seller profile (bio, follower counts, polarized rating split). Turn off for fastest lean runs.
- **Filter at source, not after**: status, item condition, shipping-payer, price range, brand, category, exclude-keyword, sort, and order all flow into the upstream search; you pay for items you wanted, not items you filtered out.
- **Resilient session management**: automatic retries with exponential back-off keep long runs stable.

### Data You Get

> Sample shape: values are illustrative placeholders, not from a live listing.

#### Item rows (search / url modes)

| Field | Example |
|---|---|
| `id` | `m00000000000` |
| `kind` | `item` |
| `url` | `https://jp.mercari.com/item/m00000000000` |
| `itemType` | `marketplace` (or `shop`) |
| `name` | `Sample Listing Title` |
| `price` | `12000` |
| `currency` | `JPY` |
| `status` | `on_sale` |
| `itemCondition` | `like new` |
| `itemConditionId` | `2` |
| `itemConditionSubname` | `Sample condition description` |
| `categoryId` | `0` |
| `categoryName` | `Sample Category` |
| `categoryParentName` | `Sample Parent Category` |
| `categoryRootName` | `Sample Root Category` |
| `categoryPath` | `Sample Root > Sample Parent > Sample Category` |
| `itemBrandId` | `0` |
| `itemBrandName` | `Sample Brand` |
| `shippingPayer` | `seller` |
| `shippingPayerName` | `Sample shipping payer label` |
| `shippingMethodName` | `Sample shipping method` |
| `shippingFromArea` | `Sample prefecture` |
| `shippingDurationMinDays` | `1` |
| `shippingDurationMaxDays` | `2` |
| `shippingClassTotalFee` | `0` |
| `thumbnail` | `https://static.mercdn.net/thumb/item/webp/m00000000000_1.jpg` |
| `photos` | `["https://static.mercdn.net/item/detail/orig/photos/m00000000000_1.jpg"]` |
| `description` | `Full seller description text appears here when fetchDetails=true.` |
| `numLikes` | `0` |
| `numComments` | `0` |
| `comments` | `[{"userId":"0","userName":"Sample user","message":"Sample comment","createdAt":"2026-01-01T00:00:00+00:00"}]` |
| `hashtags` | `["sample-tag"]` |
| `metaTitle` | `Sample SEO title` |
| `metaSubtitle` | `Sample SEO subtitle` |
| `isAnonymousShipping` | `true` |
| `isOfferable` | `true` |
| `isCancelable` | `true` |
| `sellerId` | `000000000` |
| `sellerName` | `Sample seller name` |
| `sellerIntroduction` | `Sample seller bio text appears here when fetchDetails=true.` |
| `sellerScore` | `0` |
| `sellerNumSellItems` | `0` |
| `sellerNumRatings` | `0` |
| `sellerStarRating` | `5` |
| `sellerRatingsGood` | `0` |
| `sellerRatingsNormal` | `0` |
| `sellerRatingsBad` | `0` |
| `sellerPolarizedRatingsGood` | `0` |
| `sellerPolarizedRatingsBad` | `0` |
| `sellerFollowerCount` | `0` |
| `sellerFollowingCount` | `0` |
| `sellerCreatedAt` | `2020-01-01T00:00:00+00:00` |
| `sellerSmsVerified` | `true` |
| `sellerIsOfficial` | `false` |
| `sellerQuickShipper` | `false` |
| `sellerPhotoUrl` | `https://static.mercdn.net/members/resized/webp/000000000.jpg` |
| `sellerRaw` | full upstream `seller` block (verbatim — captures any field Mercari adds) |
| `sellerProfileRaw` | full upstream `/users/get_profile` block (verbatim) |
| `isLiked` | `false` |
| `isNoPrice` | `false` |
| `createdAt` | `2026-01-01T00:00:00+00:00` |
| `updatedAt` | `2026-01-01T00:00:00+00:00` |

Detail-only fields (description, comments, hashtags, full category breakdown, full shipping detail, complete seller profile including `sellerIntroduction` and follower counts) are populated only when `fetchDetails=true`. They appear as `null` placeholders otherwise so the row schema is identical across modes.

#### Review rows (reviews mode)

| Field | Example |
|---|---|
| `id` | `000000000:0000000000` (sellerId:pagerId, stable across runs) |
| `kind` | `review` |
| `url` | `https://jp.mercari.com/user/reviews/000000000` |
| `subject` | `seller` (or `buyer`) |
| `fame` | `good` (or `normal` / `bad`) |
| `message` | `Sample review text. May be empty when the rater left a rating without a comment.` |
| `createdAt` | `2026-01-01T00:00:00+00:00` |
| `pagerId` | `0000000000` |
| `raterId` | `000000000` |
| `raterName` | `Sample rater name` |
| `raterPhotoUrl` | `https://static.mercdn.net/members/resized/webp/000000000.jpg` |
| `sellerId` | `000000000` |
| `sellerProfileUrl` | `https://jp.mercari.com/user/profile/000000000` |
| `sellerName` | `Sample seller name` |
| `sellerIntroduction` | `Sample seller bio text` |
| `sellerScore` | `0` |
| `sellerNumRatings` | `0` |
| `sellerStarRating` | `5` |
| `sellerRatingsGood` | `0` |
| `sellerRatingsNormal` | `0` |
| `sellerRatingsBad` | `0` |
| `sellerFollowerCount` | `0` |
| `sellerFollowingCount` | `0` |
| `sellerIsOfficial` | `false` |
| `sellerPhotoUrl` | `https://static.mercdn.net/members/resized/webp/000000000.jpg` |

### How to Use

#### Search by keyword + filters

```json
{
  "mode": "search",
  "queries": ["nintendo switch"],
  "status": "on_sale",
  "sortBy": "created-desc",
  "maxPages": 5,
  "maxListings": 100,
  "fetchDetails": false,
  "proxy": { "useApifyProxy": true }
}
````

#### Multi-keyword run with price range

```json
{
  "mode": "search",
  "queries": ["iphone 15", "iphone 14", "iphone 13"],
  "status": "on_sale",
  "minPrice": 30000,
  "maxPrice": 80000,
  "sortBy": "price-asc",
  "maxPages": 10,
  "maxListings": 300,
  "proxy": { "useApifyProxy": true }
}
```

#### URL mode, multi-URL

```json
{
  "mode": "url",
  "urls": [
    "https://jp.mercari.com/search?keyword=lego&category_id=1115",
    "https://jp.mercari.com/search?keyword=pokemon&sort=created_time&order=desc"
  ],
  "maxPages": 3,
  "maxListings": 200,
  "proxy": { "useApifyProxy": true }
}
```

#### Direct item-page URLs (skip search, go straight to detail)

```json
{
  "mode": "url",
  "urls": [
    "https://jp.mercari.com/item/m00000000001",
    "https://jp.mercari.com/item/m00000000002"
  ],
  "fetchDetails": true,
  "proxy": { "useApifyProxy": true }
}
```

When the URL is an item-page URL the actor goes straight to the detail endpoint, so every direct-item URL gets the full enriched record regardless of `fetchDetails`.

#### Reviews mode: harvest every review for one or more sellers

```json
{
  "mode": "reviews",
  "sellerIds": ["140382083", "204551080"],
  "reviewSubject": "seller",
  "reviewFame": ["good", "normal", "bad"],
  "maxPages": 5,
  "maxListings": 500,
  "proxy": { "useApifyProxy": true }
}
```

Each review becomes its own row. The seller's profile (name, bio, score, ratings breakdown, follower counts) is attached to every row, so a single CSV export already has the seller context next to each review.

#### URL mode shortcut for review pages

```json
{
  "mode": "url",
  "urls": [
    "https://jp.mercari.com/user/reviews/140382083",
    "https://jp.mercari.com/user/profile/204551080"
  ],
  "maxPages": 3,
  "proxy": { "useApifyProxy": true }
}
```

Both `/user/reviews/<id>` and `/user/profile/<id>` URLs are recognised: the actor surfaces every review for those sellers alongside any other URLs in the list.

### Input Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` (keyword + filters), `url` (paste marketplace URLs), or `reviews` (seller IDs). |
| `queries` | string\[] | `[]` | Search keywords (Search mode). Japanese and English both work. |
| `urls` | string\[] | `[]` | URLs (URL mode): jp.mercari.com/search?..., /item/..., /shops/product/..., /user/profile/..., /user/reviews/... |
| `sellerIds` | string\[] | `[]` | Numeric seller IDs (Reviews mode). Find one at the end of any /user/profile/ or /user/reviews/ URL. |
| `reviewSubject` | string | `seller` | `seller`, `buyer`, or `both` (Reviews mode). Whether to fetch reviews left for the user as seller, as buyer, or both. |
| `reviewFame` | string\[] | all 3 | Rating buckets to include (Reviews mode): any of `good`, `normal`, `bad`. |
| `status` | string | `on_sale` | Item status filter (Search mode): `any`, `on_sale`, `sold_out`, `trading`. |
| `itemCondition` | string\[] | `[]` | Numeric condition IDs: 1=new, 2=like new, 3=light wear, 4=some wear, 5=heavy wear, 6=poor. |
| `shippingPayer` | string | `any` | `any`, `seller` (free shipping), `buyer`. |
| `categoryIds` | string\[] | `[]` | Numeric category IDs (find via Mercari URL params: `category_id=...`). |
| `brandIds` | string\[] | `[]` | Numeric brand IDs (`brand_id=...`). |
| `sortBy` | string | `score-desc` | `score-desc`, `created-desc`, `created-asc`, `price-asc`, `price-desc`, `num-likes-desc`. |
| `minPrice` | integer | none | Min price in JPY. |
| `maxPrice` | integer | none | Max price in JPY. |
| `excludeKeyword` | string | empty | Items matching this term are filtered upstream. |
| `maxPages` | integer | 2 | Max pages per keyword / URL / seller. ~20 listings per page in Search/URL mode; up to 100 reviews per page in Reviews mode. |
| `maxListings` | integer | 0 | Cap across all keywords/URLs/sellers combined. 0 = unlimited (capped by maxPages). |
| `fetchDetails` | boolean | false | If true (Search/URL mode only), visit each item's detail page for full data. Adds one request per listing. |
| `proxy` | object | Apify default | Proxy settings. |

### Output Example

> Sample records: values are illustrative placeholders.

#### Item record (search / url modes)

```json
{
  "id": "m00000000000",
  "kind": "item",
  "url": "https://jp.mercari.com/item/m00000000000",
  "itemType": "marketplace",
  "name": "Sample Listing Title",
  "price": 12000,
  "currency": "JPY",
  "status": "on_sale",
  "itemCondition": "like new",
  "itemConditionSubname": "Sample condition description",
  "categoryId": "0",
  "categoryName": "Sample Category",
  "categoryPath": "Sample Root > Sample Parent > Sample Category",
  "itemBrandId": "0",
  "itemBrandName": "Sample Brand",
  "shippingPayer": "seller",
  "shippingPayerName": "Sample shipping payer label",
  "shippingMethodName": "Sample shipping method",
  "shippingFromArea": "Sample prefecture",
  "shippingDurationMinDays": 1,
  "shippingDurationMaxDays": 2,
  "thumbnail": "https://static.mercdn.net/thumb/item/webp/m00000000000_1.jpg",
  "photos": [
    "https://static.mercdn.net/item/detail/orig/photos/m00000000000_1.jpg",
    "https://static.mercdn.net/item/detail/orig/photos/m00000000000_2.jpg"
  ],
  "description": "Full seller description text appears here when fetchDetails=true.",
  "numLikes": 0,
  "numComments": 0,
  "hashtags": ["sample-tag"],
  "isAnonymousShipping": true,
  "isOfferable": true,
  "isCancelable": true,
  "sellerId": "000000000",
  "sellerName": "Sample seller name",
  "sellerIntroduction": "Sample seller bio text appears here when fetchDetails=true.",
  "sellerScore": 0,
  "sellerNumRatings": 0,
  "sellerStarRating": 5,
  "sellerFollowerCount": 0,
  "sellerFollowingCount": 0,
  "sellerCreatedAt": "2020-01-01T00:00:00+00:00",
  "sellerSmsVerified": true,
  "sellerIsOfficial": false,
  "createdAt": "2026-01-01T00:00:00+00:00",
  "updatedAt": "2026-01-01T00:00:00+00:00"
}
```

#### Review record (reviews mode)

```json
{
  "id": "000000000:0000000000",
  "kind": "review",
  "url": "https://jp.mercari.com/user/reviews/000000000",
  "subject": "seller",
  "fame": "good",
  "message": "Sample review message text.",
  "createdAt": "2026-01-01T00:00:00+00:00",
  "pagerId": "0000000000",
  "raterId": "000000000",
  "raterName": "Sample rater name",
  "raterPhotoUrl": "https://static.mercdn.net/members/resized/webp/000000000.jpg",
  "sellerId": "000000000",
  "sellerProfileUrl": "https://jp.mercari.com/user/profile/000000000",
  "sellerName": "Sample seller name",
  "sellerIntroduction": "Sample seller bio text",
  "sellerScore": 0,
  "sellerNumRatings": 0,
  "sellerStarRating": 5,
  "sellerRatingsGood": 0,
  "sellerRatingsNormal": 0,
  "sellerRatingsBad": 0,
  "sellerFollowerCount": 0,
  "sellerFollowingCount": 0,
  "sellerIsOfficial": false,
  "sellerPhotoUrl": "https://static.mercdn.net/members/resized/webp/000000000.jpg"
}
```

### Plan Requirement

This actor runs cleanly on the Apify Free plan. The default Apify Proxy group is sufficient; no residential or specialty proxies are required.

If you do choose residential, a Japan country pin (`apifyProxyCountry: JP`) gives you the same view a buyer in Japan sees: prices, shipping options, and inventory match exactly. Without a country pin you may occasionally see slightly different sponsored placements.

### Tips

- For large catalogue dumps (10K+ items per keyword), run multiple keywords in one job: the per-search budget split makes sure all keywords get representation, and a single actor run is faster and simpler than several.
- Leave `fetchDetails: false` for the fastest extraction. Turn on only if you need full descriptions, comment threads, hashtags, full category breakdowns, or rich seller profiles (introduction, follower counts, polarized rating split).
- `excludeKeyword` is applied upstream, so excluded items never count against your `maxListings` budget.
- In Reviews mode, each page returns up to 100 reviews. Walking 5 pages covers 500 reviews per seller; raise `maxPages` for sellers with thousands of ratings.
- The `id` of a review row is `<sellerId>:<pagerId>`, stable across runs, so re-running the same input produces the same dataset row IDs and incremental sync stays simple.

# Actor input Schema

## `mode` (type: `string`):

How to find data to scrape. 'search' and 'url' return items; 'reviews' returns one row per review left for the listed seller IDs.

## `queries` (type: `array`):

Keywords to search for (Search mode only). Multi-keyword supported. Japanese and English both work. Each keyword runs its own paginated search; results are combined.

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

Listing availability status (Search mode only).

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

Result ordering (Search mode only). Default = relevance score.

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

Minimum price in JPY. Leave empty for no minimum.

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

Maximum price in JPY. Leave empty for no maximum.

## `itemCondition` (type: `array`):

Filter by condition (Search mode only). Multiple selectable. 1=New, 2=Like new, 3=No noticeable scratches, 4=Some scratches, 5=Damaged, 6=Poor condition.

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

Who pays shipping (Search mode only).

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

Numeric category IDs (Search mode only). Find IDs by inspecting any Mercari category URL — e.g. category\_id=859 = iPhone. Leave empty for all categories.

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

Numeric brand IDs (Search mode only). Found in Mercari URL params as brand\_id=...

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

Items matching this keyword are filtered out by the upstream search (Search mode only).

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

Direct Mercari Japan search or category URLs (URL mode only). Multi-URL supported. Filter-mode fields above are ignored. Pagination starts from the URL's page\_token and walks forward. /user/profile/<id> and /user/reviews/<id> URLs are also accepted: the actor surfaces every review for that seller.

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

Numeric seller IDs (Reviews mode only). Multi-seller supported; each seller's reviews are surfaced as separate rows. Find an ID at the end of any /user/profile/<id> or /user/reviews/<id> URL.

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

Whether to fetch reviews left for the user as seller, as buyer, or both (Reviews mode only).

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

Rating buckets to include (Reviews mode only). 'good' = positive, 'normal' = neutral, 'bad' = negative. Default = all three.

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

Maximum pages to walk per keyword / URL / seller. ~20 listings per page in Search/URL mode; up to 100 reviews per page in Reviews mode.

## `maxListings` (type: `integer`):

Cap across all keywords/URLs/sellers combined. Set 0 for unlimited (capped only by maxPages).

## `fetchDetails` (type: `boolean`):

If true (Search/URL mode only), the actor visits each listing's detail page to enrich the record with full description, all photos, comment count, like count, and seller rating breakdown (good/normal/bad). Adds one request per listing.

## `proxy` (type: `object`):

Apify Proxy default group is sufficient — Mercari Japan accepts requests from any geo. Country pin is optional.

## Actor input object example

```json
{
  "mode": "search",
  "queries": [
    "nintendo switch"
  ],
  "status": "on_sale",
  "sortBy": "score-desc",
  "itemCondition": [],
  "shippingPayer": "any",
  "categoryIds": [],
  "brandIds": [],
  "urls": [
    "https://jp.mercari.com/search?keyword=iphone&sort=price&order=asc"
  ],
  "sellerIds": [
    "140382083"
  ],
  "reviewSubject": "seller",
  "reviewFame": [
    "good",
    "normal",
    "bad"
  ],
  "maxPages": 5,
  "maxListings": 0,
  "fetchDetails": false,
  "proxy": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

# 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 = {
    "queries": [
        "nintendo switch"
    ],
    "itemCondition": [],
    "categoryIds": [],
    "brandIds": [],
    "urls": [
        "https://jp.mercari.com/search?keyword=iphone&sort=price&order=asc"
    ],
    "sellerIds": [
        "140382083"
    ],
    "reviewFame": [
        "good",
        "normal",
        "bad"
    ],
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/mercari-jp-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 = {
    "queries": ["nintendo switch"],
    "itemCondition": [],
    "categoryIds": [],
    "brandIds": [],
    "urls": ["https://jp.mercari.com/search?keyword=iphone&sort=price&order=asc"],
    "sellerIds": ["140382083"],
    "reviewFame": [
        "good",
        "normal",
        "bad",
    ],
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/mercari-jp-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 '{
  "queries": [
    "nintendo switch"
  ],
  "itemCondition": [],
  "categoryIds": [],
  "brandIds": [],
  "urls": [
    "https://jp.mercari.com/search?keyword=iphone&sort=price&order=asc"
  ],
  "sellerIds": [
    "140382083"
  ],
  "reviewFame": [
    "good",
    "normal",
    "bad"
  ],
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call abotapi/mercari-jp-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mercari JP $0.8💰 URL | Keyword | Review Scraper",
        "description": "Scrape items, sellers, and reviews from Mercari Japan (jp.mercari.com) at scale. Pull listing names, prices, conditions, all photos, shipping details, full seller descriptions, and rich seller profiles. Two input modes: keyword search with nine filters, or pass URLs directly.",
        "version": "1.0",
        "x-build-id": "Ug42PFICBReImkJZu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/abotapi~mercari-jp-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-abotapi-mercari-jp-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/abotapi~mercari-jp-scraper/runs": {
            "post": {
                "operationId": "runs-sync-abotapi-mercari-jp-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/abotapi~mercari-jp-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-abotapi-mercari-jp-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Search Mode",
                        "enum": [
                            "search",
                            "url",
                            "reviews"
                        ],
                        "type": "string",
                        "description": "How to find data to scrape. 'search' and 'url' return items; 'reviews' returns one row per review left for the listed seller IDs.",
                        "default": "search"
                    },
                    "queries": {
                        "title": "Search Keywords",
                        "type": "array",
                        "description": "Keywords to search for (Search mode only). Multi-keyword supported. Japanese and English both work. Each keyword runs its own paginated search; results are combined.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "status": {
                        "title": "Item Status",
                        "enum": [
                            "any",
                            "on_sale",
                            "sold_out",
                            "trading"
                        ],
                        "type": "string",
                        "description": "Listing availability status (Search mode only).",
                        "default": "on_sale"
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "score-desc",
                            "created-desc",
                            "created-asc",
                            "price-asc",
                            "price-desc",
                            "num-likes-desc"
                        ],
                        "type": "string",
                        "description": "Result ordering (Search mode only). Default = relevance score.",
                        "default": "score-desc"
                    },
                    "minPrice": {
                        "title": "Min Price (¥)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price in JPY. Leave empty for no minimum."
                    },
                    "maxPrice": {
                        "title": "Max Price (¥)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price in JPY. Leave empty for no maximum."
                    },
                    "itemCondition": {
                        "title": "Item Condition",
                        "type": "array",
                        "description": "Filter by condition (Search mode only). Multiple selectable. 1=New, 2=Like new, 3=No noticeable scratches, 4=Some scratches, 5=Damaged, 6=Poor condition.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "shippingPayer": {
                        "title": "Shipping Paid By",
                        "enum": [
                            "any",
                            "seller",
                            "buyer"
                        ],
                        "type": "string",
                        "description": "Who pays shipping (Search mode only).",
                        "default": "any"
                    },
                    "categoryIds": {
                        "title": "Category IDs",
                        "type": "array",
                        "description": "Numeric category IDs (Search mode only). Find IDs by inspecting any Mercari category URL — e.g. category_id=859 = iPhone. Leave empty for all categories.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "brandIds": {
                        "title": "Brand IDs",
                        "type": "array",
                        "description": "Numeric brand IDs (Search mode only). Found in Mercari URL params as brand_id=...",
                        "items": {
                            "type": "string"
                        }
                    },
                    "excludeKeyword": {
                        "title": "Exclude Keyword",
                        "type": "string",
                        "description": "Items matching this keyword are filtered out by the upstream search (Search mode only)."
                    },
                    "urls": {
                        "title": "Marketplace URLs",
                        "type": "array",
                        "description": "Direct Mercari Japan search or category URLs (URL mode only). Multi-URL supported. Filter-mode fields above are ignored. Pagination starts from the URL's page_token and walks forward. /user/profile/<id> and /user/reviews/<id> URLs are also accepted: the actor surfaces every review for that seller.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sellerIds": {
                        "title": "Seller IDs",
                        "type": "array",
                        "description": "Numeric seller IDs (Reviews mode only). Multi-seller supported; each seller's reviews are surfaced as separate rows. Find an ID at the end of any /user/profile/<id> or /user/reviews/<id> URL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "reviewSubject": {
                        "title": "Review Subject",
                        "enum": [
                            "seller",
                            "buyer",
                            "both"
                        ],
                        "type": "string",
                        "description": "Whether to fetch reviews left for the user as seller, as buyer, or both (Reviews mode only).",
                        "default": "seller"
                    },
                    "reviewFame": {
                        "title": "Review Rating Filter",
                        "type": "array",
                        "description": "Rating buckets to include (Reviews mode only). 'good' = positive, 'normal' = neutral, 'bad' = negative. Default = all three.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPages": {
                        "title": "Max Pages Per Search",
                        "minimum": 1,
                        "maximum": 750,
                        "type": "integer",
                        "description": "Maximum pages to walk per keyword / URL / seller. ~20 listings per page in Search/URL mode; up to 100 reviews per page in Reviews mode.",
                        "default": 5
                    },
                    "maxListings": {
                        "title": "Max Listings (Total)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap across all keywords/URLs/sellers combined. Set 0 for unlimited (capped only by maxPages).",
                        "default": 0
                    },
                    "fetchDetails": {
                        "title": "Fetch Item Details",
                        "type": "boolean",
                        "description": "If true (Search/URL mode only), the actor visits each listing's detail page to enrich the record with full description, all photos, comment count, like count, and seller rating breakdown (good/normal/bad). Adds one request per listing.",
                        "default": false
                    },
                    "proxy": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Apify Proxy default group is sufficient — Mercari Japan accepts requests from any geo. Country pin is optional."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
