# Yahoo Auctions Japan Scraper: Live and Sold Prices (`automation_craft/yahoo-auctions-japan-scraper`) Actor

Scrape Yahoo! Auctions Japan (ヤフオク) live and sold auctions by keyword, category, seller, brand or search link, no login. Get current or winning price in yen, bids, buy now price, end time, category path, condition, seller type and prefecture, plus details, sold price summaries and a monitor.

- **URL**: https://apify.com/automation_craft/yahoo-auctions-japan-scraper.md
- **Developed by:** [Automation Craft](https://apify.com/automation_craft) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

### Yahoo Auctions Japan Scraper: Live and Sold Prices

**Yahoo Auctions Japan scraper for live and sold auctions**: search Yahoo! Auctions Japan (ヤフオク, auctions.yahoo.co.jp)
by keyword, category, seller, brand or a pasted search link, and get one row per auction with the current or winning price,
bids, buy now price, start and end time, category path, condition, seller type and rating, prefecture and shipping. No login,
no cookies, no browser. Sold (closed) auctions go back about 180 days, so a sold search gives you real sold comparables for
pricing, and a monitor delivers each new auction once across scheduled runs.

It is built for resellers and proxy shopping services pricing what they buy and sell, collectors of trading cards, figures,
cameras and watches, and developers of price alert bots.

#### What it does

- **Live and sold on one row shape**: `status` live, sold or both; sold rows carry the winning price and the moment the
  auction ended, in ISO 8601 with Japan's offset (and in UTC).
- **Every filter Yahoo's search has, checked again on every row**: price and buy now price bounds, conditions (7 grades),
  seller type (stores, individuals, Yahoo!フリマ flea market listings), auctions or fixed price, buy now only, free shipping,
  bid count range, prefectures in or out, brand, category, seller, new listings, ending within minutes or hours, words to
  leave out, title must hold every word. A row that fails a filter is left out, free.
- **Sold date window**: the last N days, or between two dates.
- **Pasted links**: Yahoo search, closed search, category and seller page links, read as the site reads them; auction links
  for the full record of single auctions.
- **Details on request**: description, every photo, bidder count, item specifics, shipping methods and payer, returns,
  auction rules (early finish, automatic extension, bidder restrictions), seller rating counts.
- **Monitor**: give `monitorName` and schedule the run: each auction is delivered and billed once, newest first.
- **Price summary per search**: count, lowest, highest, average, median, quartiles and ten sample auctions.
- **Prices in other currencies**: up to 5 of 16 currencies at the European Central Bank's daily reference rate, with the rate
  and its date on every row.
- **Past 15,100 rows**: Yahoo serves one search 15,100 rows; `splitByPrice` splits a bigger search into price bands to reach
  the rest.

### Quick start

1. Open the Actor and type a keyword, for example ポケモンカード, ニコン F3 or セイコー.
2. Pick `status`: live for auctions on sale now, sold for ended auctions with their winning prices.
3. Add filters if you want (price, condition, seller type, prefecture), and set `maxItems`.
4. Run it, then download the dataset as JSON, CSV or Excel, or read it through the API.

The prefilled input searches ポケモンカード live and delivers 20 rows in a few seconds.

### What you get

One row per auction (`type: "listing"`), plus free rows: one coverage row per search (`type: "search"`: what Yahoo reported,
pages read, rows delivered, why the walk ended, whether it was complete), status rows for anything not delivered (an
auction link Yahoo no longer has, a search link with a setting this Actor does not read, a stop), and a run summary last.

Fill rates: sold from 900 saved rows of three keywords (2026-10-20, FEASIBILITY.md), live from 2,662 rows of three keywords
delivered by platform runs (2026-10-21). The optional fields vary by keyword:

| Field | What it holds | Live | Sold |
|---|---|---|---|
| `auctionId`, `url`, `title` | the auction | 100% | 100% |
| `price` | current price (live) or winning price (sold), yen | 100% | 100% |
| `bidCount`, `watchCount`, `views` | bids, watchers, Yahoo's view counter | 100% | 100% |
| `buyNowPrice` | the buy now (即決) price | 12 to 62% | 53% |
| `startTime`, `endTime`, `endTimeUtc`, `secondsLeft` | when it started and ends or ended; seconds left on live rows | 100% | 100% |
| `categoryId`, `categoryName`, `categoryPath`, `categoryPathIds` | the category and its path, in Yahoo's Japanese names | 100% | 100% |
| `condition`, `conditionCode`, `conditionLabel`, `conditionLabelJa` | the condition grade (new, like_new, good, fair, poor, bad, used) | 100% | 100% |
| `sellerType`, `isStore`, `sellerGoodRatingPercent` | store, individual or fleamarket; the share of good ratings | 100%, 98 to 100% | 100%, 98% |
| `prefectureCode`, `prefecture`, `prefectureJa` | where it ships from | 100% | 100% |
| `isFreeShipping`, `isFleaMarketItem`, `isFeatured`, `saleFormat`, `priceIsFloor` | flags | 100% | 100% |
| `brandId` | Yahoo's brand id | 81 to 97% | 91% |
| `catalogId` | Yahoo's product catalogue id | 4 to 61% | 23% |
| `imageUrl` | the first photo | 100% | 100% |

With `includeDetails` (25 records of every kind): `description`, `images`, `bidderCount`, `quantity`, `shippingPayer`,
`isEarlyClosing`, `isAutomaticExtension`, `sellerRatingCount`, `isWorldwideDelivery` 25 of 25; `shippingMethods` 16;
`highestBidders` 17; `itemSpecifics`, `productName` 13. Yahoo!フリマ items have no record on Yahoo! Auctions and come without
details (a note on the row says so, and no Listing detail is billed).

Sample row (sold, with details and a USD conversion, trimmed to the main fields; captured from a platform run on
2026-10-21):

```json
{
  "type": "listing",
  "auctionId": "c1248700037",
  "url": "https://auctions.yahoo.co.jp/jp/auction/c1248700037",
  "status": "sold",
  "title": "1円 Nikon D80 AF-S NIKKOR 18-200mm F3.5-5.6GII ED デジタル一眼レフカメラ レンズ 動作確認済 ニコン",
  "price": 9905,
  "currency": "JPY",
  "buyNowPrice": null,
  "startPrice": 1,
  "bidCount": 13,
  "watchCount": 19,
  "views": 78,
  "saleFormat": "auction",
  "endTime": "2026-10-20T23:41:34+09:00",
  "categoryPath": "家電、AV、カメラ > カメラ、光学機器 > デジタルカメラ > デジタル一眼 > ニコン",
  "brandId": 101345,
  "condition": "fair",
  "conditionLabelJa": "やや傷や汚れあり",
  "sellerType": "store",
  "sellerId": "DavqJgEwPrusAkAy59cFkrf4mGHgb",
  "sellerGoodRatingPercent": 99,
  "prefecture": "Osaka",
  "isFreeShipping": false,
  "convertedPrices": {
    "USD": 62.64
  },
  "exchangeRateDate": "2026-10-20",
  "exchangeRateSource": "European Central Bank euro reference rates",
  "detailsIncluded": true,
  "scrapedAt": "2026-10-21T02:56:30.087Z"
}
```

### How much does it cost to scrape Yahoo Auctions Japan?

You pay per event (Apify's pay per event model): per auction row delivered, plus the extras you turn on. Prices per 1,000
events by Apify plan:

| Event | Free | Bronze | Silver | Gold |
|---|---|---|---|---|
| Listing (one auction row) | $1.19 | $1.09 | $0.99 | $0.85 |
| Listing detail (an auction's record, with includeDetails and for auction links) | $1.40 | $1.30 | $1.10 | $1.00 |
| Results page (one page read by a monitor run) | $0.60 | $0.60 | $0.60 | $0.60 |
| Price summary (one row per search, with priceSummary) | $2.00 | $2.00 | $1.80 | $1.60 |

Platinum and Diamond plans pay the Gold price. The Actor start event is $0.004 per run (this Actor runs at 256 MB, so it is
charged once a run, at every plan). The Store pricing card shows these same prices per 1,000 events: "$0.85 / 1,000" on the
Listing row means one auction row costs 0.085 cents on the Gold plan.

Worked example on the Bronze plan: 1,000 sold auctions with their details cost $1.09 + $1.30 + $0.004 = about $2.39. A
scheduled monitor run of one search that reads 3 pages and finds 12 new auctions costs $0.004 + 3 x $0.0006 + 12 x $0.00109
\= about $0.019.

Never billed: auctions left out by your filters, auctions already delivered in the run or known to your monitor, auction links
Yahoo no longer has, searches Yahoo did not apply as sent, invalid input items, the coverage, status and summary rows. A run
refused for its input still pays the run's start fee, like every run. No platform usage is passed on to you.

### Input

The main settings (every field is described in the input schema):

| Setting | What it does |
|---|---|
| `keywords` | search words (Yahoo's syntax works: `-word` leaves a word out, `(a b)` any of them, quotes a phrase) |
| `categoryIds`, `sellers`, `brandIds` | category ids, seller page links or ids, brand ids; every keyword is searched in every category and for every seller |
| `searchUrls` | pasted Yahoo search, closed search, category or seller links |
| `auctionUrls` | auction links or ids, read with their full record |
| `status` | live, sold or both |
| `sort` | newest (sold: most recently ended), ending_soon, price_low, price_high, most_bids, fewest_bids, most_watched, buy_now_low, buy_now_high, best_match |
| filters | `minPrice`, `maxPrice`, `minBuyNowPrice`, `maxBuyNowPrice`, `conditions`, `sellerTypes`, `saleFormat`, `buyNowOnly`, `freeShippingOnly`, `minBids`, `maxBids`, `prefectures`, `excludePrefectures`, `endingWithinMinutes`, `endingWithinHours`, `newListingsOnly`, `soldWithinDays`, `soldFrom`, `soldTo`, `excludeKeywords`, `onlyTitleMatches` |
| extras | `includeDetails`, `priceSummary`, `currencies`, `useJapaneseAliases`, `includePersonalData` |
| limits | `maxItems` (100 by default), `maxItemsPerSearch`, `maxPagesPerSearch` (10 pages of 100 by default), `startPage`, `splitByPrice` |
| monitoring | `monitorName`, `resumeFromDatasetId` |
| `proxyConfiguration` | Apify datacenter (default) or residential in Japan or the United States |

Example: sold auctions matching ニコン F3 (Yahoo's own word matching) of the last 30 days, priced 10,000 to 60,000 yen,
without junk (ジャンク), with a price summary:

```json
{
  "keywords": ["ニコン F3"],
  "status": "sold",
  "soldWithinDays": 30,
  "minPrice": 10000,
  "maxPrice": 60000,
  "excludeKeywords": ["ジャンク"],
  "priceSummary": true,
  "maxItems": 500
}
```

#### Pace

Yahoo's search door allows one address about 20 requests a minute. This Actor reads at most 8 result pages at once and then
one every 6 seconds (about 1,000 rows a minute after the first 800), always from one address. If Yahoo still refuses that
address, the searches not read get free rows and the run ends cleanly: run them again later.

### FAQ

#### How do I get sold prices from Yahoo Auctions Japan?

Set `status` to sold. Each row is an auction that ended with a winning bid (or a fixed price item that sold) in about the
last 180 days, with its winning price, bid count and end time. `soldWithinDays` or `soldFrom` and `soldTo` narrow the window,
and `priceSummary` adds the median and quartiles of what each search delivered.

#### Can I monitor Yahoo Auctions for new listings?

Yes. Give a `monitorName` and schedule the run: every run reads the newest pages of each search and delivers only auctions
this monitor has not delivered before, so each auction is billed once. Each results page a monitor run reads is billed as a
Results page.

#### Do I need a Yahoo account or cookies?

No. The Actor reads the same public JSON that Yahoo's own search page loads, logged out. It never logs in, never buys or
bids, and reads nothing behind an account.

#### Can it read Yahoo! Auctions from Europe?

Yahoo! Auctions is closed to visitors from the EEA and the UK. The Actor reads it through Apify's datacenter proxy (the
default; an exit Yahoo fences is left for a fresh one, at most twice) or, if you choose residential, through Japan or the
United States, wherever you run it from.

#### Why does this Actor run with limited permissions?

Least privilege: it only reads and writes its own storages (the run's dataset and key value store), and, when you give a
`monitorName`, one named key value store it creates for that monitor. It cannot read anything else in your account.

### What this Actor does NOT do

- No bidding, buying, watching or messaging (those need an account).
- No English category names: Yahoo names categories in Japanese only (the condition grades come in English too).
- No Yahoo!フリマ item records: flea market listings come with their search fields only, and no like counts (watch counts
  and views come on every row).
- No Mercari rows: this Actor reads Yahoo! Auctions only.
- No proxy shopping service data (export restrictions, days to ship to a forwarder): it reads Yahoo's own data (the ship
  schedule and the worldwide delivery flag come with details).
- No seller profile pages, ratings history or other sellers' data beyond what an auction row shows.
- No moving to fresh addresses to read past Yahoo's lock on its search door, and no use of your own proxy links.
- No more than 15,100 rows from one search without `splitByPrice` (Yahoo's own limit), and no more than about 180 days of
  sold auctions (Yahoo's own history).
- Personal data is off by default: an individual or flea market seller's id, page link and nickname, and the highest
  bidders' names, are empty unless you turn `includePersonalData` on (a store is a business and is always shown). You are
  responsible for a lawful use of personal data, GDPR included.

### API

```bash
curl -X POST "https://api.apify.com/v2/acts/automation_craft~yahoo-auctions-japan-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keywords": ["ポケモンカード"], "status": "sold", "maxItems": 100}'
```

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('automation_craft/yahoo-auctions-japan-scraper').call({ keywords: ['セイコー'], status: 'live', maxItems: 100 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")
run = client.actor("automation_craft/yahoo-auctions-japan-scraper").call(run_input={"keywords": ["ニコン"], "status": "sold"})
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

### Changelog

See the Changelog tab.

### More data tools by Automation Craft

- [Mercari Japan Scraper: Listings, Prices, Sold](https://apify.com/automation_craft/mercari-japan-scraper)
- [Mercari Scraper: Japan & US Listings, Sold Prices](https://apify.com/automation_craft/mercari-scraper)
- [Mercari US Scraper: Listings, Sold Prices](https://apify.com/automation_craft/mercari-us-scraper)
- [OfferUp Scraper: Local Listings, Prices, Sellers](https://apify.com/automation_craft/offerup-scraper)
- [Craigslist Scraper: Listings, Prices & Alerts](https://apify.com/automation_craft/craigslist-scraper)
- [AliExpress Search Scraper - Products and Prices](https://apify.com/automation_craft/aliexpress-search-scraper)
- [Kijiji Scraper: Listings, Cars, Rentals & Prices](https://apify.com/automation_craft/kijiji-scraper)
- [Leboncoin Scraper: Ads, Prices, Real Estate & Cars](https://apify.com/automation_craft/leboncoin-scraper)

# Changelog

This Actor's version history is a separate document: https://apify.com/automation_craft/yahoo-auctions-japan-scraper/changelog.md

# Actor input Schema

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

Search words as you would type them on Yahoo! Auctions Japan, for example ポケモンカード, ニコン F3 or セイコー. Yahoo's own search syntax works: a word with a minus in front is left out, words in brackets are any of them, words in quotes are a phrase. Up to 100 keywords of up to 100 characters each.

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

Yahoo! Auctions category ids, the number in a category link (https://auctions.yahoo.co.jp/category/list/2084005150/) or after auccat= in a search link. Each row's own category path is checked to hold the id. Up to 100.

## `sellers` (type: `array`):

Seller page links (https://auctions.yahoo.co.jp/seller/<id>) or bare seller ids: the auctions of each seller, filtered by the settings below (with keywords: each keyword within each seller). Up to 100.

## `brandIds` (type: `array`):

Yahoo! Auctions brand ids (the number after brand_id= in a search link, for example 167473 for the Pokemon Card Game). A brand includes its sub brands, as on the site. Alone, the brand is searched; beside keywords, category ids or sellers, every search is narrowed to it; beside search links, it replaces each link's brand.

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

Search links copied from Yahoo! Auctions: a search (https://auctions.yahoo.co.jp/search/search?p=...), a closed search of sold auctions (/closedsearch/closedsearch?p=...), a category list or a seller page. Each link is one search with its words, category, brand, seller, prices, conditions, seller types, sale format, bid counts, free shipping, new listings, order and start row. A link with any other setting is refused with a free row that names it. Up to 100.

## `auctionUrls` (type: `array`):

Auction links (https://auctions.yahoo.co.jp/jp/auction/x1234567890) or auction ids: each is read from its item record and delivered with its details (billed as a Listing and a Listing detail). An auction Yahoo no longer has is a free row. Up to 1,000.

## `useJapaneseAliases` (type: `boolean`):

When a search (a keyword, or the words of a pasted search link) finds no auction at all and its words are a name this Actor knows in Japanese (37 names such as pokemon card, one piece, nikon and seiko), the search is read once more with the Japanese term sellers use; the rows and the coverage row say which term found them.

## `status` (type: `string`):

live: auctions and fixed price items on sale now. sold: auctions that ended with a winning bid and items sold at their price, about the last 180 days (the row price is the winning price). both: each search is read twice, live and sold.

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

The order Yahoo serves the results in. newest is newest listing first on live searches and most recently ended first on sold searches. best_match repeats some rows across pages, so its walk is never called complete. Left out: newest, and a search link keeps its own order.

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

Current price on live auctions, winning price on sold ones. Whole yen.

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

Current price on live auctions, winning price on sold ones. Whole yen.

## `minBuyNowPrice` (type: `integer`):

Live only: auctions and items with a buy now price of at least this. Whole yen.

## `maxBuyNowPrice` (type: `integer`):

Live only: auctions and items with a buy now price of at most this. Whole yen.

## `conditions` (type: `array`):

Only auctions in one of these conditions, as the seller graded them.

## `sellerTypes` (type: `array`):

Only these kinds of seller. Left out: every kind, Yahoo!フリマ listings included and flagged on each row (isFleaMarketItem).

## `saleFormat` (type: `string`):

Auctions only, fixed price items only, or both. On sold searches, fixed price also holds auctions that ended at their buy now price, as Yahoo files them. Left out: every format, and a search link keeps its own.

## `buyNowOnly` (type: `boolean`):

Only auctions that carry a buy now price (即決). Left out: off, and a search link keeps its own; false clears it.

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

Only auctions with free shipping (送料無料). Left out: off, and a search link keeps its own; false clears it.

## `minBids` (type: `integer`):

Only auctions with at least this many bids.

## `maxBids` (type: `integer`):

Only auctions with at most this many bids (1 or more: Yahoo applies no maximum of 0).

## `prefectures` (type: `array`):

Only auctions shipped from these prefectures: codes 1 to 47 or names such as Tokyo, Osaka or 東京都.

## `excludePrefectures` (type: `array`):

Leave out auctions shipped from these prefectures (codes 1 to 47 or names).

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

Live only: auctions that end within this many hours of the run.

## `endingWithinMinutes` (type: `integer`):

Live only: auctions that end within this many minutes of the run (give this or endingWithinHours).

## `newListingsOnly` (type: `boolean`):

Live only: auctions that started within the last 24 hours, as Yahoo marks them new. Left out: off, and a search link keeps its own; false clears it.

## `soldWithinDays` (type: `integer`):

Sold only: auctions that ended within this many days before the run started (Yahoo serves about 180 days).

## `soldFrom` (type: `string`):

Sold only: auctions that ended on or after this day (Japan time), written YYYY-MM-DD, for example 2026-09-01. With "soldTo" a closed window between two dates.

## `soldTo` (type: `string`):

Sold only: auctions that ended on or before this day (Japan time), written YYYY-MM-DD.

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

Auctions whose title holds one of these words are left out (each word is also sent to Yahoo as a word to leave out). One word per item, up to 30.

## `onlyTitleMatches` (type: `boolean`):

Only auctions whose title holds every word of the keyword (Yahoo also matches words in other fields).

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

Read each delivered auction's item record: description, every photo, bidder count, item specifics, shipping methods and payer, returns, early finish, automatic extension and bidder rules, seller rating counts and store licences. Billed as a Listing detail per row. Yahoo!フリマ items have no record there and come without details.

## `includePersonalData` (type: `boolean`):

Off: an individual or flea market seller's id, page link and nickname, and the highest bidders' names, are empty (a store is a business and always shown). On: they are delivered as Yahoo shows them logged out. You are responsible for a lawful use of personal data, GDPR included.

## `currencies` (type: `array`):

Adds each price in up to 5 of these currencies at the European Central Bank's daily euro reference rate of the run (one read a run), with the rates and their date on every row. Prices in yen stay.

## `priceSummary` (type: `boolean`):

One extra row per search with the count, lowest, highest, average and median price, the quartiles and ten sample auctions of what it delivered: sold comparables from a sold search. Billed as a Price summary per search that delivered a priced auction.

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

Auction rows the run delivers at most, over all searches and links.

## `maxItemsPerSearch` (type: `integer`):

Auction rows one search delivers at most.

## `maxPagesPerSearch` (type: `integer`):

Result pages of 100 rows read per search at most (Yahoo serves one search 15,100 rows, 151 pages); with splitByPrice, per price band.

## `startPage` (type: `integer`):

The page of 100 results to start each search at (page 2 starts at row 101).

## `splitByPrice` (type: `boolean`):

A search that reports more than the 15,100 rows Yahoo serves one search is split into price bands, each read on its own, to reach the rest. Slower: Yahoo paces its search door.

## `monitorName` (type: `string`):

Give a name to deliver and bill each auction once across runs: a scheduled run delivers only auctions this monitor has not delivered before, newest first. Each results page a monitor run reads is billed as a Results page. One name per set of settings.

## `resumeFromDatasetId` (type: `string`):

The id of an earlier run's dataset: the auctions in it are not delivered again in this run.

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

Apify's datacenter proxy (the default) or Apify residential with the country JP or US. Yahoo refuses Europe and the UK. The run reads Yahoo through one address.

## Actor input object example

```json
{
  "keywords": [
    "ポケモンカード"
  ],
  "useJapaneseAliases": false,
  "status": "live",
  "onlyTitleMatches": false,
  "includeDetails": false,
  "includePersonalData": false,
  "priceSummary": false,
  "maxItems": 20,
  "maxPagesPerSearch": 10,
  "startPage": 1,
  "splitByPrice": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `items` (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": [
        "ポケモンカード"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation_craft/yahoo-auctions-japan-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 = {
    "keywords": ["ポケモンカード"],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("automation_craft/yahoo-auctions-japan-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 '{
  "keywords": [
    "ポケモンカード"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call automation_craft/yahoo-auctions-japan-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation_craft/yahoo-auctions-japan-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/gCouUZNT5ETP9u6Ix/builds/pGpQe5RzRmz7lpcnc/openapi.json