# MercadoLivre Product Detail & Reviews (`riseandcode/apify-mercadolivre-product-detail`) Actor

Extract full product details from any MercadoLivre / MercadoLibre product page — price, discounts, installments, seller reputation, variants, specs, images, stock — plus optional customer reviews. Works in all 9 countries. Feed it URLs or product IDs.

- **URL**: https://apify.com/riseandcode/apify-mercadolivre-product-detail.md
- **Developed by:** [Rise and Code](https://apify.com/riseandcode) (community)
- **Categories:** E-commerce, Other
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $47.00 / 1,000 product lookups

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

### What does MercadoLivre Product Detail + Reviews do?

This Actor extracts **complete product details** from any [MercadoLivre](https://www.mercadolivre.com.br) / [MercadoLibre](https://www.mercadolibre.com) product page — **price, discount, installments (parcelas), seller reputation, variants (SKUs), technical specs, images, category, stock availability**, and optionally the product's **customer reviews (avaliações / opiniones)**.

It works across **all 9 MercadoLibre marketplaces**: Brazil, Argentina, Mexico, Chile, Colombia, Peru, Uruguay, Ecuador, and the Dominican Republic. Give it product URLs or bare product IDs (`MLB…`, `MLA…`, `MLM…`) and it returns clean, structured JSON.

Running on the Apify platform gives you API access, scheduling, integrations (Google Sheets, webhooks, Zapier, Make), residential proxy rotation, and run monitoring out of the box.

### Why use MercadoLivre Product Detail + Reviews?

- **Price monitoring & repricing** — track precio/preço, discounts, and installment plans for any set of products, on a schedule.
- **Competitor & seller intelligence** — seller name, reputation level (e.g. `5_green`), MercadoLíder/power-seller status, official-store flag, FULL fulfillment flag.
- **Catalog enrichment** — brand, technical specification attributes (ficha técnica), high-resolution images, category breadcrumbs, and every variant (color, memory, size…) with its own product ID.
- **Review mining** — pull customer reviews with rating, text, helpful-vote count and purchased variant, ready for sentiment analysis.
- **Competitor performance monitoring** — point it at a rival's listings and track how their review volume, rating, and sentiment move over time. A sudden drop in rating or a spike in negative reviews after a price change or stock issue is an early signal worth watching.
- **Dropshipping & marketplace research** — validate products at scale before listing them.

### Looking for something else on MercadoLivre?

- **Search by keyword** — use our **[MercadoLivre Search Scraper](https://apify.com/riseandcode/apify-mercadolivre-search)** to find listings for any product, brand, or search term, then feed the resulting URLs or IDs into this Actor for full details and reviews.
- **Daily deals** — use our **[MercadoLivre Deals Scraper](https://apify.com/riseandcode/apify-mercadolivre-deals)** to catch whatever is on promotion on the "Ofertas do Dia" page, with deal type and discount percentage — its results also chain into this Actor.

### How to use MercadoLivre Product Detail + Reviews

1. Visit the Actor page and click **Try for free** (an Apify account takes a minute to create).
2. Paste one or more **product URLs** — or just the **product IDs** — into the input form.
3. Optionally set **Max Reviews per Product** if you also want customer reviews.
4. Click **Start** and watch the dataset fill up.
5. Download your data as **JSON, CSV, Excel, or HTML**, or read it via the API.

Or call it straight from the API — this request scrapes one product with 10 reviews and returns the items synchronously:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/riseandcode~apify-mercadolivre-product-detail/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "productUrls": [{ "url": "https://www.mercadolivre.com.br/apple-iphone-15-256-gb-rosa-excelente-recondicionado/p/MLB2000024221" }],
    "maxReviewsPerProduct": 10
  }'
````

### Input

Configure the Actor in the **Input** tab or via JSON.

| Field                  | Type      | Default | Description                                                                                                                                                                                                       |
| ---------------------- | --------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `productUrls`          | `array`   | —       | Product page URLs — item URLs (`/MLB-1234…`) and catalog URLs (`/p/MLB1234…`) both work, from any supported country.                                                                                              |
| `productIds`           | `array`   | —       | Product/item IDs, with or without prefix: `MLB4233789327`, `MLB-4233789327`, or `4233789327` (resolved with `country`). The Actor detects whether each ID is an item or a catalog product automatically.          |
| `country`              | `string`  | `"BR"`  | Marketplace used to resolve bare IDs. One of `BR`, `AR`, `MX`, `CL`, `CO`, `PE`, `UY`, `EC`, `DO`.                                                                                                                |
| `maxReviewsPerProduct` | `integer` | `0`     | Reviews to fetch per product, up to 300. `0` means no reviews and no extra cost. See [pricing](#how-much-does-it-cost-to-scrape-mercadolivre-products) below — you're only charged for reviews actually returned. |

You can mix `productUrls` and `productIds` in the same run.

Example input:

```json
{
  "productIds": ["MLB4233789327"],
  "country": "BR",
  "maxReviewsPerProduct": 10
}
```

### Output

One dataset record is pushed per product. Download the dataset as **JSON, CSV, Excel, or HTML** from the **Output** tab or via the Apify API.

#### Output example (trimmed)

```json
{
  "productId": "MLB56625214",
  "itemId": "MLB4233789327",
  "title": "Carregador Turbo 40w Compativel Com iPhone 8 X Xr 11 12 13 14 Pro Max Usb Tipo C Duplo",
  "url": "https://www.mercadolivre.com.br/carregador-turbo-40w-.../p/MLB56625214",
  "siteId": "MLB",
  "countryCode": "BR",
  "brand": "Boyu Cell",
  "condition": "new",
  "price": 35.99,
  "originalPrice": 79.11,
  "currency": "BRL",
  "discountPercentage": 54,
  "installments": { "amount": 12, "each": 3.54, "total": 42.48, "isFree": false },
  "seller": "Boyu Cell",
  "sellerId": 334627891,
  "sellerReputation": "5_green",
  "powerSellerStatus": "platinum",
  "isOfficialStore": true,
  "isFull": true,
  "freeShipping": false,
  "shippingSummary": "Chegará grátis amanhã por ser sua primeira compra",
  "rating": 4.8,
  "ratingCount": 9793,
  "availability": "InStock",
  "categoryPath": ["Celulares e Telefones", "Acessórios para Celulares", "Carregadores e Acessórios", "Carregadores"],
  "images": ["https://http2.mlstatic.com/D_NQ_NP_2X_….webp"],
  "attributes": [{ "name": "Marca", "value": "Boyu Cell" }],
  "variants": [{ "attribute": "color", "value": "Rosa", "productId": "MLB2000024221", "selected": true }],
  "description": "Características principais…",
  "reviews": [
    {
      "reviewId": 2444821015,
      "rating": 4,
      "text": "Deixei meu celular carregando…",
      "date": "Há 8 meses",
      "country": "Brasil",
      "likes": 242,
      "variant": "Cor: Rosa"
    }
  ],
  "scrapedAt": "2026-07-02T17:40:18.233Z"
}
```

### Output fields

| Field                                                          | Description                                                                                                                                                                                     |
| -------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `productId` / `itemId`                                         | Catalog product ID and marketplace item ID.                                                                                                                                                     |
| `title`, `url`, `brand`, `condition`                           | Core identity. `condition` is `new`, `used`, or `refurbished`.                                                                                                                                  |
| `price`, `originalPrice`, `currency`, `discountPercentage`     | Current offer pricing.                                                                                                                                                                          |
| `installments`                                                 | Installment plan: number of parcelas, value of each, total, interest-free flag.                                                                                                                 |
| `seller`, `sellerId`, `sellerReputation`, `powerSellerStatus`  | Seller with reputation level (`5_green` is best) and MercadoLíder tier.                                                                                                                         |
| `isOfficialStore`, `isFull`, `freeShipping`, `shippingSummary` | Trust and logistics flags (FULL = fulfillment by MercadoLivre).                                                                                                                                 |
| `rating`, `ratingCount`, `availability`, `stockLabel`          | Aggregate rating and stock status.                                                                                                                                                              |
| `categoryPath`, `images`, `attributes`, `description`          | Category breadcrumb, gallery, ficha técnica specs, plain-text description.                                                                                                                      |
| `variants`                                                     | Every SKU option (color, memory, grading…) with its own catalog product ID — chain them back into this Actor to scrape all variants.                                                            |
| `subtitle`                                                     | Condition/sales subtitle as displayed (e.g. "Novo | +100 vendidos").                                                                                                                           |
| `reviews`                                                      | Customer reviews (when `maxReviewsPerProduct` > 0): rating, text, `originalText` (set when auto-translated from another marketplace), relative date, country, helpful votes, purchased variant. |
| `scrapedAt`                                                    | ISO timestamp of extraction.                                                                                                                                                                    |

### How much does it cost to scrape MercadoLivre products?

This Actor uses Apify's **pay-per-event** pricing: you pay fixed prices for what the Actor does, and **you are not charged separately for Apify platform usage** (compute, bandwidth, or other infrastructure). There are just two charges:

| Event          | Price                      | When it applies                                             |
| -------------- | -------------------------- | ----------------------------------------------------------- |
| **Per lookup** | **$0.05**                  | Once for each URL/ID you submit, when the lookup starts     |
| **Per review** | **$0.0015** ($1.5 / 1,000) | For each review fetched, only if `maxReviewsPerProduct` > 0 |

The **per-lookup** fee covers the fixed proxy + compute cost of resolving each input and applies as soon as the lookup starts, one per URL/ID submitted. Reviews are billed separately, per product: 3 products with 100 reviews each is 300 charged reviews, not 100, and if a product has fewer reviews available than you asked for, you only pay for what was actually returned.

**Examples:**

- 100 product URLs, no reviews → `100 × $0.05 = $5.00`
- 100 product URLs, `maxReviewsPerProduct` set to 20 → `100 × $0.05 + 100 × 20 × $0.0015 = $8.00`, **if** every product actually has 20+ reviews available. If a product has fewer, you're only charged for the reviews it actually returned.

Apify's [free plan](https://apify.com/pricing) includes $5 of monthly usage — enough for roughly 100 lookups. You can cap any run's spend with the **Max total charge** run option.

### Tips and advanced options

- **Scrape all variants of a product**: take the `variants[].productId` values from a first run and feed them back as `productIds`.
- **Bulk runs**: pass hundreds of IDs at once — the Actor fetches products over plain HTTP first and only escalates to a real browser for pages protected by anti-bot challenges, keeping runs fast and cheap.
- **Budget control**: set `ACTOR_MAX_TOTAL_CHARGE_USD` (Max total charge) on the run; the Actor stops cleanly when the cap is reached instead of failing.
- **Scheduling**: use Apify [Schedules](https://docs.apify.com/platform/schedules) to re-scrape your product list daily and build a price history.

### Data & compliance

This Actor is built to collect **publicly available data only**, with a few deliberate choices to keep its footprint minimal:

- **No login, no accounts.** The Actor only fetches public product pages and the public reviews endpoint. It never authenticates, so it accesses nothing beyond what any anonymous visitor sees.
- **Reviews are anonymized by design.** Reviewer names, avatars, and profile links are never extracted — only the rating, text, relative date, country, helpful-vote count, and purchased variant.
- **Images are returned as URLs.** The Actor never downloads or re-hosts image files; it only points to MercadoLivre's own CDN.
- **Seller fields may constitute personal data.** `seller`, `sellerId`, and reputation fields identify the merchant. When the seller is an individual (not a company or official store), this can qualify as personal data under laws such as Brazil's LGPD — even though it is public. These fields are provided for legitimate business-intelligence purposes (price monitoring, competitor analysis, catalog research). **You are the controller of the data you collect**: it is your responsibility to have a lawful basis for processing it and to honor data-subject rights in your jurisdiction.
- **Descriptions and images are third-party content.** Product descriptions, photos, and review texts are authored by sellers, MercadoLivre, or buyers and may be protected by copyright. Use them for analysis; do not republish them as-is (e.g. to clone listings).

Scraping publicly accessible data is generally lawful, but you remain responsible for how you use the output and for complying with MercadoLivre's Terms of Service and the data-protection laws that apply to you (LGPD in Brazil, and their equivalents in the other supported countries). Nothing in this README is legal advice.

### FAQ

#### Is it legal to scrape MercadoLivre?

The Actor extracts publicly available data only, without logging in, and strips reviewer identities. That said, legality depends on how *you* use the data — see [Data & compliance](#data--compliance) above.

#### A product failed to scrape — what now?

The run summary lists inputs that could not be resolved. Typical causes: the listing was removed (`notfound`), or the URL points to a non-product page. If a valid product keeps failing, please open an issue in the **Issues** tab.

#### Do reviews include absolute dates?

MercadoLivre only exposes relative dates ("Há 8 meses"); the Actor returns them as-is.

### Changelog

#### 2026-07-09

- **Changed** the per-lookup charge to fire as soon as each URL/ID starts processing, instead of only after a product is successfully parsed — so blocked or failed lookups are billed consistently rather than silently free.
- **Validated** end-to-end against all 9 supported marketplaces (Brazil, Argentina, Mexico, Chile, Colombia, Peru, Uruguay, Ecuador, Dominican Republic) to confirm country, currency, and site-ID resolution work correctly everywhere.

#### 2026-07-04

- **Fixed** a review-pagination bug where products with hundreds of reviews sometimes returned just one: MercadoLivre's reviews API returns a single "featured" review on the very first page instead of a full page, and the Actor mistakenly read that as "no more reviews" and stopped.
- **Added** pay-per-event pricing with reviews billed as their own event, separate from the product price, so you pay for exactly the reviews delivered — nothing extra when a product has fewer reviews than requested.

### Support

If you encounter a bug or have a suggestion for this Actor or for a new one, please reach out via the **Issues** tab or at <contact.riseandcode@gmail.com> and we'll look into it ASAP.
We respond in English 🇺🇸 and Portuguese 🇧🇷. Custom solutions are available on request.

# Actor input Schema

## `productUrls` (type: `array`):

MercadoLivre / MercadoLibre product page URLs. Both item URLs (<code>/MLB-1234…</code>) and catalog URLs (<code>/p/MLB1234…</code>) work, from any of the 9 supported countries.

## `productIds` (type: `array`):

Product or item IDs, with or without the site prefix — e.g. <code>MLB4233789327</code>, <code>MLB-4233789327</code> or just <code>4233789327</code> (resolved using the Country below). The Actor figures out whether each ID is an item or a catalog product.

## `country` (type: `string`):

Marketplace used to resolve bare product IDs (IDs without an MLB/MLA/… prefix) and relative URLs.

## `maxReviewsPerProduct` (type: `integer`):

How many customer reviews to fetch for each product. <b>Reviews cost $1.5 per 1,000 ($0.0015/review), charged on top of the per-input price</b> — keep it at 0 (default) for no extra cost. This price is <b>per product</b>, not shared across your run: 3 products with 100 reviews each is 300 charged reviews, not 100. If a product has fewer reviews available than you asked for, you only pay for the reviews actually returned.

## Actor input object example

```json
{
  "productUrls": [
    {
      "url": "https://www.mercadolivre.com.br/apple-iphone-15-256-gb-rosa-excelente-recondicionado/p/MLB2000024221"
    }
  ],
  "productIds": [],
  "country": "BR",
  "maxReviewsPerProduct": 0
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {
    "productUrls": [
        {
            "url": "https://www.mercadolivre.com.br/apple-iphone-15-256-gb-rosa-excelente-recondicionado/p/MLB2000024221"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("riseandcode/apify-mercadolivre-product-detail").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 = { "productUrls": [{ "url": "https://www.mercadolivre.com.br/apple-iphone-15-256-gb-rosa-excelente-recondicionado/p/MLB2000024221" }] }

# Run the Actor and wait for it to finish
run = client.actor("riseandcode/apify-mercadolivre-product-detail").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 '{
  "productUrls": [
    {
      "url": "https://www.mercadolivre.com.br/apple-iphone-15-256-gb-rosa-excelente-recondicionado/p/MLB2000024221"
    }
  ]
}' |
apify call riseandcode/apify-mercadolivre-product-detail --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=riseandcode/apify-mercadolivre-product-detail",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "MercadoLivre Product Detail & Reviews",
        "description": "Extract full product details from any MercadoLivre / MercadoLibre product page — price, discounts, installments, seller reputation, variants, specs, images, stock — plus optional customer reviews. Works in all 9 countries. Feed it URLs or product IDs.",
        "version": "0.1",
        "x-build-id": "mtKt7Qck7eTrmgIMJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/riseandcode~apify-mercadolivre-product-detail/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-riseandcode-apify-mercadolivre-product-detail",
                "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/riseandcode~apify-mercadolivre-product-detail/runs": {
            "post": {
                "operationId": "runs-sync-riseandcode-apify-mercadolivre-product-detail",
                "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/riseandcode~apify-mercadolivre-product-detail/run-sync": {
            "post": {
                "operationId": "run-sync-riseandcode-apify-mercadolivre-product-detail",
                "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",
                "properties": {
                    "productUrls": {
                        "title": "Product URLs",
                        "type": "array",
                        "description": "MercadoLivre / MercadoLibre product page URLs. Both item URLs (<code>/MLB-1234…</code>) and catalog URLs (<code>/p/MLB1234…</code>) work, from any of the 9 supported countries.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "productIds": {
                        "title": "Product IDs",
                        "type": "array",
                        "description": "Product or item IDs, with or without the site prefix — e.g. <code>MLB4233789327</code>, <code>MLB-4233789327</code> or just <code>4233789327</code> (resolved using the Country below). The Actor figures out whether each ID is an item or a catalog product.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "BR",
                            "AR",
                            "MX",
                            "CL",
                            "CO",
                            "PE",
                            "UY",
                            "EC",
                            "DO"
                        ],
                        "type": "string",
                        "description": "Marketplace used to resolve bare product IDs (IDs without an MLB/MLA/… prefix) and relative URLs.",
                        "default": "BR"
                    },
                    "maxReviewsPerProduct": {
                        "title": "Max Reviews per Product",
                        "minimum": 0,
                        "maximum": 300,
                        "type": "integer",
                        "description": "How many customer reviews to fetch for each product. <b>Reviews cost $1.5 per 1,000 ($0.0015/review), charged on top of the per-input price</b> — keep it at 0 (default) for no extra cost. This price is <b>per product</b>, not shared across your run: 3 products with 100 reviews each is 300 charged reviews, not 100. If a product has fewer reviews available than you asked for, you only pay for the reviews actually returned.",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
