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

📧 Steam Email Scraper extracts verified email addresses from Steam profiles with ease. 🚀 Streamline lead gen, outreach, and B2B research. 🔍 Fast, lightweight, and scriptable—perfect for sales teams and developers.

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

## Pricing

from $3.99 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### **Steam** Email Scraper 📱

The **Steam** Email Scraper allows users to **extract** a wide range of **data** from **Steam** accounts. This includes essential **contact** information such as email addresses, which can be used for marketing, research, or communication purposes.

Additional **data** points such as usernames, profile URLs, and account creation dates can also be retrieved. The tool ensures that all **extract**ed **data** is accurate and up-to-date, providing users with reliable information.

It is designed to handle large **data**sets efficiently, making it suitable for both small-scale and enterprise-level operations. By using this email scraping tool for **Steam**, you can gain valuable insights into user profiles and engagement patterns.

The software is built to comply with legal and ethical standards, ensuring that all **data** **extract**ion activities are conducted responsibly. Its advanced algorithms and automation capabilities make it the best choice for **extract**ing **emails** from **Steam** accounts.

Steam Email Scraper is a powerful tool designed to help users extract email addresses associated with Steam accounts efficiently and securely. This automated solution simplifies the process of gathering contact information from Steam profiles.

With the Steam Email Scraper, you can save time and effort by automating email extraction tasks. It is ideal for businesses, researchers, and developers looking to streamline their data collection processes.

This Steam email extractor is built to handle large-scale scraping operations while ensuring compliance with legal and ethical guidelines. It provides accurate and reliable results tailored to your specific needs.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: scrapier.io@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email Address | Retrieve the email addresses associated with Steam accounts. |
| Username | Extract the usernames of Steam account holders. |
| Profile URL | Obtain the direct URL to the user's Steam profile. |
| Account Creation Date | Identify the date when the Steam account was created. |
| Profile Avatar | Download the profile avatar image of the Steam user. |
| Country/Region | Extract the geographical location of the Steam account holder. |
| Friend List | Retrieve the list of friends associated with a Steam account. |
| Game Library | Access information about games owned by the Steam user. |

### 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**:

- ⭐ **Automated** email extraction from **Steam** accounts for efficient data collection
- ⭐ User-friendly interface designed for both beginners and advanced users
- ⭐ Supports large-scale data scraping with high accuracy and reliability
- ⭐ **Advanced** filtering options to target specific user profiles or data points
- ⭐ Compliance with legal and ethical guidelines for responsible data scraping
- ⭐ Real-time data extraction to ensure up-to-date information retrieval
- ⭐ **Secure** data handling with encryption to protect user privacy
- ⭐ **Customizable** settings to tailor the scraping process to your needs
- ⭐ Detailed logging and reporting for transparency and accountability
- ⭐ Cross-platform compatibility for seamless use on various operating systems
- ⭐ **Regular** updates to maintain compatibility with **Steam**s platform changes
- ⭐ Free trial version available to test the tools capabilities

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

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

1. ✅ Download and install the **Steam** Email Scraper software on your device
2. ✅ Launch the application and **log in** with your credentials if required
3. ✅ Enter the specific **Steam** account URLs or keywords you want to target
4. ✅ **Configure** the scraping settings such as data types and filters
5. ✅ **Start** the scraping process by clicking the **Start** button
6. ✅ Monitor the progress of the scraping operation in the dashboard
7. ✅ Once completed review the extracted data in the results section
8. ✅ **Export** the data in your preferred format such as CSV or JSON
9. ✅ Save the exported file to your device for further analysis or use
10. ✅ Adjust settings as needed for additional scraping tasks
11. ✅ Refer to the user guide or support team for troubleshooting assistance
12. ✅ Ensure compliance with legal guidelines before using the extracted data

### Use Cases 🎯

Marketing and Outreach
🎯 Build targeted email lists for marketing campaigns
🎯 Reach out to **Steam** users for promotional purposes
🎯 **Identify** potential customers based on gaming interests

Research and Analysis
🎯 Gather data for market research and trend analysis
🎯 **Analyze** user demographics and engagement patterns
🎯 **Study** the gaming preferences of **Steam** users

