Como Raspar Dados de Produtos e Preços do Temu em 2026 (Proxies, Anti-Bot e o JSON Oculto)

Raspar Temu em 2026 é um desafio técnico que separa amadores de engenheiros de dados experientes. A plataforma não oferece API pública, o que força uma escolha imediata: parsear HTML volátil com classes CSS hasheadas ou explorar os endpoints JSON internos como /api/poppy/v1/search e /api/poppy/v1/review/goods-detail. Se você precisa construir um scraper de preços Temu confiável, essa decisão define toda a arquitetura do seu pipeline.

Neste guia, vamos cobrir o stack anti-bot do Temu (Cloudflare Turnstile, assinatura anti_content e fingerprinting TLS/HTTP2), onde encontrar os dados, os limites reais de taxa, e como usar proxies residenciais com geo-targeting de cidade através do ProxyHat para manter a consistência de preços regionais. Ao final, você terá um exemplo Python funcional com curl_cffi e a documentação do ProxyHat.

Por que raspar Temu é diferente de outros e-commerces

O Temu é operado pela PDD Holdings, a mesma empresa por trás do Pinduoduo. Isso significa que a infraestrutura herda técnicas de defesa anti-scraping desenvolvidas para o mercado chinês, onde ataques de scraping são ordens de magnitude mais intensos. O resultado é uma combinação de proteções que vai muito além de um simples rate-limiter.

A primeira decisão é API vs HTML. O Temu renderiza páginas no servidor (SSR) com Next.js, mas os dados de produto — preço, SKUs, imagens, avaliações — são servidos por endpoints JSON internos que o navegador chama via XHR/fetch. Parsear o HTML dos cards de produto é frágil: classes CSS como _2qjFLG mudam a cada deploy, e atributos como data-uniqid são usados para tracking interno, não como âncoras estáveis. Por outro lado, os endpoints JSON retornam estruturas previsíveis com campos como goods_id, goods_price, sku_list e sale_price.

A regra prática: use HTML apenas para descoberta de URLs de produto (links canônicos, sitemaps) e use os endpoints JSON para extração de dados estruturados. Isso reduz drasticamente a manutenção do scraper.

O stack anti-bot do Temu em detalhe

O Temu usa múltiplas camadas de proteção que você precisa entender antes de escrever uma única linha de código:

• Cloudflare Turnstile + Bot Management: O Temu está por trás da rede da Cloudflare, que faz fingerprinting de TLS (JA3/JA4), análise de HTTP/2 (Akamai fingerprint, header order) e challenge JavaScript. IPs de datacenter são flagged quase instantaneamente — a taxa de bloqueio pode exceder 90% em intervalos de poucos minutos.
• Cabeçalho anti_content: Este é o mecanismo mais agressivo. O Temu gera um token assinado no cliente via JavaScript ofuscado, que codifica informações do navegador, timestamps e um nonce. Sem um anti_content válido, a maioria dos endpoints JSON retorna errno: 40001 ou 40002. Reproduzir esse token fora do navegador é extremamente difícil — ele envolve VM obfuscada e checksums dinâmicos.
• Fingerprinting TLS/HTTP2: Bibliotecas como requests e httpx (sem customização) produzem fingerprints TLS que não correspondem a navegadores reais. A Cloudflare detecta isso e aplica challenges silenciosos (403 sem corpo) ou CAPTCHAs interativos.
• Rate limiting por IP e por sessão: Mesmo com tokens válidos, o Temu limita aggressively requests repetidos do mesmo IP. Observamos throttling após aproximadamente 30-50 requests/min por IP residencial, com bloqueio temporário após ~100 requests em janelas de 5 minutos.

A boa notícia: o Temu não exige anti_content para todas as rotas. Páginas de produto públicas (HTML SSR) e alguns endpoints de listagem retornam dados sem o token, desde que o IP seja confiável e o fingerprint TLS corresponda a um navegador real. É aqui que curl_cffi e proxies residenciais entram.

Onde encontrar os dados: JSON embutido e endpoints internos

Existem três fontes principais de dados no Temu, cada uma com vantagens e desvantagens:

Fonte	Estabilidade	Dados disponíveis	Requer anti_content
HTML SSR (página de produto)	Média — classes hasheadas mudam	Título, preço, imagens, descrição	Não (mas Cloudflare pode challenge)
JSON embutido em <script id="__NEXT_DATA__"> ou blob similar	Alta — estrutura JSON estável	goods_id, price, sku_list, reviews count	Não (vem com o HTML)
Endpoint /api/poppy/v1/search	Alta — resposta JSON documentada	Lista de produtos, preços, ratings	Sim (na maioria dos casos)
Endpoint /api/poppy/v1/review/goods-detail	Alta	SKUs, preços por variante, estoque	Sim

