# ikyu.com Search Scraper (一休) (`boncross/ikyu-search`) Actor

Scrape ikyu.com (一休) search results for any Japanese area, station or landmark on your dates. Just add destinations and dates and get stay and nightly prices, cheapest room and plan, meals, cancellation deadline, ratings by aspect, coordinates and address. $1.50 per 1,000 hotels.

- **URL**: https://apify.com/boncross/ikyu-search.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.05 / 1,000 property-listeds

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 Search Scraper (一休)

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

ikyu.com (一休.com) is where Japan books its better hotels and ryokan, and ikyu.com Search Scraper prices a whole destination on it in a few seconds. Name a prefecture, an onsen town, a station or a landmark, in English or Japanese, add your dates and party, and you get the properties ikyu can sell you that night. Each one arrives with its stay total, the room and plan (プラン) behind that price, and the cancellation terms.

Why it's worth choosing:

- A country-wide pull is quick. Twelve destinations across Japan returned 1,026 priced properties in 3 to 10 seconds.
- The price is for your party, children included. Add an 8-year-old and ikyu reprices by its own age groups: all 5 Kyoto hotels we compared came back dearer.
- ikyu does the narrowing. 19 facility filters, 20 room features, 9 room types and 4 plan features go to the site, and on Kyoto each one returned exactly the count ikyu shows for it (58 properties with an onsen, 70 with a sauna).
- You see what's inside the price. Consumption tax and service charge are always in. Where a plan is sold with the hot spring tax included, you get that amount in yen.
- $1.50 per 1,000 properties on the Free plan, $1.05 on Business, and nothing is added on top for platform usage.

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

- 53 of 53 live checks on its inputs and filters passed on 7 October 2026
- 7 destinations run the same day across Japanese and English names, a station and an island: 105 hotels, none empty
- Charges matched the rows

What else you can do with it:

- Read the cheapest room's name, type, size and capacity, with rooms left
- Get the last free-cancellation date and the charge ladder by days before arrival
- Add ikyu's own conversion into USD, EUR, GBP, KRW, CNY, TWD, HKD, SGD, THB or AUD next to the yen price
- Sort by ikyu's recommendation, price up or down, points rate, or its best-rated lists overall and in six categories
- Keep only properties whose cheapest plan includes breakfast or dinner, or is still free to cancel
- Filter on property type, guest rating, review count and a nightly price band
- Watch a destination daily and get back only the properties whose price moved
- Get a row that says why when a destination can't be matched

### What data do you get for each property?

| | |
|---|---|
| 🏨 Property name and type | ikyu id and property URL |
| 💴 Stay total and nightly price in JPY, tax included | Same prices in your currency |
| ♨️ Hot spring tax already in the price | Tax-inclusive flag |
| Crossed-out list price and discount | ikyu points earned and point rate |
| ⭐ Guest rating and review count | Six aspect ratings: room, service, bath, facilities, meals, satisfaction |
| 🛏️ Cheapest room name, type, size and capacity | Cheapest plan name and id |
| 🍽️ Meal plan on the cheapest rate | Rooms left and room types available |
| Free cancellation status and last free date | Cancellation charge ladder by days before arrival |
| 📍 Coordinates, address and postcode | Prefecture, region, area and sub-area |
| 🕒 Check-in and check-out times | ☎️ Phone and room count |
| 🖼️ Property images | Facilities, with ikyu's code for each |
| Previous price and price change | The destination ikyu matched your input to |

### How to scrape ikyu.com search results

There's nothing to install and no ikyu account to set up. You fill in a form and download a table.

