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

📧 Uber Eats Email Scraper extracts Uber Eats email contacts from web pages for lead generation and outreach. 🚀 Save time, boost B2B sales & marketing prospecting with accurate, targeted data. ✅ Great for researchers, agencies & recruiters.

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

## Pricing

from $3.99 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

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

The Uber Eats Email Scraper allows users to **extract** a wide range of **data** from Uber Eats. This includes email addresses, business names, phone numbers, and other **contact** details.

The tool is designed to provide accurate and structured information for outreach and analysis. Users can also scrape additional **data** such as restaurant categories, locations, and customer reviews.

By automating the **data** **extract**ion process, the Uber Eats Email Scraper saves time and ensures consistency. This tool is suitable for businesses, researchers, and marketers looking to gather actionable insights.

It supports large-scale **data** scraping while maintaining **data** integrity and reliability.

Uber Eats Email Scraper is a powerful tool designed to extract email addresses and other relevant data from Uber Eats efficiently. It enables businesses and marketers to gather contact information for outreach and analysis purposes.

Social media scraping tools like the Uber Eats Email Scraper simplify the process of collecting vital business data. By automating data extraction, users save time and effort while gaining access to valuable insights.

With the Uber Eats Email Scraper, you can extract emails and other business details from Uber Eats profiles. This tool is ideal for businesses looking to connect with restaurants or analyze customer data.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: dev.scraperengine@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email Addresses | Extract verified email addresses of Uber Eats businesses. |
| Business Names | Retrieve the names of restaurants and businesses listed on Uber Eats. |
| Phone Numbers | Collect contact phone numbers associated with Uber Eats profiles. |
| Locations | Scrape location details such as city, state, and zip code of businesses. |
| Restaurant Categories | Identify the type of cuisine or category for each restaurant. |
| Customer Reviews | Extract customer reviews and ratings for analysis. |
| Operating Hours | Gather information on the working hours of listed businesses. |
| Website Links | Retrieve links to official websites or social media pages of businesses. |

### 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 email addresses from Uber Eats profiles
- ⭐ **Accurate** and structured data collection for business analysis
- ⭐ Ability to scrape multiple data types including phone numbers and locations
- ⭐ User-friendly interface for seamless operation and data retrieval
- ⭐ **High**-speed data scraping to handle large volumes efficiently
- ⭐ **Customizable** settings to target specific data fields or categories
- ⭐ Ensures compliance with ethical and legal data scraping guidelines
- ⭐ Provides export options in multiple formats such as CSV and JSON
- ⭐ Supports integration with other tools and APIs for advanced workflows
- ⭐ **Regular** updates to maintain compatibility with Uber Eats platform changes
- ⭐ **Secure** and reliable data extraction with minimal errors
- ⭐ Detailed documentation and customer support for troubleshooting

### 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 the specific search criteria or keywords for data extraction
3. ✅ Set the parameters such as location category or data type to target
4. ✅ **Start** the scraping process by clicking the Run button
5. ✅ Monitor the progress of data extraction in the dashboard
6. ✅ Once completed review the extracted data for accuracy
7. ✅ **Export** the data in your preferred format such as CSV or JSON
8. ✅ Use the extracted data for marketing research or business outreach

### Use Cases 🎯

Marketing Campaigns
🎯 **Use** the Uber Eats Email Scraper to collect emails for targeted marketing campaigns
🎯 **Identify** potential restaurant partners for promotional collaborations

Business Research
🎯 **Analyze** customer reviews and ratings for market insights
🎯 **Study** restaurant categories and locations for competitive analysis

Lead Generation
🎯 Generate a list of potential clients in the food and beverage industry
🎯 **Identify** businesses with specific attributes for partnership opportunities

Customer Outreach
🎯 **Collect** contact information for direct communication with restaurants
🎯 Build a database of Uber Eats businesses for customer engagement

### Why choose us? 💎