O blob JSON embutido

Quando você carrega uma página de produto como https://www.temu.com/products-p1-{goods_id}.html, o HTML inclui um bloco <script> com dados serializados. No Temu, isso não é exatamente o __NEXT_DATA__ padrão do Next.js — é um objeto JSON injetado em uma tag script com um ID variável, mas a estrutura é semelhante. Procure por padrões como window.__INITIAL_STATE__ ou objetos JSON grandes dentro de tags <script type="application/json">.

Para extrair, use uma regex ou um parser HTML como BeautifulSoup:

import re, json
from bs4 import BeautifulSoup

# html = conteúdo da página de produto
soup = BeautifulSoup(html, "html.parser")
script_tags = soup.find_all("script", type="application/json")
for tag in script_tags:
    try:
        data = json.loads(tag.string)
        if "goods" in str(data).lower():
            print(json.dumps(data, indent=2)[:500])
    except (json.JSONDecodeError, TypeError):
        continue

Os campos mais úteis dentro desse blob são goods_id, goods_name, goods_price (preço de lista), sale_price (preço promocional), sku_list (variantes com preços individuais), eval_info (número de avaliações e rating médio) e mall_id (identificador do vendedor).

Endpoints JSON internos

Para listagens de busca e categoria, o Temu usa /api/poppy/v1/search. O navegador faz POST requests com um corpo JSON contendo keyword, page, pageSize e o famoso anti_content. A resposta inclui um array de produtos com preços, imagens em miniatura e URLs.

Para detalhes de SKU, o endpoint /api/poppy/v1/review/goods-detail (ou variações como /api/poppy/v1/mall/goods-detail) retorna informações completas de variantes, estoque estimado e preços por SKU. Sem um anti_content válido, estes endpoints retornam erro. A estratégia mais sustentável é extrair dados do blob JSON embutido no HTML da página de produto, que não requer o token.

Limites de taxa e por que proxies residenciais com geo-city são obrigatórios

O Temu é uma plataforma com preços dinâmicos regionais. O preço de um produto em US$ 4,98 pode variar para US$ 5,49 ou ter frete grátis em um estado e frete pago em outro. Isso acontece porque o Temu calcula custos de envio, impostos e promoções locais dinamicamente. Se você raspa de um IP em Oregon mas precisa de preços para a Califórnia, os dados serão inconsistentes.

Por isso, proxies residenciais com geo-targeting de país e cidade são obrigatórios. Proxies de datacenter são bloqueados em minutos pela Cloudflare. Proxies residenciais, por outro lado, aparecem como tráfego de ISPs reais (Comcast, AT&T, Verizon) e têm taxa de sucesso dramaticamente maior.

Observamos os seguintes limites práticos com proxies residenciais:

• 30-50 requests/min por IP residencial antes de throttling suave (latência aumentada, respostas 429 intermitentes).
• ~100 requests em 5 minutos antes de bloqueio temporário (geralmente 15-30 minutos de cooldown).
• 5-10 requests/segundo com um pool de 50+ IPs residenciais rotativos, mantendo taxa de sucesso acima de 95%.

Com o ProxyHat, você pode especificar geo-targeting diretamente no username do proxy, o que garante que cada request saia de um IP na região correta:

# Proxy residencial nos EUA, cidade específica
http://user-country-US-city-newyork:pass@gate.proxyhat.com:8080

# Proxy residencial na Alemanha
http://user-country-DE-city-berlin:pass@gate.proxyhat.com:8080

Consulte a página de localizações do ProxyHat para a lista completa de países e cidades suportados.

Exemplo Python: raspagem de página de produto com curl_cffi e ProxyHat

A biblioteca curl_cffi é essencial porque usa libcurl com impersonação de TLS, o que significa que o fingerprint JA3/JA4 do request corresponde ao de um Chrome ou Firefox real. Isso é o que contorna a detecção TLS da Cloudflare sem precisar de um headless browser.

Instale as dependências:

pip install curl_cffi beautifulsoup4

Agora, o código completo para raspar uma página de produto do Temu:

import json, re, time, random
from curl_cffi import requests as cffi_requests
from bs4 import BeautifulSoup

# Configuração do proxy ProxyHat — residencial, EUA, Nova York
PROXY = "http://user-country-US-city-newyork:pass@gate.proxyhat.com:8080"

PRODUCT_URL = "https://www.temu.com/products-p1-0019010325.html"

