# Mercari Scraper - Japan & US Listings, Sold Prices & Sellers (`topapi/mercari-scraper`) Actor

Scrape Mercari Japan (jp.mercari.com, incl. Mercari Shops) and Mercari US listings by keyword, search URL, item or seller: price, on sale or sold, condition, brand, category, shipping, photos. Add-ons: item details, seller profiles, reviews, comments. Monitor mode. $1.30 / 1,000 JP listings.

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

## Pricing

from $1.30 / 1,000 mercari japan listings

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

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

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

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

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

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

# README

### What does Mercari Scraper do?

**Mercari Scraper** collects listings from **Mercari Japan** (jp.mercari.com, メルカリ, including Mercari Shops businesses) and **Mercari US** (mercari.com): search by keyword or paste a Mercari search URL with its filters, and get one row per listing with price, on-sale / sold status, condition, brand, category path, size, shipping, photos, seller and auction data. Resellers use it for sold-price comps and sourcing, import buyers to watch Japan, data teams for price research.

- 🔎 **Keywords, search URLs, item URLs / ids, Mercari Japan sellers and shops** in one run
- 🇯🇵 🇺🇸 **Both sites, one row shape**: prices in JPY or USD, Mercari's own English labels for condition, category path and shipping on Mercari Japan rows
- 🏷️ **Sold listings** for comps (status sold / in trade), price ranges, condition, category, brand, size, colour, shipping and seller-type filters
- ➕ **Add-ons**: item details, seller profiles, seller reviews (Mercari Japan), item comments (Mercari Japan)
- 🌐 **Free extras**: Mercari Japan's own English translation of titles and descriptions, a second currency at Mercari Japan's own exchange rate, a price-summary row per search
- 🔁 **Monitor mode** for schedules: only new listings (optionally price drops and status changes), alerts to a webhook, Slack, Discord or Telegram
- 🔓 No Mercari account, no cookies, no browser

### What data can you get from Mercari?

| | | |
|---|---|---|
| 🆔 `listing_id`, `url` | 💴 `price`, `currency`, `original_price` (US) | 🟢 `status`, `is_sold` |
| 📝 `title`, `title_en` | 🏷️ `brand_name`, `brand_id` | ✨ `condition`, `condition_id` |
| 🗂️ `category_path`, `category_id` | 📏 `size`, `colors` | 🏪 `is_shop_item`, `shop_name` |
| 🚚 `shipping_payer`, `shipping_method` | 📍 `shipping_from`, `shipping_days_max` | 💲 `shipping_fee`, `total_price` (US) |
| 🖼️ `photo_urls`, `thumbnail_url` | 🔨 `auction_highest_bid`, `auction_bid_deadline` | 📅 `created_at`, `updated_at`, `sold_at` (US) |
| ❤️ `likes`, `comments_count` | 👤 `seller_id`, `seller_name`, `seller_rating` | 📊 `sold_median_price`, `vs_sold_median_pct` |

### How to scrape Mercari with Mercari Scraper

1. Sign up for a free Apify account (it comes with monthly free credit) and open **Mercari Scraper**.
2. Type keywords such as `nintendo switch` or `ポケモンカード`, or paste Mercari URLs into **Mercari URLs**.
3. Pick the site (Mercari Japan, Mercari US or both) and, if you want, a status (sold for comps), sort, price range or condition.
4. Turn on the extras you need: item details, seller profiles, reviews, comments, translation, second currency, price summary.
5. Click **Start**, then export the dataset as JSON, CSV or Excel, or read it through the Apify API.

### ⬇️ Input

