Como Raspar Listings de Negócios e Avaliações do Yelp em 2026

Aviso legal: Este artigo cobre apenas o acesso a dados públicos que não exigem login. Antes de raspar qualquer plataforma, revise os Termos de Serviço (ToS) do Yelp e leis aplicáveis como a Computer Fraud and Abuse Act (CFAA) nos EUA e o GDPR na UE. Avaliações contêm dados pessoais — o processamento deve respeitar a legislação de privacidade relevante. Quando possível, prefira a API Fusion do Yelp.

Se você está construindo datasets de negócios locais — para análise de mercado, SEO local, ou enriquecimento de listings — o Yelp continua sendo uma das fontes mais ricas de avaliações de consumidores, horários, categorias e geolocalização. Mas raspar Yelp em 2026 não é trivial. A plataforma emprega PerimeterX (agora HUMAN Security) para bloquear bots, usa fingerprinting de TLS, e limita agressivamente IPs de datacenter. Este guia mostra como desenvolvedores podem acessar dados públicos do Yelp de forma confiável usando proxies residenciais rotativos, com exemplos executáveis em Python e Node.js.

Como Raspar Listings de Negócios e Avaliações do Yelp em 2026: O Que Está Acessível

O Yelp expõe uma quantidade significativa de dados sem exigir login. Cada negócio tem uma página pública em /biz/<slug> que inclui:

• Nome, endereço, telefone e coordenadas GPS.
• Categorias (ex.: "Italian Restaurant", "Coffee Shop").
• Horários de funcionamento por dia da semana.
• Avaliação média (1 a 5 estrelas) e contagem total de avaliações.
• Texto de avaliações — tipicamente as primeiras 10 avaliações visíveis na página, com autor (primeiro nome), data, nota e texto truncado.
• Fotos enviadas por usuários e pelo proprietário.

A API Fusion do Yelp é a opção oficial, mas tem limitações importantes: o endpoint de avaliações retorna no máximo 3 avaliações por negócio, e o acesso requer uma chave de API com cota de 500 requisições/dia no plano gratuito. Para casos de uso que exigem mais avaliações por negócio ou volume maior, a raspagem da página pública torna-se necessária.

Defesas Anti-Bot do Yelp: PerimeterX, TLS Fingerprinting e CAPTCHAs

O Yelp utiliza HUMAN Security (anteriormente PerimeterX) como sua principal camada de defesa anti-bot. Veja como isso afeta raspadores:

O Cookie _px3 e o Sensor Challenge

O PerimeterX injeta cookies _px (incluindo _px3) que contêm tokens de sessão validados por JavaScript. Quando uma requisição chega sem esses cookies — ou com cookies expirados — o servidor responde com um desafio JavaScript ("sensor challenge") que coleta dados de fingerprint do navegador: canvas rendering, WebGL, fontes instaladas, dimensões de tela, e timing de eventos. Se o desafio falha, o usuário recebe um CAPTCHA.

Fingerprinting de TLS

O Yelp (via PerimeterX) inspeciona o handshake TLS para identificar o cliente. Bibliotecas como requests e urllib produzem fingerprints JA3 distintos dos navegadores reais. Um fingerprint JA3 que não corresponde ao User-Agent declarado é um sinal forte de automação.

Bloqueio de IPs de Datacenter

Após apenas 3 a 5 requisições de um IP de datacenter, o Yelp tipicamente retorna um erro 403 ou redireciona para uma página de CAPTCHA. IPs residenciais têm reputação muito maior e podem sustentar dezenas de requisições antes de qualquer desafio, especialmente quando combinados com geo-targeting apropriado.

Por Que Proxies Residenciais Rotativos com Geo-US São Necessários

Resultados de busca do Yelp são localizados. Uma busca por "pizza" feita de um IP em Austin retorna negócios diferentes da mesma busca feita de um IP em Berlim. Para obter listings relevantes para um mercado específico, você precisa de IPs na mesma região.

Com o ProxyHat, você pode geo-targetar até o nível de cidade usando flags no username:

# Geo-targeting para Austin, Texas
http://user-country-US-city-austin:sua_senha@gate.proxyhat.com:8080

