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

📩 Mercadolibre Email Scraper mines verified seller emails from MercadoLibre listings using smart crawling. 🚀 Perfect for lead generation, B2B prospecting & marketing outreach—save time and boost conversion with clean, targeted contacts.

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

## Pricing

from $2.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 🔍

**Mercadolibre Email Scraper** is an Apify actor that automatically extracts contact emails from publicly available web data related to Mercadolibre using your **keywords**. If you’re looking to **extract mercadolibre emails** for lead generation, **find mercadolibre contact email finder** records faster, or build a **mercadolibre email database**, this tool helps you scale email discovery without manual searching—saving you hours of work.

Whether you're a marketer, recruiter, sales ops specialist, or data analyst, **Mercadolibre Email Scraper** helps you turn topic ideas into structured leads by combining **keywords**, an optional **location filter**, and **custom email-domain filters**.

---

### Why choose Mercadolibre Email Scraper?

| Feature | Benefit |
|---|---|
| ✅ **All-in-one email harvesting** | Helps you extract mercadolibre emails for multiple keywords and email domains in one run |
| ✅ **Reliability with proxy support** | Improves consistency with built-in proxy configuration for scraping public web data |
| ✅ **Fallback logic for better coverage** | Uses fallback scraping behavior when no emails are found with the initially selected proxy settings |
| ✅ **Structured JSON output** | Returns consistent fields like `keyword`, `email`, `title`, `description`, and `url` for analysis |
| ✅ **Scale-friendly batching** | Works across multiple keywords and custom domains so you can grow your mercadolibre leads email scraper dataset |
| ✅ **Export-ready results** | Produces a dataset you can export (e.g., JSON/CSV) for CRM and downstream workflows |

---

### Key features

- 📌 **Keyword-driven email discovery**: Uses your provided `keywords` to find relevant public web pages for email extraction  
- 🌍 **Location filter option**: Adds `location` when you want leads from a specific region  
- 🎯 **Custom email domain filters**: Uses your `customDomains` list (like `@gmail.com`) to focus on the email types you care about  
- 🧠 **Email extraction from publicly available text**: Extracts email addresses that match the allowed domains from scraped page text  
- 🛡️ **Proxy configuration support**: Lets you configure proxies via `proxyConfiguration` for more reliable scraping runs  
- 🔄 **Fallback behavior for missed results**: If no emails are found, it can switch scraping behavior to improve outcome coverage  
- 💾 **Deduplication built-in**: Avoids duplicate emails across results using an in-run `seen_emails` set  
- 📊 **Clear, structured output records**: Each extracted email becomes a result object with keyword context and source URL

---

### Input

Provide input via an `input.json` file. Example structure:

```json
{
  "keywords": ["honda", "wallet"],
  "location": "",
  "mercadolibreSite": "Mercadolibre Brazil (mercadolivre.com.br)",
  "customDomains": ["@gmail.com"],
  "proxyConfiguration": {}
}
````

#### Input Fields

| Field | Required | Description |
|---|---|---|
| `keywords` | Yes | A list of keywords to search for (used to find relevant Mercadolibre-related public pages and extract emails). |
| `location` | No | A location to filter search results. Leave it empty (`""`) if you don’t want location filtering. |
| `mercadolibreSite` | No | The Mercadolibre regional platform to scrape (choose the country site you care about). |
| `customDomains` | No | A list of custom email domains to target during extraction (for example `@gmail.com`). Only emails matching these domains are returned. |
| `proxyConfiguration` | No | Proxy settings for this Actor. Use this to enable and configure proxy usage for more reliable scraping. |

***

### Output

After execution, the actor saves collected results in JSON format via `await Actor.push_data(results)`.

A typical output looks like this:

```json
[
  {
    "keyword": "honda",
    "title": "Some page title from the scraped result",
    "description": "Extracted text (or 'No data' if missing) from the result description area",
    "url": "http://example.com/source-page-link",
    "email": "contact@example.com"
  }
]
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `keyword` | string | The keyword that produced this email result |
| `title` | string | The text content for the result title area (from the scraped result block) |
| `description` | string | Extracted text from the result description area (or `No data` if no description is available) |
| `url` | string | The `href` link associated with the scraped result |
| `email` | string | The extracted email address matching one of your `customDomains` |
| `error_message` | ❌ | Not present in the actor output—results are pushed as objects containing the fields listed above |

> Export note: once stored in the Apify dataset, you can export the data (for example to JSON/CSV) for analysis or importing into your workflow.

***

### How to use Mercadolibre Email Scraper (via Apify Console)

