Seguimiento de precios de TikTok Shop con instantáneas de productos en Python

TL;DR:

• El seguimiento de precios es una tubería instantánea. Llama a scraper.tiktok.shop.page en un horario, marca cada respuesta con una marca de tiempo y compara lo similar con lo similar.
• La clave de comparación incluye contexto de mercado. El ID del producto, la región devuelta, la moneda y la identidad SKU previenen coincidencias falsas.
• Los cambios en productos y SKU son eventos diferentes. Realiza un seguimiento del precio del producto mostrado y del stock por separado de la disponibilidad o precio de la variante.
• Faltante no es cero. Un campo ausente no debería activar una alerta de fuera de stock o precio gratuito.
• El actor no crea historia ni alertas. El almacenamiento SQLite, las reglas de comparación, la programación y la entrega viven en la aplicación que llama.
• Gratis para empezar. Las nuevas cuentas de Scrapeless incluyen crédito gratuito a través del Scrapeless Dashboard.

Introducción: un rastreador es más que una solicitud repetida

Una única respuesta de producto de TikTok Shop responde a lo que la página expone ahora. Un rastreador de precios responde a una pregunta diferente: ¿qué cambió entre dos observaciones comparables, y es el cambio lo suficientemente significativo como para notificar a alguien?

Esa distinción afecta todo el diseño. El actor de Scrapeless Shop suministra instantáneas de productos estructurados. La aplicación agrega una marca de tiempo, almacena filas de producto y SKU, compara cada fila con su observación previa y emite un evento listo para alertas. Esta guía construye esa tubería con Python y SQLite.

Para el patrón de solicitud detrás de las instantáneas de productos, lee la guía de actor de datos Scrapeless.

Tubería a Simple Vista

Esta tubería monitorea una lista de productos suministrada por la aplicación. No descubre cada producto en una tienda ni expone un libro de órdenes privado.

Requisitos Previos

• Una cuenta de Scrapeless y un token API del Scrapeless Dashboard
• Python con la biblioteca estándar y soporte SQLite
• IDs de producto públicos conocidos de TikTok Shop
• Una regla de región para cada producto
• Una política de alertas que defina qué cambios importan

El código requiere un token en vivo en SCRAPELESS_API_KEY. La lista de productos es proporcionada por tu aplicación.

Etapa 1 — Recuperar una Instantánea del Producto

Llama a POST https://api.scrapeless.com/api/v1/scraper/request con el actor scraper.tiktok.shop.page. Su entrada contiene product_id como una cadena y region. La documentación del actor de la página de TikTok Shop muestra los campos de solicitud y respuesta.

El resultado puede incluir identidad del producto, región devuelta, vendedor, nombre, conteo vendido, precio, moneda, stock, calificación, conteo de reseñas, imágenes, opciones, SKUs, categorías y detalles del envío. Almacena la respuesta en bruto antes de la normalización para que los cambios de esquema posteriores puedan manejarse sin recollectar la misma observación.

Etapa 2 — Normalizar Filas de Producto y SKU

Utiliza una clave de producto formada por el ID del producto y la región devuelta. Para variantes, agrega el identificador SKU. La moneda pertenece en el registro de comparación; un precio numérico no tiene un significado seguro en mercados cruzados por sí solo.

La referencia de código de moneda ISO explica el papel de los identificadores de moneda. Mantén el valor de origen, incluso cuando una capa de informes posterior también convierte precios.

El inventario de productos y variantes debe permanecer separado. La documentación de inventario de TikTok Shop trata los identificadores de productos y SKU como dimensiones de consulta distintas, lo que coincide con un esquema de instantánea limpio.

Comienza a Raspar con Scrapeless

¡Potencia tu flujo de trabajo de scraping web y automatización con Scrapeless!
Regístrate hoy y obtén $5 en crédito gratuito — sin necesidad de tarjeta de crédito.

Reclama tu crédito gratuito ahora en el Scrapeless Dashboard.

