# Tabelog Japan Restaurant Scraper (`muhammadafzal/tabelog-japan-restaurant-scraper`) Actor

Scrape public Tabelog Japan restaurant search and detail pages into normalized ratings, prices, address, phone, cuisine, hours, reservation, and map fields. MCP-ready at $0.01 per restaurant.

- **URL**: https://apify.com/muhammadafzal/tabelog-japan-restaurant-scraper.md
- **Developed by:** [Muhammad Afzal](https://apify.com/muhammadafzal) (community)
- **Categories:** Travel, MCP servers, AI
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 tabelog restaurant records

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Tabelog Japan Restaurant Scraper

Scrape public Tabelog Japan search, ranking, map, and restaurant-detail pages into normalized restaurant records. The actor is designed for Japan travel planning, hospitality research, food-market analysis, and AI agents that need consistent restaurant data rather than raw HTML. It supports Japanese, English, Chinese, and Korean Tabelog URL variants, follows search pagination, and can enrich search cards with public detail-page fields.

Use this actor only where you have the right to access and process the source data. Tabelog’s [Terms of Use](https://tabelog.com/help/rules/) and robots/access controls apply; do not use the actor to bypass challenges, republish protected content, copy reviews or photos at scale, or create an unauthorized competing directory.

### What it returns

| Field group | Included data |
|---|---|
| Identity | `restaurantId`, `name`, `nameJapanese`, canonical `url`, page language |
| Location | area, address, postal code, latitude, longitude |
| Contact | public phone and reservation-link signal |
| Food and price | cuisine, lunch/dinner budgets, structured-data price range |
| Popularity | Tabelog rating and public review count |
| Operations | opening hours and closed days when labeled on the page |
| Enrichment | bounded description, image URLs, features, parser warnings |

Each restaurant is one flat, schema-stable dataset item. Optional values are emitted as `null`, `[]`, or `false` rather than disappearing, which makes the output easier to validate in databases and MCP clients.

### Input

```json
{
  "startUrls": [
    { "url": "https://tabelog.com/tokyo/C13113/rstLst/ramen/" },
    { "url": "https://tabelog.com/en/tokyo/A1329/A132901/13225889/" }
  ],
  "maxResults": 25,
  "maxPages": 5,
  "enrichDetails": true,
  "responseFormat": "detailed"
}
````

- `startUrls`: Tabelog search/list or restaurant-detail URLs. Defaults to a Shibuya ramen search.
- `maxResults`: hard cap across all input URLs, from 1 to 1,000.
- `maxPages`: search pagination cap, from 1 to 100.
- `enrichDetails`: when true, opens each search result for more public fields; set false for faster cards.
- `responseFormat`: `concise` keeps core fields; `detailed` includes descriptions, images, and features.

Proxy and concurrency settings are kept internal so the default run is predictable for both people and AI agents. A challenge page is reported in `warnings`; the actor does not attempt to defeat access controls.

### Pricing

The actor charges `$0.01` for each schema-valid restaurant record stored, plus the small actor-start event. A 25-record run costs about `$0.25` in result events. Pay-Per-Usage platform compute and proxy charges, if enabled for the account, are separate. The actor prints its result-event cap before scraping and never charges for a malformed or skipped record.

### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('YOUR_USERNAME/tabelog-japan-restaurant-scraper').call({
  startUrls: [{ url: 'https://tabelog.com/tokyo/C13113/rstLst/ramen/' }],
  maxResults: 20,
  enrichDetails: true,
  responseFormat: 'concise',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY_APIFY_TOKEN')
run = client.actor('YOUR_USERNAME/tabelog-japan-restaurant-scraper').call(run_input={
    'startUrls': [{'url': 'https://tabelog.com/en/tokyo/A1329/A132901/13225889/'}],
    'maxResults': 1,
    'responseFormat': 'detailed',
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### MCP usage

Configure the actor through Apify’s hosted MCP server with:

```text
https://mcp.apify.com/?tools=YOUR_USERNAME/tabelog-japan-restaurant-scraper
```

Use it when an agent needs public restaurant search/detail data for Japan travel or market research. Do not use it for Google Maps, Yelp, private Tabelog pages, reservation transactions, or full review-text harvesting. The tool returns one restaurant object per result with stable keys including `name`, `url`, `address`, `cuisine`, `rating`, `reviewCount`, price fields, and optional enrichment.

### Reliability and limitations

The parser uses Tabelog’s public restaurant JSON-LD where available, then visible headings and labeled sections, with separate list-card selectors for search pages. It deduplicates restaurant IDs, follows `next` links up to `maxPages`, preserves partial results, and returns actionable warnings when a page is blocked or its structure no longer matches. Tabelog can vary fields by language, region, and restaurant; missing values are not guessed.

This actor does not log in, submit forms, make reservations, access private reviews, or bypass CAPTCHA, rate limits, or access-denied pages. Before production use, review Tabelog’s current terms, applicable Japanese privacy/copyright/database rules, and any authorization required for your use case.

### FAQ

#### Can I pass a direct restaurant URL?

Yes. A direct URL such as `https://tabelog.com/en/tokyo/A1329/A132901/13225889/` returns one enriched record.

#### Can I scrape a category or neighborhood search?

Yes. Pass the search URL copied from Tabelog. The actor follows pagination up to `maxPages` and stops at `maxResults`.

#### Why are some fields null?

Tabelog does not expose every field on every page or language variant. The actor keeps a stable shape and uses `warnings` for parser or access issues.

#### How do I reduce output size?

Set `responseFormat` to `concise` and `enrichDetails` to `false` when you only need search-card identity, location, rating, cuisine, and price signals.

# Actor input Schema

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

Use this when you have Tabelog Japan search, map, ranking, or restaurant-detail URLs. Enter a URL such as 'https://tabelog.com/tokyo/C13113/rstLst/ramen/'. Defaults to a Shibuya ramen search. This is not for Google Maps, Yelp, or private member pages.

## `maxResults` (type: `integer`):

Use this when you need a hard output and billing cap. Enter an integer such as 50. Defaults to 25 and accepts 1 through 1000. This limits restaurant records, not source requests or retries.

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

Use this when a Tabelog search should follow pagination. Enter an integer such as 3. Defaults to 5 and accepts 1 through 100 pages. This does not apply to direct restaurant-detail URLs.

## `enrichDetails` (type: `boolean`):

Use this when search results should open each restaurant page for address, phone, hours, pricing, coordinates, photos, and structured data. Defaults to true and makes one request per restaurant. Set false for a faster search-card export.

## `responseFormat` (type: `string`):

Use this when an AI agent needs smaller or richer records. Choose concise for identity, location, rating, and price fields or detailed for descriptions, photos, and features. Defaults to detailed. This does not return raw HTML.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://tabelog.com/en/tokyo/A1329/A132901/13225889/"
    }
  ],
  "maxResults": 50,
  "maxPages": 3,
  "enrichDetails": true,
  "responseFormat": "concise"
}
```

# Actor output Schema

## `restaurants` (type: `string`):

Schema-valid restaurant records from the default dataset.

## `summary` (type: `string`):

Counts, warnings, and billing totals stored under OUTPUT.

# 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/C13113/rstLst/ramen/"
        }
    ],
    "maxResults": 25,
    "maxPages": 5,
    "enrichDetails": true,
    "responseFormat": "detailed"
};

// Run the Actor and wait for it to finish
const run = await client.actor("muhammadafzal/tabelog-japan-restaurant-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/C13113/rstLst/ramen/" }],
    "maxResults": 25,
    "maxPages": 5,
    "enrichDetails": True,
    "responseFormat": "detailed",
}

# Run the Actor and wait for it to finish
run = client.actor("muhammadafzal/tabelog-japan-restaurant-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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/C13113/rstLst/ramen/"
    }
  ],
  "maxResults": 25,
  "maxPages": 5,
  "enrichDetails": true,
  "responseFormat": "detailed"
}' |
apify call muhammadafzal/tabelog-japan-restaurant-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=muhammadafzal/tabelog-japan-restaurant-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tabelog Japan Restaurant Scraper",
        "description": "Scrape public Tabelog Japan restaurant search and detail pages into normalized ratings, prices, address, phone, cuisine, hours, reservation, and map fields. MCP-ready at $0.01 per restaurant.",
        "version": "1.0",
        "x-build-id": "DOqV2nMahcrqkmmwU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/muhammadafzal~tabelog-japan-restaurant-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-muhammadafzal-tabelog-japan-restaurant-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/muhammadafzal~tabelog-japan-restaurant-scraper/runs": {
            "post": {
                "operationId": "runs-sync-muhammadafzal-tabelog-japan-restaurant-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/muhammadafzal~tabelog-japan-restaurant-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-muhammadafzal-tabelog-japan-restaurant-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "Tabelog URLs",
                        "type": "array",
                        "description": "Use this when you have Tabelog Japan search, map, ranking, or restaurant-detail URLs. Enter a URL such as 'https://tabelog.com/tokyo/C13113/rstLst/ramen/'. Defaults to a Shibuya ramen search. This is not for Google Maps, Yelp, or private member pages.",
                        "default": [
                            {
                                "url": "https://tabelog.com/tokyo/C13113/rstLst/ramen/"
                            }
                        ],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Maximum restaurants",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Use this when you need a hard output and billing cap. Enter an integer such as 50. Defaults to 25 and accepts 1 through 1000. This limits restaurant records, not source requests or retries.",
                        "default": 25
                    },
                    "maxPages": {
                        "title": "Maximum search pages",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Use this when a Tabelog search should follow pagination. Enter an integer such as 3. Defaults to 5 and accepts 1 through 100 pages. This does not apply to direct restaurant-detail URLs.",
                        "default": 5
                    },
                    "enrichDetails": {
                        "title": "Fetch restaurant details",
                        "type": "boolean",
                        "description": "Use this when search results should open each restaurant page for address, phone, hours, pricing, coordinates, photos, and structured data. Defaults to true and makes one request per restaurant. Set false for a faster search-card export.",
                        "default": true
                    },
                    "responseFormat": {
                        "title": "Response detail",
                        "enum": [
                            "concise",
                            "detailed"
                        ],
                        "type": "string",
                        "description": "Use this when an AI agent needs smaller or richer records. Choose concise for identity, location, rating, and price fields or detailed for descriptions, photos, and features. Defaults to detailed. This does not return raw HTML.",
                        "default": "detailed"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```