Automatiza tu análisis de precios en Mercado Libre con Python: Una guía paso a paso

En el entorno actual de comercio electrónico, tener visibilidad de los precios de tus competidores es clave para tomar decisiones informadas y ajustar tu estrategia de ventas ¿Sabias que es muy fácil hacerlo con simples herramientas gratuitas y un poco de código?

¿Por qué deberías hacerlo?

Como emprendedores y comerciantes, es fundamental contar con información precisa sobre cómo se posicionan nuestros productos en el mercado. Si bien las plataformas de e-commerce como Mercado Libre ofrecen gran cantidad de datos, puede ser un desafío hacer un análisis exhaustivo de manera manual. Con esta herramienta, podes automatizar la recolección de precios, analizar la competitividad y ajustar tu estrategia de precios de forma eficiente.

¿Qué vas a necesitar?

Un archivo CSV con tus productos: Este archivo debe contener al menos dos columnas:

query: El nombre del producto o la palabra clave para buscar en Mercado Libre.
precio de referencia: El precio con el que estás vendiendo el producto en tu tienda.

Google Colab: Una herramienta gratuita y accesible para ejecutar código Python en la nube, sin necesidad de configurar un entorno local.

API de Mercado Libre: Vamos a usar la API de búsqueda de Mercado Libre para obtener información de los precios de los productos.

Paso a paso: cómo hacerlo

Preparar tu archivo CSV

Tu archivo CSV debe tener una estructura como esta:

query: Nombre detallado del producto que se desea buscar

price: Precio de referencia para tu comercio actual.

Crear un nuevo Google Colab

1. En a Google Colab
2. Crea un nuevo cuaderno (notebook) de Python.
3. Asegurate de tener acceso a las bibliotecas necesarias: pandas, requests, y numpy. Podes instalarlas directamente en el Colab con el siguiente comando:

!pip install pandas requests numpy

Paso 3: Escribir el código en Python

En el Google Colab definimos diversas funciones que nos van a ayudar a realizar la búsqueda y comparación.

Importamos las librerías necesarias

import requests
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

Definimos una función de búsqueda para utilizar la API de MercadoLibre y retornar los datos ordenados en dataframe de Pandas

def search_mercadolibre(query, limit=50):
    """
    Busca productos en Mercado Libre utilizando su API de búsqueda, manejando la paginación.

    Args:
        query: Término de búsqueda.
        limit: Número máximo de resultados a obtener por página (máximo 50).

    Returns:
        Un DataFrame de pandas con los resultados de la búsqueda de todas las páginas, o None si ocurre un error.
    """

    all_results = []  # Lista para almacenar resultados de todas las páginas
    offset = 0  # Desplazamiento inicial para la paginación

    while True:
        url = f"https://api.mercadolibre.com/sites/MLA/search?q={query}&limit={limit}&offset={offset}"
        try:
            response = requests.get(url)
            response.raise_for_status()  # Lanza una excepción para códigos de estado HTTP no exitosos

            data = response.json()
            results = data.get("results", [])

            if not results:
                break  # Salir del bucle si no hay más resultados en esta página

            all_results.extend(results)  # Agregar resultados a la lista principal
            offset += limit  # Actualizar el desplazamiento para la siguiente página

        except requests.exceptions.RequestException as e:
            print(f"Error al realizar la solicitud a la API de Mercado Libre: {e}")
            return None
        except Exception as e:
            print(f"Error inesperado: {e}")
            return None

    if not all_results:
        print("No se encontraron resultados para la búsqueda.")
        return None

    df = pd.DataFrame(all_results)
    return df

Creamos otra función, para aplicar un simple ajuste de outliers en caso de alguna publicación se encuentre con un precio erroneo o la API de búsqueda nos haya devuelto un producto totalmente fuera del contexto de nuestra búsqueda. Esto es una simple técnica para intentar remover estos casos pero podríamos profundizarlo con técnicas de remoción de outliers más avanzadas.

def remove_outliers(df, column_name):
    """
    Elimina outliers de una columna numérica de un DataFrame usando quantiles.
    """
    if column_name not in df.columns:
        print(f"La columna '{column_name}' no existe en el DataFrame.")
        return df 

    try:
        # Convertir la columna a numérica, manejando errores
        df[column_name] = pd.to_numeric(df[column_name], errors='coerce')
        df = df.dropna(subset=[column_name])  # Eliminar filas con valores no numéricos
    except Exception as e:
        print(f"Error al convertir la columna a numérica: {e}")
        return df 
    
    # Calcular quantiles
    q10 = df[column_name].quantile(0.10)
    q90 = df[column_name].quantile(0.90)

    # Filtrar valores fuera de los quantiles
    df_filtered = df[(df[column_name] >= q10) & (df[column_name] <= q90)]

    return df_filtered 