Etapa 3 — Almacenar Instantáneas en SQLite

SQLite funciona bien para un monitor pequeño porque la base de datos y las funciones de tiempo están disponibles desde Python sin un servicio separado. La documentación de SQLite CREATE TABLE define las restricciones de la tabla utilizadas en el esquema.

import json
import os
import sqlite3
from datetime import datetime, timezone
from urllib.request import Request, urlopen

ENDPOINT = "https://api.scrapeless.com/api/v1/scraper/request"


def fetch_product(product_id, region):
    body = json.dumps({
        "actor": "scraper.tiktok.shop.page",
        "input": {"product_id": str(product_id), "region": region},
    }).encode()
    request = Request(
        ENDPOINT,
        data=body,
        headers={
            "x-api-token": os.environ["SCRAPELESS_API_KEY"],
            "content-type": "application/json",
        },
        method="POST",
    )
    with urlopen(request, timeout=60) as response:
        return json.load(response)


def open_database(path="tiktok_shop_history.sqlite3"):
    database = sqlite3.connect(path)
    database.execute("""
        CREATE TABLE IF NOT EXISTS product_snapshots (
            observed_at TEXT NOT NULL,
            product_id TEXT NOT NULL,
            region TEXT NOT NULL,
            currency TEXT,
            price TEXT,
            stock INTEGER,
            sold_count INTEGER,
            raw_json TEXT NOT NULL,
            PRIMARY KEY (observed_at, product_id, region)
        )
    """)
    return database


def store_product(database, raw):
    observed_at = datetime.now(timezone.utc).isoformat()
    row = (
        observed_at,
        str(raw.get("product_id", "")),
        str(raw.get("region", "")),
        raw.get("currency"),
        None if raw.get("price") is None else str(raw.get("price")),
        raw.get("stock"),
        raw.get("sold_count"),
        json.dumps(raw, ensure_ascii=False),
    )
    database.execute(
        "INSERT INTO product_snapshots VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
        row,
    )
    database.commit()
    return row

Store price as source text or an exact decimal type in systems that support it. Binary floating-point is a poor storage choice for money because some decimal values cannot be represented exactly.

Etapa 4 — Comparar Con la Observación Anterior

La comparación debe ocurrir solo dentro del mismo ID de producto, región devuelta y moneda. Consulta la fila anterior más reciente, luego genera un evento para los campos que están presentes en ambas observaciones.

from decimal import Decimal


def previous_snapshot(database, product_id, region, observed_at):
    return database.execute(
        """
        SELECT observed_at, currency, price, stock
        FROM product_snapshots
        WHERE product_id = ? AND region = ? AND observed_at < ?
        ORDER BY observed_at DESC
        LIMIT 1
        """,
        (str(product_id), region, observed_at),
    ).fetchone()


def compare(current, previous):
    if previous is None:
        return {"state": "baseline", "changes": []}

    _, old_currency, old_price, old_stock = previous
    changes = []
    if current[3] == old_currency and current[4] is not None and old_price is not None:
        new_price = Decimal(current[4])
        prior_price = Decimal(old_price)
        if new_price != prior_price:
            changes.append({
                "field": "price",
                "before": str(prior_price),
                "after": str(new_price),
                "currency": current[3],
            })
    if current[5] is not None and old_stock is not None and current[5] != old_stock:
        changes.append({"field": "stock", "before": old_stock, "after": current[5]})
    return {"state": "compared", "changes": changes}


database = open_database()
raw = fetch_product(os.environ["TIKTOK_SHOP_PRODUCT_ID"], "GB")
current = store_product(database, raw)
prior = previous_snapshot(database, current[1], current[2], current[0])
print(json.dumps(compare(current, prior), indent=2))

La primera observación establece una línea base y no debe generar una alerta de cambio de precio. Un valor faltante tampoco debe convertirse en cero o en un evento de falta de stock.

Etapa 5 — Rastrear Cambios en SKU

