Web Scraping Booking.com: Hotéis, preços e avaliações (Guia 2026)

Existem alguns casos de utilização em que o web scraping do Booking.com se paga quase imediatamente. As equipas de análise de tarifas comparam os preços por noite entre hotéis concorrentes em tempo real. Os gestores de receitas acompanham a disponibilidade e os padrões de descontos para sincronizar as suas próprias promoções. As equipas de pesquisa de mercado e análise de viagens utilizam o volume de avaliações, pontuações e cobertura de comodidades para avaliar um destino. E quem estiver a construir um metamotor de busca ou um agente de viagens com IA precisa de dados estruturados sobre propriedades que o site público apenas apresenta em JavaScript.

Ao longo deste guia, iremos extrair cinco tipos de entidades concretas: listagens de resultados de pesquisa (fichas de hotéis numa página de pesquisa), páginas de detalhes do hotel (descrição, morada, comodidades, geolocalização), preços por noite e disponibilidade, avaliações de hóspedes e inventário de hotéis baseado no mapa do site para descoberta em massa. Cada uma tem as suas peculiaridades, e misturá-las é o que lhe dá um conjunto de dados real, em vez de uma única captura de ecrã de uma SERP.

Existem duas formas razoáveis de fazer web scraping no Booking.com em qualquer volume, e são complementares em vez de concorrentes.

O Selenium com o Selenium Wire controla uma instância real do Chrome, executa o JavaScript da página e permite-lhe ler o DOM renderizado. É a opção de menor atrito quando ainda não conhece os pedidos ocultos da página e tolera bem as variações de layout, porque consulta o mesmo DOM que um utilizador vê. O preço a pagar é a velocidade e a utilização de recursos: cada página é um separador completo do navegador. Para listas selecionadas de alguns milhares de hotéis, isso é aceitável. Para monitorização contínua, torna-se dispendioso.

Chamar o /dml/graphql ponto final com httpx ignora completamente o navegador. O próprio front-end da Booking.com obtém os resultados da pesquisa a partir deste endpoint, pelo que, assim que espelhar a forma do pedido, obtém o mesmo JSON que o site, dez a cinquenta vezes mais rápido do que o Selenium e com uma pegada de memória mínima. A desvantagem é a fragilidade: as cargas úteis e os cabeçalhos necessários mudam, e é necessário mantê-los sincronizados.

Uma boa prática: faça um protótipo com o Selenium, defina a solicitação GraphQL assim que entender os dados e use o caminho da API para produção.

Use Python 3.10 ou mais recente num virtualenv novo para que as dependências permaneçam isoladas:

mkdir booking_scraper && cd booking_scraper
python -m venv .venv && source .venv/bin/activate
pip install selenium selenium-wire webdriver-manager httpx parsel
touch app.py

selenium-wire é um substituto direto para selenium que expõe as solicitações de rede subjacentes, das quais precisaremos para a sincronização da paginação. webdriver-manager baixa automaticamente o chromedriver , para que não tenha de se preocupar com as versões dos controladores nas diferentes máquinas. httpx fornece-nos um cliente compatível com HTTP/2 para o Método 2, e parsel fornece seletores CSS e XPath ao estilo do Scrapy para analisar o HTML dos hotéis. O nosso tutorial passo a passo do Selenium é um aquecimento útil se nunca tiver usado o Selenium para scraping antes.)

Este é o ponto de entrada mais intuitivo para o scraping da Booking.com: abra um URL de pesquisa numa sessão real do Chrome, deixe o JavaScript renderizar os cartões de propriedade e percorra o DOM. Utilizamos o Selenium Wire em vez do Selenium básico porque a página de pesquisa carrega os resultados através de chamadas XHR/fetch em segundo plano. O Selenium Wire permite-nos inspecionar esses pedidos individuais e aguardar até que uma resposta específica seja efetivamente devolvida, o que é importante para a paginação sem condições de corrida.

Inclua sempre datas explícitas de check-in e check-out no URL. Sem elas, o Booking.com recorre à disponibilidade padrão e a sua coluna de preços não corresponderá ao que um utilizador veria numa janela de reserva real.

from seleniumwire import webdriver
from selenium.webdriver.chrome.service import Service
from webdriver_manager.chrome import ChromeDriverManager
from selenium.webdriver.common.by import By

driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()))
url = ('https://www.booking.com/searchresults.html'
       '?ss=London&checkin=2026-05-10&checkout=2026-05-12&group_adults=2')
driver.get(url)

