# Yahoo Auctions JP Scraper: New Listing Alerts & Sold Items (`accountable_eel/yahoo-auctions-jp-lookup`) Actor Yahoo Auctions Japan scraper without login: search by keyword for current bid, start and buy-now price, bids, end time and seller type. Alerts for new auctions, price rises and auctions ending soon, plus a sold items tracker with Yahoo's final price and sell-through rate. Pay per auction. - **URL**: https://apify.com/accountable\_eel/yahoo-auctions-jp-lookup.md - **Developed by:** [Adrian Voss](https://apify.com/accountable_eel) (community) - **Categories:** E-commerce, Automation - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $1.52 / 1,000 listing returneds 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 JP Scraper: New Listings Alerts, Price Drops & Sold Items **Watch a Yahoo Auctions search, get only what changed.** New auctions, buy-it-now price drops, price rises and auctions about to close since your last run, plus the auctions that sold, with Yahoo's own final price. Charged per row returned, quiet runs cost only the start fee. Works without login, from anywhere, including Europe. This actor searches Yahoo! Auctions Japan (ヤフオク!, auctions.yahoo.co.jp) the way you do on the site: type keywords in Japanese or English, or paste a search link with your category and price filters, and get one clean row per auction with the current bid, start price, buy-it-now price (即決), bid count, end time, hours left, shipping fee, seller type and rating, the main photo and the link, with every yen price also in euros. Turn on monitoring and each run returns only what is new or changed: a Yahoo Auctions alert for new listings, and a Yahoo Auctions sold items tracker that confirms sales against Yahoo's closed-auction results and keeps a running sell-through rate. ### Who it's for - **Proxy buyers and importers** (Buyee, ZenMarket and FromJapan style services, or your own) who need to see new auctions for a list of searches before anyone else bids, and to know when a watched auction enters its last hours. - **Resellers and collectors** of retro games, trading cards, cameras, watches and anime goods, who want new auctions in a Google Sheet or Discord channel instead of refreshing ヤフオク!. - **Price researchers** who want what an item actually sold for, not the asking price: the final price, bid count and sale time of every auction a watchlist tracked to the end. - **Alert-bot builders** who want a stable JSON row per auction and keep their own bot logic. ### Why this one - **Real sold prices, confirmed by Yahoo.** When a tracked auction leaves the open search, the actor checks Yahoo's closed-auction results (落札相場, sold auctions only). Found there, the row says `soldConfirmed: true` with the `finalPrice`, final `bidCount` and `endedAt`: the auctions you watched, followed through to the sale, not a separate dump of sold comps. - **Monitoring built in.** `deltaMode` remembers what each watchlist has seen. New auctions, buy-it-now price drops, price rises past your threshold and auctions entering their last hours come back; everything else is removed before billing. - **Works from Europe.** Yahoo! JAPAN blocks visitors from the EEA and the UK. This actor reaches it through Apify's proxy, so your location doesn't matter and there's no proxy to set up. - **Prices the way Yahoo shows them.** Store sellers' start and buy-it-now prices are reported with the 10% consumption tax included, the same numbers the site displays, plus `priceEur` at the European Central Bank's daily reference rate. - **Seller privacy by default.** Store or private, the seller's good-rating %, and an anonymous seller hash to group auctions by seller. No names, no IDs, no contact details. ### What you get | Field | What it is | |---|---| | `listingId`, `url`, `title` | Yahoo auction ID (e.g. `w1245899427`), link and title | | `price`, `currentPrice` | Current price in JPY (the running bid, tax included). On a sold row, `price` is the final price | | `priceEur` | `price` in euros at the ECB daily reference rate | | `startPrice`, `buyNowPrice` | Start price and buy-it-now price (即決), tax included; `buyNowPrice` is empty when there is none | | `bidCount`, `endsAt`, `endsInHours` | Bids so far, the scheduled end, and hours left at the time of the run | | `postedAt` | When the auction started (new auctions sort to the top of "Newest first") | | `auctionStatus` | `open`, or on gone rows `sold`, `ended_unsold` or `gone` | | `condition` | `unused` when Yahoo marks the auction 未使用; empty otherwise (the search page shows nothing more) | | `categoryId`, `shippingFee`, `isFreeShipping` | Yahoo category, shipping fee in JPY when the seller states one (0 = free) | | `sellerType`, `sellerRatingPct`, `sellerHash` | `store` or `private`, the seller's good ratings %, an anonymous seller hash | | `isPromoted` | The seller pays Yahoo a PR-option rate for visibility | | `imageUrl` | The main photo link (nothing is downloaded) | Every search also returns `totalAvailable` (Yahoo's own count), `truncated`, and, with monitoring on, `newCount`, `priceDropCount`, `priceRiseCount`, `endingSoonCount`, `goneCount`, `soldCount`, `sellThroughRate` and `medianPrice`. Three dataset views: **Overview**, **Monitoring** and **Sold signals**. ### Monitoring: new auctions, price changes and ending soon Turn on `deltaMode` and schedule the actor. The first run returns and remembers everything (or nothing, with `skipFirstRun`); from then on each row carries a `changeType`: - **`new`**: an auction this watchlist has never seen. With "Newest first" (the default) these are the auctions that started since the last run. - **`price-drop`**: the seller lowered the buy-it-now price by at least `minPriceDropPct` (default 5%). Bids only go up, so the running bid never counts as a drop. - **`price-rise`** (with `alertOnPriceRise`): the current price went up since the last run, or, with `priceRiseAbove`, crossed that price. Use it to follow a bidding war on the auctions you care about. - **`ending-soon`** (with `endingWithinHours`): a watched auction entered its last hours. Reported once per auction. - **`gone`** (with `alertOnGone`): see the next section. Unchanged auctions are removed before billing, so a run with nothing new returns one summary row and costs only the start fee. The watchlist name (`deltaName`) is derived from your filters unless you type one; two schedules with different filters keep separate memories. ```json { "searches": ["ゲームボーイ ポケモン 赤", "nintendo switch 本体"], "maxListingsPerSearch": 100, "deltaMode": true, "deltaName": "retro-games", "alertOnPriceRise": true, "priceRiseAbove": 5000, "endingWithinHours": 3 } ``` Without monitoring, `endingWithinHours` is a filter instead: only auctions that end within that many hours come back, read in "Ending soonest" order. That is the quickest way to get a last-minute bidding list. ### Sold signal and sell-through Turn on **Alert on gone auctions** (`alertOnGone`) and a watchlist also returns the auctions it was tracking that have left Yahoo's open auctions. **What "gone" means, honestly.** An auction leaves the open search when it sells (at the end, or early through buy-it-now), when it ends without a bid, or when the seller cancels it. So `gone` means delisted: most often sold, sometimes withdrawn. For each gone auction the actor then checks Yahoo's closed-auction results, which list sold auctions only, most recently ended first: - **`soldConfirmed: true`**: Yahoo shows the sale. The row carries `finalPrice` (also in `price` and `priceEur`), the final `bidCount` and `endedAt`, and `auctionStatus: "sold"`. - **`soldConfirmed: false`**: the auction's end time has passed, the closed results reach back past the last time the watchlist saw it, and it is not there. It ended without a winner or was cancelled (`auctionStatus: "ended_unsold"`). - **`soldConfirmed` empty**: no answer yet (a very busy search whose closed results didn't reach back far enough, or an auction that closed early). `gonePresumedSold` is then `true` when it had at least one bid when last seen. **How a run decides an auction is gone, not just out of view.** "Newest first" is Yahoo's start-time order, and the actor checks that order on every run. A missing auction counts as gone only when an auction that sat below it last time is still visible, or when the run read every auction the search matches, or when the auction's own end time (plus an hour for Yahoo's automatic extensions) has passed. Auctions pushed below the window by newer ones are not called gone until their end time passes. With a minimum or maximum price, bids push auctions out of the search all the time, so only the end time judges gone there. Promoted auctions are never reported gone. No gone check is made on a watchlist's first run, or on a run where Yahoo refused a page. `sellThroughRate` is gone auctions, minus the ones Yahoo shows ended unsold, over auctions ever tracked, for the watchlist's lifetime. It counts gone auctions even when `alertOnGone` is off. Gone rows are ordinary rows at the same price; the closed-auction lookups are never billed. A gone auction is reported once, and the watchlist forgets auctions it hasn't seen for 30 days. ```json { "searches": ["ライカ M6"], "maxListingsPerSearch": 200, "deltaMode": true, "deltaName": "leica-m6-sold", "alertOnNew": false, "alertOnPriceDrop": false, "alertOnGone": true } ``` Scheduled daily, that returns only the Leica M6 auctions that ended, each with its final price when it sold: a Yahoo Auctions sold items tracker you can send to Google Sheets. ### Price Pay-per-event. A flat per-run fee covers session/proxy warmup; you're billed per item only when data is actually found and returned — see `.actor/pay_per_event.json` for exact prices. A miss is never charged. - **Auctions:** $2 per 1,000 auctions returned, plus a small start fee per run. - **Gone and sold auctions** (with "Alert on gone auctions" on) are ordinary rows at the same price. The closed-auction lookups behind `soldConfirmed` are free. - A monitoring run with nothing new costs the start fee only. A search that returns nothing is never billed. A daily watchlist on 5 searches that each find 20 new auctions a day is about 3,000 auctions a month, **about $6 a month**. ### How to use 1. **In the Apify Console.** Open the actor page and click **Start** — the `searches` field is already pre-filled with a working example. Results land in the run's dataset as soon as each item is found. 2. **Via the API.** Call it directly with a POST request — no Console needed once you have an API token: ```bash curl "https://api.apify.com/v2/acts/accountable_eel~yahoo-auctions-jp-lookup/run-sync-get-dataset-items?token=" \ -X POST \ -H "Content-Type: application/json" \ -d '{"searches":["ゲームボーイ"]}' ``` 3. **On a schedule.** Save this actor as an Apify **Task** with the input you want, then add a **Schedule** (hourly, daily, weekly) so it runs on its own — no server of your own required. **Yahoo Auctions to Google Sheets or Discord without code.** Save your monitoring input as a Task and schedule it. In n8n or Make, trigger on "Apify: run succeeded", read the run's dataset, skip rows where `listingCount` is 0, and append `title`, `price`, `priceEur`, `bidCount`, `endsAt` and `url` to a Google Sheet, or post them to a Discord or Slack webhook. ### Input ```json { "searches": [ "ゲームボーイ" ] } ``` One search per line: keywords like "ゲームボーイ" or "nintendo switch", or a search link copied from auctions.yahoo.co.jp (its own category, brand, price and sort filters are kept). No login required. Accepted formats: ゲームボーイ, nintendo switch, https://auctions.yahoo.co.jp/search/search?p=%E3%83%9D%E3%82%B1%E3%83%A2%E3%83%B3%E3%82%AB%E3%83%BC%E3%83%89\&s1=end\&o1=a. - `maxListingsPerSearch` (default 100, up to 1,000): auctions per search, and your budget control. - `sort`: Newest first (default, best for alerts), Ending soonest, current price, buy-it-now price or most bids, all Yahoo's own orders. - `minPrice` / `maxPrice`: current price in JPY, sent to Yahoo and re-checked on every row. - `endingWithinHours`: a filter without monitoring, the ending-soon alert with it. - Monitoring: `deltaMode`, `deltaName`, `alertOnNew`, `alertOnPriceDrop`, `alertOnPriceRise`, `priceRiseAbove`, `alertOnGone`, `minPriceDropPct`, `skipFirstRun`. ### Sample output | query | found | status | searchQuery | sort | listingCount | totalAvailable | truncated | newCount | priceDropCount | priceRiseCount | endingSoonCount | goneCount | soldCount | sellThroughRate | medianPrice | listings | listingId | url | title | price | currency | priceEur | currentPrice | startPrice | buyNowPrice | bidCount | endsAt | endsInHours | postedAt | auctionStatus | condition | categoryId | shippingFee | isFreeShipping | imageUrl | sellerType | sellerRatingPct | sellerHash | isPromoted | isNew | changeType | previousPrice | priceDropPct | firstSeenAt | lastSeenAt | daysListed | lastPrice | finalPrice | endedAt | gonePresumedSold | soldConfirmed | scrapedAt | | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | | ゲームボーイ | true | OK | | | | | | | | | | \ | \ | \ | \ | \ | | | | \<price, jpy (current bid; final price on sold rows)> | <currency> | \<price in eur (ecb rate)> | \<current price, jpy> | \<start price, jpy> | \<buy-it-now price (即決), jpy> | <bids> | <auction ends> | <hours left> | <auction started> | \<status (open / sold / ended\_unsold / gone)> | \<condition (unused when yahoo marks it 未使用)> | <yahoo category id> | \<shipping fee, jpy (0 = free)> | <free shipping> | <image> | \<seller type (store / private)> | \<seller good ratings %> | \<seller (anonymous hash)> | \<promoted (seller pays for placement)> | \<is this auction new?> | \<change (new / price-drop / price-rise / ending-soon / gone / seen)> | \<price at the last sighting, jpy> | \<buy-now price drop %> | <first seen on a run> | <last seen on a run> | \<days tracked (first to last seen)> | \<last price seen before it went, jpy (gone rows)> | \<final sold price, jpy (sold rows)> | \<sold at (sold rows)> | \<sold or presumed sold (gone rows)> | \<sale confirmed by yahoo (true sold / false ended unsold / empty unknown)> | 1970-01-01T00:00:00.000Z | One row per auction (with "One row per listing" on, the default). A sold row from a monitoring run: ```json { "listingId": "z690002300", "url": "https://auctions.yahoo.co.jp/jp/auction/z690002300", "title": "ドラゴンクエストモンスターズ テリーのワンダーランド ゲームボーイ【GB】", "price": 1000, "currency": "JPY", "priceEur": 5.56, "bidCount": 1, "auctionStatus": "sold", "changeType": "gone", "lastPrice": 1000, "finalPrice": 1000, "endedAt": "2026-09-25T16:34:35.000Z", "gonePresumedSold": true, "soldConfirmed": true } ``` ### Use it from Clay, n8n, Make, or an AI agent This actor runs synchronously over plain HTTP — call it directly from a script, a workflow tool, or an AI agent, no Apify Console needed once you have an API token. ```bash curl "https://api.apify.com/v2/acts/accountable_eel~yahoo-auctions-jp-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \ -X POST \ -H "Content-Type: application/json" \ -d '{"searches":["ゲームボーイ"]}' ``` **n8n.** Add an HTTP Request node: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~yahoo-auctions-jp-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body Content Type `JSON`, JSON Body `{"searches":["ゲームボーイ"]}` (swap in an expression from an earlier node for a real value). **Clay.** Add an "HTTP API" column: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~yahoo-auctions-jp-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body `{"searches":["{{search}}"]}`, mapping the row's search into the `searches` array. **MCP.** In Claude, Cursor, or any MCP client with the Apify MCP server, ask for "Yahoo Auctions Japan Scraper: Alerts & Sold Prices" — the agent will find and run this actor. ### vs. alternatives | | What it costs | What you get | Trade-off | |---|---|---|---| | **This actor** | $2 per 1,000 auctions, quiet monitoring runs free | Open auctions with bids, buy-it-now, end time and euro price; new, price-drop, price-rise, ending-soon and sold alerts; final prices confirmed against Yahoo's closed auctions; sell-through rate | Search results only: no item descriptions, no seller names, no location | | Other Yahoo Auctions scrapers on the Apify Store | $0.60 to $5 per 1,000, some with a $0.05 to $0.10 start fee per run | A dump of search results | No monitoring or sold confirmation; a per-run start fee makes small scheduled runs expensive | | Proxy-buying services' own alerts | Free with an account | Alerts inside their site | Their filters, their data; nothing you can feed into Sheets or your own tools | | Checking ヤフオク! by hand | Your time | Everything | Blocked from Europe without a VPN, and no history of what sold | Store figures as of September 2026. ### FAQ **Is this allowed? What about privacy?** It reads the public search and closed-auction pages anyone in Japan can see without logging in, for the searches you choose. It doesn't log in, bid, solve CAPTCHAs or reveal hidden contact details. Sellers are never named: you get store or private, a rating and an anonymous hash. Not affiliated with Yahoo! JAPAN or LY Corporation. Check that your use fits Yahoo's terms and your local law. **Why did my monitoring run return nothing?** Nothing new or changed since the last run. You get one summary row with `listingCount` 0 and pay only the start fee. **Does it find sold auctions and their prices?** Yes, for auctions a watchlist tracked. With monitoring and "Alert on gone auctions" on, a tracked auction that closes comes back as `gone`, and when Yahoo's closed-auction results show the sale it carries `soldConfirmed: true` and the `finalPrice`. It does not search Yahoo's full sold history for you; it confirms the auctions you were watching. **Are prices with or without tax and shipping?** With tax, as Yahoo displays them (store sellers list prices before tax; the actor adds it back the way Yahoo does). Shipping is separate, in `shippingFee`, when the seller states it. **Do I need a proxy, VPN or Yahoo account?** No. The default proxy setting reaches Yahoo! JAPAN from anywhere, including the EEA and UK where Yahoo blocks direct visits. Don't switch to a European proxy: Yahoo refuses those. **Can an AI agent call this?** Yes, through the Apify MCP server or the API call above. **Other Japanese marketplaces?** [Mercari Japan Scraper](https://apify.com/accountable_eel/mercari-jp-listing-lookup) covers jp.mercari.com with the same monitoring and sold signal. # Actor input Schema ## `searches` (type: `array`): One search per line: keywords like "ゲームボーイ" or "nintendo switch", or a search link copied from auctions.yahoo.co.jp (its own category, brand, price and sort filters are kept). No login required. Accepted formats: ゲームボーイ, nintendo switch, https://auctions.yahoo.co.jp/search/search?p=%E3%83%9D%E3%82%B1%E3%83%A2%E3%83%B3%E3%82%AB%E3%83%BC%E3%83%89\&s1=end\&o1=a. You're only charged for the ones we actually find — a miss costs nothing. ## `testRun` (type: `boolean`): Turn this on to test your input on a small sample before running the full list. Turn it off to process everything. ## `onlyFound` (type: `boolean`): Only keep rows where something was actually found. Misses are always free, whether or not you show them here. ## `includeKeywords` (type: `array`): Optional. Only keep results that mention at least one of these words (e.g. a job title, a city, a product name). Leave empty to keep everything. ## `excludeKeywords` (type: `array`): Optional. Drop any result that mentions one of these words. Leave empty to skip nothing. ## `maxResults` (type: `integer`): Optional. Stop the run once this many results have been found — useful for a quick, cheap sample. Leave blank for no limit. ## `maxListingsPerSearch` (type: `integer`): Yahoo shows 50 or 100 auctions per page; this actor pages automatically, up to 1,000 per search. You pay per auction returned, so this is also your budget control. ## `sort` (type: `string`): Yahoo Auctions' own sort orders. Keep "Newest first" for new-auction alerts: it is the order the sold signal can read best. ## `minPrice` (type: `integer`): Optional. Sent to Yahoo as its own price filter and checked again on every row. Leave empty for no minimum. ## `maxPrice` (type: `integer`): Optional. Sent to Yahoo as its own price filter and checked again on every row. With monitoring, an auction whose bids pass this price drops out of the search, so it is only called gone once its end time has passed. ## `endingWithinHours` (type: `integer`): Optional. Without monitoring: return only auctions that end within this many hours (the search is read in "Ending soonest" order). With monitoring: every auction is still tracked, and one already on your watchlist comes back once more, as changeType "ending-soon", when it enters its last hours. ## `deltaMode` (type: `boolean`): Turns a search into a watchlist: a Yahoo Auctions alert for new listings. An auction is new when its Yahoo auction ID hasn't been returned by a previous run of the same watchlist. Also alerts on buy-it-now price drops, and optionally on price rises, auctions entering their last hours and gone auctions (sold, with Yahoo's final price). Unchanged auctions are removed before you are billed, so a quiet run costs only the run fee. The first run returns and remembers everything; from the second run on you get only what changed. Schedule it and send the rows to Google Sheets, Slack or n8n. ## `deltaName` (type: `string`): Leave empty and we derive one from this run's filters, so two schedules with different filters keep separate memories. Type your own name to keep one memory across a filter change, or to have two schedules share one. ## `alertOnNew` (type: `boolean`): Part of "Alert on" (split into checkboxes so the Console can render it as a plain toggle). On by default. ## `alertOnPriceDrop` (type: `boolean`): Part of "Alert on". On by default. For auctions this is the buy-it-now price (即決): bids only ever go up. ## `alertOnPriceRise` (type: `boolean`): Off by default. On: an auction already on your watchlist comes back when its current price has risen, or, with a threshold below, when it has crossed that price since the last run. ## `priceRiseAbove` (type: `integer`): Optional, used with "Alert on price rises". Alert only when an auction's current price goes from under this amount to this amount or more. Leave empty to alert on every new bid. ## `alertOnGone` (type: `boolean`): Off by default. On: auctions on your watchlist that left Yahoo's open auctions since the last run come back as rows with changeType "gone", billed as ordinary rows. When Yahoo's closed-auction results show the sale, soldConfirmed is true and the row carries the final price, bids and sale time. Gone auctions are always counted for the sell-through rate, even with this off. ## `minPriceDropPct` (type: `integer`): The buy-it-now price must fall at least this much since it was last seen. Default 5%. ## `skipFirstRun` (type: `boolean`): On: the run that first starts a watchlist banks every auction silently (no rows, no charge) instead of reporting everything that already existed as "new". Off (default): the first run returns everything it finds, all marked new. ## `columns` (type: `array`): Choose which pieces of information to include in each result row. All are included by default. ## `expandRows` (type: `boolean`): When on, each listing found gets its own row instead of being grouped under its search. You're still only charged once per search, no matter how many rows it produces. ## `maxConcurrency` (type: `integer`): Parallel requests. Keep conservative — this target has no browser fallback, so getting blocked costs more than slow-and-steady. ## `proxyConfiguration` (type: `object`): Apify Proxy config. Residential recommended for anti-bot-sensitive targets. ## Actor input object example ```json { "searches": [ "ゲームボーイ" ], "testRun": false, "onlyFound": false, "includeKeywords": [], "excludeKeywords": [], "maxListingsPerSearch": 100, "sort": "newest", "deltaMode": false, "deltaName": "", "alertOnNew": true, "alertOnPriceDrop": true, "alertOnPriceRise": false, "alertOnGone": false, "minPriceDropPct": 5, "skipFirstRun": false, "columns": [ "searchQuery", "sort", "listingCount", "totalAvailable", "truncated", "newCount", "priceDropCount", "priceRiseCount", "endingSoonCount", "goneCount", "soldCount", "sellThroughRate", "medianPrice", "listings", "listingId", "url", "title", "price", "currency", "priceEur", "currentPrice", "startPrice", "buyNowPrice", "bidCount", "endsAt", "endsInHours", "postedAt", "auctionStatus", "condition", "categoryId", "shippingFee", "isFreeShipping", "imageUrl", "sellerType", "sellerRatingPct", "sellerHash", "isPromoted", "isNew", "changeType", "previousPrice", "priceDropPct", "firstSeenAt", "lastSeenAt", "daysListed", "lastPrice", "finalPrice", "endedAt", "gonePresumedSold", "soldConfirmed" ], "expandRows": true, "maxConcurrency": 3, "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "UNBLOCKER" ] } } ``` # 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 = { "searches": [ "ゲームボーイ" ], "includeKeywords": [], "excludeKeywords": [] }; // Run the Actor and wait for it to finish const run = await client.actor("accountable_eel/yahoo-auctions-jp-lookup").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 = { "searches": ["ゲームボーイ"], "includeKeywords": [], "excludeKeywords": [], } # Run the Actor and wait for it to finish run = client.actor("accountable_eel/yahoo-auctions-jp-lookup").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 '{ "searches": [ "ゲームボーイ" ], "includeKeywords": [], "excludeKeywords": [] }' | apify call accountable_eel/yahoo-auctions-jp-lookup --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,accountable_eel/yahoo-auctions-jp-lookup" } } } ``` 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/DVt1BxaqKLMiRC58K/builds/hbuGjd6NddenJgv6l/openapi.json