# Tabelog Search Scraper (`boncross/tabelog-search`) Actor

Scrape Tabelog (食べログ) restaurant rankings by area and genre. Just add English or Japanese area names, Tabelog codes or URLs and get score, review count, rank, budgets, nearest station, closed days, 百名店 and Award badges and the card image. Export as JSON, CSV or Excel. $2.00 per 1,000 restaurants.

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

## Pricing

from $1.40 / 1,000 venue-listeds

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 Search Scraper

### What is Tabelog Search Scraper?

Tabelog (食べログ) is Japan's largest restaurant review site, and its rankings by neighbourhood and genre are the ones Japanese diners actually use. Tabelog Search Scraper turns those rankings into rows you can sort and filter: type "Ginza" and "sushi" and you get the restaurants in Tabelog's own order, with score, review count, budget and the 百名店 badge.

What you get here that a plain listing scrape doesn't give you:

- **Tabelog does the filtering, and you don't pay for what it drops.** 101 of Tabelog's own search conditions, plus budget, smoking, occasion, opening hours, reservations, Award level and a free table on a date. A restaurant that doesn't match never reaches your bill.
- **Six languages, with the Japanese name where you need it.** English, Korean, Traditional and Simplified Chinese and Thai all returned 60 of 60 restaurants in testing. The default adds each restaurant's Japanese name and address, and filled both on 200 of 200.
- **Area names the way you'd type them.** About 150 English names such as Ginza, Gion and Namba, and all 47 prefectures, 277 areas and 249 sub-areas by Japanese name or Tabelog code.
- **It's quick.** Ten cities at 200 restaurants each, 2,000 rows with Japanese names and addresses, took 143 seconds.
- **A weekly run can return only what moved.** Name a score memory and a restaurant whose score and review count haven't changed costs nothing.

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

- 35 of 35 live checks on its inputs and filters passed on 7 October 2026
- 7 destinations run the same day from Sapporo to Naha: 84 restaurants, none empty
- Charges checked against the 84 rows

What else it does:

- Sorts by score, by how often travellers view a restaurant, by the soonest free table, or in Tabelog's standard order
- Runs a pasted Tabelog listing link with its own area, genre, conditions and starting page
- Keeps only restaurants with a table free on a given date, time and party size
- Returns the 百名店 (Top 100) and Tabelog Award badges that carry weight in Japan
- Reports the previous score and the change since your last run
- Tells you why, in a row, when an area can't be matched

People use it to build ranked shortlists per neighbourhood for travel and concierge products, to watch which restaurants are rising or falling week by week, to follow the 百名店 lists as they're announced, and to count venues, budgets and review volumes by area for market research. The ids it returns feed straight into [Tabelog Restaurant Scraper](https://apify.com/boncross/tabelog-restaurant) for hours, seats and menus, and into [Tabelog Reviews Scraper](https://apify.com/boncross/tabelog-reviews) for the 口コミ themselves.

### What data can you extract from a Tabelog listing?

| | |
|---|---|
| Restaurant name and Tabelog id | 🔗 Canonical restaurant URL |
| ⭐ Tabelog score (and 5-point rating) | Review count |
| 🥇 Rank within the listing | 🍜 Genre list |
| 🚉 Nearest station | Distance from the station, printed and in metres |
| 💴 Dinner budget band | Lunch budget band |
| 📅 Closed days | 🏆 百名店 and Tabelog Award badges |
| 📸 Card image | Japanese name and address (default language) |
| Budget bands as yen numbers (min and max) | The restaurant's promotional headline |
| 📍 Area searched, in Japanese and English, and its level | Total restaurants in the listing |
| 📈 Previous score and score change | Scrape timestamp |

### How to scrape Tabelog restaurant rankings

You don't need to read Japanese or write code. It's a form, and the result opens as a spreadsheet.

