# Resy Scraper (`solidcode/resy-scraper`) Actor

\[💰 $4.0 / 1K] Extract restaurants from Resy by city, keyword, cuisine, or URL — full venue details plus optional real-time reservation availability.

- **URL**: https://apify.com/solidcode/resy-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Developer tools, Automation, Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 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

## Resy Scraper

Pull restaurants from Resy at scale — names, cuisines, neighborhoods, full addresses with coordinates, price bands, ratings, phone numbers, websites, social handles, photos, and platform IDs for every venue, plus optional real-time reservation time-slots for any date. Built for restaurant-tech teams, market analysts, and lead-gen agencies who need clean, structured Resy data across US dining markets without building and maintaining their own scraper.

### Why This Scraper?

- **~40 fields per restaurant** — name, cuisine tags, neighborhood, full street address with latitude/longitude, IANA time zone, phone, website, social profiles, photos, price band, rating, and review count, all in one flat row.
- **Real reservation availability, opt-in** — flip one switch to embed every bookable time-slot for a chosen date; a single popular venue returned up to ~90 slots in a single day during testing, each with start/end time, table type, and party size.
- **Reservation times included at no extra per-slot cost** — every restaurant stays one result, with its time-slots attached as a list inside it, so availability never multiplies your bill.
- **Party sizes from 1 to 20** — check solo-diner counters or large-group tables; the actor queries the exact party size you ask for.
- **Three cross-referencing platform IDs per venue** — Resy venue ID, Google Place ID, and Foursquare ID, so you can join Resy records straight into Google or Foursquare datasets.
- **15 curated cuisine filters** — American, French, Italian, Japanese, Korean, Mexican, Mediterranean, Seafood, Steakhouse, Sushi, Thai, and more, each running a focused city search.
- **Four input modes in one run** — search by city, free-text keyword, cuisine, or pasted Resy venue and city URLs, combinable in a single run.
- **Coverage across US dining markets** — New York, Los Angeles, Chicago, San Francisco, and beyond, all verified, with sustained pagination and `maxResults: 0` for unlimited pulls.

### Use Cases

**Market Research**
- Map the dining landscape of a city by cuisine, price band, and neighborhood
- Track which restaurants list on Resy in a target market over time
- Benchmark price bands ($–$$$$) across neighborhoods
- Build cuisine-mix profiles for entire metro areas

**Lead Generation**
- Build restaurant contact lists with phone, website, and social profiles
- Target venues by cuisine, neighborhood, or rating threshold
- Identify high-traffic restaurants by review count for sales outreach
- Enrich CRM records with verified venue addresses and coordinates

**Competitive Intelligence**
- Monitor reservation availability and prime-time slot scarcity at rival venues
- Compare booking windows and table types across competitors
- Track which venues offer waitlists versus open tables
- Watch party-size limits and large-party policies in a market

**Restaurant Tech & Data Enrichment**
- Power dining-discovery and reservation apps with structured venue feeds
- Join Resy venues to Google or Foursquare records via shared platform IDs
- Feed real-time slot availability into booking dashboards
- Geocode and map venues using built-in latitude/longitude

### Getting Started

#### Scrape a City

The simplest run — just a city:

