# Mercari US Scraper: Listings, Sold Prices (`automation_craft/mercari-us-scraper`) Actor

Mercari US scraper for resellers: mercari.com listings and sold items by keyword, category, brand, seller or search link. Rows carry the dollar price, status, condition, size, colour and photos; add sale dates, days to sell, price summaries with a buy price, or a new listing monitor. No login.

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

## Pricing

from $0.95 / 1,000 listings

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

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

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

### Mercari US Scraper: Listings, Sold Prices

**Scrape Mercari US** (www.mercari.com) listings by keyword, category, pasted search link, seller or brand: title, price in
dollars, original price and discount, status (on sale, sold, in trade), condition, brand, size, colour, category and photos.
Get sold listings with the moment of each sale and days to sell, a price summary per search with a suggested buy price,
descriptions straight from the search, and every listing's details on request: shipping, the Buyer Protection fee and the
seller's rating and sales. Give the run a monitor name and schedule it: each run then delivers only the listings that are
new, or also the ones whose price or status changed.

No Mercari account, no cookies, no API key, no browser. The Actor reads only what Mercari US shows every visitor and checks
on every page that Mercari applied the search exactly as you sent it.

This Actor is not affiliated with Mercari, Inc.

#### Who uses it

- **Resellers and flippers pricing their stock**: sold and in trade listings of a model, with the moment of each sale, the
  median, quartiles and days to sell in one summary row, and a suggested highest buy price at your margin.
- **Sourcing and deal hunting**: a monitor on a brand, size and price band, with free shipping or deals only, delivered once
  per listing to a spreadsheet, Slack or e-mail through Apify's integrations, with price drops on request.
- **Price research and data teams**: one documented schema through the Apify API, more than the 1,000 listings Mercari serves
  to one search, and the category tree in Mercari's own names.

### Quick start

1. Type what you want in **Keywords** (`pokemon card`, `nike dunk`, `lululemon`), or paste **Search links** copied from
   www.mercari.com (a search, a category page or a brand page), or give **Sellers**, **Brands** or **Listing links**.
2. Optionally set a **Status** (`sold` and `trading` for sold comparables), a price range, conditions, sizes, colours, free
   shipping, deals only, or a sold within days window.
3. Turn on **Include descriptions** (no extra charge) or **Include details** for shipping, fees, the sale time and the
   seller's rating; turn on **Price summary per search** for the figures of each search.
4. Set **Maximum listings** and run. Each listing is one row; free coverage and status rows tell you what was read and why a
   search ended.

### What you get

One row per listing (`type: "listing"`). Measured fill rates from the rows of this Actor's platform test runs (2,699 distinct listings, 2026-10-13; details from 329 listings):

| Field | What it holds | Filled |
|---|---|---|
| `listingId`, `url`, `title`, `price`, `currency`, `status`, `imageUrl`, `photoUrls`, `createdAt`, `updatedAt` | the listing as Mercari shows it: the price in `USD` as a number, status `on_sale`, `sold` or `trading` | 2699 of 2699 |
| `originalPrice`, `discountPercent` | the price before the seller lowered it, and the discount | 2699 of 2699; discount on 217 rows |
| `condition`, `conditionId`, `categoryId`, `category`, `categoryPath` | Mercari US's own labels and category path | 2699 of 2699 |
| `brand`, `brandId` | the brand Mercari shows | 2585 of 2699 (96%) |
| `size` | the size Mercari shows | 1426 of 2699 (53%) |
| `color` | the colour, only when the seller set one | 11 of 2699 (0%) |
| `promoted` | a paid listing Mercari moved up the order | 145 of 2699 rows promoted |
| `searchScore` | Mercari's own relevance score (best match order) | 9 of 22 best match rows |
| `sold` | true on sold and in trade rows | 2699 of 2699 (138 sold or in trade) |
| `soldAt`, `daysToSell` | the moment of the sale Mercari keeps and the days from listing to sale (details) | 10 of 10 sold or in trade rows with details |
| `description` | the full description (Include descriptions, or details) | 329 of 329 rows with details; 33 rows from the search alone |
| `likes`, `shippingPayer`, `shippingIncluded`, `shippingFee`, `shippingFrom`, `shippingClass` | likes, who pays shipping, the fee, the state it ships from and the weight class (details) | 310 of 329 (94%) |
| `buyerProtectionFee`, `totalPrice` | Mercari's Buyer Protection fee and the price with it (details) | 329 of 329 |
| `acceptsOffers`, `inCartCount`, `authenticated` | offers accepted, people with it in their cart, Mercari Authenticate (details) | 329 of 329; authenticated true on 0 |
| `estimatedDelivery` | Mercari's delivery estimate (details; often empty for a visitor) | 12 of 329 (4%) |
| `sellerId`, `sellerName`, `sellerRating`, `sellerRatingCount`, `sellerSalesCount`, `sellerListingCount`, `sellerUrl` | the seller's public id, display name, rating with its count, sales count, number of listings and profile link (details) | 329 of 329 |
| `searchKind`, `searchKey`, `searchKeyword`, `searchCategoryId`, `searchSellerId`, `searchStatuses`, `searchSort`, `page`, `position`, `inputLabel`, `titleMatchesKeyword`, `countrySource` | the search, link or seller that found the listing, and your own label for it | search rows |
| `detailsIncluded` | `true` when the details were read and added (billed as Listing detail) | 100% |
| `monitorState`, `changedFields`, `previousPrice`, `previousStatus`, `priceChange`, `priceDirection`, `firstSeenAt`, `lastSeenAt`, `monitorNew` | a monitor's view of the listing: `new`, `changed`, `unchanged`, `reappeared` or `removed`, and what changed | monitor runs |

