# Ikyu Restaurant Scraper - Japan Fine Dining Plans & Prices (`jpopendata/japan-restaurants-ikyu`) Actor

Ikyu restaurant scraper (一休.comレストラン): Japan's curated fine-dining restaurants with genre, area, station, lunch/dinner budgets, course plans and prices, seats, private rooms and ratings by prefecture and area; optional date availability. No reviews. Unofficial; not affiliated with Ikyu Corporation.

- **URL**: https://apify.com/jpopendata/japan-restaurants-ikyu.md
- **Developed by:** [JP Open Data](https://apify.com/jpopendata) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

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

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

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

## Ikyu Restaurant Scraper — Japan Fine Dining Plans & Prices

**Japan's curated fine-dining restaurants from 一休.comレストラン (restaurant.ikyu.com) — genre, area, nearest station, lunch and dinner budget bands, every course plan with its price, seats and private rooms, and the rating average and count, in a clean English schema. Optional: only the restaurants with a free table on a given date and time.**

restaurant.ikyu.com is the restaurant side of Ikyu, Japan's premium booking platform: hotel restaurants, kaiseki, sushi counters, French and Italian fine dining, afternoon teas and buffets, each with bookable course plans and their prices. The site is Japanese-only. This Actor reads its public lists by prefecture and area and returns one record per restaurant — with the course plans and prices that the list shows — and, optionally, the restaurant page's facts (city, seats, private rooms, smoking, cards, hours).

> **Unofficial tool.** Not affiliated with or endorsed by Ikyu Corporation or LY Corporation. It collects **publicly available data only** (no login, no paywall), politely (strictly serial requests at least 1.2 s apart, a hard per-run request budget, no block evasion, robots.txt-allowed pages only), and extracts **factual business data only** — no review texts, no reviewer data, no reservation data, no marketing prose, no photos, no phone numbers, and location only down to the city (no street address, no coordinates). No personal data is collected or processed (relevant e.g. under GDPR). Users are responsible for ensuring their own use of the data complies with the source site's terms and applicable law.

***

### Quick start — verified input

Copy-paste this into the Actor's input (JSON tab) or pass it via API. It was run successfully on 2026-10-13 (10 Kyoto restaurants with their plans and restaurant-page facts, about 20 seconds; the default RESIDENTIAL JP proxy is applied automatically). Running the Actor with an empty input `{}` does exactly the same.

```json
{
  "prefecture": "Kyoto",
  "maxItems": 10
}
```

#### A narrower search

```json
{
  "prefecture": "Kyoto",
  "area": "祇園",
  "genre": "French",
  "budgetMaxJpy": 20000,
  "maxItems": 20
}
```

`area` takes ikyu's Japanese area names (「祇園」 matches 祇園・清水寺周辺), ikyu area codes, or a pasted ikyu area URL such as `https://restaurant.ikyu.com/area/kyoto/002/0097/` for the narrowest areas. `budgetMinJpy` / `budgetMaxJpy` use ikyu's own budget filter (per person, tax and service included).

#### Who has a table on a given evening?

```json
{
  "prefecture": "Tokyo",
  "area": "銀座",
  "visitDate": "2026-10-20",
  "visitTime": "19:00",
  "partySize": 2,
  "maxItems": 10
}
```

With `visitDate`, only restaurants that ikyu shows as bookable at that date, time and party size are returned, each with the plans bookable then, and `availability.available = true`. Without it, every restaurant is returned with all its plans.

#### Common input mistakes

| Wrong | Right | Why |
|---|---|---|
| `"prefecture": "Kyoto-shi"` / `"Yokohama"` | `"prefecture": "Kyoto"` / `"Kanagawa"` | `prefecture` is one of the 47 prefectures (dropdown). Cities go in `area` (Japanese) or nowhere. |
| `"area": "Gion"` | `"area": "祇園"` | Areas are matched against ikyu's Japanese area names; romaji matches nothing (the run warns with the list of valid names). |
| `"area": "Tokyo"` with `"prefecture": "Kyoto"` | `"prefecture": "Tokyo"` and no area | `area` is a part of the chosen prefecture, not a prefecture. |
| `"visitDate": "20/10/2026"` | `"visitDate": "2026-10-20"` | YYYY-MM-DD, today or later (Japan time). |
| `"visitTime": "7pm"` | `"visitTime": "19:00"` | HH:MM between 07:00 and 24:00 in 30-minute steps. |
| `"proxyConfiguration": { "useApifyProxy": false }` | keep the default (RESIDENTIAL, JP) | restaurant.ikyu.com answers datacenter IPs with HTTP 403. |

Every invalid value stops the run **immediately**, before any request to the site, with a message that names the field and lists the valid values.

#### Empty results?

A run that ends with `items: 0` and `complete: true` is not an error. Typical causes: an `area` name that matches none of the prefecture's ikyu areas (the log lists the valid ones), a `genre` or `keyword` that no restaurant in the area has, a budget nobody offers, a `visitDate` with no free table at that time (or a date ikyu does not take bookings for yet — the log says so), or a very small `maxApiRequests` together with a rare filter. Widen the search and run again.

***

### Who is this for?

- **Restaurant and hospitality market research** — the premium dining market by prefecture and area: genres, price levels, course prices, discounts, seats and private rooms, hotel restaurants.
- **Travel and concierge services** — inventory of bookable high-end restaurants, which ones have a table tonight, and at what course price.
- **Hotel F\&B and revenue teams** — competitor course pricing and discounting around your property.
- **Data teams** — a stable English schema over a Japanese-only source, aligned with the same developer's other Japan restaurant Actors (`restaurantName`, `budgetLunch` / `budgetDinner`, `rating`, `reviewCount`).

### Sample output (dataset item, shortened)

```json
{
  "restaurantId": "113383",
  "restaurantName": "宮川町 水簾",
  "restaurantNameKana": "ミヤガワチョウ スイレン",
  "url": "https://restaurant.ikyu.com/113383",
  "genre": ["懐石・会席料理"],
  "genreCategory": "和食",
  "area": "祇園四条",
  "areaGroup": "祇園・清水寺周辺",
  "prefecture": "京都府",
  "prefectureEn": "Kyoto",
  "prefectureCode": "26",
  "city": "京都市東山区",
  "nearestStation": "祇園四条駅",
  "nearestStationDistanceM": 262,
  "budgetLunch": { "raw": "10,000円〜11,999円", "minJpy": 10000, "maxJpy": 11999 },
  "budgetDinner": { "raw": "15,000円〜19,999円", "minJpy": 15000, "maxJpy": 19999 },
  "rating": 4.66,
  "reviewCount": 104,
  "ratingBreakdown": { "food": 4.71, "service": 4.63, "atmosphere": 4.5, "costPerformance": 4.55 },
  "plans": [
    {
      "planId": "12671640",
      "planName": "【昼のメニュー】全9品",
      "mealPeriod": "lunch",
      "pricePerPersonJpy": 10000,
      "regularPricePerPersonJpy": 11200,
      "discountPercent": 10,
      "priceVariesByDate": false,
      "includes": "選べる1ドリンク",
      "seatOnly": false,
      "paymentType": "onsite_only",
      "requestReservation": false
    }
  ],
  "planCount": 5,
  "lowestPlanPriceJpy": 10000,
  "availability": null,
  "totalSeats": 20,
  "privateRooms": 3,
  "hasPrivateRoom": true,
  "smoking": "no smoking",
  "parking": false,
  "wheelchairAccessible": false,
  "childrenAllowed": true,
  "petsAllowed": false,
  "creditCards": ["VISA", "Master", "JCB", "Amex", "Diners"],
  "businessHours": "ランチ 12:00 ～ 15:00 (13:00)\nディナー 18:00 ～ 22:00 (20:00)",
  "closedDays": "月曜日（祝日の場合は営業）",
  "inHotel": null,
  "searchArea": "祇園・清水寺周辺",
  "detailFetched": true,
  "source": "一休.comレストラン (restaurant.ikyu.com)",
  "sourceUrl": "https://restaurant.ikyu.com/",
  "license": "Publicly available data — unofficial tool; users are responsible for compliance with the source site's terms",
  "retrievedAt": "2026-10-13T03:00:00.000Z"
}
```

Plan prices are ikyu's price per person, tax and service included; `regularPricePerPersonJpy` is the plan's regular price. Seat-only bookings carry no price (`seatOnly: true`). The dataset has two views: **Overview** (one row per restaurant) and **Plans** (one row per plan).

### Input reference

- **prefecture** (default `Kyoto`): one of the 47 prefectures by English name (dropdown). Via API the platform checks the list before the run starts.
- **area** (optional): a Japanese ikyu area name, an ikyu area code (3 digits such as `002`, or a 4-digit sub-area such as `0097`), or a pasted ikyu area URL. Empty = the whole prefecture.
- **genre** (optional): keeps restaurants whose genre label contains the text (`フレンチ`, `寿司`, `焼肉` …; common English words such as French, Italian, Japanese, Sushi, Chinese, Yakiniku, Steak, Tempura, Buffet are translated). Several: comma-separated.
- **keyword** (optional): keeps restaurants whose name contains the text.
- **budgetMinJpy / budgetMaxJpy** (optional): ikyu's budget filter, JPY per person.
- **visitDate / visitTime / partySize** (optional): dated availability (`visitTime` default 19:00; `partySize` default 2, 1–99).
- **includePlans** (default true): read ikyu's list in its plan view so every record has its course plans. In this view ikyu leaves out the restaurants that offer no priced plan (seat-only bookings or no plan; on 2026-10-13 that was 40 of 1,264 in Kyoto, about 3%); set `false` to list every restaurant without plans.
- **includeDetails** (default true): one extra request per restaurant for the restaurant-page facts (city, kana, genre category, seats, private rooms, smoking, wheelchair, children/pets, cards, hours, closed days, hotel name, rating breakdown).
- **maxItems** (default 10, max 5000) / **maxApiRequests** (default 0 = automatic, cap 3000) / **proxyConfiguration** (default RESIDENTIAL, JP).

### FAQ

**Where does the data come from?**
Live from restaurant.ikyu.com's public, login-free area lists and restaurant pages, at run time. Every record carries the source, source URL, a license note and the retrieval time.

**Is this an official Ikyu service?**
No. It is **unofficial**, built and maintained independently, and **not affiliated with or endorsed by Ikyu Corporation or LY Corporation.** It reads only pages that the site's robots.txt leaves open (it never uses the site's /search page).

