# Tabelog Scraper — Japan Restaurant Ratings, Reviews & Genres (`haketa/tabelog-scraper`) Actor

Scrape Tabelog (食べログ), Japan's #1 restaurant review site: restaurant name, Tabelog rating, review count, saves (bookmarks), cuisine genres, nearest station + distance and photo. Fast HTTP with Cloudflare bypass, no login.

- **URL**: https://apify.com/haketa/tabelog-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Business, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Tabelog Scraper — Japan Restaurant Ratings, Reviews, Genres & Stations (食べログ)

[![Runs on Apify](https://img.shields.io/badge/Runs%20on-Apify-00C7FF?logo=apify\&logoColor=white)](https://apify.com/haketa/tabelog-scraper)
[![Pricing](https://img.shields.io/badge/Pricing-Pay%20Per%20Result-brightgreen)](https://apify.com/haketa/tabelog-scraper)
[![Export](https://img.shields.io/badge/Export-JSON%20%7C%20CSV%20%7C%20Excel-orange)](https://apify.com/haketa/tabelog-scraper)
[![Maintenance](https://img.shields.io/badge/Maintained-Active-success)](https://apify.com/haketa/tabelog-scraper)

**Scrape Tabelog** (食べログ / tabelog.com), Japan's most prestigious and authoritative restaurant discovery directory, and extract structured dining intelligence at enterprise scale. This automated **Tabelog scraper** systematically captures **restaurant names, community star ratings, total review volume, bookmark saves, multi-genre culinary classifications, nearest train stations with walking distances in meters, geographic regions, and food imagery** — without requiring login accounts, Japanese phone verifications, or manual scraping workflows.

Export thousands of Japanese culinary venues directly to **JSON, CSV, Excel, XML, or integrate via REST API and automated webhooks** in minutes.

> Engineered for food & beverage analysts, restaurant technology & POS software providers, hospitality booking platforms, culinary travel guides, supply chain logistics, and B2B lead generation specialists who require high-fidelity **Japanese dining data** without hitting verification walls.

***

### ⚡ At a glance

| Feature | Specification |
|---|---|
| **Target Website** | [Tabelog](https://tabelog.com/) (Japan's #1 Gourmet & Restaurant Review Platform) |
| **Input Flexibility** | Direct search listing URLs (`rstLst`) by prefecture, ward, city, and culinary cuisine |
| **Paging Scale** | 1,000+ restaurants across multi-page deep pagination |
| **Data Fields** | 12+ structured attributes per dining venue |
| **Rating Accuracy** | Strict community ratings (1.00–5.00 scale) with engagement metrics |
| **Location Precision** | Nearest train/subway station name and parsed walking distance in meters |
| **Cuisine Taxonomy** | Parsed array (`genres`) and comma-separated string (`genresText`) |
| **Deduplication** | 100% unique records keyed by stable Tabelog numeric `restaurantId` |
| **Access Architecture** | Stealth anti-detect browser automation paired with Residential IP proxy rotation |
| **Export Formats** | JSON, CSV, Excel, XML, HTML Table, Apify Dataset API |

***

### 🔎 Why scrape Tabelog?

[Tabelog](https://tabelog.com) is the undisputed gold standard for gastronomic reputation across Japan. Unlike Western review platforms where average ratings frequently inflate to 4.5 stars, Tabelog enforces a famously rigorous statistical curve:

- **Under 3.00**: New or unreviewed dining spots.
- **3.00 – 3.49**: Solid, reliable everyday local dining venues.
- **3.50 – 3.99**: Exceptional culinary destinations in the top 3% of Japan.
- **4.00+**: Legendary, Michelin-grade culinary institutions in the top 0.1% nationwide.

This mathematical rigor makes Tabelog ratings the ultimate quality filter for food service intelligence. However, programmatic data acquisition faces significant challenges:

- **No public REST API**: Tabelog does not offer an open API for commercial dining search and bulk review harvesting.
- **Edge protection walls**: Automated HTTP requests are challenged by edge security verification checks.
- **Complex Japanese DOM markup**: Station distances, bookmark counts, and multi-layered cuisine categories are embedded in localized Japanese typography.
- **Bandwidth overhead**: Heavy high-resolution food photography inflates proxy data costs if not handled properly.

This **Tabelog data extractor** solves every layer: bypassing edge verification via stealth browser automation, blocking non-essential multimedia assets to reduce data consumption by over 80%, parsing Japanese station strings, and delivering deduplicated rows ready for analysis.

#### Primary commercial use cases

- **Benchmark Regional Dining Markets**: Compare average rating curves, review volumes, and bookmark velocity across Tokyo, Osaka, Kyoto, and Fukuoka.
- **Generate High-Converting B2B Leads**: Supply restaurant technology vendors (POS systems, reservation software, supplier ordering) with curated lists of high-performing venues.
- **Station-Level Food Logistics Planning**: Calculate culinary density around specific subway and commuter rail stations for delivery hub placement.
- **Curate Automated Travel Guides**: Populate luxury hospitality applications, concierge booking platforms, and tourism itineraries with top-rated venues.
- **Track Culinary Trends**: Detect rising cuisine genres (craft beer bars, specialty ramen styles, wagyu dining) before they saturate regional markets.

***

### ✨ Core capabilities

- ✅ **Universal Search URL Support**: Paste any Tabelog listing URL filtered by prefecture, neighborhood, station, or cuisine (e.g., `https://tabelog.com/tokyo/rstLst/ramen/` or `https://tabelog.com/osaka/rstLst/sushi/`).
- ✅ **Deep 1,000+ Restaurant Pagination**: Automatically traverses Tabelog's `/N/` pagination hierarchy until your target record volume is reached.
- ✅ **Strict Rating Extraction**: Extracts the true numeric Tabelog score (`rating`) alongside total user reviews (`reviewCount`) and community saves (`savedCount`).
- ✅ **Transit & Walking Distance Analytics**: Parses the primary train/subway station (`station`) and isolates the precise walking distance in meters (`stationDistanceM`).
- ✅ **Culinary Taxonomy Categorization**: Captures localized Japanese cuisine classifications both as a structured array (`genres`) and as a normalized string (`genresText`).
- ✅ **Bandwidth Optimized Execution**: Intelligently intercepts and blocks resource-heavy images, video, and fonts during navigation, slashing proxy bandwidth by ~80%.
- ✅ **Stealth Anti-Detect Automation**: Employs advanced headless browser fingerprinting designed to solve complex JavaScript verification challenges seamlessly.
- ✅ **Zero Duplicate Assurance**: Global in-memory deduplication guarantees that overlapping category queries never produce duplicate records.

***

### 🎯 Practical business applications

#### 1. Restaurant Technology & POS Sales Prospecting

Sales representatives selling modern point-of-sale systems, kitchen display hardware, or mobile ordering solutions can target venues with high bookmark counts (`savedCount > 2000`) but moderate ratings. These venues handle massive foot traffic and represent prime candidates for operational efficiency software.

#### 2. Food & Beverage Supplier Sourcing

Wholesale meat distributors, sake breweries, and seafood suppliers can scrape specific cuisine categories like yakiniku, sushi, or kaiseki across metropolitan hubs to build prospect directories filtered by neighborhood and station proximity.

#### 3. Food Delivery Hub Placement

Ghost kitchen operators and food delivery aggregators can evaluate dining density around major transit hubs by filtering for venues within 500 meters of key railway stations (`stationDistanceM <= 500`), identifying underserviced cuisine niches.

#### 4. High-End Tourism & Hospitality Concierge

Travel agencies and luxury credit card concierge desks can maintain automated feeds of restaurants with a Tabelog rating of `3.70+` across major tourist destinations, ensuring VIP clients receive reservations only at verified top-tier establishments.

***

### 📥 Input settings

The actor runs immediately with default settings (demonstrating Tokyo ramen dining), while supporting multi-URL batch crawling.

| Parameter | Type | Default | Prefill | Description |
|---|---|---|---|---|
| `startUrls` | Array | Tokyo Ramen URL | Tokyo Ramen URL | One or more Tabelog listing/search URLs. Build your filter on tabelog.com and paste the result URL. |
| `maxItems` | Integer | `0` | `20` | Maximum unique restaurants to scrape across all targets. `0` = unlimited (bounded by pagination). |
| `maxPages` | Integer | `0` | `0` | Maximum pagination pages per URL (20 restaurants per page). `0` = unlimited deep pagination. |
| `maxConcurrency` | Integer | `2` | `2` | Number of URLs to process concurrently. Keep low (1–2) for optimal proxy efficiency. |
| `proxyConfiguration` | Object | Residential | Residential | Proxy settings. Residential proxies are required for seamless edge challenge resolution. |

#### Sample configurations

##### 1. Quick exploratory test (Prefill default)

```json
{
  "startUrls": [
    { "url": "https://tabelog.com/tokyo/rstLst/ramen/" }
  ],
  "maxItems": 20,
  "maxPages": 0
}
```

##### 2. Multi-city culinary intelligence (Tokyo Ramen & Osaka Sushi)

```json
{
  "startUrls": [
    { "url": "https://tabelog.com/tokyo/rstLst/ramen/" },
    { "url": "https://tabelog.com/osaka/rstLst/sushi/" }
  ],
  "maxItems": 500,
  "maxPages": 0,
  "maxConcurrency": 2
}
```

##### 3. Deep neighborhood dive (Ginza Fine Dining)

```json
{
  "startUrls": [
    { "url": "https://tabelog.com/tokyo/A1301/A130101/rstLst/" }
  ],
  "maxItems": 1000,
  "maxPages": 0
}
```

***

### 📤 Output data structure

Each item in your Apify dataset represents an individual dining establishment.

#### Data field dictionary

##### 🍽️ Restaurant Identity & Profile

| Field | Type | Coverage | Description |
|---|---|---|---|
| `restaurantId` | String | 🟢 High (100%) | Stable numeric Tabelog venue ID (deduplication key). |
| `name` | String | 🟢 High (100%) | Official restaurant name in Japanese. |
| `url` | String | 🟢 High (100%) | Canonical URL to the restaurant's Tabelog landing page. |
| `imageUrl` | String | 🟢 High (98%+) | URL of the primary featured venue or dish photograph. |
| `area` | String | 🟢 High (100%) | Geographic area identifier derived from the source URL (e.g., `tokyo`). |

##### ⭐ Ratings & Community Engagement

| Field | Type | Coverage | Description |
|---|---|---|---|
| `rating` | Number | 🟢 High (98%+) | Official Tabelog score (`1.00`–`5.00`). Null for unranked/new listings. |
| `reviewCount` | Number | 🟢 High (99%+) | Total count of published customer reviews. |
| `savedCount` | Number | 🟢 High (100%) | Number of users who have saved/bookmarked the venue. |

##### 🏷️ Cuisine & Taxonomy

| Field | Type | Coverage | Description |
|---|---|---|---|
| `genres` | Array | 🟢 High (100%) | Array of cuisine categories (e.g., `["ラーメン", "つけ麺"]`). |
| `genresText` | String | 🟢 High (100%) | Comma-separated string of all tagged cuisine classifications. |

##### 🚉 Transit & Walking Distance

| Field | Type | Coverage | Description |
|---|---|---|---|
| `station` | String | 🟢 High (100%) | Raw station description string (e.g., `"広尾駅 840m"`). |
| `stationDistanceM` | Number | 🟢 High (99%+) | Parsed walking distance from nearest station in meters (`840`). |
| `scrapedAt` | String | 🟢 High (100%) | ISO 8601 UTC timestamp of data retrieval. |

***

#### Real JSON output record

```json
{
  "restaurantId": "13306356",
  "name": "THE TOKYO CLUB",
  "rating": 3.16,
  "reviewCount": 22,
  "savedCount": 1974,
  "station": "広尾駅 840m",
  "stationDistanceM": 840,
  "genres": [
    "ダイニングバー",
    "ハンバーガー",
    "ラーメン・つけ麺(担々麺)"
  ],
  "genresText": "ダイニングバー, ハンバーガー, ラーメン・つけ麺(担々麺)",
  "area": "tokyo",
  "url": "https://tabelog.com/tokyo/A1307/A130701/13306356/",
  "imageUrl": "https://tblg.k-img.com/restaurant/images/Rvw/312593/320x320_square_2d0c561f28eeb4c4a0b5095a925f5a5a.jpg",
  "scrapedAt": "2026-11-10T14:40:00.000Z"
}
```

***

### 🔁 Deep pagination & scale strategy

1. **Automatic Route Traversal**: Tabelog organizes result pages using trailing `/N/` URL path increments (20 establishments per page). The scraper handles URL construction and parameter preservation across all pages.
2. **Dynamic 1,000+ Record Scaling**: Setting `maxItems: 1000` (or `maxItems: 0` with `maxPages: 0`) allows the browser worker to continuously navigate through 50+ consecutive pages per search URL.
3. **Smart Session Retention**: Once initial edge verification is cleared, the active browser session maintains validated security cookies across pagination requests, maximizing crawling speed.
4. **Graceful End-of-Catalog Handling**: Navigation terminates cleanly when an empty card grid is encountered or when no new records appear.

***

### 🛠️ Step-by-step tutorial

1. **Configure Search on Tabelog**: Visit [tabelog.com](https://tabelog.com/), choose your desired prefecture (e.g., Tokyo, Osaka) and cuisine type, and copy the listing URL from your browser address bar.
2. **Add Start URLs**: In the Apify Console, paste the copied URL into `startUrls`. You can paste multiple URLs to collect different cities simultaneously.
3. **Define Desired Volume**: Set `maxItems` to `20` for a fast 1-minute test, or scale to `500`–`1000+` for full market research.
4. **Ensure Residential Proxy is Active**: Verify that Apify Residential proxy is selected in `proxyConfiguration`.
5. **Run the Actor**: Click **Start**. Live logs will indicate edge clearance and streaming item counts.
6. **Export Your Dataset**: Download your results in CSV, Excel, or JSON format from the **Storage** tab.

***

### 🏗️ Architecture & Data Extraction Flow

```mermaid
flowchart TD
    A[Start URLs: Area / Cuisine Search] --> B[Launch Stealth Browser Worker]
    B --> C[Dispatch Request via Residential Proxy]
    C --> D{Edge Verification Challenge?}
    D -->|Yes| E[Automated Turnstile / JS Challenge Clearance]
    E --> F[Retain Verified Session Cookies]
    D -->|No| F
    F --> G[Navigate Listing Page]
    G --> H[Block Heavy Images & Fonts]
    H --> I[Parse HTML Restaurant Cards]
    I --> J[Extract Ratings, Saves, Genres & Transit]
    J --> K[Deduplicate by Restaurant ID]
    K --> L[Stream Items to Apify Dataset]
    L --> M{MaxItems Reached or End of Pages?}
    M -->|No| N[Increment /N/ Page Counter]
    N --> G
    M -->|Yes| O[Close Browser & Finalize Run]
```

***

### 📊 Sample Code Integrations

#### Python (apify-client)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

## Scrape top-rated ramen in Tokyo
run_input = {
    "startUrls": [{"url": "https://tabelog.com/tokyo/rstLst/ramen/"}],
    "maxItems": 40,
    "maxPages": 0,
}

run = client.actor("haketa/tabelog-scraper").call(run_input=run_input, memory_mbytes=4096)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"[{item.get('rating', 'N/A')}] {item['name']} - Station: {item.get('station')} (Saves: {item.get('savedCount')})")
```

#### Node.js (apify-client)

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('haketa/tabelog-scraper').call({
    startUrls: [{ url: 'https://tabelog.com/osaka/rstLst/sushi/' }],
    maxItems: 40,
    maxPages: 0,
}, { memoryMbytes: 4096 });

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.table(items, ['name', 'rating', 'savedCount', 'genresText', 'station']);
```

***

### 💡 Pro scraping tips

- **Interpreting Tabelog Ratings**: In Japan, a rating of `3.50` or higher indicates an outstanding culinary establishment. Filtering your exported CSV for `rating >= 3.50` will immediately isolate the top culinary destinations in any city.
- **Bookmark Density as a Demand Metric**: For newly opened venues that haven't yet gathered enough reviews to score above 3.50, look at `savedCount`. A high save count (`1,000+`) is a strong indicator of viral popularity.
- **Targeting Specific Neighborhoods**: Tabelog allows granular geographic filtering down to specific train stations (e.g., Shibuya, Shinjuku, Ginza). Crafting station-specific URLs gives you exact neighborhood coverage.
- **Resource Efficiency**: Keep `maxConcurrency` at 1 or 2. Stealth browser sessions with Turnstile verification operate most reliably with focused concurrency.

***

### ❓ Frequently Asked Questions

**Does this actor require a Tabelog account or login?**\
No. The scraper accesses only public listing pages and does not require user accounts, passwords, or personal credentials.

**Why are residential proxies required for Tabelog?**\
Tabelog deploys strict edge security filters that automatically block traffic from commercial datacenter IP ranges. Residential proxies ensure that requests originate from standard residential network pools, allowing verification challenges to clear smoothly.

**Why are ratings null for a small number of venues?**\
Brand-new restaurants or venues that have not yet received the minimum threshold of customer reviews do not have an official Tabelog rating assigned yet. A null rating accurately reflects the absence of a public score on the site.

**Can I extract detailed menus, business hours, and phone numbers?**\
This actor extracts listing-level data across thousands of restaurants. Deep page details (such as operating hours, table counts, and telephone numbers) require visiting individual restaurant profile pages.

**What is the recommended memory allocation?**\
Because the scraper runs an anti-detect stealth browser, allocating 2,048 MB to 4,096 MB of memory ensures smooth browser execution without memory constraints.

***

### 🔗 Related Japan & hospitality actors

- [SUUMO Scraper](https://apify.com/haketa/suumo-scraper) — Japan's #1 real estate portal for rental apartments and properties.
- [Rakuten Scraper](https://apify.com/haketa/rakuten-scraper) — E-commerce product search, pricing, and reviews on Rakuten Ichiba.
- [Mercari Scraper](https://apify.com/haketa/mercari-scraper) — C2C marketplace listings, second-hand prices, and resale comps in Japan.

***

***

### 🗾 Comparison: Tabelog vs. Other Japan Dining Sources

| Attribute | Tabelog (食べログ) | Google Maps Japan | Hot Pepper Gourmet | Gurunavi |
|---|---|---|---|---|
| **Coverage** | 800,000+ venues nationwide | Comprehensive POIs | High chain/izakaya focus | Moderate dining coverage |
| **Rating Calibration** | Strict (3.5+ = Top 3%) | Inflated (mostly 4.0–4.5) | Sponsored/booking biased | Booking focused |
| **Bookmark Analytics** | Saves count (`savedCount`) | Star bookmarks (private) | Points collected | Coupons collected |
| **Transit Accuracy** | Exact meters to station | Geographic coordinate only | Station text description | Nearest exit text |
| **Cuisine Granularity** | Deep (e.g., Niboshi Ramen) | Generic (e.g., Ramen Restaurant) | General broad categories | Broad categories |
| **Scraping Accessibility** | Automated via this Actor | Heavy dynamic DOM restrictions | Limited listing depths | Pagination limits |

***

### 📈 Advanced Scraping & Workflow Automation

#### Scheduled Dining Intelligence

Automate recurring monitoring runs using Apify Schedule configurations:

- **Weekly Trend Monitoring**: Run `maxItems: 100` every Monday to capture rating shifts and new customer reviews across key dining hubs.
- **Monthly Expansion Discovery**: Set `startUrls` across emerging business districts (e.g., Toranomon, Nihonbashi) to discover newly opened restaurants right as they get indexed.

#### Enterprise Webhook Pipelines

Stream live results into PostgreSQL, BigQuery, or Snowflake through Apify Webhook events (`ACTOR.RUN.SUCCEEDED`). Pipe restaurant payloads directly into sales CRM platforms (HubSpot, Salesforce) or notification channels (Slack, Discord) whenever a restaurant with `rating >= 3.80` is detected.

***

**Can I combine multiple prefectures in one extraction job?**\
Yes. You can supply an arbitrary number of listing URLs inside `startUrls` (e.g., Tokyo ramen, Osaka okonomiyaki, Kyoto kaiseki). The actor will systematically process each target sequentially while enforcing global deduplication across the unified dataset.

**How does walking distance parsing handle complex Japanese station descriptions?**\
Tabelog displays station proximity with formats like "Shibuya Station 350m" or "Ginza Station Exit A2 120m". The scraper uses targeted regular expressions to isolate the numeric meter distance into `stationDistanceM` while preserving the full text description in `station`.

***

### 📋 Changelog

#### v1.2 (2026-11)

- **Unlocked Deep 1,000+ Pagination**: Removed restrictive 60-page caps, enabling comprehensive catalog scraping across thousands of listings governed by `maxItems`.
- **Fast Prefill Optimization**: Standardized prefill run volume (`20` items) for lightning-fast trial runs under 90 seconds.
- **Enhanced Schema Normalization**: Aligned input and output schemas with strict Apify specifications.
- **Optimized Anti-Detect Flow**: Upgraded session clearance routines and retry logic for continuous multi-page traversals.

#### v1.1 (2026-11)

- Added structured walking distance parsing in meters (`stationDistanceM`).
- Implemented aggressive media asset blocking to reduce proxy bandwidth consumption by 80%.

#### v1.0 (2026-10)

- Initial production release supporting multi-URL ingestion, rating extraction, and automated deduplication.

# Changelog

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

# Actor input Schema

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

Tabelog search/listing pages — e.g. https://tabelog.com/tokyo/rstLst/ramen/ (Tokyo ramen) or https://tabelog.com/tokyo/rstLst/ . Pick an area and cuisine on tabelog.com and paste the URL; the actor paginates each one.

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

Total unique restaurants to save across all URLs. 0 = no limit (20 per page).

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

How many result pages to paginate per listing URL (20 restaurants per page). 0 = unlimited (bounded by maxItems).

## `maxConcurrency` (type: `integer`):

How many listing URLs to process in parallel. Keep low — Cloudflare retries cost requests.

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

Tabelog is Cloudflare-protected. RESIDENTIAL proxy is REQUIRED — datacenter IPs are blocked. Keep the default (Apify Residential); the actor clears Cloudflare with an anti-detect browser + retry-rotation on fresh IPs. Japanese residential clears fastest.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://tabelog.com/tokyo/rstLst/ramen/"
    },
    {
      "url": "https://tabelog.com/osaka/rstLst/sushi/"
    }
  ],
  "maxItems": 20,
  "maxPages": 0,
  "maxConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

No description

## `datasetUi` (type: `string`):

No description

## `output` (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 = {
    "startUrls": [
        {
            "url": "https://tabelog.com/tokyo/rstLst/ramen/"
        }
    ],
    "maxItems": 20,
    "maxPages": 0,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/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 = {
    "startUrls": [{ "url": "https://tabelog.com/tokyo/rstLst/ramen/" }],
    "maxItems": 20,
    "maxPages": 0,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/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 '{
  "startUrls": [
    {
      "url": "https://tabelog.com/tokyo/rstLst/ramen/"
    }
  ],
  "maxItems": 20,
  "maxPages": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call haketa/tabelog-scraper --silent --output-dataset

```

## MCP server setup

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