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

Raspar dados de produtos e preços do Temu em 2026 é um desafio técnico que combina engenharia reversa de endpoints JSON, bypass de fingerprinting TLS/HTTP2 e uso estratégico de proxies residenciais com geo-targeting de cidade. Se a sua equipe de price intelligence precisa monitorar catálogo, SKUs e variações de preço do Temu em escala, este guia mostra exatamente como implementar um Temu price scraper de produção — do trade-off entre HTML e JSON até código Python pronto com curl_cffi e proxies ProxyHat.

Antes de mergulhar: o Temu não tem API pública. Tudo o que discutimos aqui envolve acessar endpoints internos ou fazer parsing de HTML de páginas públicas. Mantenha-se no catálogo público, respeite robots.txt e os Termos de Serviço, e evite qualquer scraping de contas ou dados pessoais.

API vs HTML: O Trade-off Central para Raspar o Temu

Quando você decide raspar Temu, a primeira decisão é de onde extrair os dados. Existem duas vias principais, cada uma com vantagens e armadilhas distintas.

Via 1: Parsing de HTML das páginas de produto e listing

A abordagem mais óbvia é carregar a página HTML de um produto (ex.: https://www.temu.com/goods.html) ou de uma busca, e fazer parsing dos cards de produto. O problema é que o Temu usa classes CSS hasheadas que mudam a cada deploy — _3kQ2H hoje pode ser _7mX1p amanhã. Além disso, os dados de preço frequentemente são renderizados via JavaScript client-side, então o HTML estático não contém os valores finais.

Vantagens do HTML:

• Não depende de tokens anti_content assinados.
• Simples de prototipar com BeautifulSoup ou Parsel.

Desvantagens:

• Classes CSS voláteis que quebram seletores a cada semana.
• Preços e SKUs podem não estar no HTML server-side.
• Requer renderização JavaScript (Playwright/Puppeteer), o que aumenta custo e latência em 3-5x.

Via 2: Endpoints JSON internos — a API de dados de produtos Temu oculta

O Temu é uma aplicação Next.js-like que carrega dados via endpoints JSON internos. Os mais relevantes são:

• /api/poppy/v1/search — retorna resultados de busca com goods_id, título, preço, imagem e SKU básico.
• Endpoints de detalhe de produto (variam, mas seguem o padrão /api/poppy/v1/goods/detail) — retornam SKU completo, variações, preço por região e info de frete.

Estes endpoints retornam JSON estruturado, muito mais estável que HTML. Mas há um catch: a maioria exige um header anti_content — um token assinado gerado client-side por código ofuscado JavaScript. Sem ele, você recebe HTTP 403 ou um payload vazio.

Recomendação prática: Para price intelligence em escala, prefira os endpoints JSON. Use HTML parsing apenas como fallback ou para descoberta inicial de URLs de produto. A estabilidade do JSON supera a volatilidade do HTML por uma margem enorme.

Também é possível extrair um blob de estado embarcado na página HTML. O Temu inclui um objeto JSON serializado dentro de uma tag <script> — similar ao __NEXT_DATA__ do Next.js — que contém os dados do produto já resolvidos. Esse blob é útil porque não exige o token anti_content, mas sua estrutura muda entre páginas de busca e páginas de produto.

A Stack Anti-Bot do Temu em 2026

O Temu é protegido por uma combinação de tecnologias anti-bot que tornam proxies de datacenter quase inúteis. Entender cada camada é essencial para projetar um scraper que sobreviva.

1. Cloudflare Turnstile

O Temu usa Cloudflare Turnstile como gateway WAF e challenge inicial. Turnstile analisa comportamento do navegador, fingerprints de TLS e padrões de tráfego. Ao detectar um IP de datacenter, ele pode exigir um challenge interativo ou simplesmente retornar 403. IPs residenciais passam com muito mais frequência porque Cloudflare os classifica como tráfego legítimo de consumidor.

2. Token anti_content assinado

O header anti_content é o coração da proteção de API do Temu. É uma string base64 gerada por JavaScript ofuscado que embute timestamps, parâmetros de requisição e um hash de fingerprint do navegador. Tentar reproduzi-lo server-side é extremamente difícil — o código de geração muda frequentemente e usa técnicas de anti-debugging.

Estratégias para lidar com o anti_content:

• Extrair da página HTML: carregue a página de produto com Playwright, intercepte o token gerado e reutilize-o por alguns minutos.
• Replay de token: tokens têm validade curta (estimada em 5-15 minutos), mas podem ser reutilizados em múltiplas requisições dentro dessa janela.
• Emulação completa: bibliotecas como curl_cffi com perfil de Chrome imitam o fingerprint TLS, mas não geram o anti_content automaticamente.

3. Fingerprinting TLS/HTTP2

O Temu (via Cloudflare) inspeciona o JA3/JA4 fingerprint da conexão TLS e o fingerprint HTTP2. Bibliotecas HTTP padrão como requests ou httpx produzem fingerprints que não correspondem a nenhum navegador real, resultando em bloqueio imediato. curl_cffi resolve isso ao usar a engine libcurl com impersonação de Chrome ou Firefox, produzindo um handshake TLS idêntico ao do navegador real.

Localizando os Dados: Endpoints JSON, Blob de Estado e Atributos data-uniqid

Para construir um scraper de produtos Temu funcional, você precisa saber exatamente onde os dados estão. Aqui está o mapa.

Endpoints JSON internos

O endpoint de busca principal é:

GET https://www.temu.com/api/poppy/v1/search?scene=search&keyword=PHONE_CASE&page=1&pageSize=20

Parâmetros-chave:

• keyword — termo de busca.
• page e pageSize — paginação (máximo 50 por página em observações empíricas).
• scene — contexto da busca (search, recommend, etc.).

Headers obrigatórios típicos:

Host: www.temu.com
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) ...
Accept: application/json, text/plain, */*
anti_content: <token_base64>
Referer: https://www.temu.com/search_result.html?search_key=PHONE_CASE

Atributos data-uniqid e classes CSS hasheadas

Nas páginas HTML, cada card de produto carrega um atributo data-uniqid contendo o goods_id. Este atributo é estável entre deploys, ao contrário das classes CSS. Use-o como âncora para localizar cards:

// XPath estável para cards de produto
//div[@data-uniqid]

Para o blob de estado embarcado, procure por uma tag <script> cujo conteúdo começa com window.__INITIAL_STATE__ ou similar. O JSON dentro contém a árvore de dados da página atual, incluindo preços resolvidos e lista de SKUs.

Exemplo de resposta truncada do endpoint de busca

{
  "data": {
    "list": [
      {
        "goods_id": "501299873451",
        "goods_name": "Capa Silicone iPhone 15 Pro",
        "goods_price": {
          "amount": 4.99,
          "currency": "USD",
          "symbol": "$"
        },
        "image_url": "https://img.kwcdn.com/...",
        "sku_list": [
          {
            "sku_id": "sku_8821",
            "spec": "Preto",
            "price": { "amount": 4.99 }
          },
          {
            "sku_id": "sku_8822",
            "spec": "Azul",
            "price": { "amount": 5.49 }
          }
        ],
        "sales": 12847,
        "shipping_info": {
          "free_shipping": true,
          "estimated_days": "5-8"
        }
      }
      // ... mais 19 itens
    ],
    "total": 3421,
    "has_more": true
  },
  "success": true,
  "errorCode": 0
}

Este é o formato ideal para alimentar um pipeline de price intelligence — estruturado, com goods_id como chave primária e SKUs aninhados.

Limites de Rate e Por Que Proxies Residenciais com Geo-City São Obrigatórios

O Temu aplica rate limiting agressivo. Observações empíricas indicam:

• ~3-5 requisições/min por IP antes de receber 429 ou challenge Turnstile.
• ~50-80 requisições/min por subnet antes de bloqueio de range.
• Após um bloqueio, o cooldown do IP dura tipicamente 24 horas.

Isso significa que para raspar 10.000 produtos, você precisa de pelo menos 200-300 IPs únicos com rotação, assumindo 2 requisições/s por IP e margem de segurança.

Por que geo-targeting de cidade importa

O Temu personaliza preços, fretes e promoções por região. Um produto pode custar $4.99 com frete grátis para um IP em Los Angeles, mas $5.49 com frete de $1.99 para um IP em Berlim. Se a sua equipe monitora preços no mercado americano, usar IPs de datacenter ou residenciais de outro país produz dados incorretos.

Com ProxyHat, você especifica geo-targeting no próprio username:

# IP residencial nos EUA
http://user-country-US:pass@gate.proxyhat.com:8080

# IP residencial em Berlim, Alemanha
http://user-country-DE-city-berlin:pass@gate.proxyhat.com:8080

# IP residencial em Nova York, EUA
http://user-country-US-city-newyork:pass@gate.proxyhat.com:8080

Para price intelligence nos EUA, padronize em -country-US ou uma cidade específica como -country-US-city-newyork. Veja todas as localizações disponíveis em nossa página de locations.

Exemplo Prático em Python: curl_cffi + ProxyHat

Aqui está um exemplo funcional de um Temu price scraper que combina curl_cffi (para fingerprint TLS de Chrome) com proxies residenciais ProxyHat.

from curl_cffi import requests as cffi_requests
import json
import time
import random

# Configuração do proxy ProxyHat — residencial, geo EUA
PROXY_URL = "http://user-country-US:YOUR_PASSWORD@gate.proxyhat.com:8080"

# Headers realistas
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": "application/json, text/plain, */*",
    "Accept-Language": "en-US,en;q=0.9",
    "Referer": "https://www.temu.com/",
    # anti_content deve ser obtido via Playwright ou extraído da página
    # "anti_content": "BASE64_TOKEN_HERE",
}

