# Isetan Mitsukoshi - Products, Prices, Stock & Reviews (`abotapi/mistore-jp-scraper`) Actor

Scrape the Isetan Mitsukoshi department store online shop (mistore.jp). Search by keyword or department, or paste search, department, brand and product links. Returns id, title, brand, category, JPY price, sale window, stock, colours and images, plus specifications, variants and customer reviews.

- **URL**: https://apify.com/abotapi/mistore-jp-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 product results

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?

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

## Isetan Mitsukoshi Online Store Scraper

Scrape products from the Isetan Mitsukoshi department store online shop at
**https://www.mistore.jp/shopping** and get a clean, flat record per product:
identity, brand, department and breadcrumb trail, price in Japanese yen, sale
flags and the sale window, stock, colour options, the full image gallery, size
and colour variants with per variant price, barcode and stock count, the
specification list, shipping and gift terms, payment methods, allergen panel,
and customer reviews where the store has them.

This is a genuine department store catalogue: womenswear, menswear, baby and
kids, bags, shoes, home, kitchen and art, food and gifts are all covered by the
same actor.

***

### What you get

**49 fields per product.** Everything below is a real field on every row, so a
dataset never changes shape between a light run and a full one.

| Group | Fields |
| --- | --- |
| Identity | `productId`, `title`, `brand`, `brandCode`, `brandUrl`, `sku`, `productNumber`, `url` |
| Category | `topCategory`, `categoryPath`, `categoryCode`, `breadcrumbs` |
| Price | `price`, `priceMin`, `priceMax`, `originalPrice`, `discountPercent`, `currency` |
| Sale and stock | `onSale`, `saleStartsAt`, `saleEndsAt`, `inStock`, `availability`, `stockNote`, `badges`, `badgeCodes`, `cardholderOnly`, `digitalProduct` |
| Media | `image`, `images`, `thumbnails`, `videos` |
| Variants | `variants[]` with `color`, `colorCode`, `size`, `sizeCode`, `barcode`, `price`, `originalPrice`, `discountPercent`, `stock`, `inStock`, `onSale`, `image`, `saleStartsAt`, `saleEndsAt` |
| Detail | `description`, `specifications[]`, `allergens[]`, `notices[]` |
| Delivery and terms | `shippingFee`, `shippingNote`, `deliveryNotes`, `giftOptions[]`, `paymentMethods` |
| Reviews | `rating`, `reviewCount`, `ratingBreakdown`, `reviews[]` with `author`, `rating`, `title`, `text`, `postedAt`, `postedTime`, `helpfulCount`, `totalVotes`, `images` |
| Run and change tracking | `searchMode`, `scrapedAt`, `changeType`, `changedFields`, `firstSeenAt`, `lastSeenAt` |

***

### Modes

#### Search

Give one or more **keywords**, one or more **departments**, or both. Each is
covered separately, across all of its results.

```json
{
  "mode": "search",
  "queries": ["バッグ"],
  "categories": ["womens"],
  "sortBy": "price_asc",
  "badges": ["sale"],
  "minPrice": 5000,
  "maxPrice": 50000,
  "fetchDetails": true,
  "maxItems": 100
}
```

Departments accept a friendly name (`womens`, `mens`, `baby_kids`, `bags`,
`shoes`, `home_kitchen_art`, `food`, `events`) or a store category code such as
`28_011500` for a narrower sub-department.

The store files **bags** and **shoes** under each audience rather than as one
store wide department, so `bags` browses the women's, men's and kids' bag
departments and `shoes` browses the women's, men's, kids' and baby shoe
departments. Each is covered in full, and `maxItems` is shared evenly between
them.

If you paste your own category code, check it against the department you meant.
**This store does not reject a code it does not recognise** — it quietly returns
the entire catalogue instead, so an unrecognised code looks like a working
department that happens to be very large.

#### URL

Paste links and let the actor route them. A listing link is covered in full;
a product link or a bare product id returns that one product with full detail,
and is always returned regardless of the filters.

```json
{
  "mode": "url",
  "urls": [
    "https://www.mistore.jp/shopping/productlist?cgid=28_011500",
    "https://www.mistore.jp/shopping/search?q=%E3%83%AF%E3%82%A4%E3%83%B3",
    "https://www.mistore.jp/shopping/brand/list?brand=002383",
    "https://www.mistore.jp/shopping/product/900000000000000003062447.html",
    "900000000000000003626529"
  ],
  "fetchDetails": true
}
```

***

### Filters

