# Tabelog Restaurant Scraper (`boncross/tabelog-restaurant`) Actor

Scrape full Tabelog (食べログ) restaurant records by URL or id, in English, Korean, Chinese or Thai. Just add restaurant URLs or ids and get score, Japanese name and address, opening hours with last orders, budgets, seats, payment, reservation policy, awards, coordinates, photos and menus.

- **URL**: https://apify.com/boncross/tabelog-restaurant.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-scrapeds

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

### What is Tabelog Restaurant Scraper?

Tabelog Restaurant Scraper gets you the full record Tabelog (食べログ) keeps on a restaurant: hours with last orders, closed days, seats, payment methods, smoking, private rooms, budgets, coordinates, awards and, if you ask, the menu with prices. Give it a restaurant URL or a bare id and you get one row back, in English, Korean, Traditional or Simplified Chinese, or Thai. The restaurant's Japanese name and Japanese address are on the row whichever language you pick.

Tabelog is Japan's largest restaurant review site, and its information table is the most complete public record of how a Japanese restaurant operates.

Why this one:

- **You can trust a batch.** 500 restaurants across eight cities returned 500 of 500, in 13 to 56 seconds.
- **Payment comes as answers, not prose.** Cards, e-money and QR payments are each true, false or left empty where the restaurant says nothing, with the card brands listed. Checked on 15 restaurants in five languages, all 75 rows agreed with the restaurant's own Japanese payment line.
- **You'll know if the place has closed.** A closed or suspended listing is flagged, with Tabelog's badge and notice, before you send anyone there.
- **Menus cost you only when there is one.** Many restaurants publish none. You pay the $0.0005 menu fee when dishes actually come back.
- **$2.00 per 1,000 restaurants** on the Free plan and $1.40 on Business, with no proxy to set up. An id Tabelog doesn't know costs nothing.

**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 8 October 2026
- 17 restaurants run on 7 October 2026, plus one made-up id: 17 venues, 1 error row
- Charges matched the rows: 1 start, 17 venues
- An id Tabelog does not know gets an uncharged error row

### What data do you get for each restaurant?

| | |
|---|---|
| Restaurant name, Japanese name and Tabelog id | 🔗 Canonical restaurant URL |
| ⭐ Tabelog score (and 5-point rating) | Review count |
| 🚦 Closed or suspended flag | 🍜 Genres |
| 📍 Japanese address, postcode and coordinates | 🚉 Nearest station, walking minutes and distance |
| 🕒 Opening hours with last orders | 📅 Closed days |
| 💴 Dinner and lunch budget bands, with yen bounds | 📖 Menu items with prices, notes and descriptions |
| 🪑 Seat count and seating text | Private room and private hire |
| 💳 Cards, e-money and QR payments, with card brands | 🚭 Smoking policy |
| 🅿️ Parking | 📞 Phone number |
| 🌐 Website | 🏆 百名店 and Tabelog Award status |
| 📸 Photo URLs | Remarks |
| Drinks, food and service notes | Children, dress code and occasions |
| The full information table, as published | Opening date |

### What people use it for