1. [Sign up for a free Apify account](https://console.apify.com/sign-up) and open [Tabelog Search Scraper](https://apify.com/boncross/tabelog-search).
2. Type one or more areas: an English name, a Japanese name, a Tabelog code or a Tabelog URL.
3. Pick a genre and a sort order. Add a budget or any of Tabelog's conditions if you want a narrower list.
4. Press Start. Two areas at 100 restaurants each took 7 to 11 seconds in testing.
5. Download the restaurants as Excel or CSV, or as JSON, XML or HTML.

### ⬇️ Input

An area is all it needs. Leave the rest alone and you get the 100 best-rated restaurants per area, with Japanese names and addresses.

You have two limits. "Max results per destination" (default 100, up to 1,200) applies to each area separately: ten areas at 50 each returns 500. "Maximum results for the whole run" caps the total across all of them, and 0 means no cap. Nothing past it is fetched or charged for.

#### Top-rated ramen in Ginza and Kyoto

```json
{
  "destinations": ["Ginza", "Kyoto Station"],
  "genre": "ramen",
  "sort": "rating",
  "maxResultsPerDestination": 40
}
```

#### Sushi with a private room, dinner budget 10,000 to 30,000 yen

```json
{
  "destinations": ["銀座"],
  "genre": "sushi",
  "budgetMin": 10000,
  "budgetMax": 30000,
  "budgetType": "dinner",
  "filters": ["privateRoom", "cardAccepted"],
  "minScore": "3.5"
}
```

#### A pasted Tabelog listing URL

The link keeps its area, genre, conditions and starting page, and the genre, sort and filter settings in the form don't apply to it. The score, review-count and 百名店 post-filters still do.

```json
{
  "destinations": ["https://tabelog.com/hokkaido/A0101/A010103/rstLst/sushi/"],
  "minReviewCount": 50,
  "maxResultsPerDestination": 100
}
```

#### Weekly score monitor

Schedule this and you only get the restaurants whose score or review count moved.

```json
{
  "destinations": ["Shinjuku", "Shibuya"],
  "genre": "yakiniku",
  "priceStoreName": "tabelog-tokyo-yakiniku",
  "onlyNewOrChanged": true,
  "maxResultsPerDestination": 100
}
```

| Field | Notes |
|---|---|
| `destinations` | Area names in English or Japanese, Tabelog area codes such as `tokyo/A1301/A130101`, or Tabelog area and listing URLs. A prefecture alone lists the whole prefecture. A pasted listing link keeps its own area, genre, conditions and page, and the genre, sort and filter inputs here do not apply to it. |
| `genre` | Tabelog genre slug or Japanese name. 46 genres: ramen, sushi, yakiniku, izakaya, french, italian, curry, tempura, udon, soba, unagi, yakitori, cafe, sweets, bar and more. |
| `sort` | `rating` (default, Tabelog score), `most_viewed` (how often travellers view the restaurant), `bookable_soonest` (the earliest free table online first) or `standard` (Tabelog's own order, restaurants that take reservations or promote on Tabelog first). |
| `language` | `ja` (default), `en`, `kr`, `tw`, `cn` or `th`. The listing's names, genres, stations and budgets come in English, Korean, Chinese or Thai; `ja` returns the English listing plus each restaurant's Japanese name (`nameJa`) and address (`addressJa`), which takes one extra page per restaurant. |
| `budgetMin`, `budgetMax`, `budgetType` | Yen bounds mapped to Tabelog's bands (1,000 to 100,000), for dinner or lunch. Applied by Tabelog. |
| `filters` | Tabelog's own search conditions, 101 of them, applied by the site: rooms and private hire (with sizes), all-you-can-drink and -eat, card and QR payment brands, e-money, food and drink focus, views and location, seating and facilities, children, services and coupons. A restaurant must match all of them. Nested options (a card brand, a room size, babies welcome) include their parent automatically. |
| `smoking` | `nonSmoking`, `nonSmokingOrSeparated` or `smokingAllowed`. |
| `occasion` | `friends`, `date`, `business`, `largeParty`, `family`, `solo`, `girlsNight`, `groupDate`. |
| `businessHours` | `breakfast`, `lunch`, `after10pm`, `afterMidnight`, `untilFirstTrain`. |
| `reservation` | `accepted`, `notAccepted`, `reservationOnly`. |
| `awards` | Current Tabelog Award levels: `gold`, `silver`, `bronze`. |
| `visitDate`, `visitTime`, `partySize` | Only restaurants with a table free online then, for that many people. |
| `minScore`, `minReviewCount`, `onlyHyakumeiten` | Free post-filters. |
| `maxResultsPerDestination`, `maxPages` | 20 per page, at most 60 pages per listing. |
| `priceStoreName`, `onlyNewOrChanged` | Score memory across runs. |
| `maxConcurrency`, `delayMs` | Requests run at once (1 to 32, default 32) and an optional pause before each (default 0). |

#### For developers

- `maxResultsPerDestination` and `maxPages` are the per-area limits and `maxItems` the run-wide one. `maxPages` at 0 follows the results cap. Rows that report an area the actor couldn't resolve don't count toward `maxItems`.
- A free-text name is matched to a Tabelog area and billed as one `destination-resolved`. Area codes and URLs skip that step and its fee.
- When a filter, `onlyNewOrChanged` or the de-duplication across destinations keeps nothing, a destination stops early: after 5 pages in a row with no restaurant kept, or after about three times the pages its limit needs (at least 10).
- `priceStoreName` names a key-value store that remembers each restaurant's score and review count. From the second run on, rows fill `previousScore`, `previousReviewCount`, `scoreChange` and `previousScrapedAt`. With `onlyNewOrChanged` on, only new or changed restaurants are pushed.
- `language: "ja"` reads one extra page per restaurant for `nameJa` and `addressJa`. Pick `en` if you don't need them. It's several times faster.
- `maxConcurrency` (default 32, the fastest level measured clean) is how many requests run at once across the run. Lower it only if a run reports refusals or errors. `delayMs` adds a pause before each call, and we'd leave it at 0.
- If Apify restarts a run part-way, it carries on where it stopped. No restaurant is written or charged twice.

### ⬆️ Output

One record per restaurant, in the order Tabelog ranks them. This is a real row in the default language:

```json
{
  "destination": "Ginza",
  "destinationName": "銀座",
  "destinationNameEn": "Ginza",
  "destinationLevel": "subarea",
  "destinationPath": "tokyo/A1301/A130101",
  "genre": null,
  "sort": "rating",
  "page": 1,
  "totalInListing": 2667,
  "language": "ja",
  "id": "13300481",
  "name": "Sushi Ikkou",
  "url": "https://tabelog.com/en/tokyo/A1301/A130101/13300481/",
  "score": 4.62,
  "rating": 4.62,
  "ratingScale": 5,
  "reviewCount": 181,
  "rank": 1,
  "station": "Higashi Ginza Sta.",
  "stationDistanceText": "144m",
  "stationDistanceM": 144,
  "genres": [
    "Sushi"
  ],
  "areaGenreText": "Higashi Ginza Sta. 144m / Sushi",
  "budgetDinner": "JPY 60,000 - JPY 79,999",
  "budgetLunch": null,
  "budgetDinnerMin": 60000,
  "budgetDinnerMax": 79999,
  "budgetLunchMin": null,
  "budgetLunchMax": null,
  "closedDays": "Wednesday",
  "awards": [
    "The Tabelog Award 2026 Gold winner",
    "Selected for Tabelog Sushi TOKYO \"Tabelog 100\" 2025"
  ],
  "isHyakumeiten": true,
  "tabelogAward": "The Tabelog Award 2026 Gold winner",
  "image": "https://tblg.k-img.com/restaurant/images/Rvw/320566/320x320_square_89cc6835fa13b2163d34a16fd0746334.jpg",
  "promoHeadline": "\"I want to create sushi that moves the heart.\" With this passion, I face the ingredients and am impressed by the thoughtfulness and skill behind each creation.",
  "previousScore": null,
  "previousReviewCount": null,
  "scoreChange": null,
  "previousScrapedAt": null,
  "scrapedAt": "2026-09-27T22:46:15.087Z",
  "nameJa": "鮨 一幸",
  "addressJa": "東京都中央区銀座5-11-12 日総第26ビル 3F"
}
```

`score` is the Tabelog rating as printed on the card, to two decimals. `rating` repeats it on a 5-point scale, to line up with our other actors. `image` is the one photo on the listing card. You can pick or drop columns before you export.

### How many restaurants can you get, and how fast?

| Run | Result |
|---|---|
| Kyoto and Ginza, rating order, 100 each, default language with Japanese names and addresses | 200 restaurants, all 200 with a Japanese name and address, 7-11 seconds |
| Kyoto, 8 restaurants | 8 restaurants, 3-7 seconds |
| Ten cities (Ginza, Shinjuku, Shibuya, Kyoto, Osaka, Sapporo, Fukuoka, Nagoya, Yokohama, Kobe), 200 each, default language | 2,000 restaurants, each with its Japanese name and address, 143 seconds |
| Ginza and Gion, rating order, 40 each, in English | 80 restaurants, 70 with awards |
| Ginza, Gion and Namba, 20 each, in each of the five languages | 60 of 60 in each language |

These are whole runs on Apify at the default settings, timed on 2 and 3 October 2026. No page was lost in any of them. With Japanese names on, you get about 860 restaurants a minute, which puts roughly 50,000 inside the default one-hour run limit. In English or another listing language it's several times faster.

How full are the columns? Across the 80 restaurants in the English run: score, review count, rank, station and image on all 80. Dinner budget on 78, genres and station distance on 77, awards on 70, closed days on 59, lunch budget on 46, and the restaurant's own headline on 24.

The ceiling is Tabelog's. It serves at most 60 pages of 20 per listing, which means one area and genre tops out at 1,200 restaurants. To go deeper, narrow the area or the genre and run them side by side.

### How much does it cost?

| Event | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| `actor-start`, per run | $0.002 | $0.002 | $0.002 | $0.002 |
| `destination-resolved`, per free-text name matched to a Tabelog area (codes and URLs are free) | $0.002 | $0.002 | $0.002 | $0.002 |
| `venue-listed`, per restaurant returned | $0.002 | $0.0018 | $0.0016 | $0.0014 |

Enterprise plans pay the Business price.

**$2.00 per 1,000 restaurants** on the Free plan, $1.40 on Business. That's all you pay: there's no proxy to set up and no platform usage on top. Restaurants removed by a filter, duplicates across areas and unchanged restaurants in a monitor are free.

- Ginza and Kyoto Station, 40 ramen restaurants each: $0.002 + 2 × $0.002 + 80 × $0.002 = **$0.166** ($0.118 on Business).
- A weekly monitor of 200 Shinjuku yakiniku restaurants where 15 scores moved: $0.002 + $0.002 + 15 × $0.002 = **$0.034** ($0.025 on Business). The 185 unchanged rows cost nothing.

Apify's Free plan includes $5 of credits a month, which is about 30 runs the size of the first example, or roughly 2,400 restaurants, before you pay anything.

### Schedule it, or call it from your own code

The weekly score monitor is where a schedule earns its keep. Create an Apify Schedule, name a score memory, switch on "Only new or changed", and each run hands you the movers. Send them on to Slack or a Google Sheet through Apify's integrations, or fire a webhook when the run ends.

From code, one request runs a short search and returns the restaurants:

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

The input JSON goes in the body. Longer runs use the standard run endpoints, and there's an `apify-client` package for Node.js and for Python.

An AI agent can call it through the Apify MCP server (`mcp.apify.com`) as `boncross/tabelog-search`. Ask for the ten best-rated sushi restaurants in Gion with a private room and the agent gets the rows back.

### Limitations

- Tabelog has no working keyword search. Its search boxes return the same listing whatever you type, which rules out searching by dish or restaurant name. Discovery is by area and genre.
- A single listing stops at 60 pages, or 1,200 restaurants.
- Listing text is Tabelog's own translation into the language you chose. The Japanese name and address come with the default language, at one extra page per restaurant.
- Budgets are Tabelog's printed bands (with the band's yen bounds as numbers). Closed days and station distance are as the card prints them, and a card that states no closed day returns null.
- Opening hours, seats, payment methods and menus aren't on the listing card.
- The filters cover the 101 conditions on Tabelog's search form. Conditions Tabelog offers only in its sidebar (course price bands, for example) can be reached by pasting that listing link.
- The search conditions are Tabelog's own. A restaurant matches when Tabelog says it does, and the conditions themselves aren't columns on the row. When nothing in an area matches, that area returns no rows, not Tabelog's fallback suggestions.
- The most-viewed and soonest-table orders are Tabelog's. The card prints no view count and no next free slot, which means those two orders can't be confirmed from the rows the way the rating order can.
- Tabelog marks no listing card as sponsored. Its standard order puts restaurants that take reservations or promote on Tabelog first. The other sorts don't.

### FAQ

#### Can I search Tabelog by restaurant name or dish?

Not on Tabelog itself, and that's why not here. Its search boxes ignore the keyword. Use an area and a genre, or if you already know the restaurant, pass its URL to [Tabelog Restaurant Scraper](https://apify.com/boncross/tabelog-restaurant).

#### Which areas can I type in English?

Around 150 names cover the places travellers ask about, including Ginza, Shinjuku, Shibuya, Roppongi, Asakusa, Gion, Kyoto Station, Namba, Dotonbori, Umeda, Susukino, Sapporo and Hakata. Everything else works by Japanese name or Tabelog code: all 47 prefectures, 277 areas and 249 sub-areas.

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

Neither. There's no proxy to set up, nothing extra to pay for, and no login involved.

#### How do I get more than 1,200 restaurants for a city?

Split the search. A prefecture, an area and a sub-area are separate listings with their own 1,200, and each genre is too. List several in one run and a restaurant that appears under two of them is returned and charged once.

#### What does the 百名店 badge mean?

百名店 (Hyakumeiten) is Tabelog's annual Top 100 per genre and region, chosen from scores and reviews. You'll find it in `isHyakumeiten` and in the `awards` texts, and "百名店 only" keeps just those restaurants.

#### Why did an area return nothing?

Usually a filter. When no restaurant in the area matches, you get no rows for it, and with an Award level selected an area with no current winners returns nothing. A name the actor can't match to a Tabelog area gives you a row that says so.

#### Where are the opening hours, seats and menus?

Not on the listing card. Pass the ids to [Tabelog Restaurant Scraper](https://apify.com/boncross/tabelog-restaurant), which returns opening hours with last orders, seats, payment methods, reservation policy and an optional menu. For the reviews, with sub-scores, visit dates and photos, use [Tabelog Reviews Scraper](https://apify.com/boncross/tabelog-reviews).

#### Is scraping Tabelog legal?

The actor reads only pages Tabelog serves to any logged-out visitor. Scraping publicly available data is generally legal, but you're responsible for complying with Tabelog's terms and the law where you use the data.

### 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.
- [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.
- [Agoda Reviews Scraper](https://apify.com/boncross/agoda-reviews): Agoda hotel reviews, including the Booking.com reviews Agoda shows.
- [Booking.com Reviews Scraper](https://apify.com/boncross/booking-reviews): Every Booking.com guest review for any hotel.
- [Expedia Reviews Scraper](https://apify.com/boncross/expedia-reviews): Expedia guest reviews for any hotel, including hotels given as Hotels.com links.

### Your feedback

Is an area name not matching, or a score that doesn't agree with the page? Raise it on the Issues tab in Apify Console and we'll reply there. If there's an area name you expected to work, say which.

# Changelog

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

# Actor input Schema

## `destinations` (type: `array`):

Areas to list. Use an English or Japanese area name (Ginza, 銀座, Shinjuku, Gion, Kyoto), a Tabelog area code such as tokyo/A1301/A130101, or a Tabelog area or listing URL. A prefecture on its own lists the whole prefecture. A pasted listing link (Japanese or English site) runs exactly as it is: its sort, conditions and starting page are kept.

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

Optional Tabelog genre, as a slug (ramen, sushi, yakiniku, izakaya, french, italian, curry, tempura, udon, soba, unagi, yakitori, cafe, sweets, bar) or a Japanese name (ラーメン, 寿司). A genre inside a pasted listing URL takes priority. Tabelog has no keyword search, so you cannot look up dishes or restaurant names here.

## `language` (type: `string`):

The language the listing is read in. English, Korean, Chinese and Thai return names, genres, areas and budgets in that language. Japanese returns the English listing plus each restaurant's Japanese name and Japanese address, which takes one extra page per restaurant and so runs slower. The same restaurants come back in every language.

## `maxResultsPerDestination` (type: `integer`):

How many restaurants to return per destination. Tabelog serves 20 per page and stops at 60 pages, so 1,200 is the ceiling.

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

A run-wide ceiling across every target. The per-target limit above applies to each one separately, so ten targets at 50 each returns 500; set this to cap the total. Zero means no run-wide limit. Rows that report an input the actor could not resolve are not counted here and are never charged for.

## `maxPages` (type: `integer`):

Optional hard cap on listing pages per destination. Leave at 0 and it follows the results cap.

## `sort` (type: `string`):

rating orders by Tabelog score, highest first. most_viewed orders by how often travellers view the restaurant, and bookable_soonest puts restaurants with the earliest free table online first. standard is Tabelog's own order, which puts restaurants that take reservations or promote on Tabelog first.

## `budgetMin` (type: `integer`):

Lowest budget in yen. Mapped to Tabelog's own bands, which run from 1,000 to 100,000. 0 means no lower bound.

## `budgetMax` (type: `integer`):

Highest budget in yen, mapped to Tabelog's bands. 0 means no upper bound.

## `budgetType` (type: `string`):

Apply the budget bounds to dinner or to lunch prices.

## `filters` (type: `array`):

Tabelog's own search conditions, applied on the site before anything is fetched. Tick as many as you need; a restaurant must match all of them. Options that the site nests under another (card brands, room sizes, babies welcome and so on) include their parent automatically.

## `smoking` (type: `string`):

Non-smoking, non-smoking or a separate smoking area, or smoking allowed.

## `occasion` (type: `string`):

Tabelog's own occasion tags.

## `businessHours` (type: `string`):

Open for breakfast or lunch, or open late.

## `reservation` (type: `string`):

Whether the restaurant takes reservations.

## `awards` (type: `array`):

Keep restaurants holding the current Tabelog Award at these levels. If none in the area hold it, the run returns nothing for that area.

## `visitDate` (type: `string`):

Only restaurants with a table free online for this date, at the time and party size below. YYYY-MM-DD.

## `visitTime` (type: `string`):

Used with the date above. HH:MM, on the half hour.

## `partySize` (type: `integer`):

Used with the date above.

## `minScore` (type: `string`):

Drop restaurants scoring below this, for example 3.5. Applied after the fetch, at no charge.

## `minReviewCount` (type: `integer`):

Drop restaurants with fewer reviews than this. Applied after the fetch, at no charge.

## `onlyHyakumeiten` (type: `boolean`):

Keep only restaurants that carry a Tabelog 百名店 (Top 100) badge.

## `priceStoreName` (type: `string`):

Name a key-value store and the actor remembers each restaurant's score and review count between runs, so every row can tell you what changed.

## `onlyNewOrChanged` (type: `boolean`):

With a score memory store named: push only restaurants that are new or whose score or review count moved. Unchanged rows cost nothing.

## `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
{
  "destinations": [
    "Ginza",
    "京都駅"
  ],
  "genre": "ramen",
  "language": "ja",
  "maxResultsPerDestination": 100,
  "maxItems": 0,
  "maxPages": 0,
  "sort": "rating",
  "budgetMin": 0,
  "budgetMax": 0,
  "budgetType": "dinner",
  "filters": [],
  "awards": [],
  "visitTime": "19:00",
  "partySize": 2,
  "minScore": "0",
  "minReviewCount": 0,
  "onlyHyakumeiten": false,
  "onlyNewOrChanged": false,
  "maxConcurrency": 32,
  "delayMs": 0
}
```

# Actor output Schema

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

Tabelog search results: every row the run returned.

## `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 = {
    "destinations": [
        "Ginza",
        "京都駅"
    ],
    "genre": "ramen"
};

// Run the Actor and wait for it to finish
const run = await client.actor("boncross/tabelog-search").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 = {
    "destinations": [
        "Ginza",
        "京都駅",
    ],
    "genre": "ramen",
}

# Run the Actor and wait for it to finish
run = client.actor("boncross/tabelog-search").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 '{
  "destinations": [
    "Ginza",
    "京都駅"
  ],
  "genre": "ramen"
}' |
apify call boncross/tabelog-search --silent --output-dataset

```

## MCP server setup

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

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/UGpmdfMaFTw3bhhUi/builds/ZOMAsh87yUcroqY1b/openapi.json