Every filter is the store's **own** refinement, sent with the request rather
than applied afterwards, so it narrows the crawl itself and you are not billed
for products you filtered out. They apply to a keyword search, a department and
a pasted listing link alike.

| Filter | Values |
| --- | --- |
| `sortBy` | `recommended`, `newest`, `price_asc`, `price_desc` |
| `badges` | `sale`, `new_arrival`, `point_bonus`, `limited_time`, `store_exclusive`, `online_exclusive`, `message_card` |
| `colors` | `white`, `black`, `beige`, `green`, `blue`, `purple`, `grey`, `brown`, `yellow`, `pink`, `orange`, `red`, `silver`, `gold`, `other` |
| `brandCodes` | store brand codes, e.g. `002383` |
| `minPrice` / `maxPrice` | yen |
| `includeOutOfStock` | off by default, matching the store |

***

### Output sample

```json
{
  "productId": "900000000000000003062447",
  "title": "型押しハンドルバッグ(9520BK17)",
  "brand": "MONO COMME CA (Women)/モノコムサ",
  "brandCode": "022826",
  "url": "https://www.mistore.jp/shopping/product/900000000000000003062447.html",
  "topCategory": "レディース",
  "categoryPath": ["レディース", "バッグ", "ハンドバッグ"],
  "categoryCode": "28_011504",
  "price": 4829,
  "priceMin": 4829,
  "priceMax": 4829,
  "originalPrice": null,
  "discountPercent": null,
  "currency": "JPY",
  "onSale": true,
  "inStock": true,
  "availability": "InStock",
  "variants": [
    {
      "variantId": "100000000000000375697687",
      "color": "ブラック",
      "colorCode": "10",
      "size": "ｻｲｽﾞ ﾅｼ",
      "barcode": "4549244554673",
      "price": 4829,
      "originalPrice": null,
      "stock": 2,
      "inStock": true,
      "onSale": true
    }
  ],
  "specifications": [
    { "name": "素材", "value": "ブラック/グレー/ダークグレー：本体:合成皮革裏地:ポリエステル付属:合成皮革" },
    { "name": "原産国", "value": "中国" }
  ],
  "shippingFee": 715,
  "giftOptions": [{ "name": "ギフト包装", "available": true, "note": "対応可" }],
  "paymentMethods": ["エムアイカード", "他のクレジットカード", "d払い"],
  "badges": ["SALE", "配送日指定不可"],
  "rating": null,
  "reviewCount": 0,
  "reviews": [],
  "scrapedAt": "2026-08-27T07:33:55Z"
}
```

***

### Reviews

Customer reviews **are** available and are extracted when you turn on
`fetchReviews`. A reviewed product returns its aggregate rating, its review
count, a per star breakdown, and a row per review with the author handle, the
post date and time, the star rating, the title, the full text and the helpful
vote tally.

```json
{
  "rating": 5.0,
  "reviewCount": 1,
  "ratingBreakdown": { "0": 0, "1": 0, "2": 0, "3": 0, "4": 0, "5": 1 },
  "reviews": [
    {
      "author": "<reviewer handle>",
      "rating": 5.0,
      "title": "可愛くてお洒落",
      "text": "娘へのプレゼントに。ジャカード織りでしっかりしていて…",
      "postedAt": "2026-08-19",
      "postedTime": "12:28:42",
      "helpfulCount": 1,
      "totalVotes": 2,
      "images": []
    }
  ]
}
```

**Every review a product declares is returned, not just the first page.** The
store's review surface serves **three reviews per page** and states its own
position in a footer ("showing 4 to 6 of 13"). The actor walks forward on that
footer until it holds the full count, so `reviewCount`, `ratingBreakdown` and
the length of `reviews` always agree with each other. `ratingBreakdown` tallies
exactly the reviews in the row: if you set `maxReviewsPerProduct` lower than a
product's total, the breakdown counts what you got, while `reviewCount` still
reports the store's own total. The buckets run `0` to `5` because the store
really does accept a zero star review, and a one to five histogram would drop
those from a row that still lists them.

**Be aware that reviews on this catalogue are sparse.** Checked live across
bags, food, cosmetics, homeware and wine, only a small minority of products
carry a review at all, and most reviewed products carry exactly one. Products
with more do exist, so the walk is real rather than decorative. Most products
come back with `reviews: []`, `reviewCount: 0` and `rating: null`. Those are
honest empty values, not fabricated zeros, and no review is invented for a
product that has none. A product with one review costs exactly one request and
never speculatively probes a second page. `fetchReviews` is off by default
because it costs at least one extra request per product.

### Discounts and original prices

