# Chewy Email Scraper (`scraper-engine/chewy-email-scraper`) Actor

Chewy Email Scraper extracts publicly available email addresses from Chewy brand, seller, and support pages. Build targeted contact lists for supplier outreach, partnerships, and B2B communication.

- **URL**: https://apify.com/scraper-engine/chewy-email-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Lead generation, E-commerce, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### **Chewy** Email Scraper 📱

**Chewy** Email Scraper allows users to **extract** structured email **data** from the **Chewy** platform efficiently. It focuses on retrieving customer email addresses and related information for marketing and outreach purposes.

The tool is designed to handle large **data**sets while ensuring **data** accuracy and organization. Users can customize their scraping parameters to target specific customer segments or product categories.

The **extract**ed **data** is delivered in a format that is easy to integrate into existing systems or marketing tools. This makes it an ideal solution for businesses looking to enhance their email marketing strategies.

The scraper is also equipped with features to ensure compliance with legal and ethical guidelines during the **data** **extract**ion process.

Chewy Email Scraper is a powerful tool designed to help users extract valuable email data from the Chewy platform efficiently and accurately. It simplifies the process of gathering customer email information for businesses and marketers.

Using the Chewy email extraction tool, you can automate the process of collecting email addresses, saving time and effort compared to manual methods. This tool is ideal for businesses looking to enhance their marketing strategies.

Chewy Email Scraper ensures that you can access the email data you need while maintaining compliance with ethical and legal standards. It is designed to be user-friendly and highly customizable to suit your specific requirements.

### 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 |
| --- | --- |
| Customer emails | Collect email addresses of customers from the Chewy platform. |
| Customer names | Retrieve names associated with the extracted email addresses. |
| Order-related emails | Extract emails related to specific orders or transactions. |
| Marketing emails | Gather promotional or marketing-related email data. |
| Product-specific emails | Scrape emails linked to specific products or categories. |
| Customer reviews | Extract emails from customer reviews or feedback sections. |
| Subscription emails | Retrieve emails related to subscriptions or newsletters. |
| Support emails | Collect emails from customer support interactions. |

### Key Features of **Chewy** Email Scraper

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

- ⭐ Automates the process of extracting emails from the **Chewy** platform
- ⭐ Supports customizable scraping parameters for targeted data collection
- ⭐ Delivers data in structured formats such as CSV or JSON for easy integration
- ⭐ Handles large-scale data extraction tasks efficiently and accurately
- ⭐ Ensures compliance with legal and ethical standards during data scraping
- ⭐ User-friendly interface with minimal technical knowledge required
- ⭐ Offers scheduling options for automated and recurring data scraping
- ⭐ Provides robust error handling and real-time progress monitoring
- ⭐ Supports filtering options to refine extracted data based on specific criteria
- ⭐ Compatible with various systems and marketing tools for seamless integration
- ⭐ Includes detailed documentation and customer support for troubleshooting

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

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

1. ✅ **Sign up** for an account on the **Chewy** Email Scraper platform
2. ✅ Log in and navigate to the dashboard to start a new scraping project
3. ✅ Enter the specific parameters for your scraping task such as product categories or customer segments
4. ✅ **Select** the type of data you wish to extract such as customer emails or order-related emails
5. ✅ Customize additional settings such as scheduling or filtering options if needed
6. ✅ **Start** the scraping process and monitor its progress in real-time on the dashboard
7. ✅ Once the scraping is complete download the extracted data in your preferred format
8. ✅ **Integrate** the extracted data into your marketing or customer relationship management tools
9. ✅ **Review** the data to ensure it meets your requirements and make any necessary adjustments
10. ✅ Use the extracted email data for outreach campaigns customer engagement or other purposes

### Use Cases 🎯

Marketing Campaigns
🎯 Build a targeted email list for promotional campaigns
🎯 Enhance customer engagement with personalized email outreach

Customer Retention
🎯 **Identify** and reconnect with inactive customers through email
🎯 Send follow-up emails to customers based on their purchase history

Market Research
🎯 **Analyze** customer feedback and reviews for insights
🎯 Gather data to understand customer preferences and trends

Business Development
🎯 Expand your email database for lead generation
🎯 **Identify** potential partners or collaborators through email data

### Why choose us? 💎

