# ikyu.com Reviews Scraper (一休) (`boncross/ikyu-reviews`) Actor

Scrape ikyu.com (一休) reviews for hotels and ryokan. Add hotel URLs, ids or names and get overall and six aspect ratings, title, full text, posting and stay dates, room, meals, party size, hotel reply, photos and likes, in English or Japanese. It can return only new reviews. $2.50 per 1,000 reviews.

- **URL**: https://apify.com/boncross/ikyu-reviews.md
- **Developed by:** [BonCross API](https://apify.com/boncross) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.75 / 1,000 review-scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## ikyu.com Reviews Scraper (一休)

### What is ikyu.com Reviews Scraper (一休)?

ikyu.com Reviews Scraper collects the guest reviews of any hotel or ryokan on ikyu.com (一休), and you choose how to read them: in ikyu's English, or in the Japanese the guest wrote. Give it hotel URLs, ikyu ids or hotel names. A run across 99 hotels returned 7,876 reviews in 25 seconds.

What makes these reviews worth having:

- Each one is scored seven ways. Next to the overall rating you get room, service, bath, facilities, meals and satisfaction, for the review and for the hotel as a whole.
- You know what the guest actually booked: the room, the meal plan, the party size and the date of the stay.
- The hotel's reply comes with the review, so you can measure who answers and what they say.
- Partner-site reviews are included and labelled. On two properties, 38 of 72 reviews came from Yahoo! Travel, and the `site` column tells you which is which. One switch limits a run to ikyu's own.
- There are no empty reviews to pay for. All 168 reviews we checked across five properties had text.
- $2.50 per 1,000 reviews on the Free plan and $1.75 on Business, and a scheduled run can skip everything you've already had for free.

**BonCross Verified** means we tested this actor against the live site before release and kept the record:

- 26 of 26 live checks on its inputs and filters passed on 7 October 2026
- 12 hotels run the same day: 194 reviews, 1 error row
- Charges checked against the 194 reviews
- A hotel name ikyu doesn't list gets a row saying so

### What can you do with ikyu reviews?

- Track guest sentiment for one property or a competitor set, month by month
- Compare ryokan with hotels on the meal and bath scores, which a single star rating hides
- Find recurring complaints in the Japanese originals, where nothing is lost to translation
- Measure how often a property replies to its guests
- Alert on a new low rating with a daily run that returns only new reviews
- Feed review text into sentiment or topic models, in either language
- Pull just the hotel-level scores for a long list of properties, without the reviews

### What review data do you get?

| | |
|---|---|
| 📝 Review title and full text | ⭐ Overall rating out of 5 |
| Six aspect ratings per review | 🗓️ Posting date and time |
| 🛏️ Room booked and room count | 🍽️ Meal plan on the stay |
| 👥 Number of guests | Stay date |
| 💬 Hotel's reply to the review | 👍 Likes on the review |
| Reviewer handle and member flag | Review id and source site |
| 🏨 Hotel name, id and URL | Hotel area, prefecture and type |
| Hotel overall rating and aspect ratings | Hotel review count |
| The site's AI review summary | 🖼️ Photos attached to reviews |
| Total reviews in the feed | Sort order the row was fetched with |

### How to scrape ikyu.com reviews

You don't need to write any code. It's a form in, a table out.

1. [Open a free Apify account](https://console.apify.com/sign-up), then go to [ikyu.com Reviews Scraper](https://apify.com/boncross/ikyu-reviews).
2. List your hotels: ikyu URLs, 8-digit ids, or names in English or Japanese.
3. Say how many reviews you want per hotel, and choose English or Japanese.
4. Press Start. When it's done, export the reviews to Excel, CSV or JSON.

### ⬇️ Input

Start with the hotels. `https://www.ikyu.com/en-us/00000146/`, `00000146` and a hotel name are all accepted, and more links than you'd want to paste can be loaded in "Start URLs (bulk upload)" from a file, a Google Sheet or a remote list. The two lists are combined.

By default you get the 100 most recent reviews per hotel, in English, from ikyu and its partner site, with the hotel's own scores repeated on each row.

Two limits apply. "Max reviews per hotel" (1 to 20,000, default 100) is per hotel: ten hotels at 50 each returns 500. "Maximum results for the whole run" caps the total across all hotels, and 0 leaves it uncapped. You aren't charged for anything beyond either limit.

#### One hotel, its 500 most recent reviews

```json
{
  "hotels": ["https://www.ikyu.com/en-us/00000146/"],
  "maxReviewsPerHotel": 500,
  "sort": "recent"
}
```

#### Japanese originals, with ikyu's AI summary and the hotel record

```json
{
  "hotels": ["Hiiragiya", "00000284"],
  "language": "ja",
  "maxReviewsPerHotel": 200,
  "includeAiSummary": true,
  "includeHotelDetails": true
}
```

#### Only the critical reviews, three stars and under

```json
{
  "hotels": ["00000146", "00000630"],
  "maxRating": 3,
  "maxReviewsPerHotel": 300
}
```

#### A daily watch that returns only reviews you haven't had

```json
{
  "hotels": ["00000146", "00000284", "00000630"],
  "maxReviewsPerHotel": 100,
  "reviewedAfter": "2026-06-01",
  "dedupStoreName": "ikyu-reviews-seen"
}
```

| Field | Notes |
|---|---|
| `hotels`, `startUrls` | ikyu URLs, 8-digit ids or names, typed or loaded in bulk. |
| `maxReviewsPerHotel`, `maxItems` | The per-hotel cap (default 100) and the run-wide cap (default 0, no cap). |
| `sort` | `recent` (newest first, the default) or `recommended` (ikyu's own ranking). |
| `sources` | `all` (the default) includes reviews from ikyu's partner site, Yahoo! Travel. `ikyu` keeps ikyu.com bookings only. |
| `minRating`, `maxRating` | A band on the overall rating, 0 to 5. 0 is off. |
| `reviewedAfter` | YYYY-MM-DD. Drops reviews posted before this date. |
| `includeHotelSummary` | The hotel's overall rating, review count and six aspect ratings on each row. On by default, no charge. |
| `includeAiSummary` | ikyu's generated summary of what guests say, in Japanese. Off by default, no charge. |
| `includeHotelDetails` | The hotel's address, coordinates, times, access, amenities and images. Off by default, no extra charge. |
| `summaryOnly` | One row per hotel with the aggregate ratings and no reviews. |
| `language` | `en` (default) for ikyu's English titles and texts, `ja` for the originals. |
| `dedupStoreName` | Names the store that remembers which reviews you've had. |
| `maxConcurrency`, `delayMs` | Parallel requests (default 8) and an optional pause before each one (default 0). |

#### For developers

- With `sort: "recent"` and `reviewedAfter`, paging stops as soon as the reviews are older than your date. With `dedupStoreName` it stops at the first review an earlier run returned.
- When `minRating` or `maxRating` keep few or no reviews, reading a hotel stops early: after a run of pages that kept nothing, when 20 or more pages have kept fewer than 0.15 a page, or at about three times the pages `maxReviewsPerHotel` needs.
- `minRating` above `maxRating` is refused before anything is read.
- `dedupStoreName` is a named key-value store. Reviews returned by earlier runs are skipped and not charged.
- `summaryOnly` bills one `hotel-summary` per hotel in place of `review-scraped`.
- `maxConcurrency` takes 1 to 32 and `delayMs` up to 10,000. Lower the first only if a run reports refusals or errors.
- Reviews are written hotel by hotel in the order you listed them. After a restart by the platform, the run continues from where it was, and no review is written or charged a second time.
- A row reporting a hotel that couldn't be resolved isn't counted by `maxItems` and isn't charged.

### ⬆️ Output

One record per review. This one is from Keio Plaza Hotel Tokyo, collected on 7 October 2026:

```json
{
  "input": "00000187",
  "hotelId": "00000187",
  "hotelName": "Keio Plaza Hotel Tokyo",
  "url": "https://www.ikyu.com/en-us/00000187/",
  "hotelRating": 4.41,
  "hotelRatingScale": 5,
  "hotelReviewCount": 130,
  "hotelRatings": { "room": 4.49, "service": 4.4, "bath": 4.21, "facilities": 4.35, "meals": 4.61, "satisfaction": 4.46 },
  "hotelArea": "Shinjuku · Waseda · Yotsuya",
  "hotelPrefecture": "Tokyo Metropolis",
  "hotelType": "HOTEL",
  "reviewsInFeed": 129,
  "id": "1002110094",
  "reviewId": "1002110094",
  "site": "IKYU",
  "rating": 4.2,
  "ratingScale": 5,
  "title": "It’s solid, as expected.",
  "text": "As a long-established Hotel, it has a well-run front desk, which makes it feel reliable and reassuring.",
  "postedAt": "2026-06-28T19:50:20+09:00",
  "stayDate": "2026-06-26",
  "roomName": "Plaza Deluxe South Double / Non-Smoking",
  "roomCount": 1,
  "guests": 1,
  "meal": "No meals",
  "mealCode": "000",
  "ratings": { "room": 5, "service": 4, "bath": 4, "facilities": 4, "meals": 0, "satisfaction": 4 },
  "reviewer": { "name": "黄金ねこ", "isMember": true },
  "response": { "text": "Thank you very much for staying at Keio Plaza Hotel.\r\n\r\nWe are delighted to hear that our front desk staff helped you feel at ease during your stay.\r\nWe will continue to value warm, attentive hospitality tailored to each guest, so that we remain a Hotel you can trust.\r\n\r\nAll of us look forward to welcoming you again." },
  "likes": 0,
  "images": [],
  "sort": "recent",
  "scrapedAt": "2026-10-07T18:54:19.468Z"
}
```

What some of those columns mean:

- **`title`** is ikyu's headline for the review. Where the guest wrote a short title you get that. Otherwise it's ikyu's own excerpt of the opening words, about 20 characters and ending "...". The whole review is always in `text`.
- **`site`** is `IKYU` or `YAHOO_TRAVEL`, the partner site whose reviews ikyu shows beside its own.
- **`rating`** is a decimal out of 5 on ikyu's own reviews and on partner reviews alike. **`ratings`** holds the guest's six aspect scores, and a 0 there is an aspect with no score. It's nearly always meals on a room-only stay, as above.
- **`hotelRatings`, `hotelRating`, `hotelReviewCount`** are the property's own scores, repeated on each review. Switch off "Hotel rating on every review" to leave the hotel columns out.
- **`reviewsInFeed`** is how many reviews the feed holds in total for your sort and source. Compare it with your row count to tell a capped run from a complete one.
- **`meal` and `mealCode`** describe the meal plan of the stay. `meal` reads "No meals", "Breakfast", "Dinner", "Breakfast and dinner", "Breakfast and lunch", "Lunch", "Breakfast, lunch and dinner" or "Lunch and dinner", in English in both languages. `mealCode` is ikyu's code for the same plan, `000` to `007` in that order.
- **`input`** is the hotel exactly as you supplied it, which keeps a multi-hotel run separable.
- **`hotelAiSummary`** appears when "Include ikyu's AI review summary" is on and ikyu has a summary for the property. **`hotel`** appears when "Include hotel details" is on.

### How much does it cost to scrape ikyu.com reviews?

| Event | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| `actor-start`, per run | $0.002 | $0.002 | $0.002 | $0.002 |
| `hotel-resolved`, per hotel name looked up (URLs and ids skip it) | $0.002 | $0.002 | $0.002 | $0.002 |
| `review-scraped`, per review returned | $0.0025 | $0.00225 | $0.002 | $0.00175 |
| `hotel-summary`, per hotel in `summaryOnly` mode | $0.002 | $0.0018 | $0.0016 | $0.0014 |

Enterprise plans pay the Business price.

**$2.50 per 1,000 reviews** on the Free plan, $1.75 on Business. Proxy usage and platform usage are inside that price. Reviews your filters drop and reviews an earlier run already returned are free, and the hotel scores, AI summary and hotel details add nothing.

- One hotel by URL, 750 reviews: $0.002 + 750 × $0.0025 = **$1.877** ($1.3145 on Business)
- Twenty hotels by name, summary rows only: $0.002 + 20 × $0.002 + 20 × $0.002 = **$0.082** ($0.07 on Business)

The $5 of monthly credits on Apify's Free plan buys about 1,900 reviews with this actor, taken 100 at a time from one hotel per run.

### How many reviews can you get, and how fast?

| Run | Result | Time |
|---|---|---|
| Hotel Granvia Kyoto, 10 most recent | 10 reviews | 5 s |
| Hotel Granvia Kyoto, Hotel Vischio Kyoto, Seikan-so and Hiiragiya Ryokan, up to 300 each | 653 reviews (all the reviews of the two smaller properties) | 5 s |
| 99 hotels across Japan, up to 100 each | 7,876 reviews | 25 s |

Whole runs on Apify, measured between 1 and 3 October 2026.

Large runs move at several thousand reviews a minute, and the per-hotel cap goes up to 20,000. Tens of thousands of reviews fit inside the default one-hour run limit.

### What it can't do

- Sort by rating. ikyu offers newest first and its own recommended order, nothing else. Use the rating band to filter, and sort in your spreadsheet.
- Explain the `recommended` order. It's ikyu's ranking, and no column in the data reproduces it.
- Give you more about a reviewer than the handle and member flag ikyu shows.
- Translate. The English text is ikyu's own English version of the review. For the guest's words, set the language to Japanese.

### FAQ

#### Can I get the reviews in Japanese?

Set "Language" to `ja` and you get the titles and texts as the guests wrote them. The default, `en`, returns ikyu's English version. Reviewer handles stay in their original script either way.

#### Why do some titles end in "..."?

Those are reviews with no headline of their own. ikyu makes one from the first 20 or so characters of the text and adds "...", and that's what `title` holds. It was 8 of 60 reviews in one English sample. The review itself isn't cut: the full text is in `text`.

#### How do I get only the reviews posted since my last run?

Name an only-new store ("Only-new store" in the form) and schedule the run. Each run returns the reviews it hasn't returned before and stops reading a hotel when it reaches one it has. You pay nothing for the ones you've already had.

#### Where do the Yahoo! Travel reviews come from, and can I leave them out?

ikyu shows reviews from its partner site next to its own, and "Review sources" includes them by default. Set it to `ikyu` for ikyu.com bookings only. On the two properties we tested at 60 reviews each, the default returned 38 partner and 34 ikyu reviews, and the ikyu-only setting returned 70, all from ikyu.

#### Can I get a hotel's scores without paying for its reviews?

Switch on "Summary rows only". You get one row per hotel with the overall rating, the review count and the six aspect ratings, at $0.002 a hotel on the Free plan.

#### What happens if a hotel name isn't on ikyu?

You get a row for that input saying it couldn't be matched, and it isn't charged. A name resolves to ikyu's first suggestion, so pass the id or URL when two properties share a name.

#### Do I need proxies or an ikyu account?

Neither one. Proxy usage is part of the price and there's nothing to configure, and the actor never logs in.

#### Is it legal to scrape ikyu.com reviews?

The actor reads only what ikyu shows to any logged-out visitor, and scraping publicly available data is generally legal. Reviews do contain personal data, such as reviewer handles, so collect them only where you have a legitimate reason. You're responsible for complying with ikyu's terms and applicable law.

### New reviews on a schedule, or from your own code

Review monitoring is a scheduled run with an only-new store. Put it on an Apify Schedule, and send what comes back to Slack or a Google Sheet through Apify's integrations, or fire a webhook when the run ends and filter for low ratings yourself.

If you'd rather call it, `POST https://api.apify.com/v2/acts/boncross~ikyu-reviews/run-sync-get-dataset-items` with the input JSON returns the reviews in the response for a small pull. Start a normal run and read its dataset for thousands. Apify's `apify-client` library, on NPM and on PyPI, handles both.

For an AI agent, add the Apify MCP server (`mcp.apify.com`) to your client. The actor is there as a tool named `boncross/ikyu-reviews`, and an agent can fetch a property's recent reviews and summarise the complaints.

### More from BonCross

- [ikyu.com Room Rates Scraper (一休)](https://apify.com/boncross/ikyu-room-rates): Each room and rate plan ikyu.com (一休) sells for a hotel or ryokan on your dates.
- [ikyu.com Search Scraper (一休)](https://apify.com/boncross/ikyu-search): ikyu.com (一休) search results for any Japanese area, station or landmark on your dates.
- [Jalan.net Reviews Scraper (じゃらん クチコミ)](https://apify.com/boncross/jalan-reviews): Jalan (じゃらん クチコミ) hotel reviews, all or only new ones.
- [Marriott Reviews Scraper](https://apify.com/boncross/marriott-reviews): Guest reviews for any Marriott hotel.
- [Rakuten Travel Reviews Scraper (楽天トラベル)](https://apify.com/boncross/rakuten-travel-reviews): Rakuten Travel (楽天トラベル) hotel reviews by hotel number, URL or Japanese name: overall…
- [Tripadvisor Place Details Scraper](https://apify.com/boncross/tripadvisor-location-details): The full Tripadvisor record for any hotel, restaurant or attraction.

### Your feedback

Seen a review on ikyu that didn't come back, or a column that reads wrong? Raise it on the Issues tab in Apify Console and include the hotel id. We look at every report and fix what we can reproduce.

# Changelog

This Actor's version history is a separate document: https://apify.com/boncross/ikyu-reviews/changelog.md

# Actor input Schema

## `hotels` (type: `array`):

ikyu hotel URLs (https://www.ikyu.com/en-us/00000146/), 8-digit accommodation ids, or hotel names in English or Japanese.

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

ikyu page addresses, with the option to load them in bulk from a file, a Google Sheet or a remote list. Use this when you have more links than you want to paste. Combined with anything in the list above.

## `maxReviewsPerHotel` (type: `integer`):

Stop after this many reviews per hotel.

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

A run-wide ceiling across every target. The per-target limit above applies to each one separately, so ten targets at 50 each returns 500; set this to cap the total. Zero means no run-wide limit. Rows that report an input the actor could not resolve are not counted here and are never charged for.

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

ikyu's orderings.

## `sources` (type: `string`):

all = reviews from ikyu and its partner sites (Yahoo! Travel); ikyu = ikyu.com bookings only.

## `minRating` (type: `number`):

Drop reviews below this overall rating. 0 = off. Filtered reviews are free.

## `maxRating` (type: `number`):

Drop reviews above this. 0 = off.

## `reviewedAfter` (type: `string`):

YYYY-MM-DD. Drop reviews posted before this (with Most recent sort, stops paging once older).

## `includeHotelSummary` (type: `boolean`):

Overall rating, review count and rating by aspect (room, service, bath, facilities, meals, satisfaction) repeated on each row. No charge.

## `includeAiSummary` (type: `boolean`):

ikyu's generated summary of what guests say (Japanese text), on each row. No charge.

## `includeHotelDetails` (type: `boolean`):

Also return address, coordinates, check-in and check-out times, access, amenities, facilities, hot spring, parking and images. No extra charge.

## `summaryOnly` (type: `boolean`):

Push one row per hotel with the aggregate ratings and no individual reviews (billed as hotel-summary).

## `language` (type: `string`):

en = ikyu's English translations of titles and texts; ja = Japanese originals.

## `dedupStoreName` (type: `string`):

Key-value store name. Reviews returned in earlier runs are skipped and not charged.

## `maxConcurrency` (type: `integer`):

How many requests run at once across the whole run. The default is the fastest level measured clean; lower it only if a run reports refusals or errors.

## `delayMs` (type: `integer`):

Optional pause before each call, in milliseconds. 0 (the default) runs as fast as the parallel limit allows.

## Actor input object example

```json
{
  "hotels": [
    "https://www.ikyu.com/en-us/00000146/"
  ],
  "startUrls": [],
  "maxReviewsPerHotel": 100,
  "maxItems": 0,
  "sort": "recent",
  "sources": "all",
  "minRating": 0,
  "maxRating": 0,
  "reviewedAfter": "",
  "includeHotelSummary": true,
  "includeAiSummary": false,
  "includeHotelDetails": false,
  "summaryOnly": false,
  "language": "en",
  "dedupStoreName": "",
  "maxConcurrency": 8,
  "delayMs": 0
}
```

# Actor output Schema

## `dataset` (type: `string`):

ikyu reviews: every row the run returned.

## `stats` (type: `string`):

Counts for the run: what was resolved, fetched, filtered and returned.

# 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 = {
    "hotels": [
        "https://www.ikyu.com/en-us/00000146/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("boncross/ikyu-reviews").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 = { "hotels": ["https://www.ikyu.com/en-us/00000146/"] }

# Run the Actor and wait for it to finish
run = client.actor("boncross/ikyu-reviews").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 '{
  "hotels": [
    "https://www.ikyu.com/en-us/00000146/"
  ]
}' |
apify call boncross/ikyu-reviews --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,boncross/ikyu-reviews"
        }
    }
}
```

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/c9a0eJespHQNBageJ/builds/sMJL1xFsb8yD6YIIg/openapi.json