# Mercado Livre Brazil - Products, Prices, Sellers & Reviews (`abotapi/mercadolivre-com-br-scraper`) Actor

Scrape Mercado Livre Brazil by keyword or URL. Filter by category, brand, price, condition, shipping, official store, and seller rating. Extract prices, discounts, instalments, stock, delivery, seller details, variants, specifications, and buyer reviews.

- **URL**: https://apify.com/abotapi/mercadolivre-com-br-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Categories:**
- **Stats:** 1 total users, 1 monthly users, 80.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 product results

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Mercado Livre Brazil Marketplace Scraper

Scrape product data from **Mercado Livre Brazil** (`mercadolivre.com.br`), Latin America's
largest online marketplace. Search by keyword with the marketplace's own filters, or paste
product, search, category and deals links.

Every product comes back with its price in reais, the price before discount, the discount
percentage, instalment terms, shipping and free-shipping signals, the seller, stock, and the
buyer rating. Turn on full details to also get the description, the complete specification
table, colour and model variants with their own prices, available stock and seller reputation.
Turn on opinions to get the star breakdown and the buyer opinions the marketplace publishes
on the product page.

### What you get

| Field | Notes |
|---|---|
| `itemId` | The listing's own MLB code |
| `catalogProductId` | The catalogue product code, shared by every seller of the same product |
| `title`, `url` | Title and canonical address |
| `brand`, `model` | From the specification table (full details only) |
| `categoryId`, `categoryPath`, `breadcrumb` | Marketplace category and its full path |
| `price`, `originalPrice`, `discountPercent`, `currency` | Current price, price before discount, and the discount. Always `BRL` |
| `installments`, `installmentsText` | Number of instalments, amount each, total, and whether they are interest free |
| `condition` | `new`, `used`, `refurbished` or `open_box` (full details only) |
| `freeShipping`, `fulfillment`, `shippingText` | Free shipping, marketplace-fulfilled delivery, and the shipping promise as shown |
| `sellerName`, `officialStore`, `seller` | Seller name, official-brand-store flag, and the seller object with its id, type and reputation grade |
| `availableQuantity`, `stockStatus` | Units available and the stock message (full details only) |
| `soldQuantity` | Units sold, as the marketplace reports it |
| `images`, `videos` | Full media gallery |
| `variants` | Colour and model variants, each with its own code, address, price and availability |
| `attributes` | The full specification table, as name / value / group triples (full details only) |
| `description` | Product description (full details only) |
| `rating`, `reviewCount`, `ratingBreakdown` | Overall rating, opinion count, and the count per star level |
| `reviews` | Each opinion the marketplace publishes on the product page: rating, text, date, country, helpful votes, photos and video count |
| `exactMatch`, `searchFallback` | Present on a search row only when that row is a loose match: it shares none of the keyword's words with its title (see "Search fallback" below) |
| `changeType`, `changedFields`, `firstSeenAt`, `lastSeenAt` | Incremental mode only |

### Two modes

**Search.** Give one or more keywords. Each is searched separately and the results are merged
and de-duplicated by listing id, so the same product is never returned or billed twice.

**URL.** Paste any mix of:

- product pages, `https://www.mercadolivre.com.br/<slug>/p/MLB70040749`
- bare product codes, `MLB70040749`
- search result pages, `https://lista.mercadolivre.com.br/notebook`
- deals pages, `https://www.mercadolivre.com.br/ofertas`
- category pages, `https://www.mercadolivre.com.br/c/eletrodomesticos`

Search links are walked forward page by page. Product links return one full record each.

**About category and deals links.** The `/ofertas` deals feed is where the
marketplace publishes browsable product lists, 48 per page, and it is read
directly. A `/c/<slug>` page is a marketing landing that carries **no product
listings at all** (verified against the live page: its embedded data holds only
banners and links), so a pasted category link is resolved to that category's
deals feed - the landing names its category, the feed returns its products -
and the run logs that this is what happened. A keyword search or a pasted
`lista.mercadolivre.com.br` search link remains the way to walk a category's
full listing set.

### Search fallback: when a keyword matches loosely

The marketplace full-text matches almost any keyword, so even a nonsense query
returns products - loosely related ones. Those rows are real products that the
site served, and they are returned, but each row whose title shares none of the
keyword's own words is marked `exactMatch: false` and `searchFallback: true`, so
you can always tell a genuine match from a loose one (and a genuine search from
a nonsense one) before you act on - or pay for - the row. Rows that do carry the
keyword in their title are never marked.

