# Zomato Reviews Scraper (`codingfrontend/zomato-reviews-scraper`)

Scrape restaurant reviews from Zomato.com

- **URL**: https://apify.com/codingfrontend/zomato-reviews-scraper.md
- **Developed by:** [codingfrontend](https://apify.com/codingfrontend) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 reviews

This Actor is paid per result. You are not charged for the Apify platform usage, but only a fixed price for dataset items the Actor outputs.
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-result

# README

## Zomato Reviews Scraper

**Note:** This scraper extracts restaurant reviews and information from Zomato.com

### Input Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `restaurantUrls` | Array | Yes | - | List of Zomato restaurant URLs to scrape reviews from |
| `maxReviewsPerRestaurant` | Integer | No | `10` | Maximum number of reviews to scrape per restaurant |
| `headless` | Boolean | No | `false` | Run browser in headless mode (no visible UI) |
| `cookies` | Array | No | `null` | **Optional:** Authentication cookies from a logged-in Zomato session. If not provided, will try to load from `COOKIES.json` file. See [Cookie Configuration](#cookie-configuration) below |

#### Input Schema Example

```json
{
  "restaurantUrls": [
    "https://www.zomato.com/chennai/pizza-hut-nungambakkam",
    "https://www.zomato.com/chennai/kfc-nungambakkam"
  ],
  "maxReviewsPerRestaurant": 10,
  "headless": false
}
```

#### Cookie Configuration

For accessing protected or authenticated content, you can provide cookies in two ways:

##### Via Input Parameter (Recommended for Apify Platform)

Add the `cookies` array to your input JSON:

```json
{
  "restaurantUrls": ["https://www.zomato.com/chennai/pizza-hut-nungambakkam"],
  "maxReviewsPerRestaurant": 10,
  "cookies": [
    {
      "name": "csrf",
      "value": "your_csrf_token_here",
      "domain": ".zomato.com",
      "path": "/",
      "secure": true,
      "httpOnly": false,
      "expirationDate": 1760425879
    },
    {
      "name": "zat",
      "value": "your_auth_token_here",
      "domain": ".zomato.com",
      "path": "/",
      "secure": true,
      "httpOnly": true,
      "expirationDate": 1791875478
    }
  ]
}
```

**Required cookie properties:**

- `name` (string): Cookie name
- `value` (string): Cookie value
- `domain` (string): Cookie domain (e.g., ".zomato.com")

**Optional cookie properties:**

- `path` (string): Cookie path (default: "/")
- `expirationDate` (number): Unix timestamp in seconds
- `httpOnly` (boolean): HTTP only flag
- `secure` (boolean): Secure flag
- `sameSite` (string): SameSite attribute

**How to get cookies:**

**Method 1: Using Chrome Extension (Easiest):**

1. Install the [Get cookies.txt LOCALLY](https://chromewebstore.google.com/detail/get-cookiestxt-locally/cclelndahbckbenkjhflpdbgdldlbecc) extension
2. Log in to Zomato in your browser
3. Visit any Zomato page (e.g., https://www.zomato.com)
4. Click the extension icon and select "Export As → JSON"
5. Copy the JSON array and use it directly in the `cookies` input parameter or save as `COOKIES.json`

**Method 2: Manual Extraction:**

1. Log in to Zomato in your browser
2. Open Developer Tools (F12)
3. Go to Application/Storage → Cookies → https://www.zomato.com
4. Copy the cookie values (especially `csrf`, `zat`, `PHPSESSID`, `_abck`)
5. Format them according to the schema above

**Important cookies for authentication:**

- `csrf` - CSRF protection token (required for API requests)
- `zat` - Zomato authentication token (primary auth)
- `PHPSESSID` - PHP session ID
- `_abck` - Anti-bot cookie
- `zhli` - Login indicator

**Note:** The scraper automatically:

- Filters out expired cookies
- Extracts fresh cookies from the browser session
- Adds required headers like CSRF token for API requests

### Output Schema

The scraper outputs comprehensive review objects extracted from Zomato restaurant pages. Each review contains detailed information about the restaurant, reviewer details, ratings, engagement metrics, and metadata.

#### Review Fields

| Field | Title | Type | Description |
|-------|-------|------|-------------|
| `reviewId` | Review ID | Integer | Unique identifier for the review |
| `status` | Review Status | String | Status of the review (success, etc.) |
| `reviewText` | Review Text | String | Full text content of the review |
| `reviewTextShort` | Short Review Text | String | Shortened version of the review text |
| `reviewDate` | Review Date | String | Formatted date when review was posted |
| `experienceType` | Experience Type | String | Type of dining experience (dining, delivery, etc.) |
| `rating` | Rating Value | Number | Numeric rating value (1-5 stars) |
| `ratingLabel` | Rating Label | String | Text label for the rating (Poor, Average, Good, etc.) |
| `ratingColorHex` | Rating Color | String | Hex color code for rating display |
| `ratingColorTheme` | Rating Theme | String | Color theme for rating (yellow-400, etc.) |
| `ratingText` | Rating Context | String | Rating context text |
| `reviewerName` | Reviewer Name | String | Name or username of the reviewer |
| `reviewerId` | Reviewer ID | Integer | Unique identifier for the reviewer |
| `reviewerProfileUrl` | Reviewer Profile URL | String | URL to the reviewer's profile |
| `reviewerProfilePic` | Reviewer Profile Picture | String | URL to the reviewer's profile picture |
| `reviewerFollowersCount` | Reviewer Followers | Integer | Number of followers the reviewer has |
| `reviewerReviewsCount` | Reviewer Review Count | Integer | Number of reviews the user has posted |
| `reviewerIsFollowed` | Is Followed | Boolean | Whether the current user follows this reviewer |
| `positiveTags` | Positive Tags | Array | Array of positive sentiment tags |
| `negativeTags` | Negative Tags | Array | Array of negative sentiment tags |
| `likeCount` | Like Count | Integer | Number of likes the review has received |
| `isLikedByUser` | Liked by User | Boolean | Whether the current user liked this review |
| `commentCount` | Comment Count | Integer | Number of comments on this review |
| `isEditable` | Is Editable | Boolean | Whether the review can be edited |
| `comments` | Comments | Array | Array of user comments on the review |
| `managementComments` | Management Comments | Array | Array of management responses to the review |
| `hasMoreComments` | Has More Comments | Boolean | Whether there are more comments to load |
| `reviewPhotos` | Review Photos | Array | Array of photo URLs attached to the review |
| `externalUrl` | External URL | String | External URL if review is shared from another platform |
| `externalHost` | External Host | String | External platform host name |
| `externalHostText` | External Host Text | String | External platform display text |
| `reviewUrl` | Review URL | String | Direct URL to this specific review |
| `backgroundColorType` | Background Color Type | String | Background color type for UI display |
| `backgroundColorTint` | Background Color Tint | String | Background color tint/shade |
| `restaurantUrl` | Restaurant URL | String | URL of the restaurant being reviewed |
| `resId` | Restaurant ID | Integer | Zomato's internal restaurant identifier |
| `scrapedAt` | Scraped At | String | ISO timestamp when the data was scraped |
| `source` | Source | String | Source of the data (zomato) |

#### Review Example

```json
{
  "review_id": 196274,
  "status": "success",
  "message": "",
  "review_url": "https://www.zoma.to/nGxll",
  "review_text": "The food is traditional and decent. Milieu is identically the same as anyother Dindigul Thalapakkati outlet. But. BUT! I had experienced bad customer service not once but twice here (maybe it is my conjecture and i don't unquestionably contradict with anyone else' certainty). The pricing is a bit high too. Nevertheless, it will be a pretty modest place for a family weekend dinner. :)",
  "review_text_short": "",
  "date": "May 12, 2013",
  "experience_type": "dining",
  "rating_value": 3,
  "rating_label": "Average",
  "rating_color_hex": "#cdd614",
  "rating_color_theme": "yellow-400",
  "rating_text": "DINING",
  "user_id": 215642,
  "user_name": "Raja",
  "user_profile_url": "https://www.zomato.com/users/raja-215642",
  "user_profile_pic": "https://b.zmtcdn.com/data/user_profile_pictures/ba6/a15fdca76bd30fbade289985eb3bdba6.jpg?fit=around%7C100%3A100&crop=100%3A100%3B%2A%2C%2A",
  "user_placeholder_pic": "https://b.zmtcdn.com/images/placeholder_200.png",
  "user_followers_count": 114,
  "user_reviews_count": 0,
  "user_is_followed": false,
  "positive_tags": [],
  "negative_tags": [],
  "like_count": 0,
  "is_liked_by_user": false,
  "comment_count": 0,
  "comments": [],
  "management_comments": [],
  "has_more_comments": false,
  "review_photos": [],
  "external_url": "",
  "external_host": "",
  "external_host_text": "",
  "is_editable": false,
  "urbanspoon_status": 0,
  "new_rating_color": "#1C1C1C",
  "background_color_type": "yellow",
  "background_color_tint": "400",
  "restaurantUrl": "https://www.zomato.com/chennai/dindigul-thalappakatti-since-1957-ramapuram/order",
  "resId": 67547,
  "scrapedAt": "2025-10-11T16:59:11.958Z",
  "source": "zomato"
}
```

### Data Visualization

The scraper includes a comprehensive view template (`.actor/view_template.html`) that provides:

#### Features

- **Review Cards**: Clean, organized display of each review
- **User Information**: Reviewer profiles with follower counts and review statistics
- **Rating Display**: Visual rating indicators with color coding
- **Photo Gallery**: Grid display of review photos
- **Tag System**: Positive and negative sentiment tags
- **Engagement Metrics**: Likes, comments, and interaction data
- **Restaurant Context**: Restaurant information and scraping metadata

#### Usage

The view template automatically formats your scraped data into a user-friendly interface when viewing results in the Apify console.

### Support

For issues and questions:

- Review the Apify Actor logs in the platform
- Ensure restaurant URLs are valid Zomato restaurant pages
- Check that restaurant pages are accessible and not restricted
- Verify that maxReviewsPerRestaurant is set to a reasonable number (recommended: 10-50)
- The scraper uses browser automation to extract data - ensure sufficient system resources
- For authentication issues, the scraper may need Zomato API credentials
- Email : lakshmanan.w3dev@gmail.com

#### Proxy Configuration

**Important:** Configure the proxy settings based on your location for optimal performance:

##### India (IN)

```json
{
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "IN"
  }
}
```

##### United States (US)

```json
{
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  }
}
```

##### United Kingdom (UK)

```json
{
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "GB"
  }
}
```

##### Other Countries

Replace `"IN"`, `"US"`, or `"GB"` with the appropriate [ISO 3166-1 alpha-2 country code](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) for your location. Common codes include:

- `CA` - Canada
- `AU` - Australia
- `DE` - Germany
- `FR` - France
- `JP` - Japan
- `SG` - Singapore

**Note:** Using a proxy from your geographic region helps avoid Zomato's regional restrictions and improves scraping success rates.

#### Data Format Notes

- All timestamps are in ISO 8601 format
- Rating values are numeric (1-5 scale)
- User information includes profile data and statistics
- Tags are extracted and categorized as positive/negative sentiment
- Photo URLs and external links are preserved when available

# Actor input Schema

## `restaurantUrls` (type: `array`):

List of Zomato restaurant URLs to scrape reviews from.

## `maxReviewsPerRestaurant` (type: `integer`):

Maximum number of reviews to scrape per restaurant.

## `headless` (type: `boolean`):

Run browser in headless mode (no visible UI). Set to false for debugging.

## `cookies` (type: `array`):

Optional: Provide authentication cookies from a logged-in Zomato session as a JSON array. If not provided, will try to load from COOKIES.json file. Export cookies from your browser using the 'Get cookies.txt LOCALLY' Chrome extension (Export As → JSON format). Each cookie object should include: name, value, domain properties at minimum.

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

Use Apify Proxy to avoid IP address-based blocking. Required for successful scraping.

## Actor input object example

```json
{
  "restaurantUrls": [
    "https://www.zomato.com/chennai/mathsya-t-nagar-t-nagar"
  ],
  "maxReviewsPerRestaurant": 20,
  "headless": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  }
}
```

# 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 = {
    "restaurantUrls": [
        "https://www.zomato.com/chennai/mathsya-t-nagar-t-nagar"
    ],
    "maxReviewsPerRestaurant": 20,
    "headless": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("codingfrontend/zomato-reviews-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 = {
    "restaurantUrls": ["https://www.zomato.com/chennai/mathsya-t-nagar-t-nagar"],
    "maxReviewsPerRestaurant": 20,
    "headless": False,
}

# Run the Actor and wait for it to finish
run = client.actor("codingfrontend/zomato-reviews-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 '{
  "restaurantUrls": [
    "https://www.zomato.com/chennai/mathsya-t-nagar-t-nagar"
  ],
  "maxReviewsPerRestaurant": 20,
  "headless": false
}' |
apify call codingfrontend/zomato-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zomato Reviews Scraper",
        "description": "Scrape restaurant reviews from Zomato.com",
        "version": "1.0",
        "x-build-id": "g2wHIkmxyRqdaSmya"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/codingfrontend~zomato-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-codingfrontend-zomato-reviews-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/codingfrontend~zomato-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-codingfrontend-zomato-reviews-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/codingfrontend~zomato-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-codingfrontend-zomato-reviews-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",
                "required": [
                    "restaurantUrls"
                ],
                "properties": {
                    "restaurantUrls": {
                        "title": "Restaurant URLs",
                        "minItems": 1,
                        "type": "array",
                        "description": "List of Zomato restaurant URLs to scrape reviews from.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerRestaurant": {
                        "title": "Max Reviews Per Restaurant",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of reviews to scrape per restaurant.",
                        "default": 20
                    },
                    "headless": {
                        "title": "Headless Mode",
                        "type": "boolean",
                        "description": "Run browser in headless mode (no visible UI). Set to false for debugging.",
                        "default": false
                    },
                    "cookies": {
                        "title": "Cookies (Optional)",
                        "type": "array",
                        "description": "Optional: Provide authentication cookies from a logged-in Zomato session as a JSON array. If not provided, will try to load from COOKIES.json file. Export cookies from your browser using the 'Get cookies.txt LOCALLY' Chrome extension (Export As → JSON format). Each cookie object should include: name, value, domain properties at minimum."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Use Apify Proxy to avoid IP address-based blocking. Required for successful scraping.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "IN"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
