# Japan Denim Restock & Price Monitor (`datalab-jp/japan-denim-restock-monitor`) Actor

Monitor official Japanese denim brand stores (WAREHOUSE & Co., TCB jeans): back in stock, sold out, price changes, new models and sizes per waist, with lot number, fabric weight (oz), wash and fit fields.

- **URL**: https://apify.com/datalab-jp/japan-denim-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 Denim Restock & Price Monitor

Track **stock, prices and new arrivals** of Japanese denim at the official online stores of **WAREHOUSE & Co.** (Osaka) and **TCB jeans** (Kojima, Okayama) in one run. You get one row per **colour × size (variant)** with **price, in-stock flag, lot / model, fabric weight (oz), wash, waist size and URL**, and in monitoring mode only **what changed since the last run**: back in stock, sold out, price up, price down, new model, new size, purchase limit added. No coding needed.

Built for people who follow Japanese jeans and denim jackets — denim shops, buyers doing price research, and enthusiasts waiting for one waist size — without checking each brand's website by hand. On 2026-10-10, 486 of the 1,004 jean / jacket / overall variants in these two stores were sold out.

### What data can you extract?

| Field | Description |
|---|---|
| `storeName`, `storeId`, `storeDomain`, `market` | Which store the row comes from (`japan` = Japanese store, `global` = English store) |
| `title`, `variantTitle` | Product title and variant as the store writes them (e.g. `Lot 800XX (STANDARD) NON WASH` / `INDIGODENIM NONWASH / 32`) |
| `brand`, `subBrand` | The store's vendor field, and a line named in WAREHOUSE's own tags (`DENIME`, `DEADSTOCK BLUE`, `Duck Digger`, `John Gluckow`, `Greenebaum Brothers`, `2nd-Hand series`) |
| `lotNumber`, `modelName` | Lot number from the title (`Lot 1001XX` → `1001XX`; TCB has none) and the title without weight/wash words (`50's Jeans 13.5oz / One-Wash` → `50's Jeans`) |
| `garmentType` | bottoms, jacket, overall, shirt, tshirt, sweat, headwear, footwear, accessory, care, other |
| `denimStated` | `true` when the title, colour option, tags or fabric line say denim |
| `fabricOz`, `fabricOzSource` | Fabric weight in ounces and where it was read (title, tags or the description's fabric line) |
| `wash`, `washText` | `one_wash`, `non_wash` (raw / rigid) or `used_wash`, and the words it was read from |
| `fit` | `slim_tapered`, `tapered`, `slim`, `straight`, `baggy`, `wide`, `relaxed` — only when a trouser's title or tag names it |
| `edition` | `collaboration` or `special_order` when the title says so |
| `color`, `size`, `waistInch`, `inseamInch` | Colour option, size label, waist in inches (trousers/overalls) and inseam when the store has a length option |
| `preorder`, `purchaseLimitQty`, `purchaseLimitText` | Pre-order flag (title/tag), purchase limit per customer (`お一人様3点まで` → 3) and a short excerpt (≤120 characters) of that sentence |
| `price`, `compareAtPrice`, `currency` | Current price and the currency the store answered in (JPY is requested) |
| `available` | The store's in-stock flag for that exact colour × size |
| `changeType`, `changes` | `restocked`, `sold_out`, `price_up`, `price_down`, `new_product`, `new_variant`, `preorder_started`, `purchase_limit_changed`, `removed`, `first_run`, `unchanged` |
| `previousPrice`, `previousAvailable`, `previousPurchaseLimitQty`, `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 |

**Only what the store states is filled in.** Fabric weight, wash and fit are `null` when the store does not write them — for example, WAREHOUSE states a weight for 59 of its 431 trouser/jacket variants ("light-ounce denim" without a number stays `null`). Product descriptions are **not** copied (only the ≤120-character purchase-limit sentence), and images are referenced by URL, not downloaded.

### Why monitor Japanese denim stores?

1. **Restock alerts for your size** — sizes that are sold out show up again as in stock when the store restocks. Schedule the Actor with `sizes: ["32"]` and `changeTypes: ["restocked", "new_variant"]` and get only the jeans that just became available in your size.
2. **Price tracking** — `price_up` / `price_down` rows give the date, old price, new price and percentage per size.
3. **New releases** — `new_product` rows show new models and colours the day they are published.
4. **Price and assortment research** — a full snapshot of lots, weights, washes, sizes and prices across both brands, 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 14 oz one-wash jeans are in stock in W32 right now?" with live data.

### How to use it (no coding)

1. Click **Try for free**.
2. Pick the **stores**, and optionally **garment types** (default: jeans/trousers, jackets, overalls), **washes**, **sizes** (e.g. `32`) and a **fabric weight** range.
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": ["warehouse", "tcb-jeans"],
  "garmentTypes": ["bottoms", "jacket", "overall"],
  "denimStatedOnly": false,
  "washes": [],
  "sizes": ["32"],
  "keywords": [],
  "changeTypes": ["restocked", "new_product", "new_variant", "price_up", "price_down"],
  "maxItems": 100,
  "stateStoreName": "japan-denim-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`.
- `garmentTypes` — defaults to `["bottoms", "jacket", "overall"]`; pass `[]` for everything (T-shirts, sweats, hats, bandanas, denim detergent…).
- `denimStatedOnly` — keeps only items the store calls denim. Off by default because TCB does not write "denim" in the titles of several denim jackets.
- `washes`, `minFabricOz` / `maxFabricOz` — drop items whose wash or weight the store does not state.
- `sizes` — exact size labels or waists (`"32"`, `"M"`, `"38"`).
- `keywords` — optional lot numbers or model names (`1001XX`, `S40`). `デニム` → `denim` and Chinese words such as `牛仔` → `denim` / `デニム` 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": "warehouse",
  "storeName": "WAREHOUSE & Co.（ウエアハウス）",
  "storeDomain": "warehouse-shop.jp",
  "market": "japan",
  "productId": "12227666772286",
  "variantId": "52923721646398",
  "handle": "lot-800xxstandard-non-wash",
  "title": "Lot 800XX (STANDARD) NON WASH",
  "variantTitle": "INDIGODENIM NONWASH / 32",
  "brand": "WAREHOUSE&Co",
  "subBrand": null,
  "modelName": "Lot 800XX (STANDARD)",
  "lotNumber": "800XX",
  "garmentType": "bottoms",
  "denimStated": true,
  "fabricOz": 14.5,
  "fabricOzSource": "tags",
  "wash": "non_wash",
  "washText": "NON WASH",
  "fit": null,
  "edition": null,
  "color": "INDIGODENIM NONWASH",
  "size": "32",
  "waistInch": 32,
  "inseamInch": null,
  "preorder": false,
  "purchaseLimitQty": null,
  "purchaseLimitText": null,
  "sku": null,
  "productType": "PANTS",
  "tags": ["14.5OZ", "WAREHOUSE", "メンフィスコットン", "単一綿", "定番モデル"],
  "price": 29700,
  "compareAtPrice": null,
  "currency": "JPY",
  "available": true,
  "imageUrl": "https://cdn.shopify.com/s/files/1/0970/9620/4606/files/132358497_31e30feb-51f2-40ea-956e-89884b588d52.webp?v=1767844248",
  "productUrl": "https://warehouse-shop.jp/products/lot-800xxstandard-non-wash",
  "variantUrl": "https://warehouse-shop.jp/products/lot-800xxstandard-non-wash?variant=52923721646398",
  "publishedAt": "2026-01-08T12:52:33+09:00",
  "productCreatedAt": "2026-01-08T12:52:31+09:00",
  "variantUpdatedAt": "2026-10-10T23:02:36+09:00",
  "scrapedAt": "2026-10-10T14:30:00.000Z",
  "changeType": "restocked",
  "changes": ["restocked"],
  "previousPrice": 29700,
  "previousAvailable": false,
  "previousPurchaseLimitQty": null,
  "priceChange": 0,
  "priceChangePct": 0,
  "previousRunAt": "2026-10-10T08:30:00.000Z",
  "firstSeenAt": "2026-10-10T08:30: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**: TCB's store can show prices in other currencies, so the Actor asks both stores for **JPY** and reads the currency the store actually answered in (`cart_currency`). Prices are compared between runs only in the same currency, so a currency switch never produces a fake price change.
- `preorder_started` is reported when a title or tag starts saying pre-order / 予約 / 受注生産. On 2026-10-10 neither store marked items this way (TCB mentions pre-orders only in running text, which the Actor does not interpret), so this event may stay rare.
- `purchase_limit_changed` is reported when a limit appears, disappears or changes its quantity (on 2026-10-10 two WAREHOUSE jeans stated `お一人様3点まで`).
- `removed` rows describe a variant that disappeared since the last run (sold through and unlisted, or hidden); they carry the last known title, size and price (`previousPrice`) with `price` and `available` set to `null`. They are only reported when the whole catalogue was read successfully.
- Restock dates announced only on Instagram or newsletters are not visible; the Actor sees what the store's product feed shows.
- 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 jean, jacket and overall in both stores is about 1,000 rows (≈ $3.02), and every item including T-shirts and accessories about 3,170 rows. Use `maxItems` to cap spend. Platform usage (compute) is included in these prices; a full run takes about 10 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 or reserves anything, and it does not help get around purchase limits.

#### API (curl)

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

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("datalab-jp/japan-denim-restock-monitor").call(run_input={"mode": "snapshot", "garmentTypes": ["bottoms", "jacket", "overall"], "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-denim-restock-monitor').call({ mode: 'snapshot', garmentTypes: ['bottoms', 'jacket', 'overall'], 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 one-wash jeans of 13.5 oz or more are in stock in waist 32 at TCB right now?" The agent calls this Actor with `mode: "snapshot"`, `stores: ["tcb-jeans"]`, `garmentTypes: ["bottoms"]`, `washes: ["one_wash"]`, `minFabricOz: 13.5`, `sizes: ["32"]` and `onlyAvailable: true`.

### 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 Knife Restock & Price Monitor**](https://apify.com/datalab-jp/japan-handmade-knife-restock-monitor) — stock and price changes at Japanese knife 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 pages were checked before the store was added (2026-10-10). Neither supported store publishes a usable terms-of-use text — WAREHOUSE's terms page contains hemming instructions and TCB's terms pages are empty — so nothing in them prohibits this use, but that is not the same as permission. Stores whose terms prohibit scraping, commercial use of their information or copying it 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?**
A generic Shopify scraper gives you the raw feed of any store you point it at. This Actor comes with a checked list of Japanese denim brand stores, adds denim fields that a generic scraper leaves inside the title, tags or description (lot number, fabric weight, wash, fit, waist, purchase limit), and returns only the changes since the last run.

**How does change detection work?**
After each run the Actor saves the price, stock, pre-order flag and purchase limit 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 denim brand 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 Japanese denim brands were checked and left out for that reason (or because the site blocks automated requests); asking for one by its ID returns the reason.

**Does it buy or reserve jeans?**
No. It does not add to cart, check out or reserve, 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 WAREHOUSE & Co., TCB jeans or any other brand mentioned. Brand and 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.

### 中文简介

- 监控日本牛仔品牌官方网店（WAREHOUSE & Co.、TCB jeans）的牛仔裤、牛仔夹克等商品的库存、价格和新品。
- 每个颜色×尺码一行：价格、是否有货、型号（Lot）、面料克重（oz）、洗水（一水/原色）、腰围、链接；监控模式只返回与上次相比的变化（补货、售罄、涨价、降价、新品、新尺码）。
- 只读取公开商品数据，不会下单、加入购物车，也不会帮助绕过限购；适用于库存与价格监控、价格调研。

# Actor input Schema

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

What to return, e.g. 'changes' for monitoring or 'snapshot' for a full list. 'changes' returns only what changed since the previous run (restocked, sold_out, price_up, price_down, new_product, new_variant, preorder_started, purchase_limit_changed, removed); the first run per store saves a baseline and returns rows as 'first_run'. Defaults to 'snapshot' when omitted. Both modes compare with and update the state in `stateStoreName`.

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

Official Japanese denim brand stores to read, e.g. \['warehouse'] or \['warehouse', 'tcb-jeans']. Only stores whose terms do not prohibit this use are supported (neither store publishes a usable terms text, which is not the same as permission): WAREHOUSE & Co. (Osaka, Japanese titles) and TCB jeans (Kojima, English titles). Defaults to both when omitted. Each store's whole public catalogue is read once per run (1–2 requests) and the filters are applied afterwards.

## `garmentTypes` (type: `array`):

Keep only these kinds of items, e.g. \['bottoms'] for jeans and trousers or \['bottoms', 'jacket'] for jeans and denim jackets. The type comes from each store's product type, corrected by the title (a TCB tee filed under Shirts is 'tshirt'). Defaults to \['bottoms', 'jacket', 'overall'] when omitted; pass \[] for every item including T-shirts, sweats, hats and accessories. 'jacket' includes coveralls and vests.

## `denimStatedOnly` (type: `boolean`):

Keep only rows whose title, colour option, tags or fabric line say denim (デニム, INDIGODENIM, 'Jeans', '10oz selvedge denim'), e.g. true to drop chinos, duck and hickory items. The check is strict on purpose: TCB does not write 'denim' in the titles of several denim jackets (e.g. 'New S40's Jacket 14oz'), so those are dropped too. Defaults to false. Use `garmentTypes` alone if you do not want to miss such items.

## `washes` (type: `array`):

Keep only these washes, e.g. \['non_wash'] for raw / unwashed denim or \['one_wash']. The wash is read from the title (NON WASH, One-Wash), the colour option (INDIGODENIM ONEWASH) or an explicit sentence such as 「この商品はワンウォッシュです」. Defaults to no wash filter. Items whose wash the store does not state have wash null and are dropped when this filter is set.

## `minFabricOz` (type: `number`):

Drop items lighter than this fabric weight in ounces, e.g. 13.5 or 14 for heavyweight jeans. The weight is read from the title ("14oz"), a tag ("14.5OZ") or the fabric line of the description ("(13.5 Oz)"). Defaults to no minimum when empty. Items with no stated weight (common at WAREHOUSE) are dropped when this or `maxFabricOz` is set.

## `maxFabricOz` (type: `number`):

Drop items heavier than this fabric weight in ounces, e.g. 12 or 10.5 for lighter denim. Same sources as `minFabricOz` (title, tag or fabric line). Defaults to no maximum when empty. Must be greater than or equal to `minFabricOz`; items with no stated weight are dropped when set.

## `sizes` (type: `array`):

Keep only these sizes, e.g. \['32', '33'] for waist 32–33 or \['38', 'M'] for a jacket size. A row matches when the store's size label or the parsed waist (inches, trousers only) equals one of the values, case-insensitive. Defaults to all sizes when empty. Combine with mode 'changes' and changeTypes \['restocked'] to be told when your size is back.

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

Drop variants cheaper than this price, e.g. 20000 or 30000 (yen). The comparison uses each row's own `currency`; the Actor asks both stores for prices in JPY (TCB can show other currencies). 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 or 50000 (yen). The comparison uses each row's own `currency` (JPY unless the store answered otherwise). Defaults to no maximum when empty. Must be greater than or equal to `minPrice`.

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

Keep only items whose title, variant, product type, sub-brand, lot number, tags or SKU contain any of these words, e.g. \['1001XX'] or \['S40', '50's Jeans']. WAREHOUSE titles are lot numbers with Japanese colour names, TCB titles English model names; a word that matches nothing in a store is retried once with a verified alias (デニム→denim, 牛仔→denim/デニム). 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 sizes that can be ordered right now. Availability is the store's own in-stock flag for each colour × size. 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 1500 for every jean, jacket and overall in both stores (about 1,000 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-denim-restock-monitor' or 'w32-raw-denim-alerts'. Letters, digits and hyphens only (max 63). Defaults to 'japan-denim-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. 'デニム' → 'denim' at TCB or '牛仔' → 'denim' / 'デニム'. Only aliases checked against real store data 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; a run on Apify on 2026-10-10 read both stores this way, so 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": [
    "warehouse",
    "tcb-jeans"
  ],
  "garmentTypes": [
    "bottoms",
    "jacket",
    "overall"
  ],
  "denimStatedOnly": false,
  "washes": [],
  "sizes": [],
  "keywords": [],
  "changeTypes": [],
  "onlyAvailable": false,
  "maxItems": 100,
  "stateStoreName": "japan-denim-restock-monitor",
  "autoRetryKeywordMapping": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset items: store, title, lot, colour, size/waist, fabric oz, wash, price, in-stock flag, URLs and changeType (restocked, sold_out, price_up, price_down, new_product, new_variant, preorder_started, purchase_limit_changed, removed…). See the dataset schema.

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

Per-store summary: HTTP status, currency, 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": [
        "warehouse",
        "tcb-jeans"
    ],
    "garmentTypes": [
        "bottoms",
        "jacket",
        "overall"
    ],
    "denimStatedOnly": false,
    "washes": [],
    "sizes": [],
    "keywords": [],
    "changeTypes": [],
    "onlyAvailable": false,
    "maxItems": 100,
    "stateStoreName": "japan-denim-restock-monitor",
    "autoRetryKeywordMapping": true,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("datalab-jp/japan-denim-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": [
        "warehouse",
        "tcb-jeans",
    ],
    "garmentTypes": [
        "bottoms",
        "jacket",
        "overall",
    ],
    "denimStatedOnly": False,
    "washes": [],
    "sizes": [],
    "keywords": [],
    "changeTypes": [],
    "onlyAvailable": False,
    "maxItems": 100,
    "stateStoreName": "japan-denim-restock-monitor",
    "autoRetryKeywordMapping": True,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("datalab-jp/japan-denim-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": [
    "warehouse",
    "tcb-jeans"
  ],
  "garmentTypes": [
    "bottoms",
    "jacket",
    "overall"
  ],
  "denimStatedOnly": false,
  "washes": [],
  "sizes": [],
  "keywords": [],
  "changeTypes": [],
  "onlyAvailable": false,
  "maxItems": 100,
  "stateStoreName": "japan-denim-restock-monitor",
  "autoRetryKeywordMapping": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call datalab-jp/japan-denim-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-denim-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/OOpweYFFuaaWBhg9Z/builds/9nlQ0X786ZUsefMRa/openapi.json