cards = driver.find_elements(By.CSS_SELECTOR, "div[data-testid='property-card']")
print(f'Found {len(cards)} property cards on page 1')

O Booking.com é bastante consistente na utilização de data-testid atributos nos seus cartões de resultados, o que os torna mais estáveis para segmentar do que nomes de classes gerados automaticamente.

Cada cartão de propriedade contém o mesmo conjunto de data-testid ganchos, pelo que o analisador por cartão é, na sua maioria, um pequeno dicionário de seletores. Os seletores CSS são normalmente a escolha certa aqui (concisos e rápidos), mas o XPath serve quando é necessário percorrer elementos pai ou irmãos. Consulte o nosso guia XPath vs seletores CSS se estiver a decidir qual usar.

def parse_card(card):
    def text(sel):
        nodes = card.find_elements(By.CSS_SELECTOR, sel)
        return nodes[0].text.strip() if nodes else None

    def attr(sel, name):
        nodes = card.find_elements(By.CSS_SELECTOR, sel)
        return nodes[0].get_attribute(name) if nodes else None

    score_block = text("div[data-testid='review-score']") or ''
    score_lines = [s.strip() for s in score_block.split('\n') if s.strip()]
    score = score_lines[0] if score_lines else None
    review_count = next((l for l in score_lines if 'review' in l.lower()), None)

    return {
        'name':         text("div[data-testid='title']"),
        'url':          attr("a[data-testid='title-link']", 'href'),
        'address':      text("span[data-testid='address']"),
        'score':        score,
        'review_count': review_count,
        'price':        text("span[data-testid='price-and-discounted-price']"),
        'image':        attr("img[data-testid='image']", 'src'),
    }

listings = [parse_card(c) for c in cards]

Há duas coisas a destacar sobre os preços. Primeiro, o review-score bloco no Booking.com comprime a pontuação numérica e o texto da contagem de avaliações num único elemento, por isso dividimo-lo em linhas e extraí-los separadamente. Segundo, o preço que se extrai de um cartão de pesquisa exclui quase sempre impostos e taxas; o total com tudo incluído só aparece quando se avança no fluxo de reserva. Trate-o como a tarifa de referência, não como o custo final, e documente isso mais adiante.

Cada clique no botão de avançar para a página seguinte dispara um POST para /dml/graphql e aguarda a resposta JSON. Se clicar e extrair imediatamente o DOM, irá ler a página anterior. O Selenium Wire corrige isto, permitindo-lhe bloquear na resposta real.

from selenium.webdriver.common.by import By

def total_pages(driver):
    nums = driver.find_elements(By.CSS_SELECTOR, "div[data-testid='pagination'] li")
    return max((int(n.text) for n in nums if n.text.isdigit()), default=1)

pages = total_pages(driver)
all_listings = [parse_card(c) for c in cards]

for page in range(2, pages + 1):
    del driver.requests  # clear so the next wait does not match an old response
    next_btn = driver.find_element(
        By.CSS_SELECTOR, "button[aria-label='Next page']")
    next_btn.click()
    driver.wait_for_request(r'/dml/graphql', timeout=10)
    cards = driver.find_elements(
        By.CSS_SELECTOR, "div[data-testid='property-card']")
    all_listings.extend(parse_card(c) for c in cards)

del driver.requests é a linha importante. Sem ela, wait_for_request corresponde alegremente à chamada GraphQL da página anterior e avança antes de os novos dados chegarem. Obtenha a contagem total de páginas a partir do controlo de paginação em vez de a codificar de forma rígida; as consultas atarefadas podem paginar vinte páginas, as mais tranquilas duas.

Assim que o Selenium lhe mostrar que a página de pesquisa é alimentada por /dml/graphql, a opção mais rápida é chamar você mesmo esse endpoint e ignorar o navegador. É aqui que o web scraping do Booking.com se torna genuinamente escalável.

O processo de descoberta é o mesmo que usaria para qualquer [API JavaScript oculta]: abra o DevTools (F12), alterne para o separador Rede, filtre por Fetch/XHR, depois acione uma pesquisa real e clique na segunda página. Verá um POST para /dml/graphql que transporta um corpo JSON com um operationName, um variables objeto (com o destino, datas, número de hóspedes e um offset) e um query ou extensions que fixa o hash da consulta. Clique com o botão direito do rato na solicitação e selecione «Copiar como cURL»; esse é o seu ponto de partida.

Verifique novamente os nomes exatos dos campos em comparação com a sua própria captura do DevTools antes de enviar; a Booking.com renomeia as operações GraphQL periodicamente, e a referência mais segura é o que o front-end está a enviar hoje.

