# Luma Email Scraper (`scrapepilotapi/luma-email-scraper`) Actor

📧 Luma Email Scraper extracts valid email addresses from web content with Luma for fast lead discovery. Perfect for B2B outreach, sales prospecting, and data enrichment. 🚀 Save time, boost targeting, and scale confidently.

- **URL**: https://apify.com/scrapepilotapi/luma-email-scraper.md
- **Developed by:** [ScrapePilot](https://apify.com/scrapepilotapi) (community)
- **Categories:** Lead generation, Automation, Other
- **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

### **Luma** Email Scraper 📱

**Luma** Email Scraper enables users to **extract** a variety of **data** points from **Luma** websites. This includes email addresses, names, and associated meta**data**.

The tool ensures that all **extract**ed **data** is relevant and formatted for easy integration into marketing campaigns. With its advanced email scraping capabilities, users can gather **contact** information from multiple sources on **Luma** platforms.

This email **data** **extract**ion tool is optimized for accuracy, ensuring that only valid and usable **data** is retrieved. It is an essential resource for marketers, researchers, and businesses looking to enhance their outreach efforts.

By using **Luma** Email Scraper, users can automate the process of collecting email **data**, saving time and improving efficiency. The tool is designed to handle large-scale **data** **extract**ion tasks while maintaining high-quality results.

Luma Email Scraper is a powerful tool designed to extract email addresses from Luma websites efficiently and accurately. It is ideal for businesses and marketers looking to build targeted email lists quickly.

This advanced email scraper automates the process of email data extraction, saving time and effort compared to manual methods. It is one of the top email scraping tools available for marketing professionals.

With Luma Email Scraper, you can streamline your email scraping automation and access high-quality data for your campaigns. It is a reliable email extractor software that ensures precision and compliance.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: scrapier.io@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email Addresses | Extracts valid email addresses from Luma websites. |
| Names | Captures associated names linked to email addresses. |
| Profile Links | Retrieves URLs of profiles containing email information. |
| Company Names | Extracts company names related to email contacts. |
| Job Titles | Identifies job titles connected to email addresses. |
| Social Media Links | Collects links to social media profiles associated with emails. |
| Phone Numbers | Extracts phone numbers when available alongside email data. |
| Custom Metadata | Gathers additional metadata based on user-defined parameters. |

### Key Features of **Luma** Email Scraper

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

- ⭐ Automates email scraping from **Luma** websites with precision
- ⭐ Supports bulk data extraction for large-scale projects
- ⭐ Integrates seamlessly with email list builder software and marketing tools
- ⭐ Offers advanced filtering options to refine extracted data
- ⭐ Ensures compliance with legal and ethical email scraping guidelines
- ⭐ Provides real-time email scraping automation for faster results
- ⭐ Includes an intuitive interface for easy setup and operation
- ⭐ Delivers high accuracy in email data extraction to minimize errors
- ⭐ Compatible with **Luma** platforms and other related APIs
- ⭐ Enables export of extracted data in multiple formats for convenience
- ⭐ Features robust security measures to protect user data during scraping
- ⭐ Offers detailed logs and reports for transparency and analysis

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

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

1. ✅ **Sign up** for an account on the **Luma** Email Scraper platform
2. ✅ Log in and navigate to the dashboard to start a new scraping project
3. ✅ Enter the URL of the **Luma** website you wish to scrape emails from
4. ✅ **Configure** the scraping parameters such as filters and data types
5. ✅ Run the scraper and monitor the progress in real-time on the dashboard
6. ✅ **Review** the extracted data and verify its accuracy using built-in tools
7. ✅ **Export** the data in your preferred format such as CSV or JSON
8. ✅ **Integrate** the exported data with your email marketing software
9. ✅ Adjust the scraping settings for future projects as needed
10. ✅ Schedule automated scraping tasks for ongoing data collection
11. ✅ Access detailed reports to analyze the performance of scraping tasks
12. ✅ Contact support for assistance if you encounter any issues

### Use Cases 🎯

Marketing Campaigns
🎯 Build targeted email lists for promotional campaigns
🎯 Enhance outreach efforts with accurate contact information

Lead Generation
🎯 **Identify** potential clients by extracting relevant email data
🎯 Streamline the process of finding new business opportunities

Market Research
🎯 Gather data to analyze trends and consumer behavior
🎯 Extract contact information for surveys and feedback

Recruitment
🎯 **Find** potential candidates by extracting emails from profiles
🎯 Reach out to professionals in specific industries or roles

Networking
🎯 Expand professional connections by collecting email addresses
🎯 **Use** extracted data to initiate meaningful conversations

### Why choose us? 💎

**Luma** Email Scraper is the **best** email scraping tool for businesses and marketers seeking **reliable** data extraction. Our platform offers **advanced** email scraping automation to save time and improve efficiency.

With features like real-time scraping and customizable parameters, users can tailor the tool to their specific needs. We prioritize accuracy, ensuring that all extracted data is valid and ready for use.

Our email extractor software is designed to handle projects of any size, making it suitable for both small and large-scale operations. By choosing **Luma** Email Scraper, you gain access to a **user-friendly** interface and seamless integration with marketing tools.

We also provide excellent customer support to assist with any challenges you may face. Our commitment to compliance ensures that all scraping activities adhere to legal and ethical standards.

Whether you need an email scraping API or a comprehensive email list builder software, **Luma** Email Scraper delivers exceptional performance. Trust us to provide the tools you need to succeed in your marketing and outreach efforts.

### **Luma** Email Scraper Scalability 📈

**Luma** Email Scraper is designed to scale with your business needs, making it one of the top email scraping tools available. It can handle small projects as well as **large-scale** email data extraction tasks with ease.

The tool’s robust infrastructure ensures reliable performance even when processing vast amounts of data. With features like bulk scraping and automated scheduling, users can manage multiple projects simultaneously.

Our email scraping API allows developers to integrate the tool into custom workflows for enhanced scalability. Whether you are a small business or a large enterprise, **Luma** Email Scraper adapts to your requirements.

It supports high-speed data extraction without compromising on accuracy or quality. By leveraging this **advanced** email scraper, you can grow your operations while maintaining efficiency and compliance.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with all applicable data protection laws when using **Luma** Email Scraper
⚖️ **Obtain** consent from individuals before using their email addresses for marketing purposes
⚖️ **Avoid** scraping websites that explicitly prohibit data extraction in their terms of service
⚖️ **Do not** use extracted data for illegal or unethical activities
⚖️ Regularly review and update your scraping practices to align with current regulations
⚖️ Respect the privacy and rights of individuals when collecting and using email data
⚖️ **Use** **Luma** Email Scraper responsibly to avoid potential legal consequences
⚖️ Consult legal professionals if you are unsure about the legality of your scraping activities

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

### Output Format 📤

📝 Example Output (JSON)

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

### FAQ ❓

#### What is Luma **Email Scraper**?

Luma Email Scraper is an advanced tool for extracting email addresses and related data from Luma websites.

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

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

#### Can I use Luma **Email Scraper** for marketing purposes?

**Yes**, you can use it to build targeted email lists for marketing campaigns, provided you have obtained consent.

#### What data can I **extract** with Luma **Email Scraper**?

You can extract email addresses, names, profile links, company names, job titles, and more.

#### Does Luma **Email Scraper** support bulk data **extract**ion?

**Yes**, it supports bulk scraping for handling large-scale projects efficiently.

#### Is there an API available for Luma **Email Scraper**?

**Yes**, our email scraping API allows developers to integrate the tool into custom workflows.

#### How accurate is the **extract**ed data?

Luma Email Scraper ensures high accuracy by validating and refining the extracted data.

#### Can I **export** the data in different formats?

**Yes**, you can export the data in formats like **CSV** or **JSON** for easy integration.

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

**Yes**, we provide excellent customer support to assist with any issues or questions.

#### Does Luma **Email Scraper** comply with GDPR?

**Yes**, it is designed to comply with GDPR and other data protection regulations.

#### Can I schedule automated scraping tasks?

**Yes**, you can schedule tasks to automate email scraping for ongoing projects.

#### What platforms does Luma **Email Scraper** support?

It is specifically designed for scraping data from Luma websites.

#### How do I get started with Luma **Email Scraper**?

Sign up for an account, configure your scraping parameters, and start extracting data.

#### Is there a free trial available?

**Yes**, we offer a free trial so you can test the tool before committing to a subscription.

#### Can I customize the scraping parameters?

**Yes**, you can customize parameters to refine the data extraction process based on your needs.

# Actor input Schema

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Luma Email Scraper",
        "description": "📧 Luma Email Scraper extracts valid email addresses from web content with Luma for fast lead discovery. Perfect for B2B outreach, sales prospecting, and data enrichment. 🚀 Save time, boost targeting, and scale confidently.",
        "version": "0.1",
        "x-build-id": "NyX8hR8nwjdLAcvQO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapepilotapi~luma-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapepilotapi-luma-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/scrapepilotapi~luma-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapepilotapi-luma-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/scrapepilotapi~luma-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapepilotapi-luma-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 Luma (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Luma profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Luma"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Luma"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```