# Resy Scraper - Restaurants & Real-Time Availability (`clearpath/resy-api`) Actor

Extract restaurant data and real-time reservation availability from Resy. Enter a city or paste URLs. Get ratings, cuisine, contact info, images, descriptions, waitlist status, and bookable time slots across 1,900+ cities. Export as JSON, CSV, or Excel.

- **URL**: https://apify.com/clearpath/resy-api.md
- **Developed by:** [ClearPath](https://apify.com/clearpath) (community)
- **Categories:** Lead generation, Travel, Social media
- **Stats:** 61 total users, 20 monthly users, 83.6% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.49 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 | Restaurant Data & Real-Time Availability (2026)

<table>
<tr>
<td style="background:#006D77;padding:24px 28px;border:none;border-radius:14px">
<span style="font-size:11px;font-weight:700;text-transform:uppercase;letter-spacing:4px;color:#EDF6F9">CLEARPATH</span><br><br>
<span style="font-size:30px;font-weight:800;color:#FAFAF9;letter-spacing:-0.5px">Resy Restaurant Scraper</span><br>
<span style="color:#EDF6F9;font-size:15px;line-height:1.6">Extract restaurant data and real-time reservation availability from Resy. 40+ fields per restaurant: full address, social links, average spend, ratings, cuisine, contact info, descriptions, images, and bookable time slots across 1,900+ cities worldwide.</span>
</td>
</tr>
</table>

&nbsp;

<table>
<tr>
<td style="padding:8px 14px;border:none;background:#006D77;border-radius:6px 0 0 6px"><span style="color:#FAFAF9;font-weight:700;font-size:13px">Resy Scraper</span></td>
<td style="padding:8px 14px;border:1px solid #E7E5E4;border-left:none"><a href="https://apify.com/clearpath/thefork-scraper" style="color:#57534E;font-weight:600;font-size:13px;text-decoration:none">TheFork Scraper</a></td>
<td style="padding:8px 14px;border:1px solid #E7E5E4;border-left:none;border-radius:0 6px 6px 0"><a href="https://apify.com/clearpath/thefork-restaurant-reviews" style="color:#57534E;font-weight:600;font-size:13px;text-decoration:none">TheFork Reviews</a></td>
</tr>
</table>

&nbsp;

**Extract complete restaurant data from Resy** across 1,900+ cities worldwide. Phone numbers, websites, social links, average spend, ratings, cuisine types, GPS coordinates, images, descriptions, venue groups, awards, and real-time reservation availability. 40+ fields per restaurant.

#### Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.

````

clearpath/resy-api on Apify. Call: ApifyClient("TOKEN").actor("clearpath/resy-api").call(run\_input={...}), then client.dataset(run\["defaultDatasetId"]).list\_items().items for results. Key inputs: city (string), startUrls (array), maxItems (integer). Full actor spec (input schema with all params/enums/defaults, output dataset fields, README): GET https://api.apify.com/v2/acts/clearpath~resy-api/builds/default (Bearer TOKEN) → inputSchema, actorDefinition.storages.dataset, readme. Pricing: pay-per-event, $5.99 per 1,000 restaurants scraped. Get token: https://console.apify.com/account/integrations

````

### Quick Start

#### Basic — Scrape restaurants in a city
```json
{
    "city": "New York"
}
````

#### Search by cuisine

```json
{
    "city": "Los Angeles",
    "cuisine": "Japanese",
    "maxItems": 200
}
```

#### Get availability for a specific date

```json
{
    "city": "Chicago",
    "includeAvailability": true,
    "date": "2026-03-20",
    "partySize": 4,
    "maxItems": 50
}
```

#### URL input — Scrape specific pages

```json
{
    "startUrls": [
        "https://resy.com/cities/new-york-ny/carbone",
        "https://resy.com/cities/new-york-ny"
    ]
}
```

### Input Parameters

| Parameter | Type | Description | Default |
|-----------|------|-------------|---------|
| `startUrls` | array | Resy URLs to scrape. Supports city and restaurant pages. | — |
| `city` | string | City name, code, or URL slug. 1,900+ cities supported. | — |
| `query` | string | Search by restaurant name, cuisine, or keyword. | — |
| `cuisine` | string | Filter by cuisine type. 15 options including Italian, Japanese, Steakhouse, Sushi, Mexican, etc. | — |
| `includeAvailability` | boolean | Include real-time reservation slots. Requires date and party size. | `false` |
| `date` | string | Reservation date (YYYY-MM-DD). Required with availability. | — |
| `partySize` | integer | Number of guests (1-20). Used with availability. | `2` |
| `maxItems` | integer | Maximum number of restaurants to return. | `100` |

### Output

Each restaurant includes 40+ fields: identity, ratings, cuisine, full address, contact, social links, average spend, venue group, awards, images, descriptions, GPS coordinates, cross-platform IDs, and more. With availability enabled, each restaurant also includes all bookable time slots.

#### Output Example

```json
{
    "id": 60029,
    "name": "Le Gratin",
    "urlSlug": "le-gratin",
    "url": "https://resy.com/cities/new-york-ny/le-gratin",
    "canonicalUrl": "https://resy.com/cities/new-york-ny/venues/le-gratin",
    "type": "French",
    "neighborhood": "Lower Manhattan",
    "locality": "New York",
    "region": "NY",
    "country": "United States",
    "address": "5 Beekman St",
    "postalCode": "10038",
    "cuisine": ["French"],
    "priceRange": 2,
    "averageSpend": "$85",
    "averageSpendAmount": 85.0,
    "currencyCode": "USD",
    "currencySymbol": "$",
    "rating": 4.63,
    "ratingCount": 6581,
    "minPartySize": 1,
    "maxPartySize": 6,
    "latitude": 40.7116,
    "longitude": -74.0068,
    "phone": "+12125979020",
    "website": "https://www.legratinnyc.com/",
    "socialLinks": [
        { "name": "facebook", "value": "https://www.facebook.com/LeGratinNYC/" },
        { "name": "instagram", "value": "legratinnyc" }
    ],
    "images": [
        "https://image.resy.com/3/003/2/60029/cc549754aa.../jpg/640x360"
        // ... 7 more
    ],
    "description": "Daniel Boulud pays tribute to the hearty, homey cooking of Lyonnais bistros known as bouchons...",
    "metaDescription": "Le Gratin is a French restaurant in the Lower Manhattan neighborhood of New York.",
    "keywords": ["dining", "reservations", "restaurant", "new york", "french"],
    "collections": ["Resy Staff Picks in New York", "Global Dining Access"],
    "venueGroup": "Dinex",
    "awards": [],
    "googlePlaceId": "ChIJj4fN7HBbwokRCB5xca3KF1E",
    "foursquareId": "4f3fd11fe4b00e2d50f2b762",
    "largePartyMessage": "For parties of 7 or more, contact us at infolegratin@danielboulud.com.",
    "waitlistAvailable": 0,
    "timeZone": "EST5EDT",
    "location": "New York",
    "locationCode": "ny",
    "scrapedAt": "2026-03-06T11:00:36.770171+00:00"
}
```

#### Output Example — With Availability

When `includeAvailability` is enabled, each restaurant includes all bookable time slots:

```json
{
    "id": 60029,
    "name": "Le Gratin",
    "url": "https://resy.com/cities/new-york-ny/le-gratin",
    "address": "5 Beekman St",
    "type": "French",
    "averageSpend": "$85",
    "rating": 4.63,
    "phone": "+12125979020",
    "website": "https://www.legratinnyc.com/",
    "slots": [
        {
            "startTime": "2026-03-06 11:30:00",
            "endTime": "2026-03-06 13:00:00",
            "type": "Dining Room",
            "configId": 1045113,
            "hasAddOns": false,
            "shiftDay": "2026-03-06"
        }
        // ... 26 more slots
    ],
    "slotCount": 27
}
```

### Pricing — Pay Per Event (PPE)

One billable event: **restaurant scraped**.

| Tier | Per 1,000 restaurants |
|------|----------------------|
| Regular | $5.99 |
| Bronze | $5.49 |
| Silver | $4.99 |
| Gold | $4.49 |

#### Free Usage

Free plan includes **5 runs** with up to **10 restaurants per run** — enough to evaluate the output before committing.

### How to Scrape Resy Restaurant Data

- **By URL** — Paste restaurant or city pages into `startUrls`
- **By city** — Enter a city name like "New York", "London", or a code like "ny"
- **With filters** — Add a cuisine type or keyword search to narrow results
- **Mix freely** — Combine URLs and city search in the same run

### API Integration

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("your_token")

run = client.actor("clearpath/resy-api").call(run_input={
    "city": "New York",
    "cuisine": "Italian",
    "maxItems": 50,
})

for restaurant in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{restaurant['name']} — {restaurant['rating']}/5 — {restaurant['phone']}")
```

#### JavaScript

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

const client = new ApifyClient({ token: 'your_token' });

const run = await client.actor('clearpath/resy-api').call({
    city: 'Los Angeles',
    includeAvailability: true,
    date: '2026-03-20',
    partySize: 2,
    maxItems: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Found ${items.length} restaurants with availability`);
```

### Advanced Usage

#### Track availability at specific restaurants

```json
{
    "startUrls": [
        "https://resy.com/cities/new-york-ny/carbone"
    ],
    "includeAvailability": true,
    "date": "2026-03-15",
    "partySize": 4
}
```

#### Extract all sushi restaurants in a city

```json
{
    "city": "New York",
    "cuisine": "Sushi",
    "maxItems": 500
}
```

#### Large city export

```json
{
    "city": "London",
    "maxItems": 10000
}
```

### Data Export

Results are available in multiple formats:

- **JSON** — Nested structures (availability slots, images) fully preserved
- **CSV** — Flat fields, arrays serialized
- **Excel** — Spreadsheet-ready

### Automation

- **Scheduled runs** — Daily, weekly, or custom data refreshes
- **Webhooks** — Get notified when a run completes
- **API** — Integrate into your data pipeline programmatically

### FAQ

**Q: What data does Resy Scraper extract?**
A: Full address, phone, website, social links (Facebook, Instagram, Twitter), average spend, ratings, cuisine, GPS coordinates, images, descriptions, venue group, awards, Google Place ID, Foursquare ID, and real-time reservation availability. Over 40 fields per restaurant.

**Q: How many restaurants can I get?**
A: Set `maxItems` up to 50,000. Most major cities have thousands of restaurants on Resy.

**Q: Which cities are supported?**
A: All 1,900+ cities where Resy operates. Covers major markets in the US, UK, and internationally. Enter any city name, code, or URL slug.

**Q: How does availability work?**
A: Enable `includeAvailability`, set a `date` and `partySize`. Each restaurant will include all bookable time slots with start/end times and room types for that date.

**Q: Can I filter by cuisine?**
A: Yes. Select from 15 cuisine types including Italian, Japanese, Steakhouse, Sushi, Mexican, and more. Combine with `query` for keyword search.

**Q: Is there a free trial?**
A: Yes. Free plan includes 5 runs with up to 10 restaurants per run. Enough to evaluate the data quality and format before upgrading.

**Q: Can I schedule recurring runs?**
A: Yes. Use Apify's scheduler for daily, weekly, or custom schedules. Combine with availability to monitor hard-to-book restaurants.

### Getting Started

#### 1. Try it free

1. [Sign up for Apify](https://console.apify.com/sign-up) — no credit card required
2. Open Resy Scraper
3. Enter a city name or paste a Resy URL
4. Click **Start** and inspect the results

#### 2. Configure

1. **Input** — Paste URLs or enter a city name
2. **Filters** — Select a cuisine type or add a search query
3. **Availability** — Enable with a date and party size
4. **Limits** — Control max restaurants per run

#### 3. Scale

1. Use the API for programmatic access
2. Schedule recurring runs for fresh data
3. Set up webhooks for pipeline automation

### Use with AI Assistants (OpenClaw, Claude, etc.)

Connect this actor to AI assistants via [Apify's MCP server](https://mcp.apify.com/). Ask your assistant to find restaurants in natural language.

#### Setup

1. Go to [mcp.apify.com](https://mcp.apify.com/) and add `clearpath/resy-api` to your MCP server
2. Connect the MCP server to your AI assistant ([OpenClaw](https://docs.openclaw.ai/), Claude Desktop, Cursor, etc.)

#### OpenClaw example

Add Apify's MCP server to `~/.openclaw/openclaw.json`:

```json5
{
  "provider": {
    "mcpServers": {
      "apify": {
        "command": "npx",
        "args": ["-y", "@apify/actors-mcp-server"],
        "env": {
          "APIFY_TOKEN": "your-apify-token"
        }
      }
    }
  }
}
```

Then message your OpenClaw bot on Telegram, WhatsApp, or Discord:

> "Find me Italian restaurants in the West Village with outdoor seating"

> "What Japanese restaurants are available in LA this Saturday for 4 people?"

> "Show me the highest-rated steakhouses in Chicago"

The assistant calls the Resy Scraper, gets structured results, and responds with restaurant details, ratings, and availability.

### Legal Compliance

This scraper extracts publicly available data from Resy listings. Users are responsible for complying with Resy's terms of service and applicable data protection regulations (GDPR, CCPA). Use extracted data responsibly and in accordance with local laws.

**Contact data**: Phone numbers are included when publicly listed. Comply with anti-spam regulations when using contact information for outreach.

### Support

- **Email**: max@mapa.slmail.me
- **Bugs**: Issues tab on the Actor page
- **Features**: Email or issues

***

*Complete restaurant intelligence from the world's leading reservation platform.*

# Actor input Schema

## `maxItems` (type: `integer`):

Maximum number of restaurants to scrape. Set a lower value for faster runs.

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

Paste one or more Resy URLs to scrape.<br><br>Supported formats:<br>• City page: <code>https://resy.com/cities/new-york-ny</code><br>• Restaurant page: <code>https://resy.com/cities/new-york-ny/carbone</code><br><br>Leave empty to use the <b>City</b> field instead.

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

City name, code, or URL slug. Use English names (e.g. <code>Munich</code> not <code>München</code>). Supports 1,900+ cities worldwide.<br><br>Examples: <code>New York</code>, <code>ny</code>, <code>los-angeles-ca</code>, <code>London</code>, <code>Munich</code><br><br>Ignored when <b>Resy URLs</b> are provided.

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

Search restaurants by name or keyword. Narrows results within the selected city.<br><br>Examples: <code>Carbone</code>, <code>rooftop</code>, <code>brunch</code>

## `cuisine` (type: `string`):

Filter restaurants by cuisine. Available cuisines vary by city, so some options may return no results in smaller markets.

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

Fetch real-time reservation time slots for each restaurant. Only restaurants with available slots for the given date and party size are returned, so the total result count will be lower than without this enabled.<br><br>Requires <b>Reservation Date</b> and <b>Party Size</b> below.

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

The date to check reservation availability for. Defaults to today if left empty.<br><br>Only used when <b>Include Availability</b> is enabled.

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

Number of guests for the reservation (1–20).<br><br>Only used when <b>Include Availability</b> is enabled.

## Actor input object example

```json
{
  "maxItems": 50,
  "city": "New York",
  "includeAvailability": false,
  "partySize": 2
}
```

# Actor output Schema

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

No description

# 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 = {
    "maxItems": 50,
    "city": "New York"
};

// Run the Actor and wait for it to finish
const run = await client.actor("clearpath/resy-api").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 = {
    "maxItems": 50,
    "city": "New York",
}

# Run the Actor and wait for it to finish
run = client.actor("clearpath/resy-api").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 '{
  "maxItems": 50,
  "city": "New York"
}' |
apify call clearpath/resy-api --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Resy Scraper - Restaurants & Real-Time Availability",
        "description": "Extract restaurant data and real-time reservation availability from Resy. Enter a city or paste URLs. Get ratings, cuisine, contact info, images, descriptions, waitlist status, and bookable time slots across 1,900+ cities. Export as JSON, CSV, or Excel.",
        "version": "0.0",
        "x-build-id": "bLF5kYrIWSEN5wRZo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/clearpath~resy-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-clearpath-resy-api",
                "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/clearpath~resy-api/runs": {
            "post": {
                "operationId": "runs-sync-clearpath-resy-api",
                "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/clearpath~resy-api/run-sync": {
            "post": {
                "operationId": "run-sync-clearpath-resy-api",
                "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": {
                    "maxItems": {
                        "title": "Max Restaurants",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of restaurants to scrape. Set a lower value for faster runs.",
                        "default": 100
                    },
                    "startUrls": {
                        "title": "Resy URLs",
                        "type": "array",
                        "description": "Paste one or more Resy URLs to scrape.<br><br>Supported formats:<br>• City page: <code>https://resy.com/cities/new-york-ny</code><br>• Restaurant page: <code>https://resy.com/cities/new-york-ny/carbone</code><br><br>Leave empty to use the <b>City</b> field instead.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City name, code, or URL slug. Use English names (e.g. <code>Munich</code> not <code>München</code>). Supports 1,900+ cities worldwide.<br><br>Examples: <code>New York</code>, <code>ny</code>, <code>los-angeles-ca</code>, <code>London</code>, <code>Munich</code><br><br>Ignored when <b>Resy URLs</b> are provided."
                    },
                    "query": {
                        "title": "Keyword Search",
                        "type": "string",
                        "description": "Search restaurants by name or keyword. Narrows results within the selected city.<br><br>Examples: <code>Carbone</code>, <code>rooftop</code>, <code>brunch</code>"
                    },
                    "cuisine": {
                        "title": "Cuisine Type",
                        "enum": [
                            "American",
                            "Asian",
                            "Chinese",
                            "French",
                            "Indian",
                            "Italian",
                            "Japanese",
                            "Korean",
                            "Mediterranean",
                            "Mexican",
                            "Middle Eastern",
                            "Seafood",
                            "Steakhouse",
                            "Sushi",
                            "Thai"
                        ],
                        "type": "string",
                        "description": "Filter restaurants by cuisine. Available cuisines vary by city, so some options may return no results in smaller markets."
                    },
                    "includeAvailability": {
                        "title": "Include Availability (reduces results to restaurants with open slots)",
                        "type": "boolean",
                        "description": "Fetch real-time reservation time slots for each restaurant. Only restaurants with available slots for the given date and party size are returned, so the total result count will be lower than without this enabled.<br><br>Requires <b>Reservation Date</b> and <b>Party Size</b> below.",
                        "default": false
                    },
                    "date": {
                        "title": "Reservation Date",
                        "type": "string",
                        "description": "The date to check reservation availability for. Defaults to today if left empty.<br><br>Only used when <b>Include Availability</b> is enabled."
                    },
                    "partySize": {
                        "title": "Party Size",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Number of guests for the reservation (1–20).<br><br>Only used when <b>Include Availability</b> 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
