# Walmart Email Scraper (`scraperx/walmart-email-scraper`) Actor

🛒 Walmart Email Scraper helps you extract seller/contact emails from Walmart pages quickly. 🚀 Great for lead generation, B2B outreach, and market research—so you can connect faster and grow smarter. 🔎📩

- **URL**: https://apify.com/scraperx/walmart-email-scraper.md
- **Developed by:** [ScraperX](https://apify.com/scraperx) (community)
- **Categories:** Lead generation, E-commerce, Automation
- **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

### **Walmart** Email Scraper 📱

The **Walmart** Email Scraper allows users to **extract** a wide range of **data** from **Walmart**'s platform. This includes email addresses, customer **contact** information, and other relevant details for marketing or analysis.

The tool is designed to provide structured and organized **data** that can be easily integrated into your existing systems. With its advanced capabilities, the **Walmart** email harvesting tool ensures efficient **data** collection while maintaining compliance with ethical guidelines.

It is perfect for businesses looking to enhance their customer outreach or conduct in-depth market research. By using this **Walmart** email **extract**ion guide, you can streamline your **data** collection process and focus on leveraging the insights gained.

Walmart Email Scraper is a powerful tool designed to extract email addresses and other relevant data from Walmart's platform efficiently. It is ideal for businesses and individuals looking to streamline communication and build targeted outreach campaigns.

With the Walmart data extraction tool, users can automate the process of collecting contact information, saving time and effort. This scraper is tailored to ensure accuracy and compliance with data collection standards.

Using email scraping software for Walmart, you can gather valuable customer insights and contact details for marketing or research purposes. It simplifies the process of extracting structured data from Walmart's vast online ecosystem.

### 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 customer or business email addresses listed on Walmart's platform. |
| Customer Names | Retrieve names associated with email addresses for personalized communication. |
| Phone Numbers | Collect phone numbers when available for direct contact purposes. |
| Store Locations | Extract details about Walmart store locations for market analysis. |
| Product Information | Gather product-related data like names, descriptions, and pricing. |
| Reviews and Ratings | Scrape customer reviews and ratings for product or service evaluation. |
| Seller Information | Retrieve data about third-party sellers on Walmart's platform. |
| Category Listings | Extract category-specific data for targeted marketing campaigns. |

### Key Features of **Walmart** Email Scraper

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

- ⭐ **Automated** extraction of **Walmart** customer emails and contact details
- ⭐ **Customizable** scraping options to suit specific business needs
- ⭐ **High**-speed data collection with accurate results
- ⭐ User-friendly interface for easy setup and operation
- ⭐ **Advanced** filtering options to refine extracted data
- ⭐ **Secure** and compliant data scraping adhering to ethical standards
- ⭐ Seamless integration with third-party tools and systems
- ⭐ Support for large-scale data extraction projects
- ⭐ **Regular** updates to ensure compatibility with **Walmart**s platform
- ⭐ Detailed **Walmart** email extraction guide for step-by-step assistance
- ⭐ Built-in error handling for uninterrupted performance
- ⭐ **Comprehensive** customer support for troubleshooting and queries

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

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

1. ✅ Download and install the **Walmart** Email Scraper on your device
2. ✅ Launch the tool and **log in** using your credentials
3. ✅ Enter the specific **Walmart** URL or keywords you want to scrape data from
4. ✅ **Configure** the scraping parameters such as data types and filters
5. ✅ **Start** the scraping process and monitor the progress in real-time
6. ✅ **Review** the extracted data for accuracy and completeness
7. ✅ **Export** the data in your preferred format such as CSV or Excel
8. ✅ **Integrate** the extracted data into your marketing or CRM tools
9. ✅ Customize the scraper settings for recurring data collection tasks
10. ✅ Follow the **Walmart** email extraction guide for troubleshooting tips
11. ✅ Ensure compliance with legal and ethical guidelines during usage
12. ✅ Contact customer support for any additional assistance

### Use Cases 🎯

Marketing Campaigns
🎯 Extract **Walmart** customer emails for targeted email marketing
🎯 Build personalized outreach campaigns using customer data
🎯 **Analyze** customer preferences for better product recommendations

Market Research
🎯 Gather product reviews and ratings for competitive analysis
🎯 **Identify** trends in **Walmart**s product categories and offerings
🎯 **Analyze** seller information for market insights

Business Development
🎯 **Collect** contact information for potential business partners on **Walmart**
🎯 **Identify** key sellers and suppliers for collaboration opportunities
🎯 **Use** extracted data to expand your business network

Customer Support
🎯 Retrieve customer contact details for follow-ups and support
🎯 **Analyze** feedback from reviews to improve customer satisfaction
🎯 Streamline communication with **Walmart** customers using extracted data

### Why choose us? 💎

Our **Walmart** Email Scraper stands out as a **reliable** and efficient data extraction tool. It is designed to meet the diverse needs of businesses, from small startups to large enterprises.

With its **user-friendly** interface and **advanced** features, it simplifies the process of extracting valuable data from **Walmart**'s platform. The scraper is built with compliance in mind, ensuring ethical data collection practices.

Regular updates guarantee compatibility with **Walmart**'s evolving platform, providing uninterrupted performance. We offer robust customer support to assist you at every step, making it easy to get started and achieve your goals.

Whether you need to extract **Walmart** customer emails or gather market insights, our tool is tailored to deliver accurate and actionable data. Choose our **Walmart** email scraping service for a seamless and secure data collection experience.

### **Walmart** Email Scraper Scalability 📈

The **Walmart** Email Scraper is designed to handle data extraction tasks of all sizes. Whether you need to scrape a few hundred records or millions of data points, our tool can scale to meet your requirements.

It supports high-speed data collection without compromising on accuracy or performance. The scraper is optimized for **large-scale** projects, making it suitable for enterprises with **extensive** data needs.

With **customizable** settings, you can tailor the tool to extract specific data types or focus on particular categories. The **Walmart** email automation tool ensures a smooth and **efficient** process, even for complex tasks.

Its robust architecture and regular updates make it a reliable choice for businesses looking to scale their data extraction efforts.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **Walmart**s terms of service when using the scraper
⚖️ **Use** the **Walmart** Email Scraper only for legitimate and ethical purposes
⚖️ **Avoid** scraping sensitive or personal data that violates privacy laws
⚖️ **Obtain** consent from individuals before using their contact information
⚖️ **Do not** use the tool to engage in spam or unsolicited communication
⚖️ Regularly review local data protection regulations to ensure compliance
⚖️ Restrict usage to publicly available data on **Walmart**s platform
⚖️ Consult legal professionals if unsure about the legality of your use case

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

### Output Format 📤

📝 Example Output (JSON)

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

### FAQ ❓

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

The Walmart Email Scraper is a tool designed to extract email addresses and other data from Walmart's platform efficiently.

#### How does the Walmart data **extract**ion tool work?

The tool automates the process of collecting structured data from Walmart's online platform.

#### Is the Walmart contact scraper easy to use?

**Yes**, the tool features a **user-friendly** interface and detailed guides to assist users.

#### Can I **extract** Walmart customer emails **secure**ly?

**Yes**, the scraper is designed to ensure **secure** and compliant data collection.

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

You can extract email addresses, customer names, phone numbers, product information, and more.

#### Is the Walmart email harvesting tool customizable?

**Yes**, the tool allows you to configure scraping parameters to suit your needs.

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

**Yes**, the Walmart email automation tool supports high-volume data collection tasks.

#### Does the scraper comply with data protection laws?

The tool is designed to adhere to legal and ethical guidelines for data scraping.

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

You can export the extracted data in formats like **CSV** or Excel for easy integration.

#### Is **customer support** available for this tool?

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

#### Can I scrape product reviews and ratings?

**Yes**, the scraper can extract reviews and ratings for analysis.

#### How often is the tool updated?

The Walmart Email Scraper is regularly updated to ensure compatibility with Walmart's platform.

#### Is there a Walmart email **extract**ion guide available?

**Yes**, we provide a detailed guide to help you use the tool effectively.

#### Can I automate recurring data **extract**ion tasks?

**Yes**, the tool supports automation for regular data collection.

#### Is the Walmart email scraping service suitable for small businesses?

**Yes**, the tool is scalable and can cater to **businesses** of all sizes.

# Actor input Schema

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Walmart Email Scraper",
        "description": "🛒 Walmart Email Scraper helps you extract seller/contact emails from Walmart pages quickly. 🚀 Great for lead generation, B2B outreach, and market research—so you can connect faster and grow smarter. 🔎📩",
        "version": "0.1",
        "x-build-id": "2QwJmljeFxNxqBYDk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperx~walmart-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperx-walmart-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~walmart-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperx-walmart-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~walmart-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperx-walmart-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 Walmart (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Walmart profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Walmart"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Walmart"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```