# Resy Availability Checker (`parsebird/resy-availability-checker`) Actor

Check Resy reservation availability for any restaurant, date and party size. Get open time slots, seating types and booking tokens, or a clear sold-out status. Monitor tables on a schedule via API. Export JSON, CSV, Excel.

- **URL**: https://apify.com/parsebird/resy-availability-checker.md
- **Developed by:** [ParseBird](https://apify.com/parsebird) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.79 / 1,000 availability checks

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

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

### Resy Availability Checker

**Resy Availability Checker** shows which reservation times are open on [Resy](https://resy.com) for any restaurant, date and party size, and returns them as structured data. You don't need a Resy account, a login or an API key.

<table><tr>
<td style="border-left:4px solid #1C1917;padding:12px 16px;font-weight:600">
Check up to 10 Resy restaurants per run and get every open time slot with its seating type and Resy token, plus a status that separates sold-out, closed and not-yet-released days, so a failed check is never mistaken for a full restaurant.
</td>
</tr></table>

##### Copy to your AI assistant

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

```
Apify Actor: parsebird/resy-availability-checker. Checks open reservation slots on resy.com for specific restaurants, without login. Call via ApifyClient: client.actor("parsebird/resy-availability-checker").call(run_input={"startUrls": [{"url": "https://resy.com/cities/new-york-ny/le-gratin"}, {"url": "https://resy.com/cities/new-york-ny/carbone"}], "date": "2026-11-20", "partySize": 4}). Inputs: startUrls ({url}[], required, 1-10 Resy restaurant pages such as https://resy.com/cities/new-york-ny/carbone; city and search pages are not supported), date (string YYYY-MM-DD, optional, defaults to today in each restaurant's time zone; past dates are not checked), partySize (integer 1-20, default 2). Output: one dataset row per restaurant with venueId, name, urlSlug, url, date, partySize, slotCount, availabilityStatus ("available" | "sold-out" | "closed" | "not-available" | "not-released" | "party-size-not-accepted"), slots ({startTime, endTime, type, token, configId}[]), checkedAt. Restaurants that could not be checked are left out and listed in the run log. Pricing: pay per restaurant checked, plus a start event per run. Full API spec: https://apify.com/parsebird/resy-availability-checker/api. Get your token: https://console.apify.com/settings/integrations.
```

### What is Resy Availability Checker?

**Resy Availability Checker** is a Resy availability API alternative for people who want to track open tables instead of refreshing a restaurant's page. Paste one or more [Resy](https://resy.com) restaurant URLs, pick a date and party size, and click **Start**. To try it, keep the prefilled restaurants and press **Start** to see today's open tables at Le Gratin and Carbone in New York.

You get one row per restaurant, with **every open time slot and its seating type**. Download the results as **JSON, CSV or Excel**, or read them through the [Apify API](https://docs.apify.com/api/v2).

### What can Resy Availability Checker do?

- 🍽️ **Check any date and party size.** Availability on Resy changes with party size, so the party size you set is the one that gets checked.
- 🚦 **Explain an empty result.** A restaurant with no open slots gets a status: sold out, closed, not yet released, party size not accepted or not available.
- 🛡️ **Never guess.** If a check fails or Resy's answer doesn't confirm the status, the restaurant is left out of the results and named in the run log. It isn't reported as sold out, and it isn't charged.
- 🌍 **Use each restaurant's local date.** Leave the date empty and "today" means today where the restaurant is, even when one run covers several time zones.
- 🧹 **Skip duplicates.** The same restaurant entered twice, even through different URL formats, is checked and charged once.

Because it runs on Apify, you also get:

- [Scheduling](https://docs.apify.com/platform/schedules) to check tables every hour, every day or at any interval
- [API access](https://docs.apify.com/api/v2) with [Python](https://docs.apify.com/api/client/python) and [JavaScript](https://docs.apify.com/api/client/js) clients
- [Integrations](https://docs.apify.com/platform/integrations) with Make, Zapier, Google Sheets, Slack and [webhooks](https://docs.apify.com/platform/integrations/webhooks)
- Export to JSON, CSV, Excel, XML and HTML

### What data can you extract from Resy?

| Field | Description |
|-------|-------------|
| `venueId` | Resy's ID for the restaurant |
| `name` | Restaurant name |
| `urlSlug` | The restaurant's name in its Resy URL |
| `url` | Link to the restaurant on Resy |
| `date` | The date checked |
| `partySize` | The party size checked |
| `slotCount` | Number of open time slots |
| `availabilityStatus` | Why the restaurant does or doesn't have slots (see below) |
| `slots[].startTime`, `slots[].endTime` | Slot start and end, in the restaurant's local time |
| `slots[].type` | Seating type as the restaurant names it, such as `Dining Room`, `Patio` or `Chef Counter` |
| `slots[].token` | Resy's identifier for that slot |
| `slots[].configId` | Resy's ID for the seating configuration. Resy leaves it empty for some restaurants, so it can be `null` |
| `checkedAt` | When the check ran, in UTC |

`availabilityStatus` is one of:

| Status | Meaning |
|--------|---------|
| `available` | Resy returned open slots |
| `sold-out` | Resy's calendar marks reservations for this day and party size as sold out |
| `closed` | Resy's calendar marks the restaurant as closed that day |
| `not-released` | The date is after the last day on the restaurant's Resy calendar. Tables may open later |
| `not-available` | Resy lists no reservations for that day, for example when a day only has a special event. Tables may still open later |
| `party-size-not-accepted` | The party size is outside the limits the restaurant sets on Resy |

Every status except `available` has `slotCount: 0`.

### How to check Resy availability step by step

1. Open [Resy Availability Checker](https://apify.com/parsebird/resy-availability-checker) and sign in to Apify.
2. Find your restaurant on [resy.com](https://resy.com) and copy its URL, such as `https://resy.com/cities/new-york-ny/carbone`.
3. Add up to 10 URLs under **Resy restaurant URLs**.
4. Pick a **Date**, or leave it empty to check today.
5. Set the **Party size**.
6. Click **Start**. The run takes seconds.
7. Download your Resy availability data as JSON, CSV or Excel from the **Output** tab.

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| startUrls | array | **Yes** | — | 1 to 10 Resy restaurant pages. City and search pages are not supported. |
| date | string | No | Today | Date to check, as `YYYY-MM-DD`. Empty means today in each restaurant's time zone. Past dates are not checked. |
| partySize | integer | No | 2 | Number of guests, from 1 to 20. |

Check availability for today:

```json
{
    "startUrls": [
        { "url": "https://resy.com/cities/new-york-ny/le-gratin" }
    ],
    "partySize": 2
}
```

Check several restaurants on one date:

```json
{
    "startUrls": [
        { "url": "https://resy.com/cities/new-york-ny/le-gratin" },
        { "url": "https://resy.com/cities/new-york-ny/carbone" },
        { "url": "https://resy.com/cities/new-york-ny/tsubame" }
    ],
    "date": "2026-11-20",
    "partySize": 4
}
```

### Output example

A restaurant with open tables:

```json
{
    "venueId": 88840,
    "name": "Tsubame",
    "urlSlug": "tsubame",
    "url": "https://resy.com/cities/new-york-ny/tsubame",
    "date": "2026-11-12",
    "partySize": 2,
    "slotCount": 2,
    "availabilityStatus": "available",
    "slots": [
        {
            "startTime": "2026-11-12 17:30:00",
            "endTime": "2026-11-12 20:00:00",
            "type": "Chef Counter",
            "token": "rgs://resy/88840/3594091/2/2026-11-12/2026-11-12/17:30:00/2/Dining Room",
            "configId": 1884291
        },
        {
            "startTime": "2026-11-12 20:00:00",
            "endTime": "2026-11-12 22:30:00",
            "type": "Chef Counter",
            "token": "rgs://resy/88840/3594091/2/2026-11-12/2026-11-12/20:00:00/2/Dining Room",
            "configId": 1884291
        }
    ],
    "checkedAt": "2026-11-07T05:18:49.783426+00:00"
}
```

A sold-out restaurant:

```json
{
    "venueId": 6194,
    "name": "Carbone",
    "urlSlug": "carbone",
    "url": "https://resy.com/cities/new-york-ny/carbone",
    "date": "2026-11-12",
    "partySize": 2,
    "slotCount": 0,
    "availabilityStatus": "sold-out",
    "slots": [],
    "checkedAt": "2026-11-07T05:18:45.298181+00:00"
}
```

### How to use the Resy availability API in Python and JavaScript

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

run = client.actor("parsebird/resy-availability-checker").call(run_input={
    "startUrls": [
        {"url": "https://resy.com/cities/new-york-ny/le-gratin"},
        {"url": "https://resy.com/cities/new-york-ny/carbone"},
    ],
    "date": "2026-11-20",
    "partySize": 4,
})

for venue in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(venue["name"], venue["availabilityStatus"], venue["slotCount"])
    for slot in venue["slots"]:
        print(" ", slot["startTime"], slot["type"])
```

**JavaScript**

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

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });

const run = await client.actor('parsebird/resy-availability-checker').call({
    startUrls: [
        { url: 'https://resy.com/cities/new-york-ny/le-gratin' },
        { url: 'https://resy.com/cities/new-york-ny/carbone' },
    ],
    date: '2026-11-20',
    partySize: 4,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((venue) => {
    console.log(venue.name, venue.availabilityStatus, venue.slotCount);
    venue.slots.forEach((slot) => console.log(' ', slot.startTime, slot.type));
});
```

Get your token in [Apify Console](https://console.apify.com/settings/integrations). See every option on the [API tab](https://apify.com/parsebird/resy-availability-checker/api).

### Use cases

- **Table monitoring:** schedule runs and send the results to Slack or email through an integration when a sold-out restaurant shows open slots.
- **Personal assistants and AI agents:** give an agent a simple way to answer "is there a table for four on Friday?"
- **Concierge and travel services:** check several restaurants for a client's date and party size at once.
- **Hospitality research:** track how far ahead restaurants sell out, or how many slots they open by day and party size.

### How does Resy Availability Checker work?

1. It reads each Resy restaurant URL and skips duplicates and pages that aren't restaurants.
2. It asks Resy for the open slots on your date and party size.
3. If there are none, it checks Resy's calendar and the restaurant's party limits to find out why.
4. It saves one row per restaurant, in the order you entered them.
5. It lists every restaurant it couldn't check in the run log, and it doesn't charge for them.

### How much does it cost to check Resy availability?

Resy Availability Checker uses pay-per-event pricing. Compute and proxy costs are included in the event price.

| Event | Free | Bronze | Silver | Gold |
|-------|------|--------|--------|------|
| `availability-checked`, per 1,000 | **$0.99** | **$0.89** | **$0.79** | **$0.79** |
| `apify-actor-start`, per run | $0.005 | $0.005 | $0.005 | $0.005 |

An `availability-checked` event fires for each restaurant saved to your results, including sold-out and closed ones. Restaurants that couldn't be checked, duplicates and invalid URLs cost nothing. The start event fires once per run.

On the Free tier, one run checking 10 restaurants costs about $0.015. Because the start fee is per run, it's cheaper to put several restaurants in one run than to start a run for each. To cap your spending, set a maximum cost per run in the run options. The run stops at that limit and keeps what it saved.

### Is it legal to scrape Resy?

Resy Availability Checker only reads availability that Resy shows publicly, without logging in, and it doesn't collect personal data. Web scraping of public data is generally legal, but what you may do with the data depends on your purpose and your country. You can read more in [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/) Check [Resy's terms](https://resy.com/terms) too, and ask a lawyer if you are unsure. This section is not legal advice.

### Other restaurant scrapers you may like

- [OpenTable Restaurants Scraper](https://apify.com/parsebird/opentable-restaurants-scraper): cuisine, price, rating, address, phone and photos from OpenTable
- [OpenTable Reviews Scraper](https://apify.com/parsebird/opentable-reviews-scraper): ratings, review text and restaurant replies from OpenTable
- [TheFork Scraper](https://apify.com/parsebird/thefork-scraper): restaurant data, menus and reviews from TheFork

### FAQ

**Do I need a Resy account or an API key?**
No. The Actor only reads what Resy shows to any visitor.

**Can this Actor book a table?**
No. It only checks availability, and it never logs in or makes a reservation. Book on [resy.com](https://resy.com) or in the Resy app.

**Will it alert me when a table opens up?**
Not by itself. Run it on a [schedule](https://docs.apify.com/platform/schedules), then connect an [integration](https://docs.apify.com/platform/integrations) or [webhook](https://docs.apify.com/platform/integrations/webhooks) to act on the results.

**What does `sold-out` mean compared with `not-released`?**
`sold-out` means Resy's calendar lists the day and all its tables are gone for your party size. `not-released` means the date is after the last day on the restaurant's calendar, so it's worth checking again later.

**When are reservations released on Resy?**
It depends on the restaurant. On November 7, 2026, the regular calendar ran to December 6 at Le Gratin and Carbone (30 days ahead) and to November 26 at 4 Charles Prime Rib (20 days ahead). Some restaurants also list single dates further out for special events. For those, days before the event can show `not-available` instead of `not-released`.

**Why is a restaurant missing from my results?**
Check the run log. A restaurant is left out when its page no longer exists on Resy, the URL has the wrong city, the date has already passed at that restaurant, or Resy didn't give a clear answer. You aren't charged for it. A restaurant that has left Resy shows `Resy has no active restaurant at this URL`.

**Which URLs work?**
Restaurant pages such as `https://resy.com/cities/new-york-ny/carbone` and `https://resy.com/cities/new-york-ny/venues/carbone`. City pages and search pages don't work. Any `date` or `seats` values in the URL are ignored, so set the date and party size in the input.

**Does it work outside New York?**
Yes. We tested restaurants in New York, Los Angeles, Honolulu, Mexico City, Madrid and Tokyo. Slot times are always in the restaurant's local time.

**Why do I see the same time more than once?**
Some restaurants offer the same time in different seating areas, such as `Dining Room` and `Outdoor Dining`. Each one is its own slot and counts toward `slotCount`.

**Why did the party size change the result so much?**
Restaurants hold different tables for different party sizes, and each sets its own limits on Resy. If your party is over a restaurant's limit, the status is `party-size-not-accepted`.

**Can I check more than 10 restaurants?**
Each run takes up to 10. Start more runs for longer lists.

**Can I schedule recurring runs?**
Yes. Use [Apify Schedules](https://docs.apify.com/platform/schedules) to run hourly, daily or at any interval. Leave the date empty so each run checks that day.

**Something doesn't work. Where do I report it?**
Open a ticket on the [Issues tab](https://apify.com/parsebird/resy-availability-checker/issues). Include your run link so we can look into it.

# Changelog

This Actor's version history is a separate document: https://apify.com/parsebird/resy-availability-checker/changelog.md

# Actor input Schema

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

Add 1 to 10 Resy restaurant pages, such as https://resy.com/cities/new-york-ny/carbone. City pages and search pages are not supported. A restaurant added twice is checked and charged once.

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

Pick the day to check, as YYYY-MM-DD. Leave it empty to check today in each restaurant's own time zone. Past dates are not checked.

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

Set the number of guests, from 1 to 20. Availability changes with party size, because each restaurant has its own table sizes and limits.

## Actor input object example

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

# Actor output Schema

## `dataset` (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 = {
    "startUrls": [
        {
            "url": "https://resy.com/cities/new-york-ny/le-gratin"
        },
        {
            "url": "https://resy.com/cities/new-york-ny/carbone"
        }
    ],
    "partySize": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/resy-availability-checker").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 = {
    "startUrls": [
        { "url": "https://resy.com/cities/new-york-ny/le-gratin" },
        { "url": "https://resy.com/cities/new-york-ny/carbone" },
    ],
    "partySize": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/resy-availability-checker").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://resy.com/cities/new-york-ny/le-gratin"
    },
    {
      "url": "https://resy.com/cities/new-york-ny/carbone"
    }
  ],
  "partySize": 2
}' |
apify call parsebird/resy-availability-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parsebird/resy-availability-checker"
        }
    }
}
```

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

## OpenAPI specification

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