# Zomato Email Scraper (`scraper-engine/zomato-email-scraper`) Actor

Zomato Email Scraper extracts publicly available business emails from Zomato restaurant listings. Use it to build targeted lead lists by city, cuisine, or rating. Ideal for sales teams, marketers, and agencies needing accurate restaurant contact data at scale.

- **URL**: https://apify.com/scraper-engine/zomato-email-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 3 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## 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** Email Scraper 📱

**Zomato** Email Scraper allows users to **extract** a wide range of **data** from **Zomato**'s restaurant listings. This includes essential **contact** details like email addresses, phone numbers, and website links.

The tool also captures additional information such as restaurant names, locations, and cuisine types. By using this **Zomato** **contact** scraper, you can gather structured **data** that is ready for analysis or integration into your CRM.

The software is designed to handle large volumes of **data**, making it suitable for businesses of all sizes. Extracting **emails** from **Zomato** is a seamless process with this automated tool, ensuring you get accurate and reliable information.

With its user-friendly interface, even non-technical users can benefit from its powerful **data** mining capabilities. This **Zomato** lead generation tool is perfect for building **contact** lists, conducting market research, or identifying potential business partners.

Zomato Email Scraper is a powerful tool designed to extract contact information from Zomato's vast database of restaurants and food businesses. It simplifies the process of gathering valuable email addresses for marketing and lead generation purposes.

With Zomato data extraction tools, you can efficiently mine data from restaurant listings, ensuring you have the most up-to-date contact details. This automated Zomato email extractor saves time and effort compared to manual data collection.

Zomato Email Scraper is ideal for businesses looking to connect with restaurants, cafes, and food service providers. It provides a reliable solution for extracting emails and other relevant data from Zomato's platform.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: dev.scraperengine@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email Addresses | Extract verified email addresses of restaurants and food businesses listed on Zomato. |
| Restaurant Names | Retrieve the names of restaurants for identification and categorization. |
| Phone Numbers | Collect contact phone numbers for direct communication with businesses. |
| Website Links | Access official website URLs for additional information or inquiries. |
| Locations | Gather detailed location data, including city and address, for targeted outreach. |
| Cuisine Types | Identify the type of cuisine offered by each restaurant for niche marketing. |
| Ratings and Reviews | Extract ratings and reviews to assess the popularity and quality of restaurants. |
| Operating Hours | Retrieve information about the operating hours of listed restaurants. |

### Key Features of **Zomato** Email Scraper

Here are the **standout features** that make the **Zomato** Email Scraper a **top-tier tool** for **marketers**, **agencies**, and **researchers**:

- ⭐ **Automated** email scraping from **Zomato**s restaurant listings
- ⭐ Ability to extract multiple data types including emails phone numbers and locations
- ⭐ User-friendly interface suitable for both technical and non-technical users
- ⭐ **High** accuracy and reliability in data extraction results
- ⭐ Supports large-scale data mining for extensive lead generation campaigns
- ⭐ **Customizable** scraping options to target specific regions or cuisine types
- ⭐ **Fast** processing speeds to save time on data collection
- ⭐ Export data in multiple formats such as CSV or Excel for easy integration
- ⭐ Built-in compliance checks to ensure ethical data usage
- ⭐ **Regular** updates to maintain compatibility with **Zomato**s platform

### How to use **Zomato** Email Scraper 🚀

Follow this **simple, step-by-step guide** to start extracting **Zomato** emails today:

1. ✅ **Sign up** for an account on the **Zomato** Email Scraper platform
2. ✅ Log in to the dashboard and configure your scraping preferences
3. ✅ Enter the target location or cuisine type to narrow down the search
4. ✅ **Select** the data fields you want to extract such as emails or phone numbers
5. ✅ Initiate the scraping process and monitor progress in real-time
6. ✅ Download the extracted data in your preferred format once the process is complete
7. ✅ **Review** the data for accuracy and remove any duplicates if necessary
8. ✅ **Integrate** the data into your CRM or use it for your marketing campaigns

### Use Cases 🎯

Lead Generation
🎯 Build targeted email lists for restaurant marketing campaigns
🎯 **Identify** potential clients in the food and beverage industry

