# Swiggy Email Scraper (`scraperx/swiggy-email-scraper`) Actor

📧 Swiggy Email Scraper finds restaurant/brand emails from Swiggy pages fast. Automate lead generation for B2B sales, marketing & outreach. 🏷️ Export results easily. 🚀 Save time, boost conversions.

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

## Pricing

from $3.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

### **Swiggy** Email Scraper 📱

The **Swiggy** Email Scraper allows users to **extract** a wide range of **data** from the **Swiggy** platform. It focuses on retrieving accurate and structured email addresses, ensuring you have access to valuable customer information.

In addition to **emails**, the tool can gather supplementary **data** such as customer names, order details, and location-based information. This makes it a comprehensive solution for businesses looking to analyze customer behavior or improve marketing strategies.

The **extract**ed **data** is delivered in a clean and organized format, ready for immediate use. By automating the **data** collection process, the **Swiggy** Email Scraper saves time and minimizes manual effort.

Its robust functionality ensures high-quality results, even for large-scale **data** **extract**ion projects.

Swiggy Email Scraper is a powerful tool designed to extract email addresses and other relevant data from the Swiggy platform. It enables businesses and developers to gather essential contact information quickly and efficiently.

With the Swiggy Email Scraper, you can automate the process of collecting customer emails, saving time and effort. It is ideal for businesses looking to enhance their marketing campaigns or improve customer outreach.

This Swiggy data extraction tool is user-friendly and highly customizable, making it suitable for both technical and non-technical users. It ensures accurate and reliable data extraction for a variety of use cases.

### 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 |
| --- | --- |
| Customer Emails | Retrieve verified email addresses of Swiggy customers for marketing or outreach purposes. |
| Customer Names | Extract customer names associated with their email addresses for personalized communication. |
| Order Details | Collect information about customer orders, including order IDs and item details. |
| Delivery Locations | Gather location data such as delivery addresses or cities for geographic analysis. |
| Restaurant Details | Extract restaurant names, contact information, and locations from the Swiggy platform. |
| Order Time Stamps | Capture the date and time of customer orders for trend analysis. |
| Customer Reviews | Retrieve customer reviews and ratings for restaurants or orders. |
| Payment Methods | Identify customer-preferred payment methods for financial insights. |

### Key Features of **Swiggy** Email Scraper

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

- ⭐ **Automated** scraping of customer email addresses from the **Swiggy** platform
- ⭐ **Customizable** scraping parameters to target specific data types or regions
- ⭐ User-friendly interface suitable for both technical and non-technical users
- ⭐ **High** accuracy and reliability in extracting structured data
- ⭐ **Fast** and efficient data extraction for large-scale projects
- ⭐ Compliance with legal and ethical data scraping guidelines
- ⭐ **Secure** handling of sensitive customer information
- ⭐ Support for exporting data in multiple formats such as CSV or JSON
- ⭐ Real-time data extraction for up-to-date information
- ⭐ **Advanced** filtering options to refine extracted data
- ⭐ Seamless integration with other tools and APIs
- ⭐ **Regular** updates to ensure compatibility with **Swiggy**s platform changes

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

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

1. ✅ **Sign up** for an account on the **Swiggy** Email Scraper platform
2. ✅ Log in to the dashboard and select the **Swiggy** email scraping tool
3. ✅ **Configure** the scraping parameters such as target data types and regions
4. ✅ Enter the **Swiggy** URLs or keywords you want to scrape data from
5. ✅ **Start** the scraping process and monitor progress in real-time
6. ✅ **Review** the extracted data in the dashboard for accuracy and completeness
7. ✅ **Export** the data in your preferred format such as CSV or JSON
8. ✅ Use the extracted data for marketing analysis or other business purposes
9. ✅ Schedule automated scraping tasks for regular data updates
10. ✅ Access support or troubleshooting resources if needed

### Use Cases 🎯

Marketing Campaigns
🎯 Build targeted email lists for promotional campaigns
🎯 Enhance customer engagement with personalized email outreach

Customer Behavior Analysis
🎯 **Analyze** order trends and preferences based on customer data
🎯 **Identify** popular delivery locations and peak ordering times

Restaurant Insights
🎯 Gather reviews and ratings for competitor analysis
🎯 Extract restaurant contact details for partnership opportunities

Business Expansion
🎯 **Identify** high-demand regions for new service launches
🎯 **Use** customer data to tailor services to specific markets

### Why choose us? 💎

The **Swiggy** Email Scraper is designed with both efficiency and accuracy in mind, making it the **best** **Swiggy** email scraping software available. Our tool is built to handle large-scale data extraction projects while maintaining high levels of precision.

