Rastreamento de Palavras-chave da Amazon com Proxies: Guia para Desenvolvedores

Aviso legal: Este guia destina-se ao rastreamento de dados públicos de busca da Amazon. Nos EUA, acessar sistemas de computação sem autorização pode violar a Computer Fraud and Abuse Act (CFAA). Na UE, o processamento de dados pessoais está sujeito ao GDPR. Rastreie apenas listagens próprias ou dados públicos, respeite os Termos de Serviço da Amazon e considere a SP-API da Amazon quando disponível.

Por que o Rastreamento de Palavras-chave da Amazon com Proxies é diferente

A busca da Amazon não é o Google. O algoritmo A9 da Amazon classifica produtos por relevância e velocidade de vendas, não apenas por autoridade de página. Para vendedores, isso significa que a posição orgânica de um ASIN para uma palavra-chave específica em um marketplace específico (amazon.com, amazon.de, amazon.co.uk) é a métrica que mais importa — e ela muda diariamente.

O rastreamento de palavras-chave da Amazon com proxies resolve três problemas que ferramentas convencionais não cobrem:

• Localização por marketplace: resultados em amazon.com diferem de amazon.de mesmo para a mesma palavra-chave. Sem geo-targeting, você rastreia dados errados.
• Anti-bot agressivo: a Amazon limita requisições por IP e exibe CAPTCHAs após ~50-100 requests por hora de um mesmo IP de datacenter.
• Paginação instável: mudar de IP entre páginas altera resultados. Sessões sticky mantêm consistência.

Se você é um amazon keyword rank tracker ou desenvolvedor de marketplace SEO, este guia mostra como implementar amazon serp scraping de forma confiável com proxies residenciais ProxyHat e track amazon rankings python em produção.

Contexto Técnico: Por que a Amazon é uma SERP Própria

A página de resultados da Amazon (search results page) tem uma estrutura HTML distinta. Cada produto orgânico é um elemento com data-component-type="s-search-result". Dentro dele:

• data-asin contém o ASIN do produto (ex: B08N5WRWNW).
• A posição orgânica é calculada pela ordem dos elementos, ignorando anúncios Sponsored.
• Anúncios patrocinados contêm o rótulo "Sponsored" ou "Patrocinado" — devem ser filtrados para não inflar posições.

A Amazon também personaliza resultados por histórico de navegação e localização. Para obter dados consistentes, você precisa de proxies residenciais com geo-targeting por país e sessões sticky que mantenham o mesmo IP durante toda a paginação.

Por que Proxies Residenciais são Necessários

A Amazon detecta e bloqueia IPs de datacenter rapidamente. Proxies residenciais usam IPs de ISPs reais, tornando o tráfego indistinguível de um consumidor comum. A tabela abaixo compara os tipos de proxy para rastreamento na Amazon:

Para rastreamento de palavras-chave na Amazon, proxies residenciais com geo-targeting por país oferecem o melhor equilíbrio entre custo e confiabilidade. Veja as localizações disponíveis na ProxyHat.

Configuração do ProxyHat para Amazon SERP Scraping

A ProxyHat usa um gateway único (gate.proxyhat.com) com flags de geo-targeting e sessão no username. Para rastrear amazon.com (EUA), use -country-US. Para amazon.de (Alemanha), use -country-DE. Para paginação estável, adicione -session-{id}.

Formato do Proxy URL

# HTTP - amazon.com (EUA) com sessão sticky
http://user-country-US-session-amz001:pass@gate.proxyhat.com:8080

# HTTP - amazon.de (Alemanha)
http://user-country-DE-session-amz002:pass@gate.proxyhat.com:8080

# SOCKS5 - amazon.co.uk (Reino Unido)
socks5://user-country-GB-session-amz003:pass@gate.proxyhat.com:1080

A flag -session-{id} garante que todas as requisições de uma mesma sessão usem o mesmo IP. Isso é crítico para paginação: se o IP mudar entre página 1 e página 2, a Amazon pode retornar resultados diferentes, corrompendo o ranking.

