API de Scraper Rufus da Amazon

O Rufus da Amazon é o assistente de compras conversacional que impulsiona cada vez mais a pesquisa pré-compra na Amazon — respondendo "Este lava-louças é seguro para a máquina de lavar?", "Como isso se compara ao modelo M2?", "Melhores tênis de corrida abaixo de €100" com respostas fundamentadas e cientes do produto. Para repriceadores, motores de comparação, monitores de marca e pipelines de compras com IA, as respostas que o Rufus fornece são sinais de alto valor.

O Rufus é restrito a sessões de clientes logados e transmite suas respostas como Eventos Enviados pelo Servidor. Isso o torna inacessível através de navegação anônima e impraticável de integrar por meio de scraping DIY. A API de Scraper Rufus da Amazon Sem Scraping resolve isso de ponta a ponta — autenticação, tokens anti-bot, roteamento de marketplace e parsing de stream são todos tratados no lado do servidor, expostos por meio de um único HTTP POST limpo. Este guia abrange tudo: por que as equipes usam a API, como funciona a solicitação e a resposta, referência de parâmetros, integração em Python e Node.js, e problemas comuns com suas soluções.

Parte 1: Por que usar a API de Scraper Rufus da Amazon Sem Scraping?

A API Rufus transforma uma superfície da Amazon autenticada e transmitida em uma única chamada HTTP estruturada em JSON.

• Nenhum login na Amazon é necessário. A autenticação é tratada pela Scrapeless. Quem chama nunca vê um formulário de login, um prompt de MFA ou um jar de cookies.
• Respostas transmitidas, analisadas para você. Uma resposta típica do Rufus é composta de 60 a 80 pedaços de Eventos Enviados pelo Servidor em sete tipos de eventos. A API costura o stream em um único objeto result analisado — sem iter_lines, sem detecção de limite \n\n, sem despacho de tipo de evento do lado do chamador.
• Roteamento de marketplace em um parâmetro. domain: "www.amazon.es", "www.amazon.com", "www.amazon.de" — a API é roteada automaticamente através de um proxy residencial que combina com o local.
• Dados de produto estruturados prontos para uso. result.products retorna uma lista de dicionários com asin, titulo, avaliacao, comentarios, imagem_url, categoria, e uma tag editorial footer — o conjunto curado do Rufus para a consulta.
• Mineração de perguntas relacionadas. Cada resposta também inclui de 3 a 5 perguntas de acompanhamento geradas pelo Rufus. Elas são uma fonte limpa de expansão de consulta para pesquisa de SEO, planejamento de conteúdo ou chamadas em cadeia do Rufus.
• Mesma conta Scrapeless, mesmo painel. A API Rufus usa o mesmo token de API que o resto da linha de produtos Scrapeless — APIs de Scraper, Navegador de Scraping, API de Scraping Universal. Uma conta, muitas superfícies.

Melhor solução de scraping do Amazon Rufus

A API de Scraper Rufus da Amazon Sem Scraping é construída para pipelines de produção que precisam da saída conversacional do Rufus como dados estruturados, sem o ônus de integração de executar um navegador autenticado a cada consulta.

• Autenticação do lado do servidor. A Scrapeless mantém as sessões autenticadas da Amazon e as rotaciona. Quem chama envia uma consulta e recebe JSON analisado de volta.
• Saída pré-analisada. A resposta padrão é um envelope JSON com um objeto result que já está preenchido com products, related_questions, interim_messages, e um request_context. Nenhuma cola de cliente de streaming é necessária para o caso comum.
• SSE bruto opcional. Definir is_sse_data: true expõe o stream bruto event:<type>\ndata:<json>\n\n para quem precisa de atualizações de UI progressivas ou auditoria de eventos de alta fidelidade.
• Multi-marketplace. www.amazon.es é verificado de ponta a ponta; a mesma estrutura se aplica a outros domínios de marketplace (.com, .co.uk, .de, .co.jp, .com.au, .in, .com.mx, .com.br).

Como fazer scraping do Rufus da Amazon com a API de Scraper Sem Scraping

