# Swiggy Restaurant Scraper (`logiover/swiggy-restaurant-scraper`) Actor

Scrape restaurant listings from Swiggy.com — India's #2 food delivery platform. Extract name, location, rating, cuisines, delivery time, cost and discount data. Fast, zero-browser API architecture.

- **URL**: https://apify.com/logiover/swiggy-restaurant-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 results

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

## Swiggy Restaurant & Menu Scraper

The most comprehensive, high-speed, and cost-effective data extraction tool for **[Swiggy](https://www.swiggy.com)** — India’s leading food delivery and quick-commerce platform. Extract rich restaurant profiles, complete digital menus, pricing data, delivery estimates, and customer ratings without the overhead of browser automation.

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-blue?style=for-the-badge)](https://apify.com)
[![Direct API](https://img.shields.io/badge/Architecture-Direct%20API-success?style=for-the-badge)]()
[![Zero Browser](https://img.shields.io/badge/Engine-Zero%20Browser-brightgreen?style=for-the-badge)]()
[![Data Quality](https://img.shields.io/badge/Data-High%20Quality-orange?style=for-the-badge)]()

---

### 🌟 Introduction: Why Scrape Swiggy?

The Indian food delivery market is a duopoly dominated by Zomato and Swiggy. To get a **100% complete picture** of the Indian food-tech landscape, you need data from both. 

While many scrapers struggle with Swiggy's dynamic React-based frontend and heavy JavaScript rendering, this **Swiggy Restaurant & Menu Scraper** bypasses the frontend entirely. By interfacing directly with Swiggy's internal Desktop API (`DAPI`), this actor delivers lightning-fast performance, extreme reliability, and vastly reduced compute costs.

Whether you are a food aggregator, a cloud kitchen operator, a market researcher, or a pricing analyst, this dataset provides the definitive ground truth for the Indian F&B sector.

---

### 🚀 Key Features

* **⚡ Blazing Fast API Architecture:** No Puppeteer, no Playwright. This actor uses pure HTTP requests (`got-scraping`) to emulate Swiggy's internal DAPI, meaning it runs 10x to 50x faster than browser-based alternatives.
* **🍔 Deep Menu Extraction:** Doesn't just stop at the restaurant name. It iterates through secondary endpoints to pull *every single menu item*, categorized accurately, with real-time prices, descriptions, and Veg/Non-Veg classifications.
* **📍 Hyper-Local Targeting (GPS Supported):** Swiggy relies heavily on hyper-local delivery zones. You aren't restricted to just "cities". You can input exact `latitude,longitude` coordinates to scrape specific neighborhoods, tech parks, or residential blocks.
* **💰 Automatic Price Normalization:** Swiggy's backend stores prices in *paise*. This scraper automatically converts all financial metrics (delivery fees, menu prices, cost for two) into standard **INR (₹)** for immediate analysis.
* **🔄 Built-in Pagination Handling:** Seamlessly navigates Swiggy's complex `nextOffset` pagination tokens to extract thousands of restaurants continuously without missing a single listing.
* **🛡️ Anti-Blocking Mechanisms:** Integrated perfectly with Apify's Proxy infrastructure to rotate IPs, randomize request delays, and spoof browser headers, ensuring uninterrupted data pipelines.

---

### 🎯 Business Use Cases

How can you monetize and utilize this Swiggy dataset?

#### 1. Cloud Kitchen (Dark Kitchen) Strategy & Expansion
Before opening a new cloud kitchen, you need to understand the local supply and demand. By scraping a specific GPS radius, you can identify "menu gaps." Are there 50 pizza places but zero healthy salad options? What is the average price of a biryani in Koramangala vs. Indiranagar? Use this data to optimize your cuisine choice and pricing strategy.

#### 2. Competitive Pricing Intelligence
If you are a restaurant owner or a franchise manager, monitoring your competitors' pricing dynamically is crucial. Track how rival restaurants alter their prices, delivery fees, and promotional discounts over time. 

#### 3. Food Aggregation & Alternative Apps
Building a hyper-local discovery app, a nutritional tracking platform, or a corporate catering service? Feed your database with accurate, structured restaurant and menu data across top Indian metro cities.

#### 4. Sentiment Analysis & Quality Monitoring
Extract average ratings and rating volumes for thousands of restaurants. Identify poorly rated establishments as potential leads for B2B restaurant management services, or analyze high-performing restaurants to understand winning operational formulas.

---

### ⚙️ How to Use: Input Configuration

The scraper is designed to be plug-and-play while offering granular control for advanced users.

#### Input JSON Example

```json
{
  "locations": [
    "bangalore",
    "mumbai",
    "12.9352,77.6245"
  ],
  "scrapeMenu": true,
  "maxRestaurants": 500,
  "requestDelay": 1500,
  "maxConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

#### Parameter Details

| Field | Type | Default | Description |
|---|---|---|---|
| **`locations`** | `Array<String>` | `[]` | **(Required)** The target areas. You can use standard city slugs (e.g., `delhi`, `pune`) or exact GPS coordinates (`lat,lng`) for hyper-local neighborhood searches. |
| **`scrapeMenu`** | `Boolean` | `true` | If enabled, the actor makes a secondary API call for *each* restaurant to download its full digital menu. Turn this off if you only need a directory of restaurants, which will drastically speed up the run. |
| **`maxRestaurants`** | `Integer` | `100` | The maximum number of restaurants to extract **per location**. Set this to `0` to scrape the absolute maximum number of restaurants Swiggy allows for that area. |
| **`requestDelay`** | `Integer` | `1000` | Wait time (in milliseconds) between API requests. Swiggy has rate limits. Keeping this between 1000ms - 2000ms ensures high success rates. |
| **`maxConcurrency`** | `Integer` | `2` | Number of simultaneous scraping tasks. Since this uses the internal API, keep concurrency low (1 to 3) to avoid triggering DDoS protections. |
| **`proxyConfiguration`**| `Object` | `Apify Proxy` | Proxies are highly recommended. Indian Residential proxies or standard Datacenter proxies work best. |

***

### 🗺️ Supported Location Formats

You have two ways to define where to scrape:

#### 1. Built-in City Slugs

The actor comes pre-configured with the exact GPS coordinates for the center of India's major metropolitan areas. Just type the slug:

- `mumbai`
- `delhi`
- `bangalore` (or `bengaluru`)
- `hyderabad`
- `chennai`
- `kolkata`
- `pune`
- `ahmedabad`
- `jaipur`
- `lucknow`

#### 2. Exact GPS Coordinates (Highly Recommended)

Food delivery is hyper-local. A search from the "center" of Mumbai will not show restaurants in Navi Mumbai. For exhaustive coverage, input exact coordinates separated by a comma:

- `"19.0760,72.8777"` (Bandra Kurla Complex)
- `"12.9352,77.6245"` (Koramangala, Bangalore)
- `"28.4595,77.0266"` (Cyber City, Gurgaon)

***

### 📊 Data Dictionary (Output Schema)

The actor generates highly structured, clean JSON datasets ready for import into Excel, BigQuery, Snowflake, or your custom database.

| JSON Key | Data Type | Description |
|---|---|---|
| `restaurantId` | `String` | Swiggy's internal unique identifier for the restaurant. |
| `name` | `String` | The official name of the restaurant. |
| `city` | `String` | The operational city or the search location input. |
| `area` | `String` | The specific neighborhood/locality (e.g., "Indiranagar"). |
| `avgRating` | `Number` | The average user rating out of 5.0. Returns `null` if unrated. |
| `ratingCount` | `String` | Textual representation of rating volume (e.g., "10K+ ratings", "500+"). |
| `costForTwo` | `String` | Swiggy's estimated cost for two people (e.g., "₹400 for two"). |
| `cuisines` | `Array<String>` | List of cuisine tags (e.g., `["Chinese", "North Indian", "Beverages"]`). |
| `deliveryTime` | `Integer` | Estimated Time of Arrival (ETA) in minutes. |
| `deliveryFee` | `Integer` | Current delivery fee in standard INR (₹). |
| `isOpen` | `Boolean` | `true` if the restaurant is currently accepting orders. |
| `isPromoted` | `Boolean` | `true` if the listing is an "Ad" or promoted placement. |
| `hasMenu` | `Boolean` | Indicates if the menu was successfully scraped and attached. |
| `menuItems` | `Array<Object>`| An array containing the full menu. See below for item structure. |
| `searchLocation` | `String` | The original input location string used to find this record. |
| `scrapedAt` | `String` | ISO-8601 timestamp of when the data was extracted. |

#### Menu Item Structure

Inside the `menuItems` array, each item contains:

- `itemId`: Unique ID of the dish.
- `name`: Name of the dish (e.g., "Paneer Butter Masala").
- `category`: The menu section it belongs to (e.g., "Main Course", "Breads").
- `description`: The chef's description of the dish (often contains ingredients).
- `price`: Exact price in INR.
- `isVeg`: `true` if the item is vegetarian (green dot), `false` for non-veg (red/brown dot).
- `inStock`: `true` if currently available to order.

***

### 📝 Sample Output

Here is a snippet of what a single record looks like when exported to JSON:

```json
{
  "restaurantId": "10576",
  "name": "Truffles",
  "city": "bangalore",
  "area": "Koramangala",
  "avgRating": 4.6,
  "ratingCount": "10K+ ratings",
  "costForTwo": "₹350 for two",
  "cuisines": [
    "American",
    "Continental",
    "Desserts",
    "Italian"
  ],
  "deliveryTime": 42,
  "deliveryFee": 45,
  "isOpen": true,
  "isPromoted": false,
  "hasMenu": true,
  "menuItems": [
    {
      "itemId": "45291012",
      "name": "All American Cheese Burger",
      "category": "Burgers",
      "description": "Our classic burger with a juicy chicken patty, double cheese, lettuce, tomatoes, and house mayo.",
      "price": 245,
      "isVeg": false,
      "inStock": true
    },
    {
      "itemId": "45291045",
      "name": "Ferrero Rocher Cold Coffee",
      "category": "Beverages",
      "description": "Thick cold coffee blended with rich Ferrero Rocher chocolates and hazelnut syrup.",
      "price": 190,
      "isVeg": true,
      "inStock": true
    },
    {
      "itemId": "45291100",
      "name": "Peri Peri French Fries",
      "category": "Sides",
      "description": "Crispy golden fries tossed in spicy peri peri seasoning.",
      "price": 140,
      "isVeg": true,
      "inStock": false
    }
  ],
  "searchLocation": "12.9352,77.6245",
  "scrapedAt": "2026-04-16T14:30:22.000Z"
}
```

***

### 💡 Pro-Tips for Best Results

1. **Grid Scraping (City-Wide):** Swiggy only shows restaurants within a certain radius of the provided coordinates. If you want to scrape an *entire* city, you should generate a grid of coordinates (e.g., spaced 3-5 km apart) covering the city limits, and pass that list of coordinates into the `locations` input.
2. **Menu Toggle:** Scraping menus requires 1 additional API request per restaurant. If you input `maxRestaurants: 1000` and `scrapeMenu: true`, the actor makes ~1000 requests. If you only need a list of restaurant names/ratings, set `scrapeMenu: false` to finish the job in seconds.
3. **Data Export:** Once the run completes, you can export the dataset from Apify in JSON, CSV, XML, or Excel format. You can also use the Apify API to pipe the data directly into your AWS S3 bucket, Google Sheets, or Zapier workflows.

***

### 🛑 Limitations & Anti-Scraping

Swiggy employs regional geo-blocking. If you attempt to access the Swiggy API from a non-Indian IP address without a proxy, Swiggy may return a 403 Forbidden error or empty data.
**Solution:** Ensure you are using the Apify Proxy. Setting it to `RESIDENTIAL` proxies based in India yields a 99.9% success rate.

***

### 💳 Pricing & Compute Usage

Because this actor relies exclusively on optimized API calls rather than launching heavy Chrome browsers, its resource footprint is minimal.

- Expect to consume approximately **0.005 to 0.01 Compute Units (CU)** per 100 restaurants processed (including full menu extraction).
- This translates to exceptionally cheap data extraction, making large-scale daily monitoring financially viable.

***

### 📜 Legal Disclaimer

This tool is designed for ethical data extraction. Users are expected to comply with Swiggy's Terms of Service, respect rate limits, and adhere to local data protection and copyright laws (such as the IT Act in India). The developer of this Apify actor is not responsible for any misuse of the data extracted.

***

*Need customizations, a Zomato companion scraper, or dedicated support? Feel free to reach out via the Apify platform!*

# Actor input Schema

## `locations` (type: `array`):

City slugs or GPS coordinates. City examples: 'mumbai', 'delhi', 'bangalore', 'hyderabad', 'pune', 'chennai', 'kolkata'. GPS format: '12.9716,77.5946'.

## `maxRestaurants` (type: `integer`):

Maximum restaurants to scrape per location. Swiggy shows ~25 per page. Set 0 for unlimited.

## `requestDelay` (type: `integer`):

Delay between requests in milliseconds.

## Actor input object example

```json
{
  "locations": [
    "bangalore",
    "mumbai"
  ],
  "maxRestaurants": 200,
  "requestDelay": 500
}
```

# Actor output Schema

## `restaurantId` (type: `string`):

Unique Swiggy ID

## `name` (type: `string`):

Restaurant Name

## `city` (type: `string`):

City of operation

## `area` (type: `string`):

Neighborhood or area

## `avgRating` (type: `string`):

Average user rating

## `ratingCount` (type: `string`):

E.g., '10K+ ratings'

## `costForTwo` (type: `string`):

Average price for 2 pax

## `cuisines` (type: `string`):

List of cuisines offered

## `deliveryTime` (type: `string`):

Delivery time in minutes

## `deliveryFee` (type: `string`):

Delivery fee in INR

## `isOpen` (type: `string`):

Currently accepting orders

## `isPromoted` (type: `string`):

Is ad promoted on listing

## `hasMenu` (type: `string`):

Menu items successfully extracted

## `menuItems` (type: `string`):

Array of item objects (name, price, veg)

## `searchLocation` (type: `string`):

Input location used

## `scrapedAt` (type: `string`):

ISO timestamp

# 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 = {
    "locations": [
        "bangalore",
        "mumbai"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/swiggy-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 = { "locations": [
        "bangalore",
        "mumbai",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("logiover/swiggy-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 '{
  "locations": [
    "bangalore",
    "mumbai"
  ]
}' |
apify call logiover/swiggy-restaurant-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Swiggy Restaurant Scraper",
        "description": "Scrape restaurant listings from Swiggy.com — India's #2 food delivery platform. Extract name, location, rating, cuisines, delivery time, cost and discount data. Fast, zero-browser API architecture.",
        "version": "0.0",
        "x-build-id": "ZWZO1Qqtd90n7eAMU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~swiggy-restaurant-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-swiggy-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/logiover~swiggy-restaurant-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-swiggy-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/logiover~swiggy-restaurant-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-swiggy-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",
                "required": [
                    "locations"
                ],
                "properties": {
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "City slugs or GPS coordinates. City examples: 'mumbai', 'delhi', 'bangalore', 'hyderabad', 'pune', 'chennai', 'kolkata'. GPS format: '12.9716,77.5946'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxRestaurants": {
                        "title": "Max Restaurants per Location",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum restaurants to scrape per location. Swiggy shows ~25 per page. Set 0 for unlimited.",
                        "default": 200
                    },
                    "requestDelay": {
                        "title": "Request Delay (ms)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Delay between requests in milliseconds.",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
