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

Scrape Tabelog (tabelog.com) restaurants in Japan by keyword, area or URL. Extract names, cuisines, ratings, reviews, lunch and dinner budgets, stations, addresses, GPS, phone numbers, hours, seating, photos, smoking policies, closed days and reservation availability.

- **URL**: https://apify.com/abotapi/tabelog-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.60 / 1,000 restaurant records

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

Scrape restaurants from Tabelog (tabelog.com), Japan's largest restaurant guide. Search by cuisine and a plain area name such as Shibuya or Osaka, or paste any Tabelog link, and get rating, review count, genre, nearest station, lunch and dinner budget, closed days, smoking policy, photos and online reservation availability for every restaurant, plus address, business hours, payment methods, seats and the newest reviews.

### Why This Scraper?

- **Two ways in.** Search by keyword and area name (Shibuya, Akihabara, Osaka, Sapporo), or paste any Tabelog link: restaurant, review, menu or photo page, search list, area page or cuisine list.
- **Ranked the way Tabelog ranks.** Keep the site ranking, or sort by highest rating or most reviews.
- **Useful filters.** Minimum rating, minimum reviews, smoking policy and online-reservation-only.
- **Budgets as numbers and text.** Lunch and dinner budget come as the shown range plus minimum and maximum yen values.
- **Reservation availability.** Restaurants that take online reservations carry the upcoming days and their status, one flat record per restaurant with no duplicates.
- **Optional details.** Turn on restaurant details to add address, postal code, coordinates, phone number, business hours, payment methods, seats, private rooms, parking, transportation, facilities and occasions.
- **Reviews on the row.** The newest reviews (20 by default) ride the restaurant record with reviewer, rating, meal time, sub scores, spend, visit month, text and photos. Turn on full review text to open each cut-off review.

### Use Cases

- **Food and travel apps:** build restaurant directories with ratings, stations and budgets.
- **Market research:** compare cuisines, price bands and review volume across Japanese cities.
- **Hospitality analysts:** track top ranked restaurants and awards in an area over time.
- **Lead generation:** list restaurants by area with address and phone number.
- **Reputation tracking:** follow what diners say about a restaurant through its newest reviews.
- **Tour planners:** find non smoking, reservable restaurants near a station.

### Data You Get

> Sample shape: values are illustrative placeholders, not from a live record.

| Field | Example |
| --- | --- |
| `restaurantId` | `13000000` |
| `name` | `Sample Ramen Shop` |
| `rank` | `1` |
| `rating` | `3.60` |
| `reviewCount` | `500` |
| `genre` | `Ramen, Tsukemen (Dipping noodles)` |
| `station` | `Sample Sta.` |
| `stationDistance` | `250m` |
| `dinnerBudget` | `- JPY 999` |
| `lunchBudget` | `JPY 1,000 - JPY 1,999` |
| `closedDays` | `Sunday, Public Holiday` |
| `smokingPolicy` | `Non smoking` |
| `imageUrl` | `https://example.com/photo.jpg` |
| `reservation` | `true` |
| `reservationInfo` | `{"onlineReservation": true, "days": [...]}` |
| `address` | `Sample district, Tokyo` |
| `latitude` / `longitude` | `35.0` / `139.0` |
| `phone` | `+81-0-0000-0000` |
| `url` | `https://example.com/restaurant/` |
| `businessHours` | `Mon-Fri 11:00 AM - 2:30 PM` |
| `paymentMethods` | `Credit cards not accepted` |
| `seats` | `12 seats (12 counter seats)` |
| `transportation` | `Sample Line, Sample Station, 1 minute walk` |
| `reviews` | list of review objects (see below) |
| `reviewsDelivered` | `20` |

**Review object (inside `reviews`):**

> Sample shape: values are illustrative placeholders, not from a live record.

```json
{
  "reviewId": "B500000000",
  "reviewUrl": "https://example.com/review/",
  "reviewerName": "Sample reviewer",
  "reviewerPostCount": 120,
  "rating": 3.5,
  "mealTime": "lunch",
  "scoreFood": 3.5,
  "scoreService": null,
  "spendPerPerson": "JPY 1,000～JPY 1,999",
  "visitMonth": "2026-10",
  "visitCount": 1,
  "title": "Sample title",
  "text": "Sample review text",
  "textTruncated": false,
  "photos": []
}
```

