# Tabelog Scraper - Japan Restaurants, Ratings & Reviews (`scrapewise/tabelog-scraper`) Actor

Scrape Tabelog (食べログ), Japan's #1 restaurant guide, without login: name, rating, reviews count, categories, price range, address, coordinates, hours, seats, payment, awards and photos. Search by keyword, prefecture and category, or paste links. Optional reviews. Error rows are free.

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

## Pricing

from $1.90 / 1,000 restaurant or review 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 Scraper: Japan restaurants with ratings, prices, hours, coordinates and reviews

Scrape [Tabelog](https://tabelog.com/en/) (食べログ), Japan's largest restaurant guide, **without an
account, cookies or a browser**: restaurant name in English and Japanese, Tabelog rating, number
of reviews, categories, dinner and lunch price range, address, latitude and longitude, nearest
station, opening hours, phone, seats, payment methods, private rooms, smoking, parking, website,
"Tabelog 100" awards and photos. Optional review rows with text, visit month, lunch or dinner,
overall rating, sub-ratings and spend per person.

Built for travel apps and guides, restaurant market research in Japan, location intelligence,
food delivery and hospitality sales lists, and datasets for recommendation engines and LLMs.

Looking for a Tabelog API? This Actor gives you a Tabelog dataset on demand: start it from the
Apify API, a schedule or an integration, and read the restaurants back as JSON, CSV or Excel.

### At a glance

- **Price per 1,000 results, Free plan:** US$ 2.50
- **Fee per run start:** None
- **Restaurants per search:** Up to 1,200 (Tabelog's own limit), or every match with `splitLargeSearches`
- **Search by keyword, prefecture, category:** Yes, plus Tabelog ranking order
- **Restaurant and list links:** Yes, Japanese and English links
- **Fast list mode (no restaurant page):** Yes
- **Coordinates (latitude, longitude):** Yes
- **Error rows (bad link, no results):** Free, with an `errorCode`

### One real row

From a test run on 2026-09-28 (two photo links kept for brevity):

```json
{
  "type": "restaurant",
  "restaurantId": "13003699",
  "name": "Asakusa Sakana Ryori Enshuya",
  "nameJapanese": "浅草 魚料理 遠州屋",
  "url": "https://tabelog.com/en/tokyo/A1311/A131102/13003699/",
  "rating": 3.47,
  "reviewCount": 567,
  "categories": ["Seafood", "Izakaya (Japanese style tavern)", "Nabe (Japanese hot pot)"],
  "tagline": "If you want to eat delicious Seafood in Asakusa",
  "nearestStation": "Tawaramachi Sta.",
  "address": "東京都台東区寿2-2-7 遠州屋",
  "locality": "Kotobuki Taito Tokyo",
  "prefecture": "Tokyo",
  "postalCode": "1110042",
  "latitude": 35.70905893870605,
  "longitude": 139.79064178464853,
  "businessHours": [
    {"days": "Mon, Tue, Wed, Thu, Fri, Sat", "hours": ["11:30 AM - 2:00 PM", "5:00 PM - 11:00 PM"]},
    {"days": "Sun, Public Holiday", "hours": ["Closed"]}
  ],
  "priceDinner": "JPY 5,000 - JPY 5,999",
  "priceLunch": "- JPY 999",
  "priceDinnerFromReviews": "JPY 6,000 - JPY 7,999",
  "reservation": "Reservations available",
  "phone": "03-3844-2363",
  "paymentMethods": "Credit card accepted\n(VISA, Master, JCB, AMEX, Diners)\nElectronic money not accepted\nQR code payments accepted\n(PayPay)",
  "seats": 170,
  "privateRooms": "Available\nFor 2 people, For 4 people, For 6 people, For 8 people, For 10-20 people, For 20-30 people, For over 30 people",
  "smoking": "Non smoking",
  "parking": "Unavailable\nThere are many coin parking lots nearby. (Also available in front of restaurant)",
  "website": "http://www.enshuuya.co.jp/",
  "awards": [],
  "photoCount": 2172,
  "photos": [
    "https://tblg.k-img.com/restaurant/images/Rvw/217513/640x640_rect_a2458eb1c388424da4bd11281bf1233e.jpg",
    "https://tblg.k-img.com/restaurant/images/Rvw/267991/640x640_rect_e8d1feb94c83303f50f8b1fa72f88906.jpg"
  ],
  "scrapedAt": "2026-09-28T20:10:00Z",
  "errorCode": null,
  "error": null
}
```

The full row also has `transportation`, `privateUse`, `facilities`, `setMenu`, `drinks`, `food`,
`occasion`, `service`, `familyFriendly`, `remarks`, `reservationPhone` and `searchPosition` (for
searches). A review row (`type: "review"`) looks like this: `visitMonth` "2026-09", `meal`
"dinner", `rating` 4.0, `ratingFood`, `ratingService`, `ratingAtmosphere`,
`ratingCostPerformance`, `ratingDrinks`, `spendPerPerson` "JPY 6,000～JPY 7,999", `title`,
`text`, `textIsExcerpt`, dish `photos` and the restaurant's id, name and link.

### Input

| Field | Type | What it does |
|---|---|---|
| `searchKeyword` | text | Dish, cuisine, restaurant name or place, in English or Japanese (`ramen`, `寿司`). |
| `searchArea` | text | One of the 47 prefectures in lowercase romaji (`tokyo`, `osaka`, `kyoto`). Empty = all Japan. |
| `category` | text | Tabelog category slug from the site's links: `ramen`, `sushi`, `yakiniku`, `izakaya`, `cafe`... |
| `sortBy` | `standard`, `ranking` | `ranking` is Tabelog's best-rated-first order. |
| `maxRestaurants` | integer, 20 in the example | Per search or list link. `0` = everything Tabelog shows (1,200 at most per search). |
| `splitLargeSearches` | boolean, off | Returns every match of a search with more than 1,200 results, without duplicates (up to `maxRestaurants`, `0` = all). |
| `startUrls` (also `restaurantUrls`, `urls`) | list | Restaurant pages, or area, station, category, ranking and search pages. Japanese or English links. |
| `includeDetails` | boolean, default true | Off = only the search list fields, about 10x faster, same price. |
| `includeReviews` | boolean, default false | Adds review rows for each restaurant. |
| `maxReviewsPerRestaurant` | integer, 20 in the example | `0` = every review. |
| `reviewSort` | `default`, `newest` | `newest` sorts by visit date. |
| `reviewMealType` | `all`, `lunch`, `dinner` | Only reviews of lunch or dinner visits. |
| `fullReviewText` | boolean, default false | Opens every review for its full text (the list shows the first ~110 characters). |
| `proxyConfiguration` | proxy | Apify datacenter proxy by default. |

An empty input runs the example: `ramen` in `tokyo`, 20 restaurants with full details.

### Price

**US$ 2.50 per 1,000 results** on the Free plan (a restaurant or a review), no start fee. Rows with
an `errorCode` are free; a restaurant or review is never charged twice in a run, even when the platform
restarts the run midway (it picks up where it stopped, and `maxRestaurants` and `maxReviewsPerRestaurant`
count what was already delivered); visit logs without a rating or text are skipped and not charged.

### Errors you may see

| `errorCode` | Meaning | Charged |
|---|---|---|
| `INVALID_URL` | not a tabelog.com restaurant, area or search link | no |
| `NOT_FOUND` | the restaurant or list does not exist on Tabelog | no |
| `NO_RESULTS` | the search matched no restaurant | no |
| `BLOCKED` | Tabelog did not answer after four attempts on new IPs; run again | no |
| `NOT_REACHED` | the run timeout arrived before this restaurant | no |
| `INVALID_INPUT` | a prefecture or number that is not valid | no |
| `ITEM_UNREADABLE`, `UNEXPECTED` | a page came in a shape we did not expect; the rest of the run goes on | no |

### Good to know

- **English site, Japanese details.** Data comes from Tabelog's English pages, which carry the
  same restaurant details as the Japanese ones plus coordinates. The street address stays in
  Japanese, as Tabelog shows it, and `nameJapanese` has the original name.
- **Reviews are translated by Tabelog.** On the English site, Japanese reviews appear in
  Tabelog's own English translation (`translatedByTabelog: true`).
- **No reviewer data at all.** No name, avatar, profile link, country or follower count of the
  person who wrote a review. Photos are the restaurant's and the dishes', from Tabelog's CDN.
- **1,200 per search is Tabelog's limit**, not ours: turn on `splitLargeSearches` to get every match, or split by
  category or paste area and station list links.
- Something broke? Open an issue on the Actor page.

### FAQ

**Do I need a Tabelog account?** No. Nothing to log in to, no cookies to paste.

**Can I paste Japanese Tabelog links?** Yes. `tabelog.com/tokyo/...` and `tabelog.com/en/tokyo/...`
both work, and the same restaurant is never charged twice.

**How fast is it?** 200 restaurants with full details took 52
seconds in a test; 100 in list mode took 5 seconds.

**Can I use this as a Tabelog API?** Yes. Run this Actor through the Apify API
(or the Apify client for Python and JavaScript) and fetch the Tabelog dataset as JSON, CSV or Excel when
the run ends.

**Can I use it from n8n, Make, Zapier or an AI agent?** Yes, through the Apify app or the Apify
MCP server: point your agent at `https://mcp.apify.com/?actors=scrapewise/tabelog-scraper` and it gets this
Actor as a tool. Error rows are free, so an agent can explore cheaply.

**What if a run is cut by its timeout?** The Actor stops shortly before the limit (at most 45 seconds) and ends
successfully with what it delivered, telling you in the status message how to get the rest.

### Changelog

- **7 Nov 2026**: a run restarted by the platform resumes without repeating or recharging restaurants
  and reviews. `splitLargeSearches` now returns every match in all areas of Osaka, Kyoto, Kanagawa, Hokkaido
  and Fukuoka too.
- **22 Oct 2026**: `splitLargeSearches` returns every match of a large search instead of stopping at 1,200,
  without duplicates.
- **0.1 (2026-09-28)**: first version. Keyword, prefecture, category and ranking search, restaurant
  and list links, full restaurant details, list mode, reviews with meal and order filters and
  optional full text, free error rows.

# Actor input Schema

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

What to search on Tabelog, as in the site's search box: a dish or cuisine (ramen, sushi, wagyu, tempura), a restaurant name or a place. English and Japanese both work. Each restaurant comes with its Tabelog rating, review count, prices and station. Leave empty to list every restaurant of the prefecture or category below. With every search field and link empty, the run searches ramen in Tokyo as an example. Also accepts 'keyword'.

## `searchArea` (type: `string`):

Limit the search to one prefecture, in lowercase romaji: tokyo, osaka, kyoto, hokkaido, fukuoka, kanagawa, aichi, okinawa... (any of the 47). Empty or 'all' means all of Japan. A name that is not a prefecture returns a free INVALID_INPUT row. For a smaller area (a ward or a station), paste the Tabelog area link in 'Tabelog links'. Also accepts 'area'.

## `category` (type: `string`):

Optional Tabelog category slug as it appears in the site's links, such as ramen, sushi, yakiniku, izakaya, cafe, sweets, italian, french, chinese, curry or washoku. Combines with the keyword and the prefecture. Leave empty for every category.

## `sortBy` (type: `string`):

Standard (default) keeps Tabelog's own order. Ranking is Tabelog's ranking by rating, best first, the usual choice for 'top restaurants' lists. With a limit it decides which restaurants you get.

## `maxRestaurants` (type: `integer`):

Stop after this many restaurants for each search or list link (default 20 when empty). 0 means as many as Tabelog shows: the site stops at 1,200 per search, so narrow by prefecture, area link or category to go further. You pay per restaurant delivered. Also accepts 'maxResults' or 'maxItems'.

## `splitLargeSearches` (type: `boolean`):

Tabelog shows at most 1,200 restaurants for any search. On: a search with more returns every match, without duplicates, up to maxRestaurants (0 = everything). Large searches take about 1 second per restaurant with details, so raise the run timeout for several thousand.

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

Tabelog links, one per line: restaurant pages (for example https://tabelog.com/tokyo/A1311/A131102/13003699/) or area, station, category, ranking and search list pages. Japanese and English (tabelog.com/en/...) links both work. Lists are paginated automatically up to 'Max restaurants per search'. Invalid links return a free error row. Also accepts 'restaurantUrls' and 'urls'.

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

On (default): opens each restaurant page for the full record: address, coordinates, hours, phone, seats, payment, private rooms, smoking, parking, website, awards and up to 30 photos. Off: only what the search list shows (name, rating, review count, station, categories, dinner and lunch price, closed days), about 10 times faster. Same price per restaurant either way.

## `includeReviews` (type: `boolean`):

Adds review rows (type 'review') for each restaurant: title, text, visit month, lunch or dinner, overall rating and the five sub-ratings, spend per person and dish photos. Each review is charged as one item, so set 'Max reviews per restaurant'. No reviewer name, photo or profile link is collected. Off by default.

## `maxReviewsPerRestaurant` (type: `integer`):

Only used with 'Include reviews': maximum reviews for each restaurant (default 20 when empty). 0 means every review. With 20 restaurants and 20 reviews each, a run delivers up to 400 reviews plus the restaurants. Also accepts 'maxReviews'.

## `reviewSort` (type: `string`):

Default keeps Tabelog's own review order. Newest sorts by visit date, most recent first, which is the right choice for monitoring recent feedback. Only used with 'Include reviews'.

## `reviewMealType` (type: `string`):

All (default) keeps reviews of every visit. Lunch or Dinner keeps only reviews of that kind of visit, since Tabelog rates them separately. Only used with 'Include reviews'.

## `fullReviewText` (type: `boolean`):

The review list shows only the first ~110 characters of each review (marked 'textIsExcerpt': true). When on, the Actor opens every review to get the full text. Same price per review, but the run is slower (one page per review). Off by default.

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

The default Apify Proxy (datacenter) works; tested with 15 search pages, 5 restaurant pages and 5 review pages in a row without a block. Keep the default.

## Actor input object example

```json
{
  "searchKeyword": "ramen",
  "searchArea": "tokyo",
  "sortBy": "standard",
  "maxRestaurants": 20,
  "splitLargeSearches": false,
  "includeDetails": true,
  "includeReviews": false,
  "maxReviewsPerRestaurant": 20,
  "reviewSort": "default",
  "reviewMealType": "all",
  "fullReviewText": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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",
    "searchArea": "tokyo",
    "maxRestaurants": 20,
    "maxReviewsPerRestaurant": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapewise/tabelog-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",
    "searchArea": "tokyo",
    "maxRestaurants": 20,
    "maxReviewsPerRestaurant": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapewise/tabelog-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",
  "searchArea": "tokyo",
  "maxRestaurants": 20,
  "maxReviewsPerRestaurant": 20
}' |
apify call scrapewise/tabelog-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapewise/tabelog-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/Vv7TDnpU9QcgoRwcv/builds/skpJZRMwN2CgYF8ZB/openapi.json