# ZOZOTOWN - Japan Fashion Products, Variants & Reviews (`abotapi/zozotown-scraper`) Actor

Scrape ZOZOTOWN (zozo.jp), Japan's largest fashion marketplace: name, brand, JPY price with was-price and discount, per-size and per-colour stock, materials, size charts, shipping, images and reviews with star breakdown. Search by keyword, brand, shop or category, or paste product and listing links.

- **URL**: https://apify.com/abotapi/zozotown-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Features:** Limited permissions
- **Stats:** 7 total users, 3 monthly users, 97.8% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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?

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

## ZOZOTOWN Scraper: Japan Fashion Products, Prices, Stock & Reviews

ZOZOTOWN Scraper turns ZOZOTOWN (zozo.jp), Japan's largest fashion marketplace with 1,500+ shops and 8,000+ brands, into structured product data. Search by keyword in Japanese or English, browse a whole brand, shop or category, or paste product and listing links you already have. Every product comes back with JPY pricing (current price, the struck-through was-price and the discount percent), colour variants, per-size and per-colour stock, materials, size charts, shipping and, when you turn it on, customer reviews with the full star breakdown. Run it on Apify and you get scheduling, API access, webhooks, integrations (Zapier, Make, n8n, Google Sheets) and automatic Japanese proxy rotation out of the box.

### Why This Scraper?

- **Two ways in.** Keyword search (Japanese or English), brand, shop or category browsing, or paste links you already have.
- **The site's own filters,** applied by the site itself so they narrow results before they are fetched: sort, department, colour, sale vs full price, new vs pre-owned, pre-order, gift wrap and coupon eligibility, plus a price range applied to the results.
- **Discounts, properly separated.** `price` is what you pay now, `originalPrice` is the struck-through was-price, `discountPercent` is the site's own figure, and `isOnSale` / `isTimeSale` tell you which kind of deal it is.
- **Per-size and per-colour stock,** not just a single in-stock flag: every shelf on the site with its own availability and back-order status.
- **Customer reviews, captured in full.** Star rating, title, review text, date, the exact colour and size the reviewer bought, their size and fit answer, and the reaction count, together with the aggregate rating and the 1-to-5 star breakdown.
- **Incremental mode and Resume,** so a scheduled run returns only what changed instead of re-collecting, and re-billing, the whole catalogue.
- **Export straight into your apps** through MCP connectors (Notion, Linear, Airtable, Apify).

### Use Cases

- **Price and discount monitoring:** track `price`, `originalPrice` and `discountPercent` across a brand or category to catch markdowns as they land.
- **Stock and restock tracking:** watch per-size, per-colour availability and back-order status for items that sell out fast.
- **Fashion marketplace research:** build a dataset of Japanese fashion catalogues, brand assortments and pricing patterns for market research.
- **Review and fit analysis:** collect star ratings, review text and size-fit answers to understand how a product actually wears and fits.
- **Scheduled catalogue monitoring:** scan a brand or category on a recurring schedule with Incremental mode to see only new arrivals, price moves and restocks.

### Data You Get

> Sample shape: values are illustrative placeholders, not from a live record.

| Field | Example |
| --- | --- |
| `productId` | `"12345678"` |
| `name` | `"サンプル コットン Tシャツ / Sample Cotton T-Shirt"` |
| `brand` / `brandNameJp` | `"ACME SPORT"` / `"アクミスポーツ"` |
| `shopName` / `shopSlug` | `"ACME SPORT"` / `"acmesport"` |
| `category` | `"Tシャツ/カットソー"` |
| `store` | `"ZOZOTOWN"` (or `"ZOZOUSED"` for pre-owned items), read from the product's new / pre-owned flag on listing cards and product pages; empty only when a card carries no such flag |
| `price` | `3575` |
| `originalPrice` | `5500` |
| `discountPercent` | `35` |
| `currency` | `"JPY"` |
| `isOnSale` / `isTimeSale` | `true` / `false` |
| `isSoldOut` | `false` |
| `colorName` / `colorCount` | `"ホワイト"` / `2` |
| `colorVariants` | id, name and swatch image for every colour the product comes in |
| `image` / `images` | the card photo, plus one image per colour (when available) |
| `url` | the canonical product link, rebuilt from the shop slug and product id |
| `description` | plain-text product description with the site's own HTML markup stripped (when **Fetch product details** is on) |
| `material` / `madeIn` | `"本体:綿 100%"` / `"中国"` |
| `sizes` | per size and colour shelf: availability word, in-stock flag, back-order flag, stock quantity |
| `sizeChart` | the site's own S/M/L size mapping for each raw size id on the product |
| `shippingFee` | `330` |
| `rating` / `reviewCount` | `4.6` / `128` (when **Fetch product details** is on) |
| `reviews` / `reviewSummary` | per-review rows plus the aggregate rating and the 1-to-5 star breakdown (when **Fetch customer reviews** is on) |
| `changeType` / `changedFields` | `"UPDATED"` / `["price"]` (Incremental mode only) |