### How to Use

1. Pick a mode: search by keyword and area, or paste Tabelog links.
2. Set your keywords, areas and filters, or paste the links.
3. Choose Max items, whether to add restaurant details and how many reviews to attach.
4. Run it and download the dataset as JSON, CSV or Excel.

**Search ramen in Tokyo:**

```json
{
  "mode": "search",
  "searchTerms": ["ramen"],
  "locations": ["tokyo"],
  "maxItems": 20
}
```

**Top rated sushi in two cities with details:**

```json
{
  "mode": "search",
  "searchTerms": ["sushi"],
  "locations": ["tokyo", "osaka"],
  "sortBy": "rating",
  "minReviews": 100,
  "fetchDetails": true,
  "maxItems": 50
}
```

**Search by plain area name:**

```json
{
  "mode": "search",
  "searchTerms": ["yakiniku"],
  "locations": ["Shibuya", "Osaka"],
  "maxItems": 30
}
```

**Paste links of any shape:**

```json
{
  "mode": "url",
  "urls": [
    "https://tabelog.com/en/tokyo/A1310/A131002/13011452/",
    "https://tabelog.com/en/tokyo/rstLst/?sw=ramen",
    "https://tabelog.com/en/tokyo/A1303/",
    "https://tabelog.com/en/rstLst/ramen/"
  ],
  "maxItems": 40,
  "maxReviews": 20
}
```

#### Run it from your code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("<ACTOR_ID>").call(run_input={"mode": "search", "searchTerms": ["ramen"], "locations": ["tokyo"], "maxItems": 20})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["name"], item["rating"])
```

JavaScript:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('<ACTOR_ID>').call({ mode: 'search', searchTerms: ['ramen'], locations: ['tokyo'], maxItems: 20 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map((i) => `${i.name} ${i.rating}`));
```

#### Tips

- Type areas as plain names: a prefecture (Tokyo, Osaka, Kyoto) or an area (Shibuya, Akihabara, Ginza, Sapporo, Nagoya). Area codes such as `A1310` and paths such as `tokyo/A1310` also work, and `all` searches the whole country. A name that cannot be matched is named in the log and skipped, never guessed.
- Reviews are read for every restaurant whose own page is read: with Add restaurant details on, or for a restaurant link pasted in URL mode. Set Max reviews per restaurant to 0 to skip them.
- Max items is the cap for the whole run and is shared across every keyword and area. Max pages does not cap the run.
- Leave search keywords empty to list every restaurant in an area.

### Send results into your apps (MCP connectors)

Optionally send the scraped results into the apps you already use via Model Context Protocol (MCP) connectors. Authorize a connector once under Apify, Settings, Integrations, then select it in the run input. The connector receives a short summary per item; the full record stays in the dataset. Leave the field empty to skip.

### Input Parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | string | `search` | Search by keyword and area, or paste Tabelog links. |
| `searchTerms` | array | `["ramen"]` | Cuisine, dish or restaurant name. Empty lists every restaurant in the area. |
| `locations` | array | `["Tokyo"]` | Plain area names (Shibuya, Osaka), area codes or paths such as tokyo/A1310; all for the whole country. |
| `sortBy` | string | `ranking` | Tabelog ranking, highest rating or most reviews. Most reviews orders the first 10 list pages (about 200 restaurants) of each search. |
| `minRating` | number | `0` | Keep restaurants rated at least this value. |
| `minReviews` | integer | `0` | Keep restaurants with at least this many reviews. |
| `smoking` | string | `any` | Any, non smoking, designated area, smoking allowed or heated tobacco only. |
| `reservableOnly` | boolean | `false` | Keep only restaurants that take online reservations. |
| `urls` | array | five sample links | Restaurant, review, menu or photo pages, search lists, area pages and cuisine lists. Filter fields are ignored. |
| `fetchDetails` | boolean | `false` | Add address, postal code, coordinates, phone, business hours, payment methods, seats and more, plus reviews. |
| `maxReviews` | integer | `20` | Newest reviews attached to each restaurant whose page is read. 0 skips reviews. |
| `fullReviewText` | boolean | `false` | Open each cut-off review for its complete text. |
| `maxPages` | integer | empty | Page limit per search. Does not cap the run. |
| `maxItems` | integer | `20` | Maximum restaurants for the whole run. 0 means unlimited. |
| `proxy` | object | Apify proxy | Proxy settings. |
| `resumeFromRunId` | string | empty | Run or dataset id of an earlier run. Restaurants collected there are skipped. |
| `incrementalMode` | boolean | `false` | Return only NEW, UPDATED and REAPPEARED restaurants on repeat runs. |
| `stateKey` | string | empty | Name a monitoring campaign to keep its state stable. |
| `emitUnchanged` | boolean | `false` | Also return restaurants that did not change. |
| `emitExpired` | boolean | `false` | Also return restaurants no longer found after a complete scan. |
| `ignoreFieldsForChanges` | array | empty | Field names whose changes alone do not mark a restaurant UPDATED. |
| `mcpConnectors` | array | empty | Optional connectors to send results to. |
| `notionParentPageUrl` | string | empty | Notion page under which item pages are created. |
| `maxNotifyListings` | integer | `50` | Cap on items exported per connector. |

