# Japan Restaurants Scraper (Gurunavi) (`jpopendata/japan-restaurants-gnavi`) Actor

Restaurants from r.gnavi.co.jp (Rakuten Gurunavi) by prefecture, area and genre — published business phone, address, budgets, hours, seats and facility info in a clean English schema. Unofficial; not affiliated with Gurunavi, Inc. No review content, no user data.

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

## Pricing

from $2.00 / 1,000 record scrapeds

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

## Japan Restaurants Scraper (Gurunavi)

**Restaurant data from Rakuten Gurunavi (楽天ぐるなび, r.gnavi.co.jp) — one of Japan's largest restaurant guides — by prefecture, neighbourhood and cuisine, in a clean English schema: published business phone numbers, addresses with postal codes, budgets, opening hours, seat counts, smoking policy, private rooms, parking and accepted credit cards.**

This Actor scrapes r.gnavi.co.jp listing pages (and optionally each restaurant's detail page) and returns structured JSON: restaurant name with katakana reading, cuisine genre, average lunch/dinner/party budgets as parsed yen values, nearest station and access line, street address, the shop's own published phone number, opening hours, closed days, total seats, facility facts and coordinates. Gurunavi is the restaurant guide where shops publish their **real business phone numbers** — which makes it the strongest Japanese source for restaurant B2B lead lists.

> **Unofficial tool.** Not affiliated with or endorsed by Gurunavi, Inc. or Rakuten Group. This Actor collects **publicly available factual business data only** — it never collects review content, user identities or shop-authored promotional prose, and it never bypasses logins or CAPTCHAs. You are responsible for using the data in compliance with the source site's terms and the laws that apply to you (including GDPR/APPI where relevant); the published phone numbers are business contact information published by the restaurants themselves, not personal data — verify your own legal basis before using them for outreach.

***

### 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-09-02 (10 izakaya in Shibuya, Tokyo, listing data only, ~15 seconds):

```json
{
  "prefecture": "Tokyo",
  "area": "shibuya",
  "genre": "izakaya",
  "maxItems": 10
}
```

Running with **no input at all** also works (defaults: Tokyo, all areas, all genres, 10 records). Add `"detailFetch": true` to fill address / phone / hours (one extra request per restaurant, ~1.2 s each).

#### Common input mistakes

| Wrong | Right | Why |
|---|---|---|
| `"prefecture": "Osaka-shi"` / `"Yokohama"` / `"Shibuya"` | `"prefecture": "Osaka"` / `"Kanagawa"` / `"Tokyo"` | `prefecture` must be one of the 47 prefectures (English name). Cities and wards go in `area`, or nowhere. |
| `"area": "Osaka"` or `"area": "Tokyo"` | leave `area` empty (or `"area": "areal2125"`) | `area` is a neighbourhood, not a city/prefecture. Take the code from a r.gnavi.co.jp listing URL. |
| `"area": "Namba"` (a non-Tokyo neighbourhood by name) | `"area": "areal27xx"` code copied from the site URL | Built-in English names exist for Tokyo only; every other neighbourhood works via its area code. |
| `"genre": "Ramen restaurants"` | `"genre": "noodle"` (or `"ramen"`) | Use a Gurunavi genre slug (17 values — see the dropdown); `ramen`, `yakiniku`, `italian`, `bar` … are mapped automatically. |
| `"prefecture": "東京都"` or `"13"` or `"tokyo"` (via API) | `"prefecture": "Tokyo"` | The platform checks the 47 English names before the run starts; other spellings are rejected with the valid list. |
| `"maxItems": "100"` | `"maxItems": 100` | Numbers are numbers in JSON — the platform rejects a numeric string before the run starts. |
| `"detailFetch": true` with `"maxItems": 100` and default `maxApiRequests` | add `"maxApiRequests": 60` (or lower `maxItems`) | Each detail costs a request; when the budget runs out the run still succeeds but with `complete: false`. |

Every invalid value stops the run **immediately** (before any request to r.gnavi.co.jp) with a message that lists the valid values.

#### Empty results?

A run that finishes with `items: 0` and `complete: true` is not an error — the query simply matched nothing on Gurunavi. Typical causes: an `area` code from a different prefecture than `prefecture` (the area code wins — check the URL you copied), a very specific `area` + `genre` combination (e.g. a small `areas…` code plus `buffet`), or a genre that has few listings outside big cities. Widen the query (drop `genre`, or use the `areal…` large-area code) and re-run.

***

### Who is this for?

- **B2B suppliers and services** — lead lists of restaurants by area and genre with the shop's own published phone number, address, seat count and budget positioning (POS systems, food suppliers, recruiting, insurance, delivery services).
- **Market research and location intelligence** — density, price points and facility profiles (private rooms, smoking policy, parking, seats) of restaurants by neighbourhood and cuisine.
- **Travel, food-tech and recommendation products** — English-schema Japanese restaurant data with reservation-grade facility details.

Looking for the Tabelog rating instead? Gurunavi publishes no public ratings — use the sibling Actor **[Japan Restaurants Scraper (Tabelog)](https://apify.com/store?search=japan-restaurants-tabelog)** for ratings, review counts and bookmark counts, and this Actor for phone-rich lead data; the two share an aligned schema (`restaurantName` / `genre` / `budgetDinner` / `address` / `prefectureEn` / `phone` / `url`) so the datasets join cleanly.

### Sample output (dataset item)

```json
{
  "restaurantName": "大衆居酒屋 酒場三九 渋谷店",
  "restaurantNameKana": "タイシュウイザカヤサカバサンキュウシブヤテン",
  "genre": ["居酒屋"],
  "budgetDinner": { "raw": "2,000円（通常平均）", "minJpy": 2000, "maxJpy": 2000 },
  "budgetLunch": { "raw": "1,000円（ランチ平均）", "minJpy": 1000, "maxJpy": 1000 },
  "budgetParty": { "raw": "3,500円（宴会平均）", "minJpy": 3500, "maxJpy": 3500 },
  "address": "東京都渋谷区宇田川町13-8ちとせ会館5F",
  "postalCode": "150-0042",
  "prefecture": "東京都",
  "prefectureEn": "Tokyo",
  "prefectureCode": "13",
  "nearestStation": "ＪＲ渋谷駅",
  "access": "ＪＲ渋谷駅 徒歩3分",
  "phone": "03-6427-8513",
  "businessHours": "月～木・日・祝前日・祝日 14:00～24:00 （L.O.23:30、ドリンクL.O.23:30） 金・土 14:00～翌4:00 （L.O.3:30、ドリンクL.O.3:30）",
  "closedDays": "年中無休",
  "totalSeats": 240,
  "smoking": "喫煙可（全席喫煙可）",
  "privateRooms": null,
  "parking": "無",
  "creditCards": ["VISA", "MasterCard", "JCB", "アメリカン・エキスプレス", "ダイナースクラブ"],
  "amenities": ["喫煙可", "お子様連れ", "食べ放題メニュー", "飲み放題メニュー"],
  "latitude": 35.6611418,
  "longitude": 139.6985508,
  "url": "https://r.gnavi.co.jp/9mpsba4d0000/",
  "gnaviShopNo": "9mpsba4d0000",
  "gnaviId": "gjf3506",
  "detailFetched": true,
  "source": "楽天ぐるなび (Gurunavi, r.gnavi.co.jp)",
  "sourceUrl": "https://r.gnavi.co.jp/",
  "license": "Publicly available data — unofficial tool; users are responsible for compliance with the source site's terms",
  "retrievedAt": "2026-08-25T09:12:44.000Z"
}
```

In cheap list-only mode (`detailFetch: false`, the default) each listing page request yields 30 records with name, genre, average budgets, access/nearest station and URL; address/phone/hours/facility fields are `null`.

The `phone` field is always the shop's **own published business line** (from the page's structured data) — never the Gurunavi 050 reservation tracking number shown in the on-page info table.

### Input reference

```json
{
  "prefecture": "Tokyo",
  "area": "shibuya",
  "genre": "izakaya",
  "maxItems": 60,
  "detailFetch": true,
  "maxApiRequests": 60
}
```

- **prefecture** (required): English name of one of the 47 prefectures exactly as in the dropdown (`"Tokyo"`, `"Osaka"`, `"Kyoto"` …). The Apify platform validates this list before the run starts, so `"東京都"`, `"13"` or `"tokyo-to"` are rejected immediately with the list of valid values (the actor itself would accept them — this matters only for local `apify run`). Cities are not prefectures — `"Yokohama"` is rejected; use `"Kanagawa"`.
- **area** (optional): a Gurunavi area code copied from any r.gnavi.co.jp URL — `areal2125` (large area), `aream…` / `areas…` (medium/small) — this works for **every neighbourhood in Japan**. Convenience English names are built in for famous Tokyo areas (shinjuku, shibuya, ginza, ikebukuro, roppongi, ueno, asakusa, akihabara, ebisu, shinagawa, kichijoji …; `Shibuya-ku` and `渋谷` also work). Unknown free text is refused with the list of valid values instead of guessing the wrong neighbourhood.
- **genre** (optional): one of the 17 Gurunavi genre slugs (`izakaya`, `japanese`, `sushi`, `roastmeat`, `western`, `buffet`, `curry`, `chinese`, `continental`, `hotpots`, `ethnic`, `noodle`, `beerandcuisine`, `cafe`, `entertainment`, `casual`, `others`) with common aliases (`ramen`→`noodle`, `yakiniku`→`roastmeat`, `italian`/`french`→`western`, `bar`→`beerandcuisine`) and Japanese labels (`居酒屋`, `寿司` …). Anything else is refused before the first request, listing all valid genres.
- **maxItems** (default 10, max 1000) / **maxApiRequests** (default 15, max 60) / **detailFetch** (default false) / **proxyConfiguration** (default none).

### Pricing

Pay per result — see the pricing tab. A listing-only run is cheap (30 records per upstream request); `detailFetch: true` costs one extra upstream request per restaurant and fills the business-info fields.

### FAQ

**Where does the data come from?**
Live from public r.gnavi.co.jp listing and shop pages at run time. Every record embeds the source, source URL, a license note and the retrieval timestamp.

**Is this an official Gurunavi/Rakuten service?**
No. **Unofficial**, independently built and maintained, not affiliated with or endorsed by Gurunavi, Inc. or Rakuten Group. Gurunavi is a trademark of its owner. (The official Gurunavi web API stopped accepting new registrations in 2021 — this Actor reads the public website instead.)

**Does it collect reviews or user data?**
**No, by design.** The parser deletes any review array from the page's structured data before reading anything, never reads user content, and also skips shop-authored promotional prose (descriptions, photo captions) and paid ad placements — automated tests assert that none of it can ever appear in the output. Only factual business data survives. Gurunavi publishes no rating scores, so there are no rating fields — see the Tabelog sibling Actor for ratings.

**Are the ratings missing?**
Gurunavi does not publish public rating scores. If you need ratings, run the sibling **Japan Restaurants Scraper (Tabelog)** — its schema is aligned with this one so you can join on name/address/coordinates.

**Why did my run stop before maxItems?**
The Actor enforces a hard per-run request budget (`maxApiRequests`) with strictly serial requests ≥1.2 s apart — polite by construction. The run summary (`RUN_SUMMARY` key-value record) reports `complete: false` with the reason whenever a budget truncated the result set. Raise `maxApiRequests` or narrow the query.

**What if r.gnavi.co.jp blocks the datacenter IP?**
The Actor performs **no block evasion** (no header spoofing, no CAPTCHA solving, no rotation tricks). If the runtime IP is refused it fails visibly with the HTTP status. Setting `proxyConfiguration` (e.g. Apify automatic proxy) usually resolves it.

**Is the whole of Japan covered?**
Yes — any prefecture, and any neighbourhood via its Gurunavi area code. What one run returns is your query's result set subject to `maxItems` and the request budget, both reported honestly in the run summary.

### Search terms this Actor answers

gurunavi scraper · gnavi scraper · Gurunavi API · Japan restaurant database · Japan restaurant leads · restaurant phone numbers Japan · Tokyo dining data · japan restaurant scraper · izakaya list Tokyo · Japanese restaurant contact list · ぐるなび データ · restaurant B2B leads Japan · Japan food service market data

### More Japan data Actors by the same developer

- **Japan Restaurants Scraper (Tabelog)** — the same aligned schema with the famous Tabelog rating, review counts and bookmark counts.
- **Japan Government Tenders & Awards** — tender notices and award results from the kkj.go.jp portal.
- **Japan Medical Facilities** — every registered hospital, clinic, dental clinic, and pharmacy (MHLW open data).
- **Japan Care Facilities** — long-term care providers across 35 service types (MHLW open data, CC BY).
- **Japan Government Subsidies & Grants** — open subsidy calls from the official jGrants API.
- **Japan Construction & Real-Estate Licenses** — licensed contractors and brokers from MLIT's official register.
- **Japan Financial Licenses & Registrations** — FSA-licensed banks, securities firms, crypto exchanges and more.

***

*Data source: r.gnavi.co.jp public pages. Unofficial; not affiliated with Gurunavi, Inc. or Rakuten Group. Factual business data only — no review content, no user data, no promotional prose. Users are responsible for their own compliance with the source site's terms and applicable law.*

# Actor input Schema

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

REQUIRED. Choose one of the 47 prefectures by its English name (e.g. "Tokyo", "Osaka", "Kyoto"). Via API/CLI pass the English name exactly as listed (e.g. "Tokyo", not "東京都" / "13" / "tokyo-to" — the platform validates the list before the run starts and rejects anything else with the list of valid values). Cities are NOT prefectures: use "Kanagawa" for Yokohama, "Aichi" for Nagoya, "Osaka" for Osaka-shi. Gurunavi listings are prefecture-scoped; narrow further with area / genre.

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

Optional. Leave EMPTY to scrape the whole prefecture (recommended for a first run). To narrow to a neighbourhood: (1) copy a Gurunavi area code from any r.gnavi.co.jp listing URL — e.g. "areal2125" from https://r.gnavi.co.jp/area/areal2125/rs/ (渋谷・原宿・青山); "areal…" = large area, "aream…" / "areas…" = medium / small area — this works for EVERY neighbourhood in Japan; or (2) for Tokyo use a built-in name: shinjuku, shibuya, ginza, ikebukuro, roppongi, ueno, asakusa, akihabara, ebisu, shinagawa, kichijoji, shinbashi, marunouchi, odaiba, kamata, tachikawa, machida … (Japanese 渋谷 / 新宿 also work). Do NOT put a city or prefecture name here (e.g. "Osaka", "Yokohama") — that is not an area and the run stops with an explanation.

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

Optional. Leave empty for all genres. One of the 17 Gurunavi genres (the slug used in listing URLs such as https://r.gnavi.co.jp/area/tokyo/izakaya/rs/). Common English words are mapped for API users: ramen → noodle, yakiniku / bbq → roastmeat, italian / french → western, bar → beerandcuisine, coffee / sweets → cafe, karaoke → entertainment, hotpot → hotpots, asian / thai / korean → ethnic; Japanese labels (居酒屋, 寿司, ラーメン …) are accepted too. Any other value stops the run immediately with the list of valid genres.

## `detailFetch` (type: `boolean`):

Optional, default false. When true, each restaurant costs one extra upstream request and adds the published business info: street address with postal code, the shop's own published phone number, kana reading, business hours, closed days, total seats, smoking policy, private rooms, parking, accepted credit cards, amenities and coordinates. When false, the actor emits listing data only (name, genre, average budgets, access / nearest station, URL) — 30 records per request, fastest and cheapest.

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

Optional, default 10. Stop after this many restaurant records (1..1000). Each listing page yields up to 30 records; with detailFetch each record also needs one detail request, so raise maxApiRequests accordingly (maxItems 60 with details ≈ 62 requests).

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

Optional, default 15. Hard budget of HTTP requests to r.gnavi.co.jp for this run (1 per listing page of 30 restaurants + 1 per detail page). Requests are strictly serial with >= 1.2 s spacing. When the budget runs out the run still SUCCEEDS with the records collected so far and complete=false in RUN\_SUMMARY (not an error).

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

Optional. Apify proxy settings. Default: no proxy (direct connection works from Apify datacenter IPs as of 2026-09). Never used for rotation/evasion — a single serial session is kept per run. Set only if r.gnavi.co.jp starts refusing the runtime IP (HTTP 403).

## Actor input object example

```json
{
  "prefecture": "Tokyo",
  "area": "shibuya",
  "genre": "",
  "detailFetch": false,
  "maxItems": 10,
  "maxApiRequests": 15
}
```

# Actor output Schema

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

Structured records 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": "Tokyo",
    "maxItems": 10,
    "maxApiRequests": 15
};

// Run the Actor and wait for it to finish
const run = await client.actor("jpopendata/japan-restaurants-gnavi").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": "Tokyo",
    "maxItems": 10,
    "maxApiRequests": 15,
}

# Run the Actor and wait for it to finish
run = client.actor("jpopendata/japan-restaurants-gnavi").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": "Tokyo",
  "maxItems": 10,
  "maxApiRequests": 15
}' |
apify call jpopendata/japan-restaurants-gnavi --silent --output-dataset

```

## MCP server setup

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

```

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/nKXIWfFmlO0hMrzeg/builds/n97WaghT6bPYjrQ84/openapi.json