# Japan Knife Restock & Price Monitor (`datalab-jp/japan-handmade-knife-restock-monitor`) Actor

Monitor Japanese kitchen-knife stores (Sakai Ichimonji Mitsuhide global & Japan, Kama-asa Kappabashi): back in stock, sold out, price changes and new knives per blade length, with knife type, steel and finish fields.

- **URL**: https://apify.com/datalab-jp/japan-handmade-knife-restock-monitor.md
- **Developed by:** [Task Data](https://apify.com/datalab-jp) (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 $2.00 / 1,000 product variant rows

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

## Japan Knife Restock & Price Monitor

Track **stock, prices and new arrivals** of Japanese kitchen knives at specialist stores — **Sakai Ichimonji Mitsuhide** (Osaka, global and Japan stores) and **Kama-asa** (Kappabashi, Tokyo) — in one run. You get one row per **blade length / option (variant)** with **price, in-stock flag, knife type, steel, finish and URL**, and in monitoring mode only **what changed since the last run**: back in stock, sold out, price up, price down, new knife, new size. No coding needed.

Built for knife shops, importers, chefs and collectors who follow availability of handmade Sakai knives (yanagiba, deba, gyuto, honyaki…) without checking each website by hand. On 2026-10-10, more than half of the knife variants in these stores (884 of 1,657) were sold out — the restock is the moment that matters.

### What data can you extract?

| Field | Description |
|---|---|
| `storeName`, `storeId`, `storeDomain`, `market` | Which store the row comes from (`global` = English store, `japan` = Japanese store) |
| `title`, `variantTitle` | Product title and variant (e.g. `白紙二号 柳刃` / `180mm`) |
| `itemCategory` | knife, whetstone, saya_case, accessory, cookware, service, event, gift_card, other |
| `knifeType` | gyuto, santoku, petty, nakiri, usuba, deba, yanagiba, takobiki, fugubiki, sujihiki, honesuki, garasuki, chinese_cleaver, bread, menkiri, unagisaki, honekiri, kenmuki, maguro, funayuki, ajikiri, bunka, kiritsuke, other |
| `steel`, `steelText` | Unified steel code when the title names it (白二鋼 / 白紙二号 / White Steel #2 → `white_2`; also blue_1, blue_2, blue_super, ginsan, vg10, vg1, sg2, …) and the words used |
| `finishes` | Finish / construction named in the title: honyaki, damascus, suminagashi, montanren, hongasumi, kasumi, mirror, kurouchi, tsuchime, migaki |
| `smith` | Smith named in the title (`中川作 …` → `中川`, `Nakagawa Satoshi Forged` → `Nakagawa Satoshi`), else null |
| `vendor` | The store's vendor field — the **maker company** at Kama-asa (e.g. `株式会社馬場刃物製作所`), the brand at Ichimonji |
| `bladeLengthMm`, `leftHanded`, `preorder` | Blade length in mm, left-handed version, pre-order / made-to-order flag |
| `price`, `compareAtPrice`, `currency` | Current price and the currency the store answered in (see notes) |
| `available` | The store's in-stock flag for that exact variant |
| `changeType`, `changes` | `restocked`, `sold_out`, `price_up`, `price_down`, `new_product`, `new_variant`, `removed`, `first_run`, `unchanged` |
| `previousPrice`, `previousAvailable`, `priceChange`, `priceChangePct`, `previousRunAt`, `firstSeenAt` | Values at the previous run and the difference |
| `productUrl`, `variantUrl`, `imageUrl` | Product page, page with the variant preselected, image URL on the store's CDN (reference only) |
| `sku`, `productId`, `variantId`, `handle`, `productType`, `tags`, timestamps | Identifiers and the store's own labels |

Product descriptions are **not** copied, and images are referenced by URL, not downloaded. Knife type, steel, finish and smith are read from the **title, product type and tags only**; when the title does not name a steel (or uses a store brand such as `FV10` or `特鋼`), `steel` is null.

### Why monitor Japanese knife stores?

1. **Restock alerts** — popular sizes of hand-forged knives sell out and come back in small batches. Schedule the Actor with `changeTypes: ["restocked", "new_product", "new_variant"]` and get only the knives that just became available.
2. **Price tracking** — `price_up` / `price_down` rows give you the date, old price, new price and percentage per blade length.
3. **Purchasing decisions for knife shops and importers** — see availability by knife type, steel and blade length across several stores in one table.
4. **Market research** — a full snapshot of every knife, steel, size and price, ready for a spreadsheet or BI tool.
5. **AI agents / RAG** — the Actor is callable through the Apify MCP server, so an AI assistant can answer "which white-steel yanagiba are in stock in Sakai right now?" with live data.

### How to use it (no coding)

1. Click **Try for free**.
2. Pick the **stores**, and optionally **knife types** (e.g. `yanagiba`, `gyuto`) and **steels** (e.g. `white_2`, `blue_2`).
3. Choose **Mode**: `changes` (monitoring) or `snapshot` (everything now).
4. Click **Start**. The first `changes` run saves a baseline of every variant and returns rows as `first_run` (up to `maxItems`).
5. Open **Schedules** and run it every few hours or daily. From the second run on you get only the changes — connect a webhook, Slack, email or Google Sheets integration to be notified.

### Input example

```json
{
  "mode": "changes",
  "stores": ["ichimonji-global", "ichimonji-japan", "kama-asa"],
  "itemCategories": ["knife"],
  "knifeTypes": ["yanagiba", "deba", "gyuto"],
  "steels": [],
  "keywords": [],
  "changeTypes": ["restocked", "new_product", "new_variant", "price_up", "price_down"],
  "maxItems": 100,
  "stateStoreName": "japan-knife-restock-monitor",
  "proxyConfiguration": { "useApifyProxy": true }
}
```

- `mode` — `changes` returns only differences from the previous run; `snapshot` returns every matching variant. When omitted (API calls), the default is `snapshot`.
- `itemCategories` — defaults to `["knife"]`; pass `[]` for everything (saya, whetstones, accessories, repair services; Kama-asa also sells cookware).
- `knifeTypes` / `steels` — work across Japanese and English titles. `white` / `blue` mean the title did not state the grade (e.g. `青鋼`).
- `keywords` — optional words such as a series or smith (`Kirameki`, `中川`, `本焼`). Japanese/English/Chinese knife words such as `gyuto` → `牛刀` or `柳刃` → `Yanagiba` are retried automatically when they match nothing in a store.
- `maxItems` — total rows for the run (default 100), shared fairly between the selected stores.
- `stateStoreName` — a named key-value store **in your own Apify account** that remembers the previous prices and stock. Use a different name for each schedule with different filters.

### Output example

```json
{
  "storeId": "kama-asa",
  "storeName": "釜浅商店",
  "storeDomain": "kama-asa.co.jp",
  "market": "japan",
  "productId": "8875665457474",
  "variantId": "47506871976258",
  "handle": "shirogami-no-2-yanagi",
  "title": "白紙二号 柳刃",
  "variantTitle": "180mm",
  "sku": "2020100018154",
  "productType": "柳刃",
  "vendor": "株式会社馬場刃物製作所",
  "tags": ["2〜3万円", "GIFT WRAPPING__label2", "包丁", "柳刃"],
  "itemCategory": "knife",
  "knifeType": "yanagiba",
  "steel": "white_2",
  "steelText": "白紙二号",
  "finishes": [],
  "smith": null,
  "bladeLengthMm": 180,
  "leftHanded": false,
  "preorder": false,
  "price": 26180,
  "compareAtPrice": null,
  "currency": "JPY",
  "available": true,
  "imageUrl": "https://cdn.shopify.com/s/files/1/0748/9814/5602/files/houchou_shirogami_yanagi_21_4689dac1-991d-4f3d-8005-9100e778cf94.jpg?v=1750722708",
  "productUrl": "https://kama-asa.co.jp/products/shirogami-no-2-yanagi",
  "variantUrl": "https://kama-asa.co.jp/products/shirogami-no-2-yanagi?variant=47506871976258",
  "publishedAt": "2023-10-18T16:07:20+09:00",
  "productCreatedAt": "2023-10-18T16:07:32+09:00",
  "variantUpdatedAt": "2026-10-10T21:55:31+09:00",
  "scrapedAt": "2026-10-10T12:57:35.522Z",
  "changeType": "restocked",
  "changes": ["restocked"],
  "previousPrice": 26180,
  "previousAvailable": false,
  "priceChange": 0,
  "priceChangePct": 0,
  "previousRunAt": "2026-10-10T06:57:35.522Z",
  "firstSeenAt": "2026-10-01T06:00:00.000Z"
}
```

(The product data above is real; the availability and change values illustrate how a `restocked` row looks.)

**Field notes**

- `changeType` is the most important change; `changes` lists all of them (a size can be `restocked` and `price_up` in the same run).
- **Currency**: the product feed of a Shopify store has no currency field; the Actor reads the currency the store set for the request (`cart_currency`). In testing, the two Japan stores answered in **JPY** and the global Ichimonji store in **USD**, so its prices are in US dollars. The `currency` column always tells you which. Prices are compared between runs only in the same currency, so a currency switch never produces a fake price change.
- `removed` rows describe a variant that disappeared since the last run; they carry the last known title and price (`previousPrice`) with `price` and `available` set to `null`. They are only reported when the whole catalogue was read successfully.
- Lottery sales announced only on social media or by email are not visible; the Actor sees what the store's product feed shows (stock flag, price, new products).
- The `RUN_REPORT` record (default key-value store) has a per-store summary: HTTP status, currency, variants read, rows returned, change counts, whether the baseline was updated, and a plain-language hint when a store returned nothing.

### How much does it cost?

Pay-per-event: a tiny start charge of $0.00005 (Apify's default Actor Start event, charged once per GB of memory; this Actor runs on 1 GB) plus a per-row price:

| Event | What it is | Price |
|---|---|---|
| Actor Start (`apify-actor-start`) | Once per run (per GB of memory) | $0.00005 |
| Result row (`apify-default-dataset-item`) | Each row returned | $0.003 (FREE and BRONZE plans) · $0.002 (SILVER and above) |

In `changes` mode you pay only for rows that changed, so a monitor that finds 5 restocks costs about $0.015 on the FREE plan. The default run (100 rows) costs about $0.30 on FREE; every knife in all three stores is about 1,660 rows (≈ $4.98), and every item including accessories about 3,600 rows. Use `maxItems` to cap spend. Platform usage (compute) is included in these prices; a full run takes about 20 seconds.

### Integrations: API, MCP, and AI agents

This Actor is **read-only**: it only reads public product feeds. It never logs in, adds to cart, orders, enters lotteries or changes anything on the stores.

#### API (curl)

```bash
curl -X POST "https://api.apify.com/v2/acts/datalab-jp~japan-handmade-knife-restock-monitor/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" -d '{"mode": "snapshot", "itemCategories": ["knife"], "maxItems": 100}'
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("datalab-jp/japan-handmade-knife-restock-monitor").call(run_input={"mode": "snapshot", "itemCategories": ["knife"], "maxItems": 100})
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('datalab-jp/japan-handmade-knife-restock-monitor').call({ mode: 'snapshot', itemCategories: ['knife'], maxItems: 100 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

The synchronous `run-sync-get-dataset-items` endpoint waits up to 300 seconds; a full run normally finishes in well under a minute.

#### Use with AI agents (MCP)

Add the Apify MCP server (`https://mcp.apify.com`) to Claude, ChatGPT, Cursor or any MCP client and ask, for example, "Which blue-steel deba knives are in stock at Kama-asa right now?" The agent calls this Actor with `mode: "snapshot"`, `stores: ["kama-asa"]`, `knifeTypes: ["deba"]` and `steels: ["blue_1", "blue_2", "blue"]`.

### Related Actors

Other Japan data Actors by the same developer:

- [**Japan Matcha & Tea Stock & Price Monitor**](https://apify.com/datalab-jp/japan-matcha-tea-stock-monitor) — stock and price changes at Japanese matcha and tea shops
- [**Japan Denim Restock & Price Monitor**](https://apify.com/datalab-jp/japan-denim-restock-monitor) — stock and price changes at Japanese denim stores
- [**Mercari Japan Scraper – Listings & Item Details**](https://apify.com/datalab-jp/mercari-japan-listings-scraper) — Mercari listings and sold prices
- [**Yahoo Auctions Japan Scraper – Live, Sold & Flea Market**](https://apify.com/datalab-jp/yahoo-auctions-flea-market-scraper) — Yahoo! Auctions and Yahoo! Flea Market listings

### FAQ

**Is this legal?**
The Actor reads only the public product feed (`/products.json`) that each store serves to every visitor, without logging in or bypassing any access control, one request at a time with pauses. It returns factual data (names, sizes, prices, stock) and does not copy product descriptions or images. Each store's robots.txt and terms were read in full before the store was added; stores whose terms prohibit crawling, scraping or commercial use of their information are not supported. You are responsible for using the data in line with applicable laws and each store's terms.

**Can I use it through the API?**
Yes — see the curl, Python and JavaScript examples above. Schedule it in Apify and read the dataset, or connect a webhook.

**Can AI agents use it?**
Yes. It is read-only, needs no credentials for the stores, and every input has a default, so an agent can call it safely.

**How is this different from a generic Shopify scraper?**
It comes with a checked list of knife stores, adds knife-specific fields (knife type, unified steel code, finish, smith, blade length, left-handed) that a generic scraper leaves inside the title, and returns only the changes since the last run.

**How does change detection work?**
After each run the Actor saves the price and stock of every variant in the named key-value store `stateStoreName` in your account. The next run compares against it. The first run per store (or a new store name) saves the full baseline and returns rows as `first_run`.

**Why is my favourite knife store not supported?**
A store is added only if it serves a public product feed and its terms of use, read in full, do not restrict this kind of use. Several well-known knife stores were checked and left out for that reason; asking for one by its ID returns the reason.

**Does it buy or reserve knives?**
No. It does not add to cart, check out, reserve or enter lotteries, and it does not help get around purchase limits. It only reports what the stores publish.

**Do I need a proxy?**
The default uses Apify's datacenter proxy because Shopify-based stores rate-limit busy cloud IP addresses. Residential proxy is not needed. If a store answers HTTP 429 repeatedly, the run report says so; run again later.

### Disclaimer

This Actor is not affiliated with, endorsed by or connected to any of the stores listed. Store names are used only to identify the data source. Data is provided as published by the stores at the time of the run and may change at any time.

### 中文简介

- 监控日本厨刀专门店（堺一文字光秀 海外店/日本店、合羽桥釜浅商店）的手工刀具库存、价格和新品。
- 每个规格（刃长/选项）一行：价格、是否有货、刀型（牛刀、柳刃、出刃等）、钢材（白纸二号、青纸、银三、VG10等）、链接；监控模式只返回与上次相比的变化（补货、售罄、涨价、降价、新品）。
- 适用于刀具店与进口商的采购判断和库存监控；只读取公开商品数据，不会下单、加入购物车或参与抽选。

# Actor input Schema

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

What to return: 'changes' = only what changed since the previous run (restocked, sold_out, price_up, price_down, new_product, new_variant, removed); 'snapshot' = every matching variant with current price and stock. In 'changes' mode the first run per store saves a baseline and returns rows as 'first_run'; schedule later runs to get only changes. Defaults to 'snapshot' when omitted. Both modes compare with and update the state in `stateStoreName`.

## `stores` (type: `array`):

Japanese knife stores to read, e.g. \['kama-asa'] or \['ichimonji-global', 'kama-asa']. Only stores whose terms of use do not restrict this use are supported: Sakai Ichimonji Mitsuhide global store (English titles), its Japan store (Japanese titles) and Kama-asa (Kappabashi, Tokyo). Defaults to all 3 when omitted. Each store's whole public catalogue is read once per run (2–3 requests) and the filters are applied afterwards; stores are processed in the listed order.

## `itemCategories` (type: `array`):

Keep only these kinds of items, e.g. \['knife'] or \['knife', 'whetstone']. The category is assigned from each store's product type, tags and title; a knife sold with a saya stays 'knife'. Defaults to \['knife'] when omitted; pass \[] for every item including saya, accessories, cookware and repair services. Kama-asa also sells pots and grills ('cookware').

## `knifeTypes` (type: `array`):

Keep only these knife shapes, e.g. \['gyuto', 'santoku'] or \['yanagiba', 'deba', 'usuba'] for traditional single-bevel knives. The type is read from Japanese and English titles (牛刀 = gyuto, 柳刃 = yanagiba), so it works across all stores. Defaults to no knife-type filter. Non-knife rows have knifeType null and are dropped when this filter is set.

## `steels` (type: `array`):

Keep only knives whose title names one of these steels, e.g. \['white_2', 'blue_2'] or \['vg10']. Japanese and English names are unified (白二鋼 / 白紙2号 / White Steel #2 = white_2). Defaults to no steel filter. Store-brand steels whose composition the store does not state (e.g. FV10, 特鋼) have steel null and are dropped when this filter is set; 'white' / 'blue' mean the title did not state the grade.

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

Drop variants cheaper than this price, e.g. 20000 (yen) or 150 (US dollars). The comparison uses each row's own `currency`: the Japan stores answer in JPY, while the global Ichimonji store answered in USD in testing (Shopify picks the currency per visitor). Defaults to no minimum when empty. Removed rows are judged by their last known price.

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

Drop variants more expensive than this price, e.g. 30000 (yen) or 300 (US dollars). The comparison uses each row's own `currency` (JPY at the Japan stores; the global store answered in USD in testing), so combine it with `stores` when you mix stores. Defaults to no maximum when empty. Must be greater than or equal to `minPrice`.

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

Keep only products whose title, size, type, vendor, tags or SKU contain any of these words, e.g. \['Kirameki'] or \['中川', '本焼']. The Japan stores use Japanese titles, the global store English ones; knife and steel words (gyuto→牛刀, 柳刃→Yanagiba, white steel→白鋼, 三德→三徳) are retried with a verified alias when they match nothing in a store. Defaults to no keyword filter. Combined with the other filters (all must match).

## `changeTypes` (type: `array`):

In 'changes' mode, return only these kinds of change, e.g. \['restocked'] for back-in-stock alerts or \['price_up', 'price_down'] for price tracking. A row matches if any of its changes is listed (a size can be restocked and repriced at once). Defaults to all change types when empty. Ignored in 'snapshot' mode; changes filtered out here are still recorded in the state and are not reported again.

## `onlyAvailable` (type: `boolean`):

In 'snapshot' mode, drop variants that are currently sold out, e.g. to list only knives that can be ordered right now. Availability is the store's own in-stock flag for each blade length / option. Defaults to false (sold-out variants are included with available=false). Ignored in 'changes' mode, where sell-outs are reported as 'sold_out' events.

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

Maximum rows for the whole run, e.g. 100 for a quick check or 2000 for every knife in every store (about 1,660 knife variants in October 2026). Each row is one billable result, so this is your cost cap; it is shared fairly between the selected stores. Defaults to 100 when omitted; accepts 1–20000. If a store's change output is cut off, its state is not updated, so the missing changes come next run (a first-run baseline is always saved in full).

## `stateStoreName` (type: `string`):

Name of the key-value store in YOUR Apify account that keeps the previous run's prices and stock, e.g. 'japan-knife-restock-monitor' or 'gyuto-restock-alerts'. Letters, digits and hyphens only (max 63). Defaults to 'japan-knife-restock-monitor'. Use a different name for each schedule with different filters so one monitor does not consume another's changes; a new name starts a new baseline.

## `autoRetryKeywordMapping` (type: `boolean`):

When a keyword matches nothing in a store, retry it once with a verified alias, e.g. 'gyuto' → '牛刀' on a Japanese store or '柳刃' → 'Yanagiba' on the global store. Only aliases checked against real store titles are used. Defaults to true. The run log and the RUN_REPORT record show which word was actually used for each store.

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

Proxy for reading the stores' public product feeds, e.g. {'useApifyProxy': true} (Apify datacenter proxy) or {'useApifyProxy': false} (direct). Shopify rate-limits per IP and has answered HTTP 429 to busy cloud IPs, so the datacenter proxy is on by default. Defaults to Apify datacenter proxy; residential proxy is not needed. Requests go one at a time with pauses and automatic retries on 429.

## Actor input object example

```json
{
  "mode": "changes",
  "stores": [
    "ichimonji-global",
    "ichimonji-japan",
    "kama-asa"
  ],
  "itemCategories": [
    "knife"
  ],
  "knifeTypes": [],
  "steels": [],
  "keywords": [],
  "changeTypes": [],
  "onlyAvailable": false,
  "maxItems": 100,
  "stateStoreName": "japan-knife-restock-monitor",
  "autoRetryKeywordMapping": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `variants` (type: `string`):

Dataset items: store, title, blade length, knife type, steel, price, in-stock flag, URLs and changeType (restocked, sold_out, price_up, price_down, new_product, new_variant, removed…). See the dataset schema.

## `runReport` (type: `string`):

Per-store summary: HTTP status, products/variants read, rows returned, change counts, whether the comparison state was updated, a status (ok, no_changes, no_match, partial, blocked_suspected, request_failed, skipped_limit) and a plain-language hint.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "changes",
    "stores": [
        "ichimonji-global",
        "ichimonji-japan",
        "kama-asa"
    ],
    "itemCategories": [
        "knife"
    ],
    "knifeTypes": [],
    "steels": [],
    "keywords": [],
    "changeTypes": [],
    "onlyAvailable": false,
    "maxItems": 100,
    "stateStoreName": "japan-knife-restock-monitor",
    "autoRetryKeywordMapping": true,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("datalab-jp/japan-handmade-knife-restock-monitor").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "mode": "changes",
    "stores": [
        "ichimonji-global",
        "ichimonji-japan",
        "kama-asa",
    ],
    "itemCategories": ["knife"],
    "knifeTypes": [],
    "steels": [],
    "keywords": [],
    "changeTypes": [],
    "onlyAvailable": False,
    "maxItems": 100,
    "stateStoreName": "japan-knife-restock-monitor",
    "autoRetryKeywordMapping": True,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("datalab-jp/japan-handmade-knife-restock-monitor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "changes",
  "stores": [
    "ichimonji-global",
    "ichimonji-japan",
    "kama-asa"
  ],
  "itemCategories": [
    "knife"
  ],
  "knifeTypes": [],
  "steels": [],
  "keywords": [],
  "changeTypes": [],
  "onlyAvailable": false,
  "maxItems": 100,
  "stateStoreName": "japan-knife-restock-monitor",
  "autoRetryKeywordMapping": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call datalab-jp/japan-handmade-knife-restock-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datalab-jp/japan-handmade-knife-restock-monitor"
        }
    }
}
```

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/u8AiXl1b5MH70PPZp/builds/Aq201NPJPzN5Lpu9r/openapi.json