| Parameter | Type | Description |
|---|---|---|
| `searchQueries` | array | Keywords, one per line. Mercari URLs work here too. |
| `site` | string | `jp` (default), `us` or `both`. URLs keep their own site. |
| `startUrls` | array | Search URLs (with their filters), item URLs, Mercari Japan seller / shop URLs. |
| `urlsFromFile` | string | Many URLs: one per line, or a link to a .txt / .csv file. |
| `itemIds` | array | `m39088208848` or a Mercari Shops product id: one full row each. |
| `sellerIds` | array | Mercari Japan seller ids or Mercari Shops shop ids: their listings, newest first. |
| `status` | array | `on_sale` (default), `sold_out`, `trading`. Empty = every status. |
| `sort` / `order` | string | `score` (best match), `created_time`, `price`, `num_likes` (JP), `recently_sold` (US); `desc` / `asc`. |
| `priceMin` / `priceMax` | integer | In yen on Mercari Japan, dollars on Mercari US. |
| `conditions` | array | `new`, `like_new`, `good`, `fair`, `poor`, `bad` (JP). |
| `categoryIds`, `brandIds`, `sizeIds` | array | Mercari's own ids (the numbers in a search URL). |
| `shippingPayer` | string | `any`, `seller` (free shipping), `buyer`. |
| `colorIds`, `shippingFromAreaIds`, `shippingOptions`, `sellerType`, `excludeKeyword` | | Mercari Japan filters: colour, ship-from prefecture, anonymous shipping, individuals vs Mercari Shops, Mercari's exclude word. |
| `postedWithinDays`, `postedAfter`, `soldWithinDays` | | Date windows. |
| `includeKeywords`, `excludeKeywords`, `onlyBelowSoldMedian` | | Filters applied to each listing before it is charged. |
| `includeDetails`, `includeSellerProfiles`, `includeSellerReviews` (+ `maxReviewsPerSeller`), `includeComments` | boolean | Paid add-ons. |
| `includeTranslation`, `currency`, `priceSummary` | | Free extras (Mercari Japan translation and exchange rate; summary rows). |
| `monitorMode`, `monitorStoreName`, `monitorChanges`, `skipFirstRun`, `resetMonitor` | | Only new listings on a schedule. |
| `webhookUrl`, `slackWebhookUrl`, `discordWebhookUrl`, `telegramToken` + `telegramChatId`, `notificationLimit` | | Alerts after a run that found new listings. |
| `maxResults` (default 100), `maxResultsPerSearch`, `maxItemsPerSeller` | integer | Listing caps. 0 = no limit. |
| `proxyConfiguration`, `maxConcurrency` | | Optional. |

#### Input JSON

```json
{
  "searchQueries": ["ポケモンカード", "nintendo switch"],
  "site": "jp",
  "status": ["sold_out"],
  "priceMin": 1000,
  "includeDetails": true,
  "includeTranslation": true,
  "currency": "USD",
  "priceSummary": true,
  "maxResults": 500
}
```

#### Paste a Mercari link to reuse the filters you set on the site

Set up a search on jp.mercari.com or mercari.com (keyword, status, price, condition, category, brand, size, shipping), copy the address bar and paste it into **Mercari URLs**. The filters in the link are used as they are; the form's filters fill only what the link leaves out.

#### Sold listings for price comps

Set **Status** to sold. On Mercari Japan a sold search covers listings in trade too, as on the site. **Price summary per search** adds one row per search with the median, quartiles, minimum, maximum and mean of recent sold listings, the median asking price and the gap between them, and puts `sold_median_price` and `vs_sold_median_pct` on every listing. **Only below the sold median** keeps the on-sale listings priced under it.

#### More listings than one search shows

Mercari Japan serves up to 12,000 listings for one search in one order (100 pages of 120). Sorted by **Newest**, the run continues past that in creation-time windows. Mercari US pages show 50 listings per search; past them the run splits the search into price bands until every band fits, so a large Mercari US pull comes back in price-band order rather than strictly in the chosen order.

### ⬆️ Output

Each row has a `type`: `listing`, `seller` (Seller profiles), `review` (Seller reviews), `comment` (Comments) or `summary` (Price summary). A real Mercari Japan listing from a run on 2026-10-28 with Item details, translation, second currency and the price summary (shortened):

```json
{
  "site": "jp",
  "listing_id": "m64676372462",
  "url": "https://jp.mercari.com/item/m64676372462",
  "title": "TOMMY HILFIGER トミーヒルフィガー 襟付きワンピース 黒 白",
  "title_en": "TOMMY HILFIGER Collared Dress Black White",
  "price": 5800,
  "currency": "JPY",
  "price_converted": 38.57,
  "converted_currency": "USD",
  "status": "on_sale",
  "condition": "No noticeable scratches or marks",
  "brand_name": "TOMMY HILFIGER",
  "category_path": "Fashion > Women's Fashion > Dresses > Maxi Dresses & Long Dresses > Other > Long-Sleeve & Three-Quarter-Sleeve",
  "size": "M",
  "shipping_payer": "seller",
  "shipping_method": "RakuRaku Mercari Shipping",
  "shipping_from": "Kyoto",
  "likes": 5,
  "comments_count": 10,
  "seller_name": "まいやん",
  "seller_rating_count": 69,
  "sold_median_price": 4290,
  "vs_sold_median_pct": 35.2,
  "details_fetched": true
}
```

