# Steam Email Scraper (`scraperx/steam-email-scraper`) Actor

📧 Steam Email Scraper extracts emails from Steam profiles for leads & outreach. Fast, reliable, and privacy-minded—automate research for B2B sales, marketing, and talent sourcing. 🚀 Build targeted lists in minutes.

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

## Pricing

from $3.99 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### **Steam** Email Scraper 📱

The **Steam** Email Scraper allows users to **extract** various types of **data** from **Steam** accounts efficiently. This **data** can be used for legitimate purposes such as marketing, research, or customer outreach.

By using this tool, you can obtain email addresses and other relevant details from **Steam** users. The **extract**ed **data** is structured and organized to ensure easy analysis and integration.

It is essential to use the **Steam** email harvesting tool responsibly and in compliance with applicable laws. The tool is designed to provide accurate and up-to-date information while maintaining user privacy and **data** security.

Steam Email Scraper is a powerful tool designed to help users extract email addresses from Steam accounts efficiently and accurately. It streamlines the process of collecting contact information from Steam users for legitimate purposes.

With the Steam Email Scraper, you can save time and effort by automating the email extraction process. This tool is ideal for businesses, researchers, and developers looking to connect with Steam users.

Steam account email extractor tools like this one are built to comply with ethical and legal standards. They ensure that data is collected responsibly and only for authorized use cases.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: dev.scraperengine@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email Address | Extract verified email addresses associated with Steam accounts. |
| Usernames | Retrieve Steam usernames linked to the extracted email addresses. |
| Profile Links | Collect direct links to Steam user profiles for further analysis. |
| Account Creation Date | Identify the creation date of Steam accounts for demographic insights. |
| Publicly Shared Information | Access any publicly shared details from Steam user profiles. |
| Game Library Data | Retrieve information about the games owned by the Steam account. |
| Activity Status | Check the online or offline status of Steam users. |
| Steam Groups | Identify the groups or communities a Steam user is part of. |

### Key Features of **Steam** Email Scraper

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

- ⭐ **Accurate**ly extracts email addresses from **Steam** user accounts
- ⭐ Supports large-scale data collection with high efficiency
- ⭐ User-friendly interface for easy operation and configuration
- ⭐ Ensures data security and compliance with privacy regulations
- ⭐ Provides detailed and structured output for seamless analysis
- ⭐ **Customizable** scraping options to target specific data points
- ⭐ **Automated** processes to save time and reduce manual effort
- ⭐ **Regular** updates to maintain compatibility with **Steam**s platform
- ⭐ Scalable to handle both small and large data extraction projects
- ⭐ Includes robust error handling and retry mechanisms
- ⭐ Offers detailed logging for transparency and troubleshooting
- ⭐ Compatible with various operating systems and environments

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

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

1. ✅ **Sign up** for an account on the platform hosting the **Steam** Email Scraper
2. ✅ Download and install the **Steam** Email Scraper software on your device
3. ✅ Log in to your **Steam** account within the scraper tool to authenticate
4. ✅ **Configure** the scraping parameters such as target profiles or groups
5. ✅ **Start** the scraping process and monitor the progress in real-time
6. ✅ **Export** the extracted data in your preferred format such as CSV or JSON
7. ✅ **Review** the collected data to ensure its accuracy and completeness
8. ✅ Use the data responsibly and in compliance with legal guidelines

### Use Cases 🎯

Marketing Campaigns
🎯 Reach out to **Steam** users with targeted marketing emails
🎯 Build a contact list for promoting gaming-related products or services

Research and Analysis
🎯 **Study** user demographics and behaviors on the **Steam** platform
🎯 **Analyze** trends in gaming preferences and community engagement

Customer Outreach
🎯 Connect with potential customers for personalized communication
🎯 Provide support or gather feedback from **Steam** users

Business Development
🎯 **Identify** potential partners or collaborators within the **Steam** community
🎯 Expand your network by connecting with relevant **Steam** users

### Why choose us? 💎

The **Steam** Email Scraper stands out as the **best** **Steam** email scraping tool due to its precision and reliability. It is built with **advanced** algorithms to ensure accurate data extraction from **Steam** accounts.

Our tool is **user-friendly** and designed to cater to both beginners and experienced users. We prioritize data security and compliance with privacy regulations to protect user information.