A real row with details (shortened, from a run on 2026-10-13):

```json
{
  "type": "listing",
  "market": "us",
  "listingId": "m41971762729",
  "url": "https://www.mercari.com/us/item/m41971762729/",
  "title": "Nintendo Switch Mario Kart Deluxe 8 / Super Smash Bros Ultimate / PGA Tour 2K21",
  "price": 50,
  "originalPrice": 55,
  "currency": "USD",
  "status": "trading",
  "sold": true,
  "condition": "Good",
  "brand": "Nintendo",
  "size": null,
  "categoryPath": "Electronics > Video games & consoles > Games",
  "createdAt": "2026-10-13T02:25:13.000Z",
  "soldAt": "2026-10-13T02:36:04.000Z",
  "daysToSell": 0,
  "detailsIncluded": true,
  "likes": 1,
  "shippingPayer": "buyer",
  "shippingFee": 7.97,
  "shippingFrom": "South Carolina",
  "shippingClass": "2 lb",
  "buyerProtectionFee": 2.08,
  "totalPrice": 65.84,
  "acceptsOffers": false,
  "authenticated": false,
  "sellerRating": 5,
  "sellerRatingCount": 69,
  "sellerSalesCount": 33,
  "sellerListingCount": 48,
  "searchKeyword": "nintendo switch"
}
```

With **Price summary per search** each search adds one row (`type: "priceSummary"`), from the listings it delivered. A real
one for 60 sold and in trade `nintendo switch` listings with a target margin of 40 percent (2026-10-13):

```json
{
  "type": "priceSummary",
  "searchLabel": "Mercari US \"nintendo switch\"",
  "currency": "USD",
  "listingsWithPrice": 60,
  "lowestPrice": 13,
  "percentile25": 29.7,
  "medianPrice": 40,
  "percentile75": 61.24,
  "highestPrice": 400,
  "averagePrice": 64.31,
  "soldShare": 1,
  "medianDaysToSell": null,
  "medianSoldPrice": 40,
  "targetMarginPercent": 40,
  "suggestedMaxBuyPrice": 24,
  "quartileRatio": 2.06,
  "wideSpread": false
}
```

It also carries the 10th and 90th percentiles, ten listings spread across the price range (`sampleListings`), and the
figures of each status apart when the search delivered more than one (`byStatus`). `wideSpread` is true when the upper
quartile is 3 or more times the lower one (a search that mixes different products). Days to sell (`medianDaysToSell`) count
the listings whose details were read: Mercari keeps the moment of the sale on the listing's detail. The suggested buy price
is the median price of the sold and in trade listings less your target margin, a rule of thumb that leaves out fees and
shipping.

Free rows, never charged:

- **One coverage row per search** (`type: "search"`): the count Mercari reports (`totalReported`), pages read, listings
  seen and delivered, listings already delivered in the run or known to the monitor, listings left out by filters,
  promoted listings left out, the creation time windows read (`creationWindows`), `complete`, `stoppedBy`, `capReached`, a
  note and, for a monitor, `newListingsMayLieBeyond`.
