Cómo Monitorear las Recomendaciones de Amazon Rufus con el Tiempo

Puntos clave:

• Las recomendaciones de Amazon Rufus son datos de productos estructurados, no una transcripción de chat. Una llamada al actor scraper.amazon con type: rufus devuelve un arreglo de products, cada entrada contiene un ASIN, título, precio, calificación y la etiqueta de sección bajo la cual Rufus la agrupó.
• El share-of-recommendation es la métrica que produce este pipeline. Rastrear qué ASINs Rufus presenta para un conjunto de consultas fijas a lo largo del tiempo convierte una estantería conversacional en una señal de visibilidad medible — el equivalente de Rufus a un share-of-voice.
• Rufus divide sus selecciones en secciones etiquetadas. La respuesta agrupa productos en bloques de contenido como "Las mejores selecciones – Mejor ANC" y "Selecciones de gran valor", por lo que cada producto lleva tanto un rango general como el encabezado de la sección que lo enmarca.
• related_questions expande el conjunto de consultas semilla por sí solo. Cada captura devuelve las preguntas de seguimiento que Rufus sugiere para la consulta, y estas se envían directamente de vuelta a la lista de prompts de la próxima ejecución.
• Cada campo es anulable y la respuesta se genera por sesión. Una consulta puede no devolver una respuesta de Rufus para una región dada, y un espacio de producto puede llegar sin un conteo de bought — por lo que el pipeline almacena instantáneas por ejecución y lee la serie, nunca una única llamada.
• El pipeline se reduce a instantáneas de solo anexar más una diferencia. Cada ejecución escribe un registro JSONL clave por consulta y tiempo de captura; al diferenciar registros consecutivos se informa qué ASINs ingresaron o cayeron entre ejecuciones.
• Gratis para comenzar. Las nuevas cuentas de Scrapeless incluyen créditos de prueba gratuitos — regístrate en app.scrapeless.com.

Introducción: la estantería de compras se trasladó al asistente

Amazon Rufus responde preguntas de compra con una lista ordenada de productos. Un comprador pregunta por los mejores auriculares con cancelación de ruido, y Rufus devuelve selecciones agrupadas — "Las mejores selecciones", "Mejores para usuarios de Apple", "Selecciones de gran valor" — cada una con un precio, una calificación y un enlace de compra, dentro del asistente y antes de que se cargue cualquier página de resultados de búsqueda. Para una marca, la pregunta ya no es dónde se clasifica un producto en la cuadrícula de resultados; es si Rufus menciona el producto en absoluto, en qué sección y en qué rango.

Esa estantería es difícil de vigilar a lo largo del tiempo. Rufus genera su respuesta por sesión, las selecciones cambian según la consulta y la región, y las tarjetas de producto se resuelven dentro de una superficie conversacional que lucha contra la automatización. Leerla a simple vista una vez no te dice nada; la señal es cómo se mueve el conjunto de recomendaciones semana a semana.

Esta guía construye un pipeline de monitoreo sobre la API de Scraping de Scrapeless: un conjunto de consultas fijas entra, el actor scraper.amazon devuelve las recomendaciones de Rufus como productos estructurados, y el pipeline extrae ASIN, rango y sección, mapea cada ASIN a una marca, almacena una instantánea por ejecución, y diferencia las instantáneas para informar el share-of-recommendation. Se empareja naturalmente con visibilidad de marca en Resúmenes de IA de Google, que rastrea la misma pregunta de recomendación en el lado de búsqueda.

Pipeline a primera vista

Todo el sistema tiene seis etapas, de extremo a extremo:

1. Definir un conjunto de consultas — una lista fija de preguntas de compra, ampliada por las related_questions que devuelve cada captura.
2. Capturar por consulta — enviar cada consulta al actor scraper.amazon con type: rufus; una región no soportada no devuelve respuesta de Rufus, lo cual el pipeline registra y omite.
3. Extraer productos — recorrer los content_blocks, obteniendo el ASIN, rango general y etiqueta de sección de cada producto.
4. Mapear ASIN → marca — resolver una marca a partir del título del producto con una pequeña heurística para que el share pueda agregarse por encima del nivel de ASIN.
5. Almacenar una instantánea por ejecución — anexar un registro JSONL por consulta, clave por consulta y tiempo de captura; nunca sobreescribir.
6. Diferenciar a lo largo del tiempo — comparar instantáneas consecutivas para informar el share-of-recommendation y qué ASINs ingresaron o cayeron.