def fetch_search_results(keyword: str, page: int = 1, page_size: int = 20):
    """Busca produtos no Temu via endpoint JSON interno."""
    url = "https://www.temu.com/api/poppy/v1/search"
    params = {
        "scene": "search",
        "keyword": keyword,
        "page": page,
        "pageSize": page_size,
    }

    session = cffi_requests.Session(impersonate="chrome124")
    proxies = {"http": PROXY_URL, "https": PROXY_URL}

    resp = session.get(
        url,
        params=params,
        headers=HEADERS,
        proxies=proxies,
        timeout=15,
    )

    if resp.status_code == 403:
        print(f"[BLOCKED] 403 — provavelmente falta anti_content ou IP flaggado")
        return None
    if resp.status_code == 429:
        print(f"[RATE LIMITED] 429 — rotate IP e aguarde")
        return None

    data = resp.json()
    if not data.get("success"):
        print(f"[ERROR] API retornou success=false: {data.get('errorCode')}")
        return None

    return data["data"]["list"]

def parse_product(item: dict) -> dict:
    """Extrai campos-chave de um item da lista de busca."""
    return {
        "goods_id": item.get("goods_id"),
        "title": item.get("goods_name"),
        "price_usd": item.get("goods_price", {}).get("amount"),
        "currency": item.get("goods_price", {}).get("currency"),
        "sales": item.get("sales"),
        "free_shipping": item.get("shipping_info", {}).get("free_shipping"),
        "sku_count": len(item.get("sku_list", [])),
        "skus": [
            {
                "sku_id": s.get("sku_id"),
                "spec": s.get("spec"),
                "price": s.get("price", {}).get("amount"),
            }
            for s in item.get("sku_list", [])
        ],
    }

