# Jalan Japan Hotel Prices — What a Night Costs by Area (`jpmarketdata/jalan-japan-hotel-price-checker`) Actor

Enter a Japanese place name and a date, and see what a hotel night really costs on Jalan. You get the typical price per person, the lowest-highest range, how many hotels still have rooms that night, and the average guest rating. $0.02 per area checked, no results = no charge. Unofficial.

- **URL**: https://apify.com/jpmarketdata/jalan-japan-hotel-price-checker.md
- **Developed by:** [h ichi](https://apify.com/jpmarketdata) (community)
- **Categories:** Travel, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 area analyzeds

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Jalan Japan Hotel Prices — What a Night Costs by Area

> **Unofficial** — independent tool, **not affiliated with, endorsed by, or sponsored by Jalan**. It reads only publicly visible pages. Support, reliability guarantees and the full disclaimer are at the bottom of this page.

**What it does:** Name a place in Japan and a night, and get what a hotel bed there really costs on Jalan, Japan's biggest domestic booking site.

**You enter:** a place, in Japanese or English — `京都`, `箱根`, or `Kyoto`, `Hakone` — plus the night, or how many days ahead to look.

**You get:** for that one night: how many hotels still have a room free, the typical price for one person and the low-to-high range in yen and US dollars, the guest-rating spread, Jalan's own sub-area split, and the cheapest and dearest stay by name.

**Price:** $0.02 per place. +$0.002 per row if you also want the list of hotels. No results = no charge.

**Example:** enter `Kyoto`, 30 days ahead → 150 hotels still had a room on 2026-10-09 · typical ¥12,912 a head (US$83.94), from ¥3,500 to ¥50,000 · guest rating 4.2 out of 5 across the 64% of them that carry one · cheapest 旅館なかなか at ¥3,500 (real run, 2026-09-09)

> Unofficial — not affiliated with Jalan. Reads public pages only.

### Pricing — $0.02 per place

| Event | Price | When |
|---|---|---|
| Area night summary | **$0.02** | Per place analyzed, one night |
| Individual hotel | **$0.002** | Only if you turn on **Also return each hotel as a row** |

A default run (1 place, summary only) costs **$0.02** and takes about 17 seconds. You pay per place; there is no monthly fee. **A place that returns zero hotels is never charged.**

Two places on two dates is four charges, not one — every place-and-night pair is its own $0.02. About 5 places fit a single run's reading time; the platform's **$3.00 Maximum cost per run** would stop one at 150.

### Input

| Field | Example | Notes |
|---|---|---|
| `areas` | `["Kyoto"]` | Japanese place names work best (`京都`, `箱根`, `別府`). The 47 prefectures and about 40 famous areas are also known by their English names. Anything else is sent to the site as typed and echoed back as `areaResolved`. $0.02 each |
| `checkInDate` | `"2026-10-09"` | The night to price. Leave empty to use today in Japan plus `daysAhead`, so a saved input never goes stale |
| `daysAhead` | `30` | Used only when `checkInDate` is empty. 0–180 |
| `nights` | `1` | 1–14. Longer stays find fewer hotels; the yen figures stay per person for one night |
| `adults` | `2` | 1–10, all sharing one room. Changes the per-head price and how many hotels have a room big enough |
| `maxHotelsSampled` | `90` | 30–150. Only used on the rare run where the site stops returning cheapest-first |
| `includeIndividualHotels` | `false` | Turn on to also get every hotel that was read, one row each (+$0.002 per row) |
| `convertToUsd` | `true` | Adds US dollar figures at today's rate. A failed lookup never fails the run |

### What the yen figures cover

Every row carries **`priceJpyBasis`**, so you never have to guess:

| `priceJpyBasis` | What it means | When you get it |
|---|---|---|
| **`population`** | Every hotel with a room that night was read — the figures describe all of them | Up to 150 hotels, which is most places most nights (`Kyoto` above: 150 found, 150 read) |
| **`sample`** | Only the hotels that were read | Above 150 hotels, or when a page did not land where it was asked to |

`sampledListings` always says how many hotels the figures were measured on, and `totalListingsFound` how many the site said there were.

Five pages of 30 are read per place. When there are more than 150 hotels, those five pages are spread down the site's cheapest-first list — one at the cheap end, one a quarter of the way down, one at the middle, one at three quarters, one at the dear end — so the sample covers the whole price range instead of piling up at the cheap end.

### The price is not always quoted per person

This is the one thing worth knowing about Jalan's numbers. A hotel card ends either 「3,500円\*\*/人\*\*」 or 「20,000円\*\*/室\*\*」 — per person or per room — while the little grey line under it says 「(大人2名利用時)」 either way. Measured 2026-09-09 for `Kyoto` on 2026-10-09: 1 of the 30 cards on the first page and 16 of the 30 cards at the dear end quoted the **room**.

So every room price is divided by the number of adults its own card says it covers, and both halves are returned:

- **`priceJpy`** and `pricePerPersonJpy` — always per person, comparable across hotels
- **`priceQuotedJpy`** and **`priceQuotedPer`** (`person` or `room`) on each hotel row — the number Jalan printed and which of the two it was
- **`perRoomQuotedShare`** — what fraction of the hotels read went through that division (0.1867 in the example below)

A tool that reads the number without its unit puts a ¥100,000 room next to a ¥20,000 head in the same median. That ¥50,000 maximum below is a ¥100,000 room for two.

### Output example (`type: "area_night_price_summary"`)

Measured on 2026-09-09 (real run, `{"areas": ["Kyoto"], "daysAhead": 30, "nights": 1, "adults": 2, "includeIndividualHotels": false}`). The whole row, nothing shortened.

```json
{
  "type": "area_night_price_summary",
  "area": "Kyoto",
  "areaResolved": "京都",
  "areaStatus": "ok",
  "checkInDate": "2026-10-09",
  "nights": 1,
  "adults": 2,
  "sortUsed": "price_asc",
  "totalListingsFound": 150,
  "totalFoundCapped": false,
  "sampledListings": 150,
  "priceJpy": {
    "min": 3500,
    "p25": 9992,
    "median": 12912,
    "p75": 15968,
    "max": 50000,
    "average": 13313
  },
  "priceJpyBasis": "population",
  "pricedListings": 150,
  "perRoomQuotedShare": 0.1867,
  "priceUsd": {
    "min": 22.75,
    "p25": 64.96,
    "median": 83.94,
    "p75": 103.81,
    "max": 325.05,
    "average": 86.55
  },
  "exchangeRateJpyUsd": 0.006501,
  "guestRating": {
    "min": 3.0,
    "p25": 4.0,
    "median": 4.2,
    "p75": 4.4,
    "max": 4.7,
    "average": 4.11
  },
  "ratedShare": 0.64,
  "reviewsPerHotel": {
    "median": 104,
    "max": 5540
  },
  "subAreaMix": [
    {
      "subArea": "京都駅周辺",
      "hotels": 69,
      "medianPricePerPersonJpy": 13175
    },
    {
      "subArea": "河原町・烏丸・大宮周辺",
      "hotels": 54,
      "medianPricePerPersonJpy": 13350
    },
    {
      "subArea": "祇園・東山・北白川周辺",
      "hotels": 15,
      "medianPricePerPersonJpy": 14336
    },
    {
      "subArea": "湯の花・丹波・美山",
      "hotels": 4,
      "medianPricePerPersonJpy": 4000
    },
    {
      "subArea": "天橋立・宮津・舞鶴",
      "hotels": 3,
      "medianPricePerPersonJpy": 3900
    },
    {
      "subArea": "嵯峨野・嵐山・高雄",
      "hotels": 2,
      "medianPricePerPersonJpy": 5100
    },
    {
      "subArea": "綾部・福知山",
      "hotels": 2,
      "medianPricePerPersonJpy": 4398
    },
    {
      "subArea": "丹後・久美浜",
      "hotels": 1,
      "medianPricePerPersonJpy": 3800
    }
  ],
  "cheapestStay": {
    "name": "旅館なかなか",
    "yadNo": "372448",
    "pricePerPersonJpy": 3500
  },
  "dearestStay": {
    "name": "サクラクロスホテル京都清水",
    "yadNo": "392838",
    "pricePerPersonJpy": 50000
  },
  "monotonicityCheck": "ok",
  "hint": null,
  "sourceUrl": "https://www.jalan.net/uw/uwp2011/uww2011search.do?actionId=G&keyword=%8B%9E%93s&stayYear=2026&stayMonth=10&stayDay=09&stayCount=1&adultNum=2&roomCount=1&distCd=06&rootCd=7701&screenId=UWW2011&activeSort=1&minPrice=0&maxPrice=999999&dispStartIndex=0",
  "checkedAt": "2026-09-09T01:09:09.902873+00:00"
}
```

With **Also return each hotel as a row** turned on you additionally get one row per hotel:

```json
{
  "type": "hotel",
  "area": "Ginzan",
  "checkInDate": "2026-10-09",
  "yadNo": "324795",
  "name": "天童セントラルホテル",
  "subArea": "山形・蔵王・天童・上山",
  "priceQuotedJpy": 4579,
  "priceQuotedPer": "person",
  "pricePerPersonJpy": 4579,
  "guestRating": 4.1,
  "reviewCount": 559,
  "address": "山形県天童市本町2-1-31",
  "hotelUrl": "https://www.jalan.net/yad324795/"
}
```

### When a place comes back empty

`areaStatus` is `ok` as soon as the site returns hotels, `not_found` when it returns none — with `hint` naming the next thing to try in one sentence (`null` otherwise). **A place that returns nothing is never charged.**

Jalan matches the word loosely against hotel names, so a place name it does not know can still find something: measured 2026-09-09, `zzzqqxnotarealplace` returned 8 hotels, most of them with "Place" in the name, from Otaru to Fukuoka. Read `areaResolved` and the sub-area split when a result looks scattered — a real place name concentrates in a few sub-areas.

### What this Actor does not do

- **No photos, no guest-review text, no hotel blurbs, no plan wording.** The product is the numbers plus the plain facts about a hotel — name, sub-area, address, price, rating, review count. This is a deliberate limit, not an oversight (Jalan's terms, art.5-1 and art.8)
- **No booking, and no prices from any other site.** These are Jalan's own asking prices for that one night
- **No history.** Each run reads the site live; nothing is kept between runs. Run the same place on two dates yourself to see a night-by-night curve
- **No hotels without a room that night.** Hotels the site lists under 「keyword only」 are left out on purpose — see below
- **No personal data.** Guest ratings are returned as a score and a count, never as text or as anything about who wrote them

### Notes on the data

- **Every page is Windows-31J (Shift\_JIS)**, robots.txt included. The place name is sent as its CP932 bytes (`京都` → `%8B%9E%93s`); sent as anything else the site finds nothing
- **`totalListingsFound` is hotels with a room free that night, not a hotel directory.** It moves with the date, which is the point: measured for `京都`, 2 adults, 1 room, 1 night — 150 on 2026-10-09, 157 on 2026-10-08 and 173 on 2026-11-03. A night two days away finds far fewer than one a month out
- **1,000 exactly means the site stopped counting.** That is the ceiling an undated search saturates at, so a dated search reporting exactly 1,000 sets `totalFoundCapped: true` and the figure should be read as "at least 1,000"
- **Hotels that match the name but have no room that night are dropped.** The site prints them under 「以下は、キーワードのみ合致した宿泊施設です」 with the note that their price is the cheapest over the next four months — a different night and a different number. Measured 2026-09-09, `Ginzan` printed 30 cards of which 23 were bookable that night; the other 7 were left out
- **`average` is the mean of the hotels read**, like every other figure in `priceJpy`; when `priceJpyBasis` is `population` those are all of them
- **Guest ratings cover fewer hotels than the prices do.** About a third of hotels carry no Jalan score at all — `ratedShare` says how many did (0.64 in the example above), and the rating figures keep their two decimals rather than being rounded to whole stars
- **`sortUsed` is always `price_asc`.** The site's own default is relevance order, so cheapest-first is asked for explicitly every time and checked afterwards: `monotonicityCheck` is `ok` when the prices really did come back in order and `violated` when they did not, in which case the run stops paging and the figures cover only the pages already read and say `sample`
- **`subAreaMix` uses Jalan's own regions** (`京都駅周辺`, `祇園・東山・北白川周辺`, `天橋立・宮津・舞鶴`), which are how Japanese travellers divide a destination — not wards, not train lines
- Requests are spaced 2 seconds apart and one place costs at most 5 of them; the run carries a wall-clock budget, and if it is reached the remaining places are read from their first page only and their rows say `truncatedForTimeLimit: true`

### If something goes wrong

- **Wrong number or a failed run?** Open a ticket on the **Issues** tab. I read every one and reply within 2 business days (Japan time).
- **You never get a fake "empty" result.** If the site can't be read, the run fails and says so.
- **No results = no charge.** You only pay for results you actually get.
- **Checked every week.** An automatic test runs this tool weekly; if the site changes, I fix it.
- **Public pages only.** No login, no personal data, and it goes easy on the site.

### More tools by the same author

- [Mercari Japan Sold Prices — What Items Really Sell For](https://apify.com/jpmarketdata/mercari-japan-price-checker)
- [Yahoo! Auctions Japan Sold Prices — Median, Range, Bids](https://apify.com/jpmarketdata/yahoo-auction-sold-comps)

All tools (Japan marketplaces, real estate, jobs, racing, prediction markets): <https://apify.com/jpmarketdata>

### Disclaimer

Unofficial, independent tool — **not affiliated with, endorsed by, or sponsored by Jalan**. Product names and logos belong to their owners and only say where the data comes from. Data is read from public pages, for market research; check before you act on it.

# Actor input Schema

## `areas` (type: `array`):

One row of numbers per place. Each area is charged $0.02, and an area with no room free that night is not charged. Japanese place names work best (`京都`, `箱根`, `別府`); the 47 prefectures and about 40 famous areas are also known by their English names (`Kyoto`, `Hakone`), and anything else is sent as typed. About 5 areas fit a run's reading time; the $3.00 Maximum cost per run stops one at 150.

## `checkInDate` (type: `string`):

The night you want priced, e.g. `2026-10-09`. Leave it empty and the night is today in Japan plus the days below, so a saved input never goes stale. The date moves every number: measured 2026-09-09, 京都 had 149 hotels with a room free on 2026-10-09 and 173 on 2026-11-03. It does not change what you are charged.

## `daysAhead` (type: `integer`):

Used only when the night above is empty: the night priced is today in Japan plus this many days. 30 means about a month out. A night far ahead usually has more hotels with rooms free and cheaper prices than one a day or two away, so this quietly decides which market you are looking at. It does not change what you are charged.

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

How many nights the stay covers. Longer stays shrink the list, because fewer hotels have every night free: measured 2026-09-09, 京都 from 2026-10-09 had 149 hotels for one night and 55 for two. The yen figures stay per person for one night either way. It does not change what you are charged.

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

How many adults share the single room that is searched for. The site prices per person at that occupancy, so two adults sharing is cheaper per head than one adult alone, and a larger party finds fewer hotels with a room big enough. The number of rooms is always 1. It does not change what you are charged.

## `maxHotelsSampled` (type: `integer`):

A safety net for the rare run where the site stops returning cheapest-first. The yen figures are then measured on this many hotels from the top of the list instead of the whole list, and the row says so in `priceJpyBasis` and `monotonicityCheck`. A normal run reads 5 pages whatever this says. It does not cap the hotel rows: with individual hotels on, every hotel read is a row (+$0.002 each).

## `includeIndividualHotels` (type: `boolean`):

Off by default: a run costs a flat $0.02 per area. Turn it on to also get the hotels that were read, one row each, at +$0.002 per row — hotel number, name, the site's own sub-area, price per person, guest rating, review count, address and link. Photos, review text and plan wording are never returned, on or off.

## `convertToUsd` (type: `boolean`):

Adds a US dollar copy of the yen price figures at today's rate. A failed rate lookup never fails the run — you simply get the yen numbers on their own.

## Actor input object example

```json
{
  "areas": [
    "Kyoto"
  ],
  "checkInDate": "",
  "daysAhead": 30,
  "nights": 1,
  "adults": 2,
  "maxHotelsSampled": 90,
  "includeIndividualHotels": false,
  "convertToUsd": true
}
```

# Actor output Schema

## `areaNightPrices` (type: `string`):

One row for each place you asked about on the night you asked about. It carries the number of hotels with a room free, the typical price for one person and the low-to-high range in yen and US dollars, the guest-rating spread and Jalan's own sub-area split.

# 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 = {
    "areas": [
        "Kyoto"
    ],
    "checkInDate": "",
    "daysAhead": 30,
    "nights": 1,
    "adults": 2,
    "maxHotelsSampled": 90
};

// Run the Actor and wait for it to finish
const run = await client.actor("jpmarketdata/jalan-japan-hotel-price-checker").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 = {
    "areas": ["Kyoto"],
    "checkInDate": "",
    "daysAhead": 30,
    "nights": 1,
    "adults": 2,
    "maxHotelsSampled": 90,
}

# Run the Actor and wait for it to finish
run = client.actor("jpmarketdata/jalan-japan-hotel-price-checker").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 '{
  "areas": [
    "Kyoto"
  ],
  "checkInDate": "",
  "daysAhead": 30,
  "nights": 1,
  "adults": 2,
  "maxHotelsSampled": 90
}' |
apify call jpmarketdata/jalan-japan-hotel-price-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jpmarketdata/jalan-japan-hotel-price-checker"
        }
    }
}

```

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/nvCq3jWOoZYKyCehc/builds/8M5HgqgFaKsc6sesR/openapi.json