# Tabelog Reviews Scraper (`boncross/tabelog-reviews`) Actor

Scrape Tabelog (食べログ) restaurant reviews by URL or id: every 口コミ with overall and five sub-scores, lunch or dinner, visit month, spend per person, text (in full where Tabelog links it), reviewer stats and photos. Sort by newest or by visit date, or get only new reviews. $2.00 per 1,000 reviews.

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

## Pricing

from $1.40 / 1,000 review-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 Reviews Scraper

### What is Tabelog Reviews Scraper?

A Tabelog (食べログ) review says more than a star rating does. Each 口コミ has a score out of five, up to five category sub-scores, what the diner spent and the month they went. Tabelog Reviews Scraper gets you all of that for any restaurant on Japan's largest review site, with the reviewer's own Japanese text in full. If you'd rather read it, pick English, Korean, Chinese or Thai and you get Tabelog's translation.

What makes it worth using:

- **The original words, whole.** In Japanese you get each review's full text at no extra charge. In a run of 200 reviews across two restaurants, all 200 came back complete.
- **It's fast enough for a whole chain.** 1,905 reviews from 20 restaurants in eight cities took 165 seconds, about 700 reviews a minute.
- **A scheduled run pays for new reviews only.** Name an only-new store and reviews you've already had are skipped for free.
- **Lunch and dinner are separate.** Tabelog records which meal a visit was. You can ask for one, and each row says which it is.
- **$2.00 per 1,000 reviews** on the Free plan, $1.40 on Business. There's no proxy to set up and no usage billed on top.

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

- 23 of 23 live checks on its inputs and filters passed on 7 October 2026
- 9 restaurants run the same day, plus one made-up id: 123 reviews, 1 error row
- Charges matched the rows: 1 start, 9 venues, 123 reviews
- An id Tabelog does not know gets an uncharged error row

You can also:

- Sort by newest or by visit month, and keep only visits after a month you choose
- Filter by minimum score, or keep only reviews with photos
- Read how many times the reviewer has been, and how many reviews and followers they have
- Get the restaurant's own score, review count, genres, station and budget bands on each row
- Find out why, in a row, when a restaurant id isn't on Tabelog

Most people who pull these reviews want one of a few things: Japanese diners' own words for sentiment analysis or model training, the food, service, atmosphere and cost-performance scores of competing restaurants side by side, what people actually paid, or an alert when a new review lands on their own venue.

### What review data do you get?

| | |
|---|---|
| ⭐ Overall review score | Five category sub-scores |
| Review title | 💬 Review text |
| 🍽 Lunch or dinner visit | 📅 Visit month |
| Visit number for that reviewer | 💴 Spend per person |
| Party size (Korean, Chinese and Thai) | 🔗 Review id and link |
| 🧑 Reviewer name and id | Reviewer review count and followers |
| 📷 Review photos and photo count | Restaurant name, id and URL |
| Restaurant score and review count | 📍 Restaurant area, genres and nearest station |
| Restaurant budget bands | 🚦 Restaurant trading status |

### How to scrape Tabelog reviews

There's nothing to install. With a free [Apify account](https://console.apify.com/sign-up):