Las etapas 1–4 se ejecutan en cada consulta en cada ciclo; las etapas 5–6 convierten esas capturas en una serie temporal. Las secciones a continuación desarrollan cada etapa en orden.

Requisitos previos

• Python 3.10 o superior (el código a continuación usa solo la biblioteca estándar más requests)
• Una cuenta de Scrapeless y una clave API — regístrate en app.scrapeless.com
• La clave exportada como SCRAPELESS_API_KEY
• Familiaridad básica con la terminal y JSON

Etapa 1 — Definir el conjunto de consultas

Un programa de monitoreo es tan bueno como su conjunto de consultas. Comienza con las preguntas de compra que importan para la categoría que rastreas — fórmulate de la manera en que un comprador pregunta a Rufus, con clara intención de compra.
"mejores auriculares con cancelación de ruido",
"mejores auriculares inalámbricos para viajar",
"mejores auriculares sobre la oreja económicos",
]

Cada captura de Rufus también devuelve una lista de `preguntas_relacionadas`: las preguntas de seguimiento que Rufus sugiere para esa consulta. Alimentar esas preguntas de nuevo en el conjunto permite que la lista de consultas crezca hacia las preguntas que los compradores realmente hacen, en lugar de mantenerse congelada en tus suposiciones iniciales.