A real Mercari US listing with Item details (shortened):

```json
{
  "site": "us",
  "listing_id": "m25434065676",
  "title": "Nintendo Switch 2 Box",
  "price": 20,
  "original_price": 20,
  "currency": "USD",
  "status": "on_sale",
  "condition": "Good",
  "brand_name": "Nintendo",
  "category_path": "Electronics > Video games & consoles > Games",
  "shipping_payer": "buyer",
  "shipping_from": "New Mexico",
  "shipping_fee": 8.09,
  "total_price": 29.1,
  "buyer_protection_fee": 1.01,
  "likes": 11,
  "seller_name": "Ubaldo Orozco",
  "seller_sales_count": 367
}
```

A **seller** row carries `name`, `rating`, `rating_count`, good / normal / bad counts (JP), `listing_count`, `sales_count` (US), `follower_count` (JP), `joined_at`, verifications and `introduction`; a Mercari Shops seller row carries the shop's score and review count. A **review** row carries `fame` (good / normal / bad), `subject` (the seller reviewed as seller or as buyer), `message`, `reviewer_name` and `created_at`. A **comment** row carries `message`, `user_name`, `is_seller` and `created_at`.

#### Fields and how often they are filled

Measured 2026-10-28 on captured Mercari pages and answers (471 Mercari Japan search rows, 150 Mercari US search rows, item details of 15 Japan listings, 4 Mercari Shops products and 4 US listings) and on the platform runs below:

| Field | Mercari Japan | Mercari US |
|---|---|---|
| listing_id, url, title, price, status, condition, category_path, seller_id, thumbnail_url, photo_urls, created_at | 100% | 100% |
| brand_name | 51.6% (listings without a brand have none) | 93.3% |
| size | 25.7% (only items with sizes) | 33.3% |
| shipping_payer, shipping_method | 70.9% of search rows (Mercari Shops rows carry them with details); 100% with details | shipping payer with details |
| auction fields | the auction listings (2.5% of rows) | none (no auctions) |
| description, likes, photo_count, seller_name, seller_rating, shipping_from | 100% with Item details | 100% with Item details |
| comments_count, is_anonymous_shipping, attributes | 100% / 100% / 60-80% with details | none on Mercari US (attributes: authenticity and facets, 9 of 100) |
| total_price, buyer_protection_fee, shipping_class | none on Mercari Japan | 100% with details |
| sold_at, days_to_sell | Mercari Japan publishes no sale time | sold listings with details |
| colors | only when the seller set one (none in the samples measured) | 9 of 100 |
| title_en, description_en (translation) | 50 of 50 | none |

### How much does it cost to scrape Mercari?

Pay per event, no start fee:

| Event | Price | Charged when |
|---|---|---|
| Mercari Japan listing (`jp-listing`) | **$0.0013** ($1.30 per 1,000) | a Mercari Japan listing row is delivered |
| Mercari US listing (`us-listing`) | **$0.0009** ($0.90 per 1,000) | a Mercari US listing row is delivered |
| Item details (`item-details`) | $0.0013 | Item details is on and the listing's page data was read |
| Seller profile (`seller`) | $0.0013 | Seller profiles is on: once per seller per run |
| Seller review (`seller-review`) | $0.001 | Seller reviews is on: per review row |
| Comment (`comment`) | $0.0009 | Comments is on: per comment row |

Translation, the second currency and price-summary rows are not charged. An item URL / id row is read from the listing's page and costs one listing (its details come with it). Listings removed by a filter, duplicates and listings seen by earlier monitor runs are never charged. Set a maximum charge on the run and it stops cleanly at it.

| Example | Rows | Price |
|---|---|---|
| 100 Mercari Japan listings | 100 | $0.13 |
| 1,000 Mercari Japan listings | 1,000 | $1.30 |
| 100 Mercari US listings with item details | 100 + 100 | $0.22 |

Measured runs (Apify platform, 256 MB, 2026-10-28):

