# Zomato Restaurant Search Scraper (`automation-lab/zomato-restaurant-search-scraper`) Actor

Extract public Zomato restaurant leads with ratings, cuisines, review counts, locality, cost-for-two, images, and profile URLs.

- **URL**: https://apify.com/automation-lab/zomato-restaurant-search-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **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

## Zomato Restaurant Search Scraper

Extract restaurant leads from public Zomato city, restaurant, and cuisine pages. The actor returns Zomato profile URLs, names, cuisines, ratings, review counts, locality, address, cost-for-two, images, and source-page metadata in a clean dataset.

Use it when you need repeatable Zomato restaurant discovery for food-tech research, local business lead generation, restaurant sales outreach, local SEO work, or market mapping in Indian cities where Zomato has strong coverage.

### What does Zomato Restaurant Search Scraper do?

Zomato Restaurant Search Scraper reads public Zomato pages and extracts restaurant cards from the embedded page state.

It can start from a city page such as `https://www.zomato.com/bangalore/restaurants` or a cuisine page such as `https://www.zomato.com/bangalore/restaurants/biryani`.

When enabled, it also follows public cuisine and locality links that Zomato exposes on the page so you can collect more restaurants from one city URL without using private APIs.

### Who is it for?

- 🍽️ Restaurant sales teams building Zomato-based prospect lists.
- 📍 Local SEO agencies checking restaurant categories, ratings, and profiles.
- 🧾 Food-tech analysts mapping cuisines, costs, and locations by city.
- 🏪 Franchise and cloud-kitchen operators researching market density.
- 🧑‍💻 Developers who need a structured Zomato extractor instead of brittle page parsing.

### Why use this scraper?

Zomato pages are useful, but manually copying restaurant cards is slow and inconsistent.

This actor gives you a repeatable Apify workflow with typed fields, a dataset export, API access, scheduled runs, webhooks, and MCP compatibility.

It focuses on public restaurant search data rather than private user accounts, checkout flows, or protected APIs.

### Key features

- ✅ Public Zomato city and cuisine URL input.
- ✅ Restaurant profile URL and Zomato restaurant ID.
- ✅ Rating, rating text, review count, and review label.
- ✅ Cuisines, locality, address, and city.
- ✅ Cost-for-two and distance when present.
- ✅ Promoted/new flags for filtering.
- ✅ Image and featured image URLs.
- ✅ Optional public cuisine/locality page discovery.
- ✅ Pay-per-event pricing with one charge per saved restaurant.

### Data fields

| Field | Description |
| --- | --- |
| `restaurantId` | Zomato restaurant identifier. |
| `name` | Restaurant name. |
| `url` | Public Zomato restaurant profile URL. |
| `city` | City slug inferred from the source URL. |
| `locality` | Locality or area shown by Zomato. |
| `address` | Public address text when available. |
| `cuisines` | Array of cuisine names. |
| `cuisineText` | Cuisines joined as text for spreadsheets. |
| `rating` | Numeric rating when available. |
| `ratingText` | Rating text exactly as shown by Zomato. |
| `reviewCount` | Parsed review count. |
| `costForTwo` | Cost-for-two text, for example `₹1,500 for two`. |
| `distance` | Distance label when present. |
| `isPromoted` | Whether the card is promoted/sponsored. |
| `isNew` | Whether Zomato marks the restaurant as new. |
| `imageUrl` | Main image URL. |
| `featuredImageUrl` | Featured image URL when available. |
| `offerText` | Public offer text when present. |
| `sourceUrl` | Zomato page where the record was found. |
| `sourceQuery` | Cuisine/query inferred from the source URL. |
| `scrapedAt` | ISO timestamp of extraction. |

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

The actor uses pay-per-event pricing.

There is a small run-start event and a per-restaurant item event.

The exact live tiered prices are shown on the Apify Store pricing tab. The default implementation charges only when a restaurant record is saved, so empty or blocked pages do not create item charges.

### Input

```json
{
  "startUrls": [
    { "url": "https://www.zomato.com/bangalore/restaurants" }
  ],
  "maxItems": 50,
  "maxPages": 20,
  "crawlCuisinePages": true,
  "includePromoted": true,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["SHADER"] }
}
````

### Input options explained

#### `startUrls`

Add one or more public Zomato URLs.

Good examples:

- `https://www.zomato.com/bangalore/restaurants`
- `https://www.zomato.com/bangalore/restaurants/biryani`
- `https://www.zomato.com/mumbai/restaurants/pizza`

#### `maxItems`

Maximum number of unique restaurants to save.