Exemplo 1: Rastreamento Básico com curl_cffi

O curl_cffi é uma biblioteca Python que usa a engine do curl com TLS fingerprinting, imitando navegadores reais. Isso reduz bloqueios comparado ao requests padrão.

import re
import json
import time
from datetime import datetime
from curl_cffi import requests

# Configuração do proxy ProxyHat
PROXY_USER = "user-country-US-session-amz001"
PROXY_PASS = "sua_senha"
PROXY_URL = f"http://{PROXY_USER}:{PROXY_PASS}@gate.proxyhat.com:8080"

def fetch_amazon_search(keyword: str, page: int = 1, marketplace: str = "com") -> str:
    """Busca uma página de resultados da Amazon."""
    url = f"https://www.amazon.{marketplace}/s"
    params = {
        "k": keyword,
        "page": page,
        "ref": f"sr_pg_{page}"
    }
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
        "Accept-Language": "en-US,en;q=0.9",
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
    }
    
    try:
        response = requests.get(
            url,
            params=params,
            headers=headers,
            proxies={"http": PROXY_URL, "https": PROXY_URL},
            impersonate="chrome120",
            timeout=30
        )
        response.raise_for_status()
        return response.text
    except Exception as e:
        print(f"Erro ao buscar página {page}: {e}")
        return ""

def parse_search_results(html: str) -> list[dict]:
    """Extrai ASINs e posições da HTML da Amazon."""
    # Padrão para cada resultado de busca
    result_pattern = re.compile(
        r'data-component-type="s-search-result"[^>]*data-asin="([A-Z0-9]{10})"',
        re.DOTALL
    )
    
    # Detectar anúncios patrocinados
    sponsored_pattern = re.compile(r'(Sponsored|Patrocinado)', re.IGNORECASE)
    
    results = []
    organic_position = 0
    
    # Dividir HTML por blocos de resultado
    blocks = re.split(r'data-component-type="s-search-result"', html)
    
    for block in blocks[1:]:  # Pular o primeiro (antes do primeiro resultado)
        asin_match = re.search(r'data-asin="([A-Z0-9]{10})"', block)
        if not asin_match:
            continue
        
        asin = asin_match.group(1)
        is_sponsored = bool(sponsored_pattern.search(block[:2000]))
        
        if not is_sponsored:
            organic_position += 1
            results.append({
                "asin": asin,
                "organic_position": organic_position,
                "is_sponsored": False
            })
        else:
            results.append({
                "asin": asin,
                "organic_position": None,
                "is_sponsored": True
            })
    
    return results

def track_keyword_rank(keyword: str, target_asin: str, max_pages: int = 5) -> dict:
    """Rastreia a posição de um ASIN para uma palavra-chave."""
    all_results = []
    
    for page in range(1, max_pages + 1):
        html = fetch_amazon_search(keyword, page)
        if not html:
            continue
        
        if "captcha" in html.lower() or "robot" in html.lower():
            print(f"CAPTCHA detectado na página {page}!")
            break
        
        results = parse_search_results(html)
        all_results.extend(results)
        time.sleep(2)  # Rate limit: 1 req a cada 2 segundos
    
    # Encontrar posição do ASIN alvo
    target_position = None
    for r in all_results:
        if r["asin"] == target_asin and not r["is_sponsored"]:
            target_position = r["organic_position"]
            break
    
    return {
        "keyword": keyword,
        "target_asin": target_asin,
        "position": target_position,
        "is_indexed": target_position is not None,
        "timestamp": datetime.utcnow().isoformat(),
        "total_organic": sum(1 for r in all_results if not r["is_sponsored"])
    }

# Exemplo de uso
if __name__ == "__main__":
    result = track_keyword_rank("wireless earbuds", "B08N5WRWNW", max_pages=3)
    print(json.dumps(result, indent=2))