| Run | Rows | Time |
|---|---|---|
| `nintendo switch` on Mercari Japan, 20 listings (the prefill) | 20 | 2.9-3.6 s |
| `ポケモンカード` + `nintendo switch`, 1,000 listings | 1,000 | 9.1 s |
| `lululemon leggings` on Mercari US, 100 listings | 100 | 7.8 s |
| `nintendo switch` on both sites, 200 listings + every add-on + price summary | 200 + 200 details + 158 sellers + 166 reviews + 51 comments + 2 summaries | 65 s |
| `ワンピース`, 50 listings + every add-on + translation + USD + summary | 350 | 27 s |
| `スニーカー`, 1,740 listings + details + comments, restarted mid-run | 1,740 + 1,740 + 1,241 | 163 s |
| monitor poll with nothing new | 0 (nothing charged) | 2.1 s |

### Run it on a schedule

1. Turn on **Monitor mode** and give the schedule its own **Monitor name**.
2. Optional: **Skip first run** remembers what is listed now without delivering it, so the first scheduled run already returns only new listings; **Also price drops and status changes** re-delivers a listing seen before whose price fell or which sold (`change_type`, `previous_price`, `previous_status`). A listing an earlier run delivered without Item details is delivered once more with them when a later run turns Item details on (`change_type: "details"`).
3. Add a webhook, Slack, Discord or Telegram target for alerts.
4. Create an Apify **Schedule** (for example every 15 minutes). A poll reads newest first and stops where it meets listings an earlier run saw; a poll with nothing new charges nothing.

### Integrations, API & MCP

Run Mercari Scraper from the Apify API, the JavaScript or Python client, Make, Zapier, n8n, Google Sheets, webhooks, or the Apify MCP server for AI agents:

```bash
curl -X POST "https://api.apify.com/v2/acts/TopApi~mercari-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries":["ポケモンカード"],"site":"jp","status":["sold_out"],"maxResults":100}'
```

### Limits & empty runs

- Mercari Japan: up to 12,000 listings per search in one order; Newest reads past it. Mercari US: 50 listings per page; deeper reads split by price band (a band of one price with more than 50 listings returns 50 of them).
- Mercari US seller pages, seller listings and seller reviews are not supported: Mercari US serves them only through its app API, which refuses this actor's connection. Mercari US seller profile rows come from an item page and carry no follower count. Mercari Japan sellers, shops and reviews work.
- Mercari Shops have no review list in this actor; shop rows carry the shop's score and review count.
- Mercari US search rows carry no description or shipping payer; Item details adds them.
- A run that finds nothing says why in its status message (no listings, everything filtered, nothing new); an unreachable site ends the run with an error status and nothing charged.

### FAQ

#### How many listings can Mercari Scraper collect in one run?

As many as you set in `maxResults` (0 = no limit). Mercari Japan serves 12,000 per search in one order and the Newest order continues past that; Mercari US is read in pages of 50 and split by price band.

#### Can Mercari Scraper get sold listings and sold prices?

Yes. Set **Status** to sold (`sold_out`; in-trade listings are included on Mercari Japan). Turn on **Price summary per search** for the median and quartiles of recent sold prices.

#### Does Mercari Scraper cover Mercari Shops?

Yes, on Mercari Japan: Shops products come in searches (`is_shop_item: true`, `shop_name`), can be filtered with **Seller type**, and their details carry stock and the shop's score.

#### Can I translate Mercari Japan listings into English?

Yes. **English translation** adds Mercari Japan's own translation of the title and description (`title_en`, `description_en`) at no charge. Condition, category path, shipping method and ship-from prefecture are always in English.

#### Can I get prices in my currency?

Set **Second currency** (USD, EUR, GBP and 14 more). `price_converted` uses Mercari Japan's own exchange rate, free of charge.

#### Can I scrape one Mercari Japan seller's listings?

Paste the seller's profile URL (`jp.mercari.com/user/profile/…`) or put the id in **Seller ids**; a Mercari Shops page (`/shops/profile/…`) works too. Add **Seller profiles** and **Seller reviews** for the profile row and reviews.

#### Can I get only new Mercari listings every day?

Yes, turn on **Monitor mode** and schedule the actor. Each run returns only listings created since the previous run; a run with nothing new charges nothing.

#### Do I need a Mercari account, cookies or an API key?

No. Mercari Scraper reads what Mercari shows any visitor.

