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

📧 Mercadolibre Email Scraper extracts verified business emails from Mercadolibre listings and stores. ✅ Boost B2B outreach, sales leads, and market research with clean data. 🚀 Fast, efficient, and SEO-ready for growth teams.

- **URL**: https://apify.com/scraperoka/mercadolibre-email-scraper.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (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 $1.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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 🚀

Manually hunting down buyer and seller contact emails wastes hours you can’t get back. **Mercadolibre Email Scraper** automatically scrapes emails from publicly available Mercadolibre data using your keywords, domain filters, and optional location—ideal for marketers, recruiters, and growth teams that need an email list fast. With Mercadolibre email extractor runs, you can collect thousands of potential contacts in a single run.

---

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "keyword": "honda",
  "title": "Example listing title",
  "description": "Contact us at sales@example.com for more information.",
  "url": "https://www.mercadolibre.com/ejemplo",
  "email": "sales@example.com"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `keyword` | string | The keyword that was used to find this contact (useful for segmenting leads) |
| `title` | string | The page title text pulled alongside the contact info |
| `description` | string | The extracted text snippet where the email was detected (great for auditing later) |
| `url` | string | The source link associated with the extracted email |
| `email` | string | The email address that matches your `customDomains` filter |
| *(dedup behavior)* | — | Emails are deduplicated during the run so the dataset grows with unique contacts |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

### Why Mercadolibre Email Scraper?

There are a lot of ways to pull contact data from e-commerce platforms—here’s what sets **Mercadolibre Email Scraper** apart.

#### Keyword + domain filtering that matches your outreach goals

You control which terms matter via `keywords`, and you narrow results to specific email providers or domains using `customDomains`. This makes the Mercadolibre leads scraper output easier to use for targeted campaigns (instead of a huge, noisy email list).

#### Structured, integration-ready output from the start

Every discovered email is pushed with consistent fields: `keyword`, `title`, `description`, `url`, and `email`. That means you can plug the **mercadolibre contact email scraper** results into your CRM, spreadsheets, or downstream automation with minimal cleanup.

#### Resilient scraping with built-in fallback behavior

The actor includes fallback logic to improve the odds of getting results when the primary attempt finds none. This helps the mercadolibre email harvesting workflow feel more reliable across different runs.

#### Built-in proxy support for reliable scraping

Use `proxyConfiguration` to route requests through Apify Proxy for better reliability, especially when you’re running multiple keywords and domains. This supports higher-volume Mercadolibre email scraping tool workflows without as much manual babysitting.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

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

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | A list of keywords to search for and match contacts against |
| `location` | ⬜ | Optional location filter text to narrow results |
| `mercadolibreSite` | ⬜ | Selects which Mercadolibre marketplace site to scrape (by region) |
| `customDomains` | ⬜ | A list of email domain filters (for example `@gmail.com`) to only keep emails from those domains |
| `proxyConfiguration` | ⬜ | Configure proxies for the Actor |

↳ `proxyConfiguration` fields are defined by Apify’s proxy editor (as exposed in the input schema).

***

### Core Capabilities

#### Keyword-driven email discovery

Mercadolibre Email Scraper uses the `keywords` you provide as the basis for finding relevant contact mentions. Combined with `customDomains`, it focuses on the kinds of buyer email extractor or seller email scraper results you can actually use.

#### Optional location filtering

If you set `location`, it will be used as an additional filter to refine what gets surfaced. This helps when you want a mercadolibre email finder that’s closer to specific regions or markets.

#### Custom email domain filtering for cleaner lists

`customDomains` lets you specify which email addresses you want to keep. For outreach teams, this is a practical way to reduce irrelevant addresses and speed up list-building for campaigns.

#### Deduplicated contacts during a run

Emails are deduplicated during the run using an in-memory `seen_emails` set. The result is a cleaner mercadolibre email list with unique `email` values rather than repeated hits.

#### End-to-end dataset pushing

All collected results are pushed to the Apify dataset via `await Actor.push_data(...)` with `charged_event_name="result"`. That gives you immediate, structured outputs ready for export and analysis.

***

### Who Gets the Most Out of This

Here's how different teams put Mercadolibre Email Scraper to work:

**Growth and performance marketers** use the mercadolibre outreach email scraper workflow to build targeted prospect lists by keyword and email domain, then export the dataset straight into their outreach tools.

**Sales development representatives** can turn product-related keywords into a structured contact dataset, focusing on domains that match their deliverability strategy and lead qualification rules.

**Freelance researchers & data analysts** benefit from the consistent output fields (`keyword`, `title`, `description`, `url`, `email`) because it’s easy to audit where each email came from and segment results by input parameters.