# Execução
if __name__ == "__main__":
    results = fetch_search_results("phone case", page=1, page_size=20)
    if results:
        for item in results[:3]:
            parsed = parse_product(item)
            print(json.dumps(parsed, indent=2, ensure_ascii=False))
    # Respeite rate limits: 1-2 req/s por IP
    time.sleep(random.uniform(1.0, 2.0))

Saída esperada (truncada):

{
  "goods_id": "501299873451",
  "title": "Capa Silicone iPhone 15 Pro",
  "price_usd": 4.99,
  "currency": "USD",
  "sales": 12847,
  "free_shipping": true,
  "sku_count": 2,
  "skus": [
    {"sku_id": "sku_8821", "spec": "Preto", "price": 4.99},
    {"sku_id": "sku_8822", "spec": "Azul", "price": 5.49}
  ]
}

Versão com curl para teste rápido

curl -x "http://user-country-US:YOUR_PASSWORD@gate.proxyhat.com:8080" \
  -H "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) ..." \
  -H "Accept: application/json" \
  -H "Referer: https://www.temu.com/" \
  "https://www.temu.com/api/poppy/v1/search?scene=search&keyword=phone%20case&page=1&pageSize=20"

Sessões Sticky, Retries e Paginação

Sessões sticky para consistência de carrinho e frete

