# Uber Eats Email Scraper (`scrapapi/uber-eats-email-scraper`) Actor

- **URL**: https://apify.com/scrapapi/uber-eats-email-scraper.md
- **Developed by:** [ScrapAPI](https://apify.com/scrapapi) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 1 total users, 0 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

### **Social Media** Email Scraper 📱

Uber Eats Email Scraper allows users to **extract** valuable **data** from Uber Eats vendor profiles efficiently. It focuses on gathering business **contact** information, including email addresses, to enhance marketing and outreach efforts.

The tool is designed to capture accurate and relevant **data**, ensuring users can access essential details about restaurants and food delivery providers. It supports automated **extract**ion processes, making it easy to collect **data** at scale without manual intervention.

By leveraging advanced scraping techniques, the scraper ensures the reliability and precision of the **extract**ed information. Users can utilize this **data** for targeted campaigns, business expansion, and research purposes.

Uber Eats Email Scraper is a powerful tool designed to extract email addresses from Uber Eats vendor profiles efficiently. It enables businesses to gather valuable contact information for marketing and outreach purposes from food delivery platforms.

This automated Uber Eats data extraction tool simplifies the process of collecting business emails from restaurants and vendors listed on Uber Eats. It is ideal for companies looking to expand their network or streamline communication with food delivery providers.

With Uber Eats Email Scraper, users can access accurate and up-to-date contact details without manual effort. The tool leverages advanced scraping techniques to ensure reliable data collection from Uber Eats API and vendor pages.

### 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 |
| --- | --- |
| Vendor Email Addresses | Extract business contact emails from Uber Eats restaurant profiles. |
| Restaurant Names | Capture the names of restaurants listed on Uber Eats. |
| Location Details | Retrieve location information such as city and address of vendors. |
| Cuisine Types | Identify the type of cuisine offered by restaurants. |
| Ratings and Reviews | Extract ratings and customer reviews for vendors. |
| Operating Hours | Gather details about restaurant opening and closing times. |
| Contact Numbers | Collect phone numbers listed on vendor profiles. |
| Menu Information | Access menu details and pricing from Uber Eats vendors. |

### Key Features of **Social Media** Email Scraper

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

- ⭐ **Automated** extraction of Uber Eats vendor email addresses for efficient data collection
- ⭐ Supports large-scale data scraping for comprehensive business outreach campaigns
- ⭐ **Accurate** and reliable data extraction with advanced scraping algorithms
- ⭐ **Customizable** filters to target specific vendors or restaurant categories
- ⭐ User-friendly interface for seamless operation and data management
- ⭐ Ensures compliance with legal regulations for ethical data usage
- ⭐ Provides detailed location and contact information for Uber Eats vendors
- ⭐ Compatible with Uber Eats API for streamlined data extraction processes
- ⭐ Offers real-time data updates to ensure the latest information is captured
- ⭐ Enables export of extracted data in multiple formats for easy integration

### How to use **Social Media** Email Scraper 🚀

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

1. ✅ **Sign up** for the Uber Eats Email Scraper tool and **log in** to your account
2. ✅ Enter the target location or vendor category you wish to scrape data from
3. ✅ **Configure** filters to narrow down the search to specific restaurant types or cuisines
4. ✅ Initiate the scraping process by clicking the **Start** button on the dashboard
5. ✅ Monitor the progress of data extraction through the real-time status updates provided
6. ✅ Once the scraping is complete review the extracted data for accuracy and completeness
7. ✅ **Export** the data in your preferred format such as CSV or Excel for further use
8. ✅ Utilize the extracted email addresses for marketing campaigns or business outreach

### Use Cases 🎯

Marketing Campaigns
🎯 Utilize extracted email addresses to launch targeted marketing campaigns
🎯 Reach out to Uber Eats vendors with promotional offers and partnership opportunities

Business Expansion
🎯 **Identify** potential restaurant partners for business growth
🎯 Expand your network by connecting with Uber Eats vendors in new locations

Research and Analysis
🎯 **Analyze** vendor data for market trends and customer preferences
🎯 **Study** restaurant profiles to gather insights into the food delivery industry

Customer Outreach
🎯 Build relationships with Uber Eats vendors through personalized communication
🎯 Enhance customer engagement by accessing accurate contact information

### Why choose us? 💎

Uber Eats Email Scraper offers unparalleled efficiency in extracting vendor emails from food delivery platforms. Our tool is designed to save time and resources by automating the data collection process, ensuring accurate and **reliable** results.

With **advanced** scraping techniques, users can access up-to-date contact information for Uber Eats vendors effortlessly. We prioritize user experience by providing a simple and intuitive interface that makes data extraction seamless.

Our scraper supports customizable filters, allowing users to target specific vendors or restaurant categories. We ensure compliance with legal guidelines, providing peace of mind for ethical data usage.

Whether you need data for marketing campaigns, research, or business expansion, Uber Eats Email Scraper delivers high-quality results tailored to your needs. Choose us for a **scalable**, **reliable**, and **user-friendly** solution to extract Uber Eats customer emails efficiently.

### **Social Media** Email Scraper Scalability 📈

Uber Eats Email Scraper is built to handle **large-scale** data extraction **efficient**ly. Whether you're targeting a small group of vendors or scraping data from thousands of Uber Eats profiles, our tool adapts to your needs **seamless**ly.

The scraper supports batch processing, enabling users to collect data from multiple sources simultaneously. With real-time updates and **advanced** algorithms, it ensures accurate and consistent results even during high-volume operations.

Our solution is designed to scale with your business, offering flexibility for growing data requirements. By leveraging cloud-based infrastructure, Uber Eats Email Scraper maintains performance and reliability at scale.

Whether you're a small business or a large enterprise, our tool delivers robust capabilities for extracting Uber Eats vendor emails effectively.

### **Social Media** Email Scraper Legal Guidelines ⚖️

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with local data protection laws and regulations when using Uber Eats Email Scraper
⚖️ **Do not** use the extracted data for unsolicited marketing or spam campaigns
⚖️ **Obtain** explicit consent from recipients before contacting them using scraped email addresses
⚖️ **Avoid** scraping data from Uber Eats profiles that are restricted or protected by terms of service
⚖️ **Use** the tool responsibly and ethically to maintain trust and credibility with vendors
⚖️ **Do not** resell or distribute extracted data without proper authorization

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

### Output Format 📤

📝 Example Output (JSON)

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

### FAQ ❓

#### What is Uber Eats **Email Scraper**?

Uber Eats Email Scraper is a tool designed to extract email addresses and other contact details from Uber Eats vendor profiles efficiently.

#### How does Uber Eats **Email Scraper** work?

The tool uses advanced scraping techniques to collect data from Uber Eats API and vendor pages automatically.

#### Is Uber Eats **Email Scraper** **legal** to use?

**Yes**, as long as you comply with local data protection laws and use the tool ethically.

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

**Yes**, the scraper allows users to apply filters to target specific vendors or restaurant categories.

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

The tool supports multiple export formats, including **CSV** and Excel.

#### Does the scraper work with Uber Eats API?

**Yes**, Uber Eats Email Scraper is compatible with Uber Eats API for streamlined data extraction.

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

**Yes**, the scraper is designed to handle high-volume operations efficiently.

#### Is the data **extract**ed by the tool accurate?

**Yes**, the scraper ensures reliable and accurate data collection using advanced algorithms.

#### What type of data can I **extract** using the tool?

You can extract email addresses, restaurant names, location details, cuisine types, ratings, and more.

#### Do I need technical expertise to use Uber Eats **Email Scraper**?

**No**, the tool features a **user-friendly** interface that makes it accessible to all users.

#### Can I use the **extract**ed data for marketing purposes?

**Yes**, but ensure you have obtained explicit consent from recipients before contacting them.

#### Is the tool compatible with other food delivery platforms?

Currently, the scraper is optimized for Uber Eats data extraction.

#### How often is the data updated?

The scraper provides real-time updates to ensure the latest information is captured.

#### Does the tool offer **customer support**?

**Yes**, our team provides **dedicated support** to assist users with any issues or queries.

#### Can I scrape data from restricted profiles?

**No**, the tool adheres to ethical guidelines and does not scrape data from restricted or protected profiles.

# Actor input Schema

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Uber Eats Email Scraper",
        "version": "0.1",
        "x-build-id": "yve64ThfqsgcCb3uz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~uber-eats-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-uber-eats-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~uber-eats-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-uber-eats-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~uber-eats-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-uber-eats-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 Ubereats (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Ubereats profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Ubereats"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Ubereats"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```