Use a small value for smoke tests and a larger value for city/cuisine lead generation.

#### `maxPages`

Maximum number of Zomato pages to fetch.

This protects your run from unexpectedly discovering too many cuisine or locality links.

#### `crawlCuisinePages`

When true, the actor follows public cuisine/locality links found in the embedded Zomato page state.

This is useful for collecting 100+ restaurants from a city page.

#### `includePromoted`

When false, promoted restaurant cards are filtered out.

Keep it true if you want the same visible restaurant universe a Zomato user sees.

### Output example

```json
{
  "restaurantId": "22243456",
  "name": "Ishaara",
  "url": "https://www.zomato.com/bangalore/ishaara-church-street-bangalore/info",
  "city": "bangalore",
  "locality": "Church Street, Bangalore",
  "address": "1st Floor, Church Street, Bangalore",
  "cuisines": ["Modern Indian", "Beverages"],
  "cuisineText": "Modern Indian, Beverages",
  "rating": 4.3,
  "reviewCount": 1276,
  "costForTwo": "₹1,500 for two",
  "isPromoted": false,
  "sourceUrl": "https://www.zomato.com/bangalore/restaurants",
  "scrapedAt": "2026-06-26T04:58:56.648Z"
}
```

### How to scrape Zomato restaurant leads

1. Open the actor on Apify.
2. Paste one or more public Zomato restaurant, city, or cuisine URLs.
3. Set `maxItems` to your target number of restaurants.
4. Keep `crawlCuisinePages` enabled for broader city coverage.
5. Run the actor.
6. Export the dataset to CSV, JSON, Excel, Google Sheets, or via API.

### Tips for better results

- Start with a city restaurant page for broad discovery.
- Start with a cuisine URL for targeted prospecting.
- Increase `maxPages` when you need more city coverage.
- Disable promoted cards if you want organic-only restaurant lists.
- Schedule recurring runs to monitor rating and review-count changes.

### Integrations

You can connect the output to:

- Google Sheets for sales prospecting.
- CRMs for restaurant outreach workflows.
- BI dashboards for cuisine and locality analysis.
- Data warehouses for historical monitoring.
- Apify webhooks for automatic downstream processing.

### 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/zomato-restaurant-search-scraper').call({
  startUrls: [{ url: 'https://www.zomato.com/bangalore/restaurants' }],
  maxItems: 100,
  maxPages: 20,
  crawlCuisinePages: true
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/zomato-restaurant-search-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.zomato.com/bangalore/restaurants'}],
    'maxItems': 100,
    'maxPages': 20,
    'crawlCuisinePages': True,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[:3])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~zomato-restaurant-search-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.zomato.com/bangalore/restaurants"}],"maxItems":100,"maxPages":20,"crawlCuisinePages":true}'
```

### MCP usage

Use this actor from Claude Desktop, Claude Code, or other MCP clients through Apify MCP.

MCP URL:

`https://mcp.apify.com/?tools=automation-lab/zomato-restaurant-search-scraper`

Claude Code setup:

```bash
claude mcp add apify-zomato-restaurant-search "https://mcp.apify.com/?tools=automation-lab/zomato-restaurant-search-scraper"
```

Claude Desktop JSON setup:

```json
{
  "mcpServers": {
    "apify-zomato-restaurant-search": {
      "url": "https://mcp.apify.com/?tools=automation-lab/zomato-restaurant-search-scraper"
    }
  }
}
```

Example prompts:

- "Scrape 100 Zomato restaurants from Bengaluru and summarize cuisines by locality."
- "Find Zomato biryani restaurants in Bengaluru with ratings and profile URLs."
- "Export Zomato restaurant leads into a spreadsheet-friendly table."

### Common workflows

#### Restaurant lead generation

Run a city page with cuisine discovery enabled, export CSV, then filter by locality, cuisine, rating, and review count.

#### Cuisine market mapping

Run multiple cuisine URLs such as biryani, pizza, Chinese, and desserts, then compare restaurant counts and ratings.

#### Local SEO monitoring

Schedule weekly runs for a fixed set of city/cuisine pages and track rating or review-count changes over time.

### Limitations

- The actor extracts public listing data visible in Zomato page state.
- It does not log in, bypass paywalls, place orders, or collect private account data.
- Zomato can change page structure; if embedded state changes, extraction may need maintenance.
- Detail-page-only data and full review text are outside the MVP output.

### FAQ and troubleshooting

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

The source pages may contain fewer unique restaurant cards, or several cuisine pages may repeat the same restaurants. Increase `maxPages`, add more start URLs, or enable cuisine discovery.