import httpx

ENDPOINT = 'https://www.booking.com/dml/graphql'
HEADERS = {
    'content-type':    'application/json',
    'origin':          'https://www.booking.com',
    'referer':         'https://www.booking.com/searchresults.html',
    'user-agent':      'Mozilla/5.0 (Windows NT 10.0; Win64; x64) '
                       'AppleWebKit/537.36 (KHTML, like Gecko) '
                       'Chrome/124.0 Safari/537.36',
    'accept-language': 'en-US,en;q=0.9',
}

def search_page(client, payload, offset):
    body = {**payload}
    body['variables']['input']['pagination'] = {'offset': offset, 'rowsPerPage': 25}
    r = client.post(ENDPOINT, json=body, headers=HEADERS, timeout=30)
    r.raise_for_status()
    return r.json()

def search_all(payload, max_results=1000):
    results = []
    with httpx.Client(http2=True) as client:
        for offset in range(0, max_results, 25):
            page = search_page(client, payload, offset)
            hits = (page.get('data', {})
                        .get('searchQueries', {})
                        .get('search', {})
                        .get('results', []))
            if not hits:
                break
            results.extend(hits)
    return results

Dois detalhes que confundem as pessoas. O endpoint devolve 25 resultados por chamada, controlados por uma variável de deslocamento que se aumenta em incrementos de 25 resultados. E a solicitação deve parecer que veio do próprio site: origin e referer definido para booking.com, content-type: application/json, e um accept-language que corresponda à sua região de IP. Remova esses cabeçalhos e receberá um erro 400 genérico ou um bloqueio suave após algumas solicitações. Use HTTP/2 (o httpx faz isso quando passa http2=True) porque a infraestrutura de ponta da Booking.com parece identificar clientes que ainda negociam apenas HTTP/1.1.

Os cartões de resultados de pesquisa são apenas uma parte do scraping da Booking.com; eles fornecem um nome e um preço, mas não oferecem os detalhes detalhados sobre o hotel que as equipas de viagens realmente desejam. Para isso, faça o scraping diretamente da URL do hotel. As páginas dos hotéis são, na sua maioria, renderizadas pelo servidor, por isso basta um simples GET mais parsel é suficiente, sem necessidade de navegador.

import httpx
from parsel import Selector

def scrape_hotel(url):
    html = httpx.get(url, headers=HEADERS, http2=True, follow_redirects=True).text
    sel = Selector(text=html)
    map_link = sel.css("a[data-atlas-latlng]::attr(data-atlas-latlng)").get('')
    lat, lng = (map_link.split(',') + [None, None])[:2]
    return {
        'name':        sel.css('h2.pp-header__title::text').get(default='').strip(),
        'description': ' '.join(sel.css("div[data-testid='property-description'] *::text").getall()).strip(),
        'address':     sel.css("span[data-testid='address']::text").get(default='').strip(),
        'lat':         lat,
        'lng':         lng,
        'amenities':   [a.strip() for a in sel.css("div[data-testid='facility-list-most-popular'] li::text").getall() if a.strip()],
    }

A latitude e a longitude estão normalmente incorporadas num data-atlas-latlng atributo no link do mapa, o que é mais fiável do que extraí-las de scripts incorporados. As comodidades estão agrupadas em blocos de funcionalidades; percorra os grupos se quiser que sejam categorizados em vez de apresentados de forma plana.

O preço por noite não está no HTML do hotel; encontra-se numa consulta GraphQL separada que devolve uma resposta em formato de calendário. Captura o pedido da mesma forma que a chamada de pesquisa: abre a página do hotel no DevTools, altera as datas e observa o POST de preços/disponibilidade para /dml/graphql. O corpo inclui os identificadores do hotel (código numérico hotel_id, código do país e moeda) e um intervalo de datas.

As páginas dos hotéis também incorporam um token do tipo CSRF no HTML que a consulta de preços espera no corpo ou num cabeçalho. Extraia-o da página uma vez por hotel e, em seguida, reutilize-o para cada chamada de preços.

def scrape_pricing(client, hotel_id, csrf, checkin, checkout, currency='EUR'):
    payload = {
        'operationName': 'AvailabilityCalendar',  # verify in DevTools
        'variables': {
            'input': {
                'hotelId': hotel_id,
                'checkIn': checkin,
                'checkOut': checkout,
                'currency': currency,
            }
        },
        'extensions': {'csrf': csrf},
    }
    r = client.post(ENDPOINT, json=payload, headers=HEADERS, timeout=30)
    r.raise_for_status()
    return r.json()

