# Tabelog Reviews Scraper (`automation-lab/tabelog-restaurant-listings-reviews`) Actor

Export public English Tabelog restaurant ratings, review counts and source-attributed review excerpts for Japanese hospitality research. Truncated excerpts and missing fields are marked honestly.

- **URL**: https://apify.com/automation-lab/tabelog-restaurant-listings-reviews.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.44 / 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

## Tabelog Reviews Scraper

Export **Tabelog reviews** as source-attributed public English excerpts nested inside restaurant records. Refresh restaurant ratings and review counts for Japanese hospitality research, location comparison and reputation analysis. Start with an English Tabelog listing URL or a specific restaurant URL.

This Actor reads public pages without login. It returns one row per restaurant, with up to 20 public review-list excerpts included. It does not promise full review text or exhaustive review history.

### What does it do?

- Follows English restaurant listing pagination until your restaurant limit or source exhaustion.
- Extracts the restaurant name, canonical URL, displayed rating, review count and address when present.
- Includes public review titles, excerpts, reviewer display names, ratings, visit-date labels and source links.
- Marks truncated excerpts and preserves missing optional values as null.
- Deduplicates restaurants across all starting URLs in a run.

### Who is it for?

Hospitality analysts can compare venue ratings and review totals across supplied areas. Reputation researchers can sample public comments with traceable sources. Travel-data teams can refresh a curated set of restaurant URLs. Repeated runs give timestamped snapshots that your own spreadsheet or database can compare; the Actor does not maintain history or send alerts.

### Why use it?

Each record links back to the original restaurant and review surface. Aggregate review counts remain separate from the number of excerpts returned, preventing a small sample from being mistaken for complete review coverage. Public English pages may translate review text; the Actor preserves the displayed excerpt rather than generating a translation or summary.

### Getting started

1. Open an English Tabelog listing such as `https://tabelog.com/en/tokyo/`.
2. Copy its URL into **English listing or restaurant URLs**.
3. Choose the global restaurant limit and excerpts per restaurant.
4. Run the Actor and inspect the default dataset.
5. Export JSON for nested reviews, or CSV for restaurant-level fields.

```json
{
  "startUrls": [{"url": "https://tabelog.com/en/tokyo/"}],
  "maxItems": 10,
  "maxReviews": 3
}
```

### Inputs

| Input | Default | Behavior |
|---|---|---|
| `startUrls` | Required | 1–50 public HTTPS `tabelog.com/en/` listing or restaurant URLs. |
| `maxItems` | 10 | Global maximum unique restaurant rows, 1–500. No zero/unlimited mode. |
| `maxReviews` | 3 | Per-restaurant public excerpts, 0–20, first review page only. Zero skips reviews. |

URL-encoded listing filters are passed to Tabelog. The Actor does not apply local keyword matching or verify the source's filter semantics. Explicit restaurant URLs return that restaurant rather than applying listing filters. English review-list URLs normalize to their restaurant. Individual review pages, Japanese URLs and other restaurant subpages are rejected.

### Output fields

| Field | Meaning |
|---|---|
| `restaurantId`, `name`, `url` | Restaurant identity and source link. |
| `rating` | Displayed aggregate rating, or null. |
| `reviewCount` | Restaurant header total, not collected excerpt count. |
| `address` | Public address, often Japanese; null when absent. |
| `reviews` | Nested public excerpt records. |
| `reviewsReturned` | Number of included excerpts. |
| `reviewSourceUrl` | Review-list source, null when review extraction is disabled. |
| `language` | English source surface (`en`), not a guarantee every value is English. |
| `scrapedAt` | ISO extraction timestamp. |

Review fields: `reviewId`, `sourceUrl`, `reviewer`, `title`, `rating`, `visitDateText`, `excerpt`, `isTruncated`, and `textScope`. Visit dates remain displayed text, not inferred posting dates. A card with multiple meal ratings contributes its first displayed meal rating. Missing fields are null.

### Example restaurant record

A local extraction of the public restaurant below returned rating 3.47 and header review count 532. Values can change; the abbreviated illustration below omits review personal data.