Exemplo 2: Rastreamento com Playwright e Sessões Sticky

Para casos onde o curl_cffi não é suficiente (JavaScript rendering, CAPTCHAs complexos), use Playwright com proxy. Este exemplo mantém uma sessão sticky para paginação estável:

import asyncio
import re
import json
from datetime import datetime
from playwright.async_api import async_playwright

PROXY_USER = "user-country-US-session-amz_play_001"
PROXY_PASS = "sua_senha"
PROXY_SERVER = "gate.proxyhat.com:8080"

async def fetch_amazon_page_playwright(keyword: str, page: int, target_asin: str):
    """Busca página da Amazon com Playwright e proxy residencial."""
    async with async_playwright() as p:
        browser = await p.chromium.launch(
            headless=True,
            proxy={
                "server": f"http://{PROXY_SERVER}",
                "username": PROXY_USER,
                "password": PROXY_PASS
            }
        )
        
        context = await browser.new_context(
            user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
            locale="en-US",
            viewport={"width": 1920, "height": 1080}
        )
        
        page_obj = await context.new_page()
        
        url = f"https://www.amazon.com/s?k={keyword}&page={page}"
        
        try:
            await page_obj.goto(url, wait_until="domcontentloaded", timeout=30000)
            await page_obj.wait_for_timeout(2000)
            
            # Verificar CAPTCHA
            content = await page_obj.content()
            if "captcha" in content.lower():
                print(f"CAPTCHA detectado na página {page}")
                await browser.close()
                return None
            
            # Extrair resultados
            results = await page_obj.evaluate("""() => {
                const items = document.querySelectorAll('[data-component-type="s-search-result"]');
                const data = [];
                let organicPos = 0;
                
                items.forEach(item => {
                    const asin = item.getAttribute('data-asin');
                    if (!asin) return;
                    
                    const text = item.textContent || '';
                    const isSponsored = /Sponsored|Patrocinado/i.test(text.substring(0, 500));
                    
                    if (!isSponsored) {
                        organicPos++;
                        data.push({
                            asin: asin,
                            organic_position: organicPos,
                            is_sponsored: false
                        });
                    } else {
                        data.push({
                            asin: asin,
                            organic_position: null,
                            is_sponsored: true
                        });
                    }
                });
                
                return data;
            }""")
            
            await browser.close()
            return results
            
        except Exception as e:
            print(f"Erro: {e}")
            await browser.close()
            return None

async def track_rank_playwright(keyword: str, target_asin: str, max_pages: int = 5):
    """Rastreia ranking com Playwright."""
    all_results = []
    
    for page in range(1, max_pages + 1):
        results = await fetch_amazon_page_playwright(keyword, page, target_asin)
        if results:
            all_results.extend(results)
        await asyncio.sleep(2)
    
    position = None
    for r in all_results:
        if r["asin"] == target_asin and not r["is_sponsored"]:
            position = r["organic_position"]
            break
    
    return {
        "keyword": keyword,
        "target_asin": target_asin,
        "position": position,
        "is_indexed": position is not None,
        "timestamp": datetime.utcnow().isoformat()
    }

# Executar
if __name__ == "__main__":
    result = asyncio.run(track_rank_playwright("bluetooth speaker", "B07DDKK7S9", max_pages=3))
    print(json.dumps(result, indent=2))

Exemplo 3: Uso Direto do Proxy (Raw) vs SDK ProxyHat

Veja como usar o proxy diretamente (raw HTTP) e via SDK ProxyHat lado a lado:

# --- RAW: Usando proxy diretamente com requests ---
import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

PROXY_RAW = "http://user-country-US-session-raw001:sua_senha@gate.proxyhat.com:8080"