A handful of secondary fields ride along too: the raw `goodsId` / `goodsCode` / `goodsDetailId` / `brandId` / `shopId` / `colorId` identifiers; `breadcrumb` (the category path as the site shows it), `targetGenders`, `tags`, `availabilityStatus` and `condition`; `isPreOrder`, `hasVariations`, `variationName` and `rewardPoints`; `productCode`, `categoryPath`/`categoryId` and the matching sub-category fields; `shippingType`, `hasExpeditedShipping` and `shipsOverseas`; and `videos` (an id and filename pair the site publishes without a resolvable direct link). `firstSeenAt` / `lastSeenAt` accompany `changeType` in Incremental mode.

### How to Use

1. Pick **Mode**: `search` to look products up by keyword, brand, shop or category, or `url` to scrape links you already have.
2. In search mode, enter **Keywords** (`ワンピース`, `nike`), or a **Brand**, **Shop** or **Category** on their own; combining Keywords with any of those three switches to a plain keyword search and the brand/shop/category no longer narrows results. In URL mode, paste product or listing links. Selecting URL mode without editing the **Start URLs** field now scrapes one example of each page type (product, search, Shift_JIS-encoded search, brand, shop, category, men's brand and women's category pages), capped by Max items; replace them with your own links. Brand and Shop also accept a multi-word display name such as `New Balance` (spaces are dropped to give the site's slug `newbalance`), not only the slug.
3. Set any **Filters** you want; they apply in both modes.
4. Turn on **Fetch product details** for description, materials and per-size stock, and **Fetch customer reviews** for review rows and the rating breakdown. Set **Max products** to cap the run and your spend, then click **Start**.

**Minimal keyword search:**

```json
{
  "mode": "search",
  "queries": ["ワンピース"],
  "maxItems": 100
}
```

**Full-catalogue brand browse, discounted items only, with details and reviews:**

```json
{
  "mode": "search",
  "brandSlug": "nike",
  "sort": "priceAsc",
  "priceType": "sale",
  "fetchDetails": true,
  "fetchReviews": true,
  "maxReviewsPerProduct": 10,
  "maxItems": 300
}
```

**Paste product links directly:**

```json
{
  "mode": "url",
  "urls": [
    "https://zozo.jp/shop/examplebrand/goods/90000001/",
    "https://zozo.jp/shop/examplebrand/goods/90000002/"
  ],
  "fetchDetails": true
}
```

**Scheduled category monitoring, including products that disappeared:**

```json
{
  "mode": "search",
  "categoryPath": "shoes/sneakers",
  "incrementalMode": true,
  "emitExpired": true,
  "stateKey": "sneaker-watch",
  "maxItems": 0,
  "maxPages": 0
}
```

#### Run it from your code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("abotapi/zozotown-scraper").call(
    run_input={"mode": "search", "queries": ["ワンピース"], "maxItems": 100}
)
for product in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(product["name"], product["price"])
```

JavaScript:

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('abotapi/zozotown-scraper').call({
  mode: 'search', queries: ['ワンピース'], maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

Or connect it to Make, Zapier, n8n, Google Sheets or webhooks from the **Integrations** tab.

#### One cap, not two

Only **Max products** carries a number by default. **Max pages per search** is unlimited and defers to it, so there is never a question of which limit stops your run. Set Max pages only if you specifically want each search to stop after a fixed number of result pages.

#### Resume and Incremental mode

Two different things for two different jobs.

- **Resume from a previous run** continues one specific interrupted crawl: paste that run's id (or its dataset id) and this run skips every product already collected there, returning only the delta.
- **Incremental mode** is for recurring monitoring of the same search or links. The first run marks every product `NEW`. A later run normally returns only `NEW`, `UPDATED` (with `changedFields` naming what moved) and, once a product that had vanished is seen again, `REAPPEARED`. Turn on **Emit unchanged** or **Emit expired** only if you also want those rows returned, and billed.
- **Ignore fields when detecting changes** (`ignoreFieldsForChanges`) lists fields, for example `rewardPoints`, that should not mark a product `UPDATED`. They stay in every returned row; they are only left out of the comparison and of `changedFields`. Editing the list never re-reports products you already have.

`REAPPEARED` and `EXPIRED` are not everyday outcomes. A product is only ever marked `EXPIRED` after a run that genuinely scanned the whole tracked search end to end, with **Emit expired** on, no cap or connection problem cutting it short, and no Resume in play; a capped or interrupted run leaves the previous state untouched and says so in the log instead. When the expiry pass itself is cut by **Max products**, the products that were returned are marked and the log states how many more also disappeared but were held back; they are reported on a later run. `REAPPEARED` can then only happen to a product that a prior run already tombstoned that way, once a later run finds it again. State is kept separately per distinct search and filter setup, or by **State key**, so two different searches never mix.

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

Optionally pipe results into the apps you already use, via Model Context Protocol (MCP) connectors. This is an extra delivery step after the scrape; the Apify dataset is never changed, and leaving the field empty skips it entirely.

Each connector receives a condensed, human-readable summary per product (its title plus the key fields as plain text); the complete record always stays in the Apify dataset.

1. Authorize a connector once under **Apify -> Settings -> Integrations** (Notion, Linear, Airtable, or Apify).
2. Select it in the **Pipe results into your apps** input field. (If the picker is empty, you have not authorized a connector yet.)
3. For **Notion**, also set **Notion parent page** to the page the item pages should be created under. It is ignored by every other connector.
4. Use **Max items to export per connector** to cap how many products are written to each connector per run. It does not affect the dataset.

The connection is mediated by Apify's MCP proxy, so this actor never sees your third-party credentials.

### Input Parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | string | `search` | `search` (keyword, brand, shop or category) or `url` (paste links). |
| `queries` | array | `[]` (prefill: `["ワンピース"]`) | Keywords to search, Japanese or English. Each is searched separately. |
| `brandSlug` | string | no default (empty) | Browse one brand's whole catalogue, using the site's own brand slug (`nike`); a multi-word display name such as `New Balance` also works. |
| `shopSlug` | string | no default (empty) | Browse one shop's whole catalogue, using the site's own shop slug; a multi-word display name such as `New Balance` also works. |
| `categoryPath` | string | no default (empty) | Browse one category, using the site's own category path (`shoes/sneakers`). |
| `urls` | array | one example link per page type | Product links, or brand, shop, category and search result links (URL mode). |
| `sort` | string | `popular` | `popular`, `newest`, `priceAsc` or `priceDesc`. |
| `gender` | string | `any` | `any`, `men`, `women` or `kids`. Applies to brand and category browsing; keyword search covers all departments. |
| `color` | string | `any` | One of the site's 14 colour families, or `any`. |
| `priceType` | string | `any` | `any`, `sale` (discounted only) or `proper` (full price only). |
| `condition` | string | `any` | `any`, `new` or `used` (the site's pre-owned range). |
| `sellType` | string | `any` | `any`, `normal` or `preorder`. |
| `includeOutOfStock` | boolean | `false` | Off by default, matching the site. Turn on to also return sold-out products. |
| `giftWrappingOnly` | boolean | `false` | Keep only products the shop can gift-wrap. |
| `couponOnly` | boolean | `false` | Keep only products a shop coupon applies to. |
| `minPrice` | integer | no default (empty) | Keep only products at or above this JPY price. Applied to results after they are fetched. |
| `maxPrice` | integer | no default (empty) | Keep only products at or below this JPY price. Applied to results after they are fetched. |
| `fetchDetails` | boolean | `false` | Read each product's own page for description, materials, size chart, per-size stock and shipping. Adds one request, and one charged event, per product. |
| `fetchReviews` | boolean | `false` | Also collect reviews and the rating breakdown. Turning this on switches Fetch product details on too, since the review endpoint is only reachable from the product page. |
| `maxReviewsPerProduct` | integer | `20` | Cap on reviews collected per product. `0` for every available review. |
| `maxItems` | integer | `20` | The run's cap, across every keyword and link. `0` for no limit. |
| `maxPages` | integer | no default (empty = unlimited) | Leave empty for unlimited; the run stops at Max products, not here. Set a number only to stop each search after that many result pages. |
| `resumeFromRunId` | string | no default (empty) | Id of a previous run (or dataset) of this actor. Products already there are skipped, so this run returns only the delta. |
| `incrementalMode` | boolean | `false` | Turn on for recurring monitoring of the same search or links. |
| `stateKey` | string | no default (empty) | Name this monitoring campaign to keep its state stable, or to share state across differently configured runs. |
| `emitUnchanged` | boolean | `false` | Also return, and bill, products unchanged since the last run. |
| `emitExpired` | boolean | `false` | Also return, and bill, products from a previous run that are no longer found. |
| `ignoreFieldsForChanges` | array | `[]` | Incremental mode only. Field names (dotted paths for nested fields, for example `sizes.stock`) that never count as a change. They stay in the output but do not mark a product `UPDATED` or appear in `changedFields`. |
| `proxy` | object | `{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "JP"}` | The site serves visitors in Japan only, so a Japanese residential connection is required. Keep the default. |
| `mcpConnectors` | array | no default (empty) | Which authorized MCP connectors to send results to. Empty means skip. |
| `notionParentPageUrl` | string | no default (empty) | Notion connector only. URL or id of the page under which item pages are created. |
| `maxNotifyListings` | integer | `50` | Cap on products written to each connector per run. Does not affect the dataset. |

### Output Example

> Sample shape: values are illustrative placeholders, not from a live record.

```json
{
  "productId": "12345678",
  "goodsId": 12345678,
  "goodsCode": "12345678",
  "name": "サンプル コットン Tシャツ / Sample Cotton T-Shirt IH0000-100 White",
  "url": "https://zozo.jp/shop/acmesport/goods/12345678/",
  "brand": "ACME SPORT",
  "brandNameJp": "アクミスポーツ",
  "brandSlug": "acmesport",
  "shopName": "ACME SPORT",
  "shopSlug": "acmesport",
  "category": "Tシャツ/カットソー",
  "categoryPath": "tops",
  "subCategoryName": "Tシャツ/カットソー",
  "breadcrumb": [
    { "label": "ZOZOTOWN", "url": "https://zozo.jp/" },
    { "label": "ACME SPORT", "url": "https://zozo.jp/shop/acmesport/" },
    { "label": "トップス", "url": "https://zozo.jp/shop/acmesport/tops/" }
  ],
  "price": 3575,
  "originalPrice": 5500,
  "discountPercent": 35,
  "currency": "JPY",
  "isOnSale": true,
  "isTimeSale": false,
  "saleType": "SALE",
  "saleEndsAt": null,
  "isSoldOut": false,
  "availabilityStatus": "IN_STOCK_NORMAL",
  "colorName": "ホワイト",
  "colorCount": 2,
  "colorVariants": [
    { "colorId": 1, "colorName": "ホワイト", "imageUrl": "https://c.imgz.jp/sample/12345678/white_35.jpg" },
    { "colorId": 2, "colorName": "ブラック", "imageUrl": "https://c.imgz.jp/sample/12345678/black_35.jpg" }
  ],
  "image": "https://c.imgz.jp/sample/12345678/main_500.jpg",
  "images": ["https://c.imgz.jp/sample/12345678/main_500.jpg", "https://c.imgz.jp/sample/12345678/white_500.jpg"],
  "videos": [],
  "productCode": "IH0000-100",
  "description": "柔らかいコットン素材を使用したゆったりとしたTシャツです。",
  "material": "本体:綿 100%",
  "madeIn": "中国",
  "targetGenders": ["women"],
  "tags": ["半袖", "クルーネック(丸首)"],
  "condition": "brand_new",
  "isPreOrder": false,
  "sizes": [
    { "size": "S", "color": "ホワイト", "availability": "INSTOCK", "inStock": true, "stockQuantity": null, "isBackOrder": false },
    { "size": "XS", "color": "ホワイト", "availability": "OUT_OF_STOCK", "inStock": false, "stockQuantity": 0, "isBackOrder": false }
  ],
  "sizeChart": [{ "sizeId": 2126, "women": ["S"] }],
  "shippingFee": 330,
  "shippingType": "ZOZOTOWN",
  "rewardPoints": 162,
  "rating": 4.6,
  "reviewCount": 128,
  "reviewSummary": {
    "averageRating": 4.6,
    "totalReviews": 128,
    "ratingBreakdown": {
      "1": { "count": 2, "percent": 2 },
      "2": { "count": 2, "percent": 2 },
      "3": { "count": 4, "percent": 3 },
      "4": { "count": 30, "percent": 23 },
      "5": { "count": 90, "percent": 70 }
    }
  },
  "reviews": [
    {
      "reviewId": 1000001,
      "rating": 5,
      "title": "サイズ感がちょうど良い",
      "body": "生地がしっかりしていて、洗濯後も型崩れしません。",
      "postedAt": "2026-05-10T09:30:00+09:00",
      "purchasedVariant": "ホワイト / M",
      "sizeFitQuestion": "サイズ感",
      "sizeFitAnswer": "ちょうどいい",
      "reviewerProfile": "性別（女性） | 30〜34歳 | 普段履いているサイズ（M）",
      "helpfulCount": 3
    }
  ]
}
```

`brandSlug`, `categoryPath`, `subCategoryName`, `breadcrumb`, `saleType`, `saleEndsAt`, `availabilityStatus`, `images`, `videos`, `productCode`, `description`, `material`, `madeIn`, `targetGenders`, `tags`, `condition`, `isPreOrder`, `sizes`, `sizeChart`, `shippingFee`, `shippingType` and `rewardPoints` all come from the product detail page, so they appear when **Fetch product details** is on, or on a pasted product link, which reads that same page to have anything to return at all. `rating` and `reviewCount` also come from that same page's own review summary, so they appear together with the fields above whenever the detail page was read, independent of the reviews toggle. `reviews` and `reviewSummary` appear only when **Fetch customer reviews** is on. A product with no reviews yet returns `reviews: []` with `reviewCount` left at the site's own value rather than an invented zero.

Reviews on ZOZOTOWN are published anonymously: there is no author name, handle or avatar anywhere in the site's own review data, so this scraper does not emit an `author` field rather than filling one with a placeholder. The only person-level content the site publishes is the coarse self-reported line the reviewer chose to show (age band, gender, usual size), passed through verbatim as `reviewerProfile`.

Listing-only results (search, brand, shop and category browsing with **Fetch product details** off) carry only `productId`, `goodsId`, `goodsCode`, `name`, `url`, `brand`, `brandNameJp`, `shopName`, `shopSlug`, `category`, `price`, `originalPrice`, `discountPercent`, `currency`, `isOnSale`, `isTimeSale`, `isSoldOut`, `colorName`, `colorCount`, `colorVariants` and `image`; every detail-page field above (including `images`, plural) is simply absent from those rows, not null.

### Plan Requirement

ZOZOTOWN serves visitors in Japan only and turns other connections away, so the default Japanese residential proxy is required; keep it unless you have your own Japan-based pool. Keyword searches, pasted search and product links, and per-product details are read from ZOZOTOWN's own product catalogue data, which stays reachable even when the store's web pages are busy turning visitors away. Brand, shop and category browsing and review text come from the store's web pages; the actor retries those with a different connection for every page, and if the pages cannot be opened at all in a run, products are still returned and only those parts are skipped (and not charged). If no connection can be established at all, the run fails with a clear message rather than finishing with an empty dataset, so you can always tell a connection problem apart from a search that genuinely had no matches. Caps: Max products accepts up to 100,000 and Max reviews per product up to 10,000 per run, so a single run cannot grow without bound.

ZOZOTOWN is a Japan-domestic marketplace operated by ZOZO, Inc. This scraper covers zozo.jp, including its ZOZOUSED, ZOZOVILLA, ZOZOCOSME and ZOZOSHOES sections, which are sub-paths of zozo.jp sharing its product catalogue. The separate zozo.com domain belongs to the same company but is not a storefront and carries no product catalogue to scrape.

You pay for products successfully returned, plus only the extras you switch on: detail enrichment (once per product, when **Fetch product details** is on) and review enrichment (once per product with reviews, when **Fetch customer reviews** is on), each charged as the product is delivered to the dataset, so nothing is held back to the end of a run. The **Pricing** tab on this page shows current rates for every event. Use **Max products** to cap the cost of any run, or set a maximum charge per run in the Apify Console.

### FAQ

#### How much does it cost?

You pay for products successfully returned, plus the detail and review extras only when you switch them on. The **Pricing** tab shows the current rates for each event. Use **Max products** to cap the cost of any run.

#### Is it legal to scrape ZOZOTOWN?

This scraper collects publicly available product information only, and does not target personal data. Reviews on ZOZOTOWN are published anonymously and no author identity is available to extract. Make sure your use of the data complies with ZOZOTOWN's Terms of Service and the laws that apply to you; this actor and its output are intended for lawful purposes such as market research and price monitoring.

#### Can I get only new or changed products on a schedule?

Yes. Schedule the actor from the **Schedules** tab and turn on **Incremental changes for scheduled runs**. Unchanged products are then suppressed rather than re-billed, and `changeType` marks what did change.

#### Why does a pasted product link return full detail fields even when Fetch product details is off?

Reading a specific product page is exactly how a pasted link is resolved into a record in the first place, so that page is always read and its fields (description, materials, sizes and the rest) always land in the output. The **Fetch product details** toggle still controls whether that per-product charge applies. In search, brand, shop and category browsing, the same toggle controls both the fetch and the charge together.

#### Why did my run fail instead of returning an empty dataset?

If the site refuses every connection, or a pasted link could not be read at all, the run stops with a clear message so "nothing matched" is never confused with "nothing could be read". Try again in a few minutes. If every connection attempt is refused at the proxy itself (an account without proxy access, such as a free plan), the run stops with a message saying a paid Apify plan is required. If only some pages or links could not be read while others succeeded, you still get what was found.

#### Can I use it with AI agents or MCP?

Yes. Call it from any Apify integration or MCP client, and use the connector field to push results into Notion, Linear or Airtable.

### 🔗 Want more fashion data?

Pair this actor with these related scrapers from the same team:

<table>
<tr><td>👗 <a href="https://apify.com/abotapi/mango-com-scraper"><b>Mango Scraper</b></a><br>Scrape Mango (shop.mango.com) fashion products: current price plus strike-through Rebajas...</td><td>👗 <a href="https://apify.com/abotapi/snkrdunk-com-scraper"><b>SNKRDUNK Scraper</b></a><br>Scrape SNKRDUNK (snkrdunk.com), Japan's sneaker and streetwear resale marketplace: JP and...</td></tr>
<tr><td>🥦 <a href="https://apify.com/abotapi/elcorteingles-es-scraper"><b>El Corte Inglés Scraper</b></a><br>Scrape El Corte Inglés elcorteingles.es products across fashion, electronics, home...</td><td>👗 <a href="https://apify.com/abotapi/next-uk-product-scraper"><b>Next.co.uk Scraper</b></a><br>Scrape Next.co.uk: keyword search, category and product-listing walks, full product...</td></tr>
<tr><td>👗 <a href="https://apify.com/abotapi/fashionnova-com-scraper"><b>Fashion Nova Scraper</b></a><br>Scrape Fashion Nova products by keyword, collection or URL. Extract product names...</td><td>👗 <a href="https://apify.com/abotapi/yesstyle-com-scraper"><b>YesStyle Scraper</b></a><br>Scrape YesStyle products by keyword or URL. Extract prices, discounts, ratings, stock...</td></tr>
</table>

👉 [Browse all abotapi scrapers](https://apify.com/abotapi)

### 💬 Support

- 🐞 **Found a bug or a missing field?** Open a ticket on the [Issues tab](https://apify.com/abotapi/zozotown-scraper/issues/open). We usually reply within hours.
- 🛠️ **Need another site, extra fields or a private build?** Email <contact@abotapi.com>.
- ⭐ **Enjoying it?** A quick review on the actor page helps other users find it.

# Actor input Schema

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

Choose Search to look products up on the site, or URL to scrape links you paste yourself.

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

Keywords to search, in Japanese or English, for example ワンピース or nike. Each keyword is searched on its own.

## `brandSlug` (type: `string`):

Browse one brand's whole catalogue, using the brand name as it appears in the site's own brand links, for example nike or adidas; a multi-word display name such as New Balance also works. Leave empty to skip.

## `shopSlug` (type: `string`):

Browse one shop's whole catalogue, using the shop name as it appears in the site's own shop links, for example nike; a multi-word display name such as New Balance also works. Leave empty to skip.

## `categoryPath` (type: `string`):

Browse one category, using the site's own category path, for example shoes/sneakers or tops/tshirt-cutsew. Leave empty to skip.

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

Links to scrape (leave the example links untouched to scrape one of each page type): product pages (zozo.jp/shop/<shop>/goods/<id>/), or brand, shop, category and search result pages.

## `sort` (type: `string`):

Order results the way the site orders them.

## `gender` (type: `string`):

Limit to one department. Applies to brand and category browsing; keyword search covers all departments.

## `color` (type: `string`):

Keep only products available in one colour family.

## `priceType` (type: `string`):

Keep only discounted products, or only full-price products.

## `condition` (type: `string`):

New products, or the site's pre-owned range.

## `sellType` (type: `string`):

Regular products, or products sold as pre-orders.

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

Off by default, matching the site, which shows in-stock products only. Turn on to also return sold-out products.

## `giftWrappingOnly` (type: `boolean`):

Keep only products the shop can gift-wrap.

## `couponOnly` (type: `boolean`):

Keep only products a shop coupon applies to.

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

Keep only products at or above this price. The site offers no price filter of its own, so this is applied to results after they are fetched.

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

Keep only products at or below this price. The site offers no price filter of its own, so this is applied to results after they are fetched.

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

Read each product's own page for description, materials, country of origin, product code, size chart, per-size and per-colour stock, shipping fee and full category path. Adds one request per product and charges the Detail enrichment event once per product returned.

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

Also collect customer reviews for each product: star rating, title, review text, date, the exact colour and size the reviewer bought, their size and fit answer, and how many people reacted to the review, plus the average rating and the star breakdown. Requires Fetch product details. Charges the Review enrichment event once per product returned with reviews.

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

Cap on reviews collected per product when Fetch customer reviews is on. Use 0 for every available review.

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

Maximum number of products saved across all keywords and links. This is the run's cap. Set 0 for no limit.

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

Leave empty for unlimited: this does not cap the run, the run stops at Max products. Set a number only to stop each search after that many result pages.

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

The site serves visitors in Japan only and turns other connections away, so a Japanese residential connection is required. Keep the default unless you have your own Japan based pool.

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

Optional. ID of a previous run of this actor, or a dataset ID. Products already in that dataset are skipped, so this run returns only NEW products. Combine both runs' datasets for the full set. For recurring monitoring of the same search, use Incremental mode below instead.

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

Turn this on for daily or recurring monitoring of the same search or links. 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 per distinct search and filter setup, or by State key below.

## `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 from your mode, search and filter settings, so 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 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 or Max pages capped it, a connection problem stopped it early, or Resume was used. This returns, and bills, extra synthetic rows.