- **Status rows** (`type: "status"`): input that cannot be used (a brand name that names no single brand comes with the
  candidates), a seller name Mercari does not know, a listing link that no longer exists or a listing deleted between the
  search and its detail read (`not_found`), a detail that could not be read, a search Mercari did not apply as sent
  (`search_not_applied`, with what was sent and what Mercari applied), and why a run stopped (`limit_reached`).
- **A run summary** (`type: "summary"`) at the end: every counter, the events charged and the requests.

If you load the rows into your own database, the pair `type` plus `listingId` is the key of a listing row: use it as an
idempotency key, so a listing delivered again by a later run (a monitor's changed listing) updates its row instead of adding
one.

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

Pay per event, with Apify's Store discounts by plan:

| Event | Free plan | Bronze | Silver | Gold |
|---|---|---|---|---|
| Listing (one listing row) | $1.33 / 1,000 | $1.22 / 1,000 | $1.10 / 1,000 | $0.95 / 1,000 |
| Listing detail (the details of a delivered listing, only when details are read) | $1.40 / 1,000 | $1.30 / 1,000 | $1.10 / 1,000 | $1.00 / 1,000 |
| Price summary (one summary row per search, only with Price summary) | $2.00 / 1,000 | $2.00 / 1,000 | $1.80 / 1,000 | $1.60 / 1,000 |
| Listing check (a change monitor's re-read of a remembered listing, only with Check listings) | $0.60 / 1,000 | $0.60 / 1,000 | $0.54 / 1,000 | $0.48 / 1,000 |
| Results page (only in monitor runs: one results page read) | $0.60 / 1,000 | $0.60 / 1,000 | $0.60 / 1,000 | $0.60 / 1,000 |
| Actor start (once per run, flat, no plan discount) | $0.006 | $0.006 | $0.006 | $0.006 |

Platinum and Diamond plans pay the Gold price. The Store pricing card shows these same prices per 1,000 events: "$0.95 /
1,000" on the Listing row means one listing costs 0.095 cents at Gold (0.133 cents on the Free plan), and
"$1.60 / 1,000" on the Price summary row means one summary costs 0.16 cents at Gold.

Examples: 100 listings on the Free plan cost $0.006 + 100 x $0.00133 = $0.139. 1,000 listings with their details on the Gold plan cost $0.006 + 1,000 x ($0.00095 + $0.001) = $1.956. 200 sold listings with a price summary on the Free plan cost $0.006 + 200 x $0.00133 + $0.002 = $0.274. An hourly monitor of one keyword that reads 1 page and finds 10 new listings costs, on the Free plan, $0.006 + $0.0006 + 10 x $0.00133 = $0.0199 per run.

Free: listings left out by your filters, listings already delivered in the run (or in the dataset you resume from), listings
a monitor delivered before and that did not change (unless you ask for them with **Unchanged ones too**), listing links that
no longer exist, searches Mercari did not apply as sent, sellers Mercari does not know, invalid input, coverage rows, status rows and the summary. Descriptions from the
search (**Include descriptions**) cost nothing extra. A listing link is always read with its details, so each one delivered
is billed as Listing plus Listing detail. A monitor's Results page is charged once the page was read and Mercari echoed the
search as sent. With **Changes too**, a listing that changed is billed as a Listing again; with **Unchanged ones too** each
unchanged listing delivered is billed as a Listing; with **Check listings the searches no longer show** each answered
re-read is a Listing check, and each listing it finds sold, changed or removed is delivered and billed as a Listing (plus a
Listing detail with details for a changed one). These re-checks are bounded by **Maximum listing checks**, not by
**Maximum listings**.

### Input

Every keyword is searched in every category id you give (or in every department) and for every seller you give, at most 100
searches a run. A pasted link is a search of its own with the filters on it; the search filters below apply to keyword,
category, seller, brand and every listing searches, and the filters applied by this Actor apply to every search.

#### What to search

- **Keywords**: words as you would type them on Mercari US. Up to 100.
- **Search every listing**: the newest listings of all of Mercari US, without a keyword, with your filters.
- **Category ids**: the number in a category link (`www.mercari.com/us/category/796/` is video games); checked against Mercari
  US's own list of 3,233 categories, which the Actor carries.
- **Split by department**: each search read once in each of Mercari US's 17 departments (Women, Men, Electronics, Toys &
  Collectibles and the rest), each with its own reach of listings.
- **Search links**: links copied from www.mercari.com: a search (`https://www.mercari.com/search/?keyword=...`), a category
  page or a brand page, read with every filter on them as the site's own page reads them: keyword, categories, brands,
  conditions, statuses, sizes, free shipping, price, sold time, colour, deals and order. A link with a filter Mercari does not
  apply for a visitor (coupons, authenticity, shipping fees) is refused with the reason. Give a link as `{"url": "...",
  "label": "my search"}` and its rows carry your label.
- **Sellers**: profile links (`https://www.mercari.com/u/123456789/` or `/u/<username>/`) or numeric seller ids: their
  listings, filtered by the settings below. A username is looked up at Mercari once; an unknown one is a free row.
- **Listing links**: `https://www.mercari.com/us/item/m.../` or a bare `m...` id, each read with its details and delivered as
  given. Up to 5,000.
- **Brands**: names as Mercari US lists them (`Nike`, `lululemon athletica`, `Coach`) or brand ids; a name is used only when
  exactly one brand of Mercari US's own list (28,853 brands, which the Actor carries) carries it, otherwise a free row lists
  close names. With no keyword, the brands alone are searched.

#### Search filters (applied by Mercari and checked on every page)

- **Status**: `on_sale`, `sold`, `trading`, one or more (default `on_sale`). In trade is a listing a buyer paid for whose
  sale is not completed yet; Mercari marks it sold after the buyer's rating, a few days later.
- **Order**: newest first (the default), best match, price low to high, price high to low, oldest first, recently sold (sold
  and in trade listings, by the moment of the sale).
- **Price** in dollars; **Condition** (`new`, `like_new`, `good`, `fair`, `poor`); **Size ids**; **Colour** (Mercari US's 14;
  only listings whose seller set a colour); **Shipping paid by** (`seller` is free shipping, `buyer`); **Deals only**
  (below the original price); **Sold within days** (by the moment of the sale, with sold or in trade statuses); **Posted
  within days** (also checked on every row).

#### Filters applied by this Actor (a listing they leave out is free)

- **Exclude words**: listings whose title holds one of them are left out (each word of it starts a word of the title, so
  `lego` also leaves out `Legoland`).
- **Only titles with every keyword word** (Mercari also matches descriptions and related words).
- **Include promoted listings**: on by default; off leaves out the paid promoted listings Mercari moves up the order.

#### Details and add-ons

- **Include descriptions**: each row's full description, read from the search itself (no detail read, no extra charge).
- **Include details** (Listing detail): description, likes, shipping payer, fee, weight class, ships from state and delivery
  estimate, the Buyer Protection fee and total, whether offers are accepted, how many people have it in their cart, Mercari
  Authenticate, the moment of the sale and days to sell, and the seller's public id, display name, rating with its count,
  sales count, number of listings and profile link.
- **Price summary per search** (Price summary), with **Target margin for a suggested buy price** (a percent).

#### Limits and advanced

- **Maximum listings** (default 100: the listings the searches and links deliver; a monitor's re-checks have their own
  bound, **Maximum listing checks**), **Maximum listings per search**, **Maximum pages per search** (default 10, 100
  listings a page, up to 100 pages).
- **Seconds between requests**: a slower pace (1 to 5 seconds, one request at a time); empty is the normal pace of about
  0.7 seconds.
- **Resume from dataset**: the id of an earlier run's dataset; its listings are not delivered or charged again (a dataset of
  up to 200,000 rows; a larger one refuses the run, and only the start fee is charged).

