OpenTable APIopentable.com ↗
Search OpenTable restaurants by location, cuisine, and date. Get real-time reservation availability, autocomplete suggestions, and detailed ratings and pricing data.
What is the OpenTable API?
This API exposes 4 endpoints covering OpenTable's US restaurant database, including detailed search, reservation availability, location resolution, and typeahead autocomplete. The search_restaurants endpoint returns paginated results with fields like restaurant_id, cuisine, rating, review_count, photos, address, and features, filterable by price band, coordinates, date, party size, and metro area.
curl -X GET 'https://api.parse.bot/scraper/f37010d4-cf53-464e-8c5a-8b0fb742720e/search_restaurants?date=2026-07-09&page=1&term=Italian&time=19%3A00&query=pizza&sort_by=RATING&latitude=40.7128&location=chicago&metro_id=0&longitude=-74.006&page_size=25&party_size=2' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace opentable-com-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
from parse_apis.opentable_restaurant_search_api import OpenTable, Sort, Restaurant, Location
client = OpenTable()
# Resolve location for San Francisco
location = client.locations.lookup(latitude=37.7749, longitude=-122.4194)
print(location.metro.display_name, location.metro.metro_id)
# Search for Italian restaurants sorted by rating
for restaurant in client.restaurants.search(
term="Italian",
latitude=37.7749,
longitude=-122.4194,
sort_by=Sort.RATING,
party_size=4,
metro_id=location.metro.metro_id,
limit=5,
):
print(restaurant.name, restaurant.rating, restaurant.cuisine, restaurant.neighborhood)
# Get autocomplete suggestions
for suggestion in client.suggestions.search(term="sushi", latitude=40.7128, longitude=-74.006):
print(suggestion.name, suggestion.type)
# Check availability for a specific restaurant
avail = restaurant.check_availability()
for day in avail.availability_days:
for slot in day.available_slots:
print(slot.time_offset_minutes, slot.type, slot.points_value)
Search for restaurants by keyword, location, date/time, party size, and various filters. Returns paginated results with comprehensive restaurant details including name, cuisine, ratings, reviews, photos, address, phone, and features. Paginates via page number. Each restaurant includes a restaurant_id usable with restaurant_availability.
| Param | Type | Description |
|---|---|---|
| date | string | Date in YYYY-MM-DD format. Defaults to tomorrow. |
| page | integer | Page number (1-based) |
| term | string | Search term (e.g., 'Italian', 'sushi', 'steakhouse', 'pizza'). Leave empty to browse all restaurants. |
| time | string | Time in HH:MM format (24h) |
| prices | string | Comma-separated price band IDs (1=under $15, 2=$30 and under, 3=$31-50, 4=$50+) |
| sort_by | string | Sort order for results |
| latitude | number | Latitude of search center |
| metro_id | integer | Metro ID (auto-resolved from coordinates if not provided). Use location_lookup to find IDs. |
| longitude | number | Longitude of search center |
| page_size | integer | Results per page (max 50) |
| party_size | integer | Number of diners |
| cuisine_ids | string | Comma-separated cuisine filter IDs |
{
"type": "object",
"fields": {
"page": "integer current page number",
"filters": "object with date, time, party_size, sort_by",
"location": "object with latitude, longitude, metro_id",
"page_size": "integer results per page",
"restaurants": "array of restaurant objects with restaurant_id, name, cuisine, rating, review_count, address, phone, photos, features, etc.",
"search_term": "string the search term used",
"total_results": "integer total number of matching restaurants"
},
"sample": {
"data": {
"page": 1,
"filters": {
"date": "2026-06-11",
"time": "19:00",
"sort_by": "WEB_CONVERSION",
"party_size": 2
},
"location": {
"latitude": 40.7128,
"metro_id": 8,
"longitude": -74.006
},
"page_size": 25,
"restaurants": [
{
"name": "Cecconi's Dumbo",
"phone": "+1 (555) 012-3456",
"photos": [
"https://resizer.otstatic.com/v4/photos/24991179-1?width=640&height=360"
],
"rating": 4.6,
"address": {
"city": "Brooklyn",
"line1": "55 Water St",
"state": "NY",
"post_code": "11201"
},
"cuisine": "Contemporary Italian",
"features": {
"bar": true,
"counter": false,
"outdoor": true,
"max_party_size": 9
},
"latitude": 40.7034056,
"longitude": -73.9923495,
"price_range": "$30 and under",
"neighborhood": "DUMBO",
"review_count": 5980,
"price_band_id": 2,
"restaurant_id": 730843
}
],
"search_term": "Italian",
"total_results": 440
},
"status": "success"
}
}About the OpenTable API
Restaurant Search
The search_restaurants endpoint accepts a term (e.g. "sushi", "steakhouse"), a date in YYYY-MM-DD format, a time in 24-hour HH:MM format, and optional filters including prices (comma-separated band IDs from 1–4), latitude, and metro_id. Results are paginated with a page_size field, and the total_results field tells you how many records match. Each restaurant object includes restaurant_id, name, cuisine, rating, review_count, phone, photos, and features. Sort options are WEB_CONVERSION, RATING, and DISTANCE.
Availability and Location
The restaurant_availability endpoint takes a comma-separated list of restaurant_ids (from search_restaurants results), a date, time, and party_size. It returns an availability array per restaurant containing availability_days objects with day_offset and no_times_reasons fields, letting you surface open time slots relative to the requested time. The location_lookup endpoint resolves latitude/longitude into OpenTable's internal geography — returning metro, macro, and neighborhood objects with their respective IDs — which you can then pass as metro_id into search_restaurants.
Autocomplete
The autocomplete endpoint accepts a term string and optional latitude/longitude bias coordinates. It returns a suggestions array where each object carries id, type, name, metro_id, metro_name, macro_name, neighborhood, and coordinates. Types can represent restaurants, cuisines, or locations, making this suitable for building typeahead search UIs that feed directly into search_restaurants parameters.
The OpenTable API is a managed, monitored endpoint for opentable.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when opentable.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official opentable.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Find available restaurants for a specific party size, date, and time in a metro area
- Build a typeahead search bar using autocomplete suggestions biased to the user's coordinates
- Display restaurant cards with ratings, review counts, photos, and price bands from search results
- Resolve a user's GPS coordinates to a metro_id for scoped restaurant searches
- Check reservation slot availability across multiple restaurants simultaneously
- Filter restaurants by cuisine type and price band to match dining preferences
- Aggregate OpenTable ratings and review counts alongside other dining data sources
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does OpenTable have an official developer API?+
What does the `restaurant_availability` endpoint actually return?+
availability array keyed by restaurant_id. Each entry contains availability_days, which is an array of objects with a day_offset (relative to the requested date), a list of available time slots, and no_times_reasons indicating why certain slots are unavailable. You can query up to several restaurants at once by passing a comma-separated list to restaurant_ids.Does the API cover restaurants outside the United States?+
location_lookup and search_restaurants reflect US coverage. You can fork this API on Parse and revise it to target non-US OpenTable markets and add the relevant geographic parameters.Are restaurant menus or menu item prices available?+
How does pagination work in `search_restaurants`?+
page parameter. Each response includes a page_size field indicating results per page and a total_results field indicating the full match count, so you can calculate the total number of pages and iterate through them sequentially.