It is **user-friendly** and accessible to users of all technical skill levels, ensuring that anyone can benefit from its capabilities. We prioritize compliance with legal and ethical guidelines, giving you peace of mind when using our tool.

Our team is dedicated to providing **regular** updates and support to ensure compatibility with **Swiggy**'s platform changes. With **advanced** features like customizable parameters and real-time scraping, our tool stands out as a **reliable** solution for your data extraction needs.

Whether you're looking to enhance marketing campaigns, analyze customer behavior, or expand your business, the **Swiggy** Email Scraper is the ideal choice. Choose us for a secure, efficient, and comprehensive email scraping solution.

### **Swiggy** Email Scraper Scalability 📈

The **Swiggy** Email Scraper is designed to scale **seamless**ly with your data extraction needs. Whether you're a small business or a large enterprise, our tool can handle projects of any size.

It offers fast and **efficient** scraping, ensuring that even large datasets are processed in minimal time. With **advanced** filtering and customization options, you can tailor the scraping process to meet specific requirements.

Our tool supports automated scheduling, allowing you to set up regular scraping tasks for continuous data updates. It is built with robust infrastructure to handle high volumes of traffic and data requests without compromising performance.

As your business grows, the **Swiggy** Email Scraper grows with you, providing a reliable and scalable solution for all your email scraping needs.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **Swiggy**s terms of service when using the scraper
⚖️ **Do not** use the tool for unauthorized or malicious purposes
⚖️ **Avoid** scraping personal data beyond what is legally permissible
⚖️ Respect customer privacy and adhere to data protection regulations
⚖️ **Use** the extracted data responsibly and for legitimate business purposes only
⚖️ **Obtain** necessary permissions when required for data usage
⚖️ **Do not** share or sell extracted data without proper authorization
⚖️ Stay informed about changes to legal and ethical guidelines for data scraping

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Swiggy Email Scraper"],
  "country": "Global",
  "maxEmailNumbers": 20,
  "platform": "Swiggy",
  "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 (Swiggy) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "Swiggy",
    "keyword": "Swiggy 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 Swiggy as the source |
| keyword | Keyword that triggered the result (Swiggy Email Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Swiggy profile link |
| email | Extracted email address |

### FAQ ❓

#### What is the Swiggy **Email Scraper**?

The Swiggy Email Scraper is a tool designed to extract email addresses and other data from the Swiggy platform efficiently.

#### Is the Swiggy **Email Scraper** **legal** to use?

**Yes**, the tool is legal to use as long as you comply with Swiggy's terms of service and data protection regulations.

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

You can extract customer **emails**, names, order details, delivery locations, restaurant information, and more.

#### Is the tool suitable for non-technical users?

**Yes**, the Swiggy Email Scraper is **user-friendly** and designed for both technical and non-technical users.

#### Can I customize the scraping parameters?

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

#### How is the **extract**ed data delivered?

The extracted data is delivered in formats like **CSV** or **JSON** for easy use.

#### Does the tool support automated scraping tasks?

**Yes**, you can schedule **automated** scraping tasks for regular data updates.

#### Is my data **secure** while using the tool?

**Yes**, the tool ensures **secure** handling of sensitive customer information.

#### Can I use the tool for **large-scale** data **extract**ion?

**Yes**, the Swiggy Email Scraper is designed to handle large-scale data extraction projects efficiently.

#### What support options are available?

Our team provides **regular updates** and support to ensure the tool's compatibility and functionality.

#### Can I **export** data in real-time?

**Yes**, the tool supports real-time data extraction and export for up-to-date information.

#### Does the tool comply with data protection regulations?

**Yes**, the Swiggy Email Scraper is designed to comply with data protection regulations and ethical guidelines.

#### What happens if Swiggy updates its platform?

Our team provides **regular updates** to ensure compatibility with any changes to Swiggy's platform.

#### Is there a **limit** to the amount of data I can scrape?

The tool is scalable and can handle projects of any size, depending on your requirements.

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

**Yes**, the tool can extract data like customer reviews and restaurant details for competitor analysis.

# Actor input Schema

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

List of keywords to search for on Swiggy (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Swiggy 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": "Swiggy",
  "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("scraperx/swiggy-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("scraperx/swiggy-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 scraperx/swiggy-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Swiggy Email Scraper",
        "description": "📧 Swiggy Email Scraper finds restaurant/brand emails from Swiggy pages fast. Automate lead generation for B2B sales, marketing & outreach. 🏷️ Export results easily. 🚀 Save time, boost conversions.",
        "version": "0.1",
        "x-build-id": "Bwh21WwNLIRSwFdMq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperx~swiggy-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperx-swiggy-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/scraperx~swiggy-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperx-swiggy-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/scraperx~swiggy-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperx-swiggy-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 Swiggy (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Swiggy profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Swiggy"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Swiggy"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```