# Yahoo! Auctions Japan Scraper - Active Listings (ヤフオク) (`jpopendata/japan-yahoo-auctions`) Actor

Yahoo Auctions Japan scraper for active listings (ヤフオク出品中): keyword search with title, current and buy-it-now price in JPY, bids, end time, condition, category and shipping. English schema, robots.txt-compliant URLs. Item facts only, no seller data. Unofficial; not affiliated with LY Corporation.

- **URL**: https://apify.com/jpopendata/japan-yahoo-auctions.md
- **Developed by:** [JP Open Data](https://apify.com/jpopendata) (community)
- **Stats:** 2 total users, 1 monthly users, 90.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 per results

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

## Yahoo! Auctions Japan Scraper - Active Listings (ヤフオク出品中)

**What is for sale on Yahoo! Auctions Japan (ヤフオク!) right now: title, current price and buy-it-now price in JPY, bid count, end time, condition, category and shipping, in a clean English schema.**

This Actor searches the public live search of auctions.yahoo.co.jp for one or more keywords or **pasted search URLs** (optionally narrowed to one category) and returns each active listing as JSON. Optional filters: price range, condition, buy-it-now only, and **ending soon** (ends within N hours). Searches with more than the site's 15,000-result limit can be split into price bands for **large pulls**.

> **Unofficial tool. Not affiliated with or endorsed by LY Corporation (LINEヤフー株式会社) or Yahoo! Auctions.** It reads publicly available pages only (no login), politely (strictly serial requests at least 1.2 s apart, a hard per-run request budget, no block evasion), fetches **only URLs the site's robots.txt allows**, and extracts **item facts only — no seller IDs, names, ratings, store flags or locations**. You are responsible for making sure your use of the data complies with the site's terms and applicable law.

Related Actors from the same publisher:

- **Sold prices (落札相場):** [jpopendata/japan-yahoo-auction-sold](https://apify.com/jpopendata/japan-yahoo-auction-sold) — what items actually sold for.
- **Price comps across marketplaces:** [jpopendata/japan-resale-price-comps](https://apify.com/jpopendata/japan-resale-price-comps) — Yahoo Auctions sold prices plus Yahoo Flea Market, BOOKOFF and Hareruya listings, with min/median/max per keyword.

***

### Quick start — verified input

Copy this into the input (JSON tab) or send it via the API. It was run successfully on 2026-10-04 (10 listings per keyword, 2 requests, about 10 seconds, no proxy). Running with an empty input `{}` uses exactly these values.

```json
{
  "keywords": ["ポケモンカード", "Nintendo Switch"],
  "maxItemsPerKeyword": 10
}
```

#### Common input mistakes

| Wrong | Right | Why |
|---|---|---|
| `"keywords": "pokemon cards"` | `"keywords": ["ポケモンカード"]` | Japanese keywords match far more listings; English works for brand and model names (`Nikon F3`). A single string is accepted too. |
| `"category": "trading cards"` | `"category": "2084241343"` or empty | Numeric auccat id from a category URL (the URL itself is accepted). |
| `"priceMin": "1,000円"` | `"priceMin": 1000` | Whole JPY. Via the API, a string with ¥ or commas is tolerated. |
| `"condition": "mint"` | `"condition": "new"` | any, new or used (新品 / 未使用 / 中古 also work). |
| `"maxItemsPerKeyword": 500` with the default budget | also raise `"maxApiRequests"` | One request returns one page of 50 listings, and the budget is shared by all keywords. |
| A pasted URL with `s1=end&o1=a` to get "ending soonest first" | `"endingWithinHours": 6` | The sort parameters are disallowed by robots.txt and are dropped from pasted URLs. The ending-soon filter is the allowed way. |
| `"keywords"` left at the pre-filled list next to `"searchUrls"` | clear `keywords` or leave it as is | When URLs are given and `keywords` still holds the pre-filled Quick start list, only the URLs are searched (the log says so). |

An invalid value stops the run immediately, before any request to the site, with a message that names the field and lists the valid values. Numbers outside their range are clamped with a warning instead.

#### Empty results?

A keyword with no live listings finishes with 0 items and `complete: true`. That is not an error (the site itself shows "条件に一致する商品は見つかりませんでした"). Typical causes: very niche or English wording (try the Japanese product name), a category that does not contain the keyword, or narrow price/condition filters with a small request budget. If some keywords stop early, the run still succeeds; the `RUN_SUMMARY` record in the key-value store shows `complete` and a `stopReason` for each keyword.

***

### Who is this for?

- **Resellers and proxy-buying services:** watch what is listed now, at what current and buy-it-now price, and when each auction ends.
- **Collectors:** track trading cards, figures, cameras, watches or retro games across many keywords in one run.
- **Price research:** combine with the sold-price Actor above to compare asking prices with actual sale prices.

### Input

| Field | Default | Notes |
|---|---|---|
| `keywords` | `["ポケモンカード", "Nintendo Switch"]` | Each keyword is searched separately. Up to 100 keywords + URLs per run. |
| `searchUrls` | empty | Search URLs pasted from your browser, one per line (see below). |
| `category` | empty | Numeric auccat id or category URL. Applies to `keywords`; a pasted URL keeps its own category. |
| `priceMin` / `priceMax` | empty | Current price in JPY. Sent to the site as its price filter and re-checked on every listing. |
| `condition` | `any` | `new` = the listing shows the 未使用 (unused) badge; `used` = it does not. Applied after fetching. |
| `buyItNowOnly` | `false` | Keep only listings with a buy-it-now (即決) price. Applied after fetching. |
| `endingWithinHours` | empty | Keep only listings that end within this many hours (1 to 720). Applied after fetching. |
| `maxItemsPerKeyword` | `10` | Per keyword or URL, 1 to 50,000. |
| `maxApiRequests` | `20` | 1 to 1,000 for the whole run, shared fairly between keywords and URLs. |
| `proxyConfiguration` | no proxy | Apify datacenter IPs are answered directly. If you set a proxy, one sticky session is used for the whole run. |

#### Paste a search URL

Set up a search on auctions.yahoo.co.jp in your browser (keyword, category, price range, condition), copy the address bar and put it in `searchUrls`:

```json
{
  "searchUrls": ["https://auctions.yahoo.co.jp/search/search?p=%E3%82%AC%E3%83%B3%E3%83%97%E3%83%A9&va=%E3%82%AC%E3%83%B3%E3%83%97%E3%83%A9&istatus=1&is_postage_mode=1&dest_pref_code=13&b=1&n=50&s1=end&o1=a&min=1000&max=5000"],
  "maxItemsPerKeyword": 10
}
```

Accepted: keyword searches (`/search/search?...` and `/search/search/<keyword>/<category>/`), category pages (`/category/list/.../<id>/`) and sold-item searches (their keyword and category are used). The Actor keeps the keyword words (`p`, `va`, `vo`, `ve`), the category (`auccat`) and the price range (`aucminprice`/`aucmaxprice`, or the site's `min`/`max` box, which is sent as `aucminprice`/`aucmaxprice`), and turns `istatus` into the condition filter. Every other parameter is dropped and never sent: sort (`s1`, `o1`), page size (`n`), `istatus` itself, `is_postage_mode` and anything else robots.txt disallows, as well as allowed parameters this Actor does not use (such as `dest_pref_code` or `b`). The run log lists every dropped parameter, and each record carries the URL in `searchUrl`. So the results can differ from what your browser shows: the site's default order instead of your sort, and no shipping-destination setting.

A category URL **without a keyword** is read from the category page itself (`/category/list/<id>`, only the page offset `b` is sent): the site redirects keyword-less searches there with a page-size parameter that robots.txt disallows, so the Actor goes to the category page directly. On category pages robots.txt also disallows the price parameters, so a price range on such a URL is applied after fetching, and a keyword-less category cannot be split into price bands (it is limited to the site's 15,000 results). Adding a keyword lifts both limits.

#### Ending soon

`"endingWithinHours": 6` keeps listings whose auction ends in the next 6 hours. robots.txt disallows the site's end-time sort, so the Actor reads results in the site's default order and filters them. For a broad keyword with a short window, give it a larger `maxApiRequests`.

#### Large pulls (more than 15,000 listings)

The site shows at most 15,000 results (300 pages) for any one search. When a keyword or URL has more results than that **and** its share of `maxApiRequests` is more than 300 requests, the Actor splits the search into current-price bands (using the allowed `aucminprice`/`aucmaxprice` parameters) until each band holds 15,000 results or fewer, then reads each band. Example for up to 50,000 listings of one keyword:

```json
{
  "keywords": ["ポケモンカード"],
  "maxItemsPerKeyword": 50000,
  "maxApiRequests": 1000
}
```

This takes time: requests are sent one at a time, at least 1.2 s apart, so 1,000 requests take roughly 30 minutes, and every listing stored is charged. Limits: a single exact price that alone has more than 15,000 listings (for example thousands of ¥1 cards) cannot be split further, so only the first 15,000 at that price are reachable; such a search ends with `complete: false` and a `stopReason` in `RUN_SUMMARY`. Prices move while the run is going, so a listing can change band; duplicates are removed by item id.

### Sample output (one dataset item)

```json
{
  "keyword": "ポケモンカード",
  "searchUrl": null,
  "itemId": "s1246126423",
  "itemTitle": "ポケモンカードゲーム 拡張パック ストームエメラルダ 14パック メガブレイブ 5パック 計19パックセット",
  "currentPriceJpy": 3000,
  "buyNowPriceJpy": 4000,
  "startPriceJpy": 3000,
  "bidCount": 1,
  "endsAt": "2026-10-04T23:29:40+09:00",
  "condition": "new",
  "badges": ["未使用"],
  "categoryId": 2084317604,
  "categoryIdPath": [25464, 27727, 25826, 2084241343, 2084317604],
  "isFreeShipping": false,
  "shippingFeeJpy": 230,
  "shippingText": "＋送料230円",
  "isFleaMarket": false,
  "isFeatured": false,
  "imageUrl": "https://auc-pctr.c.yimg.jp/i/auctions.c.yimg.jp/images.auctions.yahoo.co.jp/image/...jpg",
  "itemUrl": "https://auctions.yahoo.co.jp/jp/auction/s1246126423",
  "source": "ヤフオク! 出品中 (auctions.yahoo.co.jp search)",
  "sourceUrl": "https://auctions.yahoo.co.jp/",
  "license": "Publicly available data — unofficial tool; users are responsible for compliance with the source site's terms",
  "retrievedAt": "2026-10-04T04:55:00.000Z"
}
```

`keyword` is the keyword searched (for a pasted URL, the URL's keyword, or `null` for a category-only URL). `searchUrl` is the pasted URL the listing came from, `null` for keyword searches. `buyNowPriceJpy` is `null` when the listing has no buy-it-now price. `shippingFeeJpy` is `0` for free shipping and `null` when the site shows no fee or "送料未定". `isFeatured` marks listings with the site's paid "featured" (注目) option; the site mixes them into the result list on every page, so filter on it if you want organic results only. `startPriceJpy` is the opening price as the site publishes it (before consumption tax on listings that charge tax).

### Honest limits

- **Search-page facts only.** The Actor reads the search result list and never opens item pages. So there is no item description, no detailed condition grade (only the 未使用 badge), no category names (only ids), and no seller information by design.
- **Shipping as shown to an anonymous visitor.** The fee is what the site displays without a login; the destination it assumes may not be yours.
- **Prices change.** Current prices and bid counts are a snapshot at `retrievedAt`.
- **Site order only.** robots.txt forbids the sort (`s1`, `o1`) and page-size (`n`) parameters, so listings come in the site's default order, 50 per request (price bands are read cheapest band first).
- **Some filters run after fetching.** The price range is sent to the site. Condition, buy-it-now and ending-soon filters discard non-matching listings after each page is read, so narrow filters need a larger `maxApiRequests`.
- **15,000 results per search.** Beyond that, only price-band splitting helps (see "Large pulls"), and it needs a large request budget.
- **The site can change or refuse requests.** If it blocks an IP mid-run, the run keeps what it already has and ends successfully with `complete: false`. If it blocks the very first request, the run fails visibly instead of retrying aggressively.

### robots.txt compliance

auctions.yahoo.co.jp/robots.txt allows `/search/search` but disallows these query parameters on it: `pstagefree`, `new`, `offer`, `shipping`, `istatus`, `abatch`, `loc_cd`, `type`, `mode`, `n`, `s1`, `o1`, `max_sprice`. The rules match any parameter name ending in those letters (so the site's own `min=` price box is disallowed too). This Actor sends only `p`, `va`, `vo`, `ve` (keyword words), `auccat` (category), `aucminprice` / `aucmaxprice` (price range — the parameters the site's own price links use, not disallowed on `/search/`) and `b` (page offset). Before every request the URL is checked against a copy of the real robots.txt and refused if any rule disallows it; pasted URLs are rebuilt from the allowed parts only. The test suite checks the same rules.

### Pricing

Pay per result: you are charged for each listing stored in the dataset. A run stops by itself when it reaches the maximum charge you set for the run.

# Actor input Schema

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

What to search for, one keyword per line, e.g. "ポケモンカード", "Nikon F3", "ガンプラ". Japanese keywords match best. Each keyword is searched separately and every record carries its keyword. Up to 100 keywords + URLs per run. If both this and Search URLs are empty, the Quick start keywords are used.

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

Paste search result URLs from auctions.yahoo.co.jp, one per line: a keyword search (https://auctions.yahoo.co.jp/search/search?p=...), a category page (https://auctions.yahoo.co.jp/category/list/2084241343/) or a sold-items search (its keyword and category are used). The Actor keeps the keyword, category and price range, and the condition (applied after fetching). Parameters that the site's robots.txt disallows (sort s1/o1, page size n, istatus, is_postage_mode and others) are never sent; the run log lists every dropped parameter. Records from a URL carry it in the searchUrl field. When URLs are given and Keywords still holds the pre-filled Quick start list, only the URLs are searched.

## `category` (type: `string`):

Optional. Numeric Yahoo! Auctions category id to narrow every KEYWORD search (the auccat value from auctions.yahoo.co.jp category URLs; the URL itself is accepted too), e.g. 2084241343 = ポケモンカードゲーム. Pasted Search URLs keep their own category. Leave empty for all categories. Category NAMES are not accepted — put them in Keywords.

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

Optional. Minimum CURRENT price in JPY (e.g. 1000). Sent to the site as its aucminprice filter and re-checked on every listing. Leave empty for no minimum.

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

Optional. Maximum CURRENT price in JPY (e.g. 50000). Sent to the site as its aucmaxprice filter and re-checked on every listing. Leave empty for no maximum.

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

any (default), new or used. Japanese labels work too (新品, 未使用, 中古). new = the listing shows the 未使用 (unused) badge on the search result; used = it does not. Applied after fetching.

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

Keep only listings that have a buy-it-now price (即決価格). Applied after fetching.

## `endingWithinHours` (type: `integer`):

Optional ending-soon filter: keep only listings whose auction ends within this many hours from now (1..720, e.g. 6 or 24). Leave empty for no filter. The site's end-time sort is disallowed by robots.txt, so listings are read in the site's default order and filtered after fetching — a short window on a broad keyword needs a larger request budget.

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

Listing records kept per keyword or URL (1..50000; values outside are clamped). One request returns one 50-listing result page, so 200 listings need about 4 requests per keyword (more with filters). The site shows at most 15,000 results per search; to go beyond that, also raise maxApiRequests so the search gets more than 300 requests — it is then split into price bands automatically.

## `maxApiRequests` (type: `integer`):

Hard budget of requests to auctions.yahoo.co.jp for the whole run (1..1000; clamped), shared fairly between keywords and URLs. Requests are strictly serial with at least 1.2 s spacing (1000 requests take roughly 30 minutes). If the budget runs out the run still SUCCEEDS with the listings found so far and complete=false in the RUN_SUMMARY record of the key-value store.

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

Optional. auctions.yahoo.co.jp answers Apify datacenter IPs directly, so no proxy is used by default. If you set one, the run keeps a single sticky session (one IP) — never rotation.

## Actor input object example

```json
{
  "keywords": [
    "ポケモンカード",
    "Nintendo Switch"
  ],
  "category": "",
  "condition": "any",
  "buyItNowOnly": false,
  "maxItemsPerKeyword": 10,
  "maxApiRequests": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `records` (type: `string`):

Active Yahoo! Auctions listing records with source attribution (source, sourceUrl, license, retrievedAt) on every item.

# 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": [
        "ポケモンカード",
        "Nintendo Switch"
    ],
    "category": "",
    "condition": "any",
    "buyItNowOnly": false,
    "maxItemsPerKeyword": 10,
    "maxApiRequests": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("jpopendata/japan-yahoo-auctions").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": [
        "ポケモンカード",
        "Nintendo Switch",
    ],
    "category": "",
    "condition": "any",
    "buyItNowOnly": False,
    "maxItemsPerKeyword": 10,
    "maxApiRequests": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("jpopendata/japan-yahoo-auctions").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": [
    "ポケモンカード",
    "Nintendo Switch"
  ],
  "category": "",
  "condition": "any",
  "buyItNowOnly": false,
  "maxItemsPerKeyword": 10,
  "maxApiRequests": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call jpopendata/japan-yahoo-auctions --silent --output-dataset

```

## MCP server setup

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

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/FwJKHA5ncKIkDjDgG/builds/FuDT38uuDbi5t4qbW/openapi.json