#### Can I use Mercari Scraper with the Apify API or an MCP server?

Yes: the API, the JavaScript and Python clients, and the Apify MCP server all run it with the same JSON input.

#### Why did my Mercari Scraper run return no listings?

The status message says which: no listings for the search, all removed by your filters, or nothing new in a monitor run. Check the keyword on the site, widen the price range or the status.

#### Your feedback

Found a problem or missing a field? Open an issue on the actor's **Issues** tab and it will be looked at.

# Actor input Schema

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

What you would type in Mercari's search box, one per line, e.g. "nintendo switch", "ポケモンカード", "lululemon leggings". Japanese and English keywords both work on Mercari Japan. Mercari URLs work here too.

## `site` (type: `string`):

The site keywords, item ids and seller ids are read on. URLs keep their own site.

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

Pages copied from your browser: searches with their filters (jp.mercari.com/search?keyword=…\&status=sold_out, mercari.com/search/?keyword=…\&itemStatuses=2-3), item pages (/item/m…, /us/item/m…, /shops/product/…), Mercari Japan seller and shop pages (/user/profile/…, /shops/profile/…).

## `urlsFromFile` (type: `string`):

Many URLs at once: paste them one per line, or one link to a .txt / .csv file that lists them.

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

Listing ids such as m39088208848 (on the chosen site) or Mercari Shops product ids. Each comes back as one full row with its details.

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

Mercari Japan seller ids (the number in /user/profile/123456789) or Mercari Shops shop ids: their listings, newest first. Mercari US seller pages are not supported (see Limits).

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

On sale, sold, or both. Sold also covers listings in trade, as on Mercari. Empty = every status.

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

Mercari's own order. Newest reads past the site's per-search window (12,000 on Mercari Japan, 1,000 on Mercari US) in creation-time windows.

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

With Price: asc = cheapest first. Mercari US has no oldest-first order.

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

In the site's currency: yen on Mercari Japan, dollars on Mercari US. e.g. 3000 (JPY) or 25 (USD).

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

In the site's currency: yen on Mercari Japan, dollars on Mercari US.

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

Mercari's condition grades. Empty = any condition.

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

Mercari category ids, e.g. 7002 (Nintendo Switch on Mercari Japan) or 84 (Video games & consoles on Mercari US). The number in a category URL's category_id / categoryIds.

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

Mercari brand ids, e.g. 15487 (Nintendo on Mercari Japan) or 4591 (Nintendo on Mercari US). The number in a URL's brand_id / brandIds.

## `sizeIds` (type: `array`):

Mercari size ids (size_id / sizeIds in a search URL).

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

Who pays shipping.

## `colorIds` (type: `array`):

Mercari Japan colour ids: 1 black, 2 white, 3 gray, 4 brown, 5 red, 6 pink, 7 purple, 8 blue, 9 beige, 10 green, 11 yellow, 12 orange.

## `shippingFromAreaIds` (type: `array`):

Prefecture ids 1-47 (1 Hokkaido … 13 Tokyo … 27 Osaka … 47 Okinawa).

## `shippingOptions` (type: `array`):

Mercari Japan's shipping filter.

## `sellerType` (type: `string`):

Mercari Japan lists items from individuals and from Mercari Shops businesses.

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

Mercari's own exclude filter (Mercari Japan), e.g. "ジャンク" or "case".

## `postedWithinDays` (type: `integer`):