```json
{
    "city": "new-york-ny",
    "maxResults": 50
}
````

#### Search by Cuisine and Keyword

```json
{
    "city": "los-angeles-ca",
    "query": "sushi",
    "cuisine": ["japanese", "seafood"],
    "maxResults": 100
}
```

#### Include Reservation Availability

```json
{
    "city": "chicago-il",
    "query": "italian",
    "maxResults": 25,
    "includeAvailability": true,
    "reservationDate": "2026-06-05",
    "partySize": 2
}
```

#### Scrape Specific Restaurants by URL

```json
{
    "startUrls": [
        "https://resy.com/cities/new-york-ny/venues/eccolo-italian-restaurant"
    ],
    "includeAvailability": true,
    "partySize": 4
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `city` | string | `"new-york-ny"` | City to search on Resy. Enter a city name, Resy city code, or URL slug (e.g. "New York", "london", "los-angeles-ca"). |
| `query` | string | `""` | Free-text search by restaurant name, cuisine, or keyword (e.g. "sushi", "Carbone", "rooftop"). Leave empty to return all restaurants in the city. |
| `startUrls` | array | `[]` | Paste Resy restaurant or city page URLs to scrape directly. Use instead of, or alongside, the city/keyword search. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `cuisine` | array | `[]` | Narrow results to one or more common cuisines. Each selection runs a focused search for that cuisine in the city. Leave empty to include all cuisines. |
| `maxResults` | integer | `100` | Maximum number of restaurants to return. Set to `0` for unlimited. |
| `includeDetails` | boolean | `true` | Fetch each restaurant's full profile — ratings, street address, website, phone, social links, description, and photos. Turn off for faster, lighter results with just the core fields. |

Cuisine options: American, Chinese, Cocktail Bar, French, Indian, Italian, Japanese, Korean, Mediterranean, Mexican, New American, Seafood, Steakhouse, Sushi, Thai.

#### Reservation Availability

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeAvailability` | boolean | `false` | Also fetch real-time reservation time-slots for each restaurant. Each restaurant stays a single result — the time-slots are attached as a list inside it. |
| `reservationDate` | string | today | Date to check availability, in YYYY-MM-DD format. Leave empty to use today. Only used when availability is enabled. |
| `partySize` | integer | `2` | Number of guests for the reservation (1–20). Only used when availability is enabled. |

### Output

Each restaurant is returned as a single flat record. When reservation availability is enabled, the bookable time-slots are embedded as a `slots` list inside the same record.

```json
{
    "recordType": "venue",
    "id": 443,
    "name": "Eccolo",
    "urlSlug": "eccolo-italian-restaurant",
    "url": "https://resy.com/cities/new-york-ny/venues/eccolo-italian-restaurant",
    "neighborhood": "SoHo",
    "locality": "New York",
    "region": "NY",
    "country": "US",
    "address": "200 Lafayette St",
    "postalCode": "10012",
    "latitude": 40.7203,
    "longitude": -73.9981,
    "timeZone": "America/New_York",
    "phone": "+12125551234",
    "website": "https://eccolo-nyc.com",
    "socialLinks": ["https://instagram.com/eccolonyc"],
    "cuisine": ["Italian"],
    "type": "Italian",
    "priceRange": "$$$",
    "currencyCode": "USD",
    "rating": 4.7,
    "ratingCount": 1820,
    "minPartySize": 1,
    "maxPartySize": 8,
    "images": ["https://image.resy.com/abc.jpg"],
    "description": "A modern Italian trattoria in SoHo...",
    "metaDescription": "Book a table at Eccolo on Resy.",
    "keywords": ["italian", "trattoria", "soho"],
    "collections": ["Hot New Restaurants"],
    "googlePlaceId": "ChIJ1234567890",
    "foursquareId": "4a1b2c3d4e5f",
    "venueGroup": "Eccolo Hospitality",
    "awards": [],
    "largePartyMessage": "For parties of 9+, please call.",
    "waitlistAvailable": true,
    "slotCount": 3,
    "slots": [
        {
            "startTime": "2026-06-05 18:00:00",
            "endTime": "2026-06-05 20:00:00",
            "type": "Dining Room",
            "configId": "rgs://resy/443/...",
            "hasAddOns": false,
            "shiftDay": "2026-06-05",
            "date": "2026-06-05",
            "partySize": 2
        }
    ],
    "scrapedAt": "2026-05-29T14:00:00Z"
}
```

#### Core & Identity

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"venue"`. |
| `id` | integer | Resy venue ID. |
| `name` | string | Restaurant name. |
| `urlSlug` | string | Resy URL slug. |
| `url` | string | Canonical Resy venue URL. |
| `type` | string | Venue type. |
| `cuisine` | array | Cuisine tags. |
| `description` | string | Venue description. |
| `metaDescription` | string | SEO meta description. |
| `keywords` | array | Keyword tags. |
| `collections` | array | Resy collections the venue appears in. |
| `images` | array | Photo URLs. |
| `venueGroup` | string | Parent venue group or operator. |
| `awards` | array | Awards and badges. |
| `scrapedAt` | string | ISO timestamp of the extraction. |

#### Location

| Field | Type | Description |
|-------|------|-------------|
| `neighborhood` | string | Neighborhood. |
| `locality` | string | City. |
| `region` | string | State or region. |
| `country` | string | Country. |
| `address` | string | Street address. |
| `postalCode` | string | ZIP or postal code. |
| `latitude` | number | Latitude. |
| `longitude` | number | Longitude. |
| `timeZone` | string | IANA time zone. |

#### Contact & Social

| Field | Type | Description |
|-------|------|-------------|
| `phone` | string | Phone number. |
| `website` | string | Restaurant website. |
| `socialLinks` | array | Social profile URLs (Instagram, Twitter/X, Facebook). |

#### Ratings & Price

| Field | Type | Description |
|-------|------|-------------|
| `priceRange` | string | Price band ($–$$$$). |
| `currencyCode` | string | Currency code. |
| `rating` | number | Average rating. |
| `ratingCount` | integer | Number of ratings. |
| `minPartySize` | integer | Minimum party size accepted. |
| `maxPartySize` | integer | Maximum party size accepted. |
| `largePartyMessage` | string | Large-party note. |
| `waitlistAvailable` | boolean | Whether a waitlist is offered. |

#### Platform IDs

| Field | Type | Description |
|-------|------|-------------|
| `googlePlaceId` | string | Google Place ID. |
| `foursquareId` | string | Foursquare ID. |

#### Reservation Availability

`slotCount` is the number of bookable slots found (0 when availability is off). `slots` is the embedded list of time-slots, each with the fields below.

| Field | Type | Description |
|-------|------|-------------|
| `slotCount` | integer | Number of bookable slots found for the date and party size. |
| `slots` | array | Embedded list of reservation time-slots (populated only when availability is enabled). |
| `slots[].startTime` | string | Slot start time. |
| `slots[].endTime` | string | Slot end time. |
| `slots[].type` | string | Room or table type. |
| `slots[].configId` | string | Booking configuration token for the slot. |
| `slots[].hasAddOns` | boolean | Whether add-ons are available. |
| `slots[].shiftDay` | string | Service shift day. |
| `slots[].date` | string | Reservation date (YYYY-MM-DD). |
| `slots[].partySize` | integer | Party size queried. |

### Tips for Best Results

- Use the URL slug form for `city` (e.g. `los-angeles-ca`, `san-francisco-ca`) for the most reliable market resolution; plain city names and Resy city codes also work.
- Leave `query` empty to browse every restaurant in a city, or set it to a name, dish, or vibe ("rooftop", "omakase") to focus the search.
- Each cuisine you pick runs its own focused city search, so selecting several cuisines widens coverage rather than narrowing it — combine cuisines to sweep a market.
- Turn on `includeAvailability` only when you need bookable times; it queries each restaurant for the chosen date and adds one extra lookup per venue.
- Availability is a snapshot — prime dinner slots at popular venues turn over fast, so re-run close to your target date for the freshest open tables.
- Set `maxResults` to `0` for an exhaustive pull of a city, or cap it for quick samples; the actor overshoots the final page rather than cutting it short.
- Leave `includeDetails` on (the default) for the richest records — full address, website, social links, ratings, and photos. Turn it off for large, fast market sweeps when you only need core fields (name, neighborhood, cuisine, coordinates, price band).
- Combine `startUrls` with a city search in one run to pull specific known venues alongside a broad market sweep.

### Pricing

**$4.00 per 1,000 results** — a single flat rate that undercuts the typical Resy data tier, with no compute charges and no per-slot surcharge for availability.

| Results | Estimated Cost |
|---------|----------------|
| 100 | $0.40 |
| 1,000 | $4.00 |
| 10,000 | $40.00 |
| 100,000 | $400.00 |

A "result" is one restaurant record, including any embedded reservation time-slots — so availability never multiplies your bill. No compute charges — you only pay per result returned. Apify platform fees are additional.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This scraper collects publicly available restaurant information from Resy. Use the data responsibly and in compliance with Resy's terms of service and all applicable laws, including data-protection regulations such as GDPR and CCPA. Do not use the data to harass businesses, send unsolicited bulk communications, or for any unlawful purpose. You are responsible for how you use the data you collect.

# Actor input Schema

## `city` (type: `string`):

City to search on Resy. Enter a city name, Resy city code, or URL slug (e.g. 'New York', 'london', 'los-angeles-ca'). Leave the search fields empty if you are using Start URLs.

## `query` (type: `string`):

Free-text search by restaurant name, cuisine, or keyword (e.g. 'sushi', 'Carbone', 'rooftop'). Optional — leave empty to return all restaurants in the city.

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

Paste Resy restaurant or city page URLs to scrape directly. Optional — use this instead of, or alongside, the city/keyword search above.

## `cuisine` (type: `array`):

Narrow results to one or more common cuisines. Each selection runs a focused search for that cuisine in the city above. Leave empty to include all cuisines.

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

Maximum number of restaurants to return. Set to 0 for unlimited.

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

Fetch each restaurant's full profile — ratings, street address, website, phone, social links, description, and photos. Turn off for faster, lighter results with just the core fields (name, neighborhood, cuisine, coordinates, price band).

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

Also fetch real-time reservation time-slots for each restaurant. Each restaurant stays a single result — the time-slots are attached as a list inside it.

## `reservationDate` (type: `string`):

Date to check availability, in YYYY-MM-DD format. Leave empty to use today. Only used when reservation availability is enabled.

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

Number of guests for the reservation. Only used when reservation availability is enabled.

## Actor input object example

```json
{
  "city": "new-york-ny",
  "startUrls": [],
  "cuisine": [],
  "maxResults": 100,
  "includeDetails": true,
  "includeAvailability": false,
  "partySize": 2
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of scraped restaurants with key fields.

# 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 = {
    "city": "new-york-ny",
    "query": "",
    "startUrls": [],
    "cuisine": [],
    "maxResults": 100,
    "includeDetails": true,
    "includeAvailability": false,
    "reservationDate": "",
    "partySize": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/resy-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 = {
    "city": "new-york-ny",
    "query": "",
    "startUrls": [],
    "cuisine": [],
    "maxResults": 100,
    "includeDetails": True,
    "includeAvailability": False,
    "reservationDate": "",
    "partySize": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/resy-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 '{
  "city": "new-york-ny",
  "query": "",
  "startUrls": [],
  "cuisine": [],
  "maxResults": 100,
  "includeDetails": true,
  "includeAvailability": false,
  "reservationDate": "",
  "partySize": 2
}' |
apify call solidcode/resy-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Resy Scraper",
        "description": "[💰 $4.0 / 1K] Extract restaurants from Resy by city, keyword, cuisine, or URL — full venue details plus optional real-time reservation availability.",
        "version": "1.0",
        "x-build-id": "wpNVgimAreGf3gu3v"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~resy-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-resy-scraper",
                "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/solidcode~resy-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-resy-scraper",
                "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/solidcode~resy-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-resy-scraper",
                "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": {
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City to search on Resy. Enter a city name, Resy city code, or URL slug (e.g. 'New York', 'london', 'los-angeles-ca'). Leave the search fields empty if you are using Start URLs.",
                        "default": "new-york-ny"
                    },
                    "query": {
                        "title": "Search Keyword",
                        "type": "string",
                        "description": "Free-text search by restaurant name, cuisine, or keyword (e.g. 'sushi', 'Carbone', 'rooftop'). Optional — leave empty to return all restaurants in the city."
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Paste Resy restaurant or city page URLs to scrape directly. Optional — use this instead of, or alongside, the city/keyword search above.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "cuisine": {
                        "title": "Cuisine",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Narrow results to one or more common cuisines. Each selection runs a focused search for that cuisine in the city above. Leave empty to include all cuisines.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "american",
                                "chinese",
                                "cocktail bar",
                                "french",
                                "indian",
                                "italian",
                                "japanese",
                                "korean",
                                "mediterranean",
                                "mexican",
                                "new american",
                                "seafood",
                                "steakhouse",
                                "sushi",
                                "thai",
                                "American",
                                "Chinese",
                                "Cocktail Bar",
                                "French",
                                "Indian",
                                "Italian",
                                "Japanese",
                                "Korean",
                                "Mediterranean",
                                "Mexican",
                                "New American",
                                "Seafood",
                                "Steakhouse",
                                "Sushi",
                                "Thai"
                            ],
                            "enumTitles": [
                                "American",
                                "Chinese",
                                "Cocktail Bar",
                                "French",
                                "Indian",
                                "Italian",
                                "Japanese",
                                "Korean",
                                "Mediterranean",
                                "Mexican",
                                "New American",
                                "Seafood",
                                "Steakhouse",
                                "Sushi",
                                "Thai",
                                "American",
                                "Chinese",
                                "Cocktail Bar",
                                "French",
                                "Indian",
                                "Italian",
                                "Japanese",
                                "Korean",
                                "Mediterranean",
                                "Mexican",
                                "New American",
                                "Seafood",
                                "Steakhouse",
                                "Sushi",
                                "Thai"
                            ]
                        },
                        "default": []
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of restaurants to return. Set to 0 for unlimited.",
                        "default": 100
                    },
                    "includeDetails": {
                        "title": "Include Full Restaurant Details",
                        "type": "boolean",
                        "description": "Fetch each restaurant's full profile — ratings, street address, website, phone, social links, description, and photos. Turn off for faster, lighter results with just the core fields (name, neighborhood, cuisine, coordinates, price band).",
                        "default": true
                    },
                    "includeAvailability": {
                        "title": "Include Reservation Availability",
                        "type": "boolean",
                        "description": "Also fetch real-time reservation time-slots for each restaurant. Each restaurant stays a single result — the time-slots are attached as a list inside it.",
                        "default": false
                    },
                    "reservationDate": {
                        "title": "Reservation Date",
                        "type": "string",
                        "description": "Date to check availability, in YYYY-MM-DD format. Leave empty to use today. Only used when reservation availability is enabled."
                    },
                    "partySize": {
                        "title": "Party Size",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Number of guests for the reservation. Only used when reservation availability is enabled.",
                        "default": 2
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