# Geo-targeting para Nova York
http://user-country-US-city-newyork:sua_senha@gate.proxyhat.com:8080

Proxies residenciais rotativos oferecem duas vantagens críticas para raspagem do Yelp:

1. Reputação de IP: IPs residenciais são atribuídos por ISPs reais, então o PerimeterX os classifica como tráfego legítimo de consumidores.
2. Rotação automática: Cada requisição pode sair de um IP diferente, distribuindo o load e evitando que um único IP acumule reputação negativa.

Para sessões que precisam manter continuidade (ex.: paginação de avaliações), use o flag -session- para manter o mesmo IP durante toda a sessão:

# Sessão sticky para paginação consistente
http://user-country-US-session-abc123:sua_senha@gate.proxyhat.com:8080

Implementação Prática: Raspando Dados Públicos do Yelp com Python

O Yelp carrega dados de avaliações tanto via um endpoint JSON interno (/biz/<slug>/review_feed) quanto embutidos no HTML como um blob __INITIAL_STATE__. Ambos contêm texto de avaliações, autores, notas e datas em formato estruturado.

Veja um exemplo completo em Python usando requests através do ProxyHat:

import requests
import json
import re
import time
import random

# Configuração do proxy residencial ProxyHat
proxy_url = "http://user-country-US-city-austin:sua_senha@gate.proxyhat.com:8080"

proxies = {
    "http": proxy_url,
    "https": proxy_url,
}

# Headers realistas
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": "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",
    "Connection": "keep-alive",
}

business_slug = "uchi-austin"
url = f"https://www.yelp.com/biz/{business_slug}"

response = requests.get(url, headers=headers, proxies=proxies, timeout=30)

if response.status_code == 200:
    html = response.text

    # Método 1: Extrair __INITIAL_STATE__ do HTML
    match = re.search(r'window\.__INITIAL_STATE__\s*=\s*({.*?});', html, re.DOTALL)
    if match:
        state_json = match.group(1)
        state = json.loads(state_json)

        # Navegar até reviews no estado inicial
        biz_data = state.get("bizDetailsPage", {}).get("reviewQuery", {})
        reviews = biz_data.get("reviews", [])

        for review in reviews[:3]:  # Primeiras 3 avaliações
            print(f"Autor: {review.get('author', {}).get('displayName', 'N/A')}")
            print(f"Nota: {review.get('rating', 'N/A')}/5")
            print(f"Data: {review.get('datePublished', 'N/A')}")
            text = review.get('comment', {}).get('text', '')[:200]
            print(f"Texto: {text}...")
            print("---")
    else:
        print("__INITIAL_STATE__ não encontrado")
else:
    print(f"Erro: HTTP {response.status_code}")

# Método 2: Endpoint review_feed (paginação)
review_feed_url = f"https://www.yelp.com/biz/{business_slug}/review_feed"
params = {"rl": "en", "sort_by": "date_desc", "start": 0}

feed_response = requests.get(
    review_feed_url,
    headers=headers,
    proxies=proxies,
    params=params,
    timeout=30
)

if feed_response.status_code == 200:
    feed_data = feed_response.json()
    # feed_data contém HTML parcial com reviews adicionais
    print(f"Reviews carregados via feed: {len(feed_data.get('reviews', []))}")

# Pacing: aguardar 2-5 segundos entre requisições
time.sleep(random.uniform(2, 5))

Nota: A estrutura do __INITIAL_STATE__ muda periodicamente. Sempre valide os campos antes de processar em lote e implemente fallbacks para chaves ausentes.

Exemplo em Node.js com SOCKS5

Para casos de uso onde SOCKS5 é preferível — por exemplo, quando você precisa de uma camada de transporte mais leve ou está rodando em ambientes que não suportam proxies HTTP nativamente — o ProxyHat oferece SOCKS5 na porta 1080:

const { SocksProxyAgent } = require('socks-proxy-agent');
const fetch = require('node-fetch');

const socksAgent = new SocksProxyAgent(
  'socks5://user-country-US-city-newyork:sua_senha@gate.proxyhat.com:1080'
);