`originalPrice` and `discountPercent` are extracted at both the product level
and the variant level whenever the store publishes them. **At the time of
writing the store does not publish them.** It flags products as `SALE` and shows
the reduced price, but sampled live across 100 sale flagged and limited time
products in six departments, the list price and the discount rate were empty on
every single one. So `onSale` is reliable, and `originalPrice` and
`discountPercent` are honestly `null` rather than being back-computed from the
current price. If the store starts publishing them, for example during a
seasonal clearance, they come through automatically.

### Countries

**This is a Japan only storefront and the actor has no country input.** The
store publishes no country or region selector and no currency selector; every
price is in Japanese yen, there are no alternate locale pages, and the store's
own help pages state that it does not ship internationally. The language switch
on the site translates the same Japanese catalogue at the same yen prices rather
than opening a different country's shop. The Isetan Mitsukoshi group does run
department stores in other countries, but those are separate businesses on
separate sites, not another storefront of this one. Inventing a `country` input
with a single working value would have been misleading, so there is none.

### Stock status, and how department listings are read

`inStock` is `true`, `false`, or **`null` meaning the store did not publish it
at that point** — never a guess.

The two listing surfaces differ, and it matters:

- A **keyword search** publishes a stock flag for every product on the page, so
  search rows carry a real `true` or `false` straight from the listing.
- A **department listing** publishes no stock flag at all. It renders six
  products into the page and serves the other 54 as placeholder tiles that
  carry only a product id and an ex tax price — no title, no brand, no image,
  no stock flag.

The actor resolves those placeholders through the store's **own tile endpoint**,
the same request the site's page makes as you scroll, which returns the real
title, brand, image and tax included display price. That costs one small extra
request per placeholder and is bounded by `maxItems`, so it is never paid for
beyond what your run can use.

Two deliberate choices follow from this, both chosen over quietly guessing:

1. **A missing stock flag stays `null`, and the default in stock filter never
   drops a `null`.** Treating "not published" as "out of stock" would silently
   discard about 90% of every department page. When `fetchDetails` is on, the
   product page settles the stock status and the filter is applied to that real
   value instead.
2. **A placeholder that could not be resolved is never returned or billed.** If
   the tile request fails, the actor has a product id and nothing else. A row of
   nulls is worse than no row, so it is dropped rather than emitted as a dataset
   item.

The placeholder's own `minprice` is deliberately **not** used as the price: it
is an ex tax figure and runs 8% below the shelf price on food and 10% below on
general goods, which are Japan's two consumption tax bands.

### A note on brand on light runs

The store leaves the brand blank on its own listing tiles for many food, wine
and gift products, where the brand is usually part of the title instead. Those
rows come back with `brand: null` on a listing only run. Turning on
`fetchDetails` fills the brand from the product page, where it is always present.

***

### Recurring runs

#### Incremental mode

Turn on `incrementalMode` for scheduled monitoring. The first run returns
everything as `NEW`; later runs return only `NEW`, `UPDATED` and `REAPPEARED`,
each row carrying `changeType`, `changedFields`, `firstSeenAt` and `lastSeenAt`.
Unchanged products are suppressed, so you are not billed for rows you already
have. Turn on `emitUnchanged` or `emitExpired` only if you also want those
returned, and billed.

State is kept per combination of mode, keywords, departments, links, filters and
enrichment settings, so two different searches never mix. Set `stateKey` to name
a campaign or to deliberately share state.

`EXPIRED` rows are only produced after a run has genuinely scanned the whole
tracked search. A run stopped by `maxItems`, by `maxPages`, by Resume, or one
that read nothing at all, leaves the previous state untouched instead of
declaring products gone.

#### Resume

Paste a previous run id or dataset id into `resumeFromRunId` to continue one
interrupted crawl without returning or being charged for what it already
collected. Runs also survive a platform migration or a Resurrect on their own
via an internal checkpoint.

***

### Limits and cost

- `maxItems` caps the run. `0` means unlimited.
- `maxPages` caps result pages per keyword, department or link. `0` means
  unlimited, and the run then ends only when the store runs out of results.
  Each result page carries 60 products.
- `fetchDetails` and `fetchReviews` each add one request per product and
  together add one **Detail enrichment** charge per enriched product. Turn both
  off for the cheapest possible run.
- If enrichment starts failing across a run, it is switched off automatically
  for the rest of that run: products still come back with their listing fields,
  and the enrichment charge is not applied to them.

### Connection

The default is Apify Proxy with a Japanese exit on the metered residential
pool — the only pool that offers a Japanese exit on every Apify plan. If your
plan includes a cheaper pool, select it in the Connection section to lower the
run cost.