1. Open [Tabelog Reviews Scraper](https://apify.com/boncross/tabelog-reviews) and paste restaurant URLs or ids (7 or 8 digits).
2. Choose a language and how many reviews you want per restaurant. Add a sort or a filter if you need one.
3. Press Start, then download the reviews as Excel, CSV, JSON, XML or HTML. Two restaurants at 100 reviews each took 8 seconds in testing.

### ⬇️ Input

Give it restaurants, as Tabelog URLs or bare ids. If you change nothing else you get the 100 newest reviews per restaurant, in Japanese with the full text, and the restaurant's header on each row.

For a list too long to paste, use Start URLs. It loads links in bulk from a file, a Google Sheet or a remote list, and adds them to whatever's in the restaurant list.

You have two limits. "Max reviews per restaurant" (default 100, up to 10,000) applies to each restaurant separately: ten restaurants at 50 each returns 500. "Maximum results for the whole run" caps the total across all of them, and nothing past it is fetched or charged for.

#### Newest reviews for two restaurants, in Japanese

```json
{
  "restaurants": [
    "https://tabelog.com/tokyo/A1301/A130101/13002457/",
    "13228602"
  ],
  "maxReviewsPerRestaurant": 300,
  "sort": "newest"
}
```

#### Highly rated dinner visits with photos, in English

```json
{
  "restaurants": ["13300481"],
  "language": "en",
  "visitType": "dinner",
  "sort": "visit_date",
  "minScore": "4",
  "withPhotosOnly": true,
  "maxReviewsPerRestaurant": 200
}
```

#### Full translated text, in Korean

```json
{
  "restaurants": ["13002457"],
  "language": "kr",
  "maxReviewsPerRestaurant": 50,
  "includeFullText": true
}
```

#### Only-new monitoring

```json
{
  "restaurants": ["13002457", "13228602", "13300481"],
  "sort": "visit_date",
  "visitedAfter": "2026-06",
  "dedupStoreName": "tabelog-reviews-ginza",
  "maxReviewsPerRestaurant": 500
}
```

| 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` | `ja` (default): each review's original Japanese text, always in full. `en`, `kr`, `tw`, `cn`, `th`: Tabelog's own translation, as an excerpt unless `includeFullText` is on. Scores, sub-scores, visit month and photos are the same in every language. |
| `maxReviewsPerRestaurant` | Default 100 reviews per restaurant, up to 10,000. Tabelog serves 20 per page. |
| `maxItems` | Run-wide ceiling on reviews across every restaurant. 0 (default) means no run-wide limit. |
| `sort` | `newest` (default, Tabelog's posting order) or `visit_date` (visit month, latest first). |
| `visitType` | `all` (default), `lunch`, `dinner`. Each row's `visitType` is the review's own meal; `visitTypeFilter` records which tab was read. |
| `includeFullText` | In a translated language, open each review's full translated text instead of the excerpt. Charged per expanded review. Japanese is always full text, at no extra charge. |
| `minScore`, `visitedAfter`, `withPhotosOnly` | Free post-filters. `visitedAfter` takes YYYY-MM; with the visit-date sort the run stops as soon as a page holds only earlier visits. |
| `includeRestaurantSummary` | Attach the restaurant header to every row. On by default. |
| `dedupStoreName` | Name a store and later runs return only reviews not seen before. |
| `maxConcurrency`, `delayMs` | Requests run at once (1 to 32, default 32) and an optional pause before each (default 0). |

#### For developers

- `maxReviewsPerRestaurant` is the per-restaurant limit and `maxItems` the run-wide one.
- `minScore`, `visitedAfter` and `withPhotosOnly` are applied after a page is read. A review they drop isn't charged. `visitType` is applied by Tabelog itself.
- When a filter or the `dedupStoreName` store keeps nothing, the read stops early: after 5 pages in a row with no review kept, or after about three times the pages the per-restaurant limit needs (at least 10).
- With `sort: "newest"` and a `dedupStoreName`, the read also stops at the first review an earlier run returned. That's what makes a scheduled run return the reviews posted since the last one.
- `includeFullText` does nothing in `ja`, where the text is always full. In the other languages each review that expands is billed as one `review-full-text`. A review Tabelog can't expand keeps its excerpt, with `textTruncated: true`, and isn't billed for the expansion.
- Reviews with no full text to return are counted in the run's `STATS` record under `fullTextUnavailable`, and the log warns once per restaurant.
- `maxConcurrency` (default 32) sets how many requests run at once. `delayMs` adds a pause before each. We'd leave both alone.
- A run that Apify restarts carries on from where it stopped. No review is written or charged twice.

### ⬆️ Output

You get one record per review. This one is real, in the default language, with the text and photos shortened:

```json
{
  "input": "13002457",
  "restaurantId": "13002457",
  "restaurantName": "GURGAON",
  "restaurantUrl": "https://tabelog.com/en/tokyo/A1301/A130101/13002457/",
  "restaurant": {
    "id": "13002457",
    "name": "GURGAON",
    "url": "https://tabelog.com/en/tokyo/A1301/A130101/13002457/",
    "score": 3.7,
    "rating": 3.7,
    "ratingScale": 5,
    "reviewCount": 3351,
    "genres": [
      "Indian",
      "Indian curry"
    ],
    "area": "Ginza, Shimbashi, Yurakucho",
    "subArea": "Ginza",
    "nearestStation": "Ginza Itchome Sta.",
    "status": {
      "badge": null,
      "live": true,
      "gloss": null,
      "titlePrefix": null,
      "notice": null
    },
    "budgetDinner": "JPY 2,000 - JPY 2,999",
    "budgetLunch": "JPY 1,000 - JPY 1,999"
  },
  "id": "243451226",
  "reviewId": "243451226",
  "url": "https://tabelog.com/en/tokyo/A1301/A130101/13002457/dtlrvwlst/B536345760/?lc=0&smp=1&use_type=0",
  "score": 4,
  "rating": 4,
  "ratingScale": 5,
  "visitType": "lunch",
  "subScores": {
    "food": 4,
    "service": 4,
    "atmosphere": 4,
    "costPerformance": 4,
    "drinks": null
  },
  "spendPerPerson": "JPY 2,000～JPY 2,999",
  "spendPeople": null,
  "visitMonth": "2026-09",
  "visitCount": 1,
  "visitText": "Visited on September, 2026 1 time",
  "title": "元ダバインディア姉妹店",
  "text": "土曜の12時半過ぎに到着。\n銀座一丁目駅が最寄だけど、銀座駅からも徒歩圏内。\n店内は空席ありですんなり入れました。ランチは現金のみ。\n単品でと思ったら、ホリデーランチ(2,680円)なるものがありこちらを選択。\nどうせなら名物のチーズクルチ…",
  "textTruncated": false,
  "reviewer": {
    "name": "IKKO'S FILMSTokyo",
    "id": "011773731",
    "url": "https://tabelog.com/rvwr/011773731/",
    "reviewCount": 2423,
    "followers": 5676,
    "avatar": "https://tblg.k-img.com/user/images/Profile/11773/70x70_11773731.jpg?1785767198"
  },
  "photos": [
    "https://tblg.k-img.com/restaurant/images/Rvw/383940/640x640_rect_f2686569e836e608800b3e6b7d54a7b1.jpg",
    "…"
  ],
  "photoCount": 14,
  "textLanguage": "ja",
  "language": "ja",
  "sort": "newest",
  "visitTypeFilter": "all",
  "scrapedAt": "2026-09-28T01:30:38.726Z"
}
```

`subScores` holds `food`, `service`, `atmosphere`, `costPerformance` and `drinks`, each null where the reviewer gave none. `textLanguage` is `ja` when the text is the Japanese original. If Tabelog doesn't know a restaurant, you get a row with `input`, `id` and `error`, and that restaurant isn't charged.

### Limitations

Read the first one before you build on the text.

- **Some reviews have no Japanese original to return.** They're mostly reviews of a purchase, not of a visit, and have no lunch or dinner marker. In one check they were 13 of 15 at a sweet shop and none at seven restaurants measured the same day. Those rows keep Tabelog's translated excerpt, with `textTruncated: true` and no `textLanguage`, and the run statistics count them. Filter on `textTruncated` if you need originals only.
- In Japanese the review body is the reviewer's original. The title is the original too where the reviewer wrote one, and null otherwise. In the other languages both are Tabelog's own translation.
- Tabelog shows no posting date for a review, only the month of the visit. The newest-first order is Tabelog's, and it can't be checked from the rows. There's no rating distribution either. The aggregate score and counts come from the restaurant header.
- `photos` lists the photos the review list shows, up to four. `photoCount` is the review's total, which can be higher.
- Sub-scores exist only when the reviewer entered them.
- Tabelog doesn't show a review's like count on these pages, and prints the party size only in Korean, Chinese and Thai.
- A review's `url` is the reviewer's page for that restaurant. Two visits by the same reviewer share one link, and `reviewId` tells them apart.
- You can't search for a restaurant by name here. [Tabelog Search Scraper](https://apify.com/boncross/tabelog-search) finds ids by area and genre.

### How much does it cost?

| Event | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| `actor-start`, per run | $0.002 | $0.002 | $0.002 | $0.002 |
| `venue-resolved`, per restaurant, covering the header with aggregates | $0.002 | $0.002 | $0.002 | $0.002 |
| `review-scraped`, per review returned | $0.002 | $0.0018 | $0.0016 | $0.0014 |
| `review-full-text`, per review expanded to its full translated text (English, Korean, Chinese and Thai only) | $0.0005 | $0.00045 | $0.0004 | $0.00035 |

Enterprise plans pay the Business price.

**$2.00 per 1,000 reviews** on the Free plan, $1.40 on Business, with the full Japanese text included. You pay nothing else: no proxy to arrange, no platform usage added. Reviews a filter drops and reviews you've already had are free.

- Two restaurants, 300 newest reviews each, in Japanese: $0.002 + 2 × $0.002 + 600 × $0.002 = **$1.206** ($0.846 on Business).
- One restaurant, 50 reviews with full text in English, say 49 expanded: $0.002 + $0.002 + 50 × $0.002 + 49 × $0.0005 = **$0.1285** ($0.0912 on Business).

The $5 of credits Apify's Free plan gives you each month covers about 24 restaurants at the default 100 reviews, some 2,400 reviews, before you pay anything.

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

| Run | Result |
|---|---|
| Two restaurants, 100 newest reviews each, in Japanese | 200 reviews, all unique, each with its full original Japanese text; 8 seconds |
| One restaurant, 8 reviews | 8 reviews, 3 seconds |
| 20 restaurants in eight cities, 100 newest each, in Japanese | 1,905 reviews with their original Japanese text, 165 seconds |
| Two restaurants, in English with full text | 200 reviews; 198 expanded to the full translation, 2 left as excerpts and not charged |

The Japanese runs were timed on Apify on 2 and 3 October 2026, at the default settings and with no page lost. In Japanese that works out at about 700 reviews a minute, roughly 40,000 inside the default one-hour run limit. The translated languages run faster.

You can take as many reviews as a restaurant has, in pages of 20. A busy restaurant holds thousands, and it's worth setting "Max reviews per restaurant" to the number you'll actually use.

Not every review fills every column. Across the 200 Japanese reviews above: score, visit month, spend per person and photos on all 200, a title on 109, and the five sub-scores on 70.

### Only the new reviews, on a schedule

This is the setup we'd recommend if you watch your own venues. Give "Only-new store" a name, keep the newest-first sort, and create an Apify Schedule. Each run returns the reviews posted since the last one and stops reading there. A webhook or the Slack integration can tell you the moment one arrives.

From your own code, `POST https://api.apify.com/v2/acts/boncross~tabelog-reviews/run-sync-get-dataset-items` with the input JSON as the body runs a short job and returns the reviews in the response. For thousands of reviews, start the run and read the dataset when it finishes. The `apify-client` package exists for Node.js and for Python.

It also works as a tool for AI agents through the Apify MCP server at `mcp.apify.com`. An agent in Claude, ChatGPT or Cursor can pull a restaurant's recent reviews and summarise what diners liked and didn't.

### FAQ

#### Is the Japanese text the original or a translation?

It's the reviewer's own text, complete, and it costs nothing extra. The other languages give you Tabelog's translation. The exception is the handful of reviews Tabelog holds no original for, described under Limitations.

#### What's the difference between the excerpt and the full text?

In a translated language the review list shows about the first 100 characters. Switch on "Fetch full review text" and you get the complete translation, at $0.0005 per review that expands. In the English test run 198 of 200 expanded. The other 2 kept their excerpts and weren't charged for the expansion.

#### How many reviews can I get per restaurant?

All of them, if you want. The default is 100 and the setting goes up to 10,000.

#### Why do some reviews have no sub-scores?

Tabelog treats the five category scores as optional, and many reviewers skip them. They were filled on 70 of 200 reviews in one run.

#### Can I sort by most liked, or by the date a review was posted?

Neither is possible. Tabelog shows no like count and no posting date on these pages. You can sort newest first, which is Tabelog's own posting order, or by visit month.

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

No to both. There's no proxy to set up, and nothing is logged in.

#### Can I get lunch and dinner reviews separately?

Set "Visit type" to lunch or dinner and Tabelog returns only those. With it left on all, each row still tells you which meal the review was for.

#### Is scraping Tabelog reviews legal?

The actor reads only pages Tabelog serves to any logged-out visitor, and scraping publicly available data is generally legal. Reviews are personal content, though. Each row has the reviewer's public display name, profile id and profile URL, and you should handle them in line with Tabelog's terms and the data-protection law that applies to you.

### More from BonCross

- [Tabelog Restaurant Scraper](https://apify.com/boncross/tabelog-restaurant): Full Tabelog (食べログ) restaurant records by URL or id, in English, Korean, Chinese or Thai.
- [Tabelog Japanese Detail Add-on](https://apify.com/boncross/tabelog-restaurant-ja): Add the columns Tabelog publishes only on its Japanese pages to restaurant rows you…
- [Tabelog Search Scraper](https://apify.com/boncross/tabelog-search): Tabelog (食べログ) restaurant rankings by area and genre.
- [Tripadvisor Restaurants Scraper](https://apify.com/boncross/tripadvisor-restaurants-scraper): Every restaurant Tripadvisor lists for a city.
- [Tripadvisor Place Details Scraper](https://apify.com/boncross/tripadvisor-location-details): The full Tripadvisor record for any hotel, restaurant or attraction.
- [Tripadvisor Reviews Scraper](https://apify.com/boncross/tripadvisor-reviews): Every Tripadvisor review for any hotel, restaurant, attraction or tour.

### Your feedback

Seen a review whose text or scores don't match Tabelog? Report it on the Issues tab in Apify Console and include the review id. We read each report and reply in the thread.

# Changelog

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

# Actor input Schema

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

Tabelog restaurant URLs or bare restaurant ids (7 or 8 digits).

## `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 the reviews are read in. Japanese returns each review's original Japanese text, in full. English, Korean, Chinese and Thai return the same reviews translated by Tabelog, with the full translated text when Full review text is on. Scores, sub-scores, visit month, visit type and photos are identical in every language.

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

How many reviews to return per restaurant. Tabelog serves 20 per page.

## `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.

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

newest is Tabelog's default order. visit_date orders by the month the reviewer visited, latest first.

## `visitType` (type: `string`):

All reviews, or only lunch or only dinner visits, using Tabelog's own lunch and dinner tabs.

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

Drop reviews scoring below this, from 1 to 5. Applied after the fetch, at no charge.

## `visitedAfter` (type: `string`):

Keep reviews whose visit month is this month or later, as YYYY-MM. With the visit-date sort the run stops as soon as a page holds only earlier visits.

## `withPhotosOnly` (type: `boolean`):

Keep only reviews that carry photos.

## `includeFullText` (type: `boolean`):

Fetch each review's complete text instead of the excerpt, which a list page cuts off at roughly 100 characters. In English, Korean, Chinese and Thai this costs one extra request per expanded review and is charged as a separate event, only for reviews that were actually expanded. In Japanese every review already comes back with its full original text, at no extra charge.

## `includeRestaurantSummary` (type: `boolean`):

Attach the restaurant's header (score, review count, genres, area, nearest station, status and budgets) to every review.

## `dedupStoreName` (type: `string`):

Name a key-value store and the actor remembers which review ids it has seen for each restaurant, so scheduled runs push only new reviews.

## `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/"
  ],
  "startUrls": [],
  "language": "ja",
  "maxReviewsPerRestaurant": 100,
  "maxItems": 0,
  "sort": "newest",
  "visitType": "all",
  "minScore": "0",
  "withPhotosOnly": false,
  "includeFullText": false,
  "includeRestaurantSummary": true,
  "maxConcurrency": 32,
  "delayMs": 0
}
```

# Actor output Schema

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

Tabelog reviews: 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/"
    ]
};

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

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

```

## MCP server setup

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