# OpenTable Reviews API | Restaurant Review Intelligence (`johnvc/opentable-reviews-api`) Actor

Scrape OpenTable restaurant reviews as structured JSON: review text, dined and submitted dates, the diner's profile, and the full rating breakdown (overall, food, service, ambience, value, noise). For hospitality analytics and restaurant competitive intelligence. Pay per review, MCP-ready.

- **URL**: https://apify.com/johnvc/opentable-reviews-api.md
- **Developed by:** [John](https://apify.com/johnvc) (community)
- **Categories:** Travel, AI, MCP servers
- **Stats:** 7 total users, 7 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.01 / 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.

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

## OpenTable Reviews API | Restaurant Review Intelligence

Scrape [OpenTable](https://www.opentable.com/) restaurant reviews as clean structured JSON. Give the API a restaurant and get its reviews, each with the full review text, the dates the diner visited and posted, the diner's public profile, and the complete rating breakdown: overall, food, service, ambience, value, and noise. It is review intelligence for hospitality analytics, restaurant competitive research, and food-media sentiment analysis.

If you need to book a table, use a booking Actor. If you need the review data for analytics, this is the one: it returns the same reviews your competitors are reading, as structured JSON for AI agents.

### What you get

One row per review:

- `content`: the full review text
- `rating`: the breakdown (overall, food, service, ambience, value, noise)
- `dined_at` and `submitted_at` timestamps
- `user`: the diner's name, review count, and location
- `review_id` and the `restaurant_id` it belongs to

Enable `includeRestaurantSummary` to also get one restaurant-level row with the aggregate ratings and total counts.

### Use cases

- Track sentiment and ratings for a restaurant or a chain over time
- Benchmark a restaurant against competitors on food, service, and ambience
- Mine reviews for menu, pricing, and experience feedback
- Power restaurant analytics dashboards and food-media research
- Feed an AI agent a restaurant's reviews to summarize themes and complaints

### Input

| Field | Type | Description |
|-------|------|-------------|
| `restaurantId` | string | A single restaurant, given as either the OpenTable URL slug (e.g. `r/central-park-boathouse-new-york-2`) or the full restaurant page URL (e.g. `https://www.opentable.com/r/central-park-boathouse-new-york-2`). The slug is detected and extracted automatically. Provide this, `restaurantIds`, or both. |
| `restaurantIds` | array of strings | A batch of restaurants to fetch in one run, each a slug or a full URL. Merged with `restaurantId` and de-duplicated. All restaurants are fetched in parallel. |
| `maxResultsPerRestaurant` | integer | Reviews per restaurant. Default 30, maximum 500. |
| `includeRestaurantSummary` | boolean | Also return a restaurant-summary row with aggregate ratings. Charged once per restaurant. Default off. |

To find a restaurant, open it on OpenTable and either copy the `r/...` slug from the URL or just paste the whole page URL - either works.

#### Example input

```json
{
  "restaurantId": "r/central-park-boathouse-new-york-2",
  "maxResultsPerRestaurant": 50,
  "includeRestaurantSummary": true
}
````

### Sample output

```json
{
  "result_type": "review",
  "restaurant_id": "r/central-park-boathouse-new-york-2",
  "position": 1,
  "review_id": "OT-1294132-168206-130084588143",
  "content": "Beautiful restaurant, lovely setting and great service ...",
  "dined_at": "2026-04-01T20:30:00Z",
  "submitted_at": "2026-04-02T17:43:04Z",
  "rating": { "overall": 5, "food": 4, "service": 5, "ambience": 5, "value": 4, "noise": "Moderate" },
  "user": { "name": "PAULINA", "number_of_reviews": 28, "location": "New York Area" }
}
```

### Pricing

Pay-per-result: a flat **$0.008 per review** returned. The optional restaurant summary is **$0.005** once per restaurant, only when you enable it. No setup fee, no per-run fee, no monthly minimum.

### How to get started

1. Open [OpenTable Reviews API on the Apify Store](https://apify.com/johnvc/opentable-reviews-api?fpr=9n7kx3).
2. Enter a `restaurantId` (or a `restaurantIds` list of OpenTable slugs).
3. Set `maxResultsPerRestaurant`, then run the Actor.
4. Export the dataset as JSON, CSV, or Excel, or pull it from the API.

Prefer code? See the [OpenTable Reviews API example repo](https://github.com/johnisanerd/Apify-OpenTable-Reviews-API) for a Python quick-start and MCP setup guides.

### Run from the API

```bash
curl -X POST "https://api.apify.com/v2/acts/johnvc~opentable-reviews-api/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"restaurantId":"r/central-park-boathouse-new-york-2","maxResultsPerRestaurant":30}'
```

### 🔌 Use this API from Claude (MCP)

This Actor is compatible with the Model Context Protocol (MCP), so AI agents can call it as a tool. Add it through the hosted Apify MCP server using this Actor-specific URL:

https://mcp.apify.com/?tools=actors,docs,johnvc/opentable-reviews-api

If you run agents from [Claude Code](https://claude.ai/referral/uIlpa7nPLg) (free trial) or [Claude Cowork](https://claude.ai/referral/uIlpa7nPLg) (free trial), add the Apify MCP server and ask it to "pull this restaurant's reviews and summarize the common complaints."

Setup walkthrough:

https://www.youtube.com/watch?v=jREWahDGhJM

Apify MCP integration docs: https://docs.apify.com/platform/integrations/mcp

#### MCP setup, step by step

Visual setup guides for each client (source and more assets: [ApifyPublicData on GitHub](https://github.com/johnisanerd/ApifyPublicData)):

**Claude Cowork Desktop**

![Install in Claude Cowork Desktop](https://raw.githubusercontent.com/johnisanerd/ApifyPublicData/main/assets/guides/install_mcp_into_claude_desktop.png)

**Claude Code**

![Install in Claude Code](https://raw.githubusercontent.com/johnisanerd/ApifyPublicData/main/assets/guides/install_mcp_into_claude_code.png)

**Claude (website)**

![Install in Claude website](https://raw.githubusercontent.com/johnisanerd/ApifyPublicData/main/assets/guides/install_mcp_into_claude_ai.png)

**Cursor**

![Install in Cursor](https://raw.githubusercontent.com/johnisanerd/ApifyPublicData/main/assets/guides/install_mcp_into_cursor.png)

**ChatGPT**

![Install in ChatGPT](https://raw.githubusercontent.com/johnisanerd/ApifyPublicData/main/assets/guides/install_mcp_into_ChatGPT.png)

### FAQ

**What is a restaurant ID?** It is the OpenTable URL slug, the `r/...` path for the restaurant. Open the restaurant on OpenTable and copy it from the URL. A full URL also works.

**How many reviews come back?** Up to `maxResultsPerRestaurant` (default 30). The Actor paginates a restaurant's reviews for you.

**Does it book tables?** No. This Actor is for review data and analytics. For reservations, use a dedicated OpenTable booking Actor.

**Can I research several restaurants at once?** Yes. Pass a `restaurantIds` list; each is fetched independently and tagged with its restaurant ID.

### Featured Tasks

Ready-to-run examples that show this API solving a specific problem. Each opens its own setup so you can run it on your account in one click.

- [Monitor OpenTable reviews for a list of restaurants](https://apify.com/johnvc/opentable-reviews-api/examples/monitor-opentable-reviews-for-a-list-of-restaurants?fpr=9n7kx3) - Watch a fixed list of restaurants and pull recent reviews for every venue in one run.
- [Monitor OpenTable reviews for San Francisco restaurants](https://apify.com/johnvc/opentable-reviews-api/examples/monitor-opentable-reviews-for-san-francisco-restaurants?fpr=9n7kx3) - Track a watchlist of San Francisco venues, with review text, dined date, diner profile, and the full rating breakdown.
- [Monitor OpenTable reviews for Los Angeles restaurants](https://apify.com/johnvc/opentable-reviews-api/examples/monitor-opentable-reviews-for-los-angeles-restaurants?fpr=9n7kx3) - Keep tabs on a list of Los Angeles restaurants and their latest reviews.
- [Monitor OpenTable reviews for Chicago restaurants](https://apify.com/johnvc/opentable-reviews-api/examples/monitor-opentable-reviews-for-chicago-restaurants?fpr=9n7kx3) - Monitor reviews across a set of Chicago restaurants in a single run.
- [Monitor OpenTable reviews for Houston restaurants](https://apify.com/johnvc/opentable-reviews-api/examples/monitor-opentable-reviews-for-houston-restaurants?fpr=9n7kx3) - Follow a watchlist of Houston restaurants and pull each venue's recent reviews.
- [Monitor OpenTable reviews for London restaurants](https://apify.com/johnvc/opentable-reviews-api/examples/monitor-opentable-reviews-for-london-restaurants?fpr=9n7kx3) - Track London restaurants and their reviews, with the full per-review rating breakdown.
- [Monitor OpenTable reviews for Dubai restaurants](https://apify.com/johnvc/opentable-reviews-api/examples/monitor-opentable-reviews-for-dubai-restaurants?fpr=9n7kx3) - Monitor a list of Dubai restaurants and pull recent reviews for each venue at once.

Last Updated: 2026.06.09

# Actor input Schema

## `restaurantId` (type: `string`):

Enter a single restaurant as either its OpenTable URL slug (for example 'r/central-park-boathouse-new-york-2') or the full restaurant page URL (for example 'https://www.opentable.com/r/central-park-boathouse-new-york-2'). The slug is detected and extracted automatically. Provide this, `restaurantIds`, or both.

## `restaurantIds` (type: `array`):

Provide a list of restaurants to fetch in one run, each as an OpenTable URL slug or a full restaurant page URL. Merged with `restaurantId` and de-duplicated. All restaurants are fetched in parallel.

## `maxResultsPerRestaurant` (type: `integer`):

How many reviews to return per restaurant. The Actor paginates as needed, then stops early when a restaurant runs out of reviews. Default 30, maximum 500.

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

If enabled, also return one restaurant-summary row per restaurant with the aggregate rating breakdown and total counts. Charged once per restaurant. Default off.

## Actor input object example

```json
{
  "restaurantId": "r/central-park-boathouse-new-york-2",
  "maxResultsPerRestaurant": 30,
  "includeRestaurantSummary": false
}
```

# Actor output Schema

## `results` (type: `string`):

All review rows stored in the default dataset, one item per review.

# 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 = {
    "restaurantId": "r/central-park-boathouse-new-york-2"
};

// Run the Actor and wait for it to finish
const run = await client.actor("johnvc/opentable-reviews-api").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 = { "restaurantId": "r/central-park-boathouse-new-york-2" }

# Run the Actor and wait for it to finish
run = client.actor("johnvc/opentable-reviews-api").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 '{
  "restaurantId": "r/central-park-boathouse-new-york-2"
}' |
apify call johnvc/opentable-reviews-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=johnvc/opentable-reviews-api",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OpenTable Reviews API | Restaurant Review Intelligence",
        "description": "Scrape OpenTable restaurant reviews as structured JSON: review text, dined and submitted dates, the diner's profile, and the full rating breakdown (overall, food, service, ambience, value, noise). For hospitality analytics and restaurant competitive intelligence. Pay per review, MCP-ready.",
        "version": "0.0",
        "x-build-id": "FqPVAlF8Ac7aDcNUu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/johnvc~opentable-reviews-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-johnvc-opentable-reviews-api",
                "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/johnvc~opentable-reviews-api/runs": {
            "post": {
                "operationId": "runs-sync-johnvc-opentable-reviews-api",
                "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/johnvc~opentable-reviews-api/run-sync": {
            "post": {
                "operationId": "run-sync-johnvc-opentable-reviews-api",
                "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": {
                    "restaurantId": {
                        "title": "Restaurant ID",
                        "type": "string",
                        "description": "Enter a single restaurant as either its OpenTable URL slug (for example 'r/central-park-boathouse-new-york-2') or the full restaurant page URL (for example 'https://www.opentable.com/r/central-park-boathouse-new-york-2'). The slug is detected and extracted automatically. Provide this, `restaurantIds`, or both."
                    },
                    "restaurantIds": {
                        "title": "Restaurant IDs",
                        "type": "array",
                        "description": "Provide a list of restaurants to fetch in one run, each as an OpenTable URL slug or a full restaurant page URL. Merged with `restaurantId` and de-duplicated. All restaurants are fetched in parallel.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerRestaurant": {
                        "title": "Maximum Reviews Per Restaurant",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "How many reviews to return per restaurant. The Actor paginates as needed, then stops early when a restaurant runs out of reviews. Default 30, maximum 500.",
                        "default": 30
                    },
                    "includeRestaurantSummary": {
                        "title": "Include Restaurant Summary",
                        "type": "boolean",
                        "description": "If enabled, also return one restaurant-summary row per restaurant with the aggregate rating breakdown and total counts. Charged once per restaurant. Default off.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
