# Rakuten Ichiba Scraper (`automation-lab/rakuten-ichiba-scraper`) Actor

Scrape Rakuten Ichiba product listings for prices, shops, ratings, reviews, images, badges, shipping snippets, and product URLs.

- **URL**: https://apify.com/automation-lab/rakuten-ichiba-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Rakuten Ichiba Scraper

Scrape public Rakuten Ichiba Japan search and category pages for structured product listing data.

Rakuten Ichiba is one of Japan's largest ecommerce marketplaces. This actor turns public listing pages into a clean Apify dataset with product titles, prices, shop names, ratings, review counts, image URLs, promotional badges, Rakuten points snippets, shipping text, ranking positions, and product URLs.

Use it when you need repeatable Rakuten product data without manually copying Japanese search result pages.

### What this actor does

Rakuten Ichiba Scraper requests public Rakuten search, mall, ranking, and category listing pages, extracts visible product cards, follows pagination, and saves each product listing as one dataset item.

It supports two input styles:

- 🔎 Search keywords, such as `カメラ`, `ノートパソコン`, or `スマートウォッチ`
- 🔗 Direct Rakuten URLs, such as search pages, category pages, or already-filtered result pages

The actor is HTTP-based, so it is lighter and faster than browser-based scrapers while still capturing the core product listing data visible on Rakuten pages.

### Why use it

Rakuten pages are optimized for shoppers, not for repeatable analysis. Product cards contain mixed Japanese text, prices, points, shipping badges, seller snippets, and ranking positions that are hard to copy consistently.

This actor gives you:

- ✅ Clean product rows instead of manual copy/paste
- ✅ Ranking positions for keyword and category monitoring
- ✅ Numeric prices plus original Japanese price text
- ✅ Shop and review signals for marketplace research
- ✅ Image and product URLs for catalog matching
- ✅ Timestamps so recurring runs can be compared over time
- ✅ Apify dataset export to JSON, CSV, Excel, XML, or API pipelines

### Who is it for

This actor is useful for teams that monitor Japanese ecommerce data:

- Ecommerce analysts tracking competitive pricing on Rakuten Ichiba
- Marketplace sellers checking category visibility and assortment
- Brands monitoring authorized and gray-market shop listings
- Retail research teams comparing Rakuten with Amazon Japan or Yahoo Shopping
- Agencies preparing category reports for clients entering Japan
- Catalog enrichment teams matching products by title, image, and URL
- Lead generation teams identifying shops active in a product niche

### Typical use cases

- Track competitor prices on Rakuten Ichiba every day.
- Monitor product availability and shipping snippets.
- Collect marketplace assortment for a keyword or category.
- Watch review counts and ratings for popular products.
- Build lead lists of shops selling products in a category.
- Compare Rakuten pricing with Amazon, Yahoo Shopping, or your own store.
- Export search result snapshots for BI dashboards.
- Detect new promotional badges, points campaigns, or free-shipping offers.

### Data extraction table

| Field | Type | Description |
| --- | --- | --- |
| `sourceType` | string | Whether the row came from a keyword search or direct URL. |
| `searchQuery` | string | Search keyword used for keyword runs. |
| `sourceUrl` | string | Rakuten result page URL that produced the row. |
| `page` | number | Rakuten result page number. |
| `position` | number | Overall position in the run. |
| `pagePosition` | number | Position on the current page. |
| `title` | string | Product listing title. |
| `url` | string | Product detail URL on Rakuten. |
| `price` | number | Parsed numeric JPY price when available. |
| `priceText` | string | Original visible price text, such as `24,800円`. |
| `currency` | string | Currency code, currently `JPY`. |
| `shopName` | string | Shop or seller name when visible. |
| `rating` | number | Product rating when visible on the card. |
| `reviewCount` | number | Review count when visible on the card. |
| `imageUrl` | string | Main product image URL. |
| `badges` | array | Promotional labels, badges, coupon text, shipping labels, or points snippets. |
| `pointsText` | string | Rakuten points text when visible. |
| `shippingText` | string | Shipping or availability snippet. |
| `rawText` | string | Compact visible card text for QA/debugging. |
| `scrapedAt` | string | ISO timestamp for the scrape. |