### Send results into your apps (MCP connectors)

Optionally pipe results into the apps you already use through Model Context
Protocol (MCP) connectors. This is an extra delivery step **after** the scrape,
and it never changes the dataset.

1. Authorize a connector once under **Apify, Settings, API and Integrations**
   (Notion, Linear, Airtable or Apify).
2. Select it in the **`mcpConnectors`** field. If the picker is empty, you have
   not authorized a connector yet.
3. For **Notion**, also set **`notionParentPageUrl`** to the URL or id of the
   page the product pages should be created under. Notion gets a rich page per
   product; other connectors get a best effort write or digest.
4. Use **`maxNotifyListings`** (default 50, range 1 to 1000) to cap how many
   products are written to each connector per run.

Each connector receives a condensed, human readable summary per product: the
title, brand, price, sale flag, stock status and product link. The complete
record, including variants, specifications, allergens, delivery terms and
reviews, always stays in the Apify dataset. The connection is mediated by
Apify's MCP proxy, so this actor never sees your third party credentials.
Leave `mcpConnectors` empty to skip.

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mcpConnectors` | array | (empty) | Connectors to pipe results into. Leave empty to skip. |
| `notionParentPageUrl` | string | (empty) | Notion connector only. Page under which product pages are created. Ignored by other connectors. |
| `maxNotifyListings` | integer | 50 | Cap on products written to each connector per run. Does not affect the dataset. |

***

### Local development

```bash
python3.12 -m venv .venv
.venv/bin/pip install -r requirements.txt
PATH=.venv/bin:$PATH apify run --purge
.venv/bin/python -m pytest tests/ -q
```

# Actor input Schema

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

Choose 'search' for keywords and departments with filters, or 'url' to scrape pasted links: a search, department or brand listing link is covered in full, and a product link or bare product id returns that one product with full detail.

## `queries` (type: `array`):

Only used when mode = search, ignored in URL mode. One or more keywords to search, for example バッグ (bag), コート (coat) or ワイン (wine). English keywords work too, but the catalogue is Japanese, so Japanese keywords return far more.

## `categories` (type: `array`):

Only used when mode = search, ignored in URL mode. Browse a whole department instead of, or as well as, a keyword. Use a name from this list: womens, mens, baby\_kids, bags, shoes, home\_kitchen\_art, food, events. The store files bags and shoes under each audience rather than as one store-wide department, so 'bags' browses the women's, men's and kids' bag departments and 'shoes' browses the women's, men's, kids' and baby shoe departments; each is covered in full. A store category code such as 28\_011500 also works if you want a narrower sub-department: open the department on the site, refine it, and copy the cgid value out of the address bar. A code the store does not recognise is not an error on this site - it quietly returns the whole catalogue - so check that the department you copied really is the one you wanted.

## `urls` (type: `array`):

Only used when mode = url, ignored in search mode. Mix freely: product pages under /shopping/product/<id>.html , keyword searches under /shopping/search , department listings under /shopping/productlist , brand listings under /shopping/brand/list , or a bare product id such as 900000000000000003062447 .

## `sortBy` (type: `string`):

The store's own result ordering. 'Recommended' is the store default.

## `badges` (type: `array`):

Optional. Keep only products carrying the store's own badges. Selecting more than one returns products carrying any of them, which is how the store's own refinement behaves.

## `colors` (type: `array`):

Optional. Keep only products available in these colour families, using the store's own colour grouping.

## `brandCodes` (type: `array`):

Optional. Keep only products from these brands, using the store's own brand codes. To get one: open a brand page on the site and copy the brand value out of the address bar, for example 002383 for ANTEPRIMA. Several codes can be given at once.

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

Optional. Only keep products priced at or above this many yen. Sent to the store as its own price refinement, so it narrows the results at the source rather than filtering afterwards.

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

Optional. Only keep products priced at or below this many yen. Sent to the store as its own price refinement.

## `includeOutOfStock` (type: `boolean`):

Off by default, matching the store, which hides out of stock products. Turn on to include them: the store's own catalogue roughly doubles in size when they are shown.

## `fetchDetails` (type: `boolean`):

Collect each product's full record: description, specification list, size and colour variants with per variant price, barcode and stock count, all gallery images, shipping and delivery terms, gift wrapping availability, payment methods, allergen panel and badge marks. Turn off for a faster, cheaper run that returns the listing fields only (id, title, brand, link, price band, sale flags, stock, colour options, image).

## `fetchReviews` (type: `boolean`):

Off by default because it costs one extra request per product. Turn on to also collect each product's average rating, review count, rating breakdown and individual reviews (author, date, rating, title, text, helpful votes). Reviews are sparse on this catalogue, so most products come back with an empty reviews list and a null rating rather than invented zeros.

## `maxReviewsPerProduct` (type: `integer`):

Cap on how many individual reviews are returned for one product. Only used when Fetch customer reviews is on. The rating and review count are always the store's own totals and are not affected by this cap.

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

Maximum number of products to return across the whole run. This is the run's cap and what you are billed for. Use 0 for unlimited.

## `maxPages` (type: `integer`):

Maximum number of result pages to take per keyword, department or pasted listing link. 0 = unlimited, which returns everything the store has for it. Each result page holds 60 products.

## `resumeFromRunId` (type: `string`):

Paste a previous run ID or dataset ID to continue a large catalogue pull without returning or being charged for products already collected there. Use this after an interrupted run. For recurring monitoring of the same search, use Incremental mode below instead.

## `incrementalMode` (type: `boolean`):

Turn this on for daily or recurring monitoring. The first run returns all matching products as NEW. Later runs normally return only NEW, UPDATED and REAPPEARED products. Turn on Emit unchanged or Emit expired only when you also want those products returned, and billed. State is kept separately for each combination of mode, keywords, departments, links, filters and enrichment settings; use State key when you want to name or deliberately share a monitoring campaign.

## `stateKey` (type: `string`):

Optional. Name this monitoring campaign to keep its state stable, or to deliberately share state across differently configured runs. Leave empty to let the actor derive a key automatically, so two different searches never mix state with each other.

## `emitUnchanged` (type: `boolean`):

Off by default. Turn on to also return products that have not changed since the last run, marked UNCHANGED. This returns, and bills, extra rows you already have, so leave it off unless you specifically want the full snapshot every run.

## `emitExpired` (type: `boolean`):

Off by default. Turn on to also return products that were present in a previous run but are no longer found, marked EXPIRED. Only produced once a run has fully scanned the tracked search, not when Max products capped it and not when Resume was used. This returns, and bills, extra synthetic rows, so leave it off unless you need expiry tracking.

## `proxy` (type: `object`):

Apify Proxy with a Japanese exit is required for reliable results and is the default. The default pool is metered per use; select a cheaper pool in the Connection section only if your plan includes one.

## `mcpConnectors` (type: `array`):

Optionally send results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize one under Apify, Settings, API & Integrations, then select it here. Notion gets a rich page per item export; other connectors get a best effort write or digest. Leave empty to skip; this never changes the dataset output. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

## `notionParentPageUrl` (type: `string`):

URL or id of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "queries": [
    "バッグ"
  ],
  "categories": [],
  "urls": [
    "https://www.mistore.jp/shopping/productlist?cgid=28_011500",
    "https://www.mistore.jp/shopping/product/900000000000000003062447.html"
  ],
  "sortBy": "recommended",
  "badges": [],
  "colors": [],
  "brandCodes": [],
  "includeOutOfStock": false,
  "fetchDetails": true,
  "fetchReviews": false,
  "maxReviewsPerProduct": 20,
  "maxItems": 20,
  "maxPages": 0,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyCountry": "JP"
  },
  "maxNotifyListings": 50
}
```