def fetch_raw(keyword: str, page: int) -> str:
    session = requests.Session()
    retry = Retry(total=3, backoff_factor=1.5, status_forcelist=[429, 503])
    adapter = HTTPAdapter(max_retries=retry)
    session.mount("http://", adapter)
    session.mount("https://", adapter)
    
    resp = session.get(
        f"https://www.amazon.com/s?k={keyword}&page={page}",
        proxies={"http": PROXY_RAW, "https": PROXY_RAW},
        headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"},
        timeout=30
    )
    return resp.text

# --- SDK: Usando ProxyHat SDK (se disponível) ---
# O ProxyHat fornece um gateway HTTP/SOCKS5 padrão.
# Para uso programático, construa o proxy URL dinamicamente:

class ProxyHatClient:
    """Cliente wrapper para ProxyHat com rotação automática."""
    
    def __init__(self, username: str, password: str, country: str = "US"):
        self.username = username
        self.password = password
        self.country = country
        self.session_counter = 0
    
    def get_proxy_url(self, sticky: bool = True) -> str:
        """Retorna URL do proxy com sessão opcional."""
        user = f"{self.username}-country-{self.country}"
        if sticky:
            user += f"-session-{self.session_counter:06d}"
        return f"http://{user}:{self.password}@gate.proxyhat.com:8080"
    
    def new_session(self):
        """Inicia nova sessão (novo IP)."""
        self.session_counter += 1
    
    def fetch(self, url: str, headers: dict = None) -> str:
        """Faz requisição via proxy ProxyHat."""
        import requests
        proxy_url = self.get_proxy_url(sticky=True)
        resp = requests.get(
            url,
            proxies={"http": proxy_url, "https": proxy_url},
            headers=headers or {"User-Agent": "Mozilla/5.0"},
            timeout=30
        )
        return resp.text

# Uso comparativo
if __name__ == "__main__":
    # Raw
    html_raw = fetch_raw("laptop stand", 1)
    print(f"Raw: {len(html_raw)} bytes")
    
    # SDK wrapper
    client = ProxyHatClient("user", "sua_senha", country="US")
    html_sdk = client.fetch("https://www.amazon.com/s?k=laptop+stand&page=1")
    print(f"SDK: {len(html_sdk)} bytes")

Exemplo 4: Rastreamento Multi-Marketplace Concorrente

Para vendedores que operam em múltiplos marketplaces, rastrear concorrentemente reduz tempo de execução. Use asyncio com proxies geo-targeting por país:

import asyncio
import aiohttp
import json
from datetime import datetime

MARKETPLACES = {
    "com": {"country": "US", "lang": "en-US"},
    "de": {"country": "DE", "lang": "de-DE"},
    "co.uk": {"country": "GB", "lang": "en-GB"},
    "fr": {"country": "FR", "lang": "fr-FR"},
}

PROXY_BASE = "gate.proxyhat.com:8080"
PROXY_USER = "user"
PROXY_PASS = "sua_senha"

async def fetch_marketplace(session, keyword: str, marketplace: str, config: dict, target_asin: str):
    """Busca resultados de um marketplace específico."""
    proxy_user = f"{PROXY_USER}-country-{config['country']}-session-{marketplace.replace('.', '')}"
    proxy_url = f"http://{proxy_user}:{PROXY_PASS}@{PROXY_BASE}"
    
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
        "Accept-Language": config["lang"]
    }
    
    url = f"https://www.amazon.{marketplace}/s?k={keyword}&page=1"
    
    try:
        async with session.get(
            url,
            proxy=proxy_url,
            headers=headers,
            timeout=aiohttp.ClientTimeout(total=30)
        ) as resp:
            html = await resp.text()
            
            if "captcha" in html.lower():
                return {"marketplace": marketplace, "error": "CAPTCHA"}
            
            # Parse simples para posição
            import re
            blocks = re.split(r'data-component-type="s-search-result"', html)
            organic_pos = 0
            position = None
            
            for block in blocks[1:]:
                asin_match = re.search(r'data-asin="([A-Z0-9]{10})"', block)
                if not asin_match:
                    continue
                asin = asin_match.group(1)
                is_sponsored = bool(re.search(r'(Sponsored|Patrocinado|Gesponsert)', block[:2000]))
                
                if not is_sponsored:
                    organic_pos += 1
                    if asin == target_asin:
                        position = organic_pos
                        break
            
            return {
                "marketplace": marketplace,
                "keyword": keyword,
                "target_asin": target_asin,
                "position": position,
                "is_indexed": position is not None,
                "timestamp": datetime.utcnow().isoformat()
            }
    except Exception as e:
        return {"marketplace": marketplace, "error": str(e)}