### Filters

These are the marketplace's own filters, applied at the source rather than by discarding rows
afterwards, so a filtered run is genuinely cheaper and not just shorter.

- **Category** and **brand**, by the name the site shows in its own filter list. If the site
  does not offer that value for your keyword, the run warns and lists what it does offer,
  rather than silently returning an unfiltered result.
- **Price range** in reais, **condition** (new, used, refurbished, open box)
- **Free shipping only**, **marketplace-fulfilled only**
- **Official brand stores only**, **top-rated sellers only**
- **Minimum discount**, **interest-free instalments only**
- **Sort** by relevance, lowest price or highest price

Filters apply to keyword searches. In URL mode the link you paste already carries whatever
filters you selected on the site, so these are not applied on top of it.

One honest caveat, verified live: the marketplace's own filtered pages occasionally include a
couple of loose-match rows (an accessory alongside notebooks, for example) whose card carries
no seller block or no instalment block. Those rows are returned with the corresponding field
left unset rather than guessed, and - on keyword searches - they carry the `searchFallback`
mark when they share none of the keyword's words with their title.

### Connection: this one matters

Mercado Livre serves its **search result pages and product pages only to a Brazilian
consumer-grade connection**. From anywhere else those two page types answer with a sign-in
interstitial before any data is rendered, whatever headers or timing you use.

So the default connection for this actor is **Apify Proxy, Residential tier, country Brazil**,
and that is what you want for the search and product data.

Everything else is cheap and needs no such connection:

- category and deals pages (`/c/...`, `/ofertas`)

If you run without a Brazilian residential connection, the actor collects those open pages and
tells you plainly that the search and product pages could not be reached. It **never** reports
a blocked run as an empty search: a run that emitted nothing because its pages were refused
fails with a message naming the connection, and that holds for **both** kinds of page, the
search and product pages that need the Brazilian connection and the category and deals pages
that do not. A keyword that genuinely has no matches still succeeds with zero rows: "returned
nothing" and "was refused" are two separate counters and only their conjunction is a success.

Two consequences worth knowing before you size a run:

1. A search page costs more than you would expect, because the marketplace retires a
   connection after it has served one such page. Measured while this actor was built: 4 of 4
   result pages taken on a fresh connection came back in full (about 3 MB, 48 products each),
   and 12 of 12 taken on a connection that had already served one came back as a 70 KB
   verification page with no products, whether they were asked for by navigating, by opening a
   new tab, by requesting from inside the page, after clearing cookies, after a human-paced
   pause, scroll and click, or by replaying the session over a plain HTTP client. So the actor
   gives every search page and every product page its own fresh connection.
2. A page holds up to 48 products, so **Max products** is the main lever on cost, and **Max
   result pages per search** is there when you want to bound the walk's depth as well. Full
   details add one more page per product, which is why they are opt in and carry their own
   charge.

### Buyer opinions

Opinions are a real, fully published feature on this marketplace, and this actor collects them.
Per product you get the overall rating, the opinion count and the count at each star level;
per opinion you get the rating, the text, the date, the reviewer's country, the helpful-vote
count, the photo addresses and the number of attached videos. Opinion **authors are not
returned**: the marketplace does not publish a name or profile with a product opinion, so
there is no author field to return and none is invented.

Opinions are published **on the product page itself** (the first page of them, alongside the
rating summary). That has two consequences, both disclosed up front:

- turning on **Fetch buyer opinions** opens each product's page, exactly as full details does,
  so it is charged the same **Detail enrichment** event per product whose page was read - the
  two toggles are one page read, and either one alone is enough to open it;
- what is available is the page's own first page of opinions, so `maxReviewsPerProduct` caps
  rows that are already on the page rather than paging a deeper feed.

The marketplace's standalone opinion-feed URL was probed while building this and it no longer
serves opinions (it returns an empty shell for every product, including ones with tens of
thousands of published opinions), so the actor reads opinions where the marketplace actually
publishes them: the product page.

### Incremental mode and resume

Two different things, both in the **Resume & recurring updates** section.