### The monitor: new listings, and changes

Give the run a **Monitor name** (for example `nike-dunk-size-10`) and schedule it. Every run reads the newest pages of each
search up to **Maximum pages per search** and delivers the listings this monitor has not delivered before; listings it
delivered are free. Each results page a monitor reads is charged as a Results page. One monitor name belongs to one set of
settings (searches, filters, the details switch and the change mode); descriptions and the summary options can be switched
without a new name.

With **Changes too**, a listing the monitor delivered before whose price or status changed (a price drop, sold, in trade)
is delivered again with `monitorState: "changed"`, the changed fields, the previous price and status, the price change and
its direction, and when the monitor first and last saw it. **Unchanged ones too** delivers the known listings as well
(`unchanged`, each billed as a Listing). **Check listings the searches no longer show** re-reads up to **Maximum listing checks** remembered listings
on sale or in trade that no page of the run showed, longest unseen first, and delivers the ones that sold, changed their
price (`changed`) or were removed (`removed`); each answered re-read is a Listing check, and each row it delivers is a
Listing (these do not count toward **Maximum listings**).

### Caps and facts

- **One Mercari US search serves 1,000 listings** (10 pages of 100). In the newest and oldest orders this Actor goes on past
  them: it searches again for the listings created before (after) the last one it read, a creation time window that Mercari
  confirms on every page, so up to 100 pages reach up to 10,000 listings of one search (`creationWindows` on the coverage
  row). In the other orders a walk ends at 1,000 with `capReached: true`: narrow the search with a price band, a category
  or a condition, or use **Split by department**.