```json
{
  "restaurantId": "13294162",
  "name": "Sushi Dokoro Isseki Sanchou",
  "url": "https://tabelog.com/en/tokyo/A1301/A130103/13294162/",
  "rating": 3.47,
  "reviewCount": 532,
  "reviewsReturned": 3,
  "reviewSourceUrl": "https://tabelog.com/en/tokyo/A1301/A130103/13294162/dtlrvwlst/",
  "language": "en"
}
```

### How much does it cost to extract Tabelog restaurant reviews?

Pay-per-event pricing charges a one-time **start** event and one **item** event for each restaurant delivered. Nested excerpts have no separate event charge. Rejected or duplicate restaurants are not charged as items. Failed runs can retain partial results and their corresponding charges; the start fee applies once work starts.

The start event is **$0.001 per run**. Restaurant prices follow your qualifying Apify Store spend tier:

| Tier | Per restaurant |
|---|---:|
| FREE | $0.00276 |
| BRONZE | $0.0024 |
| SILVER | $0.001872 |
| GOLD / PLATINUM / DIAMOND | $0.00144 |

At BRONZE, 1 restaurant is about $0.0034, 10 restaurants $0.025, and 100 restaurants $0.241, including the start event. These are estimates, not guaranteed invoices. Apify spend tiers depend on qualifying monthly Store spend, not the number of rows in this Actor alone. Revenue and payout estimates can change through refunds, fraud, disputes, taxes, corrections and clawbacks.

### Limits and completeness

Only the first public review-list page is read, up to 20 cards. Source `View more` controls and ellipsis endings set `isTruncated`; a false flag is not a guarantee of complete historic text. No full review pages, login-only records, reviewer profiles, images or videos are downloaded.

The source may show a different count of visits on review pages than the restaurant header review total. Neither implies complete coverage of collected excerpts. Restaurant pagination has a 100-page safety cap; reaching it fails explicitly rather than silently claiming completion. Ordering follows the source. There is no built-in trend calculation, sentiment model, alert service or historical backfill.

### Reliability and troubleshooting

Direct HTTP is used with a 30-second request timeout and up to two transient retries. There is no automatic paid proxy fallback. A blocked page, unrecognized layout, invalid URL or exhausted upstream failure makes the run fail rather than returning a misleading successful empty dataset. Partial rows remain inspectable.

If access changes, reduce the scope and inspect the failure log. Do not assume an HTTP 200 or an empty dataset proves no restaurants exist. Start with a known restaurant to distinguish listing filters from source availability.

### Integrations

Send restaurant rows to Google Sheets or a BI warehouse to compare timestamped snapshots by `restaurantId`. Process nested review arrays in your own JSON pipeline for a source-linked sample. Apify schedules can repeat the same input; your downstream system owns change comparison and alerting. Use webhooks to trigger an export only after successful runs, and label failed-run data partial.

### API examples

Use an Apify token in your environment. Never hard-code a token in a shared script.

```bash
curl -X POST \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  'https://api.apify.com/v2/acts/automation-lab~tabelog-restaurant-listings-reviews/runs' \
  -d '{"startUrls":[{"url":"https://tabelog.com/en/tokyo/"}],"maxItems":10,"maxReviews":3}'
```

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/tabelog-restaurant-listings-reviews').call({
  startUrls: [{ url: 'https://tabelog.com/en/tokyo/' }], maxItems: 10, maxReviews: 3
});
if (run.status !== 'SUCCEEDED') throw new Error(`Run ${run.id}: ${run.status}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 10 });
console.log(items);
```

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/tabelog-restaurant-listings-reviews').call(run_input={
    'startUrls': [{'url': 'https://tabelog.com/en/tokyo/'}], 'maxItems': 10, 'maxReviews': 3
})
if run['status'] != 'SUCCEEDED':
    raise RuntimeError(f"Run {run['id']}: {run['status']}")
print(client.dataset(run['defaultDatasetId']).list_items(limit=10).items)
```

### MCP setup

For **Claude Code**:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/tabelog-restaurant-listings-reviews"
```