### Example output

```json
{
  "sourceType": "search",
  "searchQuery": "カメラ",
  "sourceUrl": "https://search.rakuten.co.jp/search/mall/%E3%82%AB%E3%83%A1%E3%83%A9/",
  "page": 1,
  "position": 1,
  "pagePosition": 1,
  "title": "Example digital camera listing",
  "url": "https://item.rakuten.co.jp/example-shop/example-item/",
  "price": 24800,
  "priceText": "24,800円",
  "currency": "JPY",
  "shopName": "Example Shop",
  "rating": 4.5,
  "reviewCount": 128,
  "imageUrl": "https://thumbnail.image.rakuten.co.jp/example.jpg",
  "badges": ["送料無料", "ポイント"],
  "pointsText": "ポイント5倍",
  "shippingText": "送料無料",
  "rawText": "Example compact card text",
  "scrapedAt": "2026-05-19T08:00:00.000Z"
}
````

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

This actor uses pay-per-event pricing. Each run has a small start event and then a result event for every product listing saved to the dataset.

The pricing is designed for both small tests and larger recurring monitoring jobs. You can control your spend by setting `maxResults` before the run starts.

Cost tips:

- Start with 20-50 products to confirm the keyword or URL is correct.
- Use one keyword per scheduled monitoring run if you need stable ranking comparisons.
- Increase `maxResults` only after checking that the first dataset rows contain the product category you expect.
- Keep proxy enabled for reliability; Rakuten may return short reference pages to some direct traffic.

### How to scrape Rakuten Ichiba

1. Open the actor in Apify Console.
2. Enter one or more Rakuten search keywords in `searchQueries`, or paste direct Rakuten result URLs in `startUrls`.
3. Set `maxResults` to the number of product listings you want.
4. Keep `useApifyProxy` enabled for Rakuten reliability.
5. Leave `proxyGroups` as `RESIDENTIAL` and `proxyCountryCode` as `JP` unless you know another route works.
6. Click **Start**.
7. Open the default dataset after the run finishes.
8. Export the data as JSON, CSV, Excel, XML, RSS, or consume it through the dataset API.

### Input parameters

| Parameter | Type | Required | Description |
| --- | --- | --- | --- |
| `searchQueries` | array | No\* | Rakuten keywords to search. Japanese keywords usually work best. |
| `startUrls` | array | No\* | Direct Rakuten search/category URLs. |
| `maxResults` | integer | No | Maximum product listings to save across all inputs. |
| `useApifyProxy` | boolean | No | Enables Apify Proxy. Recommended for Rakuten. |
| `proxyGroups` | array | No | Proxy groups to use. Prefill is `RESIDENTIAL`. |
| `proxyCountryCode` | string | No | Proxy country code. Prefill is `JP`. |
| `maxRequestRetries` | integer | No | Retry attempts for failed or blocked requests. |

\*Provide at least one `searchQueries` item or one `startUrls` item.

### Search queries

Use `searchQueries` for normal keyword searches. Japanese keywords usually produce the best results because Rakuten Ichiba is a Japanese marketplace. English terms can also work when Rakuten has matching product titles.

Example:

```json
{
  "searchQueries": ["ノートパソコン", "カメラ"],
  "maxResults": 50
}
```

### Direct URLs

Use `startUrls` when you already have a Rakuten search, mall, ranking, or category URL. The actor will request the URL and paginate with Rakuten's `p` parameter.

Example:

```json
{
  "startUrls": [
    { "url": "https://search.rakuten.co.jp/search/mall/%E3%82%AB%E3%83%A1%E3%83%A9/" }
  ],
  "maxResults": 100
}
```

### Recommended settings

For a first run, keep `maxResults` between 20 and 50. For recurring monitoring, set one keyword or one URL per run when you want stable ranking comparisons. For broad research, provide multiple keywords and increase `maxResults` after validating the first sample.

### Proxy settings

Rakuten can return short reference pages or sparse HTML to some datacenter traffic. The actor therefore enables Apify Proxy by default. Residential proxies are prefilled because they are usually more reliable for marketplace pages.

If you already know your traffic source works without proxy, you can disable `useApifyProxy`. For production use, leave it enabled.

### Pagination

The actor paginates by adding or updating Rakuten's `p` query parameter. It stops when it reaches `maxResults`, when a page no longer contains product cards, or when Rakuten returns no additional listings.

### Data freshness

The actor scrapes live public pages. Prices, shipping snippets, point campaigns, and availability can change frequently. Use `scrapedAt` to identify when each row was collected.

### Ranking analysis

Use `position` for the overall run order. Use `page` and `pagePosition` when you need to compare Rakuten page layout or detect ranking movement over time.

### Shop monitoring

The `shopName` field helps identify sellers active in a category. Not every Rakuten card exposes the shop name in the same markup, so this field can be empty for some rows.

### Review monitoring

When visible, `rating` and `reviewCount` are parsed from the listing card. If Rakuten hides review data for a layout, the fields are omitted instead of guessed.

### Images

The actor extracts the first product image URL from each card. Use `imageUrl` for visual QA, catalog matching, or downstream enrichment.

### Badges and promotions

Rakuten cards often contain many promotional snippets. The actor collects short visible labels that look like coupons, points, sales, ranking badges, used/new labels, or free-shipping badges.

### Tips

- Use Japanese search terms for better coverage.
- Paste a filtered Rakuten URL when you need a specific category, price range, or sort order.
- Keep scheduled monitoring inputs stable so ranking changes are comparable.
- Treat optional fields as optional; Rakuten does not show every signal on every card.
- Inspect `rawText` when troubleshooting a layout or missing field.
- Use `sourceUrl` and `page` to trace a row back to the exact result page.

### Limitations

This actor focuses on listing cards, not full product detail pages. It does not log in, add products to carts, bypass paywalls, or access private seller dashboards. It extracts only information visible on public Rakuten pages.

### Anti-bot behavior

If Rakuten returns a short reference page, the run log will include a warning. In that case, keep Apify Proxy enabled, use residential proxies, reduce the number of keywords in one run, and retry later.

### Performance

The actor is HTTP-based and does not run a browser. This keeps compute use low compared with Playwright actors. Network and proxy cost are the main cost drivers for large jobs.

### Dataset export

After a run, export the dataset as JSON, CSV, Excel, XML, or RSS from Apify. CSV is convenient for spreadsheets. JSON is recommended for API pipelines.

### Integrations

You can connect this actor to repeatable workflows:

- **Scheduled price monitoring**: run the same keyword every morning, export CSV, and compare `price`, `position`, and `shopName` against yesterday's dataset.
- **BI dashboard pipeline**: trigger the actor from an orchestrator, read the dataset API, and load product rows into BigQuery, Snowflake, Airtable, or Google Sheets.
- **Competitive alerting**: use an Apify webhook after each successful run, then send low-price or new-shop matches to Slack, email, or your internal alert system.
- **Catalog enrichment**: join `title`, `imageUrl`, and `url` with internal SKU matching logic.
- **Agency reporting**: run category URLs for multiple clients and export separate datasets for each recurring report.

### API usage

You can run the actor from the Apify API, schedule it, or integrate it with webhooks. A common workflow is to schedule daily keyword runs and export the dataset to your analytics warehouse.

#### Node.js example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/rakuten-ichiba-scraper').call({
  searchQueries: ['カメラ'],
  maxResults: 20,
  useApifyProxy: true,
  proxyGroups: ['RESIDENTIAL'],
  proxyCountryCode: 'JP'
});
console.log(`Dataset: https://api.apify.com/v2/datasets/${run.defaultDatasetId}/items`);
```

#### Python example

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/rakuten-ichiba-scraper').call(run_input={
    'searchQueries': ['カメラ'],
    'maxResults': 20,
    'useApifyProxy': True,
    'proxyGroups': ['RESIDENTIAL'],
    'proxyCountryCode': 'JP',
})
print(run['defaultDatasetId'])
```

