# Resy Restaurant Scraper (`automation-lab/resy-restaurant-scraper`) Actor

Extract public Resy restaurant venue data, search results, ratings, cuisine, locations, price bands, and availability metadata. Export JSON, CSV, or Excel.

- **URL**: https://apify.com/automation-lab/resy-restaurant-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 Restaurant Scraper

Extract public Resy restaurant venue details, discovery results, and read-only availability metadata with a simple Apify Actor.

Use it to monitor restaurants, dining markets, cuisine coverage, price bands, ratings, neighborhoods, and availability signals without building your own Resy API client.

### What does Resy Restaurant Scraper do?

Resy Restaurant Scraper collects structured venue rows from public Resy surfaces.

It can:

- 🔎 Search Resy by restaurant name, cuisine, city, or market phrase.
- 🧾 Fetch known numeric Resy venue IDs directly.
- 🗺️ Return city, neighborhood, latitude, longitude, cuisine, and price metadata.
- ⭐ Include rating averages and rating counts when Resy returns them.
- 📞 Include public contact information such as phone numbers.
- 📅 Optionally check read-only public availability metadata for a date and party size.
- 📦 Export clean JSON, CSV, Excel, XML, RSS, or API dataset results from Apify.

### Who is it for?

Hospitality analysts use it to track venue coverage and premium dining patterns.

Travel and concierge teams use it to build shortlists of restaurants in target cities.

Restaurant agencies use it to monitor client and competitor metadata.

Local SEO teams use it to compare cuisine, neighborhood, and rating signals.

Data teams use it to enrich internal restaurant databases with public Resy identifiers.

### Why use this actor?

Resy data is useful, but public pages are JavaScript shells and manual collection is slow.

This actor uses Resy's public read endpoints over HTTP, so it is lightweight and does not require a browser session.

You get normalized rows that are ready for spreadsheets, dashboards, lead lists, enrichment workflows, and monitoring jobs.

### What data can it extract?

| Field | Description |
| --- | --- |
| `venueId` | Numeric Resy venue identifier |
| `name` | Restaurant name |
| `url` | Resy venue URL when available |
| `source` | `search`, `venueId`, or `venueUrl` |
| `searchQuery` | Search query that found the venue |
| `city` | City or Resy location name |
| `neighborhood` | Neighborhood returned by Resy |
| `latitude` / `longitude` | Geographic coordinates |
| `cuisine` | Cuisine or restaurant type array |
| `priceRange` | Resy price band |
| `averageBillSize` | Average bill size when returned |
| `ratingAverage` | Rating average |
| `ratingCount` | Number of ratings |
| `phoneNumber` | Public phone number |
| `collections` | Resy collection names |
| `availableSlotCount` | Public slot count for requested date and party size |
| `availableTimes` | Public available times when returned |
| `scrapedAt` | ISO timestamp for the run |

### How much does it cost to scrape Resy restaurant data?

The actor uses Apify pay-per-event pricing.

A small start event covers each run.

A per-item event is charged for each saved restaurant row.

For most small monitoring runs, the total cost is designed to be around cents per batch rather than dollars.

Exact pricing is shown on the Apify Store page before you run the actor.

### How to use it

1. Open the actor on Apify.
2. Add one or more search queries such as `rezdora`, `new york italian`, or `los angeles sushi`.
3. Optionally add known numeric Resy venue IDs.
4. Set `maxItems` to the number of restaurants you want.
5. Enable availability metadata only if you need date and party-size signals.
6. Click **Start**.
7. Export the dataset or consume it through the Apify API.

### Input options

#### Search queries

Use `searchQueries` when you want discovery.

Examples:

- `rezdora`
- `new york italian`
- `los angeles sushi`
- `chicago steakhouse`

#### Venue IDs

Use `venueIds` when you already know numeric Resy IDs.

Example:

```json
{
  "venueIds": ["443"],
  "maxItems": 1
}
````

#### Venue URLs

Use `venueUrls` only when the URL contains a numeric `id` or `venue_id` parameter.

Slug-only Resy URLs often do not expose the numeric ID in the URL, so search queries are usually better.

#### Availability metadata

Set `includeAvailability` to `true` to collect public availability slot metadata.

This is read-only.

The actor does not book, hold, cancel, modify, or join reservations.

### Example input

```json
{
  "searchQueries": ["rezdora", "new york italian"],
  "venueIds": ["443"],
  "maxItems": 10,
  "includeVenueDetails": true,
  "includeAvailability": true,
  "partySize": 2
}
```

### Example output

```json
{
  "venueId": 443,
  "name": "I Sodi",
  "url": "https://resy.com/cities/ny/venues/i-sodi",
  "source": "venueId",
  "city": "New York",
  "neighborhood": "West Village",
  "cuisine": ["Italian"],
  "priceRange": 3,
  "ratingAverage": 4.7961,
  "ratingCount": 23654,
  "availableSlotCount": 0,
  "availabilitySummary": "No public slots returned for the requested date and party size",
  "scrapedAt": "2026-06-13T08:36:07.976Z"
}
```

### Tips for best results

Use specific restaurant names when you need exact matches.

Use city and cuisine phrases when you want discovery.

Keep `maxItems` low for first tests.

Enable availability only when it matters to your workflow.

For repeat monitoring, schedule the actor daily or weekly and compare exports over time.

### Integrations

You can connect the actor to:

- Google Sheets for restaurant tracking.
- Airtable for hospitality CRM enrichment.
- Slack for daily availability or new-venue alerts.
- BI tools for market analysis.
- Data warehouses through Apify webhooks or API pulls.
- Concierge workflows that need structured venue shortlists.

### 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('automation-lab/resy-restaurant-scraper').call({
  searchQueries: ['new york italian'],
  maxItems: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/resy-restaurant-scraper').call(run_input={
    'searchQueries': ['los angeles sushi'],
    'maxItems': 10,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~resy-restaurant-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"searchQueries":["rezdora"],"maxItems":5}'
```

### MCP usage

Use this actor from Claude Desktop, Claude Code, or another MCP-compatible client through Apify MCP.

Add the Apify MCP server to Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com"
```

For Claude Desktop, Cursor, or VS Code, add this JSON config:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com"
    }
  }
}
```

You can then ask for `automation-lab/resy-restaurant-scraper` directly.

Example prompts:

- "Run the Resy Restaurant Scraper for `new york italian` and summarize the top venues."
- "Find Resy restaurants matching `los angeles sushi` and export names, neighborhoods, and ratings."
- "Check public availability metadata for venue ID 443 for a party of 2 tomorrow."

### Scheduling ideas

Run daily to monitor availability signals.

Run weekly to refresh a restaurant market database.

Run monthly to compare cuisine and price-band coverage across cities.

Use Apify webhooks to send the dataset to your own endpoint after every run.

### Data quality notes

The actor returns what public Resy endpoints return at run time.

Some venues may omit address, description, tags, or availability slots.

Availability can change quickly and should be treated as a point-in-time signal.

Ratings and counts are Resy-provided public values, not independently verified scores.

### Limitations

The actor does not log in.

The actor does not solve CAPTCHA.

The actor does not book reservations.

The actor does not guarantee a complete city-wide directory from a single vague query.

Slug-only venue URLs may need to be provided as search queries or numeric venue IDs.

### Legality and ethical use

This actor extracts public, read-only information.

Use the data responsibly and comply with applicable laws, Resy's terms, and your internal policies.

Do not use the actor to spam restaurants, bypass access controls, or automate bookings.

### FAQ and troubleshooting

#### Why did I get fewer results than `maxItems`?

Resy may return fewer matches for a query, or duplicate venues may be removed before saving.

Try broader search phrases or multiple queries.

#### Why are availability fields empty?

Availability depends on date, party size, restaurant configuration, and public slot visibility.

An empty slot count means the public endpoint did not return slots for that request.

#### Why did a URL input not work?

Most Resy venue pages use slugs, while the public API uses numeric venue IDs.

Use a search query or provide the numeric ID directly.

### Related scrapers

Explore other Automation Lab actors:

- https://apify.com/automation-lab/google-maps-scraper
- https://apify.com/automation-lab/tripadvisor-scraper
- https://apify.com/automation-lab/yelp-scraper

### Changelog

#### 0.1

Initial build with search, direct venue IDs, venue profile enrichment, and optional read-only availability metadata.

# Actor input Schema

## `searchQueries` (type: `array`):

Restaurant names, cuisine/location phrases, or market keywords to search on Resy.

## `venueIds` (type: `array`):

Known numeric Resy venue IDs to fetch directly, e.g. 443 for I Sodi.

## `venueUrls` (type: `array`):

Optional Resy URLs that contain a venue\_id or id query parameter. Slug-only URLs may not expose the numeric ID, so use searchQueries or venueIds for those.

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

Maximum number of unique venues to save.

## `includeVenueDetails` (type: `boolean`):

Fetch each public venue profile after discovery. Disable only when you want faster search-only output.

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

Fetch read-only public slot counts and times for each venue. This does not book, hold, or modify reservations.

## `availabilityDate` (type: `string`):

Date to check when availability metadata is enabled, in YYYY-MM-DD format. Defaults to tomorrow if omitted.

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

Party size used for read-only availability checks.

## Actor input object example

```json
{
  "searchQueries": [
    "rezdora",
    "new york italian"
  ],
  "venueIds": [
    "443"
  ],
  "venueUrls": [],
  "maxItems": 10,
  "includeVenueDetails": true,
  "includeAvailability": false,
  "partySize": 2
}
```

# 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 = {
    "searchQueries": [
        "rezdora",
        "new york italian"
    ],
    "venueIds": [
        "443"
    ],
    "venueUrls": [],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/resy-restaurant-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 = {
    "searchQueries": [
        "rezdora",
        "new york italian",
    ],
    "venueIds": ["443"],
    "venueUrls": [],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/resy-restaurant-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 '{
  "searchQueries": [
    "rezdora",
    "new york italian"
  ],
  "venueIds": [
    "443"
  ],
  "venueUrls": [],
  "maxItems": 10
}' |
apify call automation-lab/resy-restaurant-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Resy Restaurant Scraper",
        "description": "Extract public Resy restaurant venue data, search results, ratings, cuisine, locations, price bands, and availability metadata. Export JSON, CSV, or Excel.",
        "version": "0.1",
        "x-build-id": "EKIHDMClbXC0dI5HK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~resy-restaurant-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-resy-restaurant-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/automation-lab~resy-restaurant-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-resy-restaurant-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/automation-lab~resy-restaurant-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-resy-restaurant-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": {
                    "searchQueries": {
                        "title": "🔎 Search queries",
                        "type": "array",
                        "description": "Restaurant names, cuisine/location phrases, or market keywords to search on Resy.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "venueIds": {
                        "title": "Venue IDs",
                        "type": "array",
                        "description": "Known numeric Resy venue IDs to fetch directly, e.g. 443 for I Sodi.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "venueUrls": {
                        "title": "Venue URLs with numeric IDs",
                        "type": "array",
                        "description": "Optional Resy URLs that contain a venue_id or id query parameter. Slug-only URLs may not expose the numeric ID, so use searchQueries or venueIds for those.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum venues",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of unique venues to save.",
                        "default": 25
                    },
                    "includeVenueDetails": {
                        "title": "Fetch full venue details",
                        "type": "boolean",
                        "description": "Fetch each public venue profile after discovery. Disable only when you want faster search-only output.",
                        "default": true
                    },
                    "includeAvailability": {
                        "title": "Include availability metadata",
                        "type": "boolean",
                        "description": "Fetch read-only public slot counts and times for each venue. This does not book, hold, or modify reservations.",
                        "default": false
                    },
                    "availabilityDate": {
                        "title": "Availability date",
                        "type": "string",
                        "description": "Date to check when availability metadata is enabled, in YYYY-MM-DD format. Defaults to tomorrow if omitted."
                    },
                    "partySize": {
                        "title": "Party size",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Party size used for read-only availability checks.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