async def track_multi_marketplace(keyword: str, target_asin: str):
    """Rastreia palavra-chave em todos os marketplaces concorrentemente."""
    async with aiohttp.ClientSession() as session:
        tasks = [
            fetch_marketplace(session, keyword, mp, config, target_asin)
            for mp, config in MARKETPLACES.items()
        ]
        results = await asyncio.gather(*tasks)
        return results

# Executar
if __name__ == "__main__":
    results = asyncio.run(track_multi_marketplace("phone case", "B08N5WRWNW"))
    for r in results:
        print(json.dumps(r, indent=2))

Exemplo 5: Agendamento Diário com Retries e Backoff

Em produção, você precisa de agendamento, retries com backoff exponencial e detecção de CAPTCHA. Este exemplo usa APScheduler e armazena histórico de posições:

import asyncio
import json
import logging
import sqlite3
from datetime import datetime
from apscheduler.schedulers.asyncio import AsyncIOScheduler
from curl_cffi import requests

# Configuração
PROXY_USER = "user-country-US"
PROXY_PASS = "sua_senha"
PROXY_URL = f"http://{PROXY_USER}:pass@gate.proxyhat.com:8080"

logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
logger = logging.getLogger(__name__)

# Palavras-chave e ASINs para rastrear
TRACKING_CONFIG = [
    {"keyword": "wireless earbuds", "asin": "B08N5WRWNW", "marketplace": "com"},
    {"keyword": "bluetooth speaker", "asin": "B07DDKK7S9", "marketplace": "com"},
    {"keyword": "laptop stand", "asin": "B07FZ8S74R", "marketplace": "com"},
]

# Inicializar banco de dados
def init_db():
    conn = sqlite3.connect("rank_history.db")
    conn.execute("""
        CREATE TABLE IF NOT EXISTS rank_history (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            keyword TEXT NOT NULL,
            asin TEXT NOT NULL,
            marketplace TEXT NOT NULL,
            position INTEGER,
            is_indexed BOOLEAN,
            timestamp TEXT NOT NULL
        )
    """)
    conn.commit()
    conn.close()

def save_result(result: dict):
    conn = sqlite3.connect("rank_history.db")
    conn.execute(
        "INSERT INTO rank_history (keyword, asin, marketplace, position, is_indexed, timestamp) VALUES (?, ?, ?, ?, ?, ?)",
        (result["keyword"], result["target_asin"], result.get("marketplace", "com"),
         result["position"], result["is_indexed"], result["timestamp"])
    )
    conn.commit()
    conn.close()

async def fetch_with_retry(keyword: str, page: int, max_retries: int = 3) -> str:
    """Fetch com retries e backoff exponencial."""
    for attempt in range(max_retries):
        try:
            session_id = f"amz_{datetime.now().strftime('%Y%m%d')}_{page}"
            proxy_user = f"user-country-US-session-{session_id}"
            proxy_url = f"http://{proxy_user}:{PROXY_PASS}@gate.proxyhat.com:8080"
            
            resp = requests.get(
                f"https://www.amazon.com/s?k={keyword}&page={page}",
                proxies={"http": proxy_url, "https": proxy_url},
                headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"},
                impersonate="chrome120",
                timeout=30
            )
            
            if resp.status_code == 200 and "captcha" not in resp.text.lower():
                return resp.text
            elif "captcha" in resp.text.lower():
                logger.warning(f"CAPTCHA na página {page}, tentativa {attempt + 1}")
                await asyncio.sleep(60)  # Espera longa para CAPTCHA
            else:
                logger.warning(f"Status {resp.status_code}, tentativa {attempt + 1}")
                await asyncio.sleep(2 ** attempt)  # Backoff exponencial: 1s, 2s, 4s
                
        except Exception as e:
            logger.error(f"Erro: {e}, tentativa {attempt + 1}")
            await asyncio.sleep(2 ** attempt)
    
    return ""

