# OpenTable Scraper - Restaurants, Phones, Reviews & Tables (`scrapersdelight/opentable-scraper`) Actor

Scrape OpenTable restaurants by city, keyword, coordinates or URL: name, cuisine, price band, address, coordinates, phone, rating, reviews, bookings today. Add bookable times, profile details (website, hours, menus, chef), diner reviews and website emails. Deep search past the ~1,000 cap.

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

## Pricing

from $0.18 / 1,000 restaurants

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

### What does OpenTable Scraper do?

**OpenTable Scraper** exports restaurants from [OpenTable](https://www.opentable.com) - the reservation network most sit-down restaurants in the US, UK, Canada, Ireland, Germany, Mexico, Japan and Australia list on. Give it a city, a neighbourhood, coordinates, a cuisine keyword or OpenTable URLs, and each row is one restaurant: name, cuisine, price band, full address, coordinates, phone, rating, review count and how many times it was booked today. Restaurant suppliers, delivery and POS sales teams, hospitality analysts and local-marketing agencies use it to build restaurant lead lists and market maps.

- 🍽️ **Every restaurant OpenTable lists for a place** - and with **Deep search**, past OpenTable's ~1,000-per-search cap (New York: 990 → 2,311; London: 999 → 2,796).
- 📞 **Contact data in every row** - phone on 99% of restaurants, street address and coordinates on 100%.
- 📅 **Bookable times** for a date, time and party size (OpenTable's own availability, 50 restaurants per call).
- 🧾 **Restaurant details** - website, opening hours, all cuisines, chef, dress code, parking, payment options, food / service / ambience / value ratings, noise, popular dishes, private dining, and full **menus** with prices.
- ⭐ **Diner reviews** - text, five ratings, noise, dates, diner, VIP, helpful votes and the restaurant's reply; newest, highest, lowest or OpenTable's recommended order; filter by date, rating, VIP or a word ("birthday").
- 📧 **Emails** from each restaurant's own website (found for 50% of restaurants in our test runs).
- 🌍 **Any OpenTable market** - opentable.com, .co.uk, .ca, .ie, .de, .com.au, .com.mx, .jp and more, picked from the place you type.
- 🔓 **No login, no cookies, no API key**, no browser - fast and cheap.

### What data can you get from OpenTable?

| | | |
|---|---|---|
| 🏷️ Name, `restaurantId`, OpenTable URL | 🍝 Cuisine, all `cuisines` | 💲 `priceBand` ($$-$$$$), `priceRange` |
| 📍 `address`, `city`, `state`, `postalCode` | 🗺️ `latitude`, `longitude`, `neighborhood` | 📞 `phone`, `phoneFormatted` |
| ⭐ `rating`, `reviewCount` | 🔥 `recentReservationCount` (booked today) | 🍷 `diningStyle`, `dressCode` |
| 🌐 `website`, 📧 `email`, `facebookUrl` | 🕒 `hours` | 👨‍🍳 `executiveChef` |
| 🥗 `ratingFood`, `ratingService`, `ratingAmbience`, `ratingValue`, `noiseLevel` | 📋 `menus` (sections, dishes, prices) | 🍲 `popularDishes` |
| 📅 `isAvailable`, `availableTimes` | 🥂 `hasPrivateDining`, `privateDiningCapacity` | 🛵 `hasTakeout`, `deliveryPartners`, `orderOnlineLink` |
| 🪑 `hasBar`, `hasOutdoor`, `hasHighTop`, `hasCounter` | 🏅 `awards` (e.g. MICHELIN) | 💬 `reviews` / review rows |

### How to scrape OpenTable with OpenTable Scraper

1. [Create a free Apify account](https://console.apify.com/sign-up) (it comes with free monthly credit).
2. Open **OpenTable Scraper** and type one or more places, e.g. `Chicago, IL` or `London`.
3. Optional: add a cuisine or keyword, filters, Bookable times, Restaurant details, Reviews or Find emails.
4. Click **Start**.
5. Download the restaurants as JSON, CSV, Excel or HTML, or read them through the API.

### ⬇️ Input

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` (restaurants by place), `restaurants` (the URLs / ids / names you list), `reviews` (one row per review). |
| `locations` | array | - | Places as you would type them on OpenTable: `"Chicago, IL"`, `"London"`, `"SoHo, New York"`, `"Paris, France"`. |
| `searchTerms` | array | - | Cuisine or keyword: `"sushi"`, `"steakhouse"`, `"brunch"`. Empty = every restaurant. |
| `latitude`, `longitude` | number | - | Search around exact coordinates. |
| `startUrls` | array | - | OpenTable restaurant pages (`/r/…`, `/<name>`, `/restaurant/profile/<id>`) or search pages (`/s?…`) from any OpenTable site. |
| `restaurantIds` | array | - | OpenTable restaurant ids, e.g. `"108541"`. |
| `restaurantNames` | array | - | `"Name, City"`, e.g. `"Nobu Fifty Seven, New York"`. A name OpenTable does not match is reported, never guessed. |
| `maxResults` | integer | `100` | Most rows the run delivers. |
| `maxResultsPerSearch` | integer | `0` | Cap per place × keyword (0 = none). |
| `deepSearch` | boolean | `false` | Search the area in map tiles to get past OpenTable's ~1,000 per search. |
| `sortBy` | string | `best` | `best`, `rating`, `distance`, `newest`. |
| `priceBands` | array | - | `2` = $$ ($30 and under), `3` = $$$ ($31-$50), `4` = $$$$ ($50 and over). |
| `awardTags`, `tableCategories`, `occasions`, `onlyJustAdded` | | - | OpenTable's own filters: awards (`MICHELIN`), seating (`bar`, `counter`, `highTop`, `outdoor`), occasions (`ROMANTIC`, `BRUNCH`), new restaurants. |
| `searchRadiusMiles` | integer | `0` | OpenTable's search radius (also the area Deep search covers). |
| `onlyBookable` | boolean | `false` | Only restaurants with tables around the date / time / party size below. |
| `cuisines`, `minRating`, `minReviews`, `withPhoneOnly`, `wheelchairAccessible` | | - | Refine filters, applied before anything is charged. |
| `includeAvailability` | boolean | `false` | Bookable times around `date` (or `daysAhead`, default tomorrow), `time` (default `19:00`), `partySize` (default 2), plus `availabilityDays` more days. |
| `includeDetails` | boolean | `false` | Read each restaurant's OpenTable profile (website, hours, chef, ratings…). |
| `includeMenus` | boolean | `false` | Add OpenTable-hosted menus (turns on details). |
| `includeReviews` | boolean | `false` | Add reviews; `maxReviewsPerRestaurant` (20), `reviewsSort`, `reviewsSince`, `reviewsMinRating`, `reviewsVipOnly`, `reviewsKeyword`. |
| `includeEmails` | boolean | `false` | Emails from each restaurant's own website (turns on details); `verifyEmailDomain` checks the domain takes mail. |
| `domain` | string | `auto` | OpenTable country site; auto picks it from the place. |
| `proxyConfiguration` | object | - | Optional. The actor uses Apify's own connection and switches to Apify RESIDENTIAL by itself when OpenTable refuses it. |

#### Input JSON

```json
{
  "locations": ["Chicago, IL", "London"],
  "searchTerms": ["steakhouse"],
  "priceBands": ["3", "4"],
  "maxResults": 200,
  "includeDetails": true,
  "includeReviews": true,
  "maxReviewsPerRestaurant": 10
}
```

#### Places, keywords and OpenTable's 1,000-restaurant window

OpenTable answers a search with the restaurants nearest the place's centre - about 750 to 1,000 of them. Type the place the way OpenTable's own search box knows it; the run log and `RUN_SUMMARY` show what each place was read as (`Chicago, IL` → Chicago, `London` → London, United Kingdom, `New York` → New York City). For a whole metro, switch on **Deep search**: the area is cut into map tiles, each searched on its own, and every restaurant is delivered once.

#### Restaurants and reviews you already know

`mode: restaurants` takes OpenTable URLs, ids or `"Name, City"` and returns each restaurant from its profile page (details included). `mode: reviews` returns one row per review for the restaurants you list - or for every restaurant a search finds.

### ⬆️ Output

A restaurant from a real run (Austin, TX, 100 restaurants):

```json
{
  "restaurantId": "1280941",
  "name": "Aba - Austin",
  "url": "https://www.opentable.com/r/aba-austin",
  "cuisine": "Mediterranean",
  "priceBand": "$$$$",
  "priceRange": "$50 and over",
  "neighborhood": "South Congress",
  "address": "1011 S Congress Ave",
  "city": "Austin",
  "state": "TX",
  "postalCode": "78704-1779",
  "latitude": 30.2534769,
  "longitude": -97.7478877,
  "phoneFormatted": "(737) 273-0199",
  "rating": 4.8,
  "reviewCount": 2165,
  "recentReservationCount": 188,
  "diningStyle": "Casual Dining",
  "hasPrivateDining": true,
  "maxPartySize": 8,
  "searchTotalResults": 378
}
```

With **Restaurant details** (Denver, CO):

```json
{
  "name": "Champagne Tiger",
  "website": "https://www.champagnetiger.com/",
  "hours": "Brunch\nFri–Sun 10:00 am–3:30 pm\nDinner\nWed, Thu 4:30 pm–9:00 pm",
  "cuisines": ["French", "American"],
  "executiveChef": "Chef Josh Hood",
  "dressCode": "Casual Dress",
  "parking": "Private Lot",
  "paymentOptions": ["AMEX", "Discover", "Mastercard", "Visa"],
  "ratingFood": 4.8, "ratingService": 4.8, "ratingAmbience": 4.8, "ratingValue": 4.7,
  "noiseLevel": 2,
  "reviewTags": ["Lively", "Great for brunch", "Good for groups"]
}
```

A review row (`mode: reviews`, lowest rated first):

```json
{
  "reviewId": "OT-1017331-256954-150259237775",
  "restaurantName": "Brooklyn Chop House - Downtown",
  "rating": 1, "ratingFood": 2, "ratingService": 1, "ratingAmbience": 2, "ratingValue": 2,
  "dinedAt": "2026-07-09T12:00:00-04:00",
  "reviewerName": "John",
  "reviewerMetro": "New York City",
  "text": "We were 3 and the only table new guests seated at 12:39.  Main course came out at 1:20.  Never coming back!"
}
```

#### Fields and how often they are filled

Measured on 5,107 restaurants (New York + London, deep search) for search fields, 90 restaurants (Denver + Austin) for details, 60 for emails, 200 reviews:

| Field | Filled | Field | Filled |
|---|---|---|---|
| name, URL, cuisine, price band, neighbourhood, address, city, postal code, coordinates, review count | 100% | website, hours, cuisines, dress code, parking, category ratings, noise | 100% |
| phone | 99% | amenities | 98% |
| rating | 96% | payment options | 88% |
| booked today (`recentReservationCount`) | 83% (99% in Austin) | cross street | 82% |
| `state` | 82% (UK addresses often have none) | executive chef | 70% |
| featured review excerpt | 92% | popular dishes | 54% |
| online-ordering link | 18% | Facebook page | 44% |
| delivery partners | 9% | menus | 26% |
| awards | 2% (all restaurants), 100% with the MICHELIN filter | email (website or profile) | 50% with Find emails |

Reviews: text, ratings, dates and diner on 100% of reviews; restaurant replies on 15%; VIP flag on 35%.

### Use cases

- 🚚 **Food & beverage suppliers** - a list of every upscale Italian restaurant in a metro with phone, address and chef.
- 💳 **POS, payments and reservation-software sales** - restaurants with their booking volume (`recentReservationCount`) to prioritise outreach.
- 📈 **Hospitality market research** - cuisine and price-band mix, ratings and availability by neighbourhood.
- 🏙️ **Local marketing agencies** - prospect lists with website, email and Facebook page.
- 📝 **Reputation monitoring** - new and low-rated reviews per restaurant, on a schedule.
- 🍷 **Wine & spirits distributors** - private-dining venues with capacity and contact details.

### How much does it cost to scrape OpenTable?

Pay per result, no start fee:

| Event | Price | When |
|---|---|---|
| Restaurant | $0.00018 per restaurant ($0.18 per 1,000) | every restaurant row |
| Bookable times | $0.00027 per restaurant | each restaurant OpenTable answered availability for (Bookable times on) |
| Restaurant details | $0.00045 per restaurant | each restaurant whose profile page was read (details, menus, emails, wheelchair filter or restaurants mode) |
| Review | $0.00045 per review | each review delivered |
| Email found | $0.045 per restaurant | each restaurant delivered with at least one email (Find emails on) |

| Run | Cost |
|---|---|
| 20 restaurants (the prefilled demo) | $0.0036 |
| 100 restaurants | $0.018 |
| 1,000 restaurants | $0.18 |
| 100 restaurants with details | $0.063 |
| 100 restaurants with 20 reviews each | $0.918 |

A search that finds nothing costs nothing, and a restaurant found by two of your searches is delivered and charged once.

### Integrations, API, scheduling & MCP

- **Schedule** a run (daily new restaurants in a city, weekly low-rated reviews) and get the results by **webhook**, email, Slack or Google Sheets.
- Connect **Make, Zapier or n8n** with the Apify integration.
- Call it from code with the [Apify API](https://apify.com/scrapersdelight/opentable-scraper/api) - `apify-client` for [Python](https://docs.apify.com/api/client/python) and [JavaScript](https://docs.apify.com/api/client/js).
- AI agents can run it through the [Apify MCP server](https://mcp.apify.com/).

### More restaurant scrapers

- [Tripadvisor Scraper](https://apify.com/scrapersdelight/tripadvisor-scraper) - restaurants, hotels and attractions with reviews.
- [Restaurantji Scraper](https://apify.com/scrapersdelight/restaurantji-scraper) - restaurant leads with phones and cuisine.
- [MenuPix Restaurant Scraper](https://apify.com/scrapersdelight/menupix-restaurant-scraper) - restaurants with phone, website and address.
- [New Liquor License Monitor](https://apify.com/scrapersdelight/liquor-license-monitor) - restaurants and bars about to open.
- [UK Food Business Leads (FHRS)](https://apify.com/scrapersdelight/fhrs-food-hygiene-scraper) - every UK food business with its hygiene rating.
- More on [our profile](https://apify.com/scrapersdelight).

### Limits & empty runs

- **~750-1,000 restaurants per search** is OpenTable's own window; use Deep search, more places or keywords for more.
- **Bookable times depend on OpenTable answering its availability call.** It limits that call per connection: in our tests it answered every time on some connections and refused others for a while. Restaurants it refuses come without times and **are not charged for them**; after three refused calls in a row the run stops asking. Rows always carry `recentReservationCount` (bookings today).
- **A date search pages less cleanly than OpenTable's normal search** (849 rows → 801 unique in New York): every restaurant is delivered once, but a few may be missed - leave "Only restaurants with tables" off for complete lists.
- **Restaurant details read one page per restaurant**, so they are slower (about 1 second each, 4 in parallel).
- An empty run means OpenTable has no restaurant for that place and filter; it is listed in `RUN_SUMMARY` and costs nothing.

### FAQ

#### How much does OpenTable Scraper cost?

$0.18 per 1,000 restaurants, with optional add-ons priced per result (see the table above). There is no start fee.

#### How many restaurants can OpenTable Scraper get?

As many as OpenTable lists. One search returns up to ~1,000; Deep search returned 2,311 for New York and 2,796 for London in our tests.

#### Does OpenTable Scraper get phone numbers and emails?

Yes. Phone is in 99% of rows. With Find emails it reads each restaurant's own website and found an email for 50% of restaurants in our test runs.

#### Can OpenTable Scraper check table availability?

Yes, with Bookable times: the times OpenTable offers around your date, time and party size, for up to 7 days. You are charged only for restaurants OpenTable answered for.

#### Can OpenTable Scraper get reviews?

Yes - inside each restaurant row (Reviews) or one row per review (`mode: reviews`), with order, date, rating, VIP and keyword filters.

#### Does OpenTable Scraper work outside the US?

Yes. Type the place with its country (`"Paris, France"`, `"Toronto"`, `"London"`); the matching OpenTable site is picked automatically.

#### Can I schedule OpenTable Scraper?

Yes. Use Apify schedules; `daysAhead` keeps a scheduled availability check on "7 days from today".

#### Can I use OpenTable Scraper with the API or Python?

Yes - every run can be started and read through the Apify API or `apify-client`.

#### Can AI agents use OpenTable Scraper through MCP?

Yes, through the Apify MCP server.

#### Do I need an OpenTable account, login or API key?

No. The actor reads what OpenTable shows any visitor.

#### Why did my OpenTable Scraper run return no results?

OpenTable had no restaurant for the place and filters (`RUN_SUMMARY` lists the search and how the place was read). Check the spelling, add the country, or remove a filter. Nothing is charged for an empty search.

#### Your feedback

Missing a field or found a bug? Open an issue on the Issues tab - we read every one.

# Actor input Schema

## `mode` (type: `string`):

Restaurants by place (search), restaurants you list by URL / id / name (restaurants), or diner reviews, one row per review (reviews).

## `locations` (type: `array`):

Cities, regions or neighbourhoods as you would type them on OpenTable, e.g. "Chicago, IL", "London", "SoHo, New York", "Toronto". Add the country for places outside the US ("Paris, France"). Each is searched with every search term below.

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

Optional. What you would type into OpenTable's search, e.g. "sushi", "steakhouse", "brunch", "rooftop". Empty = every restaurant in the place.

## `latitude` (type: `number`):

Optional. Search around exact coordinates (with longitude), e.g. 40.7128. Runs in addition to the places above.

## `longitude` (type: `number`):

Optional. Longitude for the coordinates search, e.g. -74.006.

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

Optional. Restaurant pages (opentable.com/r/..., opentable.com/<name>, /restaurant/profile/<id>) and search pages (opentable.com/s?...) from any OpenTable country site. A search URL keeps its keyword, coordinates, date and party size.

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

Optional. OpenTable restaurant ids (the number in /restaurant/profile/<id>), e.g. "108541". Used by the restaurants and reviews modes.

## `restaurantNames` (type: `array`):

Optional. One restaurant per line as "Name, City", e.g. "Nobu Fifty Seven, New York". Resolved with OpenTable's own search; a name OpenTable does not match is reported, never guessed.

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

Most rows this run delivers (restaurants, or reviews in reviews mode). Each place / URL is searched in order until this is reached.

## `maxResultsPerSearch` (type: `integer`):

Optional cap for each place x term search (0 = no cap; Max results still applies).

## `deepSearch` (type: `boolean`):

OpenTable serves the ~750-1,000 restaurants nearest the place's centre. Deep search cuts the area into map tiles and searches each, deduplicating by restaurant id (New York: 990 -> 2,311; London: 999 -> 2,796).

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

OpenTable's result order.

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

Only these OpenTable price bands. Empty = all.

## `awardTags` (type: `array`):

Only restaurants with these OpenTable award tags, e.g. "MICHELIN".

## `tableCategories` (type: `array`):

Only restaurants offering this seating.

## `occasions` (type: `array`):

OpenTable's occasion prompts, e.g. "ROMANTIC", "BRUNCH", "BUSINESS", "GROUPS".

## `onlyJustAdded` (type: `boolean`):

Only restaurants OpenTable marks as new on OpenTable.

## `searchRadiusMiles` (type: `integer`):

Optional. OpenTable's search radius around the place. It also sets the area deep search covers. 0 = OpenTable's default.

## `onlyBookable` (type: `boolean`):

Ask OpenTable for restaurants with tables around the date, time and party size below (OpenTable's own date search).

## `cuisines` (type: `array`):

Keep restaurants whose main cuisine is one of these, e.g. "Italian", "Steakhouse", "Japanese" (OpenTable's cuisine names).

## `minRating` (type: `number`):

Only restaurants rated at least this (1-5). 0 = off.

## `minReviews` (type: `integer`):

Only restaurants with at least this many reviews. 0 = off.

## `withPhoneOnly` (type: `boolean`):

Skip restaurants without a phone number.

## `wheelchairAccessible` (type: `boolean`):

Only restaurants whose OpenTable profile lists wheelchair access (reads each profile, so Restaurant details are included).

## `includeAvailability` (type: `boolean`):

Add each restaurant's bookable times around the reservation below (OpenTable's own availability call, 50 restaurants per call). Charged only for restaurants OpenTable answered for.

## `date` (type: `string`):

Reservation date, YYYY-MM-DD. Empty = tomorrow (or Days ahead).

## `daysAhead` (type: `integer`):

Use instead of a date for scheduled runs: 0 = today, 7 = a week from the run.

## `time` (type: `string`):

Reservation time, HH:MM (24-hour), e.g. 19:00. OpenTable answers times within ~2.5 hours either side.

## `partySize` (type: `integer`):

Number of diners.

## `availabilityDays` (type: `integer`):

Bookable times for this many days after the date too (0-6), in availabilityDays.

## `includeDetails` (type: `boolean`):

Read each restaurant's OpenTable profile: website, opening hours, all cuisines, chef, dress code, parking, payment options, amenities, food / service / ambience / value ratings, noise, review summary, popular dishes, private dining.

## `includeMenus` (type: `boolean`):

Add the OpenTable-hosted menus (sections, dishes, descriptions, prices) from the profile page. Turns on Restaurant details.

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

Add diner reviews to each restaurant (text, 5 ratings, noise, dates, diner, VIP, helpful votes, restaurant reply).

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

Most reviews per restaurant (paged 100 at a time). 0 = all (up to 5,000).

## `reviewsSort` (type: `string`):

Which reviews come first.

## `reviewsSince` (type: `string`):

Optional. Only reviews of visits on or after this date (YYYY-MM-DD).

## `reviewsMinRating` (type: `integer`):

Only reviews with at least this overall rating (1-5). 0 = all.

## `reviewsVipOnly` (type: `boolean`):

Only reviews by diners OpenTable marks as VIP.

## `reviewsKeyword` (type: `string`):

Optional. Only reviews that mention this word or phrase (OpenTable's own review search), e.g. "birthday", "gluten".

## `includeEmails` (type: `boolean`):

Look for each restaurant's email on its own website (homepage + contact / about pages; own-domain or ordinary mailbox addresses only). Turns on Restaurant details (the website comes from the profile). Charged only when an email is found.

## `verifyEmailDomain` (type: `boolean`):

Drop addresses whose domain has no mail server (DNS check).

## `domain` (type: `string`):

Which OpenTable market to search in. Auto picks it from the place (London -> opentable.co.uk, Toronto -> opentable.ca).

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

Restaurants enriched in parallel (details, reviews).

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

Optional. The actor tries Apify's own connection first and switches to Apify RESIDENTIAL (US) by itself when OpenTable refuses it. Set your own proxy or another Apify group here to try it first.

## Actor input object example

```json
{
  "mode": "search",
  "locations": [
    "Chicago, IL"
  ],
  "maxResults": 20,
  "maxResultsPerSearch": 0,
  "deepSearch": false,
  "sortBy": "best",
  "onlyJustAdded": false,
  "searchRadiusMiles": 0,
  "onlyBookable": false,
  "minRating": 0,
  "minReviews": 0,
  "withPhoneOnly": false,
  "wheelchairAccessible": false,
  "includeAvailability": false,
  "time": "19:00",
  "partySize": 2,
  "availabilityDays": 0,
  "includeDetails": false,
  "includeMenus": false,
  "includeReviews": false,
  "maxReviewsPerRestaurant": 20,
  "reviewsSort": "newestReview",
  "reviewsMinRating": 0,
  "reviewsVipOnly": false,
  "includeEmails": false,
  "verifyEmailDomain": true,
  "domain": "auto",
  "maxConcurrency": 4
}
```

# Actor output Schema

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

One row per restaurant (search and restaurants modes) or per review (reviews mode).

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

Per search: how the place was resolved, OpenTable's own result count, calls, rows delivered, duplicates and filtered counts, map tiles, errors, and the route used.

# 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 = {
    "locations": [
        "Chicago, IL"
    ],
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapersdelight/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 = {
    "locations": ["Chicago, IL"],
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapersdelight/opentable-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "locations": [
    "Chicago, IL"
  ],
  "maxResults": 20
}' |
apify call scrapersdelight/opentable-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapersdelight/opentable-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/cZlrg0JxnUp9frd1K/builds/yardaIshBt0CN8PyP/openapi.json