1. [Create a free Apify account](https://console.apify.com/sign-up) and open [ikyu.com Search Scraper](https://apify.com/boncross/ikyu-search).
2. Type one destination per line: "Kyoto", "箱根", "Shinjuku Station", "Kinosaki Onsen".
3. Set your dates, the adults per room and the number of rooms. Pick a currency if you want one beside the yen.
4. Add filters or a sort if you need them, then press Start.
5. Download the properties as Excel, CSV or JSON when the run finishes.

### ⬇️ Input

Give it at least one destination, or a keyword on its own to search all of Japan. A destination can be an area or prefecture name in either language, a station, a landmark, an onsen area, an ikyu area id (`320711`) or an ikyu area URL. Each line is searched separately.

Left alone, a run prices one night for two adults in one room, 30 days from today, and returns up to 100 properties per destination in ikyu's recommended order. For a rolling watch, leave the dates empty and use "Check-in days ahead": a schedule then always looks the same distance into the future.

You have two limits. "Max results per destination" (1 to 5,000, default 100) applies to each destination separately: ten destinations at 50 each returns 500. "Maximum results for the whole run" caps the total across all of them, and 0 means no cap. Nothing past either limit is charged for.

#### A prefecture on fixed dates, best rated first

```json
{
  "destinations": ["Kyoto"],
  "checkIn": "2026-11-20",
  "checkOut": "2026-11-22",
  "adults": 2,
  "currency": "USD",
  "sort": "rating",
  "maxResultsPerDestination": 100
}
```

#### Ryokan with dinner in three onsen towns, cheapest first

```json
{
  "destinations": ["箱根", "下呂温泉", "Kinosaki Onsen"],
  "checkInDaysAhead": 45,
  "nights": 1,
  "accommodationTypes": ["INN"],
  "mealsIncluded": "dinner",
  "sort": "price_low_to_high"
}
```

#### A station and a landmark, narrowed by a keyword

```json
{
  "destinations": ["Shinjuku Station", "Tokyo Disneyland"],
  "keyword": "private open-air bath",
  "checkInDaysAhead": 30,
  "nights": 2,
  "freeCancellationOnly": true,
  "minRating": 4.5
}
```

The keyword is matched by ikyu against text in the language you chose. Use English words on the default English setting. For Japanese words such as `温泉`, set `"language": "ja"`.

#### A daily price watch that returns only what changed

```json
{
  "destinations": ["Karuizawa", "Hakone"],
  "checkInDaysAhead": 30,
  "nights": 1,
  "priceStoreName": "ikyu-prices",
  "onlyNewOrChanged": true
}
```

| Field | Notes |
|---|---|
| `destinations`, `keyword` | Where to search, and an optional free-text filter ikyu applies on top. |
| `maxResultsPerDestination`, `maxItems` | The per-destination cap (default 100) and the run-wide cap (default 0, no cap). |
| `checkIn`, `checkOut` | Fixed dates, YYYY-MM-DD. |
| `checkInDaysAhead`, `nights` | Used when the dates are empty. Defaults 30 and 1. |
| `adults`, `rooms`, `childrenAges` | Adults per room (default 2), rooms (default 1) and one age per child, 0 to 12. |
| `sort` | `recommended` (the default), `price_low_to_high`, `price_high_to_low`, `rating`, `rating_room`, `rating_service`, `rating_bath`, `rating_facilities`, `rating_meals`, `rating_satisfaction` or `points_rate`. |
| `accommodationTypes` | `HOTEL`, `INN` (ryokan), `RESORT_HOTEL`, `BUSINESS`, `VACATION_RENTAL`. Empty means all. |
| `facilities`, `roomFeatures`, `roomTypes`, `planFeatures` | ikyu's own filters. A property must have all the facilities you pick, a room with all the room features, one of the room types and a plan with the plan features. |
| `minRating`, `minReviewCount` | Drop properties rated below, or reviewed fewer times than, the value. 0 is off. |
| `minPricePerNight`, `maxPricePerNight` | A nightly price band per room, in the selected currency. 0 is off. |
| `mealsIncluded`, `freeCancellationOnly` | Both look at each property's cheapest plan. `mealsIncluded` is `any`, `breakfast` or `dinner`. |
| `currency`, `language` | `JPY` by default, and yen prices are always included. `en` (default) or `ja`. |
| `priceStoreName`, `onlyNewOrChanged` | The price memory for scheduled runs, and the switch that returns only new or changed prices. |
| `maxConcurrency`, `delayMs` | Parallel requests (default 8) and an optional pause before each one (default 0). |

#### For developers

- `checkIn: "none"` runs an undated search. You get ikyu's reference price, and availability isn't checked.
- `childrenAges` maps to ikyu's age groups: 10 to 12 and 6 to 9 are priced as primary-school children, under 6 as an infant with meals and bedding.
- `minRating`, `minReviewCount`, the price band, `mealsIncluded` and `freeCancellationOnly` are applied to the rows ikyu returns. When they keep few or no properties, reading a destination 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 `maxResultsPerDestination` needs.
- An `accommodationTypes` value outside the five listed returns nothing from ikyu. The run warns you in the log when that happens.
- `priceStoreName` names a key-value store that remembers each property's nightly price per dates, occupancy and currency. The next run fills `previousPricePerNight`, `priceChange` and `priceChangePct`. With `onlyNewOrChanged`, unchanged properties are skipped and not charged.
- `maxConcurrency` runs from 1 to 32, and 8 is the fastest setting we measured without errors. `delayMs` goes up to 10,000. We'd leave both alone unless a run reports errors.
- Lowercase `checkin`, `checkout` and `checkinDaysAhead` are accepted as well.
- Rows are written in the order of your destinations. If Apify restarts a run part-way, it carries on where it stopped, and no property is delivered or charged twice.
- A row reporting a destination that couldn't be resolved doesn't count towards `maxItems` and isn't charged.

### ⬆️ Output

One record per property and stay. The Output tab shows them as an overview table or as JSON. This one is a ryokan in Ito from a search for `箱根` on 7 October 2026, with its image list shortened to one:

```json
{
  "destination": "箱根・熱海・伊豆",
  "destinationKind": "area",
  "destinationId": "160000",
  "id": "00030792",
  "hotelId": "00030792",
  "name": "Ito Hotel Juraku",
  "url": "https://www.ikyu.com/en-us/00030792/",
  "type": "INN",
  "category": "INN",
  "catchCopy": "Ocean View Resort on the Hill with Serene Blue Hot Springs",
  "isIkyuPlus": false,
  "isPremium": false,
  "prefecture": "Shizuoka Prefecture",
  "prefectureCode": "22",
  "region": "Hakone · Atami · Izu",
  "area": "Izu",
  "areaId": "160614",
  "subArea": "Ito",
  "subAreaId": "16061401",
  "areaLabel": "Izu Ito Onsen",
  "address": "281, Oka, Ito City",
  "postcode": "414-0055",
  "phone": "+81-557-37-3161",
  "lat": 34.964675,
  "lng": 139.090245,
  "roomCount": 71,
  "checkInFrom": "15:00",
  "checkInUntil": "18:00",
  "checkOutUntil": "11:00",
  "rating": 4.54,
  "ratingScale": 5,
  "reviewCount": 262,
  "ratings": {
    "room": 4.43,
    "service": 4.69,
    "bath": 4.47,
    "facilities": 4.42,
    "meals": 4.63,
    "satisfaction": 4.59
  },
  "images": [
    "https://www.img-ikyu.com/contents/common/image/acc2/00030792/4/org/10790117.jpg"
  ],
  "facilities": [
    "Hot spring",
    "Rooms with open-air baths available",
    "Open-air bath",
    "Free-flowing hot spring",
    "Large public bath",
    "Sauna",
    "Within a 5-minute walk to the convenience store.",
    "Outdoor pool",
    "Free shuttle service"
  ],
  "facilityCodes": ["9", "4", "11", "10", "12", "28", "16", "6", "13"],
  "checkIn": "2026-11-13",
  "nights": 1,
  "adults": 2,
  "rooms": 1,
  "isAvailable": true,
  "priceTotalJpy": 55140,
  "pricePerNightJpy": 55140,
  "priceListedTotalJpy": 61200,
  "discountPercent": 9.9,
  "currency": "JPY",
  "priceTotal": 55140,
  "pricePerNight": 55140,
  "pricesIncludeTax": true,
  "hotSpringTaxIncludedJpy": 600,
  "points": 6060,
  "pointRate": 10,
  "cheapestMeal": "Dinner and Breakfast included",
  "cheapestMealCode": "003",
  "cheapestRoom": {
    "roomId": "10252087",
    "name": "[NEW] Ocean View Triple Room",
    "type": "Twin",
    "sizeSqm": 44,
    "capacity": {
      "min": 2,
      "max": 3
    },
    "plan": "Advance Payment Only 【Early Bird 30・10% Off】 Juraku All-Inclusive Buffet 1 Night 2 Meals",
    "planId": "11542219",
    "meal": "Dinner and Breakfast included",
    "roomsLeft": 2,
    "isFreeCancellation": true,
    "freeCancellationUntil": "2026-10-13",
    "freeCancellationDaysBefore": 31,
    "ladder": [
      {
        "daysBefore": 30,
        "chargePercent": 20,
        "charge": null
      },
      {
        "daysBefore": 3,
        "chargePercent": 30,
        "charge": null
      },
      {
        "daysBefore": 1,
        "chargePercent": 50,
        "charge": null
      },
      {
        "daysBefore": 0,
        "chargePercent": 100,
        "charge": null
      }
    ],
    "noShowChargePercent": 100
  },
  "roomTypesAvailable": 3,
  "checkOut": "2026-11-14",
  "previousPricePerNight": null,
  "priceChange": null,
  "priceChangePct": null,
  "previousScrapedAt": null,
  "scrapedAt": "2026-10-07T17:15:07.651Z"
}
```

A few columns need a word:

- **Prices** are what ikyu displays: per room, for the whole stay and the party you asked for, after its standard discounts. `priceTotalJpy` and `pricePerNightJpy` are always yen. `priceTotal` and `pricePerNight` are in the currency you picked.
- **Tax.** `pricesIncludeTax` is true on every priced row, because ikyu quotes consumption tax and service charge inside the price. `hotSpringTaxIncludedJpy` is the hot spring (bathing) tax already inside the price, in yen for the whole stay. It's 0 where the plan isn't sold with it included. A local accommodation tax, or a bathing tax the property collects when you arrive, isn't in the price and has no amount in the data.
- **`destination`, `destinationKind`, `destinationId`** show what ikyu matched your input to. In the example, `箱根` was matched to the wider 箱根・熱海・伊豆 region, which is why an Ito ryokan is in it.
- **`facilities` and `facilityCodes`** list the property's facilities in your language, with ikyu's code for each. Both are null when ikyu gives no facility list.
- **`isAvailable`** is true on every row of a dated search. ikyu lists only what it can price for the dates, and a sold-out property is simply absent.

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

| Run | Result | Time |
|---|---|---|
| Kyoto, 8 properties, 1 night | 8 properties, all priced | 3 s |
| Kyoto, Tokyo, Osaka and Hakone, up to 150 each, 1 night | 600 properties, all priced | 4 s |
| 12 destinations across Japan, up to 100 each, cheapest first, 1 night | 1,026 properties, all priced | 3 to 10 s |

These are whole runs on Apify, measured between 1 and 3 October 2026.

A destination can't return more properties than ikyu lists for it, which is about 500 in Kyoto and 1,300 in Tokyo. The per-destination cap goes up to 5,000, so a whole prefecture fits in one line of input, and a whole-country search finishes well inside the default one-hour run limit.

### How much does it cost to search ikyu.com?

| Event | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| `actor-start`, per run | $0.002 | $0.002 | $0.002 | $0.002 |
| `destination-resolved`, per destination looked up on the site (names matched against the built-in area tree are free) | $0.002 | $0.002 | $0.002 | $0.002 |
| `property-listed`, per property returned | $0.0015 | $0.00135 | $0.0012 | $0.00105 |

Enterprise plans pay the Business price.

**$1.50 per 1,000 properties** on the Free plan, $1.05 on Business, with all the fields above. That's the whole price, with proxy usage and platform usage included. Properties your filters remove are free, and so are unchanged properties in an only-changes run.

- Kyoto prefecture, 100 properties, name matched from the built-in area tree: $0.002 + 100 × $0.0015 = **$0.152** ($0.107 on Business)
- Four destinations, two of them looked up on the site, 300 properties: $0.002 + 2 × $0.002 + 300 × $0.0015 = **$0.456** ($0.321 on Business)

Apify's Free plan gives you $5 of credits a month, which is 32 searches the size of the first example: about 3,200 priced properties before you pay anything.

### Limitations

- You get each property's cheapest room and plan. For the full grid of rooms and plans, use [ikyu.com Room Rates Scraper (一休)](https://apify.com/boncross/ikyu-room-rates).
- Sold-out properties can't be listed. ikyu leaves them out of a dated search.
- An undated search returns ikyu's reference price, not checked availability.
- Member-only ikyu Plus prices need a login and aren't included.
- `rating` is null until a property has enough reviews, which matches what ikyu shows.
- The `rating` sort and the six category sorts return ikyu's top-rated properties, overall or in that category, but not in exact score order. Every property we measured under a category sort scored 4.68 or better in that category, with at least 26 reviews. `points_rate` is in strict order.
- There's no sort by review count.
- `mealsIncluded` and `freeCancellationOnly` judge a property by its cheapest plan. A ryokan whose cheapest plan is room-only is dropped by a dinner filter even if it sells dinner plans.

### FAQ

#### Can I search in English?

Prefectures, areas, stations, landmarks and onsen names resolve in English or Japanese. With "Language" on English you get ikyu's English property names and descriptions where the site has them. Switch to Japanese for the originals.

#### Why did my destination return hotels from a wider area, or around a station?

ikyu's area list has regions and districts, and not every town or city is an area in its own right. A name that isn't one falls to the closest thing ikyu has. In our 7 October 2026 check, "Kanazawa" was matched to Kanazawa Station and `箱根` to the 箱根・熱海・伊豆 region. Each row's `destination` and `destinationKind` tell you what was searched, and `area` and `subArea` let you narrow the result. For a whole city, give the prefecture or the district names.

#### Why does my keyword return nothing?

It's almost always the language. The keyword matches text in the language you chose, and a Japanese keyword on the English setting finds nothing: `温泉` in Kyoto returned 0 properties in English and 28 in Japanese, while "onsen" returned 18 in English.

#### How are children priced?

Put each child's age (0 to 12) in "Children's ages". ikyu prices by age group: 10 to 12 and 6 to 9 as primary-school children, under 6 as an infant with meals and bedding. Expect a higher price than for the adults alone. With one 8-year-old added, 5 of 5 Kyoto hotels we compared cost more.

#### Are the prices tax-inclusive?

ikyu quotes room totals with consumption tax and service charge, and every priced row says so in `pricesIncludeTax`. Where the plan's price already includes the hot spring tax, `hotSpringTaxIncludedJpy` gives the amount. A local accommodation tax isn't included.

#### How do I get only the prices that moved since yesterday?

Give "Price memory store" a name, switch on "Only new or changed prices" and put the run on an Apify Schedule with "Check-in days ahead". Each run returns the properties that are new or whose nightly price changed, and you're charged for those alone.

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

Neither. There's no proxy to set up and no proxy charge, and the actor doesn't log in to anything.

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

The actor reads only what ikyu serves to any logged-out visitor. Scraping publicly available data is generally legal, but you're responsible for complying with ikyu's terms and applicable law in how you use the data.

### Schedule it, or call it from your own code

A rolling price watch is what most people schedule: an Apify Schedule, "Check-in days ahead", and a price memory store. A webhook can fire when the run ends, and Apify's integrations will pass the rows on to Google Sheets, Slack, Zapier, Make or Airbyte.

From code, `POST https://api.apify.com/v2/acts/boncross~ikyu-search/run-sync-get-dataset-items` with the input JSON as the body returns the properties in one call for a small search. Use the asynchronous run endpoint for a large one. The `apify-client` packages on NPM and PyPI wrap both.

AI agents reach it through the Apify MCP server at `mcp.apify.com`, where it appears as a tool named `boncross/ikyu-search`. An agent can then ask for ryokan in Hakone with dinner on a given date and get structured records back.

### More from BonCross

- [ikyu.com Reviews Scraper (一休)](https://apify.com/boncross/ikyu-reviews): ikyu.com (一休) reviews for hotels and ryokan.
- [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.
- [Jalan.net Area Rates Scraper (じゃらん)](https://apify.com/boncross/jalan-area-rates): Jalan (じゃらん) prices and rooms left for every available hotel in an area, a whole…
- [Jalan.net Room Rates Scraper (じゃらん)](https://apify.com/boncross/jalan-room-rates): Every plan and room Jalan (じゃらん) lists for a hotel on a date.
- [Jalan.net Hotel Search Scraper (じゃらん)](https://apify.com/boncross/jalan-search): Jalan (じゃらん) hotel search results for any area and your dates.
- [Marriott Hotel Details Scraper](https://apify.com/boncross/marriott-hotel-details): Everything a Marriott property publishes: address, coordinates, phones, brand, guest…

### Your feedback

Is a destination resolving to the wrong place, or is there a filter on ikyu's list page that you can't find here? Open an issue on this actor's Issues tab in Apify Console and tell us which destination or filter. We read every issue and answer there.

# Changelog

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

# Actor input Schema

## `destinations` (type: `array`):

Area or prefecture names in English or Japanese ("Kyoto", "箱根", "Gion", "Karuizawa"), a station or landmark ("Shinjuku Station", "Tokyo Disneyland"), an ikyu area id (320711) or an ikyu area URL. One search per entry.

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

Free-text filter applied by ikyu on top of the destination. It matches text in the Language below: with English, use English words ("onsen", "private bath"); for Japanese words ("温泉", "露天風呂付客室") set Language to ja: a Japanese keyword on the English site matches nothing. With no destinations, searches all of Japan by keyword.

## `maxResultsPerDestination` (type: `integer`):

Cap per destination, up to 100 at a time. ikyu lists about 500 properties in Kyoto and 1,300 in Tokyo.

## `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.

## `checkIn` (type: `string`):

YYYY-MM-DD. Empty = Check-in days ahead. "none" = undated search (ikyu's reference price, availability not checked). Lowercase `checkin` also works.

## `checkOut` (type: `string`):

YYYY-MM-DD. Empty = Nights. Lowercase `checkout` also works.

## `checkInDaysAhead` (type: `integer`):

Used when Check-in is empty. Lowercase `checkinDaysAhead` also works.

## `nights` (type: `integer`):

Used when Check-out is empty.

## `adults` (type: `integer`):

Per room. ikyu prices per room for this many people.

## `rooms` (type: `integer`):

Number of rooms.

## `childrenAges` (type: `array`):

Optional. The age of each child, 0-12, one per line. ikyu prices children by age group: 10-12 and 6-9 as primary-school children, under 6 as an infant with meals and bedding. Adults are set above.

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

ikyu's own orderings, the same as its sort menu. The "best rated" sorts return ikyu's top-rated properties overall or in one category (every one measured scored 4.68 or better in that category, with at least 26 reviews), though ikyu does not put them in exact score order. "Highest points rate first" is in strict order.

## `accommodationTypes` (type: `array`):

Keep only these ikyu types, applied by ikyu: HOTEL, INN (ryokan), RESORT_HOTEL, BUSINESS, VACATION_RENTAL. Empty = all. Anything else returns no properties, so the run warns rather than finishing empty without saying why.

## `facilities` (type: `array`):

Keep only properties with ALL of these, applied by ikyu. Each result lists its facilities in `facilities`.

## `roomFeatures` (type: `array`):

Keep only properties with a room offering ALL of these, applied by ikyu.

## `roomTypes` (type: `array`):

Keep only properties offering these room types, applied by ikyu.

## `planFeatures` (type: `array`):

Keep only properties with a plan offering these, applied by ikyu.

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

Drop properties rated below this. 0 = off. Filtered properties are free.

## `minReviewCount` (type: `integer`):

0 = off.

## `mealsIncluded` (type: `string`):

Keep properties whose cheapest plan includes the meal.

## `freeCancellationOnly` (type: `boolean`):

Keep properties whose cheapest plan is still free to cancel today.

## `minPricePerNight` (type: `number`):

In the selected currency, per room. 0 = off.

## `maxPricePerNight` (type: `number`):

In the selected currency, per room. 0 = off.

## `currency` (type: `string`):

JPY prices are always included; set USD, EUR, GBP, KRW, CNY, TWD, HKD, SGD, THB, AUD… to add ikyu's own conversion.

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

en = ikyu's English site names and descriptions; ja = Japanese originals.

## `priceStoreName` (type: `string`):

Key-value store name; remembers each property's nightly price per dates/occupancy/currency and adds previousPricePerNight and priceChange next run.

## `onlyNewOrChanged` (type: `boolean`):

With a price memory store: skip unchanged properties (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
{
  "destinations": [
    "Kyoto"
  ],
  "keyword": "",
  "maxResultsPerDestination": 100,
  "maxItems": 0,
  "checkIn": "",
  "checkOut": "",
  "checkInDaysAhead": 30,
  "nights": 1,
  "adults": 2,
  "rooms": 1,
  "childrenAges": [],
  "sort": "recommended",
  "accommodationTypes": [],
  "facilities": [],
  "roomFeatures": [],
  "roomTypes": [],
  "planFeatures": [],
  "minRating": 0,
  "minReviewCount": 0,
  "mealsIncluded": "any",
  "freeCancellationOnly": false,
  "minPricePerNight": 0,
  "maxPricePerNight": 0,
  "currency": "JPY",
  "language": "en",
  "priceStoreName": "",
  "onlyNewOrChanged": false,
  "maxConcurrency": 8,
  "delayMs": 0
}
```

# Actor output Schema

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

ikyu search results: 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 = {
    "destinations": [
        "Kyoto"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("boncross/ikyu-search").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 = { "destinations": ["Kyoto"] }

# Run the Actor and wait for it to finish
run = client.actor("boncross/ikyu-search").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 '{
  "destinations": [
    "Kyoto"
  ]
}' |
apify call boncross/ikyu-search --silent --output-dataset

```

## MCP server setup

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

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/5gxMWmdAgHxgSloQ7/builds/A16gj63IO81vZGBeA/openapi.json