For **Claude Desktop**, **Cursor**, or **VS Code**, use the equivalent HTTP MCP configuration supported by your client:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/tabelog-restaurant-listings-reviews"
    }
  }
}
```

Authenticate using your client's supported Apify flow. Discover actual tool names and argument schemas with scoped `tools/list`; the selected Actor also exposes run/storage helper tools. Example prompt: “Extract two restaurants from this English Tabelog listing, include three public excerpts each, and show the source links.”

Start once and retain the run ID. If nonterminal, check that same run with bounded backoff (2, 4, 8 seconds, capped at 10) and a 120-second consumer deadline; never restart merely to poll. Set the client timeout above the chosen server wait plus transport margin. At the deadline report the run as pending. After success, read dataset pages of 20 with explicit offset and fields, at most 100 source rows and 64 KiB of serialized result content admitted to model context, whichever comes first. Enforce the byte limit host-side before injecting results; oversized records must be omitted or summarized with disclosure. If your client cannot enforce it, do not claim a hard byte bound. Keep full exports outside model context. Report continuation offsets and partial status when a budget is reached. No universal token-saving claim is made.

### Legality, responsible use and affiliation

This is an independent tool, not affiliated with, endorsed by or certified by Tabelog or Kakaku.com. Tabelog is named to identify the source. Apify's standard user terms apply. Public availability is not permission for every reuse: respect source terms, applicable law, privacy expectations and copyright. Avoid harassment, identity enrichment and republishing personal review content without an appropriate basis.

### Data handling and dependencies

Runtime extraction uses no AI model and sends no user data to an AI provider. English text may already be translated by Tabelog. Apify hosts run input, results and logs under your account's storage/retention settings; the Actor creates no separate durable cache or history. Delete unneeded runs and storage through Apify controls. Public reviewer names and text can be personal data; collect only what your research requires.

Failed operations send sanitized diagnostic input, exceptions and actor/build/run IDs to our private GlitchTip service for repair; secret fields and URL queries are removed and reports are retained for 30 days. Apify and this private diagnostic service are the processing recipients. No external paid scraping API, proxy or model is required; operating costs are covered by the documented Actor price. Logs report restaurant IDs and counts, not review text or reviewer names.

### FAQ

**Does this collect all reviews?** No. It samples the first public review page, with explicit per-restaurant limits and truncation flags.

**Can I supply Japanese URLs?** No. Use `https://tabelog.com/en/` pages.

**Why are some fields null?** The source does not always expose titles, ratings or addresses. No missing values are invented.

**Does it monitor changes automatically?** No. You may schedule runs and compare their snapshots downstream.

**How do I get help?** Open an issue through the Actor's Apify support channel with the run link and a non-sensitive reproduction input.

### Related Actors

For a separate restaurant-discovery workflow, see [Foursquare Locations Scraper](https://apify.com/automation-lab/foursquare-locations-scraper). It uses a different source and does not replace Tabelog review evidence.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/tabelog-restaurant-listings-reviews/changelog.md

# Actor input Schema

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

1–50 public HTTPS tabelog.com/en/ listing or restaurant URLs. Listing filters encoded in your URL are passed to Tabelog; no keyword filter is applied locally. Restaurant URLs return that restaurant. Review-list URLs are normalized to their restaurant. Individual reviews, Japanese pages and other detail subpages are rejected. Restaurants are deduplicated globally.

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

Global cap on unique restaurant rows across all starting URLs, default 10, range 1–500. Listing pagination stops at this limit or source exhaustion; a 100-listing-page safety cap fails explicitly. Zero and unlimited are unsupported.

## `maxReviews` (type: `integer`):

Maximum public review-list excerpts nested in each restaurant, default 3, range 0–20. Zero skips review extraction. Only the first public review page is read, in source order; no review pagination or full text is promised. Truncated excerpts are flagged and missing fields are null.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://tabelog.com/en/tokyo/"
    }
  ],
  "maxItems": 10,
  "maxReviews": 3
}
```

# Actor output Schema

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

Default dataset; one row per restaurant with nested public review excerpts.

# 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 = {
    "startUrls": [
        {
            "url": "https://tabelog.com/en/tokyo/"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/tabelog-restaurant-listings-reviews").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 = { "startUrls": [{ "url": "https://tabelog.com/en/tokyo/" }] }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/tabelog-restaurant-listings-reviews").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 '{
  "startUrls": [
    {
      "url": "https://tabelog.com/en/tokyo/"
    }
  ]
}' |
apify call automation-lab/tabelog-restaurant-listings-reviews --silent --output-dataset

```

## MCP server setup

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

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/eQDxECpCFW4hgeHAx/builds/pfhVX3eqF3Y6e2WUw/openapi.json