```python
def expand_queries(result: dict) -> list[str]:
    """Extraer las preguntas de seguimiento que Rufus sugirió para una consulta capturada."""
    return result.get("preguntas_relacionadas") or []

Para la consulta de auriculares, ese campo volvió como ["Comparar Sony XM6 vs Bose QC Ultra 2", "Mejores auriculares para viajar y vuelos", "Mejores auriculares con cancelación de ruido en su lugar", "¿Están en oferta alguno de estos?"]. Agrega las preguntas que deseas rastrear al conjunto inicial y deduplica; trata el resto como candidatos para revisar antes de promoverlos al conjunto monitoreado.

Etapa 2 — Capturar Rufus para cada consulta

Una única solicitud POST a /api/v1/scraper/request con el actor scraper.amazon y tipo: rufus devuelve el conjunto de recomendaciones. El actor renderiza el servidor de superficie de Rufus del lado del servidor y lo analiza en una respuesta JSON, por lo que no hay que gestionar un navegador, proxy o sesión de tu parte.

# Recomendaciones de Amazon Rufus a través de la API de Scraping de Scrapeless (scraper.amazon, tipo: rufus).
# Requiere SCRAPELESS_API_KEY en el entorno.
curl -sS -X POST https://api.scrapeless.com/api/v1/scraper/request \
  -H "Content-Type: application/json" \
  -H "x-api-token: ${SCRAPELESS_API_KEY}" \
  -d '{
    "actor": "scraper.amazon",
    "input": {
      "type": "rufus",
      "keywords": "mejores auriculares con cancelación de ruido",
      "domain": "www.amazon.com"
    }
  }'
# Pasa a: | jq '.result.products' para la lista de recomendaciones planas.

La misma llamada en Python lee la clave del entorno y devuelve el objeto result. Rufus se genera por sesión, por lo que una consulta puede volver sin respuesta; Amazon devuelve un error de región por una tienda no compatible en lugar de recomendaciones. Trata un resultado persistentemente vacío como sin respuesta de Rufus para esta consulta/región, regístralo y pasa a la siguiente consulta; no es algo que debas enviar nuevamente.

import os
import requests

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


def capture_rufus(query: str, domain: str = "www.amazon.com") -> dict:
    resp = requests.post(
        ENDPOINT,
        headers={
            "Content-Type": "application/json",
            "x-api-token": os.environ["SCRAPELESS_API_KEY"],
        },
        json={"actor": "scraper.amazon", "input": {"type": "rufus", "keywords": query, "domain": domain}},
        timeout=180,
    )
    resp.raise_for_status()
    return resp.json().get("result", {}) or {}

Si la región a la que apuntas no tiene superficie de Rufus, el actor informa la falla para esa tienda y el result está vacío; selecciona la región que realmente deseas monitorear y compara de manera similar, porque una ejecución de EE. UU. y una no de EE. UU. son conjuntos de datos diferentes.

Etapa 3 — Extraer productos con rango y sección

El conjunto de recomendaciones vive en dos lugares en la respuesta. result.products es la lista plana de cada artículo recomendado; result.content_blocks son los mismos artículos agrupados en las secciones etiquetadas que Rufus renderizó (tipo: "product_section", cada uno con un encabezado category y su propio array de products). Leer los bloques preserva tanto el rango general como la sección que enmarcó cada elección.

def extract_products(result: dict) -> list[dict]:
    """Aplanar los bloques de contenido de Rufus en filas de asin, rango, sección, marca."""
    rows = []
    rank = 0
    for block in result.get("content_blocks") or []:
        if block.get("type") != "product_section":
            continue
        section = block.get("category")
        for product in block.get("products") or []:
            asin = product.get("asin")
            title = product.get("title")
            if not asin or not title:  # espacio medio resuelto — tratar como nullable, saltar
                continue
            rank += 1
            rows.append({
                "asin": asin,
                "title": title,
                "section": section,
                "rank": rank,
                "price": product.get("price"),
                "rating": product.get("rating"),
                "brand": brand_from_title(title),
            })
    return rows

Los campos bought, original_price y delivery están presentes en algunos productos y ausentes en otros, así que lee cada uno con .get() y trata un campo faltante como nullable en lugar de asumir que está allí.

Mapear ASIN a marca

La participación en la recomendación es más útil agregada a la marca que dejada en el ASIN, porque una marca a menudo aparece varias veces en secciones. Una heurística basada en el título cubre el caso común: empareja una marca conocida si el título menciona una, de lo contrario, retrocede al primer token del título.

MARcas_CONOCIDAS = ("Sony", "Bose", "Apple", "Sennheiser", "Beats", "JBL", "Anker")


def marca_de_titulo(titulo: str) -> str | None:
    if not titulo:
        return None
    minusculas = titulo.lower()
    for marca in MARcas_CONOCIDAS:
        if marca.lower() in minusculas:
            return marca
    return titulo.split()[0]  # respaldo: primera palabra del título

Mantén la lista MARcas_CONOCIDAS en el ámbito de la categoría que monitoreas; la alternativa maneja la larga cola sin una tabla de búsqueda.

Obtén tu clave API en el plan gratuito: app.scrapeless.com

Etapa 4 — Almacenar una instantánea por ejecución

La canalización es solo de anexado: cada captura escribe un registro JSONL claveado por la consulta y la hora de captura, y nada se sobrescribe. Eso te da el historial completo para diferenciar, y significa que una ejecución mala o vacía nunca destruye una buena anterior.

import json
import time


def anexar_instantanea(ruta: str, consulta: str, filas: list[dict]) -> dict:
    registro = {"consulta": consulta, "capturado_en": int(time.time()), "productos": filas}
    with open(ruta, "a", encoding="utf-8") as manejador:
        manejador.write(json.dumps(registro, ensure_ascii=False) + "\n")
    return registro

Usar un entero epoch para capturado_en mantiene cada registro autodescriptivo y ordenable sin un índice separado. Para cargar el historial de vuelta para una consulta dada, lee el archivo línea por línea y filtra por la clave consulta — una pasada produce cada instantánea en orden de captura.

Etapa 5 — Diferenciar e informar la cuota de recomendación

Dos funciones del lado de lectura convierten el historial de instantáneas en métricas. La cuota de recomendación cuenta cuántas veces aparece cada marca a lo largo de una ejecución y normaliza a un porcentaje; la diferencia compara los conjuntos ASIN de dos ejecuciones para mostrar movimiento.

from collections import Counter


def cuota_de_recomendacion(filas: list[dict]) -> dict[str, float]:
    conteos = Counter(fila["marca"] for fila in filas if fila.get("marca"))
    total = sum(conteos.values())
    if not total:
        return {}
    return {marca: round(100 * n / total, 1) for marca, n in conteos.most_common()}


def diferenciar_ejecuciones(filas_prev: list[dict], filas_curr: list[dict]) -> dict[str, list[str]]:
    prev = {fila["asin"] for fila in filas_prev}
    curr = {fila["asin"] for fila in filas_curr}
    return {
        "ingresados": sorted(curr - prev),
        "eliminados": sorted(prev - curr),
    }

Ejecuta cuota_de_recomendacion por consulta para ver qué marcas dominan el estante conversacional para esa pregunta, o en todo el conjunto de consultas para una vista general de la categoría. Ejecuta diferenciar_ejecuciones entre las dos instantáneas más recientes de una consulta para captar la semana en que una marca entró en las recomendaciones o quedó fuera de ellas — el momento que vale la pena alertar.

Programación y escalado

El bucle de captura une las etapas: para cada consulta, captura, extrae, almacena una instantánea y registra un resultado vacío como un salto. Ejecútalo en un horario — diario o semanal — y el archivo JSONL se convierte en la serie temporal.

if __name__ == "__main__":
    ruta_instantanea = "instantaneas_rufus.jsonl"
    for consulta in CONSULTAS_SEMILLA:
        resultado = capturar_rufus(consulta)
        filas = extraer_productos(resultado)
        if not filas:
            print(f"{consulta}: no hay respuesta de Rufus para esta consulta/región")
            continue
        anexar_instantanea(ruta_instantanea, consulta, filas)
        cuota = cuota_de_recomendacion(filas)
        lideres = ", ".join(f"{b} {pct}%" for b, pct in list(cuota.items())[:3])
        print(f"{consulta}: {len(filas)} productos — {lideres}")

Algunos límites prácticos cuando escalas el conjunto de consultas:

• Mantén la concurrencia moderada — un puñado de consultas en vuelo a la vez es suficiente; una ejecución de monitoreo es constante, no una explosión.
• Fija la región por ejecución para que la serie permanezca comparable; una consulta que no devuelve respuesta de Rufus en una región se registra como un salto, no se mezcla en los números de otra región.
• Delimita el conjunto de consultas a lo que actúas. Cada consulta es una llamada facturable, así que monitorea las preguntas que impulsan decisiones y deja que preguntas_relacionadas sugiera las siguientes a agregar. Planifica la cadencia contra los precios de Scrapeless.

Lo que obtienes de vuelta

Cada captura produce la lista plana de productos más los content_blocks agrupados en secciones; la canalización reduce ambos a filas de instantánea y una tabla de cuotas. La forma a continuación es lo que devuelve el actor, recortado a una sección.

// El esquema es lo que scraper.amazon (tipo: rufus) devuelve; los valores de campo son una muestra ilustrativa de una ejecución en vivo (secciones y productos recortados).
{
  "metadata": { "type": "rufus", "rawUrl": "https://…" },
  "result": {
    "user_query": "mejores auriculares con cancelación de ruido",
    "content_blocks": [
      {
        "type": "product_section",
        "category": "Mejores Elecciones – Mejor ANC",

{"productos": [
{
"asin": "B0GN4CFF6H",
"título": "Auriculares inalámbricos con cancelación de ruido Sony WH-1000XM6/B",
"precio": "$398.00",
"precio_original": "$428.00",
"calificación": "4.5",
"reseñas": "238",
"entrega": "Entrega GRATIS el viernes, 19 de junio",
"url": "https://…"
}
]
}
],
"productos": [
{ "asin": "B0GN4CFF6H", "título": "Sony WH-1000XM6/B …", "categoría": "Mejores Selecciones – Mejor ANC" }
],
"preguntas_relacionadas": ["Comparar Sony XM6 vs Bose QC Ultra 2", "¿Alguno de estos está en oferta?"]
}
}

Después de las etapas 3-5, un registro de instantánea y su tabla de participación se ven así:

```json
// Salida de la tubería — muestra ilustrativa (esquema real, valores de ASIN/marca/rango ilustrativos): una fila de instantánea solo de anexión más el recuento de participación de recomendación.
{
  "instantánea": {
    "consulta": "mejores auriculares con cancelación de ruido",
    "capturado_en": 1781716376,
    "productos": [
      { "asin": "B0GN4CFF6H", "rango": 1, "sección": "Mejores Selecciones – Mejor ANC", "marca": "Sony" },
      { "asin": "B0FDKR293G", "rango": 2, "sección": "Mejores Selecciones – Mejor ANC", "marca": "Bose" },
      { "asin": "B0GSS4SGZR", "rango": 3, "sección": "Mejor para usuarios de Apple", "marca": "Apple" }
    ]
  },
  "participación de recomendación": { "Sony": 33.3, "Bose": 33.3, "Apple": 33.3 }
}

