# Mercari US Scraper: Sold Prices, Conditions & Sellers (`getascraper/mercari-us-scraper`) Actor

Scrape Mercari US (mercari.com) active and sold listings. Extract clean price, shipping, condition, and seller details directly as pages load. US proxy configuration included. $2.99 per 1,000 results.

- **URL**: https://apify.com/getascraper/mercari-us-scraper.md
- **Developed by:** [GetAScraper](https://apify.com/getascraper) (community)
- **Categories:** AI, E-commerce, Automation
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 listings

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Mercari US Scraper: Sold Prices, Conditions & Sellers

**Get structured listing data from mercari.com, including USD prices, condition labels, listing status, seller ID, and shipping fees.** Built for resellers, pricing analysts, and store owners who need Mercari US datasets in bulk, without manual exports, complex proxy setups, or fragile scraper keys that break easily.

### What does Mercari US Scraper do?

This Actor collects active and sold listings from any search query or category URL on Mercari US. Instead of relying on fragile webpage structures that break whenever the website changes its design, this scraper securely extracts real-time product information directly as the pages load.

It supports search queries with filters for pricing limits, item conditions, sort order, and listing status (active vs sold out). Scrolling and page transitions are handled automatically, and the run stops when your selected limit is reached.

### Why use Mercari US Scraper?

Mercari US is America's second-largest peer-to-peer secondhand marketplace. Resellers, dropshippers, and pricing analysts require stable access to listing and completed-sales data:

* **Sold Price Appraisal:** Extract historically sold items to evaluate what buyers actually paid. This is the single most valuable metric for identifying high-margin reselling opportunities.
* **Pricing Intelligence:** Pull competitor prices to feed your automated spreadsheets, calculating your exact profits after shipping fees.
* **Database Hydration:** Provide clean, structured secondary-market listings to your automated pipelines (like Airtable, Excel, or Google Sheets).

### How to use Mercari US Scraper

1. **Configure input:** Open the Input tab in your Apify Console.
2. **Enter a keyword or URL:** Provide a search keyword or paste a valid `mercari.com` search URL directly.
3. **Apply status filters:** Set the status to `["on_sale"]` for active items, or `["sold_out"]` to extract completed sold price history.
4. **Select item conditions:** Optionally narrow down by conditions such as `["new"]` or `["like_new"]`.
5. **Set limits:** Specify a result cap (default: 1,000) and click Start.

### Input

| Field | Type | Description |
|---|---|---|
| `startUrls` | array | One or more Mercari US search, category, or listing URLs. |
| `keyword` | string | Search keyword query used if no `startUrls` are provided. |
| `sort` | string | Sort order: `relevance`, `price_asc`, `listed_time`, `price_desc`. |
| `status` | array | Listing status filter: `on_sale`, `sold_out`. Default: `["on_sale"]`. |
| `priceMin` | integer | Minimum price filter in USD. |
| `priceMax` | integer | Maximum price filter in USD. |
| `condition` | array | Condition labels: `new`, `like_new`, `good`, `fair`, `poor`. |
| `limit` | integer | Max listings to extract per query. Default: 1,000. |
| `proxyConfiguration` | object | Proxy settings. US rotating residential proxies are recommended. |

### Output

Each listing is returned as a structured JSON record inside the Apify dataset. You can download the dataset in JSON, CSV, Excel, or HTML format.

Example output record:

```json
{
  "type": "listing",
  "id": 0,
  "url": "https://www.mercari.com/us/item/m78912345678/",
  "listing_id": "m78912345678",
  "title": "Vintage Patagonian Fleece Jacket Size L",
  "description": "Retro fleece jacket in excellent shape, no stains.",
  "price": 45,
  "original_price": 120,
  "currency": "USD",
  "listing_status": "active",
  "condition_id": "like_new",
  "brand": "Patagonia",
  "size": "L",
  "color": "Blue",
  "category_path": ["Men", "Coats & jackets", "Fleece Jacket"],
  "authenticated": false,
  "likes_count": 14,
  "thumbnail_url": "https://images.mercdn.net/item/m78912345678_1.jpg",
  "media": {
    "image_urls": ["https://images.mercdn.net/item/m78912345678_1.jpg"]
  },
  "seller_id": "89123456",
  "seller_username": "retro_finds_us",
  "seller_rating_score": 4.9,
  "seller_review_count": 112,
  "sales_count": 94,
  "shipping_payer": "buyer",
  "shipping_fee": 7.99,
  "item_location": "OR",
  "scrape_context": {
    "scraped_time": 1777464674689
  }
}
````

### Data table

| Field | Description |
|---|---|
| `type` | Always `listing`. |
| `url` | Full listing URL on `mercari.com`. |
| `listing_id` | Mercari US item ID (e.g. `m78912345678`). |
| `title` | Listing title. |
| `description` | Product text description. |
| `price` | Price in USD (float). |
| `original_price` | Retail price in USD (if available). |
| `currency` | Always `USD`. |
| `listing_status` | Status code: `active` or `sold`. |
| `condition_id` | Condition rating: `new`, `like_new`, `good`, `fair`, `poor`. |
| `brand` | Product brand name. |
| `size` | Sizing information (e.g. `XL`, `8.5`). |
| `color` | Primary item color. |
| `category_path` | Array of strings representing category hierarchy. |
| `authenticated` | True if verified by Mercari Authenticate. |
| `likes_count` | Number of buyer favorites. |
| `thumbnail_url` | CDN-hosted primary image URL. |
| `media.image_urls` | List of all item photo URLs. |
| `seller_id` | Unique seller account identifier. |
| `seller_username` | Seller handle. |
| `seller_rating_score` | Average seller score out of 5 stars. |
| `seller_review_count` | Total reviews count. |
| `sales_count` | Total seller transactions. |
| `shipping_payer` | Who pays shipping: `seller` or `buyer`. |
| `shipping_fee` | Shipping rate in USD. |
| `item_location` | Sourcing state or city origin. |

### Pricing

Running this Actor costs approximately $2.99 per 1,000 results. A run of 500 listings typically completes in 2 to 3 minutes.

### Tips

- **Use proxies in production:** Enable rotating proxies. Mercari US blocks search requests in large batches without rotating IP addresses.
- **Validate first:** Set the `limit` to 20-50 to check field coverage before running larger datasets.
- **Deduplication:** Adding multiple category URLs to `startUrls` will automatically deduplicate identical listing IDs inside the same run session.

### FAQ, disclaimers, and support

**Can I scrape completed sold price history?** Yes. Set the `status` field to `["sold_out"]` in the inputs.

**How does this differ from other Mercari scrapers?** Other scrapers rely on complex technical coding keys that break whenever the website's layout changes. This Actor reads the data directly as the browser receives it, making it much more reliable and stable.

**Is this compliant?** This Actor extracts public listings from `mercari.com` for research and comparison purposes. Users are responsible for ensuring their use complies with local laws, regulations, and platform terms of service.

**Support:** Open an issue in the Actor's Issues tab in your Apify Console.

# Actor input Schema

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

Paste one or more Mercari US web links (search pages, categories, or individual items) to scrape directly.

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

Optional search term (like 'apple watch' or 'vintage leather jacket') used if you do not paste any Start URLs above.

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

Choose how to sort the search results.

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

Filter by item availability. Select 'on\_sale' to find active items, or 'sold\_out' to check historically sold prices.

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

Optional minimum price in US Dollars. Filters out cheaper items.

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

Optional maximum price in US Dollars. Caps search results.

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

Optional item condition filters (e.g. 'new', 'like\_new', 'good', 'fair', 'poor').

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

Maximum number of listings to save on this run (e.g. 50 or 100). Default is 1000.

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

Specify the proxy servers to use for anti-scraping measures. US rotating proxies are strongly recommended.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.mercari.com/search/?keyword=apple%20watch"
    }
  ],
  "sort": "relevance",
  "status": [
    "on_sale",
    "sold_out"
  ],
  "condition": [
    "new",
    "like_new",
    "good",
    "fair",
    "poor"
  ],
  "limit": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `results` (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",
        "sold_out"
    ],
    "condition": [
        "new",
        "like_new",
        "good",
        "fair",
        "poor"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("getascraper/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",
        "sold_out",
    ],
    "condition": [
        "new",
        "like_new",
        "good",
        "fair",
        "poor",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("getascraper/mercari-us-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.mercari.com/search/?keyword=apple%20watch"
    }
  ],
  "status": [
    "on_sale",
    "sold_out"
  ],
  "condition": [
    "new",
    "like_new",
    "good",
    "fair",
    "poor"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyCountry": "US"
  }
}' |
apify call getascraper/mercari-us-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mercari US Scraper: Sold Prices, Conditions & Sellers",
        "description": "Scrape Mercari US (mercari.com) active and sold listings. Extract clean price, shipping, condition, and seller details directly as pages load. US proxy configuration included. $2.99 per 1,000 results.",
        "version": "0.1",
        "x-build-id": "XKLf4E2aFbE2xQ3oF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/getascraper~mercari-us-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-getascraper-mercari-us-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/getascraper~mercari-us-scraper/runs": {
            "post": {
                "operationId": "runs-sync-getascraper-mercari-us-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/getascraper~mercari-us-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-getascraper-mercari-us-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "proxyConfiguration"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Paste one or more Mercari US web links (search pages, categories, or individual items) to scrape directly.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Optional search term (like 'apple watch' or 'vintage leather jacket') used if you do not paste any Start URLs above."
                    },
                    "sort": {
                        "title": "Sort",
                        "enum": [
                            "relevance",
                            "price_asc",
                            "listed_time",
                            "price_desc"
                        ],
                        "type": "string",
                        "description": "Choose how to sort the search results.",
                        "default": "relevance"
                    },
                    "status": {
                        "title": "Listing Status",
                        "type": "array",
                        "description": "Filter by item availability. Select 'on_sale' to find active items, or 'sold_out' to check historically sold prices.",
                        "default": [
                            "on_sale"
                        ]
                    },
                    "priceMin": {
                        "title": "Min Price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional minimum price in US Dollars. Filters out cheaper items."
                    },
                    "priceMax": {
                        "title": "Max Price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional maximum price in US Dollars. Caps search results."
                    },
                    "condition": {
                        "title": "Item Conditions",
                        "type": "array",
                        "description": "Optional item condition filters (e.g. 'new', 'like_new', 'good', 'fair', 'poor').",
                        "default": []
                    },
                    "limit": {
                        "title": "Maximum Listings",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of listings to save on this run (e.g. 50 or 100). Default is 1000.",
                        "default": 1000
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Specify the proxy servers to use for anti-scraping measures. US rotating proxies are strongly recommended.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