# Actor output Schema

## `overview` (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 = {
    "mode": "search",
    "queries": [
        "バッグ"
    ],
    "categories": [],
    "urls": [
        "https://www.mistore.jp/shopping/productlist?cgid=28_011500",
        "https://www.mistore.jp/shopping/product/900000000000000003062447.html"
    ],
    "incrementalMode": false,
    "emitUnchanged": false,
    "emitExpired": false,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyCountry": "JP"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/mistore-jp-scraper").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "mode": "search",
    "queries": ["バッグ"],
    "categories": [],
    "urls": [
        "https://www.mistore.jp/shopping/productlist?cgid=28_011500",
        "https://www.mistore.jp/shopping/product/900000000000000003062447.html",
    ],
    "incrementalMode": False,
    "emitUnchanged": False,
    "emitExpired": False,
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyCountry": "JP",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/mistore-jp-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "mode": "search",
  "queries": [
    "バッグ"
  ],
  "categories": [],
  "urls": [
    "https://www.mistore.jp/shopping/productlist?cgid=28_011500",
    "https://www.mistore.jp/shopping/product/900000000000000003062447.html"
  ],
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyCountry": "JP"
  }
}' |
apify call abotapi/mistore-jp-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/mistore-jp-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/WW1s9qP7bIoX7KOHg/builds/7uAzTmQQjpnz7OybJ/openapi.json