# Mercadolibre Email Scraper (`scraperx/mercadolibre-email-scraper`) Actor

📧 Mercadolibre Email Scraper extracts seller emails from MercadoLibre listings fast and accurately. 🚀 Perfect for lead gen, B2B outreach, and market research—save time, reach prospects, and boost conversions.

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

## Pricing

from $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

### **MercadoLibre** Email Scraper 📱

The Mercadolibre Email Scraper allows you to **extract** a variety of essential **data** points from the Mercadolibre platform. This includes email addresses, seller names, product details, and **contact** information.

By automating the **data** collection process, this tool ensures accuracy and efficiency. Users can gather structured **data** that is easy to analyze and integrate into their workflows.

This makes it a valuable resource for businesses seeking to connect with sellers or gain insights into the marketplace. The tool is designed to work seamlessly with Mercadolibre’s platform, ensuring compliance and reliability.

Whether you need bulk **data** or specific seller information, the Mercadolibre Email Scraper has you covered.

Mercadolibre Email Scraper is a powerful tool designed to extract email addresses and contact information from Mercadolibre, one of the largest e-commerce platforms in Latin America. This automated solution helps businesses and individuals gather valuable seller data efficiently.

With the Mercadolibre Email Scraper, you can streamline the process of collecting contact information from Mercadolibre sellers. It eliminates the need for manual data collection, saving time and resources.

Mercadolibre is a hub for millions of sellers and buyers, making it a goldmine for business opportunities. Our email scraping software for Mercadolibre ensures you can tap into this potential by extracting relevant data effortlessly.

### 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 Addresses | Extract seller email addresses for direct communication. |
| Seller Names | Retrieve the names of sellers to personalize outreach. |
| Product Listings | Collect details about products listed by sellers. |
| Contact Numbers | Extract phone numbers for alternative communication methods. |
| Store Names | Identify the names of stores operated by sellers. |
| Location Details | Gather location-based information for targeted marketing. |
| Ratings and Reviews | Analyze seller ratings and customer reviews for insights. |
| Product Categories | Organize data by product categories for better segmentation. |

### Key Features of **MercadoLibre** Email Scraper

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

- ⭐ **Automated** extraction of seller email addresses from Mercadolibre
- ⭐ User-friendly interface requiring no technical expertise
- ⭐ **Accurate** and up-to-date data collection for reliable insights
- ⭐ Ability to extract bulk data or specific seller information
- ⭐ **Customizable** scraping options to meet unique business needs
- ⭐ Seamless integration with Mercadolibres platform for compliance
- ⭐ Export data in multiple formats such as CSV or JSON
- ⭐ **High**-speed scraping to save time and resources
- ⭐ **Secure** and ethical data extraction practices
- ⭐ 247 customer support to assist with any issues

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

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

1. ✅ **Sign up** for an account on the Mercadolibre Email Scraper platform
2. ✅ Log in to the dashboard and select the scraping tool
3. ✅ Enter the desired search criteria such as product category or seller name
4. ✅ **Configure** the scraping parameters including data types to extract
5. ✅ **Start** the scraping process and monitor progress in real-time
6. ✅ Once completed review the extracted data for accuracy
7. ✅ **Export** the data in your preferred format such as CSV or JSON
8. ✅ Use the data for marketing research or business development purposes
9. ✅ Adjust settings for future scraping tasks as needed
10. ✅ Contact customer support if you encounter any issues during the process

### Use Cases 🎯

Lead Generation
🎯 **Collect** seller email addresses for targeted outreach campaigns
🎯 Build a database of potential business partners on Mercadolibre

Market Research
🎯 **Analyze** product listings and categories for market trends
🎯 **Study** seller ratings and reviews to understand customer preferences

Business Development
🎯 **Identify** high-performing sellers for potential partnerships
🎯 Gather location-based data for regional marketing strategies

Competitor Analysis
🎯 Monitor competitor product listings and pricing strategies
🎯 Evaluate competitor seller performance through ratings and reviews

### Why choose us? 💎

Our Mercadolibre Email Scraper stands out as a **reliable** and efficient tool for data extraction. It is designed to meet the needs of businesses, marketers, and researchers by providing accurate and up-to-date information.