async def track_keyword(keyword: str, target_asin: str, marketplace: str = "com"):
    """Rastreia uma palavra-chave e salva no banco."""
    import re
    
    all_results = []
    for page in range(1, 6):
        html = await fetch_with_retry(keyword, page)
        if not html:
            continue
        
        blocks = re.split(r'data-component-type="s-search-result"', html)
        organic_pos = 0
        
        for block in blocks[1:]:
            asin_match = re.search(r'data-asin="([A-Z0-9]{10})"', block)
            if not asin_match:
                continue
            asin = asin_match.group(1)
            is_sponsored = bool(re.search(r'(Sponsored|Patrocinado)', block[:2000]))
            
            if not is_sponsored:
                organic_pos += 1
                all_results.append({"asin": asin, "position": organic_pos})
        
        await asyncio.sleep(2)  # Rate limit
    
    position = None
    for r in all_results:
        if r["asin"] == target_asin:
            position = r["position"]
            break
    
    result = {
        "keyword": keyword,
        "target_asin": target_asin,
        "marketplace": marketplace,
        "position": position,
        "is_indexed": position is not None,
        "timestamp": datetime.utcnow().isoformat()
    }
    
    save_result(result)
    logger.info(f"{keyword} -> ASIN {target_asin}: posição {position}")
    return result

async def daily_tracking_job():
    """Job diário que rastreia todas as palavras-chave configuradas."""
    logger.info("Iniciando rastreamento diário...")
    for config in TRACKING_CONFIG:
        await track_keyword(config["keyword"], config["asin"], config["marketplace"])
        await asyncio.sleep(5)  # Pausa entre keywords
    logger.info("Rastreamento diário concluído.")

async def main():
    init_db()
    scheduler = AsyncIOScheduler()
    # Executa diariamente às 09:00 UTC
    scheduler.add_job(daily_tracking_job, "cron", hour=9, minute=0)
    scheduler.start()
    logger.info("Scheduler iniciado. Pressione Ctrl+C para parar.")
    
    # Executar imediatamente na primeira vez
    await daily_tracking_job()
    
    try:
        while True:
            await asyncio.sleep(3600)
    except (KeyboardInterrupt, SystemExit):
        scheduler.shutdown()

if __name__ == "__main__":
    asyncio.run(main())

Erros Comuns e Casos Limítrofes

1. Não Separar Anúncios Sponsored de Resultados Orgânicos

Se você contar anúncios como posições orgânicas, seus dados estarão inflacionados. Sempre verifique o rótulo "Sponsored" / "Patrocinado" / "Gesponsert" / "Sponsorisé" dependendo do marketplace.

2. Trocar de IP Entre Páginas

Sem sessões sticky (-session-{id}), cada página pode vir de um IP diferente, resultando em conjuntos de produtos inconsistentes. Use a mesma session-id para todas as páginas de uma keyword.

3. Não Verificar Indexação

Antes de rastrear posição, verifique se o ASIN está indexado para aquela keyword. Se position is None após 5 páginas, o ASIN pode não estar ranqueando — investigue antes de assumir erro de scraping.

4. Ignorar Localização do Marketplace

Resultados em amazon.com com IP dos EUA diferem de amazon.com com IP do Brasil. Se você rastreia amazon.de, use -country-DE. Veja todas as localizações suportadas.

5. Rate Limiting Insuficiente