- Checking opening hours, closed days and reservation policy before publishing a restaurant recommendation
- Sweeping a saved venue list for closed and suspended listings
- Building Japan dining datasets with coordinates, budgets and seating for travel apps
- Telling travellers which places take cards and which allow smoking
- Collecting menu prices for a neighbourhood or a genre
- Filling in the restaurants that [Tabelog Search Scraper](https://apify.com/boncross/tabelog-search) found by area and genre
- Serving restaurant records to Korean, Chinese and Thai speaking travellers in their own language

### How to scrape Tabelog restaurant details

1. [Create an Apify account](https://console.apify.com/sign-up). It's free and takes an email address.
2. Open [Tabelog Restaurant Scraper](https://apify.com/boncross/tabelog-restaurant) and paste your restaurants, one per line: Tabelog URLs or ids of 7 or 8 digits.
3. Choose the language. Switch the menu on if you need dish prices, and say how many photos to keep.
4. Press Start. Twenty restaurants with menus took 5 seconds in testing.
5. Open the Output tab and download the records as Excel, CSV, JSON, XML or HTML.

### ⬇️ Input

Paste Tabelog URLs or bare restaurant ids (7 or 8 digits) into the restaurant list. Any Tabelog link for a restaurant works, and you get the canonical URL back in the output.

Got a long list in a file or a Google Sheet? Put it in Start URLs, which loads links in bulk. You can use both at once and they're combined.

You get one row for each restaurant you give. The only cap is "Maximum restaurants for the whole run", which is 0 (no limit) unless you set it.

#### Full records with menus

```json
{
  "restaurants": [
    "https://tabelog.com/tokyo/A1301/A130101/13002457/",
    "13300481",
    "26030760"
  ],
  "includeMenu": true,
  "maxPhotos": 10
}
```

#### Check whether listings are still trading, in Korean

```json
{
  "restaurants": ["13198142", "13021939", "13002457"],
  "language": "kr",
  "includeInfoTable": false,
  "maxPhotos": 0
}
```

#### A batch with the raw information table kept

```json
{
  "restaurants": ["13228602", "13002457", "13300481", "13198142"],
  "includeMenu": false,
  "includeInfoTable": true,
  "maxConcurrency": 3
}
```

| Field | Notes |
|---|---|
| `restaurants` | Tabelog URLs or restaurant ids (7 or 8 digits). |
| `startUrls` | Tabelog page addresses, pasted or loaded in bulk from a file, a Google Sheet or a remote list. Combined with `restaurants`. |
| `language` | `en` (default), `kr`, `tw` (Traditional Chinese), `cn` (Simplified Chinese) or `th`. Sets the language of the record's text. The Japanese name (`nameJa`) and the Japanese address come back in every language. |
| `maxItems` | Run-wide ceiling on restaurants. 0 (default) means no limit. |
| `includeMenu` | Off by default. Fetch the menu page and return dish names with prices, notes and descriptions. Charged only when items come back. |
| `includeInfoTable` | Keep the raw information table alongside the parsed fields. On by default. |
| `maxPhotos` | How many photo URLs to keep, 10 by default and up to 20. Set 0 to skip them. |
| `maxConcurrency`, `delayMs` | Parallel requests (1 to 32, default 32) and an optional pause before each call (default 0). |

#### For developers

- `restaurants` and `startUrls` are merged into one list, and `maxItems` stops the run once that many restaurants have been returned.
- `includeMenu` costs one extra page per restaurant. `venue-menu` is charged only when that page has items. A menu page that couldn't be read sets `menuError` on the row, and you aren't charged for it.
- `includeInfoTable: false` drops `infoTable` and `infoTableOrder` from the row. The parsed columns are unaffected.
- `maxConcurrency` is how many requests run at once (default 32). `delayMs` pauses before each call (default 0). The defaults are what the speed figures below were measured at.
- Rows are written in the order of your input list.
- If Apify restarts a run part-way, it picks up where it stopped. Nothing is written or charged twice.

### ⬆️ Output

Each restaurant is one record. Here's a real one in English, with the raw information table left out for length:

```json
{
  "input": "13270211",
  "nameJa": "美会",
  "serviceChargeJa": null,
  "id": "13270211",
  "url": "https://tabelog.com/en/tokyo/A1307/A130701/13270211/",
  "name": "Bia",
  "nameFull": "Bia",
  "alias": "(美会)",
  "title": "Bia Reservation - Nogizaka/Innovative | Tabelog",
  "status": {
    "badge": null,
    "live": true,
    "gloss": null,
    "titlePrefix": null,
    "notice": null
  },
  "score": 4.33,
  "rating": 4.33,
  "ratingScale": 5,
  "reviewCount": 508,
  "ldScore": 4.33,
  "ldReviewCount": 508,
  "genres": [
    "Innovative",
    "Japanese Cuisine",
    "Thai"
  ],
  "genreText": "Innovative, Japanese Cuisine, Thai",
  "prefecture": "Tokyo",
  "area": "Roppongi",
  "subArea": "Roppongi, Nogizaka, Nishi-Azabu",
  "nearestStation": "Nogizaka Sta.",
  "address": "東京都港区六本木7-3-21 来山ビル 2F",
  "addressParts": {
    "postcode": "1060032",
    "region": "Tokyo",
    "locality": "Roppongi Minato Tokyo",
    "street": null
  },
  "lat": 35.66536681871384,
  "lng": 139.72794968425114,
  "access": "4 minutes walk from Tokyo Metro Nogizaka Station\n5 minutes walk from Tokyo Metro Roppongi Station\n205 meters from Nogizaka.",
  "walkMinutes": 4,
  "stationDistanceM": 205,
  "phone": "03-6804-2489",
  "reservation": "Reservation only\n…",
  "budgetDinner": "JPY 40,000 - JPY 49,999",
  "budgetLunch": null,
  "budgetDinnerMin": 40000,
  "budgetDinnerMax": 49999,
  "budgetLunchMin": null,
  "budgetLunchMax": null,
  "budgetText": "JPY 40,000 - JPY 49,999",
  "budgetFromReviews": "JPY 40,000 - JPY 49,999",
  "priceRange": "JPY 40,000～JPY 49,999",
  "hours": {
    "services": [],
    "notices": [
      "■Closed on\nSundays and Public Holidays\n【Two seating times available】\nFirst seating starts at 17:30\nSecond seating starts at 20:30"
    ],
    "text": "■Closed on\nSundays and Public Holidays\n【Two seating times available】\nFirst seating starts at 17:30\nSecond seating starts at 20:30"
  },
  "closedDays": "Sundays and Public Holidays",
  "payment": {
    "text": "Credit card accepted\n(VISA, Master, JCB, AMEX, Diners)\nElectronic money not accepted\nQR code payments not accepted",
    "cards": true,
    "cardBrands": [
      "VISA",
      "Master",
      "JCB",
      "AMEX",
      "Diners"
    ],
    "eMoney": false,
    "qrPay": false
  },
  "serviceCharge": null,
  "seats": 15,
  "seatsText": "15 seats",
  "privateRoom": "Available\nFor 2 people, For 4 people, For 6 people, For 8 people",
  "privateHire": "Available\nFor up to 20 people",
  "smoking": "Non smoking",
  "parking": "Unavailable\nCoin parking available nearby",
  "space": "Stylish space, Relaxing space, Spacious seating, Couple seating, Counter seating, Sofa seating, Power outlets available, Free Wi-Fi available",
  "drinks": "Sake (Nihonshu), Shochu (Japanese spirits), Wine, Particular about Sake (Nihonshu), Particular about Shochu (Japanese spirits), Particular about wine",
  "food": "Particular about fish",
  "occasions": null,
  "services": "Parties over 2.5 hours, BYO drinks, Sommelier available",
  "children": "Children welcome(Babies welcome, Preschoolers welcome, School-age children welcome), Strollers welcome\nOnly when a private room is available.",
  "dressCode": null,
  "homepage": null,
  "openedOn": "2022.3.28",
  "awards": [
    "The Tabelog Award 2026 Silver winner",
    "The Tabelog Award 2025 Silver winner",
    "The Tabelog Award 2024 Silver winner",
    "Selected for Tabelog Innovative/Creative Cuisine \"Tabelog 100\" 2025"
  ],
  "isHyakumeiten": true,
  "tabelogAward": "Tabelog Award 2026 Silver",
  "remarks": "For the number of guests and any other requests, please contact us by phone.",
  "moved": null,
  "photos": [
    "https://tblg.k-img.com/resize/660x370c/restaurant/images/Rvw/277439/4d3e957fbdfa37a44062d6bd4cd1f822.jpg?token=b2a4d7c&api=v2",
    "…"
  ],
  "scrapedAt": "2026-09-27T22:52:46.002Z"
}
```

| Column | Meaning |
|---|---|
| `name`, `nameJa` | The name in the chosen language, and the restaurant's Japanese name. |
| `address` | The Japanese address, whatever the language. `addressParts` carries the postcode and the region in the chosen language. |
| `walkMinutes`, `stationDistanceM` | The first walking time the restaurant states, and the distance to the nearest station. |
| `hours` | `services` (days, time and last order per sitting, where the restaurant lists them by day), `notices` (its own notes) and `text` (the whole cell). |
| `closedDays` | The closed days, read from the restaurant's own hours notes. |
| `payment` | `cards`, `eMoney` and `qrPay` are `true` or `false` where the restaurant states them and `null` where it says nothing; `cardBrands` lists the brands. |
| `awards`, `isHyakumeiten`, `tabelogAward` | Every 百名店 selection and Award listed, whether the restaurant has ever been a 百名店, and its latest Tabelog Award tier. |
| `status` | `live` is false for a closed or suspended listing, with the badge and a note. |
| `infoTable`, `infoTableOrder` | With `includeInfoTable` on: the restaurant's whole information table as label → text (labels are the Japanese headings, whatever the language; the text is in the chosen language), and the labels in the order the page lists them. Absent when the option is off. |

Switch the menu on and each row also has `menu` (items with `name`, `price`, `priceNote`, `description` and `image`) and `menuCount`. If Tabelog doesn't know a restaurant, you get a row with `input`, `id` and `error`.

### How much does it cost?

| Event | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| `actor-start`, per run | $0.002 | $0.002 | $0.002 | $0.002 |
| `venue-scraped`, per restaurant returned | $0.002 | $0.0018 | $0.0016 | $0.0014 |
| `venue-menu`, per restaurant whose menu was fetched and had items | $0.0005 | $0.00045 | $0.0004 | $0.00035 |

Enterprise plans pay the Business price.

The full record is **$2.00 per 1,000 restaurants** on the Free plan and $1.40 on Business. Nothing is added to that: no proxy to set up, no platform usage billed on top, and unknown ids are free.

- 50 restaurants without menus: $0.002 + 50 × $0.002 = **$0.102** ($0.072 on Business).
- 200 restaurants with menus, of which 120 publish one: $0.002 + 200 × $0.002 + 120 × $0.0005 = **$0.462** ($0.324 on Business).

Free-plan accounts on Apify get $5 of credits a month. Here that's about 49 runs of 50 restaurants, close to 2,450 full records, before you pay anything.

### How fast is it, and how complete are the records?

| Run | Result |
|---|---|
| 20 restaurants in Tokyo and Kyoto, menus on | 20 of 20 returned, 7 menus with 63 items, 5 seconds |
| 1 restaurant | 3 seconds |
| 500 restaurants across Tokyo, Kyoto, Osaka, Sapporo, Fukuoka, Nagoya, Yokohama and Kobe | 500 of 500, 13 to 56 seconds depending on the server's load |
| 15 restaurants in Tokyo, Kyoto and Kobe, in each of the five languages | 15 of 15 in all five, the Japanese name and address identical across them |

Timed on Apify at the default settings on 2 and 3 October 2026. You can put as many restaurants in one run as you like, and an unknown id gives you a free error row without stopping the rest.

A column is empty only where the restaurant publishes nothing for it. Across 15 restaurants in Tokyo, Kyoto and Kobe:

- All 15: name, Japanese name, score, address, coordinates, phone, access, seats, smoking, reservation policy, payment and photos
- 14: dinner budget, parking and awards
- 13: space and drinks
- 11: opening date
- 10: walking minutes and closed days
- 6: lunch budget, food, services, website, remarks and service charge
- 5: children

### Use it from a sheet, your own code or an AI agent

A venue list goes stale. To keep yours current, put the ids in a saved task, add an Apify Schedule, and let the Google Sheets integration or a webhook pass each refreshed batch to wherever the list lives. Closures, changed hours and new awards show up in the next run.

Developers can run it and read the records in one call for short lists: `POST https://api.apify.com/v2/acts/boncross~tabelog-restaurant/run-sync-get-dataset-items`, with the input JSON as the body. The `apify-client` packages on NPM and PyPI cover longer runs.

For an AI agent, add the Apify MCP server (`mcp.apify.com`) to Claude, ChatGPT, Cursor or another MCP client. The agent can then check whether a restaurant is open on a Wednesday and takes cards before it recommends the place.

### FAQ

#### What can I pass as a restaurant?

A Tabelog URL in any form, or the bare id (7 digits in Hokkaido, 8 elsewhere). Both lead to the same record, and the canonical URL is on the row.

#### How do I find restaurant ids in the first place?

You can't look a restaurant up by name here. [Tabelog Search Scraper](https://apify.com/boncross/tabelog-search) lists restaurants by area and genre and returns their ids. If you already have Tabelog URLs, paste those.

#### How do I tell that a restaurant has closed?

Look at `status`. `live` is false on a closed or suspended listing, and the badge and notice say which. For a quick sweep of a saved list, turn photos and the information table off, as in the second input example.

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

You need neither. There's no proxy to set up and no login is involved.

#### Are the opening hours parsed or raw text?

You get both. `hours.services` has the days, time and last order of each sitting where the restaurant lists them that way, and `hours.text` keeps the whole cell. A day-by-day week built from the Japanese page is in [Tabelog Japanese Detail Add-on](https://apify.com/boncross/tabelog-restaurant-ja).

#### Why is `closedDays` or `walkMinutes` empty on some rows?

Both are read from the restaurant's own notes. Where a restaurant words them without naming a day or a time, the column stays empty. Thai translations name the closed days least consistently.

#### What do I pay for a menu that isn't there?

Nothing. Many restaurants publish no menu on Tabelog, and the menu fee applies only when items come back. If the menu page couldn't be read at all, the row says so in `menuError`. It doesn't pass as an empty menu.

#### Known limits

- The record's text is Tabelog's own translation into the language you chose. The Japanese name and the Japanese address are original. The restaurant's own Japanese wording (its remarks, PR text, the notes on its hours, its closed days and a day-by-day week) is in [Tabelog Japanese Detail Add-on](https://apify.com/boncross/tabelog-restaurant-ja), which joins on `id`.
- You get the photo URLs the page shows, up to 20. Tabelog doesn't publish the total number of photos there.
- Reviews aren't included. [Tabelog Reviews Scraper](https://apify.com/boncross/tabelog-reviews) returns them with sub-scores and visit dates.

#### Is scraping Tabelog legal?

The actor reads only pages Tabelog serves to any logged-out visitor. Web scraping of publicly available data is generally legal. How you use the records is up to you, and that includes complying with Tabelog's terms and the law that applies to you.

### More from BonCross

- [Tabelog Search Scraper](https://apify.com/boncross/tabelog-search): Tabelog (食べログ) restaurant rankings by area and genre.
- [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

If a record doesn't match what the restaurant's Tabelog page says, we want to know. Open an issue on the Issues tab in Apify Console with the restaurant id. BonCross reads each one and answers there.

# Changelog

This Actor's version history is a separate document: https://apify.com/boncross/tabelog-restaurant/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.

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

The language of the record's text: categories, opening hours, payment, seating, facilities, remarks and the rest of the restaurant information. Whatever the language, every row also carries the restaurant's Japanese name (nameJa) and its Japanese address. The shop's own Japanese wording (its remarks, PR text and notes on its hours, closed days and a structured week) is in Tabelog Japanese Detail Add-on, which joins on id.

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

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

## `includeMenu` (type: `boolean`):

Also fetch the menu page for dish names, prices and descriptions. That is one extra page per restaurant, charged as venue-menu only when the menu has items.

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

Attach the full label-to-value table exactly as Tabelog prints it, in page order, next to the parsed fields.

## `maxPhotos` (type: `integer`):

How many photo URLs (640 px) to keep per restaurant from the details page.

## `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": [],
  "language": "en",
  "maxItems": 0,
  "includeMenu": false,
  "includeInfoTable": true,
  "maxPhotos": 10,
  "maxConcurrency": 32,
  "delayMs": 0
}
```

# Actor output Schema

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

Tabelog restaurants: 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 = {
    "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").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").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 --silent --output-dataset

```

## MCP server setup

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

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/kZ2ijccJkSRtgFdoD/builds/35KucaAU2B0tu9UDE/openapi.json