**Are reviews included?**
Only the numeric rating average, the count and the four-part rating breakdown. Review texts and reviewer data are **never extracted**, and review pages are never requested. The restaurants' own marketing texts, photos and phone numbers stay on the source site too; location stops at the city.

**How fresh are availability and prices?**
They are what ikyu shows at the moment of the run. Plans and prices change often; re-run for fresh data. Without `visitDate` the plans are all plans ikyu lists for the restaurant, not a promise that they are bookable on a particular day.

**Do I need a proxy?**
Yes, and it is on by default. restaurant.ikyu.com answers requests from datacenter IP ranges with HTTP 403 (observed 2026-10-13), while the same requests succeed from ordinary consumer connections. The default `proxyConfiguration` therefore uses Apify **Residential** proxies with country **JP**; leave it as is. Residential proxy traffic is billed as Apify platform usage. The Actor uses one residential IP for the whole run and never rotates on its own. If the run's very first request is refused (some residential IPs are), it waits its normal interval and retries that one request **once** on a fresh session (same headers); if that is refused too, the run fails visibly. If the site refuses a request later, the run keeps the records already collected, ends **successfully** with `complete: false` and a `stopReason` in `RUN_SUMMARY`, and you pay only for the records delivered.

**What about server load?**
Strictly serial requests at least 1.2 s apart, 20 restaurants per list page, one optional request per restaurant page, a hard per-run request budget, `Retry-After` honoured, exponential backoff, no CAPTCHA/login/block evasion. If the site's page format changes, the Actor stops instead of guessing. A stop after some records were collected ends the run successfully with `complete: false`; a stop before the first record fails the run visibly.

