# Yahoo Auctions Japan Sold Price Comps (ヤフオク落札相場) (`toshiboh/yahoo-auctions-japan-sold-price-comps`) Actor

Get real sold prices from Yahoo! Auctions Japan (ヤフオク) for any keyword: median, min/max, count, recent comps. JSON via API or MCP. No personal data.

- **URL**: https://apify.com/toshiboh/yahoo-auctions-japan-sold-price-comps.md
- **Developed by:** [Toshiboh](https://apify.com/toshiboh) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 summaries

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

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

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

**Get real sold prices from [Yahoo! Auctions Japan](https://auctions.yahoo.co.jp/) (ヤフオク) for any keyword** — median, min/max, quartiles, and a sample of the most recent closed listings. Built for sourcing and resale teams who need a fast, English-language answer to "what does this actually sell for in Japan?" without reading Japanese or scraping pages by hand. Runs on the Apify platform, so you get API access, scheduling, and monitoring out of the box.

### Why use Yahoo Auctions Japan Sold Price Comps?

Overseas resellers, proxy-buying services, and sourcing agents constantly need to answer one question before they buy: *is this worth it in the Japanese market?* Listing prices (what sellers are asking) are a poor signal — **sold prices are the real market**. This Actor queries Yahoo! Auctions' closed-listings search directly and returns aggregated comps, so a buying decision takes one API call instead of a manual search in Japanese.

It is also built to be safe to depend on: it only reads the page LY Corporation's own `robots.txt` explicitly allows, and it **never reads or outputs seller/buyer information** — only what was sold, for how much, and when.

### How to use Yahoo Auctions Japan Sold Price Comps

1. Open the **Input** tab and enter one or more search keywords (Japanese or English romanized terms both work, but Japanese keywords match far more listings).
2. Optionally set a price range, how many recent items to sample, and how many recent items to show per keyword.
3. Click **Start** — or call the Actor via the API, a Python/JS client, or an MCP-compatible AI agent.
4. Read the results from the **Output** tab, or download the dataset as JSON, CSV, or Excel.

### Input

| Field | Type | Description |
|---|---|---|
| `keywords` | array of strings | Search terms. One summary row per keyword. |
| `maxItemsPerKeyword` | integer | How many most-recently-sold listings to sample per keyword (default 100, max 300). |
| `minPrice` / `maxPrice` | integer | Optional sold-price range in JPY. |
| `topN` | integer | How many of the most recent sold items to list inside each summary row (default 5). |
| `includeItems` | boolean | Also output every sampled item as its own dataset row (billed separately, see Pricing). |

```json
{
  "keywords": ["ポケモンカード リザードン", "Nintendo Switch 有機EL"],
  "maxItemsPerKeyword": 100
}
```

### Output

One dataset row per keyword, with the aggregated comps:

```json
{
  "type": "summary",
  "keyword": "ポケモンカード リザードン",
  "totalResultsAvailable": 26967,
  "sampled": 100,
  "currency": "JPY",
  "priceJpy": { "median": 17000, "mean": 20968, "p25": 14625, "p75": 19000, "min": 500, "max": 126999 },
  "fixedPriceShare": 0.82,
  "avgBidCount": 3.4,
  "conditionBreakdown": { "NEW": 39, "USED20": 30 },
  "topItems": [ { "title": "...", "priceJpy": 18000, "endTime": "2026-09-17T23:05:27+09:00" } ]
}
```

You can download the full dataset in JSON, HTML, CSV, or Excel from the Output tab.

#### Data fields

| Field | Description |
|---|---|
| `priceJpy.median` / `mean` / `p25` / `p75` / `min` / `max` | Sold price stats across the sampled items, in JPY. |
| `sampled` | How many sold items the stats are based on. |
| `totalResultsAvailable` | Total closed listings Yahoo reports for the keyword (before sampling). |
| `fixedPriceShare` | Share of sampled items that were "Buy It Now" (fixed price) rather than auctioned. |
| `avgBidCount` | Average number of bids across the sampled items. |
| `conditionBreakdown` | Count of sampled items by Yahoo's condition code (e.g. `NEW`, `USED20`). |
| `topItems` | The most recently sold items (title, price, end time, condition, listing URL, image). |

**This Actor never outputs seller or buyer information.** No usernames, no ratings, no IDs — by design, not as an afterthought.

### Pricing

This Actor uses the Apify **Pay Per Event** model. There is no fixed run cost — you only pay for what you get:

| Event | Price | When it's charged |
|---|---|---|
| `summary` | $0.05 | Once per keyword that returns at least one sold item. |
| `item` | $0.003 | Once per item, only if `includeItems` is enabled. |

Example: 50 keywords, summaries only, costs **$2.50**. A keyword with zero sold items is not charged.

### Tips

- Keep `includeItems` off unless you need the raw per-item data — the summary already covers typical sourcing/pricing decisions.
- Use Japanese keywords where possible; they match far more listings than romanized English terms.
- Results only include **sold (closed) listings**, sorted by most recent end time — this Actor does not read active/current listings.
- Call it via the [Apify API](https://docs.apify.com/api/v2), the [Python](https://docs.apify.com/api/client/python) or [JavaScript](https://docs.apify.com/api/client/js) client, or as a tool from an MCP-compatible AI agent.

### FAQ

**Why is there no seller information in the output?**
By design. This Actor only reads and reports on completed transactions (item, price, time) — never on who bought or sold. This keeps it clear of personal-data handling entirely.

**Can I get active (not-yet-sold) listings?**
No — this Actor is scoped to closed/sold listings only, since that's what gives an honest read on real market price.

**Is this affiliated with Yahoo! JAPAN or LY Corporation?**
No. This Actor is an independent tool that reads publicly accessible search result pages. It is not affiliated with, endorsed by, or connected to LY Corporation or Yahoo! JAPAN. Data is provided for research and sourcing purposes with no accuracy guarantee. If you run into blocked runs or unexpected data, please open an issue on the Actor's Issues tab.

# Actor input Schema

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

Search terms (Japanese or English). One summary row per keyword. Max 50.

## `maxItemsPerKeyword` (type: `integer`):

How many most-recent sold listings to sample (100 per page, max 300).

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

Only include sold items priced at or above this amount.

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

Only include sold items priced at or below this amount.

## `topN` (type: `integer`):

How many of the most recently sold items to list inside each summary row.

## `includeItems` (type: `boolean`):

In addition to the per-keyword summary row, output one dataset row per sampled sold item.

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

Optional. Leave empty first; enable Apify datacenter proxy only if runs get blocked.

## Actor input object example

```json
{
  "keywords": [
    "ポケモンカード リザードン"
  ],
  "maxItemsPerKeyword": 100,
  "topN": 5,
  "includeItems": false
}
```

# 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 = {
    "keywords": [
        "ポケモンカード リザードン"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("toshiboh/yahoo-auctions-japan-sold-price-comps").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": ["ポケモンカード リザードン"] }

# Run the Actor and wait for it to finish
run = client.actor("toshiboh/yahoo-auctions-japan-sold-price-comps").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": [
    "ポケモンカード リザードン"
  ]
}' |
apify call toshiboh/yahoo-auctions-japan-sold-price-comps --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,toshiboh/yahoo-auctions-japan-sold-price-comps"
        }
    }
}
```

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/YX6zDzkzPca6l5OL8/builds/vp7chjyCk8FT08IJY/openapi.json