The Uber Eats Email Scraper is designed to provide a **reliable** and efficient solution for data extraction. Our tool is built with **advanced** algorithms to ensure accuracy and speed in gathering information.

We prioritize user experience by offering a simple and intuitive interface that requires minimal technical expertise. With customizable settings, users can target specific data fields and refine their search criteria.

Our software is **regular**ly updated to adapt to changes on the Uber Eats platform, ensuring uninterrupted functionality. We also emphasize data security by implementing robust measures to protect user information.

Whether you're a marketer, researcher, or business owner, our tool is tailored to meet your data extraction needs. By choosing the Uber Eats Email Scraper, you gain access to a powerful and **scalable** solution for your business.

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

The Uber Eats Email Scraper is built to handle data extraction at any scale. Whether you need information on a few businesses or thousands, our tool can manage the workload **efficient**ly.

It is optimized for high-speed scraping, ensuring quick results without compromising accuracy. Users can customize parameters to focus on specific data fields, making it suitable for both small-scale and **large-scale** projects.

Our software supports batch processing, allowing you to extract data from multiple profiles simultaneously. With export options in various formats, you can **seamless**ly integrate the data into your existing workflows.

The Uber Eats Email Scraper is a reliable solution for businesses of all sizes, offering flexibility and scalability to meet your needs.

### **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 Uber Eats terms of service when using the scraper
⚖️ **Use** the tool only for lawful and ethical purposes such as business research or marketing
⚖️ **Avoid** scraping personal or sensitive information without proper authorization
⚖️ **Do not** use the scraper to engage in spamming or unsolicited marketing activities
⚖️ Respect intellectual property rights and avoid unauthorized use of extracted data
⚖️ Inform stakeholders about the source of data and obtain consent where necessary
⚖️ **Adhere** to data privacy regulations such as GDPR or CCPA when handling extracted data
⚖️ Regularly review updates to legal and ethical guidelines to ensure compliance

### 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 other business data from Uber Eats profiles.

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

You can extract **emails**, business names, phone numbers, locations, restaurant categories, customer reviews, operating hours, and website links.

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

**Yes**, it is legal to use as long as you comply with Uber Eats terms of service and data privacy regulations.

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

**Yes**, you can set specific parameters such as location, category, or data type to target during the scraping process.

#### What formats are available for **export**ing data?

You can export the extracted data in formats such as **CSV** or **JSON** for easy integration.

#### Is technical expertise required to use this tool?

**No**, the Uber Eats Email Scraper is **user-friendly** and designed to be accessible for users with minimal technical knowledge.

#### How often is the tool updated?

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

#### Can I scrape data from multiple profiles simultaneously?

**Yes**, the tool supports batch processing to extract data from multiple profiles at once.

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

**Yes**, the tool implements robust security measures to protect user information and ensure safe data extraction.

#### What industries can benefit from using this tool?

Industries such as marketing, research, and food services can benefit from using the Uber Eats Email Scraper.

#### Does the tool comply with GDPR and CCPA regulations?

**Yes**, the tool is designed to comply with data privacy regulations such as GDPR and CCPA.

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

**Yes**, the Uber Eats Email Scraper is ideal for generating leads in the food and beverage industry.

#### What should I do if I encounter issues with the tool?

You can refer to the documentation or contact customer support for assistance with troubleshooting.

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

**No**, the tool is scalable and can handle data extraction at any scale, depending on your requirements.

#### Does the tool integrate with other software or APIs?

**Yes**, the tool supports integration with other software and APIs for advanced workflows.

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Uber Eats Email Scraper",
        "description": "📧 Uber Eats Email Scraper extracts Uber Eats email contacts from web pages for lead generation and outreach. 🚀 Save time, boost B2B sales & marketing prospecting with accurate, targeted data. ✅ Great for researchers, agencies & recruiters.",
        "version": "0.1",
        "x-build-id": "wVL9VDKXfbXeskXCU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperx~uber-eats-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperx-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/scraperx~uber-eats-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperx-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/scraperx~uber-eats-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperx-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```