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

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

## Pricing

from $2.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

The **Zomato** Email Scraper allows users to **extract** a wide range of **data** from **Zomato**'s restaurant listings. This includes essential **contact** information such as email addresses, phone numbers, and website URLs.

Additionally, users can gather restaurant-specific details like names, locations, cuisines, and ratings. The tool is designed to ensure high accuracy and relevance of the **extract**ed **data**.

By automating the **data** **extract**ion process, users can save time and focus on utilizing the information for their business objectives. Whether you're looking to build a **data**base of restaurant **contact**s or analyze market trends, this scraper provides reliable and comprehensive results.

Zomato Email Scraper is a powerful tool designed to extract contact information from Zomato's restaurant database efficiently. It simplifies the process of gathering emails for marketing, research, or lead generation purposes.

With the Zomato Email Scraper, users can automate the extraction of valuable data from Zomato, saving time and effort compared to manual collection. This tool is ideal for businesses looking to connect with restaurant owners or managers.

Our Zomato data extraction tool ensures high accuracy and reliability when harvesting emails and other contact details. It is built to handle large-scale data scraping while maintaining compliance with legal guidelines.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: scrapier.io@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email Address | Extracts the email addresses of restaurants listed on Zomato. |
| Phone Number | Retrieves phone numbers provided by restaurants for contact purposes. |
| Restaurant Name | Captures the names of restaurants listed on Zomato. |
| Location | Extracts detailed location information, including city and address. |
| Cuisine Type | Identifies the type of cuisine served by each restaurant. |
| Ratings and Reviews | Gathers ratings and reviews to assess restaurant popularity. |
| Website URL | Retrieves the official website links provided by restaurants. |
| Opening Hours | Extracts the operating hours of restaurants listed on Zomato. |

### 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**:

- ⭐ Automates email scraping for **Zomato** restaurants with high accuracy
- ⭐ Supports extraction of multiple data types including emails phone numbers and locations
- ⭐ User-friendly interface for easy configuration and operation
- ⭐ Handles large-scale data extraction efficiently without compromising speed
- ⭐ **Customizable** filters to target specific restaurants or locations
- ⭐ Ensures compliance with legal and ethical guidelines during data scraping
- ⭐ Provides detailed logs and reports for tracking extraction progress
- ⭐ Integrates seamlessly with **Zomato**s API for reliable data access
- ⭐ Offers robust error handling and retry mechanisms for uninterrupted scraping
- ⭐ **Secure**ly stores extracted data for further analysis and usage

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

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

1. ✅ Download and install the **Zomato** Email Scraper on your system
2. ✅ Launch the tool and configure the scraping parameters such as location or cuisine type
3. ✅ Enter your **Zomato** API credentials to ensure secure data access
4. ✅ **Select** the data types you wish to extract such as email addresses or phone numbers
5. ✅ Set filters to refine your search like targeting specific cities or restaurant categories
6. ✅ **Start** the scraping process and monitor progress through the built-in dashboard
7. ✅ Once completed export the extracted data in your preferred format (CSV JSON etc)
8. ✅ **Review** the results and utilize the data for your business needs

### Use Cases 🎯

Marketing Campaigns
🎯 **Use** the **Zomato** Email Scraper to collect restaurant emails for targeted email marketing
🎯 Generate leads for promotional campaigns focused on specific cuisines or locations

Market Research
🎯 **Analyze** restaurant data to identify trends in customer preferences and dining habits
🎯 Gather insights into popular cuisines and high-rated restaurants in specific areas

Lead Generation
🎯 Build a comprehensive database of restaurant contacts for business outreach
🎯 **Identify** potential partners or clients in the food and beverage industry

Competitor Analysis
🎯 Extract competitor data to evaluate their market presence and customer reviews
🎯 Understand pricing menu offerings and operational hours of competing restaurants

### Why choose us? 💎

Our **Zomato** Email Scraper is designed to provide unmatched efficiency and reliability in data extraction. With **advanced** features like customizable filters and seamless API integration, it delivers precise results tailored to your needs.

We prioritize user experience by offering a simple interface and robust error handling to ensure smooth operation. Whether you're a marketer, researcher, or developer, our tool adapts to diverse requirements, making it a versatile solution for **Zomato** data extraction.

Additionally, we adhere to strict legal and ethical standards, ensuring compliance during every stage of the scraping process. By choosing our **Zomato** data extraction tool, you gain access to high-quality data that empowers your business decisions and strategies effectively.

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

The **Zomato** Email Scraper is built to handle **large-scale** data extraction effortlessly. Its **advanced** architecture ensures high-speed performance even when processing **extensive** restaurant databases.

Whether you need data from a single city or multiple regions, the tool scales to meet your requirements without compromising accuracy. With **customizable** filters and batch processing capabilities, users can **efficient**ly target specific segments of **Zomato**'s listings.

This scalability makes it suitable for businesses of all sizes, from startups to enterprises, looking to leverage **Zomato** data for growth and analysis. By automating the scraping process, our tool eliminates manual effort, allowing you to focus on utilizing the extracted data for impactful results.

### **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 the scraper
⚖️ **Do not** use the tool to extract data for illegal or unethical purposes
⚖️ **Avoid** sharing or selling extracted data without proper authorization
⚖️ Respect user privacy and refrain from scraping sensitive or personal information
⚖️ **Use** the scraper responsibly and limit requests to prevent server overload
⚖️ Verify the accuracy of extracted data before using it for business purposes
⚖️ **Adhere** to local data protection laws and regulations during data extraction
⚖️ Consult legal professionals if unsure about the legality of scraping **Zomato** data

### 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 the Zomato **Email Scraper**?

It is a tool designed to extract contact information like **emails** and phone numbers from Zomato's restaurant database.

#### Can I use the scraper for **lead generation**?

**Yes**, the Zomato Email Scraper is ideal for building a database of restaurant contacts for lead generation purposes.

#### Is the tool compliant with **legal** guidelines?

**Yes**, the scraper adheres to legal and ethical standards, ensuring **compliance** during data extraction.

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

You can extract **emails**, phone numbers, restaurant names, locations, cuisines, ratings, and more.

#### How do I configure the scraper?

You can configure the scraper by setting parameters like location, cuisine type, and data types to extract.

#### Can I **export** the **extract**ed data?

**Yes**, the tool allows you to export data in formats like **CSV** or **JSON** for further analysis.

#### Does the scraper work with Zomato's API?

**Yes**, the tool integrates **seamless**ly with Zomato's API for reliable data access.

#### Is the scraper suitable for **large-scale** data **extract**ion?

**Yes**, it is designed to handle extensive restaurant databases efficiently without compromising accuracy.

#### What are the system requirements for the tool?

The tool requires a stable internet connection and a computer capable of running modern software applications.

#### Can I customize the filters for data **extract**ion?

**Yes**, the scraper allows you to set filters to target specific restaurants, locations, or cuisines.

#### Is technical support available for the scraper?

**Yes**, we provide **dedicated support** to assist users with installation, configuration, and troubleshooting.

#### How long does the scraping process take?

The duration depends on the size of the database and the parameters set, but the tool is optimized for speed.

#### Are there any **limit**ations on the data I can scrape?

The tool is designed to extract **publicly available** information listed on Zomato.

#### Can I use the scraper for competitor analysis?

**Yes**, the tool can help you gather data on competing restaurants for strategic insights.

# 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("scrapapi/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("scrapapi/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 scrapapi/zomato-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zomato Email Scraper",
        "version": "0.1",
        "x-build-id": "lbSDSNRsi0DlDYgB2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~zomato-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-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/scrapapi~zomato-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-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/scrapapi~zomato-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```