# Yahoo Auctions Japan Keyword & Category Price Scraper (`vexaloom-labs/yahoo-auctions-japan-keyword-and-category-price`) Actor

Search Yahoo Auctions Japan by keyword or browse a category, with current bid price, buy-it-now price, condition, bid count, end time and seller, filtered by price range and sorted by ending soonest, price or bids.

- **URL**: https://apify.com/vexaloom-labs/yahoo-auctions-japan-keyword-and-category-price.md
- **Developed by:** [vexaloom-labs](https://apify.com/vexaloom-labs) (community)
- **Categories:** E-commerce, Automation, Other
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Yahoo Auctions Japan Live & Sold Auction Scraper

Yahoo Auctions Japan (ヤフオク!) is the country's biggest consumer auction site. This actor turns its public listings into clean JSON: live auctions with current bids and buy-it-now prices, closed auctions with the price they actually sold for, seller storefronts, and individual item pages with descriptions and full photo sets.

No Yahoo account, cookie, API key or proxy setup is needed.

### What you can scrape

| Mode | What it returns |
|---|---|
| `keywordSearch` | Live listings for one or more keywords |
| `browseCategory` | Live listings from a category ID, optionally narrowed by keyword |
| `soldSearch` | Closed auctions with final sold prices — useful for sold-price comparisons |
| `sellerListings` | Live listings from one or more seller IDs |
| `itemDetails` | Full detail pages for a list of item IDs or item URLs |

Every mode supports price bounds, condition grade, listing type, prefecture, free-shipping and buy-it-now filters where Yahoo exposes them. Keyword modes also accept excluded words.

### Record fields

Prices are whole yen (`JPY`). Empty fields are omitted rather than written as `null`.

| Field | Meaning |
|---|---|
| `itemId` | Yahoo auction ID |
| `itemUrl` | Direct link to the listing |
| `title` | Listing title |
| `currentPrice` | Current bid, or the final price on sold rows |
| `soldPrice` | Final winning price on closed auctions |
| `priceType` | `current` or `final` |
| `buyItNowPrice` | Buy-it-now price, when offered |
| `startPrice` | Starting price |
| `currency` | Always `JPY` |
| `bids` | Bid count (`0` is kept) |
| `watchCount` | Number of watchers |
| `biddersCount` | Distinct bidders (detail pages) |
| `condition`, `conditionCode` | English condition and Yahoo's grade code |
| `conditionNameJa` | Yahoo's Japanese condition label (detail pages) |
| `startDate`, `endDate` | ISO 8601 timestamps |
| `timeRemainingSeconds` | Seconds left on live listings |
| `seller`, `sellerId`, `sellerUrl` | Seller identity and storefront link |
| `sellerDisplayName`, `sellerRating`, `sellerRatingCount` | Seller reputation |
| `sellerLocation`, `prefecture`, `prefectureCode` | Item location |
| `category`, `categoryId`, `categoryPath` | Category name, ID and hierarchy |
| `brand` | Brand path, when Yahoo lists one |
| `imageUrl`, `imageUrls` | Main image and full photo set |
| `shippingFee`, `shippingFeeType`, `freeShipping` | Shipping cost and who pays |
| `shippingMethods`, `shipSchedule`, `shippingPaidBy` | Delivery options |
| `listingType` | `auction` or `fixedPrice` |
| `marketplace` | `yahooAuctions` or `paypayFleaMarket` |
| `status` | `open` or `closed` |
| `quantity`, `returnable`, `isWorldwideDelivery` | Item terms |
| `description`, `descriptionHtml` | Full item description (detail pages) |
| `scrapedAt` | ISO 8601 scrape timestamp |

### Input reference

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `keywordSearch` | `keywordSearch`, `browseCategory`, `soldSearch`, `sellerListings` or `itemDetails` |
| `searchQueries` | array | – | Keywords, Japanese or English; each runs until `maxItems` |
| `excludeKeywords` | array | – | Remove listings containing any of these words |
| `categoryIds` | array | – | Numeric category IDs, e.g. `23336` for Computers |
| `sellerIds` | array | – | Seller IDs or seller page URLs (`sellerListings`) |
| `itemIds` | array | – | Auction IDs or item URLs (`itemDetails`) |
| `condition` | string | `any` | `any`, `new`, `used`, `likeNew`, `excellent`, `good`, `acceptable` or `poor` |
| `listingType` | string | `all` | `all`, `auction` or `fixedPrice` |
| `sortBy` | string | `relevance` | 14 orders: ending soonest/last, newest, price, bids, buy-it-now price, total price incl. shipping, watchers, relevance, featured |
| `minPrice` | integer | – | Minimum price in yen |
| `maxPrice` | integer | – | Maximum price in yen |
| `priceType` | string | `currentPrice` | Apply `minPrice`/`maxPrice` to `currentPrice` or `buyNowPrice` |
| `prefecture` | string | Any prefecture | Two-digit Japanese prefecture code; use the dropdown for names |
| `freeShippingOnly` | boolean | `false` | Keep only free-shipping listings |
| `buyItNowOnly` | boolean | `false` | Keep only listings with a buy-it-now price |
| `maxItems` | integer | `20` | 1 to 5,000 records per run |
| `includeDetails` | boolean | `false` | Open each item page for description, photos, bidder count, seller rating/location and shipping methods |

#### Example: live keyword search

```json
{
  "mode": "keywordSearch",
  "searchQueries": ["PlayStation 5", "Nintendo Switch"],
  "condition": "used",
  "minPrice": 5000,
  "maxPrice": 40000,
  "sortBy": "endingSoon",
  "maxItems": 100
}
```

#### Example: sold-price comparison

```json
{
  "mode": "soldSearch",
  "searchQueries": ["Leica M6"],
  "sortBy": "endingLast",
  "maxItems": 50,
  "includeDetails": true
}
```

#### Example: browse a category

```json
{
  "mode": "browseCategory",
  "categoryIds": ["23336"],
  "listingType": "fixedPrice",
  "sortBy": "priceAsc",
  "maxItems": 200
}
```

#### Example: item pages from a list of URLs

```json
{
  "mode": "itemDetails",
  "itemIds": [
    "w1250838886",
    "https://page.auctions.yahoo.co.jp/jp/auction/e1251357399"
  ]
}
```

### Pagination and limits

The actor follows result pages until `maxItems` is reached or Yahoo stops returning new records. Yahoo serves roughly 100 records per page and makes about 15,000 results browsable per search; very broad queries can hit that window. Split a broad search by category, price band or condition to reach deeper stock. Closed-auction history covers roughly the last 180 days.

### FAQ

**Do I need a Yahoo Japan login or API key?**
No. The actor reads publicly visible Yahoo Auctions Japan pages and the site's own public JSON endpoints.

**Are sold prices real winning prices?**
Yes — `soldSearch` reads closed auctions and reports the final price Yahoo records, not an estimate.

**Why do some rows have no buy-it-now price?**
Only fixed-price listings and auctions that offer instant purchase have one; the field is omitted otherwise.

**Can I search in Japanese?**
Yes. Pass Japanese keywords directly, exactly as you would type them into Yahoo's search box.

**How do I find a category or seller ID?**
Open the category or seller page on auctions.yahoo.co.jp and copy the numeric category ID or the seller ID from the URL. Seller and item URLs are accepted too.

**Why are some prices 0 or 1 yen?**
Those are live auctions with a low starting bid and no bids yet. Check `bids` and `startPrice` to tell them apart.

**Does this actor cover PayPay Flea Market?**
Closed searches can include flea-market rows from Yahoo's network; they are marked with `marketplace: "paypayFleaMarket"` and link to the flea-market item page. `itemDetails` covers Yahoo auction pages only.

**Is this affiliated with Yahoo Japan?**
No. This is an independent tool that reads publicly available pages and is not endorsed by LY Corporation.

### Data source

Public listing, category, seller, closed-auction and item pages on `auctions.yahoo.co.jp` (plus the site's own JSON endpoints). No login, cookies, credentials or user proxy configuration are required.

# Actor input Schema

## `mode` (type: `string`):

What to scrape on Yahoo Auctions Japan.

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

One or more keywords, Japanese or English (mode=keywordSearch, soldSearch). Each keyword is searched separately until maxItems is reached.

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

Listings containing any of these words are removed (all search modes).

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

Yahoo Auctions category IDs, e.g. 23336 for Computers. Used by browseCategory and as an optional filter for keywordSearch/soldSearch.

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

Seller IDs or seller page URLs (mode=sellerListings), e.g. FCm8JEeKSC4qTg4Ww3SAS54XL2aKF.

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

Auction IDs or item page URLs (mode=itemDetails), e.g. w1250838886 or https://page.auctions.yahoo.co.jp/jp/auction/w1250838886.

## `condition` (type: `string`):

Only return listings in this condition grade.

## `listingType` (type: `string`):

Auctions, fixed-price listings, or both.

## `sortBy` (type: `string`):

Result order. When Yahoo's JSON endpoint is unavailable, fallback pages are sorted locally within each fetched page window.

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

Only include listings at or above this price in yen.

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

Only include listings at or below this price in yen.

## `priceType` (type: `string`):

Use the current bid price or the buy-it-now price for minPrice/maxPrice.

## `prefecture` (type: `string`):

Only include listings located in this prefecture.

## `freeShippingOnly` (type: `boolean`):

Only return listings whose seller offers free shipping.

## `buyItNowOnly` (type: `boolean`):

Only return listings that offer a buy-it-now price.

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

Maximum number of auction records to return across all keywords and pages.

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

Open each item page to add description, all photos, bidder count, seller rating/location and shipping methods. Adds one request per record.

## Actor input object example

```json
{
  "mode": "keywordSearch",
  "searchQueries": [
    "PlayStation 5"
  ],
  "condition": "any",
  "listingType": "all",
  "sortBy": "relevance",
  "priceType": "currentPrice",
  "prefecture": "",
  "freeShippingOnly": false,
  "buyItNowOnly": false,
  "maxItems": 3,
  "includeDetails": false
}
```

# Actor output Schema

## `auctions` (type: `string`):

Dataset containing all scraped Yahoo Auctions Japan listing records.

# 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 = {
    "mode": "keywordSearch",
    "searchQueries": [
        "PlayStation 5"
    ],
    "condition": "any",
    "listingType": "all",
    "sortBy": "relevance",
    "priceType": "currentPrice",
    "freeShippingOnly": false,
    "buyItNowOnly": false,
    "maxItems": 3,
    "includeDetails": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("vexaloom-labs/yahoo-auctions-japan-keyword-and-category-price").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 = {
    "mode": "keywordSearch",
    "searchQueries": ["PlayStation 5"],
    "condition": "any",
    "listingType": "all",
    "sortBy": "relevance",
    "priceType": "currentPrice",
    "freeShippingOnly": False,
    "buyItNowOnly": False,
    "maxItems": 3,
    "includeDetails": False,
}

# Run the Actor and wait for it to finish
run = client.actor("vexaloom-labs/yahoo-auctions-japan-keyword-and-category-price").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 '{
  "mode": "keywordSearch",
  "searchQueries": [
    "PlayStation 5"
  ],
  "condition": "any",
  "listingType": "all",
  "sortBy": "relevance",
  "priceType": "currentPrice",
  "freeShippingOnly": false,
  "buyItNowOnly": false,
  "maxItems": 3,
  "includeDetails": false
}' |
apify call vexaloom-labs/yahoo-auctions-japan-keyword-and-category-price --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vexaloom-labs/yahoo-auctions-japan-keyword-and-category-price"
        }
    }
}
```

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/8raiIZV6QWeCsD4z3/builds/AOIXInZdB0eCJcZAv/openapi.json