**Who is responsible for how the data is used?**
You are. The Actor collects publicly available factual data politely, but whether your particular use (for example redistribution) is allowed under the source site's terms and applicable law is your responsibility.

### Search terms this Actor answers

ikyu restaurant scraper · restaurant.ikyu.com scraper · 一休レストラン データ · japan fine dining data · japan restaurant prices api · kaiseki restaurant list · tokyo fine dining restaurants dataset · kyoto restaurant data · japan restaurant availability · hotel restaurant japan data · course menu prices japan · japanese restaurant booking data

### More Japan data Actors by the same developer

- **Japan Luxury Hotels & Ryokan (ikyu.com)** — the hotel side of Ikyu: ratings, room counts and advertised prices.
- **Tabelog Scraper — Japan Restaurants** — ratings, budgets and hours from tabelog.com.
- **HotPepper Gourmet Scraper — Japan Restaurants** — budgets, seats and private rooms from hotpepper.jp.
- **Gurunavi Scraper — Japan Restaurants** — business data from gnavi.co.jp.
- **Japan Hotels & Ryokan Prices (jalan.net)** — Japan's largest domestic travel site.

***

*Unofficial tool; not affiliated with Ikyu Corporation or LY Corporation. Publicly available data only; users are responsible for compliance with the source site's terms and applicable law. No personal data is collected.*