O fluxo de trabalho de ponta a ponta envolve quatro etapas: obter um token de API, construir o corpo da solicitação, enviar o POST, analisar a resposta. Inscreva-se em scrapeless.com, copie o token da API do painel e armazene-o como uma variável de ambiente:

export SCRAPELESS_API_TOKEN=sk_seu_token_aqui

O endpoint é POST https://api.scrapeless.com/api/v1/scraper/request com o cabeçalho x-api-token: <SEU_TOKEN> e um corpo JSON. A resposta é um envelope JSON onde result contém a saída analisada do Rufus.

Como fazer scraping do Rufus por consulta de palavra-chave

Este é o fluxo canônico para fazer uma pergunta ao Rufus e obter respostas estruturadas fundamentadas na Amazon.

Etapa 1: Construir o corpo da solicitação

O corpo da solicitação possui três campos obrigatórios sob input: type (sempre "rufus"), keywords (a pergunta ou intenção de compra), e domain (o marketplace da Amazon).

{
  "actor": "scraper.amazon",
  "input": {
    "type":     "rufus",
    "keywords": "o macbook air m3 é bom para edição de vídeo",
    "domain":   "www.amazon.es"
  }
}

Etapa 2: Definir parâmetros

keywords aceita consultas em linguagem natural de forma livre — perguntas diretas ("Isso é à prova d'água?"), comparações ("M1 vs M3 para vídeo"), ou intenção de compra ("melhor macbook para estudantes"). domain seleciona o marketplace da Amazon; alinhe-o com a localidade que você deseja que Rufus baseie sua resposta. O booleano opcional is_sse_data tem como padrão o valor falso (envelope JSON analisado); defina como verdadeiro para receber o fluxo SSE bruto em vez disso.

Passo 3: Enviar a solicitação

POSTe o corpo para o endpoint com o cabeçalho x-api-token. A resposta padrão chega em 5–15 segundos de ponta a ponta como uma única resposta HTTP fragmentada (cerca de 130 KB para uma consulta típica). Analise o JSON, leia result.products e result.related_questions.

Uma resposta típica de sucesso:

{
  "html": "id:CHUNK_0\nevent:context\ndata:{...}\n\nid:CHUNK_1\nevent:affordance\n...",
  "metadata": {
    "rawUrl": "https://api.scrapeless.com/storage/scrapeless.scraper.amazon/.../<id>.html",
    "type":   "rufus"
  },
  "result": {
    "request_context":   { "requestId": "TMWTVKB12QFTQEV9D2GJ", "sessionId": "257-9398007-5193547", "bsr": {...} },
    "user_query":        "o macbook air m3 é bom para edição de vídeo",
    "interim_messages":  ["Comprobando...", "Recopilando dados…"],
    "products":          [ { "asin": "B08N5TLVQ2", "title": "Apple MacBook Air...", "rating": "4.8", "reviews": "2.045", ... }, ... ],
    "related_questions": ["MacBook Air vs MacBook Pro diferenças", "Qual MacBook é melhor para estudantes?", ...],
    "feedback_controls": { "groupId": "...", "text": "..." }
  }
}

Parâmetros da API de Scraping do Scrapeless Amazon Rufus

O objeto result analisado que a API retorna:

Referência completa da API: apidocs.scrapeless.com/api-34218448.

Como integrar o Scrapeless ao seu projeto

A integração é um único POST HTTP. Abaixo estão exemplos funcionando em Python e Node.js — ambos direcionam para a solicitação canônica (keywords="o macbook air m3 é bom para edição de vídeo", domain="www.amazon.es").

Python

import os
import requests

URL = "https://api.scrapeless.com/api/v1/scraper/request"
HEADERS = {
    "x-api-token":  os.environ["SCRAPELESS_API_TOKEN"],
    "Content-Type": "application/json",
}
BODY = {
    "actor": "scraper.amazon",
    "input": {
        "type":     "rufus",
        "keywords": "o macbook air m3 é bom para edição de vídeo",
        "domain":   "www.amazon.es",
    },
}

resp = requests.post(URL, headers=HEADERS, json=BODY, timeout=60)
resp.raise_for_status()
data = resp.json()

