¿Cómo crear un rastreador de precios Walmart desde cero?

¿Qué pueden hacer los rastreadores de precios de Walmart?

Supongamos que está pensando en comprar un nuevo televisor en Walmart, pero no está seguro de si ahora es el mejor momento para hacerlo. Comprobar el precio manualmente todos los días lleva mucho tiempo. Ahí es donde resulta útil una herramienta de seguimiento de precios.

• Supervise automáticamente el precio del producto 24 horas al día, 7 días a la semana.

• Lleve un registro de la evolución histórica de los precios.

• Le avisará al instante por correo electrónico o SMS cuando baje de precio.

Qué necesita para empezar a hacer un seguimiento

Antes de sumergirte, asegúrate de tener preparadas las siguientes herramientas:

1. Python (versión recomendada 3.8 o superior) - para escribir y ejecutar el script

2. Editor de código (VS Code o PyCharm) - para facilitar la codificación y hacerla más eficiente.

3. Cuenta de desarrollador de Walmart (opcional) - el uso de la API oficial proporciona más estabilidad

4. IPs proxy (opcional) - ayuda a evitar el bloqueo en caso de peticiones frecuentes

Instalar las bibliotecas Python necesarias

Abra su terminal o símbolo del sistema y ejecute el siguiente comando:

pip install requests beautifulsoup4 selenium pandas schedule smtplib

Si va a utilizar la automatización del navegador, también tendrá que instalar ChromeDriver o geckodriverdependiendo de su navegador.

Cómo obtener los precios de los productos Walmart

Método 1: API oficial de Walmart (Recomendado)

Walmart ofrece una API para desarrolladores que permite obtener datos de productos directamente.

Paso 1: Obtener una clave API

Visite el portal para desarrolladores de Walmart.

Cree una cuenta y solicite una clave API (la aprobación puede tardar algún tiempo).

Paso 2: Obtener el precio con Python

solicitudes de importación

API_KEY = "SU_SCRAPERAPI_KEY"
PRODUCT_URL = "https://www.walmart.com/ip/123456789" # Sustitúyalo por la URL de su producto

def get_price():  
    response = requests.get(
        f "http://api.scraperapi.com?api_key={API_KEY}&url={PRODUCT_URL}"
    )  
    # Extraer el precio del HTML (ejemplo simplificado)
    return "29.99" # Sustituir por la lógica de análisis sintáctico real

precio = get_precio()
print(f "Precio actual: ${precio}") 

Aunque esta forma es legal y tiene menos probabilidades de ser bloqueada, requiere acceso a la API y puede tener límites de velocidad.

Método 2: Raspado con un rastreador web (alternativa)

Si no desea utilizar la API, puede utilizar herramientas como Selenio o BeautifulSoup para extraer el precio directamente de la página del producto.

Ejemplo: Extraer el Precio de la Página de Producto Automáticamente Usando Selenium

from selenium import webdriver
from selenium.webdriver.chrome.options import Opciones

# Configurar navegador headless (se ejecuta sin abrir una ventana)
options = Opciones()
options.add_argument("--headless")
driver = webdriver.Chrome(options=opciones)

product_url = "https://www.walmart.com/ip/123456789" # Sustituir por la URL de su producto
driver.get(product_url)

# Encuentra el elemento precio (puede que tengas que modificar el XPath)
elemento_precio = driver.find_element("xpath", '//span[@itemprop="precio"]')
precio = elemento_precio.text
print(f "Precio actual: {precio}")

driver.quit() # Cerrar el navegador

Walmart tiene protecciones anti-scraping y las peticiones frecuentes pueden hacer que tu IP sea bloqueada. De este modo, añadir time.sleep(5) entre peticiones para evitar que el sitio se vea afectado demasiado rápido y se recomienda utilizar IPs proxy rotativas para mayor fiabilidad.

Evasión de la detección de raspado de Walmart [Opcional].