**Automation specialists and developers** can integrate the mercadolibre contact data scraper into a larger pipeline by running the actor and consuming the dataset output programmatically via the Apify API.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run Mercadolibre Email Scraper from start to finish:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and find *Mercadolibre Email Scraper*.
2. **Enter your inputs** — set `keywords` (required), then optionally `location`, `mercadolibreSite`, `customDomains`, and `proxyConfiguration`.
3. **Configure proxy settings** — if you use `proxyConfiguration`, enable Apify Proxy for improved reliability on larger runs.
4. **Hit Run and watch the live log** — monitor progress and see the actor’s extraction activity while it processes your inputs.
5. **View results in the dataset tab** — collected records appear as the actor pushes `results` to the dataset.
6. **Export as JSON, CSV, or Excel** — download the dataset in your preferred format from the Apify dashboard.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Mercadolibre Email Scraper plugs directly into your existing workflow.

You can export your dataset as JSON, CSV, or Excel straight from the Apify dataset tab. For teams that build dashboards or maintain ongoing lists, this makes the mercadolibre email scraping software output easy to reuse immediately.

For automation and orchestration, you can connect results via Apify’s API (see [Apify API documentation](https://apify.com/docs/api)). From there, you can push data into your CRM, spreadsheets, or other systems using no-code tools like Zapier/Make, and trigger downstream actions with webhooks when runs complete (refer to Apify docs for exact setup steps).

***

### Pricing & Free Trial

Mercadolibre Email Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. Free tier usage is typically enough for several test runs, so you can validate your keyword and `customDomains` strategy before scaling.

For larger batches, billing is based on Apify platform compute units (CU). To see current plan limits and pricing details, check the Apify pricing page.

Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate-limit resistance | Uses built-in request resilience and optional proxy routing |
| Improved run success | Includes fallback behavior when no emails are found in the initial attempt |
| Cleaner results | Deduplicates emails during the run to reduce repeated entries |
| Structured dataset writing | Pushes results into your Apify dataset with consistent fields |
| Multi-input scaling | Processes combinations of `keywords` and `customDomains` in one run |

**Limitations:** This actor works with publicly available data. If the relevant email isn’t present in the extracted text for a given result, it won’t be found—even if the keyword and domain filters match. For enterprise-scale needs, contact us to discuss custom configurations.

For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial?

Yes. Apify provides a free tier that includes credits for running actors, which is enough to test Mercadolibre Email Scraper on a small input set.

#### Do I need to log in to Mercadolibre to use this?

No. The actor scrapes emails from publicly available sources using the inputs you provide, so you don’t need a Mercadolibre account for the run.

#### How accurate is the data?

The accuracy depends on what email addresses are present in the extracted publicly available text. Mercadolibre Email Scraper extracts emails that match the `customDomains` you set, so the results align with your domain filtering instead of broad guessing.

#### How many results can I get per run?

Results depend on your combination of `keywords` and `customDomains`, plus how often matching emails appear in the extracted public data. There’s no specific “maxResults” parameter in the actor inputs—so plan your run size based on your keyword and domain breadth.

#### How often is the data updated / how fresh is it?

The actor collects data at the time you run it. So freshness is tied to your run schedule: run again when you want the latest dataset.

#### Is this legal? Does it comply with GDPR / CCPA?

The actor uses **publicly available data**. You are responsible for ensuring your use, storage, and outreach comply with GDPR, CCPA, platform terms, and any applicable local regulations.

#### Can I export results to Google Sheets or Excel?

Yes. You can export from the Apify dataset tab as JSON, CSV, or Excel. If you want Google Sheets specifically, you can import the exported CSV into your sheet.

#### Can I run this on a schedule automatically?

Yes. You can schedule Actor runs on the Apify platform. Use Apify’s scheduling features (see Apify docs) to automate periodic email list refreshes.

#### Can I access this via API?

Yes. You can access and consume results programmatically via the Apify API. Refer to [Apify API documentation](https://apify.com/docs/api) for details.

#### What happens if the actor hits an error?

If requests fail for a specific keyword/domain combination, the actor logs the issue and continues processing other combinations. Your final dataset will include whatever results were successfully collected and pushed.

***

### Need Help or Have a Request?

Got a question about Mercadolibre Email Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We actively maintain this actor based on user feedback, and we’re happy to help with input setup, scaling ideas, or workflow improvements. If you want a feature like expanded filtering or easier downstream exporting, email us with your use case.

***

### Disclaimer & Responsible Use

*Mercadolibre Email Scraper is the fastest, most reliable way to build targeted Mercadolibre email lists—start your free run today.*

The actor uses **publicly available data**. It does not access private accounts, login-gated content, or password-protected pages. You’re responsible for complying with GDPR, CCPA, platform ToS, and any applicable local regulations when using or storing the extracted data. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scraperoka/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 verified business emails from Mercadolibre listings and stores. ✅ Boost B2B outreach, sales leads, and market research with clean data. 🚀 Fast, efficient, and SEO-ready for growth teams.",
        "version": "1.0",
        "x-build-id": "nuvK7TmO8LnaXWX6P"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~mercadolibre-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-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/scraperoka~mercadolibre-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-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/scraperoka~mercadolibre-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
