# Japanwelt Product Scraper - Prices, Stock, SKUs (`sian.agency/japanwelt-product-scraper`) Actor

Export the Japanwelt catalogue: prices, per-unit prices, availability, delivery times, SKUs, brands, ratings and category paths for Japanese food, tea, tableware, futons and games.

- **URL**: https://apify.com/sian.agency/japanwelt-product-scraper.md
- **Developed by:** [SIÁN OÜ](https://apify.com/sian.agency) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 catalogues

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

## 🎌 Japanwelt Product Scraper — Prices, Stock & SKUs

[![Actor](https://img.shields.io/badge/Apify-Actor-00b4d8)](https://apify.com/sian.agency/japanwelt-product-scraper)
[![Shop](https://img.shields.io/badge/shop-japanwelt.de-1B3A5C)](https://www.japanwelt.de)
[![Market](https://img.shields.io/badge/market-Germany-D9463E)](https://apify.com/sian.agency/japanwelt-product-scraper)
[![Pricing](https://img.shields.io/badge/pricing-pay%20per%20result-7BA05B)](https://apify.com/sian.agency/japanwelt-product-scraper)

#### 🎉 Germany's largest Japan-focused shop, exported — 4,781 products across 21 departments

##### Built for price monitoring, resellers and anyone tracking Japanese goods in the German market

***

### 🔎 What is the Japanwelt Product Scraper — and when should you use it?

The **Japanwelt Product Scraper** turns the German shop japanwelt.de and its roughly 4,781 product pages into clean, structured rows you can filter, export and feed straight into a spreadsheet, database or AI agent. No account, no portal API key, no browser automation to maintain.

**Use it when you need:** Japanwelt product rows carrying the German product name, the current EUR price, the shop's own published price per unit where there is one, the pack content, a three-state stock light and a direct link to the product page. Detail mode goes further on named products: the shop's article number, the brand, the manufacturer part number, the shop's own category path, the delivery window, the specification table, the full description and every gallery image.

**Use something else when:** you need a different shop. Use [Kleinanzeigen Scraper](https://apify.com/sian.agency/kleinanzeigen-scraper?fpr=sian) for German classifieds, where the same futons, tatami and Go sets turn up second-hand. Use [BAUHAUS Product Scraper](https://apify.com/sian.agency/bauhaus-product-scraper?fpr=sian) for German DIY, garden and interiors, where this one covers the Japanese end of the same room. Use [Douglas Product Scraper](https://apify.com/sian.agency/douglas-product-scraper?fpr=sian) for German beauty and fragrance retail. This actor reads one shop, so it says what Japanwelt charges rather than what anyone else charges for the same matcha. Each run is a snapshot: price history exists only if you schedule the run and keep the datasets. The shop publishes no EAN barcodes, so joins against other catalogues go through brand plus manufacturer part number.

### 🤖 Use with AI agents

Already connected to the [Apify MCP server](https://mcp.apify.com)? Just ask for this Actor by name: sian.agency/japanwelt-product-scraper

**Your agent can pay for its own runs.** This Actor is eligible for [agentic payments](https://docs.apify.com/platform/actors/publishing/monetize), so an agent can discover it, run it and settle the bill over [x402](https://www.x402.org/) (USDC on Base) or [Skyfire](https://www.skyfire.xyz/) — without an Apify account or API token of its own. Billing is the same either way: per successful row, never for errors.

Otherwise copy this prompt into Claude, ChatGPT, Cursor or any MCP-enabled assistant:

```text
I want prices, per-unit prices, stock and article numbers from the Japanwelt shop using the Apify Actor `sian.agency/japanwelt-product-scraper`.

Use it when I need: Japanwelt product rows carrying the German product name, the current EUR price, the shop's own published price per unit where there is one, the pack content, a three-state stock light and a direct link to the product page. Detail mode goes further on named products: the shop's article number, the brand, the manufacturer part number, the shop's own category path, the delivery window, the specification table, the full description and every gallery image.

Don't use it when: you need a different shop — use kleinanzeigen-scraper or bauhaus-product-scraper or douglas-product-scraper instead.

How to call it: leave `operation` on `catalog` and put German words in `searchTerms` (tee returns 276 products, matcha 109, kintsugi 11, shogi 5), or paste shop category links into `categoryUrls` to take whole shelves — a department link takes everything under it. Clear both to walk all 21 departments. `sortBy` decides which end of the shelf a capped run returns: priceAsc, priceDesc, newest, popularity or name. Switch `operation` to `productDetail` and pass `productUrls` for one deep row per product. `maxItems` is the hard ceiling on rows and therefore on what a run charges.

Start with this input:
{
  "operation": "catalog",
  "searchTerms": [
    "matcha"
  ],
  "sortBy": "priceAsc",
  "maxItems": 100
}

Ask me whether they want a broad shelf sweep or a deep read of named products, and which German word or shop category to narrow to, then run the Actor and summarise the results as a table.
```

**Things you can ask your agent for:**

- *Export every matcha and green tea at Japanwelt with its price per 100 g, cheapest first.*
- *Watch the futon and tatami departments daily and tell me when anything drops below 300 euro or comes back in stock.*
- *Give me the article number, brand and part number for these ten product links so I can match them against my wholesaler list.*

Machine-readable API, MCP config and OpenAPI definition for this Actor are published at [apify.com/sian.agency/japanwelt-product-scraper.md](https://apify.com/sian.agency/japanwelt-product-scraper.md).

### 📋 Overview

| | |
|---|---|
| **Shop** | japanwelt.de (Germany) |
| **Catalogue** | ~4,781 product pages, 549 shop categories, 21 top-level departments |
| **Language** | German product text, prices in EUR including VAT |
| **Modes** | Catalogue (search or shelves) · Product detail |
| **Fanout** | up to 100 products per request in catalogue mode |
| **Proxy** | none needed, and none billed to you |
| **Charging** | a small run-start fee, then one event per product row |

Two operations, picked with a single `operation` field:

- **🛒 Catalogue** — search the shop for your terms, or walk the shop categories you name, and get
  one row per product: price, per-unit price, pack content, image, stock light and listing
  position. This is the broad, cheap mode.
- **🔬 Product detail** — hand it product page links and get one deeper row each: article number,
  brand, manufacturer part number, the shop's own category path, delivery window, the
  specification table, the full description and every gallery image.

### ✨ Features

- **One request, a whole shelf.** The listing page accepts a large page size and returned 276
  products for a single search during the build, so a category export is a handful of requests.
- **Per-unit prices the shop publishes.** Tea and food rows carry the shop's own euro-per-100-g or
  euro-per-litre figure next to the pack content, which is the only honest way to compare a 25 g
  tin of gyokuro against a 200 g bag of konacha.
- **A stock light with three states, not a boolean.** Green ships now, amber ships in roughly four
  to six weeks, red is sold out. A plain in-stock flag hides the middle one.
- **Article numbers, brands and part numbers** in detail mode, which is what you join on when you
  match this catalogue against a wholesaler list or a marketplace listing.
- **Sort the shelf before the cap bites.** Cheapest first, most expensive first, newest, most
  popular or A–Z, so a capped run returns the end of the shelf you actually wanted.
- **German decimals handled properly.** `3.599,00 €` is three thousand five hundred and
  ninety-nine euros, and the row says `3599`, not `3.6`.
- **No proxy, no key, no surprise bill.** The shop answers plain requests; nothing else is charged
  to your account.

### 🎬 Quick start

Press **Start** with the default input and you get 25 matcha products with prices. That is the
whole setup.

```json
{
  "operation": "catalog",
  "searchTerms": ["matcha"],
  "maxItems": 25
}
```

### 🚀 Getting started (3 simple steps)

#### Step 1: Pick a mode

Leave `operation` on `catalog` for breadth. Switch it to `productDetail` when you already know
which products you care about and want the article number, brand and specifications.

#### Step 2: Say what to cover

In catalogue mode, put German words in `searchTerms`, shop category links in `categoryUrls`, or
clear both to walk all 21 departments. In detail mode, put product page links in `productUrls`.
Catalogue rows carry the exact link in `productUrl`, so one feeds the other.

#### Step 3: Set your ceiling

`maxItems` is the hard limit on rows, and therefore on what the run can charge. 25 is a look
around; 5000 with empty search terms and empty category links is a full catalogue export.

### 📥 Input configuration

| Field | Type | Default | What it does |
|---|---|---|---|
| `operation` | select | `catalog` | `catalog` for many products at once, `productDetail` for one deep row per link |
| `searchTerms` | list of text | `["matcha"]` | German search words, one per line. Each is searched separately |
| `categoryUrls` | list of links | empty | Shop category links. A department link takes everything under it |
| `sortBy` | select | `relevance` | Shop default, newest, most popular, cheapest first, most expensive first, or name A–Z |
| `productUrls` | list of links | empty | Product page links, required in detail mode |
| `maxItems` | number | `25` | Hard ceiling on rows returned and charged |

German words find the most, because the shop is German. Measured during the build: `tee` returns
276 products, `matcha` 109, `kintsugi` 11, `wagashi` 9, `shogi` 5. `futon`, `tatami`, `sake`,
`shoji`, `bento` and `kimono` all have shelves of their own.

Nothing in the input asks you how to fetch anything. No proxy picker, no concurrency, no retry
count. Those are ours to get right.

### 📤 Output

One flat row per product. Fields that a mode does not publish are simply absent rather than
invented.

| Field | Type | Notes |
|---|---|---|
| `productId` | number | The shop's own numeric article id |
| `sku` | text | Article number such as `JW11081` (detail mode) |
| `productName` | text | German product name as published |
| `productUrl` | link | Direct link to the product page |
| `imageUrl` | image | Full-size product picture |
| `price` | number | Current price in EUR, VAT included |
| `priceIsFrom` | boolean | True when the shop shows a starting price for several sizes |
| `currency` | text | `EUR` |
| `referencePrice` | number | The shop's published price per unit |
| `referenceUnit` | text | What that per-unit price is per, e.g. `100 Gramm` |
| `packContent` | text | Pack content, e.g. `40 Gramm` or `1 Stück` |
| `availability` | text | `InStock` or `OutOfStock` |
| `inStock` | boolean | Convenience flag |
| `stockIndicator` | text | `green`, `amber` or `red` — the shop's own light |
| `deliveryTime` | text | Delivery window, e.g. `ca. 9-13 Tage` (detail mode) |
| `brand` | text | Brand or manufacturer (detail mode) |
| `partNumber` | text | Manufacturer part number (detail mode) |
| `categoryPath` | text | The shop's own path, e.g. `Teezeremonie > Matcha & Grüner Tee` |
| `rating` | number | Rating on the shop's 1-to-10 scale, empty when nobody has rated it |
| `reviewCount` | number | How many reviews that rating is built on |
| `shortDescription` | text | The shop's own summary |
| `descriptionText` | text | Full product description (detail mode) |
| `specifications` | array | Name/value pairs from the product's own spec table (detail mode) |
| `imageUrls` | array | Every gallery image of this product (detail mode) |
| `listingPosition` | number | Where the product sat in the listing you asked for |
| `searchTerm` | text | Which of your search terms produced this row |
| `categoryUrl` | link | Which shelf produced this row |
| `operation` | text | `catalog` or `productDetail` |
| `scrapedAt` | date | When the row was read |

A run also writes an HTML **📄 Processing Report** to the key-value store: what came back, what
did not and why, what it cost, and links to download the dataset as JSON or CSV.

### 💼 Use cases & examples

#### 1. Japanese food and tea price monitoring

Track what Germany's largest Japan-focused retailer charges for matcha, sencha, gyokuro, hojicha,
sake, soy sauce and miso, at the pack size that matters. The published per-100-g price lets you
compare a 25 g tin against a 200 g bag without doing the arithmetic.

```json
{ "operation": "catalog", "searchTerms": ["matcha", "sencha", "gyokuro"], "sortBy": "priceAsc", "maxItems": 300 }
```

#### 2. Furniture and interiors catalogue research

Futon beds, tatami mats in custom sizes, shoji screens, paravents and Japanese lamps run from the
low hundreds into the low thousands of euros. One department link returns them all with
availability and delivery windows attached.

```json
{ "operation": "catalog", "categoryUrls": ["https://www.japanwelt.de/futon-betten/", "https://www.japanwelt.de/tatami/"], "maxItems": 500 }
```

#### 3. Reseller and marketplace arbitrage

Detail rows carry the article number, the brand and the manufacturer part number, which is enough
to match a product against a wholesaler list or a marketplace listing and find where the same
article sells for more.

```json
{ "operation": "productDetail", "productUrls": ["https://www.japanwelt.de/anziehen/schluesselanhaenger/anhaenger-kinchaku.html"] }
```

#### 4. Availability and assortment monitoring

The stock light and the delivery window show what is genuinely available rather than merely
listed. Run a shelf on a schedule and watch it change week to week.

```json
{ "operation": "catalog", "categoryUrls": ["https://www.japanwelt.de/teezeremonie/"], "sortBy": "newest", "maxItems": 400 }
```

#### 5. Niche market sizing

Go and Shogi sets, calligraphy supplies, kimono and yukata, bonsai tools — shelves too small for a
general retail scraper to bother with, priced and counted in one export.

```json
{ "operation": "catalog", "searchTerms": ["go-brett", "shogi", "kalligraphie", "bonsai"], "maxItems": 200 }
```

#### 6. Cross-shop price comparison

Pair this with the sibling German Asian-goods scrapers to see who charges what for the same rice,
sauce or tea across three shops.

#### 7. AI agents and shopping assistants

Point an agent at this actor over MCP and it can answer "what does Japanwelt want for a 2 m tatami
mat, and is it in stock" with real numbers rather than a guess.

### 🔗 Integration examples

#### JavaScript/Node.js

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('sian.agency/japanwelt-product-scraper').call({
    operation: 'catalog',
    searchTerms: ['matcha'],
    sortBy: 'priceAsc',
    maxItems: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const p of items) {
    console.log(`${p.productName} — ${p.price} ${p.currency} (${p.referencePrice ?? '—'} / ${p.referenceUnit ?? '—'})`);
}
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("sian.agency/japanwelt-product-scraper").call(run_input={
    "operation": "catalog",
    "categoryUrls": ["https://www.japanwelt.de/futon-betten/"],
    "maxItems": 200,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["productName"], item.get("price"), item.get("stockIndicator"))
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/sian.agency~japanwelt-product-scraper/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "operation": "catalog",
    "searchTerms": ["tatami"],
    "maxItems": 50
  }'
```

#### Automation workflows (N8N / Zapier / Make)

Every one of these can run the actor on a schedule and act on the rows:

- **N8N** — an Apify node runs the actor, and a Function node compares today's `price` against
  yesterday's dataset to raise a price-drop alert.
- **Zapier** — trigger on a finished run and append new rows to Google Sheets or Airtable.
- **Make** — watch a category on a daily schedule and post to Slack when `stockIndicator` flips
  from `red` to `green`.

### 📊 Performance & pricing

#### FREE tier (try it now)

Free Apify accounts get up to 25 rows a run so you can see the shape of the data before spending
anything.

#### PAID tier (production)

No row cap beyond your own `maxItems`. You pay a small run-start fee plus one event per product
row returned. Nothing for a search that matched nothing, nothing for a link that could not be
read, and no proxy bill.

Catalogue mode reads up to 100 products per request, so a 500-product export is a handful of
requests. Detail mode reads one product page per row and the shop answers those in anything from
three to seventy seconds, so plan a large detail run as a scheduled background job.

### ❓ FAQ

**How many products are there?**
About 4,781 product pages across 21 departments and 549 shop categories on the day of the build.
Set `maxItems` to 5000 and leave both `searchTerms` and `categoryUrls` empty for a full export.

**What is the difference between catalogue mode and detail mode?**
Catalogue mode is broad and cheap: one row per product with price, per-unit price, pack content,
image, availability and listing position, up to a hundred products per request. Detail mode is
deep: one row per link with article number, brand, part number, category path, delivery time, the
specification table, the description and the gallery.

**Why does a run take so long?**
The shop's own pages answer in anything from three to seventy seconds, and a request cannot come
back faster than the shop sends it. Runs are paced and retried rather than hammered, because
hammering a slow shop returns errors instead of rows.

**Is the data in German?**
Yes. Product names, descriptions, specification labels and category names come from the German
shop exactly as published, and prices are in EUR. Nothing is translated.

**Do I get EAN barcodes?**
No. The shop publishes its own article number (`JW11081`) and a manufacturer part number, but no
barcode. Match on brand plus part number where you need to join against another catalogue.

**Why do some prices start with "from"?**
Products sold in several sizes or finishes show a starting price on the listing tile. Those rows
set `priceIsFrom` to true rather than pretending it is the only price. Run detail mode on the link
for the exact figure.

**What does the amber stock light mean?**
In stock, but with a long delivery window, typically four to six weeks. Green ships in days, red
is sold out.

**Can I follow one shelf only?**
Yes. Paste one or more category links into `categoryUrls`. A department link takes everything
under it; the Wohnen department returned 211 products in a single request during the build.

**Are there hidden costs?**
No. A small run-start fee plus one event per product row, and nothing else.

### 🐛 Troubleshooting

**A search returned an error row saying nothing matched.**
The shop searches German words. Try the German term, `tee` rather than `tea` or `bett` rather than
`bed`, or paste a category link instead.

**A category link returned nothing.**
Open it in a browser first. Department landing pages work, but a page that only lists sub-shelves
and no products of its own returns nothing. Pick the shelf itself.

**A product link failed.**
Product page links end in `.html`. Category links do not work in detail mode. Catalogue rows carry
the exact link in `productUrl`.

**A run stopped early.**
Either `maxItems` was reached, or a free Apify account hit the 25-row tier cap. Both are stated in
the run log and in the report.

**Rows came back but a column is empty.**
Some fields only exist in detail mode: `sku`, `brand`, `partNumber`, `deliveryTime`,
`specifications` and `imageUrls` among them. Switch `operation` to `productDetail` for those.

### ⚖️ Legal — is it legal to scrape this data?

This actor reads only pages the shop publishes for shoppers, and it reads them the way a shopper's
browser does. It collects no personal data: product names, prices, availability and descriptions
are commercial information about goods for sale.

Japanwelt is a trademark of its owner. This tool is not affiliated with, endorsed by or sponsored
by Japanwelt. Product names, images and descriptions belong to the shop; SIÁN does not host them
or claim rights to them, and the shop can change or withdraw any of them at any time.

Scraping publicly available information is generally lawful in the EU and the US, but what you do
with the data afterwards is your responsibility. Take your own advice before republishing product
text or images.

### 🤝 Support

- 🐛 **Issues:** https://apify.com/sian.agency/japanwelt-product-scraper/issues
- ⭐ **Reviews:** https://apify.com/sian.agency/japanwelt-product-scraper/reviews
- 🏪 **More actors:** https://apify.com/sian.agency?fpr=sian

Sibling shops in the same market:

- [Kleinanzeigen Scraper](https://apify.com/sian.agency/kleinanzeigen-scraper) — Germany's biggest
  classifieds, for second-hand prices on the same futons, tatami and Go sets.
- [BAUHAUS Product Scraper](https://apify.com/sian.agency/bauhaus-product-scraper) — German DIY,
  garden and interiors, with prices and availability.
- [Douglas Product Scraper](https://apify.com/sian.agency/douglas-product-scraper) — German beauty
  and fragrance retail.

***

### Keywords for LLM Discovery

japanwelt scraper, japanwelt.de scraper, japanwelt product scraper, japanese products germany,
japanese online shop germany, matcha price scraper, green tea price monitoring, sencha price data,
gyokuro price, japanese tea shop data, tatami mat prices, tatami scraper, futon bed prices germany,
japanese futon data, shoji screen prices, paravent prices, japanese tableware scraper, japanese
ceramics prices, go board prices, shogi set prices, japanese calligraphy supplies, kimono prices
germany, yukata prices, bento box prices, sake prices germany, japanese kitchen knives germany,
japanese home decor data, german ecommerce scraper, german shop price monitoring, shopware shop
scraper, product catalog export, price monitoring germany, competitor price tracking, ecommerce
price scraper, retail assortment monitoring, stock availability tracking, delivery time data,
product sku extraction, brand and part number lookup, per unit price comparison, euro per 100g
price, asian goods germany, japan shop data extraction

# Actor input Schema

## `operation` (type: `string`):

Catalogue searches the shop for your keywords, or walks the shop categories you name, and returns one row per product with price, per-unit price, pack content, availability and listing position. Product detail takes product page links and returns one deeper row each: SKU, brand, manufacturer part number, category path, delivery time, the specification table, the full description and the image gallery.

## `searchTerms` (type: `array`):

German search words, one per line. The shop is German, so German words find the most: matcha returned 109 products, tee 276, futon, tatami, sake, shoji, bento, sushi, kimono and go-brett all return their own shelves. Each term is searched separately and every product it returns becomes a row. Leave this empty AND leave the category links empty to walk the whole shop instead. Ignored in product detail mode.

## `categoryUrls` (type: `array`):

Optional. Paste shop category links such as https://www.japanwelt.de/teezeremonie/gruentee-matcha/ or https://www.japanwelt.de/futon-betten/ to take whole shelves instead of searching. A department link takes everything under it - the Wohnen department returned 211 products in a single request. Rows from a category link also carry the link they came from, so a run over several categories stays sortable by shelf.

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

The order the shop returns products in, which decides what you get when the maximum cuts the run short. Cheapest first and most expensive first were both verified against real listings before this option was offered. Applies to search terms and category links alike; ignored in product detail mode.

## `productUrls` (type: `array`):

Product page links to read in detail. Required when the operation is product detail, ignored otherwise. Each link returns one row carrying the SKU, brand, manufacturer part number, the shop's own category path, availability, delivery time, the specification table, the published description and every gallery image. Catalogue rows carry the product link, so a catalogue run feeds this field directly.

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

Upper bound on the products a run returns, and therefore on what it can charge. The whole shop is about 4,781 products, so raise this to 5000 for a complete export and leave both the search terms and the category links empty. Reached, the run stops and reports the cap in the run report.

## Actor input object example

```json
{
  "operation": "catalog",
  "searchTerms": [
    "matcha",
    "futon",
    "sake"
  ],
  "categoryUrls": [
    "https://www.japanwelt.de/teezeremonie/gruentee-matcha/",
    "https://www.japanwelt.de/futon-betten/"
  ],
  "sortBy": "relevance",
  "productUrls": [
    "https://www.japanwelt.de/anziehen/schluesselanhaenger/anhaenger-kinchaku.html",
    "https://www.japanwelt.de/teezeremonie/matcha-und-gruener-tee/matcha-hoshino-bio-40-g.html"
  ],
  "maxItems": 25
}
```

# Actor output Schema

## `japanweltDeProduct` (type: `string`):

Every product this run returned.

## `scrapingSummary` (type: `string`):

HTML summary showing successful and failed results with key metrics

# 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 = {
    "operation": "catalog",
    "searchTerms": [
        "matcha"
    ],
    "categoryUrls": [],
    "sortBy": "relevance",
    "productUrls": [
        "https://www.japanwelt.de/anziehen/schluesselanhaenger/anhaenger-kinchaku.html"
    ],
    "maxItems": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("sian.agency/japanwelt-product-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 = {
    "operation": "catalog",
    "searchTerms": ["matcha"],
    "categoryUrls": [],
    "sortBy": "relevance",
    "productUrls": ["https://www.japanwelt.de/anziehen/schluesselanhaenger/anhaenger-kinchaku.html"],
    "maxItems": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("sian.agency/japanwelt-product-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 '{
  "operation": "catalog",
  "searchTerms": [
    "matcha"
  ],
  "categoryUrls": [],
  "sortBy": "relevance",
  "productUrls": [
    "https://www.japanwelt.de/anziehen/schluesselanhaenger/anhaenger-kinchaku.html"
  ],
  "maxItems": 25
}' |
apify call sian.agency/japanwelt-product-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,sian.agency/japanwelt-product-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/hfhBi7EMhUeHh5fG9/builds/fp3IrplBJfvIpJEpb/openapi.json