# Tabelog Japanese Detail Add-on (`boncross/tabelog-restaurant-ja`) Actor

Add the columns Tabelog publishes only on its Japanese pages to restaurant rows you already have: 備考, お店のPR, the shop's own 営業時間 notes, 定休日 and structured weekly hours. Just add URLs or ids and join on id. Use the Tabelog Restaurant scraper for everything else.

- **URL**: https://apify.com/boncross/tabelog-restaurant-ja.md
- **Developed by:** [BonCross API](https://apify.com/boncross) (community)
- **Categories:** Travel
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 venue-japanese

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

## Tabelog Japanese Detail Add-on

### What is Tabelog Japanese Detail Add-on?

This is an add-on, not a whole scraper. Tabelog Japanese Detail Add-on returns one extra row per restaurant with the columns Tabelog (食べログ) publishes only on its Japanese pages: the shop's remarks (備考), its own PR text (お店のPR), the notes it writes under its opening hours, its closed days (定休日) and its opening hours as a structured week. You join that row onto restaurants you already have, using the Tabelog `id`.

The rest of a restaurant comes from the three scrapers this one sits beside:

| You want | Use |
|---|---|
| Restaurants ranked by area and genre | [Tabelog Search Scraper](https://apify.com/boncross/tabelog-search) |
| The full record: address, coordinates, phone, score, budgets, seats, payment, awards, photos and menu, in five languages | [Tabelog Restaurant Scraper](https://apify.com/boncross/tabelog-restaurant) |
| The reviews, with sub-scores and the original Japanese text | [Tabelog Reviews Scraper](https://apify.com/boncross/tabelog-reviews) |
| The shop's own Japanese wording and a day-by-day week | This add-on |

Why add it:

- **Hours you can compute with.** You get a week keyed by day, each sitting with its opening, closing and last-order time. It was filled on 87 of 88 restaurants measured.
- **The shop's words, untouched.** Remarks, PR text and hours notes are the Japanese the shop wrote. On all 88 restaurants the named columns matched Tabelog's own page exactly.
- **Rules you'd otherwise miss.** Reservation-only, irregular closures, "closes when sold out" and five more are flagged from the shop's text, each with the line it came from.
- **You pay only where you need it.** $1.50 per 1,000 restaurants on the Free plan, $1.20 on Business, and a restaurant whose page can't be read isn't charged.

**BonCross Verified** means we tested this actor against the live site before release and kept the record:

- 18 of 18 live checks on its inputs and filters passed on 7 October 2026
- 17 restaurants run the same day, plus one made-up id: 17 rows, 1 error row
- Charges matched the rows: 1 start, 17 venues
- A page that cannot be read gets an uncharged error row

### How much does it cost?

| Event | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| `actor-start`, per run | $0.002 | $0.002 | $0.002 | $0.002 |
| `venue-japanese`, per restaurant whose Japanese page answered | $0.0015 | $0.0014 | $0.0013 | $0.0012 |

Enterprise plans pay the Business price.

**$1.50 per 1,000 restaurants** on the Free plan, $1.20 on Business, with proxy usage and platform usage included. If a restaurant's page can't be read you get an error row for it and no charge.

- 100 restaurants: $0.002 + 100 × $0.0015 = **$0.152** ($0.122 on Business).
- 1,000 restaurants: $0.002 + 1,000 × $0.0015 = **$1.502** ($1.202 on Business).

Tabelog Restaurant Scraper bills the main record at its own price. That lets you run the add-on over just the restaurants where the Japanese columns matter, not your whole list.

With the $5 of credits on Apify's Free plan each month you can run about 3,200 restaurants through the add-on, in batches of 100, before you pay anything.

### What data does the add-on return?

| | |
|---|---|
| Tabelog id, to join on | 🔗 Canonical restaurant URL |
| Current name, in Japanese | Former name, where the restaurant was renamed |
| 📝 Remarks (備考) | 📣 The shop's PR text (お店のPR), in full |
| 🕒 Opening hours as the shop writes them | The shop's own notes on its hours |
| 📅 Opening hours as a structured week | Last-order time per sitting |
| 🚫 Closed days (定休日) | ⚠️ Rule flags found in the hours text |
| The full Japanese 店舗情報 table, optional | When the row was collected |

Nothing else is here on purpose. Names in other languages, the address, coordinates, phone, rating, budgets, seats, payment, awards, photos and menus are all in [Tabelog Restaurant Scraper](https://apify.com/boncross/tabelog-restaurant).

What people do with these columns: build opening-hours data a booking or maps product can rely on, catch reservation-only restaurants before sending anyone there, read how a shop describes itself for positioning or copy research, track temporary openings and seasonal closures from the shop's notes, and spot renamed restaurants through the former name.

### How to add Tabelog's Japanese-only details to your restaurants

1. [Create a free Apify account](https://console.apify.com/sign-up) if you don't have one, and open [Tabelog Japanese Detail Add-on](https://apify.com/boncross/tabelog-restaurant-ja).
2. Paste the restaurants: Tabelog URLs or ids of 7 or 8 digits. The ids from a Tabelog Restaurant Scraper or Tabelog Search Scraper run work as they are.
3. Decide whether you want the whole Japanese 店舗情報 table as an extra column. It's on unless you turn it off.
4. Press Start. Forty-odd restaurants take between 6 and 25 seconds.
5. Download the rows and join them to your existing ones on `id`.

### ⬇️ Input

All you have to give is the restaurants, as Tabelog URLs or bare ids (7 or 8 digits). Any URL for a restaurant works, including one of its sub-pages such as the reviews tab. If you list the same restaurant twice it's read once.

For a long list, use Start URLs. It loads links in bulk from a file, a Google Sheet or a remote list, and it's combined with the restaurant list.

There's one limit, "Maximum restaurants for the whole run". It stops the run after that many restaurants have been returned, and the default of 0 means no limit.

| Field | What it does |
|---|---|
| `restaurants` | Tabelog restaurant URLs or ids (7 or 8 digits). |
| `startUrls` | The same, loaded in bulk from a file, a Google Sheet or a remote list. |
| `maxItems` | Stop after this many restaurants have been returned across the run. Default `0`, no limit. |
| `includeInfoTable` | Add the full Japanese 店舗情報 table as `infoTableJa`. Default on. |
| `maxConcurrency` | How many restaurants to read at once, 1 to 8. Default `8`. |
| `delayMs` | Optional pause before each request, in milliseconds. Default `0`. |

#### A few restaurants by id

```json
{
  "restaurants": ["13291424", "28043837", "13294162"]
}
```

#### Restaurant URLs, without the info table

```json
{
  "restaurants": [
    "https://tabelog.com/tokyo/A1307/A130701/13291424/",
    "https://tabelog.com/hyogo/A2801/A280101/28043837/"
  ],
  "includeInfoTable": false
}
```

#### A long list from a Google Sheet, capped

```json
{
  "startUrls": [{ "requestsFromUrl": "https://docs.google.com/spreadsheets/d/.../export?format=csv" }],
  "maxItems": 500
}
```

#### For developers

- `restaurants` and `startUrls` are merged and de-duplicated by restaurant id before anything is read.
- `maxConcurrency` (default and maximum 8) is how many restaurants are read at once. `delayMs` adds a pause before each request and is 0 by default.
- `venue-japanese` is charged when a restaurant's Japanese page answered. An id Tabelog doesn't know returns a not-found row, and a page that couldn't be read on this run returns an error row saying so. Neither is charged.
- If Apify restarts a run, restaurants whose rows are already written aren't read or charged again.

### ⬆️ Output

One row per restaurant. This is a real row, with `infoTableJa` left out and Wednesday to Saturday (the same as Monday) cut for length:

```json
{
  "input": "13291424",
  "id": "13291424",
  "url": "https://tabelog.com/tokyo/A1307/A130701/13291424/",
  "nameJa": "YORONIKU TOKYO AZABUDAIHILLS",
  "formerNameJa": null,
  "remarks": null,
  "promotion": null,
  "hoursNotes": ["※2026.4/6(月)、13(月)、27(月) 臨時営業いたします。\n年末年始はお休み"],
  "hoursText": "17:00 - 23:00\nL.O. 22:00\n※2026.4/6(月)、13(月)、27(月) 臨時営業いたします。\n年末年始はお休み",
  "weekly": {
    "mon": [{ "open": "17:00", "close": "23:00", "lastOrder": "22:00", "text": "17:00 - 23:00（L.O. 22:00）" }],
    "tue": [{ "open": "17:00", "close": "23:00", "lastOrder": "22:00", "text": "17:00 - 23:00（L.O. 22:00）" }],
    "sun": [{ "open": "17:00", "close": "23:00", "lastOrder": "22:00", "text": "17:00 - 23:00（L.O. 22:00）" }],
    "notes": ["※2026.4/6(月)、13(月)、27(月) 臨時営業いたします。", "年末年始はお休み"]
  },
  "closedDays": null,
  "mechanics": [],
  "scrapedAt": "2026-09-27T21:27:20.983Z"
}
```

| Column | Meaning |
|---|---|
| `id` | The Tabelog id. Join on this. |
| `nameJa`, `formerNameJa` | The current name as the Japanese page shows it, and the former name where the restaurant was renamed. |
| `remarks` | 備考, the shop's free-text remarks. |
| `promotion` | お店のPR, the shop's own PR text, title then body, in full. |
| `hoursText` | The opening-hours cell as the shop writes it. |
| `hoursNotes` | The shop's own notes within its opening hours. |
| `weekly` | One key per day (`mon` … `sun`, plus `holiday` and similar where the shop lists them). Each day is a list of sittings with `open`, `close` and `lastOrder`; a day closed outright is `{ "text": "定休日", "closed": true }`. The shop's notes that apply to no single day are in `weekly.notes`. |
| `closedDays` | 定休日, as the restaurant states it. |
| `mechanics` | Rules found in the shop's own text, each as `{ rule, matched, line }`: `reservation required somewhere in the text`, `irregular closures`, `closes when sold out`, `sign-in list or numbered ticket`, `follows the facility calendar`, `private-hire or group rule present`, `relocation mentioned`, `closure or suspension wording`. An empty list means none was found. |
| `infoTableJa` | The Japanese 店舗情報 table, heading to text, when `includeInfoTable` is on. The headings and the words match Tabelog's desktop page; punctuation and line breaks can differ. See Limitations for what it leaves out. |

A restaurant that can't be read still gets a row, with `input`, `id` and `error`.

### How fast is it, and how often is each column filled?

| Run | Restaurants | Time |
|---|---|---|
| 43 restaurants across Japan, mostly casual | 43 | 6-7 s |
| 45 restaurants, mostly top-rated, in Tokyo, Osaka, Kyoto, Kobe and Hokkaido | 45 | 16-25 s |

Both sets ran on Apify on 4 October 2026 at the default settings, two to four times each. The time is the work after start-up. Top-rated restaurants have larger pages that answer more slowly, which is why the second set takes longer. That's 100 to 400 restaurants a minute, and you can put several thousand in one run without reaching the default one-hour limit. Nothing caps the number of restaurants per run.

Across those 88 restaurants:

| Column | Filled on |
|---|---|
| The 店舗情報 table | 88 |
| Structured hours | 87 |
| The shop's hours notes | 69 |
| Closed days | 68 |
| Remarks | 64 |
| Rule flags | 56 |
| A former name | 5 |
| PR text | 4 |

Remarks and PR text are written by the shop, and many shops write none.

### Run it from your own code or an AI agent

In a pipeline this usually runs straight after Tabelog Restaurant Scraper, on the ids that step returned. One call starts it and returns the rows for a short list:

```
POST https://api.apify.com/v2/acts/boncross~tabelog-restaurant-ja/run-sync-get-dataset-items?token=YOUR_TOKEN
```

```json
{
  "restaurants": ["13291424", "28043837"],
  "includeInfoTable": false
}
```

There are `apify-client` packages for JavaScript and Python, and the API tab in Apify Console shows each call with your token filled in. To keep hours current, schedule the run and have a webhook hand the new rows to your database.

Through the Apify MCP server, an AI agent can use it as a tool to look up a restaurant's opening hours, closed days and booking rules from its Tabelog id.

### Limitations

- You get the Japanese-only columns and nothing more. The rest of the record is in Tabelog Restaurant Scraper, joined on `id`.
- The text is Japanese, exactly as the shop wrote it. Nothing is translated.
- Remarks and PR text exist only where the shop wrote them.
- `weekly` follows the shop's own layout. A shop that describes its hours in prose has its times in `hoursText` and its notes in `weekly.notes`, with no per-day entries.
- Rule flags come from the shop's wording. They tell you where to look. They don't replace reading the text.
- `infoTableJa` holds the same table as Tabelog's desktop page, but its punctuation and line breaks can differ: a sub-value may sit on its own line ("8席\n（カウンターのみ8席）" against "8席（カウンターのみ8席）"), and lists such as 利用シーン come without the "｜" separators. Measured on 88 restaurants, 81% of cells match the desktop page character for character and 92 to 95% match once punctuation and line breaks are ignored. The named columns (`remarks`, `hoursText`, `weekly`, `closedDays` and the rest) match the desktop page exactly on all 88.
- `infoTableJa` does not include the editor change log (最近の編集者).
- For a restaurant that has moved, the 住所 note says it moved but does not give the former address.
- Some status notices are absent: the renewal notice in オープン日, and the status notice inside 店名 on closed, suspended and moved restaurants.
- 受賞・選出歴 lists each award year once, and only the recent years.
- For chain restaurants, `infoTableJa` includes 関連店舗情報 (related-store information).

### FAQ

#### Why is this a separate actor?

Because these columns appear only on Tabelog's Japanese pages, and most buyers need them for some restaurants, not all. Kept apart, you pay for them only where you want them, and Tabelog Restaurant Scraper stays the cheaper way to get the main record.

#### How do I combine it with Tabelog Restaurant Scraper?

Run both on the same restaurants and join the rows on `id`. `nameJa` is on both sides, which gives you a readable check that the join is right.

#### Do I have to run Tabelog Restaurant Scraper first?

You don't. The add-on takes any Tabelog restaurant URL or id, wherever you got it. On its own, though, a row has no address, score or coordinates.

#### Do I need proxies or a Tabelog account?

There's nothing to set up. Proxy usage is included in the price, and no login is used.

#### What happens when a restaurant's page can't be read?

You get an error row saying so, and you aren't charged for it. It's rare: run those ids again later. An id Tabelog doesn't know gives you a not-found row, also free.

#### Why is `promotion` empty on most rows?

Most restaurants publish no PR text. It was present on 4 of 88 in our measurement. Where a shop has written one, you get all of it.

#### What is in `weekly.notes`?

The shop's own notes on its hours that belong to no single day, such as a temporary opening date or a New Year closure.

#### Is it legal to scrape Tabelog?

The actor reads public restaurant pages that anyone can open without an account. How you use the data is your responsibility, including any personal data rules that apply where you work.

### More from BonCross

- [Tabelog Restaurant Scraper](https://apify.com/boncross/tabelog-restaurant): Full Tabelog (食べログ) restaurant records by URL or id, in English, Korean, Chinese or Thai.
- [Tabelog Reviews Scraper](https://apify.com/boncross/tabelog-reviews): Tabelog (食べログ) restaurant reviews by URL or id: every 口コミ with overall and five…
- [Tabelog Search Scraper](https://apify.com/boncross/tabelog-search): Tabelog (食べログ) restaurant rankings by area and genre.
- [Tripadvisor Restaurants Scraper](https://apify.com/boncross/tripadvisor-restaurants-scraper): Every restaurant Tripadvisor lists for a city.
- [Tripadvisor Place Details Scraper](https://apify.com/boncross/tripadvisor-location-details): The full Tripadvisor record for any hotel, restaurant or attraction.
- [Tripadvisor Reviews Scraper](https://apify.com/boncross/tripadvisor-reviews): Every Tripadvisor review for any hotel, restaurant, attraction or tour.

### Your feedback

Found a week that's parsed wrongly, or a shop rule the flags should catch? Raise it on the Issues tab in Apify Console and quote the restaurant id. We read them all and reply there.

# Changelog

This Actor's version history is a separate document: https://apify.com/boncross/tabelog-restaurant-ja/changelog.md

# Actor input Schema

## `restaurants` (type: `array`):

Tabelog restaurant URLs or bare restaurant ids (7 or 8 digits). Any URL variant works. The actor reads the canonical URL back from the page.

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

Tabelog page addresses, with the option to load them in bulk from a file, a Google Sheet or a remote list. Use this when you have more links than you want to paste. Combined with anything in the list above.

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

Stop after this many restaurants have been returned. 0 means no limit.

## `includeInfoTable` (type: `boolean`):

Include the Japanese 店舗情報 table as an extra column, heading to text. Its punctuation and line breaks can differ from Tabelog's desktop page, and it leaves out the editor change log (最近の編集者). The named columns above are extracted either way.

## `maxConcurrency` (type: `integer`):

How many requests run at once across the whole run. The default is the fastest level measured clean; lower it only if a run reports refusals or errors.

## `delayMs` (type: `integer`):

Optional pause before each call, in milliseconds. 0 (the default) runs as fast as the parallel limit allows.

## Actor input object example

```json
{
  "restaurants": [
    "https://tabelog.com/tokyo/A1301/A130101/13002457/",
    "13300481"
  ],
  "startUrls": [],
  "maxItems": 0,
  "includeInfoTable": true,
  "maxConcurrency": 8,
  "delayMs": 0
}
```

# Actor output Schema

## `dataset` (type: `string`):

One supplemental row per restaurant with the Japanese-only columns; join on id.

## `stats` (type: `string`):

Counts for the run: what was resolved, fetched, filtered and returned.

# 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 = {
    "restaurants": [
        "https://tabelog.com/tokyo/A1301/A130101/13002457/",
        "13300481"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("boncross/tabelog-restaurant-ja").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 = { "restaurants": [
        "https://tabelog.com/tokyo/A1301/A130101/13002457/",
        "13300481",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("boncross/tabelog-restaurant-ja").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 '{
  "restaurants": [
    "https://tabelog.com/tokyo/A1301/A130101/13002457/",
    "13300481"
  ]
}' |
apify call boncross/tabelog-restaurant-ja --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,boncross/tabelog-restaurant-ja"
        }
    }
}
```

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/afghZmcY3QTHUZ94g/builds/y23PuMWbeb5Lw4w59/openapi.json