### Output Example

> Sample shape: values are illustrative placeholders, not from a live record.

```json
{
  "recordType": "restaurant",
  "restaurantId": "13000000",
  "name": "Sample Ramen Shop",
  "rank": 1,
  "rating": 3.6,
  "reviewCount": 500,
  "genre": "Ramen, Tsukemen (Dipping noodles)",
  "station": "Sample Sta.",
  "stationDistance": "250m",
  "dinnerBudget": "- JPY 999",
  "lunchBudget": "JPY 1,000 - JPY 1,999",
  "closedDays": "Sunday, Public Holiday",
  "smokingPolicy": "Non smoking",
  "reservation": false,
  "detailsScraped": false,
  "scrapedAt": "2026-01-01T00:00:00Z"
}
```

### Plan Requirement

The actor runs on any Apify plan. Proxy usage is billed by Apify according to your plan.

#### Proxy

The default Apify proxy reads this site reliably and works on every plan that includes proxy access. Residential is recommended for the most reliable results on large or frequent runs. If a connection type is refused for your account, the run continues on a backup connection and logs a notice. Apify free plans do not include residential proxies, so some pages may be unavailable there; upgrade at https://apify.com/pricing or supply your own proxy URLs. Residential traffic is capped per run, after which the run continues on the standard connection.

### FAQ

#### How much does a run cost?

You pay per restaurant returned, a detail event per restaurant whose own page is read, and a review event for each review delivered on those restaurants. Restaurants that are not returned, unchanged restaurants hidden by incremental mode and reviews that were not delivered are never charged. See the pricing tab for the current rates.

#### Is it legal to scrape Tabelog?

The actor reads publicly visible restaurant information. You are responsible for using the data in line with the site terms and the laws that apply to you.

#### Can I schedule runs?

Yes. Use Apify schedules to refresh a search daily or weekly.

#### Why are some budgets empty?

Restaurants that list no lunch or dinner budget return an empty value.

#### Why did a run fail?

A run fails only when no page could be read at all. Try again later or choose a different proxy group.

#### Can I use it with AI tools?

Yes. Use the MCP export or the Apify MCP server to hand results to your assistant.

### 🔗 More scrapers you might like

Pair this actor with these related scrapers from the same team:

<table>
<tr><td>🛒 <a href="https://apify.com/abotapi/zomato-scraper"><b>Zomato Scraper</b></a><br>Scrape restaurants and reviews from zomato.com. Get names, cuisines, ratings and votes...</td><td>🧩 <a href="https://apify.com/abotapi/resy-restaurant-availability-scraper"><b>Resy Scraper</b></a><br>Scrape Resy restaurants and live reservation availability by city or URL. Get bookable...</td></tr>
<tr><td>🧩 <a href="https://apify.com/abotapi/opentable-reviews-scraper"><b>OpenTable Reviews Scraper</b></a><br>Scrape full OpenTable.com restaurant reviews by keyword, area, or restaurant profile...</td><td>🛒 <a href="https://apify.com/abotapi/grabfood-restaurants-scraper"><b>GrabFood Restaurant Scraper</b></a><br>Scrape GrabFood restaurants across Southeast Asia, including SG, MY, TH, VN, PH, ID, KH...</td></tr>
<tr><td>🛒 <a href="https://apify.com/abotapi/wolt-restaurants-scraper"><b>Wolt Scraper</b></a><br>Scrape Wolt restaurants and full menus by city or URL. Extract 60+ fields including...</td><td>🧩 <a href="https://apify.com/abotapi/rakuten-ichiba-scraper"><b>Rakuten Ichiba Scraper</b></a><br>Scrape Rakuten Ichiba (rakuten.co.jp) by keyword or URL. Extract JPY prices, discounts...</td></tr>
</table>