With features like customizable scraping options and detailed logging, our software offers unparalleled functionality. Whether you need to extract emails from **Steam** accounts for marketing or research, our tool delivers consistent results.

We provide **regular** updates to maintain compatibility with **Steam**'s platform and address any changes. Our dedicated support team is always ready to assist you with any queries or issues.

By choosing our **Steam** email extraction software, you gain access to a **reliable** and efficient solution for your data needs.

### **Steam** Email Scraper Scalability 📈

The **Steam** Email Scraper is designed to handle projects of any size, making it a scalable solution for diverse needs. Whether you need to extract a few emails or process large datasets, our tool can manage it **efficient**ly.

It supports batch processing and automation to streamline **large-scale** data collection. The software is optimized for speed and performance, ensuring quick results without compromising accuracy.

With robust error handling and retry mechanisms, it minimizes disruptions during the scraping process. Our tool is compatible with various systems and environments, providing flexibility for different use cases.

Regular updates ensure that the scraper remains functional and **efficient** as **Steam** evolves. This scalability makes it an ideal choice for businesses, researchers, and developers alike.

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

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

#### Legal & Ethical Guidelines
⚖️ **Use** the **Steam** Email Scraper only for authorized and ethical purposes
⚖️ **Obtain** consent from users before collecting or utilizing their data
⚖️ Comply with all applicable data protection and privacy laws in your region
⚖️ **Do not** use the tool for spamming or any other malicious activities
⚖️ **Ensure** that the data collected is stored securely and responsibly
⚖️ Respect **Steam**s terms of service and user privacy policies
⚖️ **Avoid** scraping data from users who have opted out of public visibility
⚖️ Regularly review and update your practices to maintain compliance

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

### Output Format 📤

📝 Example Output (JSON)

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

### FAQ ❓

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

The Steam Email Scraper is a tool designed to extract email addresses and other relevant data from Steam accounts efficiently.

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

**Yes**, it is legal to use as long as you comply with data protection laws and Steam's terms of service.

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

You can extract email addresses, usernames, profile links, account creation dates, and other **publicly available** information.

#### Can I use this tool for marketing purposes?

**Yes**, but you must obtain user consent and comply with all relevant regulations to use the data for marketing.

#### Is the tool compatible with all operating systems?

The Steam Email Scraper is compatible with various operating systems, including Windows, macOS, and Linux.

#### How do I ensure compliance with privacy laws?

Always obtain user consent, respect privacy settings, and adhere to data protection regulations in your region.

#### Can I scrape data from **private** Steam accounts?

**No**, the tool only extracts data from publicly accessible Steam accounts.

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

**Yes**, the Steam Email Scraper is designed to handle both small and large-scale data extraction projects.

#### How often is the tool updated?

The tool is regularly updated to maintain compatibility with Steam's platform and improve functionality.

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

**Yes**, our **dedicated support** team is available to assist you with any questions or issues.

#### Can I **export** the **extract**ed data?

**Yes**, you can export the data in formats such as **CSV** or **JSON** for further use.

#### Does the tool store the data it **extract**s?

**No**, the tool does not store any data. All extracted information is saved locally on your device.

#### What are the system requirements for the tool?

The system requirements vary depending on the version, but it is optimized to run on most modern devices.

#### Is there a free trial available?

**Yes**, a free trial is available to help you evaluate the tool before purchasing.

#### Can I customize the scraping parameters?

**Yes**, the tool allows you to configure various parameters to target specific data points.

# Actor input Schema

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

List of keywords to search for on Steampowered (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Steampowered 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": "Steampowered",
  "location": "",
  "emailDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keywords": [
        "marketing"
    ],
    "emailDomains": [
        "@gmail.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperx/steam-email-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": ["marketing"],
    "emailDomains": ["@gmail.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scraperx/steam-email-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "marketing"
  ],
  "emailDomains": [
    "@gmail.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraperx/steam-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Steam Email Scraper",
        "description": "📧 Steam Email Scraper extracts emails from Steam profiles for leads & outreach. Fast, reliable, and privacy-minded—automate research for B2B sales, marketing, and talent sourcing. 🚀 Build targeted lists in minutes.",
        "version": "0.1",
        "x-build-id": "IH7GWr74FxFfTRl7h"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperx~steam-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperx-steam-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scraperx~steam-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperx-steam-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scraperx~steam-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperx-steam-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 Steampowered (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Steampowered profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Steampowered"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Steampowered"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```