Only listings created in the last N days (Mercari's own creation-time filter). 0 = any time. Pairs well with a daily schedule.

## `postedAfter` (type: `string`):

Only listings created on or after this date.

## `soldWithinDays` (type: `integer`):

Sold listings of the last N days. Mercari US filters by the moment of the sale; Mercari Japan publishes no sale time, so its last update stands for it. Sets Status to sold.

## `includeKeywords` (type: `array`):

Keep only listings whose title (or brand) contains every one of these words, e.g. "oled".

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

Drop listings whose title contains any of these words, e.g. "junk", "broken", "box only".

## `onlyBelowSoldMedian` (type: `boolean`):

Keep only on-sale listings priced under the median price of the same search's recent sold listings (turns on the price summary).

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

Read each listing's page data: full description, every photo, likes, comment count, ship-from area, shipping days and fee, attributes, hashtags, the seller's name and rating; Mercari US adds the sale time, total price with buyer protection and shipping class. Add-on: $0.0013 per listing.

## `includeSellerProfiles` (type: `boolean`):

One extra row per seller: rating and counts, listings, sales (US), followers, verification, join date, introduction. Charged once per seller per run: $0.0013.

## `includeSellerReviews` (type: `boolean`):

One row per review left on each seller: good / normal / bad, text, buyer or seller side, date, reviewer, feedback tags (US). $0.001 per review.

## `maxReviewsPerSeller` (type: `integer`):

Newest first.

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

One row per comment on each listing: text, time, commenter, whether the seller wrote it. $0.0009 per comment.

## `includeTranslation` (type: `boolean`):

Adds Mercari Japan's own English translation of each listing's title and description (title_en, description_en). Not charged.

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

Adds price_converted at Mercari Japan's own exchange rate. Not charged.

## `priceSummary` (type: `boolean`):

One summary row per search (not charged): median, quartiles, min, max and mean of recent sold listings, median asking price, ask-vs-sold gap, sell-through where Mercari's counts allow; every listing gets sold_median_price and vs_sold_median_pct.

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

Each run delivers only listings not delivered by earlier runs of the same search (newest first, stops at the first page with nothing new). An empty poll costs nothing.

## `monitorStoreName` (type: `string`):

Named key-value store that remembers what was delivered. Use a different name per independent monitor.

## `monitorChanges` (type: `boolean`):

Deliver a listing seen before again when its price dropped or its status changed (e.g. sold), with change_type, previous_price and previous_status.

## `skipFirstRun` (type: `boolean`):

The first monitor run only remembers the current listings (nothing delivered, nothing charged); later runs deliver what is new.

## `resetMonitor` (type: `boolean`):

Forget what this monitor delivered before.

## `webhookUrl` (type: `string`):

POST the new listings (JSON) to your endpoint after each run that found some.

## `slackWebhookUrl` (type: `string`):

Slack incoming-webhook URL for a short message with the new listings.

## `discordWebhookUrl` (type: `string`):

Discord channel webhook URL.

## `telegramToken` (type: `string`):

Your Telegram bot's token (with the chat id below).

## `telegramChatId` (type: `string`):

The chat or channel id the bot posts to.

## `notificationLimit` (type: `integer`):

How many listings each alert message names.

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

Total listing rows per run (seller, review, comment and summary rows not counted). 0 = no limit. Mercari serves up to 12,000 listings per Japan search and 1,000 per US search in one order; newest-first reads past both.

## `maxResultsPerSearch` (type: `integer`):

Cap for each keyword or URL. Empty or 0 = only the total cap.

## `maxItemsPerSeller` (type: `integer`):

Cap for each seller id or seller / shop URL. Empty or 0 = only the total cap.

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

Optional. Without it the run reads directly and moves to Apify's datacenter, then residential proxy only if Mercari refuses.

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

Requests in flight for details, profiles and translations.

## Actor input object example

```json
{
  "searchQueries": [
    "nintendo switch"
  ],
  "site": "jp",
  "status": [
    "on_sale"
  ],
  "sort": "score",
  "order": "desc",
  "shippingPayer": "any",
  "sellerType": "any",
  "onlyBelowSoldMedian": false,
  "includeDetails": false,
  "includeSellerProfiles": false,
  "includeSellerReviews": false,
  "maxReviewsPerSeller": 20,
  "includeComments": false,
  "includeTranslation": false,
  "currency": "none",
  "priceSummary": false,
  "monitorMode": false,
  "monitorStoreName": "mercari-monitor",
  "monitorChanges": false,
  "skipFirstRun": false,
  "resetMonitor": false,
  "notificationLimit": 10,
  "maxResults": 20,
  "maxConcurrency": 8
}
```

# Actor output Schema

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

One item per Mercari listing, plus seller, review, comment and price-summary rows when those options are on (type tells them apart).

## `summary` (type: `string`):

Per-search counts (read, delivered, filtered, duplicates, seen before), egress route, requests and charges.

# 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"
    ],
    "site": "jp",
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("topapi/mercari-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"],
    "site": "jp",
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("topapi/mercari-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 '{
  "searchQueries": [
    "nintendo switch"
  ],
  "site": "jp",
  "maxResults": 20
}' |
apify call topapi/mercari-scraper --silent --output-dataset

```

## MCP server setup

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