# Actor input Schema

## `prefecture` (type: `string`):

Choose one of the 47 prefectures by its English name (e.g. "Tokyo", "Osaka", "Kyoto"). Via API pass the English name exactly as listed ("Tokyo", not "東京都" or "13" — the platform checks the list before the run starts). Cities are NOT prefectures: use "Kanagawa" for Yokohama, "Aichi" for Nagoya, "Hyogo" for Kobe. Narrow further with area / genre / keyword.

## `area` (type: `string`):

Optional — leave empty for the whole prefecture. To narrow: a Japanese area name as ikyu writes it (e.g. "祇園" matches 祇園・清水寺周辺; "嵐山" matches 嵐山周辺), an ikyu area code (3 digits such as "002", or a 4-digit sub-area such as "0097"), or a pasted ikyu area page URL such as https://restaurant.ikyu.com/area/kyoto/002/0097/ (narrowest). Romaji such as "Gion" matches nothing. A name that matches no area ends the run with 0 records and a warning that lists every valid area name.

## `genre` (type: `string`):

Optional. Keeps restaurants whose ikyu genre label contains this text, applied after reading each list page (e.g. "フレンチ", "寿司", "焼肉", "懐石"). Common English words are translated: French, Italian, Japanese, Kaiseki, Sushi, Chinese, Yakiniku, Steak, Teppanyaki, Tempura, Buffet, Afternoon tea, Unagi, Yakitori, Sukiyaki, Korean, Spanish, Innovative. Several genres: separate with commas. A rare genre may need a higher maxApiRequests.

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

Optional. Keeps restaurants whose name contains this text (case- and width-insensitive), e.g. "鮨" or a hotel name such as "リッツ". Applied after reading each list page.

## `budgetMinJpy` (type: `integer`):

Optional. ikyu's own budget filter: only restaurants with a course plan at or above this price per person (tax and service included), and only those plans. Example: 10000.

## `budgetMaxJpy` (type: `integer`):

Optional. ikyu's own budget filter: only restaurants with a course plan at or below this price per person, and only those plans. Example: 20000. Must not be lower than budgetMinJpy.