Market Research
🎯 **Analyze** restaurant trends based on location and cuisine types
🎯 Gather data for competitor analysis and business strategy development

Business Outreach
🎯 Connect with restaurant owners for partnerships or collaborations
🎯 Promote your services to food businesses using accurate contact data

Data Integration
🎯 Incorporate extracted data into CRM systems for streamlined operations
🎯 **Use** structured data for creating targeted advertising campaigns

### Why choose us? 💎

**Zomato** Email Scraper is designed to offer unparalleled efficiency and accuracy in data extraction. Our tool is equipped with **advanced** algorithms to ensure you get the most relevant and up-to-date information.

Unlike manual data collection, our automated **Zomato** email extractor saves time and reduces errors. We prioritize user experience by offering a simple and intuitive interface suitable for all skill levels.

Our software is built with scalability in mind, making it ideal for both small businesses and large enterprises. By choosing our **Zomato** data extraction tool, you gain access to **reliable** customer support and **regular** updates.

We are committed to providing a solution that adheres to ethical guidelines and ensures data security. Whether you need to extract emails from **Zomato** for lead generation or market research, our tool delivers consistent results.

Trust us to help you unlock the full potential of **Zomato**'s extensive database for your business needs.

### **Zomato** Email Scraper Scalability 📈

**Zomato** Email Scraper is built to handle data extraction tasks of any size. Whether you need to scrape a few hundred entries or millions of records, our tool can scale to meet your requirements.

The software is optimized for speed and efficiency, ensuring quick results even for **large-scale** projects. With **customizable** options, you can tailor the extraction process to focus on specific regions or data types.

Our automated **Zomato** email extractor is designed to work **seamless**ly without compromising on accuracy. Businesses of all sizes can benefit from its robust performance and flexibility.

By using our **Zomato** contact scraper, you can easily expand your marketing efforts or research capabilities. Scalability is at the core of our software, making it a reliable choice for growing businesses and enterprises alike.

### **Zomato** Email Scraper Legal Guidelines ⚖️

**Yes**—scraping **Zomato** is **legal** as long as you follow **ethical** and **compliant** practices. The **Zomato** Email Scraper extracts only **publicly available** information from **public** **Zomato** profiles, making it **safe** and **compliant** for **research**, **marketing**, and **analysis**.

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **Zomato**s terms of service when using this tool
⚖️ **Do not** use the extracted data for spamming or unsolicited communications
⚖️ **Obtain** proper consent before contacting individuals or businesses from the data
⚖️ **Use** the tool only for legitimate business or research purposes
⚖️ **Avoid** scraping sensitive or personal information that is not publicly available
⚖️ Regularly review and adhere to local data privacy laws and regulations
⚖️ **Do not** resell or redistribute the extracted data without proper authorization
⚖️ **Use** the **Zomato** Email Scraper responsibly to maintain ethical standards

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Zomato Email Scraper"],
  "country": "Global",
  "maxEmailNumbers": 20,
  "platform": "Zomato",
  "engine": "legacy"
}
````

### Input Table