- **Best match on sold listings**: Mercari orders a search of sold or in trade listings only by the moment of the sale
  when best match is asked, so this Actor runs such a search (and such a pasted link) as recently sold: the rows carry
  `searchSort: "recently_sold"`, a link's coverage row notes it, and the run log says it for the setting.
- **Sold listings**: a sale shows as in trade first and as sold a few days later, when the sale completes; **Sold
  within days** reads both by the moment of the sale. Search rows carry no sale time; the details do (`soldAt`).
- **Colour** matches only listings whose seller set a colour, so a colour search returns fewer listings than the same
  search without it.
- **Promoted listings**: Mercari moves paid listings up every order (about half of the rows in best match); they carry
  `promoted: true`.
- **Every page is checked**: Mercari answers each search with the search it applied, and a page whose keyword, status,
  order, price, category, brand, size, condition, colour, shipping payer, deals, seller or time window differs from what was
  sent delivers nothing and ends that search with a free row.
- **Every row is checked**: a row whose brand, size, colour, condition, price, status, seller or creation time does not match
  your filters is left out free, and with details on, a detail that names another shipping payer or a sale outside the
  window is left out too.
- **Refusals**: Mercari US sits behind Cloudflare, which lets residential visitors in; when it refuses an address the run
  moves to a fresh one, at most 6 times a run, then stops reading with a free row (`source_unavailable`). The listings
  already delivered stay; what was not read is not charged (only the start fee is); run it again later. Refusals come in waves: on
  2026-10-13 between 07:10 and 08:15 UTC, 9 of 86 test runs ended this way, most of them runs reading many details
  (a long run of details meets more refusals); earlier that day none did.
- **Work that delivers nothing is bounded**: the requests that deliver no billed row are counted at what they cost the run,
  and a run may spend USD 0.0007 of them plus USD 0.00009 per listing, 0.00003 per listing detail and 0.00003 per Results
  page billed; then it stops with a free row that says so. A filter that almost no listing passes, or a long list of links
  that no longer exist, ends there; narrow the search or split the list.
- The Actor runs at 256 MB, fixed. A run writes at most 30 status rows of one kind about single listings, links or
  searches; the summary counts every one.
- The category, size, colour and brand lists are Mercari US's own, read on 2026-10-13; a category or size added later is
  refused as unknown until the lists are refreshed, a brand id is sent as given.

### FAQ

#### Is it legal to scrape Mercari?

This Actor reads only public listing data, without logging in, and delivers no contact field; e-mail addresses written
into a title or description are replaced. Whether your use is lawful depends on where you are, Mercari's
terms and what you do with the data, personal data included; that responsibility is yours.

#### Does Mercari have an official API?

Mercari US offers no public API for searching its listings. This Actor reads the same listing data Mercari's own web pages
load, with no key or account from Mercari, and gives you the rows through the Apify API (examples below).

#### How can I see sold items and the date they sold on Mercari?

Set **Status** to `sold`, `trading` or both (a listing a buyer just paid for is in trade until the sale completes) and the
**Order** to recently sold; **Sold within days** keeps the last days only. With **Include details** each row carries the
moment of the sale Mercari keeps (`soldAt`) and the days it took to sell, and **Price summary per search** adds the median,
quartiles and share sold.

#### How do I get alerts for new Mercari listings?