HEADERS = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                  "AppleWebKit/537.36 (KHTML, like Gecko) "
                  "Chrome/124.0.0.0 Safari/537.36",
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
    "Accept-Language": "en-US,en;q=0.9",
    "Accept-Encoding": "gzip, deflate, br",
    "Referer": "https://www.temu.com/",
}

def fetch_product(url, proxy=PROXY):
    session = cffi_requests.Session(impersonate="chrome124")
    resp = session.get(
        url,
        headers=HEADERS,
        proxies={"http": proxy, "https": proxy},
        timeout=30,
    )
    if resp.status_code != 200:
        print(f"Erro: {resp.status_code}")
        return None
    return resp.text

def parse_embedded_json(html):
    soup = BeautifulSoup(html, "html.parser")
    script_tags = soup.find_all("script")
    for tag in script_tags:
        text = tag.string or tag.get_text()
        if text and "goods_id" in text:
            # Tenta extrair o JSON do conteúdo do script
            match = re.search(r'\{.*?"goods_id".*?\}', text, re.DOTALL)
            if match:
                try:
                    return json.loads(match.group())
                except json.JSONDecodeError:
                    continue
    return None

html = fetch_product(PRODUCT_URL)
if html:
    data = parse_embedded_json(html)
    if data:
        # Extrai campos-chave
        product = {
            "goods_id": data.get("goods_id"),
            "goods_name": data.get("goods_name"),
            "goods_price": data.get("goods_price"),
            "sale_price": data.get("sale_price"),
            "sku_list": [
                {"sku_id": s.get("sku_id"), "price": s.get("price")}
                for s in data.get("sku_list", [])
            ],
        }
        print(json.dumps(product, indent=2, ensure_ascii=False)[:800])

Um exemplo de resposta truncada seria:

{
  "goods_id": "0019010325",
  "goods_name": "Wireless Bluetooth Earbuds, Noise Cancelling",
  "goods_price": {"amount": 12.98, "currency": "USD"},
  "sale_price": {"amount": 4.98, "currency": "USD"},
  "sku_list": [
    {"sku_id": "sku_001", "price": {"amount": 4.98, "currency": "USD"}},
    {"sku_id": "sku_002", "price": {"amount": 5.49, "currency": "USD"}}
  ]
}

Note que a estrutura exata pode variar — o Temu atualiza o schema do JSON periodicamente. Sempre valide os campos com .get() e trate None graciosamente.

Sessões sticky, retries e paginação

Para fluxos que exigem consistência — como simular navegação de busca com paginação, ou verificar preços de frete no carrinho — você precisa de sessões sticky. Sem elas, cada request sai de um IP diferente, e o Temu pode interpretar isso como comportamento anômalo, especialmente se houver tokens de sessão nos cookies.

Com o ProxyHat, sessões sticky são controladas via o flag -session- no username:

# Sessão sticky — mesmo IP por toda a duração da sessão
http://user-session-temu-pipeline-001-country-US:pass@gate.proxyhat.com:8080

Use o mesmo identificador de sessão para todos os requests de uma sequência lógica (ex: página 1, 2 e 3 de uma busca). Quando quiser rotar para um novo IP, mude o identificador.

Estratégia de retries

Implemente retries com backoff exponencial e rotação de IP em cada tentativa:

import time

def fetch_with_retry(url, max_retries=5):
    for attempt in range(max_retries):
        session_id = f"temu-retry-{attempt}-{int(time.time())}"
        proxy = f"http://user-session-{session_id}-country-US:pass@gate.proxyhat.com:8080"
        try:
            html = fetch_product(url, proxy=proxy)
            if html and "goods_id" in html:
                return html
        except Exception as e:
            print(f"Tentativa {attempt} falhou: {e}")
        time.sleep(2 ** attempt + random.uniform(0, 1))
    return None

Paginação de busca

Para listar produtos de uma categoria ou busca, a abordagem mais robusta é iterar sobre páginas HTML (ex: ?page=2, ?page=3) e extrair os goods_id dos links de produto. Cada página pode ter 30-60 produtos. Com 50 IPs residenciais e 5 requests/segundo, você pode coletar ~18.000 produtos por hora. Veja mais estratégias de scraping em larga escala no nosso guia de web scraping.

Para monitoramento contínuo de preços em SERPs, consulte também nosso caso de uso de SERP tracking.

Erros comuns e edge cases

