# Rakuten Scraper | Japan Products, Shops and Rankings (`lentic_clockss/rakuten-scraper`) Actor

Collect Rakuten Ichiba products, JPY prices, shop details, rankings and categories from Japan. Export structured rows, with optional review snippets. Pay per delivered row plus a small start fee.

- **URL**: https://apify.com/lentic_clockss/rakuten-scraper.md
- **Developed by:** [kane liu](https://apify.com/lentic_clockss) (community)
- **Categories:** E-commerce, Business, Automation
- **Features:** Limited permissions
- **Stats:** 17 total users, 8 monthly users, 97.3% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.20 / 1,000 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

**Collect Rakuten Ichiba product, shop, ranking and category data from Japan as rows you can export or read through the API.**

- Search Japanese keywords or supply Rakuten Ichiba page URLs.
- Compare JPY prices, shipping information, points and review totals.
- Collect shop details, rankings, category names and search suggestions.
- Add review snippets as separate rows when available.
- Pay only for the rows you receive: $3.00 per 1,000 rows on the Free plan plus a small start fee.

### What does Rakuten Scraper do?

Rakuten Scraper collects publicly available data from Rakuten Ichiba at `rakuten.co.jp`. Use it for price tracking, catalog research or comparing shops. It does not cover the global `rakuten.com` marketplace and is not an official Rakuten product.

- **Search**: use `keyword` or `searchQueries`; narrow results with `genreId`, prices or filters.
- **Items**: supply `itemUrl`, or `shopUrlCode` with `manageNumber`.
- **Shops**: use `shopUrlCode` to collect a shop row and product rows found on its page.
- **Rankings**: choose `ranking`, optionally with a genre and ranking period.
- **Categories**: choose `categories` for genre names and hierarchy information.
- **Suggestions**: choose `suggest` with a keyword for autocomplete suggestions.

`enrichReviews` is off by default. Each returned review snippet becomes a separate billed row, sharing the input's row allowance with products. Shop disclosure enrichment, `enrichLead`, is on by default and adds available business information to the shop row.

### What data can you extract from Rakuten?

Fields depend on the page and mode. These examples illustrate the format, not a current price or guaranteed result.

#### Product and ranking rows

| Field | Description | Example |
| --- | --- | --- |
| `rowType` | Entity type | `product` |
| `id` | Identifier within the row type | `example-shop:bottle-1` |
| `title` | Product title | `Stainless steel bottle` |
| `price` | Listed price | `2050` |
| `currency` | Price currency | `JPY` |
| `itemId` | Rakuten item identifier | `10005699` |
| `manageNumber` | Item code within the shop | `bottle-1` |
| `shopUrlCode` | Shop code in its URL | `example-shop` |
| `shopName` | Displayed shop name | `Example Shop` |
| `url` | Product page address | `https://item.rakuten.co.jp/example-shop/bottle-1/` |
| `shippingIncluded` | Whether shipping is included | `true` |
| `pointCount` | Listed reward points | `18` |
| `reviewScore` | Aggregate review rating | `4.5` |
| `reviewCount` | Number of reviews | `120` |
| `rankingRank` | Position in the selected ranking | `1` |
| `imageUrl` | Main product image address | `https://example.com/product.jpg` |

#### Review rows

These have `rowType="review"`. Product rows retain aggregate review fields rather than a `reviewSnippets` list.

| Field | Description | Example |
| --- | --- | --- |
| `reviewId` | Identifier for this review row | `example-shop:bottle-1:review:example-1` |
| `productId` | Parent product identifier | `example-shop:bottle-1` |
| `productUrl` | Parent product address | `https://item.rakuten.co.jp/example-shop/bottle-1/` |
| `text` | Available review text | `Example review text` |

#### Shop rows

These have `rowType="shop"`, with shop identity fields and available disclosure details.

| Field | Description | Example |
| --- | --- | --- |
| `companyName` | Disclosed business name | `Example Company` |
| `tel` | Public business telephone | `+1 555 0100` |
| `businessHours` | Published opening hours | `09:00-17:00` |

#### Category rows

These have `rowType="category"`.

| Field | Description | Example |
| --- | --- | --- |
| `genreId` | Rakuten genre identifier | `564500` |
| `name` | Category name | `スマートフォン・タブレット` |
| `depth` | Level in the returned hierarchy | `1` |

#### Suggestion rows

Identify suggestions by `recordType="suggestion"`; their `rowType` is currently `product`, not a separate suggestion type.

| Field | Description | Example |
| --- | --- | --- |
| `recordType` | Distinguishes suggestions from listings | `suggestion` |
| `keyword` | Requested search word | `水筒` |
| `name` | Suggested search phrase | `水筒 子供` |

### How to scrape Rakuten

1. Open [Rakuten Scraper](https://apify.com/lentic_clockss/rakuten-scraper) in Apify Console. A free Apify account is enough to try it.
2. Fill one target field, such as `keyword`, and leave `mode` on `auto`.
3. Set `maxResults` to `5` for your first run.
4. Click **Start** and wait for completion.
5. Download the dataset or read it through the API.

An empty input starts an example search for `水筒`, limited to 3 rows. Normal start and row charges apply. Filling one target field selects the matching mode automatically. URLs take precedence over item or shop identifiers, which take precedence over keywords. `genreId` narrows a mode; it does not select one by itself.

#### Search

Enter `keyword`, or put several keywords in `searchQueries`. Japanese words are recommended; the Actor does not promise to translate your query. Add `genreId` to restrict a search to a category.

#### Items

Paste an Ichiba item address into `itemUrl`. Alternatively, enter the shop code and item code from the address as `shopUrlCode` and `manageNumber`.

#### Shops

Enter the shop code in `shopUrlCode`, without the full URL. The shop row counts toward `maxResults`, along with any product and review rows. This is not a guarantee of the shop's complete inventory.

#### Rankings

Set `mode` to `ranking`. Without a genre, it requests the overall ranking. `period` accepts `daily`, `realtime`, `weekly` or `monthly`.

#### Categories

Set `mode` to `categories`. Add `genreId` to begin at one genre, and use `maxResults` to limit delivered rows. The returned hierarchy may be incomplete.

#### Suggestions

Set `mode` to `suggest` and enter `keyword`. Suggestions are search phrases, not product offers, so price and item identifiers may be absent.

### What to fill in

| Field | What to enter | Default |
| --- | --- | --- |
| `mode` | `auto`, `search`, `item`, `shop`, `ranking`, `categories` or `suggest` | `auto` |
| `keyword` | One search word or phrase | Empty; form sample `水筒` |
| `searchQueries` | Several keywords | Empty |
| `startUrls` | Ichiba search, item, shop or ranking page URLs | Empty |
| `itemUrl` | One item page URL | Empty |
| `shopUrlCode` | Shop code; combine with `manageNumber` for an item | Empty |
| `manageNumber` | Item code within a shop | Empty |
| `maxResults` | Maximum rows per input, from 1 to 500 | `70`; form sample `3` |
| `genreId` | Genre identifier to narrow the selected mode | Empty |
| `genreSlug` | Recognized genre name or alias; prefer a known `genreId` | Empty |
| `sort` | `standard`, `price_asc`, `price_desc`, `newest`, `review_count` or `review_score` | Site order |
| `minPrice`, `maxPrice` | Optional price bounds in JPY | Unset |
| `filters` | For example, `free_shipping` or `super_deal` | Empty |
| `tags` | Tag values from the relevant search page | Empty |
| `used` | Search page's used-item setting, `0` or `1` | Unset |
| `period` | Ranking period | `daily` |
| `page` | Starting search page, from 1 to 100 | `1` |
| `maxGenreNodes` | Category exploration limit; not the delivered row allowance | `800` |
| `enrichDetails` | Add available item-page details to listings | `false` |
| `enrichReviews` | Request review snippets as separate billed rows | `false` |
| `enrichStock` | Request available item stock details | `false` |
| `enrichShipping` | Request available item shipping details | `false` |
| `enrichBenefits` | Request available item points and benefits | `false` |
| `enrichLead` | Add public business disclosures to shop rows | `true` |

**Search with filters:**

```json
{
  "keyword": "水筒",
  "sort": "price_asc",
  "minPrice": 500,
  "maxPrice": 3000,
  "filters": ["free_shipping"],
  "maxResults": 5
}
```

**Item:** replace the placeholder address with an existing item.

```json
{
  "itemUrl": "https://item.rakuten.co.jp/example-shop/example-item/",
  "maxResults": 1
}
```

**Shop:** replace the placeholder code with an existing shop.

```json
{
  "shopUrlCode": "example-shop",
  "maxResults": 5
}
```

**Ranking:**

```json
{
  "mode": "ranking",
  "genreId": "560202",
  "period": "daily",
  "maxResults": 5
}
```

**Categories:**

```json
{
  "mode": "categories",
  "genreId": "564500",
  "maxGenreNodes": 5,
  "maxResults": 5
}
```

**Suggestions:**

```json
{
  "mode": "suggest",
  "keyword": "水筒",
  "maxResults": 5
}
```

- `maxItems` and `limit` are accepted as aliases for `maxResults`.
- Unknown fields do not fail the run by themselves. Close misspellings can be corrected; other unknown fields are ignored with a note.
- Invalid targets stop processing before rows are charged, with a message such as `INVALID_INPUT: itemUrl — paste a Rakuten Ichiba item page address`. A start charge can still apply.
- The `INPUT_REPORT` record in the run's key-value store records input resolution, including fields filled, corrected or ignored. `INPUT_ECHO` shows the parsed input.
- Invalid ranking periods fall back to `daily`. A reversed price range is removed rather than treated as a valid filter.

### Output example

Illustrative product row:

```json
{
  "rowType": "product",
  "id": "example-shop:bottle-1",
  "recordType": "item",
  "manageNumber": "bottle-1",
  "shopUrlCode": "example-shop",
  "title": "Stainless steel bottle",
  "price": 2050,
  "currency": "JPY",
  "shippingIncluded": true,
  "pointCount": 18,
  "url": "https://item.rakuten.co.jp/example-shop/bottle-1/",
  "country": "JP"
}
```

You can export the dataset as JSON, CSV, Excel, XML, RSS or an HTML table. Keep `rowType` and `id` when combining exports so products, reviews and shops remain distinguishable.

### Why use this Rakuten scraper?

- **Pay per row.** Row charges apply to delivered dataset rows, not pages attempted.
- **Several inputs.** Supply multiple keywords or URLs in one run, each with its own row allowance.
- **Explicit input feedback.** Check `INPUT_REPORT` before changing a query that produced unexpected results.
- **Keep delivered data.** Rows already written remain in the dataset if the run stops. Data not yet delivered is not guaranteed after a manual stop.
- **No proxy setup.** You do not need to set up proxies or supply a Rakuten account.

### How much does it cost to scrape Rakuten?

The Actor uses pay-per-event pricing. The start event costs **$0.005**, billed once per allocated GB with a minimum of one event. At the default **512 MB**, that means one start event, or **$0.005**. Platform usage is included in these prices.

| Apify plan | Price per row | Price per 1,000 rows |
| --- | --- | --- |
| Free | $0.003 | $3.00 |
| Starter | $0.003 | $3.00 |
| Scale | $0.0026 | $2.60 |
| Business | $0.0022 | $2.20 |
| Platinum | $0.002 | $2.00 |
| Diamond | $0.0016 | $1.60 |

`maxResults` applies to each keyword or start URL. A single item, shop, ranking, category or suggestion request counts as one input. The default is 70 rows; larger requests are collected in parts of 70. All row types share the allowance, so 5 rows with reviews enabled need not mean 5 products.

Free Apify plan users are limited to 10 runs of this Actor and 200 rows per run. Set **Maximum cost per run** (`maxTotalChargeUsd` in the API) to cap the whole run, including row and start charges.

Example: 3 keywords returning 50 rows each give 150 rows. At default memory on the Free plan: `150 × $0.003 + $0.005 = $0.455`. A run that delivers fewer rows incurs fewer row charges; an example run is not automatically free.

- The Apify Free plan includes **$5.00** in monthly usage credit (about **1,666 rows** at `$0.003` per row across Free-plan runs capped at 200 rows per run).

### What happens when the run timeout is too short

When a collection is expected to outlast your remaining timeout, the run can pause with the status message "Queued on the collection backend; this run will resume automatically when results are ready (about N s)." It appears as `ABORTED` temporarily.

When results are ready, the same run resumes, delivers to the same dataset and finishes as `SUCCEEDED` if collection succeeds. A resumed delivery can show "Resumed: delivering N rows." Rows already delivered are skipped so they are not delivered or charged twice. This automatic pause is different from a manual abort or a collection failure.

- Automatic pausing is limited to 3 times per run. Keep the default timeout of **3600 seconds** to reduce the need to pause.
- The synchronous endpoints `run-sync` and `run-sync-get-dataset-items` wait at most 300 seconds and can return an empty dataset during a pause. For longer runs, start asynchronously and read the dataset after `SUCCEEDED`, or use a success webhook.

### Use with AI agents and the API

#### Apify MCP server (Claude, ChatGPT, Cursor, VS Code)

Add this Actor to an MCP client that supports remote servers:

```
https://mcp.apify.com?tools=lentic_clockss/rakuten-scraper
```

Sign in with Apify when prompted through OAuth, or send `Authorization: Bearer <YOUR_APIFY_TOKEN>`. The tool starts a run and returns run and dataset IDs; the agent can read the rows with `get-dataset-items`.

Clients without remote MCP support can use `npx @apify/actors-mcp-server --tools lentic_clockss/rakuten-scraper` with `APIFY_TOKEN` set.

Example prompt: "Search Rakuten Ichiba for 水筒, return 5 rows, and compare listed JPY prices and shipping information."

- **Agent execution note:** Set `maxResults` between `5` and `20` on exploratory tool calls to keep responses compact, and read `RUN_SUMMARY` and `INPUT_REPORT` from the default key-value store to inspect normalized inputs and delivered row counts. When a long run briefly reports `ABORTED` with the automatic-resume status message, wait for the same run ID to finish as `SUCCEEDED` instead of starting a duplicate run.

#### Apify API

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("lentic_clockss/rakuten-scraper").call(
    run_input={"keyword": "水筒", "maxResults": 5}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('lentic_clockss/rakuten-scraper').call({
  keyword: '水筒', maxResults: 5
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

For HTTP, send the JSON input to `POST https://api.apify.com/v2/acts/lentic_clockss~rakuten-scraper/runs` with `Authorization: Bearer <YOUR_APIFY_TOKEN>`. After completion, read `GET https://api.apify.com/v2/datasets/<datasetId>/items?format=json`.

#### Integrations

Connect results to Google Sheets, Make, Zapier, n8n, Slack, Airtable or a webhook from the Actor's **Integrations** tab. Use Apify Schedules for recurring runs.

### 日本語の説明

楽天市場の商品、ショップ、ランキング、ジャンル情報を収集します。検索する場合は `keyword` に「水筒」などの日本語を入力し、最初は `maxResults` を `5` にしてください。商品ページの指定には `itemUrl` を使います。日本の楽天市場が対象で、海外の楽天サイトや楽天トラベルは対象外です。料金は開始料金と、実際に出力された行数で決まります。レビューを追加すると、商品とは別の行として数えられ、同じ上限を使います。結果は CSV や Excel で保存できます。入力が空の場合も少量のサンプル検索が実行され、通常の料金が適用されます。取得できない項目や、情報が不足するページもあります。

### FAQ

#### Is it legal to scrape Rakuten?

This Actor targets public data. You are responsible for checking Rakuten's terms and applicable data-protection law before collecting or using it. Public availability alone does not remove those obligations; personal data requires a lawful basis. This is not legal advice.

#### Why did my run end as ABORTED?

Check the status message. The automatic-resume message means the run has paused while awaiting results. Other aborts do not necessarily resume. Keep the run ID when contacting support.

#### How many results can I get?

`maxResults` accepts 1–500 rows per input, subject to availability, the whole-run cost cap and free-plan limits. It is a ceiling, not a promise to find that many rows.

#### Why are some fields empty?

Different pages expose different information. Ranking cards can lack titles or prices; `enrichDetails` can add item-page fields when available. Shipping, stock and benefits are not guaranteed for every item.

#### Does this cover rakuten.com, Rakuma, Travel or Books?

No. It targets Japan's Ichiba marketplace, not those separate services. Products sold within Ichiba are distinct from dedicated Rakuten services.

#### Can I collect every review?

No completeness guarantee is made. Available review snippets become separate rows when `enrichReviews` is enabled, and they share the input's row limit with products.

#### Which identifiers should I use to join exports?

Use `rowType` with `id`. For products, `shopUrlCode` and `manageNumber` identify the item within a shop. Review rows link back through `productId` and `productUrl`.

### Limitations

- Japan Ichiba only; no login, checkout or private account data.
- Site changes or unavailable pages can cause partial data, empty results or failures.
- Shop mode returns products found on the supplied shop page, not a guaranteed full catalog.
- Category results can fall back to known category entries and are not guaranteed to form a complete, freshly observed tree.
- Enrichment may add time and may leave fields empty. Review snippets are not a complete review archive.
- An accepted Rakuten URL is not proof that every page type on that domain is supported.

### Related scrapers

More e-commerce and marketplace scrapers from the same publisher:

- [Walmart Scraper](https://apify.com/lentic_clockss/walmart-scraper)
- [Temu Scraper](https://apify.com/lentic_clockss/temu-scraper)
- [Allegro Scraper](https://apify.com/lentic_clockss/allegro-scraper)
- [Shopee Scraper](https://apify.com/lentic_clockss/shopee-search-scraper)
- [Amazon Scraper](https://apify.com/lentic_clockss/amazon-search-results-collector)
- [TikTok Shop Scraper](https://apify.com/lentic_clockss/tiktok-shop-scraper)
- [Stealth Web Scraper](https://apify.com/lentic_clockss/stealth-web-scraper)
- [Email Validator](https://apify.com/lentic_clockss/email-risk-validator)

Browse all of our scrapers at [apify.com/lentic_clockss](https://apify.com/lentic_clockss).

### Support

Found a problem or need another field? Open an issue in the **Issues** tab of this Actor's page and include the run ID and the input you used.

# Actor input Schema

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

Choose what to collect, or leave auto to select from the fields you fill. Ranking and category modes need no keyword; genreId narrows the selected mode.

## `keyword` (type: `string`):

Search word or phrase for search or suggestion mode. Japanese keywords are recommended.

## `searchQueries` (type: `array`):

Several keywords at once. Each keyword gets its own maxResults row allowance.

## `startUrls` (type: `array`):

Rakuten Ichiba search, item, shop or ranking page addresses. Each address selects its page type and has its own maxResults allowance.

## `itemUrl` (type: `string`):

One item page address, e.g. https://item.rakuten.co.jp/<shop>/<item>/

## `shopUrlCode` (type: `string`):

Shop code from the shop address, e.g. rakutenmobile-store in https://www.rakuten.co.jp/rakutenmobile-store/. Alone it lists the shop; with a manage number it opens one item.

## `manageNumber` (type: `string`):

Item code from the final part of an item page address. Use with shopUrlCode to select one item.

## `maxResults` (type: `integer`):

Maximum rows for each keyword or start URL; a single item, shop, ranking, category or suggestion request counts as one input. Default 70, collected in parts of 70 for larger requests; all row types share the allowance, subject to the run cost cap and the Free plan limit of 200 rows per run.

## `genreId` (type: `string`):

Rakuten genre identifier, such as 564500 for smartphones and tablets. Narrows search, ranking or category mode; does not select a mode by itself.

## `genreSlug` (type: `string`):

Recognized genre name or alias, such as smartphone. Used when genreId is empty; a known numeric genreId is more precise.

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

Search result order: standard, price_asc, price_desc, newest, review_count or review_score. Leave empty for the site order.

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

Minimum listed price in JPY for search results. Leave empty for no minimum.

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

Maximum listed price in JPY for search results. Leave empty for no maximum.

## `filters` (type: `array`):

Search filters: free_shipping, super_deal, student, subscription or include_sold_out. Availability depends on the search page.

## `tags` (type: `array`):

Tag identifiers from a Rakuten search page. Leave empty if you do not need tag filtering.

## `used` (type: `integer`):

Optional used-item setting from the search page: 0 or 1. Availability depends on the page.

## `period` (type: `string`):

Ranking period: daily, realtime, weekly or monthly. Used in ranking mode.

## `page` (type: `integer`):

First search result page to collect, starting at 1.

## `maxGenreNodes` (type: `integer`):

Limit category exploration in categories mode. maxResults separately limits the rows delivered.

## `enrichDetails` (type: `boolean`):

Add available item-page details to product listings. May increase run time.

## `enrichReviews` (type: `boolean`):

Request available review snippets as separate billed rows. Review rows and product rows share the same maxResults allowance; a complete review history is not guaranteed.

## `enrichStock` (type: `boolean`):

Request available stock and variant information for items. These details may be missing.

## `enrichShipping` (type: `boolean`):

Request available item shipping fees and delivery estimates. These details may be missing.

## `enrichBenefits` (type: `boolean`):

Request available item reward points and benefit eligibility. These details may be missing.

## `enrichLead` (type: `boolean`):

Add available public business disclosures to the shop row, such as company name, telephone and opening hours. Enabled by default for shop mode.

## `engine` (type: `string`):

Choose a search method, or leave auto for the default. Availability of optional fields can differ between methods.

## `proxyCountry` (type: `string`):

Keep JP for Japan. This setting does not select a different Rakuten marketplace.

## `workerBaseUrl` (type: `string`):

Leave empty. Used only by the developer for testing.

## Actor input object example

```json
{
  "mode": "auto",
  "keyword": "水筒",
  "maxResults": 3,
  "period": "daily",
  "page": 1,
  "maxGenreNodes": 800,
  "enrichDetails": false,
  "enrichReviews": false,
  "enrichStock": false,
  "enrichShipping": false,
  "enrichBenefits": false,
  "enrichLead": true,
  "engine": "auto",
  "proxyCountry": "JP"
}
```

# Actor output Schema

## `results` (type: `string`):

Delivered dataset rows: products, review snippets, shops, categories or search suggestions.

## `runSummary` (type: `string`):

Run outcome, delivered row count and available warnings.

## `inputEcho` (type: `string`):

Parsed input used for the run.

## `errorSummary` (type: `string`):

Error information saved when a run fails.

# 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": "auto",
    "keyword": "水筒",
    "maxResults": 3,
    "period": "daily",
    "page": 1,
    "proxyCountry": "JP"
};

// Run the Actor and wait for it to finish
const run = await client.actor("lentic_clockss/rakuten-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": "auto",
    "keyword": "水筒",
    "maxResults": 3,
    "period": "daily",
    "page": 1,
    "proxyCountry": "JP",
}

# Run the Actor and wait for it to finish
run = client.actor("lentic_clockss/rakuten-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": "auto",
  "keyword": "水筒",
  "maxResults": 3,
  "period": "daily",
  "page": 1,
  "proxyCountry": "JP"
}' |
apify call lentic_clockss/rakuten-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lentic_clockss/rakuten-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/f18uUI2FmXSNEXZFJ/builds/MVTPMGaFc78sLanV4/openapi.json