#### cURL example

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~rakuten-ichiba-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"searchQueries":["カメラ"],"maxResults":20,"useApifyProxy":true,"proxyGroups":["RESIDENTIAL"],"proxyCountryCode":"JP"}'
```

### Example API input

```json
{
  "searchQueries": ["スマートウォッチ"],
  "maxResults": 200,
  "useApifyProxy": true,
  "proxyGroups": ["RESIDENTIAL"],
  "maxRequestRetries": 3
}
```

### MCP

Use Apify's hosted MCP endpoint when connecting Claude Code, Claude Desktop, Cursor, VS Code, or another MCP-compatible client. The tool URL should include this actor slug so the client exposes the Rakuten Ichiba tool directly.

#### Claude Code MCP setup

```bash
claude mcp add --transport http apify-rakuten-ichiba "https://mcp.apify.com?tools=automation-lab/rakuten-ichiba-scraper"
```

#### Claude Desktop, Cursor, and VS Code MCP JSON

```json
{
  "mcpServers": {
    "apify-rakuten-ichiba": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/rakuten-ichiba-scraper"
    }
  }
}
```

After connecting, authenticate with your Apify account/token as required by your MCP client.

#### Example MCP prompts

Try these example prompts after connecting the Apify MCP server:

- "Run Rakuten Ichiba Scraper for カメラ with 30 results and summarize the cheapest products."
- "Scrape this Rakuten category URL and return the top shops by listing count."
- "Monitor ノートパソコン on Rakuten Ichiba and compare prices with the previous dataset."

### Legality

The actor collects publicly visible Rakuten Ichiba listing information. Use it responsibly, respect Rakuten's terms, avoid excessive request volumes, and do not use the output for spam, deceptive activity, or privacy-invasive profiling. You are responsible for ensuring your use case complies with applicable laws and marketplace policies.

### Related scrapers

Other Automation Lab actors that can support ecommerce and marketplace workflows:

- [Amazon Scraper](https://apify.com/automation-lab/amazon-scraper) — collect Amazon product search and listing data.
- [Shopee Reviews Scraper](https://apify.com/automation-lab/shopee-reviews-scraper) — gather Shopee review data for product research.
- [Made-in-China Scraper](https://apify.com/automation-lab/made-in-china-scraper) — extract supplier and product listings from Made-in-China.
- [Trustpilot Scraper](https://apify.com/automation-lab/trustpilot-scraper) — monitor company reviews and ratings.

Use Rakuten Ichiba Scraper when your target is public product listing data from Rakuten Japan.

### Troubleshooting

If a run returns no data, check the log for block-page warnings and verify that the input URL opens in a normal browser. Try a smaller `maxResults`, keep `useApifyProxy` enabled, and use Japanese keywords when possible.

If only some fields are empty, Rakuten probably did not show those values on that particular listing card. The actor does not invent missing ratings, review counts, or shop names.

### Quality notes

Rakuten changes markup over time. The extractor uses multiple selector and text-pattern fallbacks instead of depending on one CSS class. The `rawText` field is included to make troubleshooting easier when Rakuten tests a new layout.

### Best practices

Start with a small run. Inspect the output. Then scale to more keywords or pages. For tracking, keep the same query spelling and sorting URL between runs.

### Support

If you need help, include the Apify run URL, your input JSON, and a short explanation of what you expected to see. This makes it possible to reproduce the issue quickly.

### Changelog

- `0.1.0` — Initial release for Rakuten Ichiba search/category product listing cards.

### FAQ

#### Does it scrape product detail pages?

No. Version 0.1 extracts listing-card data from public search/category pages.

#### Can I scrape by category?

Yes. Paste a Rakuten category or search URL into `startUrls`.

#### Is Japanese input required?

No, but Japanese keywords usually provide better Rakuten coverage.

#### Why are some fields empty?

Rakuten does not show every detail on every card. Empty optional fields mean the value was not visible or could not be parsed safely.

#### Can I use this for price monitoring?

Yes. Schedule recurring runs and compare `price`, `position`, `shopName`, and `scrapedAt` over time.

# Actor input Schema

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

Rakuten Ichiba keywords to search. Use Japanese or English terms supported by Rakuten.

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

Optional Rakuten search/category URLs, for example https://search.rakuten.co.jp/search/mall/camera/

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

Maximum number of product listing cards to save across all queries and URLs.

## `useApifyProxy` (type: `boolean`):

Recommended. Rakuten may return short reference/block pages to direct datacenter traffic.

## `proxyGroups` (type: `array`):

Apify Proxy groups to use when proxying requests. RESIDENTIAL is recommended for Rakuten.

## `proxyCountryCode` (type: `string`):

Two-letter country code for Apify Proxy. JP is recommended for Rakuten Japan.

## `maxRequestRetries` (type: `integer`):

Number of retry attempts for failed or blocked requests.

## Actor input object example

```json
{
  "searchQueries": [
    "ノートパソコン"
  ],
  "startUrls": [
    {
      "url": "https://search.rakuten.co.jp/search/mall/%E3%82%AB%E3%83%A1%E3%83%A9/"
    }
  ],
  "maxResults": 20,
  "useApifyProxy": true,
  "proxyGroups": [
    "RESIDENTIAL"
  ],
  "proxyCountryCode": "JP",
  "maxRequestRetries": 3
}
```

# Actor output Schema

## `overview` (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 = {
    "searchQueries": [
        "ノートパソコン"
    ],
    "startUrls": [
        {
            "url": "https://search.rakuten.co.jp/search/mall/%E3%82%AB%E3%83%A1%E3%83%A9/"
        }
    ],
    "maxResults": 20,
    "useApifyProxy": true,
    "proxyGroups": [
        "RESIDENTIAL"
    ],
    "proxyCountryCode": "JP",
    "maxRequestRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/rakuten-ichiba-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": ["ノートパソコン"],
    "startUrls": [{ "url": "https://search.rakuten.co.jp/search/mall/%E3%82%AB%E3%83%A1%E3%83%A9/" }],
    "maxResults": 20,
    "useApifyProxy": True,
    "proxyGroups": ["RESIDENTIAL"],
    "proxyCountryCode": "JP",
    "maxRequestRetries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/rakuten-ichiba-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [
    "ノートパソコン"
  ],
  "startUrls": [
    {
      "url": "https://search.rakuten.co.jp/search/mall/%E3%82%AB%E3%83%A1%E3%83%A9/"
    }
  ],
  "maxResults": 20,
  "useApifyProxy": true,
  "proxyGroups": [
    "RESIDENTIAL"
  ],
  "proxyCountryCode": "JP",
  "maxRequestRetries": 3
}' |
apify call automation-lab/rakuten-ichiba-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/rakuten-ichiba-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Rakuten Ichiba Scraper",
        "description": "Scrape Rakuten Ichiba product listings for prices, shops, ratings, reviews, images, badges, shipping snippets, and product URLs.",
        "version": "0.1",
        "x-build-id": "uoqxkIy9MDCenSYBM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~rakuten-ichiba-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-rakuten-ichiba-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~rakuten-ichiba-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-rakuten-ichiba-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~rakuten-ichiba-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-rakuten-ichiba-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQueries": {
                        "title": "🔎 Search queries",
                        "type": "array",
                        "description": "Rakuten Ichiba keywords to search. Use Japanese or English terms supported by Rakuten.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "🔗 Direct Rakuten URLs",
                        "type": "array",
                        "description": "Optional Rakuten search/category URLs, for example https://search.rakuten.co.jp/search/mall/camera/",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Max products",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of product listing cards to save across all queries and URLs.",
                        "default": 50
                    },
                    "useApifyProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Recommended. Rakuten may return short reference/block pages to direct datacenter traffic.",
                        "default": true
                    },
                    "proxyGroups": {
                        "title": "Proxy groups",
                        "type": "array",
                        "description": "Apify Proxy groups to use when proxying requests. RESIDENTIAL is recommended for Rakuten.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyCountryCode": {
                        "title": "Proxy country code",
                        "type": "string",
                        "description": "Two-letter country code for Apify Proxy. JP is recommended for Rakuten Japan.",
                        "default": "JP"
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of retry attempts for failed or blocked requests.",
                        "default": 3
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```