Creamos una función que se encargará de comparar los precios suministrados en nuestro CSV con el precio promedio del resultado de búsqueda en Mercado Libre

def analyze_product_prices(csv_filepath, price_column="price"):
    """
    Analiza los precios de productos desde un CSV y los compara con precios en Mercado Libre.

    Args:
        csv_filepath: Ruta al archivo CSV con la tabla de productos.
        price_column: Nombre de la columna en el CSV que contiene el precio.

    Returns:
        Un DataFrame con el análisis de precios, o None si ocurre un error.
    """
    try:
        products_df = pd.read_csv(csv_filepath)
    except FileNotFoundError:
        print(f"Error: Archivo CSV no encontrado en '{csv_filepath}'.")
        return None
    except pd.errors.ParserError:
        print(f"Error: No se pudo procesar el archivo CSV '{csv_filepath}'. Verifica su formato.")
        return None
    except Exception as e:
        print(f"Error inesperado al leer el archivo CSV: {e}")
        return None

    results = []
    for index, row in products_df.iterrows():
        query = row["query"]
        target_price = row[price_column]

        df_mercadolibre = search_mercadolibre(query)
        if df_mercadolibre is not None:
            df_filtered = remove_outliers(df_mercadolibre, "price")
            if not df_filtered.empty:
                avg_ml_price = df_filtered["price"].mean()
                deviation_percent = ((avg_ml_price - target_price) / target_price) * 100
                results.append({
                    "producto": query,
                    "precio_comercio": target_price,
                    "precio_mercado_libre": f"{round(avg_ml_price)}",
                    "desvío": f"{round(deviation_percent)}%"  # Formatear como porcentaje entero
                })
            else:
                print(f"No se encontraron precios válidos en Mercado Libre para '{query}' después de eliminar outliers.")
        else:
            print(f"No se pudieron obtener resultados de Mercado Libre para '{query}'.")

    return pd.DataFrame(results) 

Por último y luego de ejecutar todas las funciones anteriores cargamos nuestro CSV y ejecutamos la búsqueda y análisis de nuestros productos.

csv_file = "productos.csv"  # Reemplazar con la ruta de tu archivo CSV
analysis_results = analyze_product_prices(csv_file)

if analysis_results is not None:
    print(analysis_results)
    # Puedes realizar más análisis o guardar los resultados a otro archivo
    analysis_results.to_csv("price_analysis.csv", index=False)

En los pasos anteriores logramos:

• Consulta la API de Mercado Libre para buscar cada producto usando la palabra clave.
• Calcula el precio promedio de los productos encontrados, eliminando los valores atípicos (outliers) usando el rango intercuartílico (IQR).
• Compara el precio de tu producto con el promedio de Mercado Libre y calcula la desviación porcentual.

Una vez que hayas cargado tu archivo CSV y ejecutado el código en Colab, obtendrás un archivo de salida price_analysis.csv que contiene el análisis comparativo de precios para cada producto.

Este simple análisis te permitirá ver si tus precios son competitivos y cómo se comparan con los precios de mercado.

Algunas consideraciones

Es importante tener en cuenta algunos aspectos para interpretar correctamente los resultados:

1. Outliers: El proceso de eliminación de valores atípicos (outliers) se basa en el uso del rango intercuartílico (IQR). Aunque este es un método estándar, no garantiza que todos los precios extremos sean irrelevantes. En algunos casos, un precio alto o bajo puede reflejar una oferta válida o una estrategia de precios específica de un vendedor.
2. Imprecisión en la API de Mercado Libre: La API de Mercado Libre devuelve resultados que pueden no reflejar precios exactos o completos en tiempo real. La información puede estar desactualizada, incompleta o ser inexacta debido a diversas razones, como problemas técnicos o cambios en las ofertas de los vendedores.
3. Dependencia de la búsqueda por palabras clave: El análisis se basa en las palabras clave proporcionadas en el archivo CSV. Si las palabras clave no son precisas o bien definidas, los resultados pueden no ser representativos de todos los productos disponibles en Mercado Libre. Es recomendable realizar ajustes a las consultas para obtener resultados más relevantes. Así mismo productos técnicos o con atributos y características distintas podrían distorsionar el análisis.
4. Limitaciones del método de comparación: Esta herramienta compara precios promedio y puede no reflejar las fluctuaciones o dinámicas de precios particulares de ciertos productos. Es recomendable complementar este análisis con otras herramientas de monitoreo de precios y ajustar la estrategia de acuerdo a los datos más recientes.

Conclusión

Con Python y Google Colab, podes realizar un análisis de precios de manera rápida y eficiente sin necesidad de herramientas costosas. Esta herramienta es perfecta para emprendedores, comerciantes y empresas que buscan optimizar sus precios y mantenerse competitivos en el mercado.