**Resume from a previous run** continues one specific interrupted run. Paste the run or dataset
id and the products already collected there are skipped, so they are neither returned nor
billed again. The walk still starts at the first result page and steps over the products that
run already collected, so if you set **Max result pages per search** to a number, raise it
when you resume a deep pull: the pages the previous run covered still count against it. Left
at its default of 0 it does not bound the resumed walk at all.

**Incremental mode** is for recurring monitoring. Turn it on and schedule the actor: the first
run returns everything as `NEW`, and later runs return only what changed, marked `NEW`,
`UPDATED` or `REAPPEARED`, with `changedFields` naming exactly which fields moved. State is
kept per keyword-and-filter setup, so two different searches never mix baselines; use
**State key** to name a campaign or to deliberately share one.

- **Emit unchanged** also returns products that did not change, marked `UNCHANGED`. This
  returns, and bills, extra rows you already have.
- **Emit expired** also returns products that have disappeared, marked `EXPIRED`. These are
  only produced after a run has fully scanned the tracked search, so never when Max products
  capped the run, never after a resume, and never when a run collected nothing.

`reviews` is excluded from change detection on purpose: a popular product carries hundreds of
opinion rows, and tracking every one of them would rewrite the record on every new opinion and
would put the whole opinion corpus into the saved state. Nothing is lost: `rating`, `reviewCount` and
`ratingBreakdown` are all tracked, so a new or deleted opinion still marks the product
`UPDATED` and still names those fields in `changedFields`.

### Scope: Brazil only

This actor covers the Brazilian storefront only, and that is deliberate rather than an
oversight.

Mercado Libre runs one platform behind per-country storefronts. Verified live while building
this actor: the same catalogue backend serves every country, with the site prefix carrying the
country (`MLB` Brazil, `MLA` Argentina, `MLM` Mexico, `MLC` Chile, `MCO` Colombia, `MLU`
Uruguay), and the same category numbering resolves on all of them. The other storefronts are
also behind the same connection gate, pinned to *their* country.

So a multi-country build is feasible but is a different actor: it needs a residential
connection per country, its own per-country catalogue and price validation, and its own
currency handling. Nothing here is speculative about markets that were not tested. If you want
another Mercado Libre country covered, ask and it can be built and verified properly.

### Send results into your apps (MCP connectors)

Optionally pipe results into the apps you already use, through Model Context Protocol (MCP)
connectors. Authorize a connector under Apify, Settings, API & Integrations, then select it in
`mcpConnectors`. Notion, Linear, Airtable and Apify are supported. For Notion, also set
`notionParentPageUrl` and each product becomes a page under it; the other connectors get a
best-effort write or a digest.

Each connector receives a condensed, human-readable summary per product. The complete record
always stays in the Apify dataset. `maxNotifyListings` caps how many products are written per
connector and never affects the dataset output.

| Input | What it does |
|---|---|
| `mcpConnectors` | The connectors to send results to. Leave empty to skip the export entirely |
| `notionParentPageUrl` | URL or id of the Notion page the item pages are created under. Required for the Notion connector, ignored by the others |
| `maxNotifyListings` | Cap on products written to each connector per run. Does not affect the dataset |

### Pricing

You are charged for:

- **Product result** for each product returned.
- **Detail enrichment**, once per product whose page is opened. That happens when **Fetch full
  details** is on, and also when **Fetch buyer opinions** is on, because opinions are published
  on the product page. It buys the description, the full specification table, variants with
  their own prices, available stock, seller reputation, the complete image gallery and the
  published opinions. With both toggles off nothing is charged for it, including a pasted
  product link, which returns its full record for the product-result price alone.
- **Actor start**, once per run.

Suppressed rows are never charged. In incremental mode, a product whose detail page was read
but whose record turned out unchanged is not billed for either the row or the enrichment.

### Limits and behaviour

- **Max products** is the run's one hard cap and is always applied. **Max result pages per
  search** is optional and unlimited by default (0), so the walk goes as deep as the
  marketplace serves and stops on Max products, on a page that returns nothing new, or on an
  internal 400-page safety stop. Set it to a number when you want a shallower, cheaper pull.
- Sponsored placements are dropped: they are not part of the result set you asked for, they
  repeat across pages, and billing you for advertising would be wrong.
- If product pages start being refused mid-run, full details are switched off for the rest of
  the run and the remaining products come back with their catalogue fields only, uncharged for
  enrichment, rather than grinding through a paid connection.