# Saída analisada do Rufus
for product in data["result"]["products"]:
    print(f"{product['asin']}  {product['rating']}★  {product['title'][:80]}")

print("\nPerguntas relacionadas:")
for q in data["result"]["related_questions"]:
    print(f"  - {q}")

Node.js (18+)

const URL = "https://api.scrapeless.com/api/v1/scraper/request";

const resp = await fetch(URL, {
  method: "POST",
  headers: {
    "x-api-token":  process.env.SCRAPELESS_API_TOKEN,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    actor: "scraper.amazon",
    input: {
      type:     "rufus",
      keywords: "o macbook air m3 é bom para edição de vídeo",
      domain:   "www.amazon.es",
    },
  }),
});
if (!resp.ok) throw new Error(`HTTP ${resp.status}: ${await resp.text()}`);

const data = await resp.json();

for (const p of data.result.products) {
  console.log(`${p.asin}  ${p.rating}★  ${p.title.slice(0, 80)}`);
}

console.log("\nPerguntas relacionadas:");

para (const q of data.result.related_questions) {
console.log( - ${q});
}

Ambos os clientes retornam um objeto `data.result` analisado idêntico em forma — sem tratamento de SSE, sem reassembly de chunks. Para consumo bruto de SSE (UIs progressivas, auditorias de eventos de total fidelidade), defina `input.is_sse_data: true` no corpo e leia a resposta como um fluxo:

### Python — modo bruto de SSE

