# Gurunavi Scraper - Japan Restaurants, Budgets & Hours (`scrapewise/gurunavi-scraper`) Actor

Scrape Gurunavi (ぐるなび), Japan's restaurant guide: name, cuisine, lunch and dinner budget, address, phone, coordinates, hours, closed days, seats, courses, reservation availability and photos. Search by keyword, prefecture, cuisine, budget and features, or paste links. Error rows are free.

- **URL**: https://apify.com/scrapewise/gurunavi-scraper.md
- **Developed by:** [Scrapewise Data](https://apify.com/scrapewise) (community)
- **Categories:** Travel, Lead generation
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.04 / 1,000 restaurant delivereds

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

## Gurunavi Scraper: Japan restaurants with budgets, address, phone, hours, courses and availability

Scrape [Gurunavi](https://r.gnavi.co.jp/) (ぐるなび), one of Japan's biggest restaurant guides, **without an account**:
restaurant name and kana reading, cuisine, lunch and dinner budget in yen, access from the nearest station, full
address with postal code, latitude and longitude, store phone and reservation phone, opening hours, closed days,
seats, smoking, parking, credit cards, website, opening date, set courses with prices, reservation availability for
the coming days, selling points, scenes and photos.

Search by keyword (in English or Japanese), prefecture, cuisine, budget and features such as private room or all you
can drink, or paste any Gurunavi restaurant or list link. Built for travel apps and guides, food and beverage market
research in Japan, restaurant sales and supplier lead lists, location intelligence and datasets for recommendation
engines and LLMs.

### At a glance

| What | Price (Free plan) |
|---|---|
| Restaurant delivered | **US$ 4.00 per 1,000 restaurants** (US$ 0.004 each) |
| Run start | US$ 0.005 per run |

- 100 restaurants with the full restaurant page = **US$ 0.305**. Same price with or without the restaurant page.
- Error rows, duplicates and restaurants already delivered in earlier runs (`onlyNew`) are never charged.
- `maxItems` is a hard cap, and a spending limit set on the run stops it cleanly with everything delivered so far.
- No cap per search: a search with 5,000+ restaurants can be read to the end.
- The proxy that Gurunavi needs is included in the price. Keep the default proxy settings.

### Quick start

Yakitori in Osaka, list only (fast):

```json
{
  "searchKeyword": "yakitori",
  "area": "osaka",
  "includeDetails": false,
  "maxItems": 100
}
```

Tonkatsu in Kyoto with the full restaurant page (address, phone, coordinates, hours):

```json
{
  "searchKeyword": "tonkatsu",
  "area": "kyoto",
  "maxItems": 50
}
```

Sushi restaurants in Tokyo with a private room, at least 5,000 yen per person, bookable online:

```json
{
  "area": "tokyo",
  "cuisine": "sushi",
  "characteristic": "private-room",
  "minBudget": 5000,
  "onlineReservation": true,
  "maxItems": 200
}
```

Restaurant pages and a station list copied from the browser:

```json
{
  "startUrls": [
    { "url": "https://r.gnavi.co.jp/gacg800/" },
    { "url": "https://r.gnavi.co.jp/eki/0002802/rs/" }
  ]
}
```

### Input

| Field | What it does |
|---|---|
| `searchKeyword` | Dish, cuisine or restaurant name. Common food words in English (ramen, sushi, yakiniku, tempura, wagyu, izakaya, udon, okonomiyaki, kaiseki, shabu shabu and about 80 more) are searched in Japanese for you. Japanese works as typed. Several keywords: separate with commas. |
| `area` | One of the 47 prefectures in English (tokyo, osaka, kyoto, hokkaido, fukuoka...), big cities (yokohama, kobe, sapporo, nagoya), `japan` for the whole country, or a Gurunavi area code like `aream2115`. |
| `cuisine` | Gurunavi cuisine category: izakaya, japanese, sushi, ramen, noodle, yakiniku, hotpot, western (Italian and French), continental, chinese, ethnic, curry, buffet, bar, cafe, entertainment, casual, others. |
| `characteristic` | One feature every restaurant must have: private-room, all-you-can-eat, all-you-can-drink, takeout, solo-friendly, kids-welcome, pets-allowed, date, anniversary, birthday-perk, girls-night, night-view, parking, open-24-hours, smoking-allowed. |
| `minBudget`, `maxBudget` | Average spend per person in yen. |
| `onlineReservation`, `withCoupon`, `newlyOpened` | Only restaurants bookable on Gurunavi, with a Gurunavi coupon, or marked as newly opened. |
| `startUrls` | Restaurant pages (`r.gnavi.co.jp/<code>/` or the English `gurunavi.com/en/...` page) and list pages (area, station, cuisine, search results). |
| `includeDetails` | On by default: opens each restaurant page for address, phone, coordinates, hours and the rest. Off: list fields only, about 3 times faster. |
| `maxItems` | Restaurants in the whole run (default 20, 0 = no limit). |
| `onlyNew` | For schedules: skip restaurants this search already delivered in your earlier runs. |
| `proxyConfiguration` | Keep the default: it is the setting that works with Gurunavi. |

With every search field and link empty, the run searches ramen in Tokyo as an example.

### Output fields

Every restaurant is one row with `type: "restaurant"`. Fields marked with \* come from the restaurant page
(`includeDetails`, on by default). Fields Gurunavi does not show for a restaurant are left out of that row.

| Field | Example |
|---|---|
| `restaurantId`, `shopCode` | `kdw7204`, `84wsa5z60000` (Gurunavi ids) |
| `name`, `brandName`, `branchName` | Full name, brand, and branch when Gurunavi splits it |
| `nameKana` \* | Reading in katakana |
| `catchphrase` | The restaurant's own one-line pitch on the list |
| `cuisine` \* | Gurunavi cuisine, for example `とんかつ（トンカツ）` |
| `listingType` | `member` (full listing) or `basic` |
| `budgetLunchYen`, `budgetDinnerYen` | Average spend per person, in yen |
| `averageBudget`, `priceRange` \* | Budget text as shown on the page |
| `access`, `accessDetails` \* | Walking time from the nearest stations |
| `nearestStations`, `areaPath` \* | Stations and the Gurunavi area trail |
| `address`, `postalCode`, `prefecture`, `city`, `streetAddress` \* | Full address in Japanese |
| `latitude`, `longitude` \* | Coordinates |
| `phone`, `reservationPhone` \* | Store phone, and the reservation line shown on Gurunavi |
| `website`, `openingDate` \* | Official website and opening date (`YYYY-MM-DD`) |
| `openingHours`, `closedDays` \* | Hours with last order, and closed days |
| `seats`, `seatNotes` \* | Total seats, counter and terrace notes |
| `smoking`, `parking`, `creditCards`, `otherPayments` \* | As listed by the restaurant |
| `privateRooms`, `privateHire`, `children`, `pets`, `allYouCanDrink`, `allYouCanEat` \* | When the restaurant fills them in |
| `foreignLanguageSupport`, `connectivity`, `facilities`, `lunchServices` \* | English menu, Wi-Fi, late-night service... |
| `scenes`, `sellingPoints` \* | Occasions (date, family, solo) and the restaurant's own selling points |
| `cancellationPolicy`, `description` \* | Cancellation policy and the restaurant's introduction |
| `highlights` | Takeout, online reservation coupon, points |
| `isSuspended` | `true` when Gurunavi marks the restaurant as temporarily closed |
| `courses` | Set courses: name, price in yen, discounted price, number of dishes |
| `availability` | Next days with reservation status: available, on request, by phone, full |
| `photos`, `images` | Photo links with type (highlight, dish, seating, course) and caption |
| `url`, `mapUrl`, `englishPageUrl` | Gurunavi page, map page, English page |
| `sourceQuery`, `scrapedAt` | The search or link that produced the row, and when |

### One real row

From a test run on 2026-10-23 (`"searchKeyword": "tonkatsu", "area": "kyoto"`), photo lists shortened:

```json
{
  "type": "restaurant",
  "restaurantId": "kdw7204",
  "shopCode": "84wsa5z60000",
  "name": "とんかつ KYK 京都ポルタ店",
  "nameKana": "トンカツケイワイケイキョウトポルタテン",
  "catchphrase": "とんかつ",
  "cuisine": "とんかつ（トンカツ）",
  "listingType": "member",
  "budgetLunchYen": 1500,
  "budgetDinnerYen": 1700,
  "averageBudget": "1,700円（通常平均）\n1,500円（ランチ平均）",
  "access": "地下鉄烏丸線京都駅 徒歩1分",
  "nearestStations": ["京都駅", "九条駅", "七条駅"],
  "address": "京都府京都市下京区烏丸通東塩小路下ル東塩小路町902番地京都駅前地下街 ポルタ",
  "postalCode": "600-8216",
  "prefecture": "京都府",
  "city": "京都市下京区",
  "latitude": 34.986831663321,
  "longitude": 135.75843431758,
  "phone": "075-343-3265",
  "reservationPhone": "050-5493-3269",
  "openingHours": "11:00～22:00\n（L.O.21:30）",
  "closedDays": ["不定休日あり", "京都ポルタに準ずる"],
  "seats": 63,
  "smoking": ["店内全面禁煙"],
  "parking": ["無"],
  "creditCards": ["VISA", "MasterCard", "JCB", "アメリカン・エキスプレス", "ダイナースクラブ", "Discover Card"],
  "children": ["お子様メニューあり", "お子様用椅子あり"],
  "scenes": ["デート", "お一人様", "家族", "友人・知人", "夫婦"],
  "sellingPoints": ["京都駅でとんかつ", "黒豚", "ゆったりとした店内"],
  "highlights": ["Takeout"],
  "isSuspended": false,
  "photos": [
    { "url": "https://rimage.gnst.jp/rest/img/84wsa5z60000/s_0n68.jpg", "type": "highlight", "caption": "KYKは黒豚", "price": null, "seatName": null }
  ],
  "url": "https://r.gnavi.co.jp/84wsa5z60000/",
  "mapUrl": "https://r.gnavi.co.jp/84wsa5z60000/map/",
  "englishPageUrl": "https://gurunavi.com/en/kdw7204/rst/",
  "sourceQuery": "tonkatsu",
  "scrapedAt": "2026-10-23T14:58:01Z",
  "errorCode": null,
  "error": null
}
```

Restaurants with online booking also carry `courses` (for example a crab course at 20,300 yen with 32 dishes) and
`availability` for the next days (`{"date": "2026-10-24", "status": "available"}`).

### Errors you may see

Error rows have `type: "error"`, an `errorCode` and a plain message. They are never charged.

| errorCode | Meaning |
|---|---|
| `INVALID_INPUT` | A field could not be used, for example an area that is not a Japanese prefecture. |
| `INVALID_URL` | A link that is not a Gurunavi restaurant or list page. |
| `NOT_FOUND` | The restaurant page or the area list does not exist (closed or removed). |
| `NO_RESULTS` | Gurunavi has no restaurant for this keyword and these filters. |
| `BLOCKED` | Gurunavi did not answer this search. Keep the default proxy settings and run again. |
| `UNEXPECTED` | Anything else; the run ends with what it already delivered. |

### Integrations, scheduling and AI agents

- **Schedules:** run the same search every day or week from Apify Schedules. Turn on `onlyNew` to receive only
  restaurants that are new to that search since your last run (good for new-opening alerts and lead lists).
- **Export:** download the dataset as JSON, CSV, Excel, XML or HTML, or read it from the Apify API.
- **Make, n8n, Zapier:** use the Apify integration to send new restaurants to Google Sheets, a CRM, Slack or a
  database.
- **AI agents:** the Actor works through the Apify MCP server, so an assistant such as Claude or ChatGPT can search
  Gurunavi on request ("find izakaya with private rooms near Shinjuku under 4,000 yen").
- **Webhooks:** trigger your own endpoint when a run finishes.

### FAQ

**Do I need a Gurunavi account?** No. The Actor reads the public pages.

**Can I search in English?** Yes. Common food words in English are turned into the Japanese words Gurunavi uses
(ramen becomes ラーメン, yakitori becomes 焼き鳥). Restaurant data itself is in Japanese, as on the site.

**How many restaurants can I get?** As many as Gurunavi lists for the search: ramen in Tokyo returns 5,423. Set
`maxItems` to 0 to get all of them, and raise the run timeout for several thousand with the restaurant page.

**Why are some fields missing on a row?** Restaurants with a basic listing fill in fewer fields (often only address,
phone, access and smoking). Empty fields are left out instead of being sent as blanks.

**Is the phone number personal data?** No. It is the business phone of the restaurant, published by the restaurant.
No reviewer or customer data is collected.

**Can I only get the list without opening each restaurant?** Yes, set `includeDetails` to false. The price is the same,
the run is about 3 times faster, and you still get name, budget, access, photos, courses and availability.

### Limitations

- Gurunavi answers only through the default proxy settings; other settings return free `BLOCKED` rows.
- Keyword search matches Gurunavi's own text. Words that are not in the built-in English list are searched as typed.
- Availability covers the days Gurunavi shows on the list (usually about two weeks).
- Reviews are not collected in this version; every other field of the restaurant page is.

### Changelog

- **23 Oct 2026, 0.1:** first version. Keyword (English or Japanese), prefecture, cuisine, feature, budget,
  reservation, coupon and new-opening filters; restaurant and list links; full restaurant page; `onlyNew`; free error rows.

# Actor input Schema

## `searchKeyword` (type: `string`):

What to search on Gurunavi: a dish, a cuisine or a restaurant name. Common food words in English are searched in Japanese for you (ramen, sushi, yakiniku, tempura, wagyu, izakaya, udon, okonomiyaki and about 80 more); any Japanese word works as typed. Several keywords: separate them with commas. Leave empty to list every restaurant of the area and filters below. With every field empty, the run searches ramen in Tokyo as an example. Also accepts 'keyword' or 'query'.

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

One of the 47 prefectures in English: tokyo, osaka, kyoto, hokkaido, fukuoka, kanagawa, aichi, okinawa... Big cities also work (yokohama, kobe, sapporo, nagoya). Empty or 'japan' searches the whole country. A Gurunavi area code such as aream2115 (Shinjuku) also works. Anything else returns a free INVALID_INPUT row. Also accepts 'prefecture' or 'location'.

## `cuisine` (type: `string`):

Optional Gurunavi cuisine category. Combines with the keyword, area and the other filters.

## `characteristic` (type: `string`):

Optional feature that every restaurant must have, as tagged on Gurunavi.

## `minBudget` (type: `integer`):

Optional. Only restaurants whose average spend per person is at least this many yen.

## `maxBudget` (type: `integer`):

Optional. Only restaurants whose average spend per person is at most this many yen, for example 3000.

## `onlineReservation` (type: `boolean`):

Only restaurants that take reservations on Gurunavi.

## `withCoupon` (type: `boolean`):

Only restaurants that offer a Gurunavi coupon.

## `newlyOpened` (type: `boolean`):

Only restaurants that Gurunavi marks as newly opened.

## `startUrls` (type: `array`):

Optional. Restaurant pages (https://r.gnavi.co.jp/gacg800/), English restaurant pages (gurunavi.com/en/...), or any Gurunavi list page (area, station, cuisine or search results, copied from the address bar). Lists are paginated automatically up to the item limit. Invalid links return a free error row. Also accepts 'urls'.

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

On (default): each restaurant also gets its full page: address, postal code, coordinates, phone, reading in kana, hours, closed days, average budget, seats, smoking, parking, website, opening date, nearest stations, languages, scenes, selling points and description. Off: only what the list shows (name, catchphrase, lunch and dinner budget, access, photos, courses and reservation availability), about 3 times faster. Same price either way.

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

Stop after this many restaurants in the whole run (default 20). 0 means no limit. You pay per restaurant delivered. Also accepts 'maxResults'.

## `onlyNew` (type: `boolean`):

For scheduled runs: skip restaurants this search already delivered in your earlier runs (not charged), so each run returns only restaurants that are new on Gurunavi for that search.

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

Keep the default: it is the setting that works with Gurunavi. Other settings are refused by the site and return free BLOCKED rows.

## Actor input object example

```json
{
  "searchKeyword": "ramen",
  "area": "tokyo",
  "cuisine": "any",
  "characteristic": "any",
  "onlineReservation": false,
  "withCoupon": false,
  "newlyOpened": false,
  "includeDetails": true,
  "maxItems": 20,
  "onlyNew": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "JP"
  }
}
```

# Actor output Schema

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

No description

## `resultsCsv` (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 = {
    "searchKeyword": "ramen",
    "area": "tokyo",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "JP"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapewise/gurunavi-scraper").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 = {
    "searchKeyword": "ramen",
    "area": "tokyo",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "JP",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapewise/gurunavi-scraper").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 '{
  "searchKeyword": "ramen",
  "area": "tokyo",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "JP"
  }
}' |
apify call scrapewise/gurunavi-scraper --silent --output-dataset

```

## MCP server setup

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

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/7jnfhq69LJysFjGhf/builds/FQg9PRMkJHEjOrVeD/openapi.json