# OpenTable Scraper — Restaurants & Reviews (`muhammadafzal/opentable-scraper`) Actor

Scrape OpenTable restaurant listings, cuisines, prices, availability, ratings, reviews, locations, and booking details into structured data.

- **URL**: https://apify.com/muhammadafzal/opentable-scraper.md
- **Developed by:** [Muhammad Afzal](https://apify.com/muhammadafzal) (community)
- **Categories:** Travel, Lead generation, Automation
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 restaurant scrapeds

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Scraper — Restaurants & Reviews

Scrape OpenTable restaurants in any city. Export profiles, ratings, reviews, menus, cuisine, price, hours, and coordinates as structured JSON, CSV, or Excel. MCP-ready for AI agents.

### Features

- **Search by city, cuisine, neighborhood, or restaurant name** — paginate through all OpenTable search results
- **Scrape by direct URL** — paste any OpenTable restaurant profile URL
- **Full restaurant profiles** — name, description, overall rating, review counts, cuisines, price tier, address, coordinates, neighborhood, metro, phone, website, hours, dining style, dress code, parking, executive chef, features (bar, counter, outdoor, high-top, max party size), private dining, takeout, delivery, payment options, gallery photos
- **Optional reviews extraction** — collect individual reviews with full text, diner profiles (name, initials, location, VIP status, review count), dined/submitted dates, and helpfulness votes
- **Browser-based anti-bot bypass** — uses Playwright with Chromium + response interception to capture OpenTable's API responses with correct TLS fingerprints, defeating Akamai protection
- **MCP-ready** — optimized for Claude, ChatGPT, Cursor, and other AI agents with semantic field names and structured output

### Use Cases

- Competitive analysis and benchmarking of nearby restaurants (ratings, amenities, price band)
- Market-entry research and city-level restaurant coverage studies
- Restaurant scoring, ranking, and neighborhood food-density analysis
- Review monitoring and sentiment analysis
- Sourcing acquisition or M\&A targets using reservation counts and review velocity
- Enriching travel apps, directories, and restaurant profile databases with geocoordinates
- Building city guides, affiliate booking pages, and editorial "best of" lists
- Generating prospect lists and CRM enrichment for sales outreach
- Training recommendation models and AI prototypes on real restaurant attributes

### Input

The actor supports two input modes (can be combined):

#### Search Terms

Provide city names, neighborhoods, cuisines, or restaurant names:

```json
{
    "searchTerms": ["New York", "Italian Chicago", "sushi San Francisco"],
    "maxResults": 500,
    "includeReviews": false
}
```

#### Direct URLs

Provide specific OpenTable restaurant URLs:

```json
{
    "startUrls": [
        { "url": "https://www.opentable.com/r/le-bernardin-new-york" },
        { "url": "https://www.opentable.com/restaurant/profile/100" }
    ],
    "includeReviews": true,
    "maxReviewsPerRestaurant": 50
}
```

#### All Input Fields

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `searchTerms` | array | `["New York"]` | City, neighborhood, cuisine, or restaurant names to search |
| `startUrls` | array | `[]` | Direct OpenTable restaurant URLs |
| `maxResults` | integer | `100` | Max restaurant records to return |
| `priceBands` | array | `[]` | Filter by price tier (1-4) |
| `sortBy` | string | `web_conversion` | Sort order: `web_conversion` (featured) or `distance` |
| `includeReviews` | boolean | `false` | Also scrape individual reviews |
| `maxReviewsPerRestaurant` | integer | `50` | Max reviews per restaurant |
| `proxyConfiguration` | object | Apify Proxy | Proxy routing (residential recommended) |

### Output

Each record contains:

| Field | Type | Description |
|-------|------|-------------|
| `name` | string | Restaurant name |
| `url` | string | OpenTable profile URL |
| `restaurantId` | number | OpenTable internal ID |
| `description` | string | Restaurant description |
| `rating` | number | Overall rating (1-5) |
| `reviewCount` | number | Recent review count |
| `totalReviewCount` | number | Total reviews |
| `primaryCuisine` | string | Primary cuisine |
| `cuisines` | string\[] | All cuisine tags |
| `priceTier` | number | Price band (1-4) |
| `priceRange` | string | Price label |
| `address` | object | Full postal address |
| `latitude` | number | Geocode |
| `longitude` | number | Geocode |
| `neighborhood` | string | Neighborhood |
| `metro` | string | Metro area |
| `phoneNumber` | string | Contact phone |
| `website` | string | Restaurant website |
| `hoursOfOperation` | string | Hours text |
| `diningStyle` | string | Dining style |
| `dressCode` | string | Dress code |
| `parkingInfo` | string | Parking details |
| `executiveChef` | string | Chef name |
| `imageUrl` | string | Cover photo URL |
| `features` | object | Bar, counter, outdoor, highTop, maxPartySize |
| `hasPrivateDining` | boolean | Private dining available |
| `hasTakeout` | boolean | Takeout available |
| `paymentOptions` | string\[] | Accepted payments |
| `photoUrls` | string\[] | Gallery photos |
| `reviews` | array | Individual reviews (if enabled) |
| `scrapedAt` | string | ISO timestamp |
| `sourceUrl` | string | Source URL |

#### Review Object (when `includeReviews` is true)

| Field | Type | Description |
|-------|------|-------------|
| `reviewId` | string | Unique review ID |
| `text` | string | Full review text |
| `dinedDate` | string | Dine-in date (ISO) |
| `submittedDate` | string | Submission date (ISO) |
| `ratingOverall` | number | Overall rating |
| `reviewerName` | string | Diner nickname |
| `reviewerInitials` | string | Diner initials |
| `reviewerLocation` | string | Diner city |
| `reviewerIsVip` | boolean | VIP status |
| `reviewerApprovedReviewCount` | number | Diner's total reviews |
| `reviewHelpfulUp` | number | Helpful up-votes |
| `reviewHelpfulDown` | number | Helpful down-votes |

### Pricing

This actor uses **Pay-Per-Event** pricing:

| Event | Price | Description |
|-------|-------|-------------|
| Restaurant scraped | **$0.005** | Per restaurant record returned |
| Review scraped | **$0.001** | Per review returned (only when `includeReviews` is enabled) |
| Actor start | **$0.00005** | Per run start (memory-based) |

**Example costs:**

- 100 restaurants, no reviews: ~$0.50
- 100 restaurants with 50 reviews each (5,000 reviews): ~$5.50 ($0.50 + $5.00)
- 1,000 restaurants, no reviews: ~$5.00

### How It Works

The actor uses a **3-layer extraction strategy** to maximize reliability against OpenTable's Akamai protection:

1. **Response interception** (primary) — Playwright's `page.on('response')` captures OpenTable's own API JSON responses with correct TLS fingerprints and auth headers
2. **Embedded JSON extraction** (fallback) — parses `window.__NEXT_DATA__` and `<script type="application/json">` SSR hydration data
3. **DOM parsing** (last resort) — multi-selector fallback extraction from rendered HTML

### Technical Details

- **Crawler**: PlaywrightCrawler with Chromium launcher
- **Anti-bot**: Browser-based with response interception, randomized viewports, random delays, session pooling
- **Proxy**: Apify Proxy (datacenter default, residential recommended for blocked regions)
- **Language**: TypeScript
- **Output**: Structured JSON dataset (exportable as CSV, Excel, JSON, XML via Apify Console)

### Export Scraped Data

Export scraped data, run the scraper via API, schedule and monitor runs, or integrate with other tools via the Apify platform. Results can be downloaded as JSON, CSV, Excel, or XML from the Apify Console.

### API Usage

```bash
## Run via API
curl -X POST "https://api.apify.com/v2/acts/USERNAME~opentable-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchTerms": ["New York"], "maxResults": 100}'
```

```javascript
// Run via JavaScript SDK
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('USERNAME/opentable-scraper').call({
    searchTerms: ['New York'],
    maxResults: 100
});
const dataset = await client.dataset(run.defaultDatasetId);
const items = await dataset.listItems();
```

### Limitations

- OpenTable uses Akamai protection — residential proxies may be required for some regions
- Free users are limited to 10 results per run
- Review extraction adds significant time per restaurant
- Some fields may be null if OpenTable doesn't provide them for a given restaurant

### Support

If you encounter issues, please report them on the [Issues tab](https://apify.com/USERNAME/opentable-scraper/issues) in the Apify Console.

### What is OpenTable Scraper?

**OpenTable Scraper** turns the target data into structured, reusable results on Apify. Use it when you need repeatable collection for analysts, developers, agencies, researchers, and AI-agent workflows without maintaining a custom scraper or one-off integration. Run it manually, schedule recurring jobs, call it through the Apify API, or connect it to an AI agent through the Apify MCP server.

The Actor stores results in an Apify dataset, where they can be previewed and exported as JSON, CSV, Excel, XML, or RSS. Availability and completeness depend on the source, supplied inputs, public visibility, authentication requirements, and upstream rate limits.

### Use cases for OpenTable Scraper

- Build structured datasets for research, reporting, enrichment, or monitoring.
- Automate repetitive collection with schedules, webhooks, and API calls.
- Feed clean records into spreadsheets, databases, CRMs, BI tools, AI agents, or RAG pipelines.
- Track changes over time by running the same validated input on a schedule.
- Replace fragile manual copy-and-paste work with a reproducible Apify workflow.

### How to use OpenTable Scraper

1. Open the Actor input page and choose a focused, valid target.
2. Set a conservative result limit for the first run.
3. Start the Actor and inspect the dataset for coverage and field availability.
4. Export the results or connect the dataset to your downstream system.
5. Scale gradually and use scheduling, pagination, or proxies when supported.

#### Important input options

- `searchTerms` — Use this field when the user provides a city, neighborhood, cuisine, or restaurant name to search on OpenTable. Each entry is paginated separately. Examples: 'New York', 'Italian Chicago', '
- `startUrls` — Use this field when the user provides specific OpenTable restaurant URLs to scrape directly (e.g. https://www.opentable.com/r/le-bernardin-new-york or https://www.opentable.com/restaurant/pr
- `maxResults` — Maximum number of restaurant records to return. The scraper stops early when this limit is reached. Default 100. Free users are limited to 10. Paid users can set up to 1,000,000.
- `priceBands` — Restrict results to specific price tiers. Leave empty for all price bands. $ = Under $30, $$ = $31-50, $$$ = $50-75, $$$$ = $75+. Map to OpenTable price band IDs 1-4.
- `sortBy` — How OpenTable orders search results. 'web\_conversion' = featured/popular first (default). 'distance' = nearest first.
- `includeReviews` — If enabled, also scrape individual reviews (review text, multi-axis ratings, diner profile, dined/submitted dates) for each restaurant. Slows the run. Charged per review at $0.001/review.
- `maxReviewsPerRestaurant` — Maximum number of reviews to collect per restaurant when includeReviews is enabled. Default 50. Set higher for full review history.
- `proxyConfiguration` — Connection routing for the run. The default (Apify Proxy) works best for reaching OpenTable reliably. OpenTable uses Akamai protection — residential proxies provide the highest success rate.

### API and automation example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('muhammadafzal/opentable-scraper').call({
  // Add the same input fields you use in the Apify Console.
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Related Apify Actors

Use these dedicated tools when a neighboring data source or workflow is a better match:

- [Instagram Followers & Following Scraper — With Cookies](https://apify.com/muhammadafzal/instagram-following-scraper)
- [Leads Finder Pro - B2B Leads with Emails \[Apollo Alternative\]](https://apify.com/muhammadafzal/leads-finder-pro)
- [Yellow Pages US Scraper — Business Leads & Reviews](https://apify.com/muhammadafzal/yellow-pages-us-scraper)
- [Yellow Pages Australia Scraper — Business Leads & Reviews](https://apify.com/muhammadafzal/yellow-pages-au-scraper)
- [Etsy Scraper Pro — Products, Prices, Reviews & Shop Data](https://apify.com/muhammadafzal/etsy-scraper-pro)
- [AllTrails Scraper — Hiking Trails, Reviews & GPS Data](https://apify.com/muhammadafzal/alltrails-scraper)
- [Shopify Store Scraper - Products, Reviews & Emails](https://apify.com/muhammadafzal/shopify-store-scraper)
- [🔧 USA Plumbers Scraper — Leads with Phone, Address & Website](https://apify.com/muhammadafzal/usa-plumbers-scraper)
- [Yellow Pages CA Scraper — Canadian Business Leads](https://apify.com/muhammadafzal/yellow-pages-ca-scraper)
- [California CSLB Contractor License Scraper](https://apify.com/muhammadafzal/cslb-california-scraper)

### Frequently asked questions

#### How many results can I scrape with OpenTable Scraper?

The practical total depends on the source, input limits, pagination, available records, run timeout, and upstream restrictions. Start with a small run, verify the output, and increase the limit gradually.

#### Can I integrate OpenTable Scraper with other apps?

Yes. Use Apify integrations, webhooks, schedules, dataset exports, Make, Zapier, Google Sheets, cloud storage, or your own application.

#### Can I use OpenTable Scraper with the Apify API?

Yes. Start runs with the Apify REST API or an official Apify client, then retrieve records from the run's default dataset. Keep your API token in a secret or environment variable.

#### Can I use OpenTable Scraper through an MCP Server?

Yes. The Apify MCP server can expose the Actor to compatible AI clients and agents. Review the input and expected cost before allowing an autonomous workflow to run it at scale.

#### Do I need proxies?

It depends on the source and volume. Use the default configuration first. For larger or geographically sensitive jobs, select an appropriate proxy configuration only when the Actor supports it.

#### Is it legal to scrape this data?

Scraping rules vary by source, jurisdiction, data type, and intended use. Collect only data you are authorized to access, respect applicable terms and privacy laws, and avoid restricted or personal data misuse. This documentation is not legal advice.

#### Your feedback

If a field is missing, a source layout has changed, or you need a supported use case documented, open an issue on the Actor page with a reproducible input and run ID.

# Actor input Schema

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

Use this field when the user provides a city, neighborhood, cuisine, or restaurant name to search on OpenTable. Each entry is paginated separately. Examples: 'New York', 'Italian Chicago', 'sushi San Francisco'. Use startUrls instead when the user provides direct OpenTable restaurant URLs.

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

Use this field when the user provides specific OpenTable restaurant URLs to scrape directly (e.g. https://www.opentable.com/r/le-bernardin-new-york or https://www.opentable.com/restaurant/profile/100). Do NOT use this when the user describes a city or cuisine — use searchTerms for that.

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

Maximum number of restaurant records to return. The scraper stops early when this limit is reached. Default 100. Free users are limited to 10. Paid users can set up to 1,000,000.

## `priceBands` (type: `array`):

Restrict results to specific price tiers. Leave empty for all price bands. $ = Under $30, $$ = $31-50, $$$ = $50-75, $$$$ = $75+. Map to OpenTable price band IDs 1-4.

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

How OpenTable orders search results. 'web\_conversion' = featured/popular first (default). 'distance' = nearest first.

## `includeReviews` (type: `boolean`):

If enabled, also scrape individual reviews (review text, multi-axis ratings, diner profile, dined/submitted dates) for each restaurant. Slows the run. Charged per review at $0.001/review.

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

Maximum number of reviews to collect per restaurant when includeReviews is enabled. Default 50. Set higher for full review history.

## `proxyMode` (type: `string`):

Use Residential when OpenTable blocks restaurant profile pages or when you need the most complete profile data. Residential Proxy access must be enabled on your Apify account and is charged by traffic. Automatic keeps the account's default available Apify Proxy routing.

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

Connection routing for the run. The default (Apify Proxy) works best for reaching OpenTable reliably. OpenTable uses Akamai protection — residential proxies provide the highest success rate. Only change if your environment requires a custom proxy.

## Actor input object example

```json
{
  "searchTerms": [
    "New York"
  ],
  "startUrls": [],
  "maxResults": 100,
  "priceBands": [],
  "sortBy": "web_conversion",
  "includeReviews": false,
  "maxReviewsPerRestaurant": 50,
  "proxyMode": "auto",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All restaurant records extracted from OpenTable. Click to view the full dataset as JSON.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchTerms": [
        "New York"
    ],
    "startUrls": [],
    "maxResults": 100,
    "includeReviews": false,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("muhammadafzal/opentable-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchTerms": ["New York"],
    "startUrls": [],
    "maxResults": 100,
    "includeReviews": False,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("muhammadafzal/opentable-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 '{
  "searchTerms": [
    "New York"
  ],
  "startUrls": [],
  "maxResults": 100,
  "includeReviews": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call muhammadafzal/opentable-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/DYT8mwLT2XLTH1cIC/builds/aDh7xdWwabcZkrpkl/openapi.json