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

- **URL**: https://apify.com/scrapapi/swiggy-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

### **Swiggy** Email Scraper 📱

The **Swiggy** Email Scraper allows users to **extract** critical customer email **data** from **Swiggy**'s platform. This **data** can be used to build targeted marketing campaigns, analyze customer trends, and improve overall business strategies.

The scraper ensures that **data** **extract**ion is conducted efficiently and securely, adhering to legal guidelines. Extractable **data** includes customer **emails**, order-related information, and user profiles.

By utilizing the **Swiggy** email **extract**or software, businesses can gain deeper insights into their customer base and optimize their operations. The tool is designed to handle large volumes of **data**, making it suitable for businesses of all sizes.

Swiggy Email Scraper is a powerful tool designed to help businesses extract valuable customer email data from Swiggy's platform. It enables streamlined data collection for marketing and analytics purposes.

With the Swiggy Email Scraper, you can automate the process of gathering user emails, saving time and effort compared to manual methods. This tool is ideal for businesses looking to expand their reach and optimize their strategies.

Swiggy data extraction tools like this scraper are essential for businesses aiming to understand customer preferences and behaviors. Efficient email scraping for Swiggy ensures accurate and actionable insights.

### 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 |
| --- | --- |
| Customer Email Addresses | Extract verified email addresses of Swiggy users for marketing and outreach. |
| Order Details | Retrieve order-related information such as order IDs and timestamps. |
| User Profiles | Gather user profile data including names and preferences. |
| Restaurant Information | Extract details about restaurants such as names and locations. |
| Delivery Areas | Identify delivery zones and areas covered by Swiggy. |
| Ratings and Reviews | Access customer feedback and ratings for restaurants and services. |
| Promotional Data | Collect information on discounts and promotional offers available on Swiggy. |
| Transaction History | Retrieve payment and transaction records for analysis. |

### 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** extraction of **Swiggy** customer email addresses for targeted outreach
- ⭐ **Secure** and efficient data harvesting compliant with legal standards
- ⭐ Ability to extract large volumes of data in minimal time
- ⭐ **Customizable** scraping settings for specific data requirements
- ⭐ Supports integration with other data analysis tools and platforms
- ⭐ Provides detailed logs and reports for tracking and auditing purposes
- ⭐ User-friendly interface for seamless operation and setup
- ⭐ **Advanced** filtering options to refine extracted data based on criteria
- ⭐ **Regular** updates to ensure compatibility with **Swiggy**s platform changes
- ⭐ Scalable solution suitable for businesses of all sizes and industries

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

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

1. ✅ Download and install the **Swiggy** Email Scraper software from the official website
2. ✅ Log in to the tool using your credentials and configure the settings as required
3. ✅ **Select** the data types you wish to extract such as customer emails or order details
4. ✅ **Input** specific filters or criteria to refine the scraping process
5. ✅ Initiate the scraping process and monitor progress through the dashboard
6. ✅ Download the extracted data in your preferred format once the process is complete
7. ✅ **Integrate** the data with your existing analytics tools for further processing
8. ✅ Regularly update the software to ensure compatibility with **Swiggy**s platform

### Use Cases 🎯

Marketing Campaign Optimization
🎯 Extract **Swiggy** user emails to create targeted email campaigns
🎯 **Analyze** customer preferences to tailor promotional offers

Customer Insights and Analytics
🎯 Gather user profile data to understand customer behavior
🎯 Utilize transaction history for trend analysis

Restaurant Performance Analysis
🎯 Access ratings and reviews to evaluate restaurant services
🎯 **Identify** popular delivery areas for strategic planning

Business Expansion Strategies
🎯 **Use** **Swiggy** data extraction tools to identify new market opportunities
🎯 Leverage promotional data to attract more customers

### Why choose us? 💎

The **Swiggy** Email Scraper is designed to meet the diverse needs of businesses seeking efficient data extraction solutions. Our tool is equipped with **advanced** features that ensure secure and accurate data harvesting from **Swiggy**'s platform.

By using our **Swiggy** email extractor software, businesses can gain access to valuable customer information for targeted marketing and analytics. We prioritize user experience with a simple interface and customizable settings, making it easy for businesses to adapt the tool to their requirements.

Our automated **Swiggy** email scraping service is **scalable**, allowing businesses of all sizes to benefit from **reliable** data extraction. We offer **regular** updates and dedicated support to ensure the tool remains compatible with **Swiggy**'s platform changes.

Choosing our **Swiggy** data extraction tool means investing in a solution that delivers consistent results and helps businesses achieve their goals efficiently.

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

The **Swiggy** Email Scraper is built to handle **large-scale** data extraction needs for businesses of all sizes. Whether you are a small startup or a large enterprise, our tool adapts to your requirements **seamless**ly.

Automated **Swiggy** email scraping ensures consistent performance even when processing high volumes of data. The scraper's **customizable** settings allow businesses to refine their data extraction processes based on specific criteria.

With support for integration into existing systems, the tool can scale alongside your business growth. Regular updates and improvements ensure that the **Swiggy** email extractor software remains reliable and **efficient** over time.

Our solution is designed to provide long-term value, making it a dependable choice for businesses looking to optimize their operations.

### **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 before using the scraper
⚖️ **Do not** use the **Swiggy** Email Scraper to collect data for illegal activities
⚖️ **Obtain** explicit consent from users before using their email data for marketing purposes
⚖️ **Avoid** scraping sensitive or personal information that is not publicly available
⚖️ **Use** the tool responsibly and adhere to local data protection regulations
⚖️ Regularly review legal guidelines to ensure compliance with updated laws

### 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 customer email data and other information from Swiggy's platform.

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

**Yes**, as long as you comply with Swiggy's terms of service and local data protection laws.

#### What data can I **extract** using the Swiggy **Email Scraper**?

You can extract customer **emails**, order details, user profiles, restaurant information, and more.

#### How do I install the Swiggy **Email Scraper**?

Download the software from our website and follow the installation instructions provided.

#### Can I customize the data **extract**ion process?

**Yes**, the tool offers customizable settings to refine the scraping process based on your needs.

#### Is the Swiggy **Email Scraper** suitable for **large-scale** data **extract**ion?

**Yes**, the tool is designed to handle high volumes of data efficiently.

#### Does the tool provide data in a **specific** format?

You can download extracted data in various formats, including **CSV** and **JSON**.

#### How often is the tool updated?

We provide **regular updates** to ensure compatibility with Swiggy's platform changes.

#### Can I integrate the scraper with other tools?

**Yes**, the Swiggy Email Scraper supports integration with various analytics and CRM tools.

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

**Yes**, we offer **dedicated support** to assist with any technical issues or queries.

#### Does the scraper work for all regions?

The tool is designed to work with Swiggy's platform across supported regions.

#### Can I use the tool for promotional data **extract**ion?

**Yes**, the scraper can extract information on discounts and promotional offers available on Swiggy.

#### Is the tool user-friendly?

**Yes**, the Swiggy Email Scraper features an intuitive interface for easy operation.

#### How **secure** is the data **extract**ion process?

The tool ensures **secure** and compliant data harvesting practices.

#### What industries benefit from using the Swiggy **Email Scraper**?

Industries such as food delivery, marketing, and analytics can benefit from using the tool.

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

```

## MCP server setup

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

```

## OpenAPI specification

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