# Resy Restaurants & Availability Scraper (`fetch_cat/resy-restaurants-availability-scraper`) Actor

🍽️ Find public Resy restaurant profiles and availability by city, keyword, or URL. Export venue data for hospitality and travel research.

- **URL**: https://apify.com/fetch\_cat/resy-restaurants-availability-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Travel, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.02 / 1,000 venue rows

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Restaurants & Availability Scraper

Find Resy restaurants, venue details, and public reservation availability by city, neighborhood, keyword, or Resy URL.

### What does Resy Restaurants & Availability Scraper do?

This Apify Actor helps you collect public restaurant information from Resy searches.
It returns venue profiles together with optional public availability times for a selected date and party size.
Use it to monitor dining markets, build hospitality datasets, enrich travel products, or research restaurants in Resy-supported cities.

### Who is this Resy scraper for?

- 🍽️ Restaurant market-intelligence teams tracking local dining supply
- 🏨 Hotel concierge and travel teams building recommendation lists
- 📍 Local lead-generation teams finding restaurants by city or cuisine
- 📊 Hospitality analysts comparing neighborhoods, cuisines, and price ranges
- 🧭 Travel apps that need structured venue discovery data
- 🧪 Data teams prototyping Resy-based market research workflows

### Why use this actor?

- Search by city, neighborhood, cuisine, keyword, or Resy URL
- Save structured venue rows to an Apify dataset
- Include public availability timestamps when Resy exposes them
- Export to JSON, CSV, Excel, Google Sheets, S3, or your own API
- Run on demand, schedule daily checks, or integrate from code

### What data can it extract?

| Field | Description |
| --- | --- |
| `venueId` | Resy venue ID |
| `name` | Restaurant name |
| `url` | Public Resy venue URL |
| `city` | Resy city/location |
| `neighborhood` | Neighborhood when available |
| `address` | Formatted public address when available |
| `latitude` | Venue latitude |
| `longitude` | Venue longitude |
| `cuisine` | Cuisine labels |
| `priceRange` | Dollar-sign price range |
| `venueDescription` | Public Resy description/editorial note |
| `images` | Venue image URLs |
| `tags` | Cuisine and collection tags |
| `availabilityDate` | Date checked |
| `partySize` | Party size checked |
| `availableTimes` | Public reservation start times |
| `sourceUrl` | Search URL or generated source URL |
| `scrapedAt` | Timestamp when the row was saved |

### Pricing

This Actor uses Apify pay-per-event pricing. The prices below come from the current Actor pricing configuration. Apify public plans map to Store discount tiers, so the table shows both the user-facing plan context and the pricing tier name. The final price shown in Apify depends on the user account plan and any custom agreement.

| Event | What is charged | Price |
| --- | --- | ---: |
| `start` | One-time fee per run | $0.005 |

| Event | What is charged | Free / no discount | Starter / Bronze | Scale / Silver | Business / Gold | Custom / Platinum | Custom / Diamond |
| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |
| `apify-default-dataset-item` | Per Resy venue row saved to the default dataset | $0.03558 / 1,000 | $0.03094 / 1,000 | $0.02413 / 1,000 | $0.01856 / 1,000 | $0.01238 / 1,000 | $0.01 / 1,000 |

Apify may also charge platform usage for compute, storage, proxies, or data transfer outside this Actor pricing. Check the Actor run and the Apify Pricing tab for the exact cost shown to your account.

### How to scrape Resy restaurants

1. Open the actor on Apify.
2. Enter a city, neighborhood, cuisine, keyword, or Resy URL.
3. Choose a date and party size if you want availability times.
4. Set `maxResults` to the number of venue rows you need.
5. Run the actor.
6. Download the dataset or connect it to your workflow.

### Input settings

#### `cityOrLocation`

Use a city, neighborhood, restaurant keyword, or cuisine term.
Examples:

- `New York`
- `Brooklyn sushi`
- `Chicago steakhouse`
- `Los Angeles Italian`

#### `searchUrl`

Paste a Resy city, search, or venue URL when you want to anchor the run to a known Resy page.
If `cityOrLocation` is empty, the actor derives a search term from this URL.

#### `date`

Use `YYYY-MM-DD` format.
If omitted, the actor checks the current date.

#### `partySize`

The number of diners for availability checks.
The default is 2.