As avaliações dos hóspedes são carregadas através de um XHR separado quando clicas no separador «Avaliações» numa página de hotel. Abre o DevTools, muda para «Fetch/XHR», clica no separador e copia o pedido. Este é paginado através de um skip (ou offset) inteiro em lotes de cerca de 25 e devolve o texto da avaliação, a pontuação, o idioma, o país do avaliador e a data.

Assim que tiver uma chamada a funcionar, pode expandir-se em simultâneo, executando lotes num httpx.AsyncClient:

import asyncio, httpx

async def fetch_reviews(client, hotel_id, skip):
    r = await client.post(ENDPOINT, json=review_payload(hotel_id, skip), headers=HEADERS)
    return r.json()

async def all_reviews(hotel_id, total):
    async with httpx.AsyncClient(http2=True) as c:
        tasks = [fetch_reviews(c, hotel_id, s) for s in range(0, total, 25)]
        return await asyncio.gather(*tasks)

Mantenha a simultaneidade em um dígito por hotel; as avaliações têm um limite de taxa bastante restrito.

Para a extração em massa do inventário da Booking.com, em vez de extrair uma consulta de cada vez, comece em https://www.booking.com/robots.txt. A Booking.com publica as suas Sitemap: entradas lá, incluindo índices de mapas do site de hotéis, atrações e aeroportos. Cada índice de mapa do site aponta para submapas do site limitados a 50.000 URLs (conforme o protocolo de mapa do site), razão pela qual o índice de hotéis está dividido em muitos ficheiros. Percorrer o índice fornece-lhe dezenas de milhões de URLs de hotéis, com duplicados, que pode deduplicar com base no slug da URL ou num ID de hotel analisado. O nosso guia de extração de mapas do site tem um padrão reutilizável para isso.

Para pesquisas direcionadas, o próprio endpoint de autocompletar localização da Booking.com resolve uma string de cidade ou bairro nos identificadores de destino que a chamada GraphQL de pesquisa espera, o que é melhor do que codificá-los manualmente.

O sucesso do scraping da Booking.com em qualquer volume resume-se a parecer um navegador normal e recuar quando o site o solicita. A partir de 2026, a pilha anti-bot da Booking.com parece identificar tanto o comportamento TLS como o HTTP/2, pelo que os princípios básicos são inegociáveis: um cliente compatível com HTTP/2 (httpx com http2=True), um conjunto de cabeçalhos realista incluindo accept-language e sec-ch-ua-*, e um user-agent que corresponda a uma versão atual do Chrome. (Verifique periodicamente a sensibilidade ao HTTP/2; isto muda.)

Utilize proxies residenciais ou de ISP em vez de intervalos de datacenters; os IPs de datacenters que acedem ao Booking.com começam a ativar captchas após algumas dezenas de pedidos. Mantenha a simultaneidade conservadora (5 a 10 por IP), adicione jitter e reduza exponencialmente o 429 e 403. A rede de proxies residenciais da WebScrapingAPI e a API Scraper tratam da rotação, das tentativas de repetição e das impressões digitais TLS, caso prefira não reinventar essa infraestrutura. Os navegadores anti-detecção são o último recurso para as páginas mais difíceis.

A Booking.com infere a moeda exibida a partir da geolocalização do seu IP de saída, pelo que um scraper baseado nos EUA verá USD e um baseado na UE verá EUR por predefinição. Para uma moeda consistente, encaminhe através de um proxy direcionado para um país específico ou passe um selected_currency parâmetro de consulta em cada pedido. (Teste novamente este comportamento periodicamente; o nome do parâmetro e a lógica de inferência de IP são o tipo de coisa que muda discretamente.)

A plataforma também limita qualquer pesquisa individual a aproximadamente 1.000 resultados. Para enumerar o inventário numa cidade movimentada, divida a consulta: extraia Londres por bairro (Shoreditch, Camden, Kensington), depois por classificação por estrelas, depois por faixa de preço e junte os resultados pelo ID do hotel.

Para execuções em produção, incorpore este código no Scrapy e deixe-o tratar de novas tentativas, persistência e execuções distribuídas. Armazene a saída normalizada no Postgres ou num armazenamento colunar, faça um snapshot diário e mantenha os seus scrapers em conformidade com robots.txt e os termos de serviço da Booking.com.