• Usar requests ou httpx puro: O fingerprint TLS não corresponde a um navegador real. Use curl_cffi com impersonate="chrome124" ou similar.
• Ignorar o Referer e Accept-Language: O Temu verifica se esses headers são consistentes com a geo do IP. Um IP nos EUA com Accept-Language: zh-CN é um sinal vermelho imediato.
• Não respeitar cooldowns: Após um 403 ou 429, não continue batendo no mesmo IP. Faça rotação e espere 15-30 minutos antes de reusar aquele IP.
• Tentar reproduzir anti_content do zero: É possível, mas exige engenharia reversa profunda da VM JavaScript do Temu. Para a maioria dos casos de uso, o blob JSON embutido no HTML é suficiente e muito mais sustentável.
• Esquecer que preços variam por região: Sempre documente qual região cada batch de dados representa. Misturar preços de diferentes estados sem metadados geo torna o dataset inútil para price intelligence.

Ética, Termos de Serviço e considerações legais

Raspar dados de catálogo público é uma área legalmente cinzenta. Nos EUA, o Computer Fraud and Abuse Act (CFAA) tem sido interpretado de forma cada vez mais restritiva contra scrapers que acessam sistemas sem autorização explícita. O caso hiQ Labs v. LinkedIn estabeleceu alguns precedentes a favor de scraping de dados públicos, mas a situação permanece fluida. Na UE, a GDPR se aplica a qualquer dado pessoal — avaliações de usuários, nomes de reviewers, fotos de perfil — que você possa coletar incidentalmente.

Práticas recomendadas:

• Colete apenas dados de catálogo público: preços, títulos, imagens de produto, specs. Não raspe dados de usuários (reviews com nomes, fotos de perfil, histórico de compras).
• Não raspe atrás de login: Se precisa de dados que só aparecem autenticado (preços de membro, histórico de pedidos), pare. Isso viola os Termos de Serviço do Temu e potencialmente o CFAA.
• Respeite robots.txt: Verifique https://www.temu.com/robots.txt antes de qualquer coleta. Mesmo que não seja legalmente vinculante em todas as jurisdições, é um sinal de boa-fé.
• Considere o Merchant Feed oficial: Se você é um vendedor ou parceiro do Temu, o Seller Center do Temu oferece feeds de produto via API. Para price intelligence competitivo, no entanto, não há alternativa ao scraping.
• Rate limiting responsável: Mantenha sua taxa de requests abaixo dos limites observados e não degrade a experiência de outros usuários. A FTC e reguladores da UE têm se interessado cada vez mais por práticas de scraping em larga escala.

Regra de ouro: Se os dados estão visíveis para qualquer visitante anônimo em um navegador normal, raspar via proxy residencial com rate-limiting responsável é defensável. Se precisa de login, cookies de sessão de conta, ou contorna CAPTCHAs ativamente, você está em território de risco.

Configuração do ProxyHat para raspagem do Temu

O ProxyHat oferece proxies residenciais, mobile e datacenter. Para o Temu, use exclusivamente proxies residenciais com geo-targeting de país e, quando possível, cidade. Veja os planos na página de preços do ProxyHat.

Configuração recomendada:

• Tipo: Residencial
• Geo: -country-US (ou país alvo), -city-newyork para máxima consistência regional
• Rotação: Per-request para descoberta de URLs; sticky (-session-) para paginação e fluxos multi-step
• Porta: 8080 (HTTP) ou 1080 (SOCKS5)
• Concorrência: 50-100 sessões simultâneas para um pipeline de médio porte

Exemplo com SOCKS5:

socks5://user-country-US-city-chicago:pass@gate.proxyhat.com:1080

Principais conclusões

• Prefira JSON embutido a HTML parsing: O blob JSON dentro das tags <script> da página de produto é a fonte mais estável e não requer anti_content.
• Use curl_cffi com impersonação Chrome: É a única forma prática de contornar o fingerprinting TLS da Cloudflare sem um headless browser completo.
• Proxies residenciais com geo-city são obrigatórios: Proxies de datacenter são bloqueados em minutos; sem geo-targeting, os preços são inconsistentes entre regiões.
• Mantenha-se abaixo de 50 req/min por IP: Use um pool de 50+ IPs e rotacione com sessões sticky para fluxos multi-step.
• Colete apenas catálogo público: Não raspa atrás de login, não coleta dados pessoais de reviews, e respeita robots.txt e os limites de taxa.

Com essa arquitetura — curl_cffi + ProxyHat residencial com geo-city + extração de JSON embutido — você pode manter um pipeline de price intelligence do Temu com 95%+ de taxa de sucesso, baixa manutenção e cobertura regional consistente. Para começar, confira os planos do ProxyHat e a documentação técnica.