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

- **URL**: https://apify.com/scrapapi/walmart-email-scraper.md
- **Developed by:** [ScrapAPI](https://apify.com/scrapapi) (community)
- **Categories:** Automation, Lead generation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### **Walmart** Email Scraper 📱

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

With this tool, users can efficiently gather **Walmart** customer **emails** or vendor **emails** to build targeted marketing campaigns. The scraping process is automated, ensuring accuracy and saving time for users.

This **Walmart** email **extract**ion solution is designed to handle large-scale **data** scraping while maintaining high performance. It is suitable for businesses looking to **extract** **Walmart** customer **emails** or gather leads for outreach efforts.

By using this tool, users can streamline their **data** collection process and focus on achieving their business goals.

Walmart Email Scraper is a powerful tool designed to help users extract email addresses and other relevant contact information from Walmart's platform. It simplifies the process of gathering data, making it an essential solution for businesses and marketers.

With the Walmart data extraction tool, users can efficiently collect contact details to build targeted marketing campaigns or enhance their customer outreach efforts. This automated solution saves time and ensures accuracy in data collection.

Our Walmart email harvesting tool is user-friendly and highly customizable, enabling users to tailor their scraping process to specific needs. It is ideal for extracting Walmart vendor emails and other essential data points.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: scrapier.io@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email Addresses | Extract customer and vendor email addresses from Walmart's platform. |
| Vendor Contact Details | Gather contact information for Walmart vendors, including emails and names. |
| Product Information | Scrape product details such as names, descriptions, and prices. |
| Customer Reviews | Collect customer reviews and ratings for specific products. |
| Category Data | Extract data related to product categories and subcategories. |
| Store Locations | Retrieve information about Walmart store locations and addresses. |
| Pricing Data | Scrape pricing information for products across different categories. |
| Promotional Offers | Extract details about discounts, deals, and promotions. |

### 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** email scraping for efficient data collection
- ⭐ **Customizable** scraping parameters to meet specific needs
- ⭐ Ability to extract **Walmart** vendor emails and customer contact details
- ⭐ **High** accuracy in data extraction with minimal errors
- ⭐ Support for large-scale data scraping tasks
- ⭐ User-friendly interface for easy operation
- ⭐ Compliance with legal and ethical guidelines for data scraping
- ⭐ **Fast** and reliable performance for quick results
- ⭐ Ability to extract additional data points such as product details and reviews
- ⭐ **Regular** updates to ensure compatibility with **Walmart**s platform

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

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

1. ✅ **Sign up** for an account and access the **Walmart** Email Scraper tool
2. ✅ Log in to the platform and navigate to the scraping dashboard
3. ✅ Enter the specific parameters for your data extraction such as keywords or categories
4. ✅ **Select** the type of data you want to scrape such as email addresses or vendor details
5. ✅ Set any filters or conditions to refine your scraping process
6. ✅ **Start** the scraping process and monitor the progress in real-time
7. ✅ Download the extracted data in your preferred format once the scraping is complete
8. ✅ Use the data for your marketing research or business purposes

### Use Cases 🎯

Marketing Campaigns
🎯 Build targeted email lists for promotional campaigns
🎯 Extract **Walmart** customer emails to enhance outreach efforts

Vendor Research
🎯 Gather contact details of **Walmart** vendors for partnership opportunities
🎯 Scrape **Walmart** vendor emails to streamline communication

Competitor Analysis
🎯 Extract pricing and product data for competitive analysis
🎯 Monitor promotional offers and discounts on **Walmart**s platform

Customer Insights
🎯 **Analyze** customer reviews and ratings for product improvements
🎯 Extract **Walmart** customer emails to understand customer preferences

### Why choose us? 💎

Our **Walmart** Email Scraper is designed to provide efficient and accurate data extraction for businesses of all sizes. It offers a **user-friendly** interface that makes it easy to use, even for beginners.

The tool is highly customizable, allowing users to tailor the scraping process to their specific needs. With its automated features, the **Walmart** data extraction tool saves time and reduces manual effort.

Our software is built to handle large-scale data scraping tasks, ensuring high performance and reliability. We prioritize compliance with legal and ethical guidelines, ensuring that your data collection process is secure and responsible.

Whether you need to extract **Walmart** customer emails or vendor contact details, our solution is designed to meet your requirements. Choose our **Walmart** email harvesting tool for a **reliable** and efficient data scraping experience.

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

The **Walmart** Email Scraper is built to handle data extraction tasks of any scale. Whether you need to scrape a small dataset or perform **large-scale** data collection, our tool is equipped to meet your needs.

It is designed to maintain high performance and accuracy, even when processing large volumes of data. The automated **Walmart** email scraping solution ensures that you can **efficient**ly gather information without compromising on speed or quality.

Our software is ideal for businesses of all sizes, from small startups to large enterprises. With its robust infrastructure, the **Walmart** leads extractor can scale to match your growing data requirements.

This makes it a reliable choice for long-term data extraction needs.

### **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
⚖️ **Only** use the **Walmart** Email Scraper for lawful and ethical purposes
⚖️ **Avoid** scraping sensitive or personal information without proper authorization
⚖️ **Do not** use the tool to send unsolicited emails or spam
⚖️ Respect data privacy regulations such as GDPR or CCPA when collecting data
⚖️ **Use** the scraper responsibly to avoid overloading **Walmart**s servers
⚖️ **Obtain** necessary permissions if required for specific data extraction tasks
⚖️ Consult legal experts to ensure compliance with applicable laws and regulations

### 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.

#### Can I use this tool to **extract** Walmart vendor emails?

**Yes**, the tool allows you to scrape Walmart vendor **emails** and other contact details.

#### Is the Walmart **Email Scraper** easy to use?

**Yes**, it features a **user-friendly** interface and customizable options for easy operation.

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

You can extract email addresses, vendor contact details, product information, and more.

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

**Yes**, as long as you comply with Walmart's terms of service and data privacy laws.

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

**Yes**, the tool is designed to handle large-scale data scraping tasks efficiently.

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

You can download the data in various formats such as **CSV** or Excel.

#### Does the tool support automated scraping?

**Yes**, the Walmart Email Scraper is fully **automated** for efficient data collection.

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

**Yes**, we provide technical support to help you with any issues or questions.

#### Can I customize the scraping parameters?

**Yes**, the tool allows you to set specific parameters for tailored data extraction.

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

**Yes**, the Walmart Email Scraper is designed to comply with GDPR, CCPA, and other data privacy laws.

#### What is the accuracy of the **extract**ed data?

The tool ensures high accuracy in data extraction with minimal errors.

#### Can I scrape promotional offers from Walmart?

**Yes**, the tool can extract details about discounts, deals, and promotions.

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

The tool is scalable and can handle **large volumes** of data, depending on your requirements.

#### How often is the tool updated?

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

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

```

## MCP server setup

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

```

## OpenAPI specification

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