# Walmart Email Scraper Fast Advanced And Cheapest (`solid-scraper/walmart-email-scraper-fast-advanced-and-cheapest`) Actor

📧 Walmart Email Scraper Fast Advanced & Cheapest extracts verified Walmart business emails fast—ideal for lead gen, sales, and marketing outreach. Save time, scale campaigns, and reach targeted prospects instantly. 🚀

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

## Pricing

from $1.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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 - Fast, Advanced and Cheapest 📬

**Walmart Email Scraper - Fast, Advanced and Cheapest** is an Apify actor that extracts email addresses from Walmart based on the keywords, optional location filter, and email-domain list you provide. This **Walmart email scraper** helps you build a **Walmart customer email extractor** style lead list faster—whether you’re doing **scrape Walmart emails** for outreach, **Walmart marketing email list** enrichment, or research that needs reliable contact data at scale. Whether you're a marketer, lead researcher, or data analyst, this actor turns public web data into a structured dataset with emails—saving you hours of manual work.

---

### Why choose Walmart Email Scraper - Fast, Advanced and Cheapest?

| Feature | Benefit |
| --- | --- |
| ✅ **All-in-one Walmart email harvesting workflow** | Extract emails directly from Walmart using your chosen keywords and email-domain filters |
| ✅ **Built-in resilience** | Includes retries/fallback logic and stops early when limits are reached |
| ✅ **High-quality structured dataset output** | Each result is stored immediately with labeled fields (keyword, title, description, URL, email) |
| ✅ **Scales with keyword × domain coverage** | Runs across your keyword list and custom domains to widen your lead coverage |
| ✅ **Resume support** | Saves progress so long runs can continue without starting from scratch |
| ✅ **Limit controls to manage cost/time** | Uses `maxEmails` to stop at your target and avoid unnecessary extra scraping |

---

### Key features

- 🔎 **Accurate email extraction**: Extracts email addresses and filters them by your selected custom domains  
- 🧩 **Flexible input for Walmart email leads**: Use a list of `keywords` (queries) plus optional `location` to refine results  
- 🌐 **Custom email-domain targeting**: Provide domains like `@gmail.com` or `@yahoo.com` to improve relevance for a **Walmart B2B email scraper tool** workflow  
- 🛡️ **Reliability with resilient execution**: Includes fallback and stopping logic for stable runs  
- 💾 **Real-time saving to the dataset**: Each discovered contact row is pushed as soon as it’s found  
- 🔄 **Progress persistence for long jobs**: Resumes using stored cursor and already-seen emails  
- 📊 **Scalable results with a clear stop condition**: Collects up to your `maxEmails` limit (or free-tier cap when applicable)  

---

### Input

Provide input via an `input.json` file. Example structure:

```json
{
  "keywords": ["manager", "founder"],
  "location": "",
  "customDomains": ["@gmail.com", "@yahoo.com"],
  "maxEmails": 20
}
````

#### Input Fields

| Field | Required | Description |
| --- | --- | --- |
| `keywords` | ✅ Yes | A list of keywords or queries the actor uses to find relevant Walmart profiles/mentions and extract emails from publicly available sources. |
| `location` | ❌ No | Optional location text to filter the search results for more targeted **Walmart customer email extractor** outcomes. Leave empty for no location filtering. |
| `customDomains` | ❌ No | A list of email domains (for example `@gmail.com`, `@yahoo.com`). The scraper uses this to focus email extraction on domains you care about (helpful for **Walmart email harvesting software** workflows). |
| `maxEmails` | ❌ No | Maximum number of emails to collect. The scraper stops once it reaches this limit. Higher limits can take longer and still don’t guarantee reaching the target number. |

***

### Output

The actor pushes rows into the default dataset view as JSON objects—each time it finds a matching email, it immediately saves a structured record.

Example pushed row:

```json
{
  "network": "Walmart.com",
  "keyword": "manager",
  "title": "No title",
  "description": "No data",
  "url": "No URL",
  "email": "example@gmail.com"
}
```

#### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `network` | string | The source network label for each row (always `Walmart.com` in this actor). |
| `keyword` | string | The keyword from your input that led to this result. |
| `title` | string | The title text captured for the result item. |
| `description` | string | Text content used to locate the email (stored as extracted text). |
| `url` | string | The URL associated with the result item. |
| `email` | string | The extracted email address. |

**Note:** The dataset is saved in a “Scraped Leads” table view with the fields `keyword`, `title`, `description`, `url`, and `email`. You can export the dataset after the run (commonly as JSON/CSV depending on your Apify setup).

***

### How to use Walmart Email Scraper - Fast, Advanced and Cheapest (via Apify Console)

1. **Open Apify Console**\
   Log in at https://console.apify.com and go to the **Actors** section.

2. **Find the actor listing**\
   Search for **Walmart Email Scraper - Fast, Advanced and Cheapest** and open the actor page.

3. **Enter your input settings**\
   In the **INPUT** tab, use the built-in form or upload an `input.json`.\
   Add your `keywords` first—then optionally set `location`, `customDomains`, and `maxEmails`.

4. **Configure targeting for better results** 🎯\
   For **Walmart email scraper** performance, provide focused `customDomains` (e.g. `@gmail.com`) and use role/title style keywords (like `manager` or `founder`) to align with your **Walmart leads email scraper** goals.

5. **Run the actor** ▶️\
   Click **Run**. During execution, you’ll see logs indicating progress and when results are being pushed.

6. **Monitor progress in logs** 🔄\
   The actor saves progress and resumes using a cursor and already-seen emails, which helps for longer runs.

7. **Open the dataset from OUTPUT** 📦\
   When the run finishes (or reaches `maxEmails`), open the **Scraped Leads** dataset to view your extracted contacts.

8. **Export your results**\
   Export the dataset in the format you need for downstream workflows (for example, to import into your CRM or analytics pipeline).

No coding required—get accurate results in minutes with this SEO-friendly **Walmart Email Scraper - Fast, Advanced and Cheapest**.

***

### Advanced features & SEO optimization

- 🔍 **Engineered for Walmart email scraping use cases**: Designed to excel at **Walmart email scraper** and **scrape Walmart emails** workflows for **Walmart marketing email list** building
- 🧠 **Input normalization**: Accepts `keywords` as a list; the actor normalizes them before running
- 💾 **Resume-safe long runs**: Progress is persisted so you can continue without losing the already-found **Walmart email database scraper** results
- ⏱️ **Timeout-aware runtime behavior**: The actor supports longer executions (you can extend timeout via Apify **Run Options**) to improve coverage when searching across more keywords/domains
- 🔧 **Domain-filtered email extraction**: Uses your `customDomains` to focus on the email formats that matter most for your outreach strategy (including **Walmart contact email scraper** use cases)

***

### Best use cases

- 📈 **Sales outreach teams building lead lists**: Collect emails from publicly available Walmart sources using role keywords to speed up **Walmart seller email list scraper** workflows
- 🧲 **B2B researchers enriching contact databases**: Use `customDomains` filters to align outreach lists with your preferred email provider types (great for a **Walmart B2B email scraper tool**)
- 🎯 **Marketing ops teams preparing campaign audiences**: Turn **Walmart email extraction tool** results into structured datasets for segmentation and personalization
- 🧑‍💻 **Data analysts creating contact-and-URL mappings**: Analyze `keyword`, `url`, and `email` together for quality checks and attribution
- 🏪 **Ecommerce brands validating outreach channels**: Quickly test whether Walmart-related contacts use the domains your team targets
- 🤝 **Partnership teams finding relevant decision makers**: Use keywords like “manager” and “founder” to improve relevance of the **fast Walmart email finder** outputs
- 🗂️ **CRM automation pipelines**: Export the dataset and push rows into your CRM or marketing automation tools for follow-up sequences

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `keywords` as an array of keywords/queries (required)
  - ✅ `location` as a string (optional)
  - ✅ `customDomains` as an array of email domains like `@gmail.com` (optional)
  - ✅ `maxEmails` as an integer between 1 and 10000 (optional)

- **Proxy Support**
  - ✅ Uses built-in proxy support for reliable scraping (configured automatically during the run)

- **Retry Mechanism**
  - ✅ Includes retry/fallback behavior to improve resilience during execution

- **Dataset Structure**
  - ✅ Saved in the default dataset view titled **Scraped Leads**
  - ✅ Each row includes: `keyword`, `title`, `description`, `url`, `email` (plus `network` = `Walmart.com`)

- **Rate Limits & Performance**
  - ⚠️ Bigger keyword/domain coverage and higher `maxEmails` can take longer (the scraper stops once your target is reached or results end)

- **Limitations**
  - ⚠️ Email results depend on what’s publicly available for the matching Walmart entries
  - ⚠️ The scraper stops when it reaches `maxEmails`, but it doesn’t guarantee that it will always reach the requested number of emails

***

### FAQ

#### Can I scrape more than 100 emails?

✅ Yes, if you’re running under a paying plan. When running on Apify as a free user, the actor applies a free-tier maximum of **100 emails** by enforcing `maxEmails` down to the free limit. To collect more, you’ll need a paid plan.

#### What inputs do I need to start scraping?

You must provide `keywords`. The actor also accepts optional `location` and `customDomains` to refine results and focus the extracted emails on the email-domain types you want.

#### What email addresses does it extract?

It extracts email addresses and filters them by your provided `customDomains`. This is how **Walmart customer email extractor** results stay relevant to your outreach strategy.

#### Does it save results while it’s running?

✅ Yes. Each discovered record is pushed into the dataset immediately (real-time saving), so you don’t have to wait until the end to review what’s coming in.

#### Will it resume if the run is interrupted?

✅ Yes. The actor stores progress (cursor and already-seen emails) and resumes from the saved state, which is helpful when you run **Walmart email harvesting software** jobs that take longer.

#### Can I use it for B2B outreach?

✅ Yes. Use targeted `keywords` and choose appropriate `customDomains` to build a **Walmart marketing email list** or **Walmart B2B email scraper tool** dataset you can import into your outreach systems.

#### Is the data pulled from public sources only?

✅ Yes. The actor collects information only from **publicly accessible sources**. It does not access private profiles, authenticated data, or password-protected pages.

#### How can I request support or changes?

If you need custom help or tailored solutions, you can reach out at `[dataforleads@gmail.com](mailto:dataforleads@gmail.com)`.

***

### Support & feature requests

Have questions about **Walmart Email Scraper - Fast, Advanced and Cheapest** or want to request improvements? Share your feedback and feature ideas and we’ll do our best to incorporate them.

- 💡 **Feature Requests**: Examples include adding CSV export convenience, enhancing custom email parsing options, or improving integration-friendly outputs for CRM workflows.
- 📧 **Contact**: Email us at <dataforleads@gmail.com>.

Your feedback directly shapes the roadmap for this **Walmart email scraper**.

***

### Closing CTA / Final thoughts

*Try **Walmart Email Scraper - Fast, Advanced and Cheapest** to build your most complete Walmart contact email list from publicly available sources—fast, structured, and ready for scale.*

# Actor input Schema

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

A list of keywords or queries to search for.

## `location` (type: `string`):

Location to filter search results.

## `customDomains` (type: `array`):

List of custom email domains

## `maxEmails` (type: `integer`):

Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.

## Actor input object example

```json
{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20
}
```

# 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": [
        "manager",
        "founder"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("solid-scraper/walmart-email-scraper-fast-advanced-and-cheapest").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": [
        "manager",
        "founder",
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("solid-scraper/walmart-email-scraper-fast-advanced-and-cheapest").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": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ]
}' |
apify call solid-scraper/walmart-email-scraper-fast-advanced-and-cheapest --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Walmart Email Scraper Fast Advanced And Cheapest",
        "description": "📧 Walmart Email Scraper Fast Advanced & Cheapest extracts verified Walmart business emails fast—ideal for lead gen, sales, and marketing outreach. Save time, scale campaigns, and reach targeted prospects instantly. 🚀",
        "version": "1.0",
        "x-build-id": "9tAkZRaWAtbZgw7nE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~walmart-email-scraper-fast-advanced-and-cheapest/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-walmart-email-scraper-fast-advanced-and-cheapest",
                "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/solid-scraper~walmart-email-scraper-fast-advanced-and-cheapest/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-walmart-email-scraper-fast-advanced-and-cheapest",
                "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/solid-scraper~walmart-email-scraper-fast-advanced-and-cheapest/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-walmart-email-scraper-fast-advanced-and-cheapest",
                "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 or Queries",
                        "type": "array",
                        "description": "A list of keywords or queries to search for.",
                        "default": [
                            "manager",
                            "founder"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "customDomains": {
                        "title": "Enter Custom Email Domains (e.g. @gmail.com, @yahoo.com)",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com",
                            "@yahoo.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Enter Max Emails",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