Give the run a **Monitor name** and schedule it on Apify: each run reads the newest pages of your searches and delivers only
the listings it has not delivered before, and with **Changes too** also price drops and status changes. Apify's integrations
send the new rows to e-mail, Slack, a spreadsheet or a webhook.

#### Why does this Actor run with limited permissions?

It needs no access to your other Apify data. It only writes to its own run's dataset and key-value store and, when you use a
monitor, to one named key-value store it creates itself for that monitor; with **Resume from dataset** it reads the one
dataset you name.

### What this Actor does not do

- No login, buying, offers, likes, messages or anything behind a Mercari account.
- No seller profiles, seller reviews or followers, and no seller id on search rows: only the public seller fields of the
  details row (id, display name, rating with its count, sales count, number of listings, profile link); a seller's listings
  are a search (**Sellers**).
- No most liked order: Mercari US serves none (18 order values measured on 2026-10-13).
- No proxy setting: Mercari US answers only Apify residential exits (datacenter addresses are refused), and every run uses
  them at no extra charge.
- No HTML description or pre promotion shipping fee: Mercari US serves the description as plain text, and its pre promotion
  fee was 0 on every listing measured.
- No coupon, authenticity or shipping fee filter: Mercari does not apply them for a visitor, or no listing row shows them.
- No Mercari Japan: this listing reads Mercari US only.
- No ready made tasks are published with this listing: start from the input form's example or the API examples below.
- No connectors of its own (Notion, Airtable, Linear): the dataset is the output, read through the Apify API or Apify's
  integrations (Make, Zapier, n8n, Google Sheets, Slack, webhooks), which use your own accounts there.
- No e-mail addresses: every word holding an e-mail address in a title or description is replaced (`[e-mail removed]`).
  Numbers a seller writes, phone numbers included, are delivered as written. Mercari US shows no seller phone number to
  a visitor who is not signed in, so there is no phone field.
- No views or the buyer of a sale: Mercari does not show them to a visitor.
- No photo download: photo addresses are in every row.

### API

```bash
curl -X POST "https://api.apify.com/v2/acts/automation_craft~mercari-us-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keywords": ["nintendo switch"], "statuses": ["sold", "trading"], "sort": "recently_sold", "soldWithinDays": 7, "priceSummary": true, "maxItems": 50}'
```

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation_craft/mercari-us-scraper').call({ searchUrls: ['https://www.mercari.com/search/?keyword=nike%20dunk&itemStatuses=2-3&sortBy=6'], maxItems: 50 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.filter((x) => x.type === 'listing'));
```

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("automation_craft/mercari-us-scraper").call(run_input={"brands": ["lululemon athletica"], "sizeIds": [3], "shippingPayer": "seller", "maxItems": 20})
rows = [x for x in client.dataset(run["defaultDatasetId"]).iterate_items() if x["type"] == "listing"]
```

#### A prompt for your AI assistant

Paste this into ChatGPT, Claude or another assistant to have it write the input for you:

```text
Write the JSON input for the Apify Actor automation_craft/mercari-us-scraper. Its settings: keywords (list), usCategoryIds
(list of Mercari US category ids), searchUrls (mercari.com links), sellerUrls (profile links or ids), listingUrls, brands
(names or ids), statuses (on_sale, sold, trading), sort (newest, best_match, price_low, price_high, oldest, recently_sold),
minPriceUsd, maxPriceUsd, conditions (new, like_new, good, fair, poor), sizeIds, colors, shippingPayer (seller = free
shipping, buyer), dealsOnly, soldWithinDays, postedWithinDays, excludeKeywords, includeDescriptions, includeDetails,
priceSummary, targetMarginPercent, maxItems, monitorName, monitorChanges. I want: <describe what you want>.
```

### Changelog

- 0.1 (2026-10): first version: keyword, category, department, search link, category and brand page, seller, brand and every
  listing searches; size, colour, free shipping, deals, sold and posted window filters; descriptions from the search; details
  with the sale time, fees and seller fields; past 1,000 listings per search in the newest and oldest orders; price summaries
  with a suggested buy price; a monitor of new and changed listings with re-checks; resume from a dataset; a slower pace.

### More data tools by Automation Craft