Business Development
🎯 **Identify** potential partners or collaborators on **Steam**
🎯 Expand your network by connecting with relevant users
🎯 Discover new opportunities in the gaming industry

Data Enrichment
🎯 Enhance existing datasets with additional user information
🎯 Verify and update contact details for accuracy
🎯 Integrate extracted data into CRM systems for better management

### Why choose us? 💎

The **Steam** Email Scraper stands out as the **best** email scraping tool for **Steam** due to its **advanced** features and user-centric design. Our software is built with cutting-edge technology to ensure accurate and efficient data extraction.

We prioritize user convenience by offering a simple interface that requires no technical expertise to operate. Our tool is compatible with various platforms, allowing you to scrape emails from **Steam** accounts seamlessly.

We also provide robust security measures to protect your data and ensure compliance with legal standards. Our dedicated support team is available to assist with any issues or questions you may have.

By choosing our **Steam** email extractor, you gain access to a **reliable** and **scalable** solution that meets your unique requirements. Whether you are a marketer, researcher, or developer, our tool is designed to help you achieve your goals effectively.

Experience the difference with our automated **Steam** email scraper and take your data collection to the next level.

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

The **Steam** Email Scraper is designed to handle both small-scale and **large-scale** data extraction tasks. Its **advanced** algorithms ensure **efficient** performance even when processing **extensive** datasets.

This makes it suitable for businesses of all sizes, from startups to large enterprises. The tool's **customizable** settings allow you to scale operations based on your specific needs.

Whether you need to extract emails from a few accounts or thousands, our software can handle the workload **seamless**ly. We also offer robust support and regular updates to maintain optimal performance.

By using our **Steam** email scraping software, you can confidently scale your data collection efforts without compromising on accuracy or reliability. Our solution is built to grow with your business, ensuring that you always have the tools you need to succeed.

### **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
⚖️ **Ensure** compliance with all applicable data protection laws and regulations
⚖️ **Obtain** proper consent before using extracted email addresses for marketing purposes
⚖️ **Do not** use the tool to scrape sensitive or personally identifiable information illegally
⚖️ **Avoid** scraping data from accounts with privacy settings that restrict access
⚖️ **Use** the extracted data responsibly and ethically for legitimate purposes only
⚖️ Regularly review and adhere to **Steam**s terms of service and usage policies
⚖️ **Do not** sell or distribute extracted data without proper authorization
⚖️ Respect the privacy and rights of **Steam** users during the data scraping process

### 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 data from Steam accounts efficiently and **secure**ly.

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

#### Can I use this tool for free?

We offer a free trial version to test the tool's capabilities before purchasing.

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

You can extract email addresses, usernames, profile URLs, account creation dates, and more.

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

**Yes**, the tool features a **user-friendly** interface designed for both beginners and advanced users.

#### Does this tool support **large-scale** data scraping?

**Yes**, it is designed to handle both small-scale and large-scale data extraction tasks efficiently.

#### How do I **export** the **extract**ed data?

You can export the data in formats like **CSV** or **JSON** for further use.

#### Is my data **secure** while using this tool?

**Yes**, we implement robust security measures to protect your data during the scraping process.

#### Can I customize the scraping process?

**Yes**, the tool offers customizable settings to tailor the scraping process to your needs.

#### What support options are available?

We provide **dedicated support** to assist with any issues or questions you may have.

#### Does the tool comply with GDPR regulations?

**Yes**, the Steam Email Scraper is designed to comply with GDPR and other data protection laws.

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

**No**, the tool does not support scraping data from accounts with privacy restrictions.

#### Are there regular updates for the software?

**Yes**, we provide **regular updates** to ensure compatibility with Steam's platform changes.

#### What operating systems are supported?

The tool is compatible with various operating systems, including Windows, macOS, and Linux.

#### Is there a refund policy for the paid version?

**Yes**, we offer a refund policy as per our terms and conditions if you are not satisfied with the product.

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapium/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 verified email addresses from Steam profiles with ease. 🚀 Streamline lead gen, outreach, and B2B research. 🔍 Fast, lightweight, and scriptable—perfect for sales teams and developers.",
        "version": "0.1",
        "x-build-id": "eNxmfRt4BQueeqOnC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapium~steam-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapium-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/scrapium~steam-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapium-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/scrapium~steam-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapium-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```