## `ignoreFieldsForChanges` (type: `array`):

Optional. Field names that must NOT count as a change in incremental mode, for example rewardPoints or rating. Use a dotted path such as sizes.stock for a nested field. Ignored fields are still returned in every row; they only stop a product being marked UPDATED and are left out of changedFields. Changing this list never re-reports your existing products.

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

Optionally send the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize a connector once under Apify -> Settings -> Integrations, then select it here. The connector receives a condensed, human-readable summary per item (title + key fields), not the full JSON; the complete record stays in the dataset. Leave empty to skip. 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": [
    "ワンピース"
  ],
  "urls": [
    {
      "url": "https://zozo.jp/shop/nike/goods/104503785/"
    },
    {
      "url": "https://zozo.jp/search/?p_keyv=nike"
    },
    {
      "url": "https://zozo.jp/brand/nike/"
    },
    {
      "url": "https://zozo.jp/shop/nike/"
    },
    {
      "url": "https://zozo.jp/category/shoes/sneakers/"
    },
    {
      "url": "https://zozo.jp/men-brand/nike/"
    },
    {
      "url": "https://zozo.jp/women-category/shoes/sneakers/"
    },
    {
      "url": "https://zozo.jp/search/?p_keyv=%83%8F%83%93%83s%81%5B%83X"
    }
  ],
  "sort": "popular",
  "gender": "any",
  "color": "any",
  "priceType": "any",
  "condition": "any",
  "sellType": "any",
  "includeOutOfStock": false,
  "giftWrappingOnly": false,
  "couponOnly": false,
  "fetchDetails": false,
  "fetchReviews": false,
  "maxReviewsPerProduct": 20,
  "maxItems": 20,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "JP"
  },
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "ignoreFieldsForChanges": [],
  "maxNotifyListings": 50
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `detail` (type: `string`):