• O web scraping do Booking.com funciona melhor quando dois métodos são usados em conjunto: o Selenium Wire para prototipagem e estabilidade do DOM, e o /dml/graphql ponto de extremidade via httpx para velocidade de produção.
• Recolha o conjunto completo de entidades (resultados de pesquisa, páginas de detalhes dos hotéis, preços por noite e avaliações de hóspedes), em vez de apenas a SERP de pesquisa; caso contrário, o conjunto de dados será demasiado escasso para a análise de tarifas.
• Utilize data-testid seletores e wait_for_request on /dml/graphql para manter o scraper da página de pesquisa resistente a alterações de layout e condições de corrida de paginação.
• Planeie antecipadamente em função das restrições da plataforma: proxies residenciais, cabeçalhos HTTP/2, seleção de moeda com base no IP e o limite de paginação de cerca de 1.000 resultados que obriga à partição de consultas.
• Utilize mapas do site em /robots.txt para a descoberta em massa de URLs de hotéis e a API de autocompletar localização para resolver identificadores de destino.

Na maioria das jurisdições, a extração de listagens de hotéis, preços e avaliações agregadas visíveis ao público é geralmente considerada permitida quando feita a um ritmo razoável e sem contornar a autenticação. Dito isto, os termos de serviço, a Diretiva de Bases de Dados da UE e o RGPD (para qualquer informação que permita identificar o autor da avaliação) são todos importantes. Peça a um consultor jurídico para analisar o seu caso de utilização específico antes da implementação comercial e evite armazenar dados pessoais.

Duas opções fiáveis: encaminhe os pedidos através de um proxy localizado no país cuja moeda pretende (a Booking.com deduz a moeda a partir do IP de saída) ou passe um selected_currency=EURparâmetro de consulta do tipo em cada pedido para substituir o padrão inferido. Combine ambos para garantir a consistência, uma vez que a substituição é ocasionalmente ignorada quando o IP e o parâmetro entram em conflito para hotéis com preços numa moeda local fixa.

Divida a consulta. A Booking.com limita qualquer pesquisa individual a cerca de 1.000 resultados, por isso a solução alternativa é dividir a cidade em subconjuntos mais pequenos que caibam dentro desse limite: por bairro, depois por classificação por estrelas e, se necessário, por faixa de preço. Junte os IDs dos hotéis resultantes e elimine duplicados. Para uma enumeração completa do inventário, recorra à navegação pelo índice do mapa do site do hotel em vez da interface de pesquisa.

Use o Selenium para descoberta e tarefas pequenas; use o endpoint GraphQL para escalabilidade. O Selenium é mais flexível quando o front-end muda, porque consulta o DOM renderizado. O GraphQL é muito mais rápido e mais barato por pedido, mas tem de manter as cargas úteis e os cabeçalhos dos pedidos sincronizados com o site ativo. Um padrão comum é manter ambos e fazer failover da API para o navegador quando a API falha.

Quase sempre uma de três coisas: as suas datas de check-in/check-out não estão fixadas no URL, o seu IP de saída alterou a moeda ou aplicou um desconto regional, ou o preço do cartão de pesquisa exclui impostos e taxas que o navegador só exibe no passo seguinte. Fixe as datas, defina a moeda e identifique claramente os preços extraídos como tarifas noturnas antes de impostos.

O web scraping do Booking.com é um problema resolúvel assim que deixares de o tratar como uma única página e começares a tratá-lo como um ecossistema de endpoints. O Selenium Wire oferece-te uma rampa de acesso flexível para resultados de pesquisa e paginação, o endpoint interno /dml/graphql oferece a velocidade necessária para monitorização contínua, e chamadas dedicadas para páginas de detalhes de hotéis, preços por noite e avaliações completam o conjunto de dados. Adicione a descoberta do mapa do site, o particionamento de consultas e o controlo explícito da moeda, e terá um scraper que vai além do exemplo simples de consulta única.

Os elementos que a maioria das equipas subestima são os relacionados com a infraestrutura: impressão digital TLS e HTTP/2, qualidade do proxy residencial, lógica de repetição e recuo, e a paciência para manter os seletores e as cargas úteis GraphQL em sincronia à medida que o site evolui.

Se preferir não manter essa camada anti-bloqueio por conta própria, a nossa equipa na WebScrapingAPI oferece uma API de Scraper que devolve HTML bruto através de IPs residenciais rotativos com CAPTCHAs e gestão de TLS gerida por nós, além de uma API de Navegador para as interações em várias etapas que o Selenium gere neste guia. Inserir qualquer uma delas no código acima e poderá concentrar-se na análise e no modelo de dados, que é a parte que realmente diferencia o seu produto.