# Japan Travel Guide - Travel Info & Data for All 47 Prefectures (`kotaro-project/japan-travel-guide`) Actor

Japan travel information and Japan travel data in English for every prefecture of Japan: places to see with time needed, best season and access, local Japanese food with price ranges, getting around, places to stay and family travel. Built for travel apps and AI trip planners.

- **URL**: https://apify.com/kotaro-project/japan-travel-guide.md
- **Developed by:** [KOTARO project](https://apify.com/kotaro-project) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $9.99 / full japan guide

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

## Japan Travel Guide — Japan Travel Information & Data, All 47 Prefectures (English)

Structured English travel data for **every prefecture of Japan**, written for visitors from outside Japan. One Actor, the whole country, down to the details travellers actually need.

- **288 places to see** — each with Japanese name, one-line summary, time needed, best time to visit, opening hours (where available), how to get there and nearby places
- **282 practical guides** — local food (dishes with Japanese names, descriptions, price ranges, vegetarian labels), hidden favourites with what to order, getting around, family travel and more
- **Where to stay** in each area — hotels, ryokan and onsen inns
- **69 features** — 53 themes (cherry blossom, autumn leaves, onsen, ramen, sushi, castles, festivals, vegetarian, travelling with children…) and 16 special guides (campervan trips from Tokyo, Hokkaido and Kyushu; Asakusa and Ueno; Shibuya and Shinjuku; Tokyo Disney Resort; Kyoto, Osaka, Hiroshima and Okinawa in a day; Mt. Fuji…)
- **2,100+ detailed items** in total
- **Japan essentials, free with every run** — 12 pages for when something goes wrong: if you feel unwell, asking someone to call for you, embassies, words that work, your first night, staying connected, manners, the last train, luggage, weather, dietary cards

Built for travel apps, AI trip planners, tour operators and content teams.

### Four ways to get it

| Mode | What you get |
|---|---|
| `all` | All of Japan — 47 prefectures, 570 pages |
| `area` | One area — Hokkaido, Tohoku, Kanto, Chubu, Kansai, Chugoku, Shikoku, Kyushu or Okinawa |
| `features` | All 69 themes and special guides |
| `feature` | Only the features you list |

Every run ends with the 12 Japan essentials pages, at no charge. Every record carries its `area`, so the whole country can be laid out on one map.

### Input examples

All of Japan:

```json
{ "mode": "all" }
```

The Kanto area, short list:

```json
{ "mode": "area", "area": "Kanto", "includeDetails": false }
```

Two features:

```json
{ "mode": "feature", "features": ["campervan-kanto", "tokyo-route-east"] }
```

### Output example (place)

```json
{
  "id": "gifu/gujo-hachiman",
  "type": "place",
  "prefecture": "Gifu",
  "nameEn": "Gujo Hachiman",
  "nameJa": "郡上八幡",
  "summary": "A water town of clear channels running through the streets, and a dance that runs all night in August.",
  "timeNeeded": "Half a day",
  "bestTime": "Early morning, whatever the season",
  "nearby": ["Shirakawa-go", "Takayama old town", "Gero Onsen"],
  "url": "https://lets.neuro-hive.jp/pref/gifu/gujo-hachiman.html"
}
```

### Pricing

A fixed price per run, by mode:

| Mode | Price |
|---|---|
| All of Japan (570 pages) | $9.99 per run |
| One area | $1.99 per run |
| All 69 features | $8.88 per run |
| Chosen features | $0.29 per feature |
| Japan essentials (12 pages) | free, with every run |

If the input cannot be answered (for example an unknown area or feature name), the run returns one record with `"error"` and nothing is charged.

### Notes

- Content is from the Let's! Japan travel guide (lets.neuro-hive.jp). Photos are not included.
- Opening hours and seasonal events are as researched when each page was written; every record carries `dataBuiltAt` (the date the data was rebuilt). Check before you go.
- Prices (food, admission and the like) are indicative, as researched when each page was written; check before you go. External links may change.
- The data is rebuilt whenever the Let's! guide is updated (weekly checks, monthly seasonal updates).

### Keywords

Japan, Japanese, Japan travel, Japan travel data, Japan travel information, Japan tourism, Japan guide, Japanese food, Japan sightseeing, Japan hotels and onsen, Japan trip planner, Asia travel, East Asia travel, Asia travel data

# Actor input Schema

## `mode` (type: `string`):

Every run also includes the 12 'Japan essentials' pages (medical help, emergencies, embassies, phrases, manners and more) free of charge.

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

Areas as grouped by the Let's! guide. Chubu includes Niigata, Nagano and the Hokuriku coast.

## `features` (type: `array`):

Feature names, e.g. campervan-kanto, tokyo-route-east (Asakusa and Ueno), tokyo-disney-resort, cherry-blossom, ramen, onsen.

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

Include paragraphs and item lists (dishes, shops, tips). Turn off for a short list.

## Actor input object example

```json
{
  "mode": "all",
  "includeDetails": true
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("kotaro-project/japan-travel-guide").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("kotaro-project/japan-travel-guide").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 '{}' |
apify call kotaro-project/japan-travel-guide --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kotaro-project/japan-travel-guide"
        }
    }
}
```

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/uoZ26C4jurhBmVPyA/builds/8MKZ0en1pBAneieZ5/openapi.json