# 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 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 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 it for?

Resy Restaurants & Availability Scraper is built for teams that need structured restaurant discovery data without manually searching Resy page by page.

### 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 |

### How much does it cost to scrape Resy restaurants?

The actor uses pay-per-event pricing.
There is a small run-start charge and a per-venue charge for each saved restaurant row.
Your total cost depends mainly on `maxResults` and whether you enable availability checks.
Start with a small run such as 25 venues, confirm the output, then scale your search.

### 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 options

#### `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": [],
  "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 notes

Availability is public and can change quickly.
A venue may appear in search but have no public slots for your selected date and party size.
In that case, the row is still useful because it contains venue profile and location fields.

### 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 with 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);
```

### API usage with 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'])
```

### API usage with 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 scrapers

- https://apify.com/fetch\_cat/google-maps-lead-finder
- https://apify.com/fetch\_cat/apple-maps-places-scraper
- https://apify.com/fetch\_cat/airbnb-listings-scraper

### Changelog

#### 0.1

- Initial Resy venue search and public availability extraction.

### Support

If you need a new field or a specific Resy workflow, open an Apify issue with a sample input and expected output.

### 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
}
```

# 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

# 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

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Resy Restaurants & Availability Scraper",
        "description": "🍽️ Find public Resy restaurant profiles and availability by city, keyword, or URL. Export venue data for hospitality and travel research.",
        "version": "0.1",
        "x-build-id": "ACFCMt8v5VfQ1pHQ3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~resy-restaurants-availability-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-resy-restaurants-availability-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/fetch_cat~resy-restaurants-availability-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-resy-restaurants-availability-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/fetch_cat~resy-restaurants-availability-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-resy-restaurants-availability-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": {
                    "cityOrLocation": {
                        "title": "City, neighborhood, or keyword",
                        "type": "string",
                        "description": "Search term to use on Resy, such as a city, neighborhood, cuisine, or restaurant keyword."
                    },
                    "searchUrl": {
                        "title": "Resy search or city URL",
                        "type": "string",
                        "description": "Optional Resy URL. If provided without a city/location, the actor derives a search term from the URL."
                    },
                    "date": {
                        "title": "Availability date",
                        "type": "string",
                        "description": "Date to check for public table availability in YYYY-MM-DD format. Defaults to today when omitted."
                    },
                    "partySize": {
                        "title": "Party size",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Number of diners for availability checks.",
                        "default": 2
                    },
                    "includeAvailability": {
                        "title": "Include availability times",
                        "type": "boolean",
                        "description": "When enabled, the actor makes one lightweight availability lookup per venue and returns available table times when Resy exposes them publicly.",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Maximum venues",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of venue rows to save.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy configuration. Datacenter proxies are usually sufficient; use residential only if your run is blocked."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