| Data Type | Description |
| --- | --- |
| keywords | Keywords to find relevant profiles |
| country | Country setting (Global) |
| maxEmailNumbers | Maximum emails to collect (default 20) |
| platform | Platform to scrape (Zomato) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "Zomato",
    "keyword": "Zomato Email Scraper",
    "title": "Google's Single-Benefit Marketing Strategy for Chrome ...",
    "description": "✓For years, once we created a Gmail account, we couldn't change the username (the part before @ gmail.com ). ... Grand Rapids Marketing Co. Read more",
    "url": "https://www.linkedin.com/posts/phill-agnew_heres-how-google-marketed-chrome-browser-activity-7404878510214914048-dLxI",
    "email": "before@gmail.com"
  }
]
```

### Output Table

| Data Type | Description |
| --- | --- |
| network | Identifies Zomato as the source |
| keyword | Keyword that triggered the result (Zomato Email Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Zomato profile link |
| email | Extracted email address |

### FAQ ❓

#### What is Zomato **Email Scraper**?

Zomato Email Scraper is a tool designed to extract email addresses and other data from Zomato's restaurant listings.

#### How does the Zomato data **extract**ion tool work?

The tool uses **automated** algorithms to scrape data from Zomato based on your specified criteria.

#### Can I **extract** data from **specific** locations on Zomato?

**Yes**, you can configure the scraper to target specific cities or regions for data extraction.

#### Is the Zomato contact scraper easy to use?

**Yes**, the tool features a **user-friendly** interface suitable for both technical and non-technical users.

#### What formats can I **export** the **extract**ed data in?

You can export the data in formats such as **CSV** or Excel for easy integration.

#### Is this Zomato email scraping software compliant with **legal** guidelines?

**Yes**, the tool is designed to adhere to ethical and legal standards for data usage.

#### Can I use the Zomato **lead generation** tool for **large-scale** projects?

**Yes**, the tool is scalable and can handle data extraction tasks of any size.

#### What types of data can I **extract** using this tool?

You can extract email addresses, phone numbers, restaurant names, locations, and more.

#### Is **customer support** available for the Zomato **Email Scraper**?

**Yes**, we offer reliable customer support to assist with any issues or questions.

#### How often is the software updated?

The tool is regularly updated to ensure compatibility with Zomato's platform and maintain performance.

#### Can I use this tool for competitor analysis?

**Yes**, the tool is ideal for gathering data for competitor analysis and market research.

#### Is the Zomato **Email Scraper** **secure**?

**Yes**, the tool is designed with data security and user privacy in mind.

#### Do I need technical skills to use this tool?

**No**, the tool is easy to use and does not require advanced technical skills.

#### Can I customize the scraping parameters?

**Yes**, the tool allows you to customize settings such as target location and data types.

#### What is the primary purpose of this Zomato data mining software?

The primary purpose is to extract valuable data from Zomato for lead generation, research, and business outreach.

# Actor input Schema

## `keywords` (type: `array`):

List of keywords to search for on Zomato (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Zomato profiles/posts containing these keywords and extract email addresses.

## `platform` (type: `string`):

Select platform.

## `location` (type: `string`):

Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.

## `emailDomains` (type: `array`):

Optional: Filter results to only include emails from specific domains (e.g., \['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.

## `maxEmails` (type: `integer`):

Maximum number of emails to collect per keyword (default: 20).

## `engine` (type: `string`):

Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE\_SERP proxy with traditional selectors - more reliable but slower and more expensive.

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

Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries.

## Actor input object example

```json
{
  "keywords": [
    "marketing"
  ],
  "platform": "Zomato",
  "location": "",
  "emailDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "keywords": [
        "marketing"
    ],
    "emailDomains": [
        "@gmail.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-engine/zomato-email-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 = {
    "keywords": ["marketing"],
    "emailDomains": ["@gmail.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scraper-engine/zomato-email-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 '{
  "keywords": [
    "marketing"
  ],
  "emailDomains": [
    "@gmail.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraper-engine/zomato-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zomato Email Scraper",
        "description": "Zomato Email Scraper extracts publicly available business emails from Zomato restaurant listings. Use it to build targeted lead lists by city, cuisine, or rating. Ideal for sales teams, marketers, and agencies needing accurate restaurant contact data at scale.",
        "version": "0.1",
        "x-build-id": "tak9Rfl0c9BB7FUM3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~zomato-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-zomato-email-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/scraper-engine~zomato-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-zomato-email-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/scraper-engine~zomato-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-zomato-email-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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "List of keywords to search for on Zomato (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Zomato profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Zomato"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Zomato"
                    },
                    "location": {
                        "title": "Location Filter",
                        "type": "string",
                        "description": "Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.",
                        "default": ""
                    },
                    "emailDomains": {
                        "title": "Email Domains Filter",
                        "type": "array",
                        "description": "Optional: Filter results to only include emails from specific domains (e.g., ['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Maximum Emails per Keyword",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect per keyword (default: 20).",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "legacy"
                        ],
                        "type": "string",
                        "description": "Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE_SERP proxy with traditional selectors - more reliable but slower and more expensive.",
                        "default": "legacy"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```