Quando você precisa simular o fluxo de checkout — por exemplo, para capturar preços de frete por CEP — é obrigatório manter o mesmo IP durante toda a sessão. Se o IP muda entre a página de produto e o cálculo de frete, o Temu pode retornar dados inconsistentes ou bloquear a requisição.

ProxyHat suporta sessões sticky via flag no username:

# Sessão sticky — mesmo IP por até 10 minutos
http://user-country-US-session-checkout01:YOUR_PASSWORD@gate.proxyhat.com:8080

Cada identificador de sessão único (checkout01, checkout02, etc.) mapeia para um IP residencial fixo. Use nomes de sessão descritivos para organizar seus workers.

Estratégia de retries com backoff exponencial

import time
import random

def fetch_with_retry(fetch_fn, max_retries=4):
    for attempt in range(max_retries):
        try:
            result = fetch_fn()
            if result is not None:
                return result
        except Exception as e:
            print(f"[RETRY {attempt+1}] Erro: {e}")

        # Backoff exponencial com jitter
        wait = (2 ** attempt) + random.uniform(0.5, 1.5)
        time.sleep(wait)

    print("[FAILED] Máximo de retries atingido")
    return None

Combine retries com rotação de IP: a cada 403 ou 429, troque o identificador de sessão para obter um novo IP residencial.

Paginação eficiente

Para paginar resultados de busca:

all_products = []
for page in range(1, max_pages + 1):
    items = fetch_with_retry(
        lambda p=page: fetch_search_results("phone case", page=p)
    )
    if not items:
        break
    all_products.extend([parse_product(i) for i in items])

    # Rate limit: 1-2 req/s por IP
    time.sleep(random.uniform(1.0, 2.0))

    # Rotacionar IP a cada 5 páginas para evitar bloqueio
    if page % 5 == 0:
        # O ProxyHat rotaciona automaticamente em modo não-sticky
        pass

Em modo não-sticky (sem flag -session-), o ProxyHat atribui um novo IP a cada requisição automaticamente, o que é ideal para paginação de busca.

Comparação: Tipos de Proxy para Raspar Temu

Para a maioria dos casos de price intelligence, proxies residenciais rotativos com geo-city oferecem o melhor equilíbrio custo-benefício. Confira os planos em nossa página de pricing.

Ética, Termos de Serviço e Considerações Legais

Raspar Temu exige cuidado ético e legal. Aqui estão os pontos críticos:

Mantenha-se em dados públicos do catálogo

• Raspe apenas páginas e endpoints de catálogo público — preços, títulos, imagens, SKUs.
• Não raspe contas de usuário, dados pessoais, carrinhos de terceiros ou informações de checkout de outros usuários.
• Não tente bypass de autenticação para acessar áreas restritas.

CFAA e GDPR

Nos EUA, o Computer Fraud and Abuse Act (CFAA) pode aplicar-se a scraping que ultrapassa barreiras técnicas de autenticação. A jurisprudência pós-Van Buren (2021) é mais favorável a scrapers de dados públicos, mas acessar endpoints internos com tokens forjados pode ser interpretado como "exceeding authorized access."

Na UE, o GDPR protege dados pessoais. Se o seu scraping capturar inadvertidamente dados pessoais (ex.: reviews com nomes de usuários), você precisa de base legal para processamento e deve minimizar a coleta. O catálogo público de produtos geralmente não contém dados pessoais, mas fique atento a reviews e Q&A.

robots.txt e ToS do Temu

Verifique sempre o robots.txt do Temu antes de raspar. Os Termos de Serviço podem proibir scraping automatizado — violar ToS não é automaticamente ilegal, mas pode resultar em banimento e ações civis. Para casos de uso comerciais de alto volume, consulte um advogado.

Quando preferir o Merchant Feed oficial