```python
import os, json, requests

resp = requests.post(URL, headers=HEADERS, json={
    "actor": "scraper.amazon",
    "input": {
        "type":         "rufus",
        "keywords":     "é o macbook air m3 bom para edição de vídeo",
        "domain":       "www.amazon.es",
        "is_sse_data":  True,
    },
}, stream=True, timeout=60)

event_type, data_buf = None, []
for line in resp.iter_lines(decode_unicode=True):
    if line is None:
        continue
    if line.startswith("event:"):
        event_type = line[len("event:"):].strip()
    elif line.startswith("data:"):
        data_buf.append(line[len("data:"):])
    elif line == "":
        if event_type and data_buf:
            payload = json.loads("".join(data_buf))
            print(event_type, "->", str(payload)[:120])
        event_type, data_buf = None, []

Node.js — modo bruto de SSE

const resp = await fetch(URL, {
  method: "POST",
  headers: { "x-api-token": process.env.SCRAPELESS_API_TOKEN, "Content-Type": "application/json" },
  body: JSON.stringify({
    actor: "scraper.amazon",
    input: {
      type: "rufus", keywords: "é o macbook air m3 bom para edição de vídeo",
      domain: "www.amazon.es", is_sse_data: true,
    },
  }),
});

const reader = resp.body.getReader();
const decoder = new TextDecoder("utf-8");
let buf = "";
while (true) {
  const { value, done } = await reader.read();
  if (done) break;
  buf += decoder.decode(value, { stream: true });
  const frames = buf.split("\n\n");
  buf = frames.pop();
  for (const frame of frames) {
    const lines = frame.split("\n");
    const evtLine = lines.find(l => l.startsWith("event:"));
    const dataLine = lines.find(l => l.startsWith("data:"));
    if (evtLine && dataLine) {
      const event = evtLine.slice("event:".length).trim();
      const data  = JSON.parse(dataLine.slice("data:".length));
      console.log(event, "->", JSON.stringify(data).slice(0, 120));
    }
  }
}

No modo bruto, espere de 60 a 80 frames em sete tipos de eventos: contexto, afordança, interim, inference, feedback, remove, close. O evento inference carrega a resposta consolidada; close sinaliza o fim do fluxo.

Como evitar problemas comuns encontrados na raspagem de dados

Respostas de erro que você pode ver

A API retorna JSON estruturado para cada caso de erro — code é o código de erro do Scrapeless, message é a explicação legível por humanos. Respostas reais capturadas de solicitações intencionalmente inválidas:

Códigos na faixa 144xx são erros de autenticação e validação de ator; 204xx são erros de forma de solicitação (campo de entrada); 205xx são erros de upstream da Amazon. Trate 205xx com EOF inesperado ou mude a região como transitórios — tente novamente após um pequeno intervalo.

Conclusão

O Amazon Rufus está se tornando uma superfície chave para descoberta de produtos, comparação e pesquisa pré-compra. Para equipes que dependem de dados de intenção de compra, oferece sinais valiosos como recomendações de produtos, contexto de comparação e perguntas de acompanhamento que podem alimentar SEO, precificação e fluxos de trabalho de compras com IA.

A API de Scraper do Scrapeless Amazon Rufus remove as partes mais difíceis de trabalhar com o Rufus. Em vez de gerenciar sessões de login da Amazon, análise de SSE, desafios de anti-bot e roteamento de mercado, você envia uma solicitação e recebe uma saída estruturada de volta. Isso o torna uma escolha prática para pipelines de produção que precisam de acesso confiável e escalável à inteligência de compras gerada pelo Rufus.

Clare seu plano gratuito e comece a raspar:

Junte-se à vibrante comunidade do Scrapeless para reivindicar um plano gratuito de $5-10 e conectar-se com outros inovadores:

Comunidade Oficial do Scrapeless no Discord
Comunidade Oficial do Scrapeless no Telegram

FAQ sobre a API do Scraper Amazon Rufus

P: Preciso de uma conta Amazon ou MFA?
Não. A autenticação é tratada do lado do servidor pelo Scrapeless. O código do chamador só vê result.products e result.related_questions — nunca um formulário de login da Amazon, desafio de MFA ou jarra de cookies.

P: Para que serve o Amazon Rufus?
O Amazon Rufus é o assistente de compras conversacional da Amazon. Os compradores o utilizam para fazer perguntas sobre produtos, comparar opções e obter recomendações com base em caso de uso, orçamento e atributos do produto.

P: Por que o Amazon Rufus é importante para SEO e pesquisa de produtos?
O Rufus expõe perguntas reais de compras e intenções de acompanhamento que refletem como os usuários pensam antes de comprar. Essas perguntas são úteis para expansão de palavras-chave, planejamento de conteúdo, posicionamento de produtos e compreensão do que mais importa para os compradores.

P: Os dados do Amazon Rufus podem ser extraídos diretamente da Amazon?
Não de forma confiável através da navegação anônima. O Rufus está vinculado a sessões de clientes logados e transmite suas respostas, o que torna a extração manual frágil e difícil de escalar. O Scrapeless lida com essa complexidade do lado do servidor.

P: O que torna o Scrapeless melhor do que construir um scraper Rufus personalizado?
O Scrapeless lida com autenticação, tokens anti-bot, parsing de streams e roteamento de marketplace para você. Isso reduz o overhead de manutenção e torna a API muito mais fácil de usar em produção do que um navegador DIY ou pipeline SSE.

P: Quais marketplaces a API Rufus suporta?
A API é projetada para domínios de marketplace da Amazon, como www.amazon.com, www.amazon.es e www.amazon.de. Isso a torna adequada para fluxos de trabalho de múltiplos mercados, onde as respostas do Rufus precisam ser localizadas por região. Atualmente, os domínios da Europa e dos EUA são suportados, e o Scrapeless está continuamente expandindo os domínios suportados!

P: Que tipo de dados a API Rufus retorna?
Normalmente, retorna um objeto JSON estruturado contendo recomendações de produtos, perguntas relacionadas e contexto da solicitação. Dependendo da consulta, você também pode usar a saída transmitida bruta se precisar de dados completos em nível de evento.

P: Como as marcas podem usar os dados do Rufus?
As marcas podem usar os dados do Rufus para pesquisa de concorrentes, análise de comparação de produtos, estratégia de conteúdo, mineração de intenção de compra e merchandising assistido por IA. É especialmente útil quando você quer entender quais atributos de produtos o Rufus destaca com mais frequência.

P: A API Rufus é útil para agentes de IA e automação?
Sim. Como retorna dados estruturados em vez de uma sessão de navegador, se encaixa perfeitamente em agentes de IA, pipelines de enriquecimento, sistemas de recomendação e outros workflows automatizados.