#### Why did a URL fail?

Check that the page is a public Zomato restaurant/search/cuisine page and returns normal HTML in a browser. Some old city slugs or malformed cuisine URLs can return 404.

#### Should I enable proxies?

The actor defaults to the cost-effective Apify SHADER proxy group because Zomato may block direct cloud datacenter traffic. Keep that default unless you have a trusted custom proxy.

### Legality and responsible use

This actor extracts publicly available Zomato page data. You are responsible for using the data legally, respecting applicable terms, privacy rules, and local regulations, and avoiding spam or abusive outreach.

### Related scrapers

- [Google Maps Lead Finder](https://apify.com/automation-lab/google-maps-lead-finder) — broader local-business lead discovery.
- [Google Maps Reviews Scraper](https://apify.com/automation-lab/google-maps-reviews-scraper) — review monitoring and reputation analysis.
- [Website Contact Finder](https://apify.com/automation-lab/website-contact-finder) — enrich restaurant or business websites with contact details.

### Changelog

#### 0.1

Initial private build for public Zomato restaurant search and cuisine page extraction.

### Support

If a public Zomato restaurant page stops working, open an Apify issue with the run ID, input, and expected city/cuisine. Include whether proxies were enabled.

# Actor input Schema

## `startUrls` (type: `array`):

Public Zomato restaurant/search pages to scrape, such as city restaurant pages or cuisine pages.

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

Maximum number of unique restaurant records to save.

## `maxPages` (type: `integer`):

Safety cap for fetched Zomato pages, including discovered cuisine/locality pages.

## `crawlCuisinePages` (type: `boolean`):

Follow public cuisine and nearby restaurant links found in the embedded Zomato page state to collect more restaurants without using private APIs.

## `includePromoted` (type: `boolean`):

Keep sponsored/promoted restaurant cards in the output. Disable to return only organic listings.

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

Apify proxy settings. SHADER is enabled by default because Zomato blocks some cloud datacenter requests.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.zomato.com/bangalore/restaurants"
    }
  ],
  "maxItems": 20,
  "maxPages": 20,
  "crawlCuisinePages": true,
  "includePromoted": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "SHADER"
    ]
  }
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.zomato.com/bangalore/restaurants"
        }
    ],
    "maxItems": 20,
    "maxPages": 20,
    "crawlCuisinePages": true,
    "includePromoted": true,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "SHADER"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/zomato-restaurant-search-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 = {
    "startUrls": [{ "url": "https://www.zomato.com/bangalore/restaurants" }],
    "maxItems": 20,
    "maxPages": 20,
    "crawlCuisinePages": True,
    "includePromoted": True,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["SHADER"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/zomato-restaurant-search-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 '{
  "startUrls": [
    {
      "url": "https://www.zomato.com/bangalore/restaurants"
    }
  ],
  "maxItems": 20,
  "maxPages": 20,
  "crawlCuisinePages": true,
  "includePromoted": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "SHADER"
    ]
  }
}' |
apify call automation-lab/zomato-restaurant-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zomato Restaurant Search Scraper",
        "description": "Extract public Zomato restaurant leads with ratings, cuisines, review counts, locality, cost-for-two, images, and profile URLs.",
        "version": "0.1",
        "x-build-id": "jYWKQIVCxYmoshUHT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~zomato-restaurant-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-zomato-restaurant-search-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~zomato-restaurant-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-zomato-restaurant-search-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~zomato-restaurant-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-zomato-restaurant-search-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Zomato city or cuisine URLs",
                        "type": "array",
                        "description": "Public Zomato restaurant/search pages to scrape, such as city restaurant pages or cuisine pages.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum restaurants",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of unique restaurant records to save.",
                        "default": 20
                    },
                    "maxPages": {
                        "title": "Maximum pages to fetch",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Safety cap for fetched Zomato pages, including discovered cuisine/locality pages.",
                        "default": 20
                    },
                    "crawlCuisinePages": {
                        "title": "Discover cuisine/locality pages",
                        "type": "boolean",
                        "description": "Follow public cuisine and nearby restaurant links found in the embedded Zomato page state to collect more restaurants without using private APIs.",
                        "default": true
                    },
                    "includePromoted": {
                        "title": "Include promoted restaurants",
                        "type": "boolean",
                        "description": "Keep sponsored/promoted restaurant cards in the output. Disable to return only organic listings.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy settings. SHADER is enabled by default because Zomato blocks some cloud datacenter requests.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "SHADER"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```