## `visitDate` (type: `string`):

Optional. YYYY-MM-DD (today or later, Japan time). When set, the run lists only restaurants with a free table on that date at visitTime for partySize, and each record's plans are the plans bookable then (availability.available = true). Leave empty for undated results (all restaurants with their plans). Dates ikyu does not take bookings for yet give 0 records with a warning.

## `visitTime` (type: `string`):

Optional, used only with visitDate (default 19:00). HH:MM between 07:00 and 24:00 in 30-minute steps, e.g. "12:00" for lunch or "19:30".

## `partySize` (type: `integer`):

Optional, default 2 (ikyu's own default). Number of guests (1–99). Affects which plans ikyu shows (plans have minimum/maximum party sizes) and, with visitDate, which tables are free.

## `includePlans` (type: `boolean`):

Default true. Reads ikyu's list in its plan view, so every record carries the restaurant's course plans (name, lunch/dinner, price per person, regular price, discount). Restaurants with no priced plan (seat-only bookings or no plan — about 3% in Kyoto on 2026-10-13) are not listed in this view; set false to list every restaurant without plans. Ignored when visitDate or a budget is set (plans are always shown then).

## `includeDetails` (type: `boolean`):

Default true. One extra request per restaurant adds the city (municipality — no street address), name reading, genre category, total seats and private rooms, smoking, wheelchair access, children/pets policy, credit cards, business hours, closed days, hotel name and the rating breakdown. Set false for a faster list-only run (20 restaurants per request).

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

Default 10. Stop after this many restaurant records (1–5000). Each list page holds 20 restaurants; with includeDetails each record also costs one request.

## `maxApiRequests` (type: `integer`):

Default 0 = sized automatically from maxItems and the options. Hard budget of HTTP requests to restaurant.ikyu.com for this run (cap 3000). Requests are strictly serial and at least 1.2 s apart, so 300 requests take about 6 minutes. When the budget runs out the run still SUCCEEDS with the records collected so far and complete=false in RUN_SUMMARY.

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

Default: Apify RESIDENTIAL proxy, country JP — required, because restaurant.ikyu.com answers datacenter IP ranges with HTTP 403. Proxy traffic is billed as Apify platform usage. The run keeps ONE sticky session (one IP for the whole run) and never rotates; only a refused FIRST request is retried once on a fresh session.

## Actor input object example

```json
{
  "prefecture": "Kyoto",
  "area": "祇園",
  "genre": "フレンチ",
  "keyword": "鮨",
  "budgetMinJpy": 10000,
  "budgetMaxJpy": 20000,
  "visitTime": "19:00",
  "partySize": 2,
  "includePlans": true,
  "includeDetails": true,
  "maxItems": 10,
  "maxApiRequests": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "JP"
  }
}
```

# Actor output Schema

## `records` (type: `string`):

One record per restaurant with source attribution (source, sourceUrl, license, retrievedAt) on every item.

# 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 = {
    "prefecture": "Kyoto",
    "partySize": 2,
    "includePlans": true,
    "includeDetails": true,
    "maxItems": 10,
    "maxApiRequests": 0,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "JP"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("jpopendata/japan-restaurants-ikyu").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 = {
    "prefecture": "Kyoto",
    "partySize": 2,
    "includePlans": True,
    "includeDetails": True,
    "maxItems": 10,
    "maxApiRequests": 0,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "JP",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("jpopendata/japan-restaurants-ikyu").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 '{
  "prefecture": "Kyoto",
  "partySize": 2,
  "includePlans": true,
  "includeDetails": true,
  "maxItems": 10,
  "maxApiRequests": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "JP"
  }
}' |
apify call jpopendata/japan-restaurants-ikyu --silent --output-dataset

```

## MCP server setup

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

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/yjdz9yOeXhz6FI56W/builds/lmPYmzBiCm3IKeKuN/openapi.json