👉 [Browse all abotapi scrapers](https://apify.com/abotapi)

### 💬 Support

- 🐞 **Found a bug or a missing field?** Open a ticket on the [Issues tab](https://apify.com/abotapi/tabelog-scraper/issues/open). We usually reply within hours.
- 🛠️ **Need another site, extra fields or a private build?** Email <contact@abotapi.com>.
- ⭐ **Enjoying it?** A quick review on the actor page helps other users find it.

# Actor input Schema

## `mode` (type: `string`):

Search runs a keyword and area search. URL mode reads the Tabelog pages you paste.

## `searchTerms` (type: `array`):

Cuisine, dish or restaurant name, for example ramen, sushi or yakiniku. Leave empty to list every restaurant in the area.

## `locations` (type: `array`):

Where to search, by plain name: a prefecture (Tokyo, Osaka, Kyoto, Hokkaido) or an area (Shibuya, Akihabara, Ginza, Shinjuku, Sapporo, Nagoya). Area codes (A1310) and paths (tokyo/A1310) also work, and "all" searches the whole country. A name that cannot be matched is reported in the log and skipped, never guessed. Every keyword is searched in every area.

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

Order of the results. Most reviews reads the first 10 list pages of each search (about 200 restaurants) and orders those by review count, because the site has no review-count order of its own.

## `minRating` (type: `number`):

Keep only restaurants rated at least this value (Tabelog scores run roughly 2.5 to 4.5). 0 keeps everything.

## `minReviews` (type: `integer`):

Keep only restaurants with at least this many reviews. 0 keeps everything.

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

Narrow the search to one smoking policy.

## `reservableOnly` (type: `boolean`):

Keep only restaurants that take online reservations.

## `urls` (type: `array`):

Multi-URL mode. Paste any Tabelog link: a restaurant page (its review, menu, photo and map pages work too), a keyword search list, an area or prefecture page, a cuisine list, a station list or a ranking list. Links in any language version of the site are read in English. The filter fields above are ignored and pagination walks forward. Links that are not restaurant or list pages are skipped with a warning.

## `fetchDetails` (type: `boolean`):

Open each restaurant page to add address, postal code, coordinates, phone number, business hours, payment methods, seats, transportation and facilities, plus the newest reviews (see Max reviews per restaurant). Billed as a separate detail event per restaurant. Restaurants pasted as links in URL mode are always read this way.

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

How many of the newest reviews to attach to each restaurant whose own page is read (Add restaurant details, or a restaurant link in URL mode). Default 20, 0 skips reviews. Each delivered review is billed as one review event.

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

Reviews carry the site's preview text, which is cut off on long reviews and marked textTruncated. Turn on to open each cut-off review for its complete text. Slower; no extra charge.

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

Optional page limit per search. Leave empty or 0 for no page limit (default). This does not cap the run: it defers to Max items, which is the one default cap.

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

The one default cap: maximum number of restaurants to return across the whole run (default 20). 0 means unlimited. Max pages per search has no default limit and defers to this value.

## `proxy` (type: `object`):

Proxy settings. The default Apify proxy works on every plan and reads this site reliably. Residential is recommended for the most reliable results on large or frequent runs.

## `resumeFromRunId` (type: `string`):

Run ID (or dataset ID) of a previous run of this Actor. Restaurants already collected there are skipped, so this run returns only the delta. Leave empty for a normal run. For recurring daily or weekly monitoring of the same search, use Incremental changes below instead.

## `incrementalMode` (type: `boolean`):

Turn this on for daily or recurring monitoring. A restaurant is returned as UPDATED when a tracked field changes (rating, budget, closed days, genre, smoking policy, photos, details). Not compared: rank, page, review count, the reservation calendar and the newest-reviews list. The first run returns every matching restaurant as NEW; later runs return only NEW, UPDATED and REAPPEARED restaurants. State is kept separately for each search and filter setup; use State key to name or share a campaign.

## `stateKey` (type: `string`):

Name this monitoring campaign to keep its state stable, or to deliberately share state across differently configured runs. Leave empty to derive a key automatically from the search and filter settings.

## `emitUnchanged` (type: `boolean`):

Off by default. Turn on to also return restaurants that have not changed since the last run, marked UNCHANGED. These extra rows are billed like any other row.

## `emitExpired` (type: `boolean`):

Off by default. Turn on to also return restaurants seen in an earlier run but no longer found, marked EXPIRED. Only produced after a run that read every page to its end, not when Max items capped it or Resume was used. These extra rows are billed like any other row.

## `ignoreFieldsForChanges` (type: `array`):

Field names whose changes alone should not make a restaurant UPDATED. Rank, page, review count, the reservation calendar and the newest-reviews list are already ignored by default.

## `mcpConnectors` (type: `array`):

Optionally send the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize a connector once under Apify → Settings → Integrations, then select it here. The connector receives a condensed, human-readable summary per item (title + key fields), not the full JSON; the complete record stays in the dataset. Leave empty to skip.

## `notionParentPageUrl` (type: `string`):

URL (or id) of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "searchTerms": [
    "ramen"
  ],
  "locations": [
    "Tokyo"
  ],
  "sortBy": "ranking",
  "minRating": 0,
  "minReviews": 0,
  "smoking": "any",
  "reservableOnly": false,
  "urls": [
    "https://tabelog.com/en/tokyo/A1310/A131002/13011452/",
    "https://tabelog.com/en/tokyo/rstLst/?sw=ramen",
    "https://tabelog.com/en/tokyo/A1303/",
    "https://tabelog.com/en/rstLst/ramen/",
    "https://tabelog.com/en/tokyo/A1310/A131002/13011452/dtlrvwlst/"
  ],
  "fetchDetails": false,
  "maxReviews": 20,
  "fullReviewText": false,
  "maxItems": 20,
  "proxy": {
    "useApifyProxy": true
  },
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "maxNotifyListings": 50
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `reservations` (type: `string`):

No description

## `details` (type: `string`):

No description

## `reviews` (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 = {
    "searchTerms": [
        "ramen"
    ],
    "locations": [
        "Tokyo"
    ],
    "urls": [
        "https://tabelog.com/en/tokyo/A1310/A131002/13011452/",
        "https://tabelog.com/en/tokyo/rstLst/?sw=ramen",
        "https://tabelog.com/en/tokyo/A1303/",
        "https://tabelog.com/en/rstLst/ramen/",
        "https://tabelog.com/en/tokyo/A1310/A131002/13011452/dtlrvwlst/"
    ],
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/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 = {
    "searchTerms": ["ramen"],
    "locations": ["Tokyo"],
    "urls": [
        "https://tabelog.com/en/tokyo/A1310/A131002/13011452/",
        "https://tabelog.com/en/tokyo/rstLst/?sw=ramen",
        "https://tabelog.com/en/tokyo/A1303/",
        "https://tabelog.com/en/rstLst/ramen/",
        "https://tabelog.com/en/tokyo/A1310/A131002/13011452/dtlrvwlst/",
    ],
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/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 '{
  "searchTerms": [
    "ramen"
  ],
  "locations": [
    "Tokyo"
  ],
  "urls": [
    "https://tabelog.com/en/tokyo/A1310/A131002/13011452/",
    "https://tabelog.com/en/tokyo/rstLst/?sw=ramen",
    "https://tabelog.com/en/tokyo/A1303/",
    "https://tabelog.com/en/rstLst/ramen/",
    "https://tabelog.com/en/tokyo/A1310/A131002/13011452/dtlrvwlst/"
  ],
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call abotapi/tabelog-scraper --silent --output-dataset

```

## MCP server setup

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