Algunas observaciones honestas después de ejecutarlo:

• La respuesta es por sesión. La misma consulta devuelve un conjunto diferente de recomendaciones y diferentes preguntas_relacionadas, de una ejecución a otra. Almacene capturado_en en cada registro; la serie a lo largo del tiempo es la señal, no una sola captura.
• Las secciones enmarcan el rango. La sección de un producto (bloques_de_contenido[].categoría) explica por qué se clasificó donde lo hizo — "Mejor para usuarios de Apple" es un estante diferente que "Mejores Selecciones de Gran Valor". Lleve la sección, no solo la posición.
• Los campos son anulables. comprado, precio_original, y entrega aparecen en algunos productos y no en otros; un espacio medio resuelto puede llegar sin un título o asin. Lean cada uno con .get() y salten la fila en lugar de almacenar espacios en blanco.
• La región decide si hay respuesta o no. Una tienda no soportada devuelve un error de región en lugar de productos. Determine la región que monitorea y registre las fallas como saltos.

Manejo responsable

Esta tubería solo lee las recomendaciones de productos públicas que Rufus muestra a cualquier comprador — ASINs, títulos, precios, calificaciones, y las etiquetas de sección. Manténgalo en esa superficie pública: no recojan datos personales ni contenido restringido por cuenta, respeten los términos de servicio de Amazon y las directivas de robots, y almacenen solo los campos de productos que el programa de monitoreo necesita. La participación de recomendación es una métrica de visibilidad de marca construida a partir de listas públicas, nada más.