No description

## `reviews` (type: `string`):

No description

## `changes` (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 = {
    "queries": [
        "ワンピース"
    ],
    "urls": [
        {
            "url": "https://zozo.jp/shop/nike/goods/104503785/"
        },
        {
            "url": "https://zozo.jp/search/?p_keyv=nike"
        },
        {
            "url": "https://zozo.jp/brand/nike/"
        },
        {
            "url": "https://zozo.jp/shop/nike/"
        },
        {
            "url": "https://zozo.jp/category/shoes/sneakers/"
        },
        {
            "url": "https://zozo.jp/men-brand/nike/"
        },
        {
            "url": "https://zozo.jp/women-category/shoes/sneakers/"
        },
        {
            "url": "https://zozo.jp/search/?p_keyv=%83%8F%83%93%83s%81%5B%83X"
        }
    ],
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "JP"
    },
    "ignoreFieldsForChanges": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/zozotown-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 = {
    "queries": ["ワンピース"],
    "urls": [
        { "url": "https://zozo.jp/shop/nike/goods/104503785/" },
        { "url": "https://zozo.jp/search/?p_keyv=nike" },
        { "url": "https://zozo.jp/brand/nike/" },
        { "url": "https://zozo.jp/shop/nike/" },
        { "url": "https://zozo.jp/category/shoes/sneakers/" },
        { "url": "https://zozo.jp/men-brand/nike/" },
        { "url": "https://zozo.jp/women-category/shoes/sneakers/" },
        { "url": "https://zozo.jp/search/?p_keyv=%83%8F%83%93%83s%81%5B%83X" },
    ],
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "JP",
    },
    "ignoreFieldsForChanges": [],
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/zozotown-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 '{
  "queries": [
    "ワンピース"
  ],
  "urls": [
    {
      "url": "https://zozo.jp/shop/nike/goods/104503785/"
    },
    {
      "url": "https://zozo.jp/search/?p_keyv=nike"
    },
    {
      "url": "https://zozo.jp/brand/nike/"
    },
    {
      "url": "https://zozo.jp/shop/nike/"
    },
    {
      "url": "https://zozo.jp/category/shoes/sneakers/"
    },
    {
      "url": "https://zozo.jp/men-brand/nike/"
    },
    {
      "url": "https://zozo.jp/women-category/shoes/sneakers/"
    },
    {
      "url": "https://zozo.jp/search/?p_keyv=%83%8F%83%93%83s%81%5B%83X"
    }
  ],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "JP"
  },
  "ignoreFieldsForChanges": []
}' |
apify call abotapi/zozotown-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/zozotown-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/8tuGg0THgeTNXA46z/builds/aHRmR2pOn4yhve8BU/openapi.json