#### `includeAvailability`

When enabled, the actor checks public availability for each venue.
When disabled, the actor only returns venue profile fields and runs faster.

#### `maxResults`

Maximum number of venue rows to save.
Use a low value for test runs.

#### `proxyConfiguration`

Proxy use is optional.
Most public searches work without a proxy.
If your run is blocked, try Apify Proxy with datacenter proxies before residential proxies.

### Example input

```json
{
  "cityOrLocation": "New York",
  "date": "2026-07-05",
  "partySize": 2,
  "includeAvailability": true,
  "maxResults": 25,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

### Example output

```json
{
  "venueId": "87134",
  "name": "Brooklyn Chop House - Downtown FIDI",
  "url": "https://resy.com/cities/new-york-ny/venues/brooklyn-chop-house-downtown-fidi",
  "city": "New York",
  "neighborhood": "Financial District",
  "address": null,
  "latitude": 40.71164941860875,
  "longitude": -74.00596236132077,
  "cuisine": ["Steakhouse"],
  "priceRange": "$$$",
  "venueDescription": "Only in New York does a chop house serve LSD...",
  "images": ["https://image.resy.com/..."],
  "tags": ["Steakhouse"],
  "availabilityDate": "2026-07-05",
  "partySize": 2,
  "availableTimes": [],
  "availabilityStatus": "no_slots",
  "availabilityError": null,
  "sourceUrl": "https://resy.com/cities/new-york",
  "scrapedAt": "2026-07-05T08:00:00.000Z"
}
```

### Tips for better Resy results

- Use broad city searches first, then narrow by cuisine or neighborhood.
- Keep `maxResults` low while testing a new market.
- Disable availability if you only need venue profile data.
- Use a future `date` when checking reservation availability.
- Run the actor daily if you need trend monitoring.

### Availability status

Availability is public and can change quickly.
A venue can appear in search but have no public slots for your selected date and party size. In that case `availabilityStatus` is `no_slots`.

`availabilityStatus` is `available` when times were found, `unavailable` when the venue did not provide the location data needed for a lookup, `lookup_failed` when the optional lookup could not be completed, and `not_requested` when `includeAvailability` is disabled. Check this field before treating an empty `availableTimes` array as no availability.

### Common use cases

- Build a local restaurant lead list
- Monitor new restaurants in a city
- Compare Resy coverage by neighborhood
- Track available dining slots for concierge planning
- Enrich travel guides with restaurant profile data
- Analyze cuisine and price distribution in a market

### Integrations

You can connect the dataset to:

- Google Sheets for operations teams
- BigQuery or Snowflake for analytics
- Zapier or Make for alerts
- Slack for availability monitoring
- S3 for archival exports
- Your backend through the Apify API

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/resy-restaurants-availability-scraper').call({
  cityOrLocation: 'New York',
  date: '2026-07-05',
  partySize: 2,
  maxResults: 25
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('fetch_cat/resy-restaurants-availability-scraper').call(run_input={
    'cityOrLocation': 'New York',
    'date': '2026-07-05',
    'partySize': 2,
    'maxResults': 25,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~resy-restaurants-availability-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"cityOrLocation":"New York","date":"2026-07-05","partySize":2,"maxResults":25}'
```

### MCP usage

Use the Apify MCP server with tools enabled for this actor:

```text
https://mcp.apify.com/?tools=fetch_cat/resy-restaurants-availability-scraper
```

Claude Code setup:

```bash
claude mcp add apify-resy --url "https://mcp.apify.com/?tools=fetch_cat/resy-restaurants-availability-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-resy": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/resy-restaurants-availability-scraper"
    }
  }
}
```

Example prompts:

- "Find 25 Resy restaurants in New York and summarize cuisines."
- "Check public Resy availability for Chicago steakhouse results tomorrow."
- "Export the Resy venue dataset to a table grouped by neighborhood."

### Scheduling

Schedule recurring runs to monitor restaurant availability or new venue search results.
Daily runs are useful for concierge teams and market analysts.
Weekly runs are usually enough for broad venue discovery.

### Data freshness

The actor collects live public data at run time.
Restaurant profiles and availability can change after your run finishes.
For operational decisions, rerun close to the time you need the data.

### Limits

- The actor returns public Resy data only.
- It does not book reservations.
- It does not log in to user accounts.
- Some venues may not expose availability for every date or party size.
- Very narrow searches may return fewer rows than `maxResults`.