1. **Open Apify Console**\
   Log in at [console.apify.com](https://console.apify.com) and go to the **Actors** tab.

2. **Find Mercadolibre Email Scraper**\
   Search for **Mercadolibre Email Scraper** and open the actor page.

3. **Go to the INPUT section**\
   Use the built-in form to enter:
   - `keywords`
   - Optional `location`
   - Optional `mercadolibreSite`
   - Optional `customDomains`
   - Optional `proxyConfiguration`

4. **Set your email-domain targets (recommended)** 📧\
   In `customDomains`, add the domains you want to capture (this is what makes the mercadolibre email scraper results more useful for outreach).

5. **Configure proxy settings (optional)** 🛡️\
   If you need improved scraping reliability, set `proxyConfiguration` accordingly. The actor can also use fallback behavior when no emails are found for your initial proxy settings.

6. **Click Run** ▶️\
   Start the run and watch logs to see progress for each keyword/domain combination and the extracted records.

7. **Review results in the OUTPUT tab**\
   Open the dataset to view the JSON records (`keyword`, `title`, `description`, `url`, `email`) and export them for downstream use (CRM, spreadsheets, or analysis).

No coding required—get results in minutes with this SEO-friendly **mercadolibre email harvesting** tool.

***

### Advanced features & SEO optimization

- 🔍 **Engineered for “Mercadolibre Email Scraper” workflows**: Built specifically for lead generation where you need a **mercadolibre seller email scraper tool** style output (emails tied to keyword context).
- 🌐 **Email-domain targeting for cleaner leads**: Uses your `customDomains` to focus on the kinds of **mercadolibre business email scraper** leads you actually want.
- 🔄 **Resilience via fallback behavior**: If a run finds no emails under the initial proxy configuration, it can switch scraping behavior to try to improve outcome coverage.
- 🧾 **Structured dataset for analysis-ready pipelines**: The output is consistently shaped (ideal for analysts building a mercadolibre email database or for marketers validating lead sources).
- 📊 **Keyword-rich extraction at scale**: Works across multiple keywords and domains, making it a practical choice for automated mercadolibre email scraping and harvest pipelines.

***

### Best use cases

- 📈 **Marketing teams building lead lists**: Quickly collect contact emails tied to relevant Mercadolibre topics for outreach campaigns.
- 🧑‍💼 **Sales operations teams sourcing prospects**: Expand a pipeline by scraping emails from publicly available sources using your keyword strategy and custom email domains.
- 🔎 **Data analysts enriching datasets**: Combine keyword context (`keyword`) and source context (`url`, `title`) with extracted emails for analysis.
- 🏪 **Ecommerce and brand researchers**: Gather mercadolibre contact email finder data around product-related keywords to map competitive presence.
- 💼 **Recruiters and sourcing specialists**: Discover publicly listed contact emails for brand or seller communication workflows.
- 🛠️ **Automation engineers integrating with CRMs**: Feed extracted emails into downstream systems using the actor’s structured JSON dataset output.
- 🎯 **Lead generation specialists**: Build a practical mercadolibre email harvesting pipeline by iterating on keywords and domain filters.

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `keywords` as an array of strings
  - ✅ `location` as a string (optional)
  - ✅ `mercadolibreSite` as a selected country platform from the provided enum
  - ✅ `customDomains` as an array of strings (email domains)
  - ✅ `proxyConfiguration` as an object (proxy settings)

- **Proxy Support**
  - ✅ Proxy configuration via `proxyConfiguration`
  - ✅ Built-in fallback behavior when no emails are found under initial proxy conditions

- **Retry Mechanism**
  - ❌ Not specified in the provided source code as a user-configurable retry count

- **Dataset Structure**
  - ✅ JSON array of objects pushed via `Actor.push_data(results)`
  - ✅ Each result contains: `keyword`, `title`, `description`, `url`, `email`

- **Rate Limits & Performance**
  - ✅ Processing is done per keyword and per domain, and results are deduplicated within the run
  - ❌ No explicit speed or throughput numbers are provided in the source

- **Limitations**
  - ❌ Only emails matching `customDomains` are returned
  - ❌ If no relevant public data contains extractable emails for the chosen domains, the output may be empty

***

### FAQ

#### Do I need to provide all input fields for Mercadolibre Email Scraper?

No. The only required field is `keywords`. You can leave `location`, `mercadolibreSite`, `customDomains`, and `proxyConfiguration` at their defaults if you want a quick start.

#### What email addresses will the actor extract?

It extracts email addresses that match the allowed domains from `customDomains`. For example, if `customDomains` includes `@gmail.com`, it will return emails ending with `@gmail.com`.

#### Can I target a specific Mercadolibre country site?

Yes. Use `mercadolibreSite` to select the regional platform from the provided list (for example, Mercadolibre Brazil (mercadolivre.com.br)).

#### Does location filtering work?

Yes. If you set `location` (it’s a string), the actor includes it to narrow results. If you keep `location` empty (`""`), it will not apply a location filter.

#### How is the output structured for analysis?

The actor pushes an array of result objects to the dataset, each containing `keyword`, `title`, `description`, `url`, and `email`. This makes it easy to import into spreadsheets, BI tools, or CRM pipelines.

#### Can I integrate this into a Python workflow?

Yes. In Apify, dataset export can be used to move results into your Python/ETL pipeline. The actor itself is designed to output structured JSON records, which is typically easy to process programmatically in downstream steps.

#### Is this data taken from private or logged-in pages?

❌ No. This tool is intended to work with **publicly available sources**. It does not access private profiles, authenticated-only content, or password-protected pages.

#### What should I do if I need help or have a feature request?

For questions about Mercadolibre Email Scraper, share your request and details with <dataforleads@gmail.com>.

***

### Support & feature requests

Have feedback or want to improve Mercadolibre Email Scraper? We’d love to hear from you. 😊

- 💡 **Feature Requests**: Examples include adding additional export options (CSV/Excel), expanding output fields beyond `keyword`, `title`, `description`, `url`, and `email`, or enhancing email-domain filtering features for your mercadolibre email database workflow.
- 📧 **Contact**: Reach out via <dataforleads@gmail.com>.

Your input directly shapes the roadmap for better automated mercadolibre email scraping.

***

### Closing CTA / Final thoughts

*If you’re serious about extracting mercadolibre emails at scale, **Mercadolibre Email Scraper** is a practical, SEO-friendly way to build lead-ready results fast.*

Use this **mercadolibre email scraper** to turn keyword ideas into structured contact data—without the manual grind.

***

### Disclaimer

This tool only accesses **publicly accessible sources** and extracts email addresses from publicly available web data. It does not access private profiles, authenticated-only information, or password-protected pages.

It is your responsibility to comply with applicable laws and regulations (including GDPR and CCPA where relevant), as well as spam rules and the target platforms’ terms of service while using this actor.

If you need data removal, contact: <dataforleads@gmail.com>.

Please use Mercadolibre Email Scraper responsibly, ethically, and for legitimate purposes only.

# Actor input Schema

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

A list of keywords to search for.

## `location` (type: `string`):

Location to filter search results.

## `mercadolibreSite` (type: `string`):

Select the Mercadolibre site to scrape.

## `customDomains` (type: `array`):

List of custom email domains

## `proxyConfiguration` (type: `object`):

Configure proxies for this Actor.

## Actor input object example

```json
{
  "keywords": [
    "honda",
    "wallet"
  ],
  "location": "",
  "mercadolibreSite": "Mercadolibre Brazil (mercadolivre.com.br)",
  "customDomains": [
    "@gmail.com"
  ]
}
```

# 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": [
        "honda",
        "wallet"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/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": [
        "honda",
        "wallet",
    ],
    "location": "",
    "customDomains": ["@gmail.com"],
}

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/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": [
    "honda",
    "wallet"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com"
  ]
}' |
apify call scrapers-hub/mercadolibre-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapers-hub/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 mines verified seller emails from MercadoLibre listings using smart crawling. 🚀 Perfect for lead generation, B2B prospecting & marketing outreach—save time and boost conversion with clean, targeted contacts.",
        "version": "1.0",
        "x-build-id": "cutIQQ7tufH2MHjT3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapers-hub~mercadolibre-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapers-hub-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/scrapers-hub~mercadolibre-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapers-hub-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/scrapers-hub~mercadolibre-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapers-hub-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": "A list of keywords to search for.",
                        "default": [
                            "honda",
                            "wallet"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "mercadolibreSite": {
                        "title": "Platform",
                        "enum": [
                            "Mercadolibre Argentina (mercadolibre.com.ar)",
                            "Mercadolibre Bolivia (mercadolibre.com.bo)",
                            "Mercadolibre Brazil (mercadolivre.com.br)",
                            "Mercadolibre Chile (mercadolibre.cl)",
                            "Mercadolibre Colombia (mercadolibre.com.co)",
                            "Mercadolibre Costa Rica (mercadolibre.co.cr)",
                            "Mercadolibre Dominican Republic (mercadolibre.com.do)",
                            "Mercadolibre Ecuador (mercadolibre.com.ec)",
                            "Mercadolibre Guatemala (mercadolibre.com.gt)",
                            "Mercadolibre Honduras (mercadolibre.com.hn)",
                            "Mercadolibre Mexico (mercadolibre.com.mx)",
                            "Mercadolibre Nicaragua (mercadolibre.com.ni)",
                            "Mercadolibre Panama (mercadolibre.com.pa)",
                            "Mercadolibre Paraguay (mercadolibre.com.py)",
                            "Mercadolibre Peru (mercadolibre.com.pe)",
                            "Mercadolibre Salvador (mercadolibre.com.sv)",
                            "Mercadolibre Uruguay (mercadolibre.com.uy)",
                            "Mercadolibre Venezuela (mercadolibre.com.ve)"
                        ],
                        "type": "string",
                        "description": "Select the Mercadolibre site to scrape.",
                        "default": "Mercadolibre Brazil (mercadolivre.com.br)"
                    },
                    "customDomains": {
                        "title": "Custom Email Domains",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Configure proxies for this Actor."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