A Amazon bloqueia após ~50-100 requisições por hora por IP. Mantenha 1-2 requisições por segundo com sleeps entre páginas e entre keywords.

Dicas de Produção

• Agendamento: rode rastreamento 1-2x por dia. Mais frequente aumenta risco de bloqueio sem agregar valor (posições mudam lentamente).
• Retries com backoff: use backoff exponencial (1s, 2s, 4s, 8s) para erros 429 e 503.
• Detecção de CAPTCHA: verifique strings como "captcha", "robot", "Type the characters" no HTML.
• Circuit breaker: se mais de 30% das requisições falharem em 10 minutos, pause por 1 hora.
• Logging estruturado: registre keyword, ASIN, marketplace, posição, timestamp e proxy session-id para debug.
• Monitoramento de indexação: se um ASIN antes ranqueado desaparecer por 3+ dias, verifique se a listagem foi suspensa.
• Rotação de User-Agents: use 3-5 UAs diferentes para evitar fingerprinting.

Considerações Éticas e Legais

1. Rastreie apenas listagens próprias ou dados públicos. Não rastreie dados privados de concorrentes além do que é visível publicamente.
2. Respeite o robots.txt da Amazon. Verifique https://www.amazon.com/robots.txt antes de scraping.
3. Throttle responsável: limite a 1-2 requisições por segundo por sessão.
4. Considere a SP-API: a Amazon SP-API oferece endpoints oficiais para dados de vendas e catalog. Para dados de ranking, scraping pode ser necessário, mas sempre verifique alternativas oficiais primeiro.
5. GDPR: se você coleta dados pessoais de usuários da UE (reviews com nomes, por exemplo), precisa de base legal. Para rastreamento de ranking (ASINs e posições), geralmente não há dados pessoais envolvidos.

Para mais casos de uso de scraping, veja nossa página de web scraping e rastreamento de SERP. Para detalhes de preços de proxies, consulte nossos planos. A documentação técnica completa está em docs.proxyhat.com.

Pontos-Chave

Resumo prático:

• Use proxies residenciais com geo-targeting por país (-country-US, -country-DE) para resultados localizados corretos.
• Sessões sticky (-session-{id}) são obrigatórias para paginação estável.
• Sempre separe anúncios Sponsored de resultados orgânicos ao calcular posição.
• Limite a 1-2 requisições por segundo e implemente retries com backoff exponencial.
• Verifique indexação: se o ASIN não aparece em 5 páginas, pode não estar ranqueando.
• Considere a SP-API da Amazon como alternativa oficial quando disponível.
• Armazene histórico de posições em banco de dados para análise de tendências.

FAQ

O que é rastreamento de palavras-chave da Amazon com proxies?

É a prática de monitorar a posição orgânica de um ASIN nos resultados de busca da Amazon para palavras-chave específicas, usando proxies residenciais para contornar bloqueios anti-bot e acessar dados de diferentes marketplaces sem ser detectado.

Por que o rastreamento de palavras-chave da Amazon com proxies importa para usuários de proxy?

A Amazon aplica limites rigorosos de taxa e localização por marketplace. Proxies residenciais permitem acessar resultados localizados (amazon.com, amazon.de) sem bloqueios, garantindo dados de ranking precisos para otimização de listagens e estratégias de PPC.

Qual tipo de proxy funciona melhor para rastreamento de palavras-chave da Amazon?

Proxies residenciais com geo-targeting por país são ideais porque a Amazon filtra resultados por localização. Para paginação estável, use sessões sticky (session-ids) para manter o mesmo IP entre requisições e evitar variações de ranking.

Como evitar bloqueios ao implementar rastreamento de palavras-chave da Amazon com proxies?

Use proxies residenciais rotativos, limite a taxa de requisições (1-2 por segundo), implemente retries com backoff exponencial, detecte CAPTCHAs, respeite robots.txt e considere a SP-API da Amazon para dados oficiais quando disponível.