With features like automated scraping, customizable options, and secure data handling, it ensures a seamless user experience. We prioritize compliance with Mercadolibre’s policies to maintain ethical data collection practices.

Our tool is backed by 24/7 customer support to assist users at every step. Whether you need bulk data or specific seller information, our scraper delivers results quickly and efficiently.

By choosing our Mercadolibre data extraction tool, you gain access to a powerful resource that supports your business goals. We are committed to providing a **user-friendly** and **reliable** solution for all your data scraping needs.

Trust us to help you unlock the full potential of Mercadolibre’s vast marketplace.

### **MercadoLibre** Email Scraper Scalability 📈

The Mercadolibre Email Scraper is built to handle data extraction tasks of any size. Whether you need to scrape data from a few sellers or thousands, our tool can scale to meet your requirements.

It is optimized for high-speed performance, ensuring quick and **efficient** data collection. The tool’s **customizable** options allow users to tailor scraping tasks to their specific needs.

This makes it suitable for small businesses, large enterprises, and everything in between. Our scraper is designed to handle bulk data without compromising accuracy or reliability.

With robust infrastructure and **advanced** algorithms, it ensures **seamless** performance even for **large-scale** projects. Choose the Mercadolibre Email Scraper for a scalable solution that grows with your business.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with Mercadolibres terms of service when using the scraper
⚖️ **Use** the tool only for lawful and ethical purposes
⚖️ **Avoid** scraping personal data unless you have explicit consent
⚖️ **Do not** use the scraper to engage in spam or unsolicited marketing
⚖️ Respect intellectual property rights and avoid copying proprietary content
⚖️ Regularly review Mercadolibres policies to stay updated on any changes
⚖️ Limit data collection to what is necessary for your business purposes
⚖️ **Ensure** secure storage and handling of extracted data to protect privacy

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

### Output Format 📤

📝 Example Output (JSON)

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

### FAQ ❓

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

It is a tool designed to extract email addresses and other contact information from Mercadolibre.

#### Is the scraper easy to use?

**Yes**, the scraper features a **user-friendly** interface and requires no technical expertise.

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

You can extract email addresses, seller names, product details, and more.

#### Is the tool compliant with Mercadolibre’s policies?

**Yes**, the scraper is designed to operate within Mercadolibre’s terms of service.

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

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

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

**Yes**, we offer 24/7 customer support to assist with any issues.

#### Can I customize the scraping parameters?

**Yes**, the tool allows you to configure scraping settings based on your needs.

#### Is the scraper suitable for **large-scale** projects?

**Yes**, it is designed to handle bulk data extraction efficiently.

#### How often is the data updated?

The scraper ensures accurate and up-to-date data during each extraction session.

#### What are the **legal** guidelines for using this tool?

Users must comply with Mercadolibre’s policies and use the tool for lawful purposes only.

#### Can I scrape data from **specific** sellers?

**Yes**, you can configure the tool to target specific sellers or categories.

#### Is the tool **secure**?

**Yes**, the scraper uses **secure** methods to handle and store extracted data.

#### What industries can benefit from this tool?

Marketers, researchers, and **businesses** across various industries can benefit from this tool.

#### Does the tool support multiple languages?

**Yes**, the scraper is designed to work with Mercadolibre’s multilingual platform.

#### How do I get started with the scraper?

Sign up for an account, log in, and follow the step-by-step instructions to begin scraping.

# Actor input Schema

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mercadolibre Email Scraper",
        "description": "📧 Mercadolibre Email Scraper extracts seller emails from MercadoLibre listings fast and accurately. 🚀 Perfect for lead gen, B2B outreach, and market research—save time, reach prospects, and boost conversions.",
        "version": "0.1",
        "x-build-id": "F6SzVyEG2uvdfGU7V"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperx~mercadolibre-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperx-mercadolibre-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~mercadolibre-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperx-mercadolibre-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~mercadolibre-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperx-mercadolibre-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 Mercadolibre (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Mercadolibre profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Mercadolibre"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Mercadolibre"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