### Legality

This actor collects public restaurant discovery data and does not perform bookings, account actions, or private-data access.

### Legal and ethical use

This actor is designed for public restaurant discovery data.
Use the results responsibly and follow Apify's Terms of Service, Resy's public website terms, and applicable laws.
Do not use the actor for spam, harassment, credentialed access, or automated booking abuse.

### FAQ

#### Does this actor book reservations?

No. It only extracts public venue and availability information. It does not place holds, complete bookings, or access private accounts.

#### Can I monitor the same city every day?

Yes. Use an Apify schedule and keep `maxResults` aligned with the size of the market you want to monitor.

### Troubleshooting

#### Why are `availableTimes` empty?

The venue may not have public slots for the selected date and party size, or availability may have changed before the lookup.
Try a future date, a different party size, or disable availability if you only need venue profiles.

#### Why did I get fewer rows than requested?

The search term may be too narrow.
Use a broader city or cuisine query, then filter the dataset after export.

#### Should I use a proxy?

Start without a proxy.
If a run is blocked, enable Apify Proxy and try datacenter proxies first.

### Related Actors

- [Google Maps Lead Finder](https://apify.com/fetch_cat/google-maps-lead-finder)
- [Apple Maps Places Scraper](https://apify.com/fetch_cat/apple-maps-places-scraper)
- [Airbnb Listings Scraper](https://apify.com/fetch_cat/airbnb-listings-scraper)

### Support

For support, include the **run ID or run URL**, the **input JSON**, the **expected output**, and the **actual output**. Include a **reproducible public URL** (for example, the relevant Resy city, search, or venue URL) whenever possible. Do not include account credentials or reservation details.

### Field reference recap

- venue identity
- public URL
- location
- cuisine
- price range
- description
- images
- tags
- availability date
- party size
- available times
- source URL
- scrape timestamp

### Best first run

Use this small input to verify output quality before scaling:

```json
{
  "cityOrLocation": "New York",
  "date": "2026-07-05",
  "partySize": 2,
  "includeAvailability": true,
  "maxResults": 10
}
```

### Privacy and data handling

This Actor runs with Apify limited permissions and only processes data needed for the documented run. It uses the inputs you provide and the public records needed to produce the documented dataset to produce the output dataset and sends requests to public Resy Restaurants Availability pages/endpoints; results are stored in Apify run storage for your account. FetchCat does not use your inputs or outputs for advertising, does not use them for model training, and does not retain them outside the Apify run except for transient support debugging when you explicitly share run details. You are responsible for using the Actor lawfully, respecting the target site's terms, and avoiding unnecessary personal or sensitive data in inputs.

# Actor input Schema

## `cityOrLocation` (type: `string`):

Search term to use on Resy, such as a city, neighborhood, cuisine, or restaurant keyword.

## `searchUrl` (type: `string`):

Optional Resy URL. If provided without a city/location, the actor derives a search term from the URL.

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

Date to check for public table availability in YYYY-MM-DD format. Defaults to today when omitted.

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

Number of diners for availability checks.

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

When enabled, the actor makes one lightweight availability lookup per venue and returns available table times when Resy exposes them publicly.

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

Maximum number of venue rows to save.

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

Optional Apify Proxy configuration. Datacenter proxies are usually sufficient; use residential only if your run is blocked.

## Actor input object example

```json
{
  "cityOrLocation": "New York",
  "searchUrl": "https://resy.com/cities/new-york-ny",
  "date": "2026-07-05",
  "partySize": 2,
  "includeAvailability": true,
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

## `runSummary` (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 = {
    "cityOrLocation": "New York",
    "searchUrl": "https://resy.com/cities/new-york-ny",
    "date": "2026-07-05",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/resy-restaurants-availability-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 = {
    "cityOrLocation": "New York",
    "searchUrl": "https://resy.com/cities/new-york-ny",
    "date": "2026-07-05",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/resy-restaurants-availability-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 '{
  "cityOrLocation": "New York",
  "searchUrl": "https://resy.com/cities/new-york-ny",
  "date": "2026-07-05",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call fetch_cat/resy-restaurants-availability-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/romMDWKVIwHVvZYNV/builds/68HeUUcVKSu2JHhOD/openapi.json