Se você é um merchant registrado no Temu, use o Merchant Feed API oficial para acessar dados dos seus próprios produtos. É mais confiável, não requer bypass anti-bot e está dentro dos Termos de Serviço. Para dados de produtos de terceiros (competidores), o scraping via proxy é a única via — mas mantenha volume razoável e respeite rate limits.

Erros Comuns e Edge Cases

• Usar requests/httpx sem impersonação TLS: o fingerprint JA3 dessas bibliotecas não corresponde a nenhum navegador real. Use curl_cffi com impersonate="chrome124" ou similar.
• Ignorar geo-targeting: preços do Temu variam por região. Sem -country-US, você pode receber preços europeus ou asiáticos.
• Reutilizar anti_content expirado: tokens têm validade curta. Se você extrai o token via Playwright, gere um novo a cada 10 minutos.
• Concorrência excessiva por IP: mesmo com proxy residencial, 10+ requisições simultâneas por IP disparam rate limiting. Mantenha 1-2 req/s por IP.
• Não tratar 429 com backoff: receber 429 e imediatamente retentar com o mesmo IP piora a situação. Aguarde 30-60s e rotacione IP.
• Depender de classes CSS hasheadas: _3kQ2H hoje, _7mX1p amanhã. Use data-uniqid ou endpoints JSON.

ProxyHat: Configuração Específica para Temu

Para integrar ProxyHat ao seu pipeline de scraping do Temu, siga estes passos:

1. Crie uma conta em dashboard.proxyhat.com e obtenha suas credenciais.
2. Configure o proxy no formato correto: http://user-country-US:SUA_SENHA@gate.proxyhat.com:8080
3. Use SOCKS5 se precisar de UDP ou maior compatibilidade: socks5://user-country-US:SUA_SENHA@gate.proxyhat.com:1080
4. Para sessões sticky (checkout/frete): adicione -session-NOME_DA_SESSAO ao username.
5. Consulte nossa documentação para detalhes de configuração avançada.

Para casos de uso relacionados, veja também nossa página de web scraping e SERP tracking.

Pontos-Chave (Key Takeaways)

• Prefira endpoints JSON (/api/poppy/v1/search) sobre parsing de HTML — JSON é mais estável e estruturado.
• Use curl_cffi com impersonação de Chrome para passar fingerprinting TLS/HTTP2 do Cloudflare.
• Proxies residenciais com geo-city são obrigatórios — preços e fretes do Temu variam por região. Use -country-US ou -country-US-city-newyork.
• Mantenha 1-2 req/s por IP e rotacione a cada 3-5 requisições para evitar 429.
• Sessões sticky (-session-) são necessárias para fluxos de checkout e cálculo de frete consistentes.
• O token anti_content é o maior obstáculo — extraia via Playwright ou use o blob de estado embarcado como alternativa.
• Limite-se a dados públicos do catálogo — não raspe contas, dados pessoais ou áreas autenticadas.

FAQ

O Temu tem uma API pública?

Não. O Temu não oferece API pública para consumidores. Endpoints JSON internos como /api/poppy/v1/search existem, mas exigem tokens anti_content assinados e são protegidos por Cloudflare. Merchants registrados podem usar o Merchant Feed oficial.

Proxies de datacenter funcionam para raspar o Temu?

Não de forma confiável. O Cloudflare Turnstile e o fingerprinting TLS bloqueiam IPs de datacenter em segundos. A taxa de sucesso é inferior a 10%. Use proxies residenciais com geo-targeting de cidade.

Como obter o token anti_content?

A forma mais prática é carregar a página com Playwright, interceptar a geração do token via page.on('request') e reutilizá-lo por 5-15 minutos. O código de geração é ofuscado e muda frequentemente, tornando a reprodução server-side impraticável.

Qual o limite de rate do Temu?

Observações empíricas indicam ~3-5 requisições por minuto por IP antes de 429, e ~50-80 por subnet antes de bloqueio de range. O cooldown após bloqueio dura tipicamente 24 horas.

É legal raspar o Temu?

Raspar dados públicos do catálogo é geralmente aceito, mas verifique os Termos de Serviço e o robots.txt. O CFAA pode aplicar-se se você ultrapassar barreiras de autenticação. Na UE, o GDPR protege dados pessoais — evite capturar reviews com nomes de usuários. Consulte um advogado para uso comercial de alto volume.