# Actor input Schema

## `mode` (type: `string`):

Choose 'search' to search the marketplace by keyword and filters, or 'url' to scrape pasted links: product pages, search result pages, deals pages, category pages and bare MLB product codes are all accepted.

## `queries` (type: `array`):

Keywords to search, for example 'notebook' or 'tenis corrida'. Accents are optional.

## `urls` (type: `array`):

Paste mercadolivre.com.br links. Search links are walked forward page by page. Product links return one detailed record each. A bare code such as MLB70040749 is accepted as a product link. A deals link (ofertas) returns the deal feed, 48 per page; a category link (c/...) is resolved to that category's deals feed, because the category page itself carries no product listings.

## `category` (type: `string`):

Narrow the search to one marketplace category, by the name the site shows in its own category filter, for example 'Notebooks'. If the site does not offer that category for your keyword, the run warns and lists what it does offer rather than silently returning an unfiltered result.

## `brand` (type: `string`):

Narrow the search to one brand, by the name the site shows in its own brand filter, for example 'Dell'. If the site does not offer that brand for your keyword, the run warns and lists what it does offer rather than silently returning an unfiltered result.

## `condition` (type: `string`):

Return only products in this condition.

## `minPrice` (type: `integer`):

Lowest price to return, in Brazilian reais.

## `maxPrice` (type: `integer`):

Highest price to return, in Brazilian reais.

## `freeShippingOnly` (type: `boolean`):

Return only products the marketplace ships free.

## `fulfillmentOnly` (type: `boolean`):

Return only products stocked and shipped from the marketplace's own warehouses, which usually means the fastest delivery.

## `officialStoresOnly` (type: `boolean`):

Return only listings sold by an official brand store.

## `bestSellersOnly` (type: `boolean`):

Return only listings from sellers the marketplace flags as its best, which is its own seller reputation filter.

## `minDiscountPercent` (type: `integer`):

Return only products discounted by at least this percentage.

## `interestFreeInstallments` (type: `boolean`):

Return only products that can be paid in interest-free instalments.

## `sortBy` (type: `string`):

Order the marketplace applies to the results before they are read.

## `fetchDetails` (type: `boolean`):

Open each product page for description, full specifications, colour and model variants with their own prices, available stock, seller reputation and the complete image gallery. Charged once per product returned, as a Detail enrichment event.

## `fetchReviews` (type: `boolean`):

Collect the marketplace's buyer opinions for each product: overall rating, opinion count, the star breakdown, and each opinion's rating, text, date, country, helpful votes and photos (the marketplace publishes no reviewer names). Opinions live on the product page itself, so this opens each product's page the way full details does, returns those detail fields too, and is charged as a Detail enrichment event per product whose page was read.

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

Cap on opinions collected for each product. The marketplace publishes the first page of opinions on the product page; only those are available.

## `maxItems` (type: `integer`):

Hard cap on how many products this run returns and bills for, across every keyword or link.

## `maxPages` (type: `integer`):

Optional bound on result pages walked for each keyword or search link. Each page holds up to 48 products. 0 (the default) means unlimited: the walk goes as deep as the marketplace serves and stops on Max products, on a page that returns nothing new, or on the internal 400-page safety stop.

## `resumeFromRunId` (type: `string`):

Paste a previous run ID or dataset ID to continue a large pull without returning or charging for products already collected there. Use this after an interrupted run. The walk restarts from the first result page and steps over the products that run already collected, so raise Max result pages per search when you resume a deep pull. For recurring daily monitoring of the same search, use Incremental mode below instead.

## `incrementalMode` (type: `boolean`):

Turn this on for daily or recurring monitoring. The first run returns every matching product as NEW. Later runs normally return only NEW, UPDATED and REAPPEARED products. Turn on Emit unchanged or Emit expired only when you also want those rows returned (and billed). State is kept separately for each keyword, filter and detail setup; use State key to name or deliberately share a monitoring campaign. To continue one specific interrupted run instead, use Resume from a previous run above.

## `stateKey` (type: `string`):

Optional. Name this monitoring campaign to keep its state stable, or to deliberately share state across differently configured runs. Leave empty to let the actor derive a key automatically from the keywords, filters and detail settings, so different searches never mix state with each other.

## `emitUnchanged` (type: `boolean`):