La frecuencia de solicitud recomendada para una única dirección IP es de no más de 1 vez por minuto sin activar las protecciones anti-bot. Por lo tanto, al visitar y raspar páginas de Walmart con frecuencia, el uso de proxies que ofrecen IPs limpias y cambiar UA regularmente son esenciales para evitar ser marcado y obtener prohibiciones de IP. A continuación te explicamos cómo gestionar y optimizar la configuración de tu rastreador de precios Walmart.

(1) Gestión de grupos de apoderados

Dado que su dirección IP puede bloquearse temporalmente debido a demasiadas solicitudes de scraping, lo que da lugar a un error 403 Forbidden, y que los precios de los productos Walmart pueden variar según la región -por ejemplo, los usuarios de EE.UU. y Canadá pueden ver precios diferentes para el mismo artículo-, es necesario un vasto grupo de proxy con millones de IPs para rotar.

La impresionante red de OkeyProxy cuenta con más de 150 millones de IP reales, que abarcan más de 200 países. Soporta todos los dispositivos y casos de uso, incluyendo rotación automática de IPs para el scraping y rastreo de datos. Este servicio proxy ofrece precios competitivos, posicionándolo como la mejor elección para proxy scraper residencial. Ofrece una PRUEBA PROXY de $3/GB, permitiendo a todos los usuarios experimentar la fiabilidad, velocidad y versatilidad de los proxies de scraping.

# Proxy pool - sustitúyalo por sus propias IPs proxy
PROXY_POOL = [
    "http://45.123.123.123:8080",
    "http://67.234.234.234:8888",
    "http://89.111.222.333:3128"
]

# Seleccionar y validar aleatoriamente un proxy del pool
def rotar_proxy():
    while True:
        proxy = random.choice(PROXY_POOL)
        if check_proxy(proxy):
            return proxy
        else:
            print(f "Proxy {proxy} no está disponible, pruebe con otro...")
            PROXY_POOL.remove(proxy)
    raise Exception("No quedan proxies válidos en el pool.")

# Comprueba si un proxy funciona haciendo una petición de prueba
def comprobar_proxy(proxy):
    try:
        test_url = "https://httpbin.org/ip"
        response = requests.get(test_url, proxies={"http": proxy}, timeout=5)
        return response.status_code == 200
    except:
        return False

(2) Estrategias Anti-Bot

Aleatorizar cabeceras de solicitud

Para evitar ser detectado como un bot, rote su User-Agent con cada petición:

from fake_useragent import UserAgent

ua = UserAgent()
headers = {"User-Agent": ua.random}

Añadir retardos aleatorios entre peticiones

Introducir un retardo entre las solicitudes ayuda a imitar el comportamiento humano:

importar tiempo
importar aleatorio

time.sleep(random.uniform(3, 10)) # Espera de 3 a 10 segundos antes de la siguiente solicitud

Estas estrategias ayudan a reducir el riesgo de ser bloqueado y mejoran la fiabilidad de su rascador a lo largo del tiempo.

Guardar el historial de precios de los productos Walmart

Después de obtener el precio, es importante almacenarlo para poder seguir las tendencias históricas a lo largo del tiempo.

Método 1: Almacenar datos en una base de datos SQLite

importar sqlite3
from datetime import datetime

# Crear o conectarse a una base de datos
conn = sqlite3.connect("walmart_precios.db")
cursor = conn.cursor()

# Crear una tabla si no existe
cursor.execute('''
    CREATE TABLE IF NOT EXISTS precios (
        producto_id TEXT,
        precio REAL,
        fecha TEXT
    )
''')