Crea una segunda tabla de historial clave por tiempo de observación, ID de producto, región devuelta y ID de SKU. Almacena las etiquetas de opción, el precio de SKU cuando se expone, moneda y disponibilidad. Compara un SKU solo con su propia fila anterior.

Las listas de variantes pueden cambiar. Un SKU recién observado es un evento de descubrimiento; un SKU faltante es una ausencia que necesita confirmación bajo la política de colección de la aplicación. No declares una variante como descontinuada por una respuesta faltante.

Etapa 6 — Producir Eventos Listos para Alertas

Mantén la colección separada de la notificación. El trabajo de comparación puede escribir eventos como:

• el precio del producto cambió en la misma moneda y región
• el stock agregado cruzó un umbral comercial
• cambió la disponibilidad de un SKU conocido
• apareció un nuevo SKU

Aplica umbrales después de que se calculen los cambios exactos. Incluye los tiempos de observación anteriores y actuales, ID de producto, región, moneda, campo y valores antes/después. Un trabajador descendente puede enrutar el evento a correo electrónico, chat, un webhook o un panel interno.

Lee sold_count Con Atención

Preserva sold_count tal como se devolvió con la instantánea del producto. No identifica una ventana de informes, órdenes individuales, reembolsos o GMV. Un cambio entre observaciones es un cambio de etiqueta de página, no un libro de ventas completo.

Scrapeless proporciona el actor del producto a través de Scraping API. Utiliza la página de precios actual para estimar el costo del conjunto de productos y el calendario elegido.

Conclusión: mantener las instantáneas comparables

El seguimiento de precios de TikTok Shop necesita una clave estable, una marca de tiempo de colección, historial de producto y SKU separado, y reglas de cambio cautelosas. El actor proporciona cada instantánea pública del producto; el trabajo de Python circundante convierte esas observaciones en una historia y eventos listos para alertas.

¿Listo para Construir Su Monitor de Precios?

Únete al Discord de Scrapeless o a la comunidad de Telegram para discutir esquemas de monitoreo. Crea una cuenta en el Tablero de Scrapeless cuando la lista de productos y la política de alertas estén listas.

FAQ

Q: ¿Scrapeless proporciona un historial automático de precios de TikTok Shop?

No. El actor devuelve instantáneas de productos; la aplicación que llama programa solicitudes, almacena observaciones, compara filas y entrega alertas.

Q: ¿Qué clave debe usar un rastreador de precios de TikTok Shop?

Usa el ID de producto más la región devuelta para los registros de producto, y añade el ID de SKU para los registros de variantes. Mantén la moneda en cada comparación de precios.

Q: ¿Se debe almacenar un valor de precio o stock faltante como cero?

No. Faltante significa desconocido, mientras que cero es un valor definido con un significado comercial diferente.

Q: ¿Se puede usar el conteo de vendidos como ventas diarias o GMV?

No. La etiqueta devuelta no establece una ventana de informes ni proporciona un libro de órdenes y ingresos completo.

Q: ¿Con qué frecuencia debe ejecutarse el rastreador?

Elige una cadencia basada en la decisión comercial, la volatilidad del producto, el uso permitido y el presupuesto. Registra el calendario para que las brechas en la historia permanezcan visibles.

Q: ¿Es legal monitorear precios públicos de la tienda?

La legalidad depende de la jurisdicción, el mercado, el propósito, el método de acceso y los términos aplicables. Monitorea datos públicos de productos para un propósito permitido y obtén asesoramiento legal para el uso previsto.

Q: ¿Necesito gestionar proxies, defensas de página o selectores de DOM?

Scrapeless maneja la superficie de colección. La aplicación gestiona la lista de productos, marcas de tiempo, almacenamiento, comparaciones y notificaciones.

Q: ¿Puede esto funcionar sin un agente de IA?

Sí. El flujo de trabajo utiliza solicitudes HTTP directas, SQLite y código Python ordinario.