Conclusión: un estante conversacional como serie temporal

Monitorear Amazon Rufus se reduce a un bucle: capturar cada consulta contra el actor scraper.amazon con tipo: rufus, extraer ASIN más rango más sección de bloques_de_contenido, mapear cada ASIN a una marca, añadir una instantánea por ejecución, y diferenciar las instantáneas para la participación de recomendación. Determine la región, trate cada campo como anulable, registre una respuesta perdida como un salto, y deje que preguntas_relacionadas amplíen el conjunto de consultas. La misma forma de monitoreo se aplica a las otras superficies de respuestas — emparejar Rufus con raspado de los Resúmenes de IA de Google proporciona un programa en ambos asistentes de compras y búsqueda. El actor, el punto final y los nombres de los campos aquí están confirmados contra la live API de Raspado Scrapeless de referencia.

¿Listo para construir su tubería de monitoreo de recomendaciones de IA?

Únete a nuestra comunidad para reclamar un plan gratuito y conectarte con desarrolladores que construyen tuberías de datos de respuestas de IA: Discord · Telegram.

Regístrate en app.scrapeless.com para créditos de prueba gratuitos y dirije el conjunto de consultas arriba a las categorías y regiones rastreadas por tu programa de visibilidad de marca.

Preguntas Frecuentes

P: ¿Es legal monitorear las recomendaciones de Amazon Rufus?
Los datos capturados son las recomendaciones de productos visiblemente públicas que Rufus muestra a cualquier comprador. Al igual que con cualquier raspado, la legalidad depende de la jurisdicción y del uso — revise los términos relevantes y consulte a un abogado antes de construir sobre ello, y recoja solo datos de productos públicos, nunca datos personales o restringidos por cuenta.

P: ¿Por qué una consulta no devuelve respuesta de Rufus?
Dos causas. La consulta puede no ser lo suficientemente transaccional: exprésala como una pregunta de compra con una intención de producto clara. O la región que apuntaste no tiene superficie de Rufus, en cuyo caso el actor informa un fallo de región para esa tienda; fija una región admitida y registra la falta como una omisión.

P: ¿Necesito un proxy o un navegador?
No. El renderizado, la gestión de regiones y el análisis se ejecutan del lado del servidor. Envías un POST con un encabezado x-api-token y recibes un JSON de vuelta; el actor devuelve el conjunto de recomendaciones ya estructurado.

P: ¿Cómo obtengo el rango y la sección en la que apareció un producto?
Recorre result.content_blocks: cada bloque product_section lleva un encabezado de category y su propio array de products. Contar productos mientras aplanas los bloques da el rango total, y la category del bloque proporciona la sección, ambas valen la pena almacenarlas por instantánea.

P: ¿Qué es la cuota de recomendación?
Es el porcentaje de espacios recomendados que ocupa una marca en una consulta o un conjunto de consultas, agregado a partir de los productos capturados. Seguida a lo largo del tiempo, muestra si una marca está ganando o perdiendo presencia en la estantería de Rufus: el equivalente de compras conversacionales a la cuota de voz.

P: ¿Por qué almacenar instantáneas en lugar de una sola vista actual?
Rufus genera su respuesta por sesión, por lo que cualquier captura es un punto en el tiempo. Las instantáneas de solo anexar, indexadas por la consulta y el tiempo de captura, te dan el historial para diferenciar, por lo que puedes informar cuáles ASINs entraron o salieron entre ejecuciones en lugar de adivinar a partir de una sola respuesta.

P: ¿Cuántas consultas puedo monitorear a la vez?
Mantén la concurrencia moderada: un puñado de consultas en vuelo es suficiente para un monitoreo constante. Limita el conjunto a las preguntas que actúas y deja que related_questions sugiera las siguientes para agregar, de modo que cada llamada facturable gane su lugar.