# Rakuten Ichiba Products Scraper (price & seller watch) (`superslowsloth/rakuten-ichiba-products`) Actor

Search Rakuten Ichiba (rakuten.co.jp) by keyword, newest first or by price, and get one flat row per listing: JPY price, shop, review score and count, points, shipping fee, category, ranking badge and sponsored flag.

- **URL**: https://apify.com/superslowsloth/rakuten-ichiba-products.md
- **Developed by:** [Superslow Sloth](https://apify.com/superslowsloth) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.05 / 1,000 product scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Rakuten Ichiba Products Scraper (price & seller watch)

Rakuten Ichiba products scraper: search Rakuten Ichiba (楽天市場, rakuten.co.jp),
Japan's largest online marketplace, and get one flat row per listing: no nested
objects, no HTML to strip yourself. Built for price watching, competitor and seller
tracking and new-listing alerts. Give it keywords and a sort order and you get each
listing's JPY price, shop, review score and count, points, shipping fee, category and
position on the page.

This is the Rakuten **Ichiba** shopping mall. It is not Rakuten Travel (hotels).

### Input

| field | meaning |
|---|---|
| `queries` | One or more searches, exactly as typed into the Rakuten Ichiba search box |
| `sort` | Rakuten's sort code. Default `4`, newest first. Table below |
| `maxItems` | Stop each search after this many products. Every search gets its own budget |
| `proxyConfiguration` | Apify proxy by default. See **Proxy** below |

#### Sort codes

Each code was fetched on 2026-10-10 and the page's own sort name read back.

| code | order | reach |
|---|---|---|
| `1` | Standard (relevance) | 6,750 results |
| `4` | Newest first | 6,750 |
| `7` / `8` | Price low to high / high to low (all results) | 6,750 |
| `9` / `10` | Most reviews / highest review score (all results) | 6,750 |
| `2` / `3` | Price low to high / high to low | only the first 9 pages, 405 results |
| `5` / `6` | Most reviews / highest review score | 405 |
| `11` / `12` | Price plus shipping, low to high / high to low | 405 |

Rakuten itself caps one search at 150 pages of 45 listings (6,750 products) for
the first group, and at 9 pages for the second. A search with few hits is capped by
its own hit count instead. Pick `7`-`10` rather than `2`, `3`, `5`, `6` when you want
the full result set in that order.

### Output

| field | meaning |
|---|---|
| `item_code` | Rakuten's numeric item code. Unique within a shop: the pair (`shop_code`, `item_code`), plus `variant_id` where a listing has variants, names an item |
| `manage_number` | The shop's own item number, from the item URL (`item.rakuten.co.jp/<shop>/<manage_number>/`) |
| `variant_id` | Rakuten's variant id when one listing carries several SKUs, else `null` |
| `url`, `name`, `subtitle` | Item page link, listing title and the seller's catch-copy line |
| `price_jpy` | Price in yen, tax included. The lowest price when the listing has several SKUs |
| `price_max_jpy` | The highest SKU price when the listing shows a range ("1,080 - 1,380"), else `null` |
| `shop_name`, `shop_code`, `shop_url_code`, `shop_url` | The seller's shop: name, numeric id, URL slug and shop page |
| `review_count` | Number of customer reviews, `0` when there are none |
| `review_average` | Average out of 5, `null` when there are no reviews |
| `image_url` | The thumbnail, `null` when the listing has no image |
| `points` | Rakuten Points earned on one unit at this price, as Rakuten works it out |
| `point_base_multiplier`, `point_boost_multiplier` | The multipliers Rakuten reports, raw: base (normally 1, 0 on deal-point items) and any point-up boost |
| `shipping_fee_jpy`, `free_shipping` | Shipping fee to Rakuten's default region (Tokyo) and whether it is 0 |
| `sold_out`, `used`, `used_condition`, `super_deal` | Rakuten's flags: sold out, used-goods flag with its condition grade ("中古品-可"), SuperDEAL campaign |
| `category`, `genre_id` | Rakuten's genre breadcrumb, root first, and the id of its leaf |
| `ranking_position`, `ranking_genre` | The daily-ranking badge a listing wears (rank and the genre it is for), else `null` |
| `sponsored` | `true` for a paid placement in the results |
| `source` | `initial_state` normally; `json_ld` if the page's main data block was missing (see **How it reads the page**) |
| `page`, `position` | Page of the search and 1-based position on it, ads included |
| `query` | The keyword this row came from |

#### `null` is not zero

A column is `null` when the page does not show it. The actor never puts a `0` or an
empty string in its place:

- `review_average` is `null` on an item with no reviews. Rakuten prints a score of 0
  there; the actor treats that as "no score". `review_count` stays `0`, because the
  page really says zero reviews. On a `nintendo switch` search sorted newest first,
  every one of 45 listings had no reviews yet.
- `price_max_jpy` is `null` unless the listing shows a price range.
- `image_url` is `null` on listings with no picture (5 of 45 on that same page).
- `used_condition` is `null` unless the item is flagged used.
- `shipping_fee_jpy` and `free_shipping` are `null` if the page does not print a fee.
  Shipping is the fee to Rakuten's default region, Tokyo; some shops charge more
  elsewhere.

#### Sponsored rows

Rakuten sometimes serves a few paid placements at the head or tail of the results
(5 on one `nintendo switch` page, 4 on another, none on most). They are marked
`sponsored: true`, and their `url` is the item page, not Rakuten's ad-click redirect.
When a paid placement repeats a listing that also ranks organically, the organic row
is kept and the paid copy dropped, so a listing is charged once per search.

### How it reads the page

Rakuten renders the whole result set into the page's `__INITIAL_STATE__` data block,
45 listings per page, with the item, shop, price, reviews, points and shipping for
each. That block is the source. Its schema.org `ItemList` carries only 10 rows (the
page's first 10 that have a picture) and fewer fields; it is used only if the main block is missing, and rows read
that way say `source: "json_ld"` and leave the fields it does not carry `null`.

### Paging

The actor asks for `p=2`, `3` and so on. It reads the page count from the response
(`numFound` capped by the sort's own limit) and stops at the last page. A request for
a page past the end is answered by Rakuten with page 1; the actor reads the page the
body was rendered for, notices, and stops instead of billing copies of page 1.

### Proxy

The default is Apify's proxy. Rakuten served a full result page to Apify datacenter
and residential exits on 2026-10-10. Rakuten answers a burst of requests from a
single address with an HTTP 503 "アクセスが集中しております" overload page (seen after
about 30 requests in a few minutes from one address). That page, any 403/429/5xx and
any 200 with no results payload count as a refusal: the actor switches address and
retries.

### Billing

Pay per event: **$0.00105 per product**, plus **$0.002 per run** for actor-start.
Platform usage (compute, bandwidth, proxy) is included. You pay the two event prices
above and nothing else. A listing turned up twice in one search is charged once.

For comparison, Apify Store's other Rakuten Ichiba product scrapers list $0.0015
(`piotrv1001/rakuten-japan-listings-scraper`), $0.005
(`axlymxp/rakuten-ichiba-product-scraper`) and $0.01
(`moving_beacon-owner1/rakuten-ichiba-product-scraper`) per item, read 2026-10-10.
This actor's $0.00105 is 30% under the cheapest of those.

# Actor input Schema

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

One or more searches, each exactly as you would type it into the Rakuten Ichiba (rakuten.co.jp) search box, e.g. "nintendo switch" or "コーヒー豆". Each search gets its own maxItems budget, in the order given. Spellings that differ only in case are collapsed.

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

Rakuten's own sort codes, each checked against the page on 2026-10-10. Default 4, newest listings first, is the one a new-listing or competitor watch wants. Codes 2, 3, 5, 6, 11 and 12 serve only the first 9 pages (405 results on a 290,000-hit search); their twins 7, 8, 9 and 10 reach the full 6,750.

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

Stop each search after this many products. Rakuten shows 45 listings per page, so 45 is one page request. Rakuten itself serves at most 150 pages, 6,750 products, for one search and sort.

## `proxyConfiguration` (type: `object`):

Apify proxy (automatic datacenter exits) is the default and is what the actor was measured on: search.rakuten.co.jp answered Apify datacenter and residential exits with a full result page on 2026-10-10. A proxy is what lets a refused request be retried from a fresh address: Rakuten answers a burst from one address with an HTTP 503 overload page.

## Actor input object example

```json
{
  "queries": [
    "nintendo switch"
  ],
  "sort": "4",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `products` (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": [
        "nintendo switch"
    ],
    "sort": "4",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("superslowsloth/rakuten-ichiba-products").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": ["nintendo switch"],
    "sort": "4",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("superslowsloth/rakuten-ichiba-products").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": [
    "nintendo switch"
  ],
  "sort": "4",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call superslowsloth/rakuten-ichiba-products --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,superslowsloth/rakuten-ichiba-products"
        }
    }
}
```

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/gSGC9Ciq65lnVpmve/builds/dWDGbKKmRKbxQ1Y14/openapi.json