# Mercado Libre Product Rank Checker (`maximedupre/mercado-libre-product-rank-checker`) Actor

Check where your Mercado Libre or Mercado Livre product appears for each keyword. Export organic position, page, matched product details, ZIP/postal-code context, and timestamps.

- **URL**: https://apify.com/maximedupre/mercado-libre-product-rank-checker.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** E-commerce, Marketing
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.50 / 1,000 checked search pages

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

### 🎯 Mercado Libre Product Rank Checker

Mercado Libre Product Rank Checker checks where a specific product ranks in [Mercado Libre](https://www.mercadolibre.com/) or Mercado Livre search results for the keywords you care about. Add a keyword, product ID, market, and optional delivery ZIP/postal code, then export one clean rank check row with the organic rank, checked page depth, and location context.

Use it when you already know the product you want to track and need a quick answer to a practical question: "Does this product rank organically for this search, and if yes, where?"

The Actor is built for sellers, agencies, ecommerce teams, and marketplace analysts who need repeatable rank checks without opening search pages by hand. You can run one product-keyword pair for a spot check, or add many rows for a recurring tracking workflow.

### ✅ What This Actor Does

The Actor checks Mercado Libre search result pages for your target product ID. It supports Mexico and Brazil, including Mercado Livre naming for the Brazilian marketplace.

For each rank check, it can:

- Search one keyword, such as `iphone`, `notebook`, or `cafetera`.
- Look for one target Mercado Libre item ID, such as `MLM123456789` or `MLB123456789`.
- Apply a market: Mexico or Brazil.
- Apply a delivery ZIP/postal code when you want the check to match a shopper location.
- Check up to 10 result pages per product-keyword pair.
- Stop as soon as the product is found organically, or return null rank fields after the requested pages are checked.

This Actor focuses on product rank checks. It does not scrape full product search exports, product detail pages, reviews, questions, seller catalogs, checkout data, private account data, or paid ad metrics.

### 📦 Data You Get

Each output row is one product-keyword rank check. Rows are flat and ready for Apify dataset exports, API calls, schedules, webhooks, dashboards, or spreadsheets.

The dataset can include:

- `keyword`, `productId`, and `country` - the minimum input identity needed to match each batch row.
- `appliedPostalCode` - the delivery location verified by the source session, when available.
- `pagesChecked` - the pages actually checked before the answer was known.
- `organicPosition` - the rank answer, or `null` when the product was not found organically.

### 🚀 How To Run

1. Add one or more rows in **Rank checks**.
2. Enter a **Keyword** for each row.
3. Enter the target **Product ID** from Mercado Libre or Mercado Livre.
4. Choose the **Market**: Mexico or Brazil.
5. Add a **Delivery ZIP/postal code** when rankings should match a specific delivery location.
6. Set **Pages to check** for the whole run.
7. Start the Actor and open the dataset.

Two pages is a good daily tracking default. Raise the page count when you need deeper rank checks, and lower it when you only care about top-page visibility.

### 🧾 Input Example

```json
{
  "rankChecks": [
    {
      "keyword": "iphone",
      "productId": "MLM123456789",
      "country": "mx",
      "postalCode": "64000"
    },
    {
      "keyword": "notebook",
      "productId": "MLB123456789",
      "country": "br",
      "postalCode": "01001-000"
    }
  ],
  "pagesToCheck": 2
}
````

### 📊 Output Example

```json
{
  "keyword": "iphone",
  "productId": "MLM123456789",
  "country": "mx",
  "appliedPostalCode": "64000",
  "pagesChecked": 1,
  "organicPosition": 3
}
```

### 💳 Pricing

This Actor charges **$2.50 per 1,000 checked search pages**. The charge event is **Checked search page**.

Cost depends on how many product-keyword pairs you add and how many pages are actually checked. If the target product is found on page 1, the Actor does not need to check later pages for that row.

### ⚠️ Limits And Notes

- Supported markets are Mexico and Brazil.
- **Pages to check** can be from 1 to 10.
- **Rank checks** can include up to 500 product-keyword rows per run.
- Organic rank excludes sponsored ads.
- ZIP/postal-code checks depend on the source site accepting and applying the requested delivery location.
- Search results can change by time, market, delivery location, Mercado Libre ranking behavior, and logged-in personalization.

### ❓ FAQ

#### Can I check many products in one run?

Yes. Add one row per product-keyword pair in **Rank checks**. Use the same keyword with multiple product IDs, or use different keywords for the same product.

#### Does this scrape every result from a search page?

No. This Actor is a rank checker. It returns one row per product-keyword pair. If you need every product card from Mercado Libre search results, use the Mercado Libre Search Scraper linked below.

#### Does the rank include sponsored products?

No. `organicPosition` is an organic rank field, so sponsored products are excluded by default. There is no separate sponsored-rank option.

#### Can I schedule daily rank tracking?

Yes. You can schedule the Actor on Apify and export the dataset through Apify exports, webhooks, integrations, or API workflows.

### 📝 Changelog

- 1.0: Simplified rank-check output to the six fields needed for batch tracking, with validated Mexico and Brazil default examples.
- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~mercado-libre-product-rank-checker/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Mercado Libre Search Scraper ↗](https://apify.com/maximedupre/mercado-libre-search-scraper) - Export product cards from Mercado Libre and Mercado Livre search results.
- [Allegro Scraper ↗](https://apify.com/maximedupre/allegro-scraper) - Collect product listing data from Allegro search, category, and listing URLs.
- [Google Shopping Ads Scraper ↗](https://apify.com/maximedupre/google-shopping-ads-scraper) - Track live Google Shopping ad products by buyer keyword.
- [Amazon Keywords Discovery Tool ↗](https://apify.com/maximedupre/amazon-keywords-discovery-tool) - Collect Amazon autocomplete keyword suggestions for marketplace SEO research.
- [Etsy Keywords Research Tool ↗](https://apify.com/maximedupre/etsy-keywords-research-tool) - Export Etsy autocomplete suggestions for listing and keyword research.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `rankChecks` (type: `array`):

Add each keyword and product ID you want to track. Use a ZIP/postal code when the ranking should match a delivery location.

## `pagesToCheck` (type: `integer`):

Search result pages checked for each rank check. Two pages is a good daily tracking default.

## Actor input object example

```json
{
  "rankChecks": [
    {
      "keyword": "iphone",
      "productId": "MLM4737756648",
      "country": "mx",
      "postalCode": "64000"
    },
    {
      "keyword": "notebook",
      "productId": "MLB6682720920",
      "country": "br",
      "postalCode": "01001-000"
    }
  ],
  "pagesToCheck": 2
}
```

# Actor output Schema

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

Open the dataset with Mercado Libre and Mercado Livre product rank check rows.

# 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 = {
    "rankChecks": [
        {
            "keyword": "iphone",
            "productId": "MLM4737756648",
            "country": "mx",
            "postalCode": "64000"
        },
        {
            "keyword": "notebook",
            "productId": "MLB6682720920",
            "country": "br",
            "postalCode": "01001-000"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/mercado-libre-product-rank-checker").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 = { "rankChecks": [
        {
            "keyword": "iphone",
            "productId": "MLM4737756648",
            "country": "mx",
            "postalCode": "64000",
        },
        {
            "keyword": "notebook",
            "productId": "MLB6682720920",
            "country": "br",
            "postalCode": "01001-000",
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/mercado-libre-product-rank-checker").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 '{
  "rankChecks": [
    {
      "keyword": "iphone",
      "productId": "MLM4737756648",
      "country": "mx",
      "postalCode": "64000"
    },
    {
      "keyword": "notebook",
      "productId": "MLB6682720920",
      "country": "br",
      "postalCode": "01001-000"
    }
  ]
}' |
apify call maximedupre/mercado-libre-product-rank-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=maximedupre/mercado-libre-product-rank-checker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mercado Libre Product Rank Checker",
        "description": "Check where your Mercado Libre or Mercado Livre product appears for each keyword. Export organic position, page, matched product details, ZIP/postal-code context, and timestamps.",
        "version": "1.0",
        "x-build-id": "HSSgBPVymjnn9WNyx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~mercado-libre-product-rank-checker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-mercado-libre-product-rank-checker",
                "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/maximedupre~mercado-libre-product-rank-checker/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-mercado-libre-product-rank-checker",
                "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/maximedupre~mercado-libre-product-rank-checker/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-mercado-libre-product-rank-checker",
                "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": [
                    "rankChecks"
                ],
                "properties": {
                    "rankChecks": {
                        "title": "Rank checks",
                        "minItems": 1,
                        "maxItems": 500,
                        "type": "array",
                        "description": "Add each keyword and product ID you want to track. Use a ZIP/postal code when the ranking should match a delivery location.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "keyword": {
                                    "title": "Keyword",
                                    "type": "string",
                                    "description": "Search keyword to check.",
                                    "editor": "textfield",
                                    "minLength": 1,
                                    "maxLength": 120
                                },
                                "productId": {
                                    "title": "Product ID",
                                    "type": "string",
                                    "description": "Mercado Libre item ID, such as MLM123456789 or MLB123456789.",
                                    "editor": "textfield",
                                    "pattern": "^[A-Za-z]{3}-?[0-9]{6,}$"
                                },
                                "country": {
                                    "title": "Market",
                                    "type": "string",
                                    "description": "Marketplace where this product rank is checked.",
                                    "editor": "select",
                                    "default": "mx",
                                    "enum": [
                                        "mx",
                                        "br"
                                    ],
                                    "enumTitles": [
                                        "Mexico",
                                        "Brazil"
                                    ]
                                },
                                "postalCode": {
                                    "title": "Delivery ZIP/postal code",
                                    "type": "string",
                                    "description": "Delivery location for this check.",
                                    "editor": "textfield",
                                    "minLength": 3,
                                    "maxLength": 12,
                                    "pattern": "^[0-9A-Za-z -]+$"
                                }
                            },
                            "required": [
                                "keyword",
                                "productId",
                                "country"
                            ],
                            "additionalProperties": false
                        }
                    },
                    "pagesToCheck": {
                        "title": "Pages to check",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Search result pages checked for each rank check. Two pages is a good daily tracking default.",
                        "default": 2
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
