# Mercari US Scraper (`parsebird/mercari-us-scraper`) Actor

Extract Mercari US (mercari.com) listings: title, price, brand, condition, size, color, category, seller, shipping, and photos from search, category, and item pages.

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

## Pricing

from $1.39 / 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

**Mercari US Scraper** extracts structured listing data from [Mercari US](https://www.mercari.com) — one of the largest consumer-to-consumer resale marketplaces in the United States — from search results, category pages, and individual item pages.

<table><tr>
<td style="border-left:4px solid #1C1917;padding:12px 16px;font-weight:600">
Pull title, description, price, brand, condition, size, color, category, seller rating, sales count, shipping, and photos for any Mercari US search, category, or listing URL — normalized into one consistent JSON schema.
</td>
</tr></table>

<br>

##### Copy to your AI assistant

```
Use the Apify Actor "parsebird/mercari-us-scraper" to scrape Mercari US (mercari.com). Call it with the Apify API or the apify-client SDK, e.g. in Python: `from apify_client import ApifyClient; client = ApifyClient("<APIFY_TOKEN>"); run = client.actor("parsebird/mercari-us-scraper").call(run_input={"startUrls": [{"url": "https://www.mercari.com/search/?keyword=apple%20watch"}], "sort": "relevance", "status": ["on_sale"], "condition": [], "limit": 25, "proxyConfiguration": {"useApifyProxy": True, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "US"}}); items = client.dataset(run["defaultDatasetId"]).list_items().items`. Inputs: startUrls (array of {url}, search/category/item URLs), keyword (string, used only if startUrls is empty), sort (relevance|listed_time|price_asc|price_desc), status (on_sale|sold_out, default on_sale), priceMin/priceMax (integer, USD), condition (new|like_new|good|fair|poor), limit (integer, default 25, max listings per start URL), proxyConfiguration (US residential proxy strongly recommended — Mercari US sits behind Cloudflare). Output: one JSON record per listing with listing_id, title, description, price, original_price, brand, condition_id, size, color, category_path, seller_id/seller_username/seller_rating_score, shipping_payer/shipping_fee, and media.image_urls. Full API spec: https://apify.com/parsebird/mercari-us-scraper/api. Get an API token at https://console.apify.com/account/integrations.
```

### What does Mercari US Scraper do?

Mercari US Scraper (also usable as a **Mercari API alternative** or **Mercari.com data extraction tool**) turns any `mercari.com` URL into structured JSON:

- 🔍 **Search & category pages** — pass a search URL (`?keyword=...`) or a category URL, and the Actor solves Mercari's Cloudflare challenge and collects listing IDs automatically
- 🏷️ **Individual item pages** — pass a direct `mercari.com/us/item/mXXXXXXXXXX/` URL to get full listing detail
- 🔀 **Mix URL types freely** — combine search, category, and item URLs in a single run, or skip URLs entirely and just search by **Keyword**
- ⚙️ **Filters** — sort by relevance, newest, or price; filter by listing status (on sale, sold out), condition (new, like new, good, fair, poor), and a min/max price range in USD
- 🧹 **Automatic deduplication** — the same listing found via multiple start URLs is only saved and charged once
- 📸 **Full listing detail on every result** — even listings discovered through search are individually re-fetched for their complete detail page data (description, full photo set, seller stats, shipping cost), not just the summary shown on the results grid

On top of the extraction logic, every run gets Apify platform features: [scheduling](https://docs.apify.com/platform/schedules) for recurring price monitoring, full [API access](https://docs.apify.com/api/v2) and [webhooks](https://docs.apify.com/platform/integrations/webhooks), ready-made [integrations](https://apify.com/integrations) with Zapier, Make, n8n, and Google Sheets, and one-click export to JSON, CSV, Excel, XML, HTML, or RSS.

### What data can you extract from Mercari US?

| Field | Description |
|-------|-------------|
| `listing_id` / `id` | Mercari item ID (e.g. `m78912345678`) as string and numeric form |
| `title` / `description` | Listing title and full text description |
| `price` / `original_price` | Current and original price in USD |
| `listing_status` | `active` or `sold` |
| `condition_id` | `new`, `like_new`, `good`, `fair`, or `poor` |
| `brand` / `size` / `color` | Item brand, size, and color when tagged |
| `category_path` | Full category breadcrumb, e.g. `["Men", "Coats & jackets", "Fleece Jacket"]` |
| `seller_id` / `seller_username` / `seller_rating_score` / `seller_review_count` / `sales_count` | Seller identity and reputation |
| `shipping_payer` / `shipping_fee` | Who pays shipping, and the rate in USD |
| `media.image_urls` / `thumbnail_url` | Full photo set and primary image |
| `likes_count` / `authenticated` | Buyer favorites count and Mercari Authenticate verification flag |

Full field-by-field reference is in the [Output example](#output-example) section below.

### How to use Mercari US Scraper

1. Open the Actor's **Input** tab in Apify Console.
2. Paste one or more `mercari.com` URLs into **Start URLs** — search pages, category pages, or item pages — or leave it empty and enter a **Keyword** instead.
3. (Optional) Set **Sort by**, **Listing status**, **Condition**, and **Min/Max price**.
4. Set **Max listings per URL** to control how many results each search or category seed collects.
5. Click **Start**. The Actor launches a real browser session to pass Mercari's Cloudflare check once, then reuses it for the rest of the run.
6. Export the dataset as JSON, CSV, Excel, XML, HTML, or RSS from the **Storage** tab, or pull it via the [Apify API](https://docs.apify.com/api/v2).

### Output example

```json
{
  "type": "listing",
  "id": 14214569688,
  "url": "https://www.mercari.com/us/item/m14214569688/",
  "listing_id": "m14214569688",
  "title": "Cash register",
  "description": "Gently used. Coins included. Light and sounds works",
  "price": 15.0,
  "original_price": 15.0,
  "currency": "USD",
  "listing_status": "active",
  "condition_id": "good",
  "brand": null,
  "size": null,
  "color": null,
  "category_path": ["Toys & Collectibles", "Learning & Education Toys", "Stem Toys"],
  "authenticated": false,
  "likes_count": 2,
  "thumbnail_url": "https://u-mercari-images.mercdn.net/photos/m14214569688_1.jpg?1779313257",
  "media": { "image_urls": ["https://u-mercari-images.mercdn.net/photos/m14214569688_1.jpg?1779313257"] },
  "seller_id": "955272082",
  "seller_username": "user955272082",
  "seller_rating_score": 5,
  "seller_review_count": 301,
  "sales_count": 293,
  "shipping_payer": "buyer",
  "shipping_fee": 7.97,
  "item_location": "Arizona",
  "scrape_context": { "scraped_time": 1789817761497 }
}
```

This is real, unmodified output captured while testing this Actor. Fields are best-effort — brand, size, and color are only present when the seller tagged them — so always null-check optional fields downstream. Use `type + ":" + id` as an idempotency key when deduplicating or upserting across runs.

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("parsebird/mercari-us-scraper").call(run_input={
    "startUrls": [{"url": "https://www.mercari.com/search/?keyword=apple%20watch"}],
    "sort": "relevance",
    "status": ["on_sale"],
    "limit": 25,
    "proxyConfiguration": {"useApifyProxy": True, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "US"},
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["price"])
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<APIFY_TOKEN>' });
const run = await client.actor('parsebird/mercari-us-scraper').call({
    startUrls: [{ url: 'https://www.mercari.com/search/?keyword=apple%20watch' }],
    sort: 'relevance',
    status: ['on_sale'],
    limit: 25,
    proxyConfiguration: { useApifyProxy: true, apifyProxyGroups: ['RESIDENTIAL'], apifyProxyCountry: 'US' },
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Use cases

- **Resale & arbitrage research** — compare Mercari US prices for electronics, sneakers, collectibles, and apparel
- **Sold-price tracking** — filter by `sold_out` status to build historical sold-price datasets
- **Brand and category monitoring** — watch a category or brand for new listings or price drops
- **Sourcing for dropshipping** — pull structured product and seller data for sourcing pipelines
- **Market research and ML pricing models** — feed normalized JSON directly into pricing or demand-forecasting models
- **Seller reputation research** — check a seller's rating, review count, and sales history before buying

### How it works

1. The Actor launches a [Camoufox](https://camoufox.com/) browser session over a US residential proxy and passes Mercari's Cloudflare Managed Challenge once.
2. Each start URL is classified as either an **item page** (`/us/item/mXXXXXXXXXX/`) or a **search/category page** (`/search/...`).
3. For search/category URLs (or a plain **Keyword**), the Actor builds a Mercari search URL from your filters, navigates to it using the already-warmed browser session (no repeated challenge-solving), and collects listing IDs from the page.
4. For every listing ID — whether from a direct item URL or discovered via search — the Actor fetches that item's own detail page (reusing the same warmed session) and reads its full data straight out of the page's embedded JSON.
5. Results are deduplicated by listing ID and pushed to the dataset.
6. Each search execution triggers one `search-performed` billing event; each unique listing saved triggers one `listing-scraped` billing event.

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

Mercari US Scraper uses Apify's [Pay-Per-Event](https://docs.apify.com/platform/actors/publishing/monetize#pay-per-event-pricing) pricing with two events, and your Apify plan tier automatically gets a lower rate:

| Event | Free | Bronze | Silver | Gold |
|-------|------|--------|--------|------|
| `listing-scraped` (per 1,000) | $1.99 | $1.79 | $1.59 | $1.39 |
| `search-performed` (per 1,000) | $39 | $37 | $35 | $33 |

`listing-scraped` fires once per unique listing saved. `search-performed` fires once per search/category start URL (or Keyword search) actually executed — including a search that returns no matches — because passing Mercari's Cloudflare check for a new search is the expensive part of every run; item detail pages reuse that same already-open session, which is why they're priced far lower. A run with 1 search and 25 listings on a Free Apify account costs about 1 × $0.039 + 25 × $0.00199 ≈ **$0.09**. Apify also gives every account a free monthly usage allowance that covers this Actor's platform (non-event) costs for light usage — see [Apify pricing](https://apify.com/pricing) for current plan details.

### FAQ

**Do I need a proxy?**
Yes. Mercari US sits behind Cloudflare, so a US residential proxy (the default `proxyConfiguration`) is strongly recommended for reliable runs.

**Can I scrape sold listings?**
Yes. Set **Listing status** to `sold_out` to pull sold listings' data.

**Why is `search-performed` so much more expensive than `listing-scraped`?**
Each new search has to pass Mercari's Cloudflare challenge, which needs a real, proxied browser session. Once that session is open, fetching individual item pages through it is comparatively cheap — see [How it works](#how-it-works).

**Can I filter by category or brand?**
Yes — include `categoryId`, `brandId`, `colorId`, `sizeId`, or `shippingPayerId` query parameters directly in a start URL (the same parameters `mercari.com/search` uses), and the Actor applies them automatically.

**Can I schedule recurring runs?**
Yes. Use Apify's [Scheduler](https://docs.apify.com/platform/schedules) to run this Actor daily, hourly, or on any custom interval, and pair it with [webhooks](https://docs.apify.com/platform/integrations/webhooks) or integrations to push new listings to Slack, Sheets, or your own API automatically.

**Something looks wrong or missing — where do I report it?**
Open an issue on the Actor's **Issues** tab in Apify Console. Mercari occasionally changes its page structure or Cloudflare rules, and we monitor and patch quickly.

**Can I call this from my own code instead of the Console?**
Yes — see the [Python and JavaScript examples](#python) above, or the full [API reference](https://apify.com/parsebird/mercari-us-scraper/api).

### Is it legal to scrape Mercari US?

Scraping publicly available data, such as listings visible to any visitor on `mercari.com` without logging in, is generally considered legal, but you're responsible for how you use the collected data and for complying with Mercari's own [Terms of Service](https://www.mercari.com/terms_of_service/) and applicable data protection laws in your jurisdiction. Avoid collecting personal data beyond what's needed, and don't use this Actor to overload Mercari's servers. Read more in Apify's blog post on [the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### Related Actors

- [Mercari Japan Scraper](https://apify.com/parsebird/mercari-japan-scraper) — listings, brand, seller, and auction data from Mercari Japan
- [AliExpress Scraper](https://apify.com/parsebird/aliexpress-scraper) — products and sellers from AliExpress
- [Walmart Product Scraper](https://apify.com/parsebird/walmart-product-scraper) — product data from Walmart.com
- [Target Product Scraper](https://apify.com/parsebird/target-product-scraper) — product data from Target.com
- [MercadoLibre Scraper](https://apify.com/parsebird/mercadolibre-scraper) — listings from MercadoLibre (Latin America)

# Changelog

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

# Actor input Schema

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

One or more mercari.com search, category, or item URLs. Leave empty to search by Keyword instead.

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

Search term used only if Start URLs is left empty.

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

Order search results by relevance, price, or listing date.

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

Restrict results to listings in these statuses.

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

Exclude listings priced below this amount, in US dollars.

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

Exclude listings priced above this amount, in US dollars.

## `condition` (type: `array`):

Restrict results to these item conditions. Leave empty to include all conditions.

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

Maximum number of listings to extract per search or category start URL (or per Keyword search). Use a low value for a quick test run.

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

Mercari US is behind Cloudflare — US rotating residential proxies are strongly recommended for reliable runs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.mercari.com/search/?keyword=apple%20watch"
    }
  ],
  "sort": "relevance",
  "status": [
    "on_sale"
  ],
  "limit": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "startUrls": [
        {
            "url": "https://www.mercari.com/search/?keyword=apple%20watch"
        }
    ],
    "status": [
        "on_sale"
    ],
    "limit": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/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 = {
    "startUrls": [{ "url": "https://www.mercari.com/search/?keyword=apple%20watch" }],
    "status": ["on_sale"],
    "limit": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/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 '{
  "startUrls": [
    {
      "url": "https://www.mercari.com/search/?keyword=apple%20watch"
    }
  ],
  "status": [
    "on_sale"
  ],
  "limit": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call parsebird/mercari-us-scraper --silent --output-dataset

```

## MCP server setup

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