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

Automate email extraction from Uber Eats with Uber Eats Email Scraper. The actor scans listings and pulls available contact emails into structured datasets for CRM enrichment and automated lead pipelines.

- **URL**: https://apify.com/api-empire/uber-eats-email-scraper.md
- **Developed by:** [API Empire](https://apify.com/api-empire) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 4 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

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

The Uber Eats Email Scraper allows users to **extract** essential **data** from the Uber Eats platform. This includes restaurant **contact** information, email addresses, and other relevant details.

By using this tool, businesses can gather structured **data** for marketing campaigns, partnerships, and customer outreach. The scraper ensures that users can access accurate and up-to-date information from the Uber Eats **data**base.

It is designed to simplify the process of **data** **extract**ion, making it accessible even for users without technical expertise. With its automated features, the Uber Eats Email Scraper saves time and effort while delivering reliable results.

This tool is ideal for businesses looking to connect with restaurants and enhance their marketing efforts.

Uber Eats Email Scraper is a powerful tool designed to extract email addresses and contact information from Uber Eats. It is an automated solution tailored for businesses looking to connect with restaurants and partners on the Uber Eats platform.

With the Uber Eats Email Scraper, users can efficiently gather valuable data from the Uber Eats database. This tool simplifies the process of extracting contact information for marketing and business outreach purposes.

This email scraper for food delivery apps is ideal for businesses seeking to expand their network. It provides accurate and up-to-date email data from Uber Eats restaurants and partners.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: hello.apiempire@gmail.com*
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Restaurant Name | Extract the names of restaurants listed on Uber Eats. |
| Email Address | Retrieve email addresses of restaurants for direct communication. |
| Phone Number | Collect phone numbers for additional contact options. |
| Location | Gather location details of restaurants, including city and address. |
| Cuisine Type | Identify the type of cuisine offered by each restaurant. |
| Operating Hours | Extract information about restaurant operating hours. |
| Ratings and Reviews | Access customer ratings and reviews for listed restaurants. |
| Menu Details | Retrieve menu items and pricing information from restaurants. |

### 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** data extraction from Uber Eats for quick and efficient results
- ⭐ **Accurate** collection of restaurant email addresses and contact details
- ⭐ User-friendly interface suitable for both technical and non-technical users
- ⭐ **Customizable** scraping parameters to target specific data fields
- ⭐ Supports bulk data extraction to handle large-scale projects
- ⭐ **Regular** updates to ensure compatibility with Uber Eats platform changes
- ⭐ **Secure** and compliant data scraping practices to protect user privacy
- ⭐ Export data in multiple formats such as CSV JSON or Excel for convenience
- ⭐ Detailed logs and error handling for reliable operation
- ⭐ 247 customer support to assist with any issues or inquiries

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

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

1. ✅ **Sign up** or **log in** to access the Uber Eats Email Scraper tool
2. ✅ Enter your scraping parameters such as location or cuisine type
3. ✅ **Select** the data fields you want to extract such as email addresses or phone numbers
4. ✅ Set the output format for the extracted data such as CSV or JSON
5. ✅ **Start** the scraping process by clicking the Run button
6. ✅ Monitor the progress of the scraping task through the dashboard
7. ✅ Once completed download the extracted data to your device
8. ✅ **Review** the data for accuracy and use it for your business needs

### Use Cases 🎯

Marketing Campaigns
🎯 Build targeted email lists for promotional campaigns
🎯 Reach out to restaurants with special offers or partnerships

Business Development
🎯 **Identify** potential restaurant partners on Uber Eats
🎯 Expand your network by connecting with new food businesses

Market Research
🎯 **Analyze** restaurant data for trends and customer preferences
🎯 Gather insights on competitors and their offerings

Customer Outreach
🎯 Enhance customer engagement with direct communication
🎯 Provide personalized offers to restaurants based on their profiles

### Why choose us? 💎

Our Uber Eats Email Scraper is designed to provide businesses with a **reliable** and efficient way to extract data. With its **user-friendly** interface and **advanced** features, it simplifies the data collection process, even for non-technical users.

The scraper ensures accurate and up-to-date information, helping businesses make informed decisions. We prioritize security and compliance, ensuring that all data scraping activities are conducted ethically.

Our tool is **regular**ly updated to stay compatible with changes on the Uber Eats platform. Additionally, we offer 24/7 customer support to assist with any issues or questions.

Whether you need to build a contact list, conduct market research, or enhance your marketing efforts, our Uber Eats Email Scraper is the ideal solution. It is trusted by businesses across the food delivery industry for its reliability and performance.

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

The Uber Eats Email Scraper is built to handle projects of all sizes, from small-scale data extraction to **large-scale** operations. Its robust architecture ensures consistent performance, even when dealing with **extensive** datasets.

Users can customize scraping parameters to target specific data fields, making it adaptable to various business needs. The tool supports bulk data extraction, allowing users to gather large amounts of information **efficient**ly.

With its automated features, the scraper minimizes manual effort and maximizes productivity. Whether you're a small business or a large enterprise, the Uber Eats Email Scraper can scale to meet your requirements.

Regular updates and ongoing support ensure that the tool remains reliable and effective as your business grows.

### **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 all relevant data protection and privacy laws when using the Uber Eats Email Scraper
⚖️ **Do not** use the extracted data for spamming or unsolicited communications
⚖️ **Obtain** necessary permissions before contacting individuals or businesses using the scraped data
⚖️ **Avoid** scraping sensitive or personal information that is not publicly available
⚖️ **Use** the tool responsibly and within the terms of service of the Uber Eats platform
⚖️ Regularly review and adhere to any changes in data privacy regulations

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

The Uber Eats Email Scraper is a tool designed to extract email addresses and contact information from the Uber Eats platform.

#### Is the Uber Eats **Email Scraper** easy to use?

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

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

You can extract restaurant names, email addresses, phone numbers, locations, cuisine types, operating hours, ratings, and menu details.

#### Is the data **extract**ion process automated?

**Yes**, the Uber Eats Email Scraper automates the data extraction process to save time and effort.

#### Can I customize the scraping parameters?

**Yes**, you can specify parameters such as location, cuisine type, and data fields to target specific information.

#### Is the tool compatible with all devices?

The Uber Eats Email Scraper is a web-based tool and can be accessed from any device with an internet connection.

#### How often is the tool updated?

The tool is regularly updated to ensure compatibility with changes on the Uber Eats platform.

#### Is the data **extract**ion process **secure**?

**Yes**, the tool follows **secure** and compliant practices to protect user privacy and data.

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

**Yes**, the data can be exported in multiple formats such as **CSV**, **JSON**, or Excel for convenience.

#### What support options are available?

We offer 24/7 customer support to assist with any issues or inquiries related to the tool.

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

**Yes**, but ensure **compliance** with data protection laws and obtain necessary permissions before contacting individuals or **businesses**.

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

The tool supports bulk data extraction and is designed to handle large-scale projects efficiently.

#### Do I need technical skills to use the scraper?

**No**, the tool is designed to be **user-friendly** and accessible to users without technical expertise.

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

**Yes**, the Uber Eats Email Scraper adheres to relevant data protection and privacy laws.

#### Can I scrape data from other food delivery platforms?

This tool is specifically designed for Uber Eats, but we offer other scrapers for different platforms.

# 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("api-empire/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("api-empire/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 api-empire/uber-eats-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Uber Eats Email Scraper",
        "description": "Automate email extraction from Uber Eats with Uber Eats Email Scraper. The actor scans listings and pulls available contact emails into structured datasets for CRM enrichment and automated lead pipelines.",
        "version": "0.1",
        "x-build-id": "gGrD6PhX6EYsH6etB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/api-empire~uber-eats-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-api-empire-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/api-empire~uber-eats-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-api-empire-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/api-empire~uber-eats-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-api-empire-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```