**Chewy** Email Scraper is a **reliable** and efficient tool for extracting email data from the **Chewy** platform. It is designed to meet the needs of businesses of all sizes, from small startups to large enterprises.

Our tool offers **advanced** features such as customizable parameters, scheduling options, and data filtering to ensure you get the most relevant information. We prioritize user experience by providing a simple and intuitive interface that requires minimal technical knowledge.

Our scraper is built with compliance in mind, ensuring that all data extraction processes adhere to legal and ethical guidelines. With robust error handling and real-time monitoring, you can trust our tool to deliver accurate and organized results.

Additionally, we offer detailed documentation and customer support to assist you at every step. Choose **Chewy** Email Scraper for a seamless and effective email data extraction experience.

### **Chewy** Email Scraper Scalability 📈

**Chewy** Email Scraper is designed to handle data extraction tasks of any scale, making it suitable for both small and large businesses. Whether you need to extract a few hundred emails or millions, our tool can accommodate your requirements.

The scraper is optimized for performance, ensuring fast and **efficient** data collection even for large datasets. With **customizable** parameters, you can target specific customer segments or product categories without compromising on speed or accuracy.

Our tool also supports scheduling and automation, allowing you to set up recurring scraping tasks for ongoing data needs. This scalability ensures that **Chewy** Email Scraper grows with your business, providing a reliable solution for your email data extraction needs.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** that all data scraping activities comply with **Chewy**s terms of service
⚖️ **Use** the extracted email data only for legitimate and ethical purposes
⚖️ **Avoid** scraping sensitive or personal information beyond what is publicly available
⚖️ **Do not** use the tool to spam or harass individuals with unsolicited emails
⚖️ **Obtain** consent from individuals before using their email data for marketing purposes
⚖️ Regularly review and update your data scraping practices to align with legal requirements
⚖️ Respect any opt-out requests from individuals who do not wish to receive emails
⚖️ **Ensure** that your data storage and usage practices comply with data protection regulations

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

### Output Format 📤

📝 Example Output (JSON)

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

### FAQ ❓

#### What is Chewy **Email Scraper**?

Chewy Email Scraper is a tool designed to extract email data from the Chewy platform efficiently and accurately.

#### Is Chewy **Email Scraper** **legal** to use?

**Yes**, as long as you comply with Chewy's terms of service and use the data ethically and legally.

#### What types of data can I **extract**?

You can extract customer **emails**, names, order-related **emails**, marketing **emails**, and more.

#### Do I need technical skills to use this tool?

**No**, Chewy Email Scraper is **user-friendly** and requires minimal technical knowledge.

#### Can I customize the scraping parameters?

**Yes**, you can customize parameters to target specific customer segments or data types.

#### Is the **extract**ed data organized?

**Yes**, the data is delivered in structured formats like **CSV** or **JSON** for easy integration.

#### Does the tool support **large-scale** data **extract**ion?

**Yes**, Chewy Email Scraper is designed to handle large datasets efficiently.

#### Is there **customer support** available?

**Yes**, we provide detailed documentation and customer support to assist you.

#### Can I schedule recurring scraping tasks?

**Yes**, the tool supports scheduling and automation for regular data extraction.

#### How do I ensure compliance with **legal** guidelines?

Follow ethical practices, obtain consent, and comply with data protection regulations.

#### What formats are supported for data **export**?

The extracted data can be exported in **CSV** or **JSON** formats.

#### Is there a **limit** to the number of emails I can **extract**?

**No**, the tool is scalable and can handle tasks of any size.

#### Can I use this tool for market research?

**Yes**, it is ideal for gathering customer feedback and analyzing trends.

#### Does the tool offer real-time progress monitoring?

**Yes**, you can monitor the scraping process in real-time on the dashboard.

#### How do I start using Chewy **Email Scraper**?

Sign up, log in, and configure your scraping parameters to begin extracting data.

# Actor input Schema

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Chewy Email Scraper",
        "description": "Chewy Email Scraper extracts publicly available email addresses from Chewy brand, seller, and support pages. Build targeted contact lists for supplier outreach, partnerships, and B2B communication.",
        "version": "0.1",
        "x-build-id": "6ABoGx65hPBDI6Ot7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~chewy-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-chewy-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/scraper-engine~chewy-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-chewy-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/scraper-engine~chewy-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-chewy-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 Chewy (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Chewy profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Chewy"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Chewy"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```