# Yahoo! Auctions Japan Listings — Flat $0.0015 per Auction (`jpmarketdata/yahoo-auction-listings`) Actor

Every Yahoo! Auctions Japan auction for your search, live or closed: current price, buy-now price, bid count, end time and URL. One flat rate per auction, no start fee, no plan tiers. Seller identities are never emitted.

- **URL**: https://apify.com/jpmarketdata/yahoo-auction-listings.md
- **Developed by:** [h ichi](https://apify.com/jpmarketdata) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 50.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.50 / 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.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Yahoo! Auctions Japan Listings — Flat $0.0015 per Auction

Every Yahoo! Auctions Japan auction for your search term — **live, closed (ended), or both** — with current price, buy-now price, bid count, end time, status and URL. One record per auction, one flat rate per auction.

**No start fee. No per-keyword fee. No plan tiers.** You pay $0.0015 for each auction actually delivered, and nothing else. A run that finds nothing costs nothing.

### What it costs, against the alternatives

Every other Yahoo! Auctions scraper on the Store charges you before it returns a single auction. That start fee is invisible on a 10,000-row job and dominates a 50-row one — and most real jobs are the small ones: one keyword, one price band, one look.

| Auctions returned | **This Actor** | crawlerbros | jungle\_synthesizer | sigma-dev |
|---|---|---|---|---|
| Start fee | **$0** | $0.005 | $0.10 | $0.05 |
| Per auction | **$0.0015** | $0.00367 | $0.0018 | $0.0006 |
| **20 auctions** | **$0.030** | $0.078 | $0.136 | $0.062 |
| **60 auctions** | **$0.090** | $0.225 | $0.208 | $0.086 |
| **500 auctions** | **$0.750** | $1.840 | $1.000 | $0.350 |

Read that honestly, because you can do the arithmetic yourself:

- against **crawlerbros** and **jungle\_synthesizer** this Actor is cheaper at every size — 2.5x to 4.5x cheaper on a small run;
- against **sigma-dev**, whose $0.05 start fee buys a lower unit rate, this Actor is cheaper up to about **55 auctions** and more expensive above it. If you routinely pull thousands of rows per run, their per-unit rate wins and we would rather you knew.

Small, frequent, exploratory runs are where the start fee hurts and where this Actor is the cheapest thing available.

### The one thing you must know about auction prices

**A live auction's current price is a floor, not a price.** It only ever rises with bids. An open auction sitting at ¥80,000 is not something you can buy for ¥80,000 — it is an auction that has not finished.

So every record carries both prices and a flag:

- `priceJpy` — the current price. For a closed auction this is final; for a live one it is a floor.
- `buyNowPriceJpy` — the price you can actually pay today, or `null` when the auction has none.
- `priceIsFloor` — `true` exactly when a **live** auction has **no** buy-now price, i.e. when `priceJpy` cannot be paid.

Yahoo's own markup writes `buynowprice="0"` for an auction with no buy-now. That is absence, not a price of ¥0, and it is emitted as `null` — on a measured sample, 10 of 50 live auctions.

### Output

One record per auction, identical shape for both books, so nothing has to branch on `status` to read a price:

```json
{
  "type": "listing",
  "keyword": "Nikon Z6",
  "status": "live",
  "id": "e1240196684",
  "title": "Nikon デジタル一眼 Z6 ボディ 美品 動作確認済",
  "priceJpy": 86625,
  "buyNowPriceJpy": 80850,
  "priceIsFloor": false,
  "bidCount": 0,
  "endTime": "2026-08-11T13:27:03+00:00",
  "url": "https://auctions.yahoo.co.jp/jp/auction/e1240196684"
}
```

End times are always UTC ISO-8601, from both books.

### Input

| Field | What it does |
|---|---|
| `keywords` | One or more search terms (required). |
| `status` | `live`, `closed`, or `both` (default). |
| `maxListings` | Auctions per search term, 10–2000. With `both`, this is the total and is split between the two books — it is not doubled. |
| `priceMinJpy` / `priceMaxJpy` | Price band. **Pushed to Yahoo**, not filtered after the fact, so paging and result counts respect it. |

### Seller identities are never emitted

Both pages carry the seller — `data-auction-auc-seller-id` on the live cards, a `seller` object in the closed payload. Neither ever reaches a record. This is enforced in code by a `leaks_pii()` check asserted over every record before it is pushed, and in the test suite over every record shape.

### Why you can trust the count

The live search page is server-rendered HTML with sharp edges, and each one is a way to ship a quietly smaller sample:

- a `<li class="Product">` card is **not closed by `</li>`** — splitting on the closing tag glues one card's detail to the next card's image, so cards are split on the opening tag and any chunk that does not hold exactly one detail block is counted as malformed rather than guessed at;
- the page **promotes a listing twice** (51 cards for a 50-result page), so records are deduplicated by auction id;
- the result total lives in the **"すべて" tab**, not in `<meta name="description">` — the latter says *約* (approximately) and does not track your price band.

Malformed cards and dropped duplicates are logged with every run, so a Yahoo redesign shows up as a number rather than as a silently shorter dataset. If every search fails, the run **fails** — it never succeeds quietly with an empty dataset.

### Pricing

**$0.0015 per auction delivered. No start fee, no monthly minimum, all plans the same.** Auctions you do not receive are not charged.

Read-only public pages, no login, throttled requests, no browser. Nothing is stored between runs.

# Actor input Schema

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

What to search for on Yahoo! Auctions Japan.

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

Live auctions, closed (ended) auctions, or both.

## `maxListings` (type: `integer`):

How many auctions to return per search term.

## `priceMinJpy` (type: `integer`):

Pushed to Yahoo.

## `priceMaxJpy` (type: `integer`):

Pushed to Yahoo.

## Actor input object example

```json
{
  "keywords": [
    "Nikon Z6"
  ],
  "status": "both",
  "maxListings": 100
}
```

# Actor output Schema

## `listings` (type: `string`):

One record per Yahoo! Auctions listing: title, current price, buy-now price, bids, end time, seller and URL.

# 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": [
        "Nikon Z6"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jpmarketdata/yahoo-auction-listings").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": ["Nikon Z6"] }

# Run the Actor and wait for it to finish
run = client.actor("jpmarketdata/yahoo-auction-listings").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": [
    "Nikon Z6"
  ]
}' |
apify call jpmarketdata/yahoo-auction-listings --silent --output-dataset

```

## MCP server setup

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

```

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/qPapElBwe7il8VgyP/builds/yFdPCuXue4DCVGVWK/openapi.json