const businessSlug = 'joes-pizza-new-york';
const url = `https://www.yelp.com/biz/${businessSlug}`;

const headers = {
  'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.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',
};

async function scrapeYelp() {
  try {
    const response = await fetch(url, {
      agent: socksAgent,
      headers: headers,
      timeout: 30000,
    });

    if (response.status === 200) {
      const html = await response.text();
      const stateMatch = html.match(/window\.__INITIAL_STATE__\s*=\s*({.*?});/s);

      if (stateMatch) {
        const state = JSON.parse(stateMatch[1]);
        const reviews = state?.bizDetailsPage?.reviewQuery?.reviews || [];

        reviews.slice(0, 3).forEach(review => {
          console.log(`Autor: ${review?.author?.displayName || 'N/A'}`);
          console.log(`Nota: ${review?.rating || 'N/A'}/5`);
          console.log(`Texto: ${(review?.comment?.text || '').substring(0, 200)}...`);
          console.log('---');
        });
      }
    } else {
      console.error(`HTTP ${response.status}`);
    }
  } catch (err) {
    console.error('Erro:', err.message);
  }
}

scrapeYelp();

Paginação, Rate-Limit Pacing e Rotação de User-Agents

Paginação de Avaliações

O Yelp pagina avaliações em incrementos de 10. O parâmetro start no review_feed controla o offset:

for start in range(0, 100, 10):  # Primeiras 10 páginas
    params = {"rl": "en", "sort_by": "date_desc", "start": start}
    # ... fazer requisição ...
    time.sleep(random.uniform(3, 7))  # Pacing agressivo reduz bloqueios

Rate-Limit Pacing

Recomendamos 3 a 7 segundos entre requisições para o mesmo negócio e 1 a 3 segundos entre negócios diferentes. Com proxies residenciais rotativos do ProxyHat, você pode sustentar aproximadamente 100 a 200 requisições/minuto distribuídas entre múltiplos IPs, mas o pacing por IP individual deve permanecer conservador.

Sessões Sticky para Continuidade

Ao paginar avaliações de um único negócio, use o flag -session- para manter o mesmo IP. Isso evita que o PerimeterX interprete a mudança de IP no meio de uma sequência de paginação como comportamento suspeito:

session_id = f"yelp-{business_slug}-{int(time.time())}"
proxy_url = f"http://user-country-US-session-{session_id}:sua_senha@gate.proxyhat.com:8080"

Rotação de User-Agents

Mantenha uma lista de User-Agents realistas e rotacione-os entre sessões. Não troque o User-Agent no meio de uma sessão sticky — isso é um sinal de automação. Use User-Agents que correspondam ao fingerprint TLS esperado (Chrome com Chrome, Firefox com Firefox).

import random

USER_AGENTS = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0",
    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
]

# Um UA por sessão, não por requisição
ua = random.choice(USER_AGENTS)

Erros Comuns e Casos de Borda

• Status 403 persistente: Se você recebe 403 mesmo com proxy residencial, o IP pode ter sido sinalizado. Troque a sessão (-session- com novo ID) ou aguarde 10–15 minutos.
• Página de CAPTCHA em vez de conteúdo: O PerimeterX detectou automação. Reduza a frequência, verifique se seu User-Agent corresponde ao fingerprint TLS, e considere usar uma solução de navegador headless como Playwright com stealth plugin.
• __INITIAL_STATE__ ausente: O Yelp pode servir uma versão lite da página para certos IPs. Tente um IP de cidade diferente ou adicione headers Sec-Fetch-* mais completos.
• Avaliações com texto truncado: O Yelp corta avaliações longas na página pública. O texto completo pode não estar disponível sem login — respeite essa limitação.
• Geolocalização incorreta: Se os resultados não correspondem à cidade esperada, verifique se o flag -city- está correto e se o país está definido com -country-US.

Configuração no ProxyHat

Para começar a raspar dados públicos do Yelp com o ProxyHat:

1. Crie uma conta em dashboard.proxyhat.com e escolha um plano de proxies residenciais.
2. Obtenha suas credenciais (username e senha) no dashboard.
3. Configure o geo-targeting com -country-US e -city- para o mercado desejado.
4. Use sessões sticky (-session-) para paginação e rotação automática para buscas independentes.
5. Monitore a taxa de sucesso e ajuste o pacing conforme necessário.