# Inserta los nuevos datos de precios
cursor.execute("INSERT INTO precios VALUES (?, ?, ?)",
               (product_id, price, datetime.now())
conn.commit()
conn.close()

El almacenamiento de datos en una base de datos SQLite local tras el scraping de Walmart.com es ligero, lo que crea archivos automáticamente, sin necesidad de instalar software adicional.

Método 2: Almacenar datos en un archivo CSV (más sencillo)

import pandas como pd
from datetime import datetime

datos = {
    "product_id": [product_id],
    "price": [precio],
    "date": [datetime.now()]
}

df = pd.DataFrame(datos)
df.to_csv("precios.csv", mode="a", header=False) # Añadir modo

Ambos métodos funcionan bien: utilice una base de datos para consultas más avanzadas o CSV para simplificar.

Alertas diarias de los precios de Walmart

1. Compruebe los precios de Walmart según una ruta determinada

Utilice la horario para ejecutar automáticamente su script de comprobación de precios a una hora específica cada día:

importar horario
hora de importación

def comprobar_precio():
    # Coloca aquí tu código de raspado y comprobación de precios
    print("Comprobando precio...")

# Ejecuta la tarea todos los días a las 9:00 AM
schedule.every().day.at("09:00").do(comprobar_precio)

while True
    schedule.run_pending()
    time.sleep(60) # Comprueba cada minuto si hay tareas programadas

2. Enviar notificaciones por correo electrónico cuando baje el precio

importar smtplib
from email.mime.text import MIMEText

def send_email(precio):
    sender = "[email protected]"
    receptor = "[email protected]"
    contraseña = "tu_contraseña_email_o_contraseña_app"

    msg = MIMEText(f "¡El precio del producto ha bajado! Último precio: ${precio}")
    msg["Asunto"] = "Alerta de precios de Walmart"
    msg["De"] = remitente
    msg["Para"] = destinatario

    with smtplib.SMTP("smtp.gmail.com", 587) as server:
        server.starttls()
        server.login(remitente, contraseña)
        server.sendmail(remitente, destinatario, msg.as_string())

A continuación, dentro de su comprobar_precio() active la alerta cuando el precio esté por debajo de su objetivo:

if precio = 100: # Establezca el umbral de precio deseado
    send_email(precio)

Implantación en la nube del rastreador de precios de Walmart

Si desea que su rastreador de precios Walmart se ejecute continuamente o a horas programadas, puede desplegar el script en la nube utilizando una de las siguientes opciones:

• Acciones de GitHub - Gratuito y estupendo para ejecutar scripts una vez al día

• Servidores en nube (AWS, Azure, etc.) - Ideal para la supervisión en tiempo real

• PythonAnywhere - Apto para principiantes, aunque la versión gratuita tiene algunas limitaciones

Aquí hay un ejemplo que subir herramienta de raspado a Github después de Walmart seguimiento de precios, que es más común.

Programar rastreadores de precios de Walmart en GitHub

En primer lugar, cree un Repositorio GitHub.

A continuación, añada .github/workflows/tracker.yml:

nombre: Walmart Price Tracker

en:
  horario:
    - cron: "0 14 * * *" # 2 PM UTC (ajústelo a su zona horaria)

trabajos:
  run-tracker:
    runs-on: ubuntu-latest
    steps:
      - usa: actions/checkout@v4
      - nombre: Run Tracker
        ejecución: python tracker.py

Funciones adicionales para controlar el precio de los artículos Walmart

1. Supervisar y raspar los datos de varios Walmart Itens

Puede realizar fácilmente el seguimiento de varios productos almacenándolos en una lista y recorriéndolos en bucle:

LISTA_PRODUCTOS = [
    {"id": "123456789", "name": "Auriculares inalámbricos", "umbral": 50},
    {"id": "987654321", "name": "Reloj inteligente", "umbral": 200}
]

def monitor_multiple_products():
    para producto en PRODUCT_LIST:
        precio = get_price(producto["id"])
        if precio = producto["umbral"]:
            send_email(f"{producto['nombre']} acaba de bajar a ${precio}")

De este modo, recibirás alertas separadas para cada artículo que estés vigilando, lo que resulta muy útil durante las grandes rebajas.

2. Visualice las tendencias de precios a partir de los datos de seguimiento guardados

¿Quieres analizar cómo cambia el precio a lo largo del tiempo? Si almacenas los datos de precios en una base de datos CSV o SQLite, sólo tienes que trazar las tendencias históricas con pandas y matplotlib:

importar pandas como pd
import matplotlib.pyplot como plt
importar sqlite3

def trazar_precios_historia():
    # Carga los datos de la base de datos SQLite (o puedes usar pd.read_csv para ficheros CSV)
    conn = sqlite3.connect('walmart_precios.db')
    df = pd.read_sql_query("SELECT * FROM precios", conn)
    conn.close()

    # Convierte la columna fecha al formato datetime
    df['fecha'] = pd.to_datetime(df['fecha'])

    # Opcional: filtro para un producto específico
    product_id = "123456789"
    product_df = df[df['product_id'] == product_id]

    # Gráfico
    plt.figure(figsize=(10, 5))
    plt.plot(product_df['fecha'], product_df['precio'], marker='o', linestyle='-')
    plt.title(f "Evolución del precio del producto {product_id}")
    plt.xlabel("Fecha")
    plt.ylabel("Precio (USD)")
    plt.grid(True)
    plt.xticks(rotation=45)
    plt.tight_layout()
    plt.savefig("historia_precios.png")
    plt.show()

Puedes programar esta función para que se ejecute semanalmente y envíe automáticamente el gráfico a tu bandeja de entrada.

3. Construir un tablero web de Walmart Price Tracker

Puede crear un sencillo panel de seguimiento de precios de Walmart utilizando Frasco o Streamlit para mostrar los precios y las tendencias de los productos en una interfaz web.

Por ejemplo, Flask sirve plantillas HTML en las que puedes mostrar precios actuales, tendencias históricas (como imágenes o gráficos) y mucho más. Aquí tienes un ejemplo básico para empezar:

from flask import Flask, render_template
importar pandas como pd
importar sqlite3

app = Flask(__name__)

@app.route("/")
def index():
    conn = sqlite3.connect("walmart_precios.db")
    df = pd.read_sql_query("SELECT * FROM precios", conn)
    conn.close()

    latest_prices = df.sort_values("date").groupby("product_id").last().reset_index()
    return render_template("index.html", data=últimos_precios.to_dict(orient="registros"))

A continuación, cree una plantilla HTML sencilla (templates/index.html) para mostrar los precios de los productos.

Preguntas más frecuentes (FAQ)

P1: ¿Por qué se bloquea mi scraper?

Estás enviando demasiadas solicitudes en poco tiempo. Utilice apoderados de élite para rotar las direcciones IP y añadir un retardo aleatorio entre cada petición para evitar alcanzar los límites de velocidad:

time.sleep(random.randint(2, 5)) # Esperar 2-5 segundos antes de la siguiente solicitud

P2: ¿Cómo encuentro la identificación del producto?

Vaya a la página de productos de Walmart: el número que aparece después de /ip/ en la URL es el ID del producto. Por ejemplo:

https://www.walmart.com/ip/123456789 → El ID del producto es 123456789

P3: ¿Puedo hacer el seguimiento de varios productos a la vez?

Sí. Sólo tiene que crear una lista de ID de producto y hacer un bucle a través de ellos:

product_list = ["123", "456", "789"].

for producto_id in producto_list:
    precio = get_price(product_id)
    guardar_precio(id_producto, precio)

También puede ampliarlo para enviar alertas separadas para cada producto si sus precios bajan.

Conclusión

¡Eso es todo! Ahora tiene un rastreador de precios Walmart totalmente automatizado que monitorea los precios 24/7 y le notifica instantáneamente cuando hay una caída.

Si ha desplegado un rastreador de precios walmart.com a escala, es importante respetar las directrices robots.txt de Walmart (consulte las normas aquí) y rotar IPs proxy en consecuencia.

Con tu rastreador de precios Walmart personalizado, puedes comprobar los precios mientras duermes, ¡y no volver a perderte una oferta!