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:

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

Direct URLs

Provide specific OpenTable restaurant URLs:

{
    "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

# 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}'

// 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 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

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
• Leads Finder Pro - B2B Leads with Emails [Apollo Alternative]
• Yellow Pages US Scraper — Business Leads & Reviews
• Yellow Pages Australia Scraper — Business Leads & Reviews
• Etsy Scraper Pro — Products, Prices, Reviews & Shop Data
• AllTrails Scraper — Hiking Trails, Reviews & GPS Data
• Shopify Store Scraper - Products, Reviews & Emails
• 🔧 USA Plumbers Scraper — Leads with Phone, Address & Website
• Yellow Pages CA Scraper — Canadian Business Leads
• California CSLB Contractor License 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.