Off by default. Turn on to also return products that have not changed since the last run, marked UNCHANGED. This returns, and bills, extra rows you already have, so leave it off unless you want the full snapshot every run.

## `emitExpired` (type: `boolean`):

Off by default. Turn on to also return products that were present in a previous run but are no longer found, marked EXPIRED. Only produced once a run has fully scanned the tracked search, so never when Max products capped it or when Resume was used. This returns, and bills, extra synthetic rows, so leave it off unless you need expiry tracking.

## `proxy` (type: `object`):

Apify Proxy with the Residential tier and country Brazil is required for search results and product pages. On any other tier the run still collects category and deals pages, and reports clearly that the search and product pages could not be reached.

## `mcpConnectors` (type: `array`):

Optionally send results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize one under Apify, Settings, API & Integrations, then select it here. Notion gets a rich page-per-item export; other connectors get a best-effort write or digest. Leave empty to skip; never changes the dataset output. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

## `notionParentPageUrl` (type: `string`):

URL or id of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "queries": [
    "notebook"
  ],
  "urls": [
    "https://www.mercadolivre.com.br/notebook-dell-dc15-i51334u-a50-156-fhd-i5-8gb-512gb-win-11/p/MLB70040749"
  ],
  "condition": "any",
  "freeShippingOnly": false,
  "fulfillmentOnly": false,
  "officialStoresOnly": false,
  "bestSellersOnly": false,
  "interestFreeInstallments": false,
  "sortBy": "relevance",
  "fetchDetails": false,
  "fetchReviews": false,
  "maxReviewsPerProduct": 20,
  "maxItems": 20,
  "maxPages": 0,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "BR"
  },
  "maxNotifyListings": 50
}
```

# Actor output Schema

## `overview` (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 = {
    "mode": "search",
    "queries": [
        "notebook"
    ],
    "urls": [
        "https://www.mercadolivre.com.br/notebook-dell-dc15-i51334u-a50-156-fhd-i5-8gb-512gb-win-11/p/MLB70040749"
    ],
    "condition": "any",
    "freeShippingOnly": false,
    "fulfillmentOnly": false,
    "officialStoresOnly": false,
    "bestSellersOnly": false,
    "interestFreeInstallments": false,
    "sortBy": "relevance",
    "fetchDetails": false,
    "fetchReviews": false,
    "maxReviewsPerProduct": 20,
    "maxItems": 20,
    "maxPages": 0,
    "incrementalMode": false,
    "emitUnchanged": false,
    "emitExpired": false,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "BR"
    },
    "maxNotifyListings": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/mercadolivre-com-br-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 = {
    "mode": "search",
    "queries": ["notebook"],
    "urls": ["https://www.mercadolivre.com.br/notebook-dell-dc15-i51334u-a50-156-fhd-i5-8gb-512gb-win-11/p/MLB70040749"],
    "condition": "any",
    "freeShippingOnly": False,
    "fulfillmentOnly": False,
    "officialStoresOnly": False,
    "bestSellersOnly": False,
    "interestFreeInstallments": False,
    "sortBy": "relevance",
    "fetchDetails": False,
    "fetchReviews": False,
    "maxReviewsPerProduct": 20,
    "maxItems": 20,
    "maxPages": 0,
    "incrementalMode": False,
    "emitUnchanged": False,
    "emitExpired": False,
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "BR",
    },
    "maxNotifyListings": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/mercadolivre-com-br-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "search",
  "queries": [
    "notebook"
  ],
  "urls": [
    "https://www.mercadolivre.com.br/notebook-dell-dc15-i51334u-a50-156-fhd-i5-8gb-512gb-win-11/p/MLB70040749"
  ],
  "condition": "any",
  "freeShippingOnly": false,
  "fulfillmentOnly": false,
  "officialStoresOnly": false,
  "bestSellersOnly": false,
  "interestFreeInstallments": false,
  "sortBy": "relevance",
  "fetchDetails": false,
  "fetchReviews": false,
  "maxReviewsPerProduct": 20,
  "maxItems": 20,
  "maxPages": 0,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "BR"
  },
  "maxNotifyListings": 50
}' |
apify call abotapi/mercadolivre-com-br-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/mercadolivre-com-br-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/n95g7MqAgRI3UrYX0/builds/kWpTeysn6HqCMTTpN/openapi.json