Consulte a documentação do ProxyHat para detalhes completos sobre configuração de proxies. Para outros casos de uso de raspagem, veja nossos guias em raspagem web e rastreamento de SERP. A lista completa de localizações suportadas está em /pt/locations.

Raspagem Ética e Quando Usar a API Oficial

Antes de construir um scraper de Yelp em escala, considere estes princípios:

• Respeite o robots.txt: Verifique https://www.yelp.com/robots.txt e siga as diretivas aplicáveis.
• Dados pessoais: Avaliações contêm nomes e potencialmente outros dados pessoais. Sob o GDPR, o processamento de dados pessoais requer base legal. Considere anonimizar ou agregar dados em vez de armazenar informações identificáveis.
• Evite conteúdo atrás de login: Não tente acessar dados que exigem autenticação. Isso viola os ToS do Yelp e pode constituir violação da CFAA.
• Volume e impacto: Não sobrecarregue os servidores do Yelp. Mantenha pacing razoável e evite raspagem simultânea de milhares de páginas.
• Prefira a API Fusion quando suficiente: Se você precisa apenas de dados básicos de negócios (nome, endereço, telefone, rating, 3 avaliações), a API Fusion é mais rápida, mais estável e legalmente mais segura. A raspagem deve ser reservada para casos onde a API não cobre sua necessidade.

Pontos-Chave (Key Takeaways)

• O Yelp expõe dados públicos ricos sem login em /biz/<slug>, incluindo avaliações via __INITIAL_STATE__ e review_feed.
• PerimeterX/HUMAN bloqueia IPs de datacenter após 3–5 requisições; proxies residenciais com geo-US são essenciais.
• Use sessões sticky (-session-) para paginação e rotação automática para buscas independentes.
• Mantenha pacing de 3–7 segundos entre requisições ao mesmo negócio e rotacione User-Agents por sessão.
• A API Fusion retorna no máximo 3 avaliações por negócio — insuficiente para análise de sentimento em escala.
• Respeite ToS, robots.txt, GDPR e CFAA. Prefira a API oficial quando ela cobrir sua necessidade.

Perguntas Frequentes

É legal raspar listings e avaliações do Yelp?

O acesso a dados públicos sem login é geralmente permitido, mas deve respeitar os Termos de Serviço do Yelp e leis aplicáveis como a CFAA nos EUA e o GDPR na UE. Avaliações contêm dados pessoais e seu processamento requer base legal. Consulte sempre um advogado antes de operar em escala comercial.

Qual tipo de proxy funciona melhor para raspar o Yelp?

Proxies residenciais rotativos com geo-targeting dos EUA são a melhor opção. O PerimeterX bloqueia IPs de datacenter após 3–5 requisições, enquanto IPs residenciais sustentam 50–200 requisições antes de qualquer desafio. Para resultados localizados, use flags como -country-US-city-austin.

Como evitar bloqueios ao raspar o Yelp?

Use proxies residenciais rotativos, mantenha pacing de 3–7 segundos entre requisições, rotacione User-Agents por sessão (não por requisição), use sessões sticky para paginação, e garanta que seu fingerprint TLS corresponda ao User-Agent declarado. Reduza a frequência se receber 403 ou CAPTCHAs.

A API Fusion do Yelp é suficiente para obter avaliações?

A API Fusion retorna no máximo 3 avaliações por negócio e limita o plano gratuito a 500 requisições/dia. Para análise de sentimento em escala ou datasets completos de avaliações, a API é insuficiente. Para dados básicos de negócios (nome, endereço, rating), a API é a opção mais segura e estável.

Como lidar com o PerimeterX ao raspar o Yelp?

O PerimeterX usa cookies _px3, desafios de sensor JavaScript e fingerprinting de TLS. Para contornar, use proxies residenciais com boa reputação de IP, headers de navegador realistas, pacing conservador e, se necessário, um navegador headless como Playwright com stealth plugin para resolver desafios JavaScript automaticamente.