- [OfferUp Scraper: Local Listings, Prices, Sellers](https://apify.com/automation_craft/offerup-scraper)
- [Kijiji Scraper: Listings, Cars, Rentals & Prices](https://apify.com/automation_craft/kijiji-scraper)
- [Kleinanzeigen Scraper & API: Ads, Prices, Places](https://apify.com/automation_craft/kleinanzeigen-scraper)
- [Amazon Product Scraper - Search, Best Sellers](https://apify.com/automation_craft/amazon-data-scraper)
- [Amazon Sponsored Products Scraper - Ads by Keyword](https://apify.com/automation_craft/amazon-sponsored-products-scraper)
- [ShopBack Scraper: Cashback, Gift Cards, Affiliates](https://apify.com/automation_craft/affiliate-network-detector)
- [Airbnb Scraper: Prices, Calendar, Reviews](https://apify.com/automation_craft/airbnb-scraper)
- [Google Trends Scraper - Compare and Trending Now](https://apify.com/automation_craft/google-trends-scraper)

# Changelog

This Actor's version history is a separate document: https://apify.com/automation_craft/mercari-us-scraper/changelog.md

# Actor input Schema

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

Search words as you would type them on Mercari US, for example pokemon card, nike dunk or lululemon. Up to 100 keywords of up to 100 characters each.

## `searchAllListings` (type: `boolean`):

One search without a keyword: the newest listings of all of Mercari US (with your filters). Not together with keywords, categories, sellers or brands.

## `usCategoryIds` (type: `array`):

Mercari US category ids (the number in a category link such as www.mercari.com/us/category/796/), for example 796 for video games. Checked against Mercari US's own list of 3,233 categories shipped with this Actor; an id not on it is a free row. Every keyword is searched in every category.

## `splitByDepartment` (type: `boolean`):

Read each search once in each of Mercari US's 17 departments (Women, Men, Electronics, Toys & Collectibles and the rest), each with its own reach of listings. Not together with category ids; at most 100 searches a run, so up to 5 keywords.

## `searchUrls` (type: `array`):

Links copied from www.mercari.com: a search (www.mercari.com/search/?keyword=...), a category page (/us/category/...) or a brand page (/us/brand/...). Each becomes one search with the filters of the link (keyword, category, brand, condition, status, size, free shipping, price, sold time, colour, deals, order). A link with a filter Mercari does not apply for a visitor (coupons, authenticity, shipping fees) is refused with the reason, free. Up to 100 links, each a text or {"url": ..., "label": ...}.

## `sellerUrls` (type: `array`):

Seller profile links (www.mercari.com/u/<id or username>/) or numeric seller ids: each seller's listings are searched (with your keywords, if any). A username is looked up at Mercari once; an unknown one is a free row. Up to 100 sellers.

## `listingUrls` (type: `array`):

Links to single listings (www.mercari.com/us/item/m.../) or bare listing ids (m...). Each is read with its detail and delivered as given; the search filters do not apply to them. Up to 5,000.

## `brands` (type: `array`):

Brand names as Mercari US lists them (Nike, lululemon athletica, Coach) or brand ids (the number in a brand link). A name is matched against Mercari US's own brand list shipped with this Actor (28,853 brands) and used only when exactly one brand carries it; otherwise a free row lists close names. With no keyword, the brands alone are searched.

## `statuses` (type: `array`):

On sale, sold, in trade (a listing a buyer paid for whose sale is not yet completed; Mercari marks it sold after the buyer rates it). Default: on sale.

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

Newest first (the default; the order a monitor reads), best match, price low to high, price high to low, oldest first, or recently sold (sold and in trade listings only, by the moment of the sale). A search of sold or in trade listings only in best match is run as recently sold, the order Mercari applies to it.

## `minPriceUsd` (type: `number`):

Lowest price in US dollars, up to two decimals.

## `maxPriceUsd` (type: `number`):

Highest price in US dollars, up to two decimals.

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

New, like new, good, fair or poor (Mercari US's own five conditions).

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

Mercari US size ids (the sizeIds number in a search link), checked against Mercari US's own list of 384 sizes shipped with this Actor.

## `colors` (type: `array`):

Mercari US's colours. Mercari matches only listings whose seller set a colour, so a colour search returns fewer listings than the same search without it.

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

Seller: free shipping for the buyer (Mercari's own free shipping filter). Buyer: the buyer pays shipping.

## `dealsOnly` (type: `boolean`):

Only listings whose price is below their original price (Mercari's own deals filter; every delivered row is checked for it).

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

Only listings sold within this many days before the run started, by the moment of the sale Mercari keeps. Needs Status set to sold, in trade or both.

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

Only listings created within this many days before the run started. Sent to Mercari and checked on every row.

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

Leave out listings whose title holds one of these words (each word of it starts a word of the title: lego also leaves out Legoland).

## `onlyTitleMatches` (type: `boolean`):

Only listings whose title holds every word of the keyword (Mercari also matches descriptions and related words).

## `includePromoted` (type: `boolean`):

Mercari US moves paid promoted listings up the order. Turn off to leave them out (free).

## `includeDescriptions` (type: `boolean`):

Each listing's full description on its row, read from the search itself (no detail read and no extra charge).

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

Read each delivered listing's detail (the Listing detail event): description, likes, shipping payer, fee, class, ships from state and delivery estimate, Buyer Protection fee and total, offers, in carts, Mercari Authenticate, the moment of the sale and days to sell, and the seller's public id, display name, rating with its count, sales count and number of listings. Every filter is checked again on the detail.

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

One extra row per search (the Price summary event): count, lowest, highest, average and median price, quartiles, the share sold, the median days to sell of listings whose detail was read, and figures per status.

## `targetMarginPercent` (type: `integer`):

With a price summary: the suggested highest buy price, the median price of the sold and in trade listings less this percent. A rule of thumb that leaves out fees and shipping.

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

Listings delivered (and charged) at most by this run's searches and links. Default 100. A change monitor's re-checks (Check listings the searches no longer show) are bounded by Maximum listing checks instead.

## `maxItemsPerSearch` (type: `integer`):

Listings one search delivers at most (each search, link and seller apart).

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

Result pages (100 listings each) one search reads at most. Default 10. Mercari US serves 1,000 listings to one search; in the newest and oldest orders this Actor goes on in the next creation time window, so up to 100 pages reach up to 10,000 listings.

## `minSecondsBetweenRequests` (type: `integer`):

A slower pace: at least this many seconds (1 to 5) between two requests, one at a time. Leave it empty for the normal pace (about 0.7 seconds).

## `monitorName` (type: `string`):

A name for this monitor, up to 60 letters, digits, spaces and . \_ , - : # ( ). Each run then reads the newest pages, delivers the listings new to it, and pays one Results page event per page read.

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

Also deliver listings the monitor delivered before whose price or status changed since, with the previous price and status, the price change and its direction.

## `monitorDeliverUnchanged` (type: `boolean`):

With Changes too: also deliver the remembered listings that did not change (marked unchanged); each one delivered is billed as a Listing (and a Listing detail with details).

## `checkRemovedListings` (type: `boolean`):

With Changes too: re-read remembered listings on sale or in trade that this run's pages did not show (a Listing check per answered read), to learn whether they sold, changed price or were removed. Each one that sold, changed or was removed is delivered as a row and billed as a Listing (plus a Listing detail with details for a changed one). Bounded by Maximum listing checks, not by Maximum listings.

## `maxListingChecks` (type: `integer`):

Remembered listings re-read at most per run (default 100), the longest unseen first. These re-checks and the rows they deliver do not count toward Maximum listings.

## `resumeFromDatasetId` (type: `string`):

The id of an earlier run's dataset (17 letters and digits, from its Storage tab): the listings in it are not delivered or charged again. Up to 200,000 rows; a dataset that cannot be read refuses the run (only the start fee is charged).

## Actor input object example

```json
{
  "keywords": [
    "pokemon card"
  ],
  "searchAllListings": false,
  "splitByDepartment": false,
  "dealsOnly": false,
  "onlyTitleMatches": false,
  "includePromoted": true,
  "includeDescriptions": false,
  "includeDetails": false,
  "priceSummary": false,
  "maxItems": 20,
  "monitorChanges": false,
  "monitorDeliverUnchanged": false,
  "checkRemovedListings": false
}
```

# Actor output Schema

## `items` (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 = {
    "keywords": [
        "pokemon card"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation_craft/mercari-us-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 = {
    "keywords": ["pokemon card"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation_craft/mercari-us-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 '{
  "keywords": [
    "pokemon card"
  ],
  "maxItems": 20
}' |
apify call automation_craft/mercari-us-scraper --silent --output-dataset

```

## MCP server setup

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