# Rakuten Ichiba Scraper — Japan Product Prices, Shops & Reviews (`zinin/rakuten-scraper`) Actor

Search Rakuten Ichiba (楽天市場) by keyword or search URL and get product listings: price in JPY, shop, review score and count, points, free shipping, sold-out flag and item URL. No login or API key.

- **URL**: https://apify.com/zinin/rakuten-scraper.md
- **Developed by:** [Tim Zinin](https://apify.com/zinin) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 Scraper — Japan Product Prices, Shops, Reviews and Points

Get live Rakuten Ichiba (楽天市場) search results as clean rows: price in JPY, shop, review score, review count, points, free shipping, sold-out flag and the direct item URL — for any keyword or search URL, no Rakuten account and no API key.

![Rakuten Ichiba Scraper — what goes in and what comes out](https://raw.githubusercontent.com/TimmyZinin/apify-actor-assets/edf228c422129f57e34bbc7ffa4f3551f101b7db/travel-mkt-10/rakuten-scraper/readme-hero.webp)

![Rakuten Ichiba Scraper — automation workflow](https://raw.githubusercontent.com/TimmyZinin/apify-actor-assets/edf228c422129f57e34bbc7ffa4f3551f101b7db/travel-mkt-10/rakuten-scraper/readme-workflow.webp)

Rakuten Ichiba is Japan's largest online mall: tens of thousands of independent shops sell through one search box, and the same product often appears at a dozen different prices from different shops. This Actor reads the public search results pages exactly as a shopper in Japan sees them and turns every product card into one structured row. You choose the keywords (Japanese or English) or paste a search URL with your own filters, set how many products you need, and get a dataset you can download as JSON, CSV or Excel, pull through the Apify API, or send to Google Sheets, Make, n8n, Zapier or an AI agent over MCP.

It is built for recurring price and assortment work: run it daily on the same keywords, compare the rows, and you know who changed a price, who ran out of stock and which shop is gaining reviews.

### What you get

One row per product card on the Rakuten Ichiba search results page:

- **Product identity** — `itemCode` (shop code + item code, stable across runs), full product `title`, direct `url` on item.rakuten.co.jp and the Rakuten catalogue `productUrl` when Rakuten has matched the item to a catalogue product.
- **Price** — `price` as a number in Japanese yen (`currency` is always `JPY`), exactly as shown on the result card at run time.
- **Shop** — `shopName` in Japanese, `shopCode` (the shop's URL code) and a ready `shopUrl` to the shop's storefront.
- **Social proof** — `reviewScore` (0–5, Rakuten's average) and `reviewCount` for the item.
- **Rakuten points** — `pointsEarned`, the number of Rakuten Super Points a buyer earns on the listed price, which is a real part of the effective price in Japan.
- **Delivery** — `freeShipping` (true when the card shows free shipping) and `shippingNote`, Rakuten's own delivery promise text such as 「15:00までの注文で最短9/27(翌日)お届け」.
- **Availability** — `isSoldOut` flag.
- **Ad transparency** — `isSponsored` marks paid placements. They are excluded by default; switch them on to see which shops are buying visibility for your keyword.
- **Position** — `page` and `position` on the results page, so you can track ranking over time.
- **Context** — the `query` or `searchUrl` that produced the row and `scrapedAt` timestamp.

Every row is a real product that Rakuten showed for your search. Keywords with no results, blocked pages and budget stops are reported as **free** rows with an `error` field, so you always know what happened to each keyword and never pay for an explanation.

### Who uses it

- **Cross-border sellers and importers** checking what Japanese shops charge for a product before they list it, and which shops dominate a keyword.
- **Brands and distributors** watching authorised and unauthorised resellers of their products on Rakuten: price floors, points campaigns, sold-out gaps.
- **E-commerce and pricing teams** feeding a repricing tool or a BI dashboard with daily Rakuten prices next to Amazon Japan and Yahoo! Shopping data.
- **Market researchers and analysts** sizing a category: how many shops, what price band, how reviews are distributed, how much of page one is sponsored.
- **Affiliate and content publishers** building "best rice cookers under ¥10,000" style pages from fresh prices, review counts and item links.
- **AI agents** that need a grounded answer about current Japanese retail prices and can call the Actor as an MCP tool.

### How to run

1. Click **Try for free** (or **Start**) on this page. You need a free Apify account; no Rakuten account, no API key.
2. In **Search keywords**, enter one or more keywords, one per line. Japanese works best for Japanese products (`炊飯器`, `ワイヤレスイヤホン`), English brand names work too (`iphone`, `nintendo switch`).
3. Optional: paste one or more Rakuten search URLs into **Rakuten search URLs** to reuse filters you already set on the site (genre, price range, free shipping, shop). The Actor keeps every parameter of the URL and only walks its pages.
4. Pick a **Sort order** (relevance, price, price plus shipping, newest, most reviews, best review score) and set **Max products per keyword or URL**. One results page holds about 45 organic products.
5. Click **Start**. The prefilled example (`iphone`, 20 products) finishes in well under a minute.
6. Open the **Output** tab: the *Products* view shows image, title, price, shop, rating, points and link; the *Errors and empty searches* view shows the free explanation rows. Download as JSON, CSV, Excel or HTML, or call the dataset through the API.

To run it on a schedule, open **Schedules**, pick the Actor (or a saved task with your keywords) and choose daily or hourly. To connect it to other tools, see [Integration recipes](#integration-recipes).

### Pricing

This Actor uses **pay per event** pricing. You pay only for products actually delivered to your dataset, plus a small start fee:

| Event | Price | When it is charged |
|---|---|---|
| Actor start | $0.02 per GB of memory | Once per run. The default 2 GB memory means two start events. |
| Product found | $0.006 per product | For every product row delivered to the dataset. |

**Example:** with the default 2 GB memory, a run that delivers 100 products costs 2 × $0.02 + 100 × $0.006 = **$0.64**; 1,000 products cost **$6.04**. The same price applies on every Apify plan.

What you do **not** pay for:

- Rows with an `error` field — keywords with no results, pages Rakuten did not return, and the note written when your spending limit is reached — are free.
- Proxy traffic, browser time and retries are included in the product price. You never see a separate proxy bill.
- Sponsored listings are only delivered (and charged) when you switch **Include sponsored listings** on.

**Spending limit.** Apify lets you set *Max total charge* for any run. The Actor checks the remaining budget **before** every product and stops cleanly when the next product would exceed it, then writes a free row saying so. A real run with a $0.02 limit delivered 5 products and stopped with the note shown in [Partial output](#partial-output-spending-limit-reached).

**Free plan.** Apify's free plan includes monthly platform credit that covers small test runs of this Actor. The prefilled example is sized so that it completes well inside that credit.

### Input contract

| Field | Type | Default | What it does |
|---|---|---|---|
| `searchQueries` | array of strings | — (prefill `["iphone"]`) | Keywords to search. One run can hold up to 50 keywords; duplicates are removed. |
| `startUrls` | array of URLs | `[]` | Rakuten search URLs (`https://search.rakuten.co.jp/search/...`). Filters in the URL are kept. Other hosts are rejected before any work starts. |
| `sort` | string | `standard` | `standard` (relevance), `2` price low→high, `3` price high→low, `11` price+shipping low→high, `12` price+shipping high→low, `4` newest, `5` most reviews, `6` best review score. Applied to keywords only. |
| `maxItems` | integer 1–3000 | 45 (prefill 20) | Products to return per keyword or URL. The Actor stops paginating as soon as the limit is reached. |
| `includeSponsored` | boolean | `false` | Deliver sponsored placements too, flagged with `isSponsored: true`. |

You must provide at least one keyword or one URL. An empty input fails immediately with a clear message and costs nothing beyond the start event.

**Minimal input (the prefill):**

```json
{
  "searchQueries": ["iphone"],
  "maxItems": 20
}
```

**Price research input — cheapest first, several keywords:**

```json
{
  "searchQueries": ["炊飯器", "ワイヤレスイヤホン", "nintendo switch"],
  "sort": "2",
  "maxItems": 90,
  "includeSponsored": false
}
```

**Reuse filters you set on the site:**

```json
{
  "startUrls": [
    { "url": "https://search.rakuten.co.jp/search/mall/%E7%82%8A%E9%A3%AF%E5%99%A8/?max=10000&s=5" }
  ],
  "maxItems": 45
}
```

### Output examples

All examples below are copied from real runs of this Actor on the Apify platform (September 2026). Nothing is invented or edited except whitespace.

#### Happy output

Input `{"searchQueries": ["iphone"], "maxItems": 20}` — run finished in 39 seconds, 20 products delivered, 0 errors. First two rows:

```json
[
  {
    "itemCode": "rakutenmobile-store:10001518",
    "title": "Apple iPhone 15 SIMフリー 端末本体のみ(機種変更はこちら) 【ご注文から30分経過後はキャンセル不可】【自宅受け取り限定 / 本人確認必須】",
    "price": 112800,
    "currency": "JPY",
    "url": "https://item.rakuten.co.jp/rakutenmobile-store/iphone-15/?variantId=r-sku00000005",
    "imageUrl": "https://thumbnail.image.rakuten.co.jp/@0_mall/rakutenmobile-store/cabinet/product/iphone-15/pc/15-d-c05.jpg",
    "shopName": "楽天モバイル公式 楽天市場店",
    "shopCode": "rakutenmobile-store",
    "shopUrl": "https://www.rakuten.co.jp/rakutenmobile-store/",
    "reviewScore": 4.53,
    "reviewCount": 57,
    "pointsEarned": 1025,
    "freeShipping": true,
    "shippingNote": "3日程度で商品を発送",
    "isSoldOut": false,
    "isSponsored": false,
    "productUrl": "https://product.rakuten.co.jp/product/-/b82bc11a8186652534b9f1c9b86e7284/",
    "page": 1,
    "position": 1,
    "query": "iphone",
    "searchUrl": "https://search.rakuten.co.jp/search/mall/iphone/",
    "scrapedAt": "2026-09-25T15:25:48.835Z"
  },
  {
    "itemCode": "best1mobile:10001535",
    "title": "【国内版SIMフリー・新品未開封/未使用品】 iPhone16 128GB 256GB 512GB 各色 スマホ 本体",
    "price": 139800,
    "currency": "JPY",
    "url": "https://item.rakuten.co.jp/best1mobile/iphone16/?variantId=iphone16-128-black",
    "imageUrl": "https://thumbnail.image.rakuten.co.jp/@0_mall/best1mobile/cabinet/compass1728529823.jpg",
    "shopName": "デジタルトレーディング",
    "shopCode": "best1mobile",
    "shopUrl": "https://www.rakuten.co.jp/best1mobile/",
    "reviewScore": 4.77,
    "reviewCount": 109,
    "pointsEarned": 1270,
    "freeShipping": true,
    "shippingNote": "15:00までの注文で最短9/27(翌日)お届け",
    "isSoldOut": false,
    "isSponsored": false,
    "productUrl": "https://product.rakuten.co.jp/product/-/d8135098d8eab88ae310ef8c6454fc1c/",
    "page": 1,
    "position": 2,
    "query": "iphone",
    "searchUrl": "https://search.rakuten.co.jp/search/mall/iphone/",
    "scrapedAt": "2026-09-25T15:25:49.053Z"
  }
]
```

A larger real run — `{"searchQueries": ["炊飯器"], "maxItems": 150}` — walked four results pages and delivered all 150 products in 83 seconds.

#### Partial output (spending limit reached)

Input `{"searchQueries": ["nintendo switch"], "maxItems": 45}` started with *Max total charge* set to $0.02. The Actor delivered 5 products, saw that the next one would exceed the limit, stopped **before** charging and wrote this free row:

```json
{
  "itemCode": null,
  "title": null,
  "price": null,
  "currency": "JPY",
  "url": null,
  "error": "Stopped at the run's spending limit after 5 result(s). Raise \"Max total charge\" to get more.",
  "scrapedAt": "2026-09-25T15:57:19.918Z"
}
```

The five delivered rows are complete products like the ones above (the first was `daichugame:10012928`, 「Nintendo Switch すぐに遊べるセット」, ¥27,980, 4.48★ from 155 reviews).

#### Failure output

When Rakuten does not return a usable results page after three fresh residential sessions, the keyword gets a free error row and — if every keyword in the run failed — the run still ends as **Succeeded** with the status message "The site blocked all N search(es)… No result was billed, only the run start." — check that message or the `error` field to retry automatically. This row comes from a real early run while the Actor was being built:

```json
{
  "itemCode": null,
  "title": null,
  "price": null,
  "currency": "JPY",
  "url": null,
  "query": "iphone",
  "searchUrl": "https://search.rakuten.co.jp/search/mall/iphone/",
  "error": "\"iphone\": The site did not return a result page after 3 attempts (last HTTP 200, title \"【楽天市場】iphoneの通販\").",
  "scrapedAt": "2026-09-25T15:21:07.095Z"
}
```

No product was charged in that run; only the start event applied. Keywords that simply have no matching products get a similar free row: `No results found for "…".`

### Field dictionary

| Field | Type | Meaning | Notes |
|---|---|---|---|
| `itemCode` | string | `shopCode:itemCode`, Rakuten's stable identity of the listing | Use it as the primary key when you compare runs. `null` only on error rows. |
| `title` | string | Product title exactly as the shop wrote it | Usually Japanese, often with campaign tags in 【】 brackets. Not translated. |
| `price` | number | Price shown on the result card, in yen | Integer. Excludes coupons, member prices and shipping unless the shop included them. |
| `currency` | string | Always `JPY` | Present on every row, including error rows, for schema stability. |
| `url` | string | Item page on item.rakuten.co.jp | For sponsored rows this is the clean item URL, not the ad-tracking redirect. |
| `imageUrl` | string | First product image (thumbnail CDN) | Images are not downloaded by the Actor; the URL is Rakuten's. |
| `shopName` | string | Shop's display name | Japanese. |
| `shopCode` | string | Shop's URL code | Stable; use it to group rows by shop. |
| `shopUrl` | string | Shop storefront URL | Built from `shopCode`. |
| `reviewScore` | number | Average review score, 0–5 | `0` means the item has no reviews yet. |
| `reviewCount` | integer | Number of reviews for the item | |
| `pointsEarned` | integer | Rakuten Super Points earned on this price | Base plus shop multipliers shown on the card; personal SPU bonuses are not included. |
| `freeShipping` | boolean | Card shows free shipping | `null` if Rakuten did not return shipping data. |
| `shippingNote` | string | Rakuten's delivery promise text | Japanese; dates are relative to the run time. |
| `isSoldOut` | boolean | Item marked sold out | |
| `isSponsored` | boolean | Paid placement | Only `true` when *Include sponsored listings* is on. |
| `productUrl` | string | Rakuten catalogue product page | `null` when Rakuten has not matched the item to a catalogue product. |
| `page` | integer | Results page the product appeared on | 1-based. |
| `position` | integer | Position on that page | 1-based, organic order after filtering sponsored rows. |
| `query` | string | Keyword that produced the row | `null` for URL inputs. |
| `searchUrl` | string | First results page URL for this keyword or URL | |
| `scrapedAt` | string | ISO timestamp when the row was written | UTC. |
| `error` | string | Present only on free explanation rows | Never present on paid product rows. |

### Evidence and boundaries

What this Actor observes and what it does not:

- **Source.** Only the public Rakuten Ichiba search results pages at `search.rakuten.co.jp`, the same pages any visitor in Japan sees without logging in. It does not open item pages, carts or account areas.
- **Price is the card price at run time.** Rakuten prices change during campaigns (お買い物マラソン, 楽天スーパーSALE), time sales and point-multiplier days. The row is what the search card said when the Actor loaded it. It is not a checkout total and does not include coupons, member-rank bonuses, shipping for remote areas or tax changes.
- **Points are the card's points.** Personal SPU multipliers depend on the buyer's own Rakuten services and are not visible to a logged-out visitor.
- **Stock is the sold-out flag only.** Rakuten does not publish quantities on search cards.
- **Ranking depends on context.** Relevance order on Rakuten can vary with location, time and personalisation. The Actor uses a Japanese residential connection and no login, which is the closest thing to a neutral shopper view, but two runs minutes apart can order page one differently.
- **Titles are not translated or cleaned.** Shops put campaign tags into titles; you get them as written so nothing is lost.
- **No guarantees about completeness.** Rakuten reports tens of thousands of hits for broad keywords but only lets visitors page through a bounded subset. For broad keywords, narrow the search (genre, price range in a pasted URL) rather than asking for tens of thousands of rows.

How the Actor reaches the page: Rakuten, like most large retailers, protects its pages against automated traffic. The Actor opens each results page in a real, privacy-hardened browser through Japanese residential proxies, waits until Rakuten's own page data is present, and reads it. Images, fonts and video are never downloaded, which keeps the run fast and the traffic small. If a page is not usable, it retries with a fresh session up to three times and then reports the keyword as a free error row instead of guessing.

### Decision routing

| What you see in the data | What it usually means | What to do next |
|---|---|---|
| Your product appears from many shops within a 5–10% price band | Commodity competition; price is the main lever | Track daily and alert on the lowest price per `itemCode` group |
| One shop sells well below everyone else | Clearance, grey import, or pricing error | Check the item page and shop history before matching the price |
| High `pointsEarned` relative to price | Shop is paying for point multipliers | Compare effective price = `price` − points value, not list price alone |
| `isSoldOut: true` for the market leader | Supply gap | Opportunity to win share if you have stock; watch for restock |
| Many `isSponsored` rows for a keyword (with sponsored on) | Competitive, ad-driven keyword | Budget for ads or target long-tail keywords instead |
| `reviewCount` growing fast for a new `itemCode` | A rising product or a shop running a review campaign | Add the item to a watch list; compare against your listing |
| Free error row `No results found` | Keyword too narrow or misspelled | Try the Japanese term or a broader keyword |
| Free error row about attempts | Rakuten did not serve the page to three sessions | Re-run later; it is not charged |

### Commercial playbooks

**1. Daily price watch for a product line.** Save a task with your 10–30 product keywords, `sort: 2` (cheapest first) and `maxItems: 45`. Schedule it daily. In your sheet, group by `itemCode`, keep the minimum `price` per day, and alert when a competitor drops below your floor. Effective price for Japanese buyers is `price` minus points, so add a column for that.

**2. Reseller and MAP monitoring for brands.** Search your brand name and model numbers. Group rows by `shopCode`. Shops that are not on your authorised list, or that sell under your minimum advertised price, are your follow-up list. Store `url` and `scrapedAt` as evidence.

**3. Category sizing before entering Japan.** Run one broad keyword per sub-category with `maxItems: 300` and `sort: standard`. Count distinct shops, look at the price distribution and the share of items with more than 100 reviews. This tells you in an afternoon whether the category is fragmented or dominated.

**4. Campaign tracking.** Rakuten's big sales change prices and points for days. Run the same task hourly during お買い物マラソン and compare `price` and `pointsEarned` to the pre-sale baseline to see who discounts and who only adds points.

**5. Content and affiliate pages.** Pull the top products by `sort: 6` (best review score) for a keyword, filter to `reviewCount` ≥ 50, and use the fresh price, rating and item link in your comparison page. Refresh weekly.

### Integration recipes

**Apify API (any language).** Start a run and get items in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/zinin~rakuten-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries": ["炊飯器"], "maxItems": 45, "sort": "2"}'
```

**Python client.**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("zinin/rakuten-scraper").call(run_input={
    "searchQueries": ["ワイヤレスイヤホン"],
    "maxItems": 90,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if not item.get("error"):
        print(item["price"], item["shopName"], item["url"])
```

**JavaScript client.**

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('zinin/rakuten-scraper').call({ searchQueries: ['nintendo switch'], maxItems: 45 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.filter((i) => !i.error).length, 'products');
```

**Google Sheets.** Use Apify's Google Sheets integration on a saved task: every finished run appends rows to your sheet. Filter out rows where `error` is not empty.

**Make, n8n and Zapier.** Use the Apify app: trigger "Watch Actor runs" (or "Watch task runs"), then "Get dataset items", then your action — Slack message when the minimum price drops, a row in Airtable, a record in your CRM.

**Webhooks.** Add a webhook for `ACTOR.RUN.SUCCEEDED` pointing at your endpoint; it receives the run object with `defaultDatasetId`, and you fetch items from there.

**AI agents (MCP).** The Actor is available as a tool through the Apify MCP server (`https://mcp.apify.com`). An agent can call it with a keyword and use the returned rows to answer "what does X cost on Rakuten right now". Keep `maxItems` small for interactive use.

### Comparing runs over time

Most buyers use this Actor to see change, not a single snapshot. A reliable change-detection setup looks like this:

1. **Fix the input.** Save a task with the exact keywords, sort order and `maxItems`. Changing any of them changes which products are in scope and makes day-to-day comparison noisy.
2. **Key on `itemCode`.** It is `shopCode:itemCode`, which Rakuten keeps stable for the life of a listing. Titles change with every campaign; positions move every hour.
3. **Store `scrapedAt` with every row.** It is the observation time. Two rows with the same `itemCode` and different `price` are a price change between those two timestamps.
4. **Separate "missing" from "sold out".** If an `itemCode` disappears from the results, it may have dropped out of the page window you requested rather than been delisted. `isSoldOut: true` is the only explicit availability signal. For important items, request more pages so the item stays in scope.
5. **Compare like with like.** Relevance order moves; if you need a stable universe, use `sort: 2` (price) or a pasted URL restricted to a genre and price band.
6. **Watch points, not only price.** During campaigns many shops keep the price and raise `pointsEarned`. A change in points is a real change in what the buyer pays.

A simple daily sheet: one tab per day of rows, a pivot of minimum `price` per `itemCode`, and a conditional format that highlights a drop of more than 5%. That is enough to catch most competitor moves on Rakuten within a day.

**Typical signals worth an alert:** a new `shopCode` appearing in the top 10 for your brand keyword; the cheapest price for an `itemCode` group falling below your floor; `isSoldOut` flipping to `true` for the leader; `reviewCount` jumping by more than 20 in a week for a competitor item.

### Scheduling and budget planning

A scheduled task is the usual way to run this Actor. Three things decide what a schedule costs and how useful it is:

- **One run, many keywords.** Put all keywords into one run instead of starting one run per keyword. The start event is charged once per run (per GB of memory), so ten keywords in one run pay one start, ten separate runs pay ten.
- **Size by pages, not by wishes.** Rakuten shows 45 products per page. `maxItems: 45` or `90` reads whole pages; `maxItems: 50` reads two pages and throws most of the second away. The price is per delivered row, so this is about run time, not money.
- **Daily is enough for most price work.** Rakuten shop prices change with campaigns (Super SALE, Marathon, 5 and 0 days), not every hour. A daily run at a fixed time gives a clean series; during a campaign week, add a second run in the evening.

**Worked budget.** Five brand keywords, 60 products each, once a day: 2 × $0.02 + 300 × $0.006 = **$1.84 per day**, about **$55 per month**. The same schedule once a week costs about **$8 per month**. Set *Max total charge* on the task to a little above the expected run cost; the Actor stops cleanly at that limit and writes a free row saying so, so a mistaken keyword list can never run away with your budget.

### Operating guide

- **Memory.** The default 2 GB is enough; more memory does not make pages load faster and increases the start fee.
- **Run size.** One results page ≈ 45 products and a few seconds. A run with 10 keywords × 45 products typically finishes in a few minutes.
- **Scheduling.** Daily is enough for most price work; hourly makes sense only during sales events.
- **Stable keys.** Compare runs on `itemCode`, not on `title` (shops edit titles constantly) and not on `position` (ranking moves).
- **Many keywords.** Put up to 50 keywords into one run rather than starting 50 runs — you pay one start fee instead of fifty.
- **Timeouts.** The default run timeout is 30 minutes. For very large jobs (thousands of products), raise the timeout or split keywords across runs.
- **Retries.** A keyword that failed with an attempts error is safe to run again; nothing was charged for it.

### Troubleshooting

**The run finished but I got fewer products than `maxItems`.** Rakuten had fewer matching products, or only lets visitors page through part of a very broad result set. Narrow the search with a pasted URL (genre, price range) to reach deeper items.

**I see `No results found`.** Check the spelling, try the Japanese term (`イヤホン` instead of `earphones`) or remove a filter from the pasted URL.

**I see an error about attempts.** Rakuten did not serve a usable page to three separate sessions. This is rare and temporary; start the run again. The failed keyword was not charged.

**The run stopped early with a spending-limit row.** Your *Max total charge* was reached. Raise it in the run options or lower `maxItems`.

**Prices look different from what I see in my browser.** Your browser may be logged in (member prices, points) or outside Japan. The Actor sees Rakuten as a logged-out shopper in Japan at the moment of the run.

**My pasted URL was rejected.** Only `https://search.rakuten.co.jp/search/...` result URLs are accepted. Item pages and shop pages are not search result pages.

### FAQ

**Do I need a Rakuten account or Rakuten API application ID?** No. The Actor reads public search pages; there is nothing to register.

**Is this the official Rakuten API?** No. It is an independent tool that reads the public website. Rakuten's official Ichiba Item Search API requires an application ID and has its own rate limits and field set; this Actor needs neither and returns what the website shows, including sponsored flags and delivery promises.

**Can I get product descriptions, all images or variant prices?** Not in this Actor. It reads search results, which is what price and assortment work needs at scale. The `url` field takes you to the item page.

**How fresh is the data?** It is read at run time. Schedule the Actor as often as you need fresh prices.

**Can I search other Rakuten sites (Rakuten France, Rakuten Books, Rakuten Travel)?** No, this Actor covers Rakuten Ichiba Japan only.

**Can I run it from outside Japan?** Yes. The Actor always uses a Japanese residential connection, so your own location does not matter.

**What happens if Rakuten changes its page?** Rows would stop appearing and keywords would return free error rows rather than wrong data. The Actor is monitored and updated.

**Why do some titles contain 【】 tags?** Shops put campaign information into titles. The Actor keeps titles exactly as written.

### 日本語での説明（楽天市場スクレイパー）

楽天市場の検索結果を、キーワードまたは検索URLから自動で取得するツールです。楽天会員ログインもAPIキーも不要です。

- **取得できる項目**：商品名、価格（円）、ショップ名・ショップコード、レビュー平均点・件数、獲得ポイント、送料無料フラグ、配送目安、売り切れフラグ、広告（PR）フラグ、商品URL、画像URL、検索順位。
- **使い方**：「Search keywords」に「炊飯器」「ワイヤレスイヤホン」「iphone」などのキーワードを1行に1つ入力し、取得件数（Max products）を指定して「Start」を押すだけです。楽天の検索画面で絞り込んだURL（ジャンル・価格帯・送料無料など）をそのまま貼り付けることもできます。
- **並び順**：標準、安い順、高い順、送料込みの安い順・高い順、新着順、レビュー件数順、レビュー評価順に対応しています。
- **料金**：取得できた商品1件ごとの従量課金です。検索結果なし・取得失敗・予算上限に達した旨のお知らせ行は無料です。
- **用途**：価格調査、競合ショップの監視、転売・並行輸入のチェック、カテゴリの市場調査、アフィリエイト記事の価格更新など。
- **出力形式**：JSON、CSV、Excel。Google スプレッドシート、Make、n8n、Zapier、API 連携にも対応しています。

検索キーワードの例：楽天 価格調査、楽天市場 スクレイピング、楽天 商品一覧 CSV、楽天 競合 価格 監視、楽天 ランキング 取得。

### Sources and rights

- Data comes from publicly accessible Rakuten Ichiba search result pages. The Actor does not log in, does not bypass paywalls and does not collect personal data about shoppers; shop names are business names published by Rakuten.
- Product titles, prices and images belong to Rakuten Group, Inc. and the respective shops. Use the data in line with Rakuten's terms and the laws that apply to you, especially for republication. For large-scale commercial reuse, consider Rakuten's official APIs and partner programmes.
- This Actor is not affiliated with, endorsed by or sponsored by Rakuten Group, Inc. "Rakuten" and 「楽天市場」 are trademarks of their owner and are used here only to describe the data source.
- Report a bug or ask for a feature in the **Issues** tab of this Actor. Custom fields or other Japanese marketplaces can be built on request.

### More marketplace scrapers from the same author

| Actor | What it gives you |
|---|---|
| [Mercado Libre Scraper](https://apify.com/zinin/mercadolibre-scraper) | Latin American product prices and sellers |
| [bol.com Scraper](https://apify.com/zinin/bol-scraper) | Dutch and Belgian product prices and sellers |
| [Wildberries Scraper](https://apify.com/zinin/wildberries-scraper) | Russian marketplace prices, brands and sellers |
| [Shopify Store Price & Catalog Change Monitor](https://apify.com/zinin/shopify-price-change-monitor) | Price and catalogue changes on Shopify stores |

# Actor input Schema

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

Keywords to search on Rakuten Ichiba (search.rakuten.co.jp). Japanese or English both work, e.g. "iphone", "炊飯器", "nintendo switch". One keyword per line.

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

Paste search result URLs from search.rakuten.co.jp to reuse filters you set on the site (genre, price range, shipping). Leave empty when using keywords.

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

Order of results for keyword searches. Ignored for pasted URLs, which keep their own sort.

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

How many products to return for each keyword or URL. One results page holds about 45 products.

## `includeSponsored` (type: `boolean`):

Rakuten mixes paid (sponsored) listings into results. Off by default so you get organic results only; sponsored rows are flagged with isSponsored when included.

## Actor input object example

```json
{
  "searchQueries": [
    "iphone"
  ],
  "startUrls": [],
  "sort": "standard",
  "maxItems": 20,
  "includeSponsored": false
}
```

# Actor output Schema

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

Dataset items produced by this run.

# 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 = {
    "searchQueries": [
        "iphone"
    ],
    "startUrls": [],
    "sort": "standard",
    "maxItems": 20,
    "includeSponsored": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("zinin/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 = {
    "searchQueries": ["iphone"],
    "startUrls": [],
    "sort": "standard",
    "maxItems": 20,
    "includeSponsored": False,
}

# Run the Actor and wait for it to finish
run = client.actor("zinin/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 '{
  "searchQueries": [
    "iphone"
  ],
  "startUrls": [],
  "sort": "standard",
  "maxItems": 20,
  "includeSponsored": false
}' |
apify call zinin/rakuten-scraper --silent --output-dataset

```

## MCP server setup

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