Como raspar preços de hotéis do Google com Node.js

As mudanças sazonais, a demanda flutuante e as atividades promocionais fazem com que os preços dos hotéis mudem frequentemente. Rastrear manualmente essas mudanças é quase impossível. Em vez disso, automatizar esse processo raspando sites e plataformas de viagens pode economizar tempo e esforço.

Neste artigo, mostraremos como raspar os preços dos hotéis de um dos maiores agregadores: o Google. Ao raspar os dados de hotéis do Google, você pode coletar rapidamente informações extensas sobre preços, avaliações e comodidades de hotéis para análise, comparação de preços ou estratégias de preços dinâmicos.

Por que raspar os preços dos hotéis do Google?

Quando você pesquisa palavras-chave relacionadas a hotéis, o Google gera uma seção de hotéis dedicada que inclui nomes, imagens, endereços, avaliações e preços para milhares de hotéis. Isso ocorre porque o Google agrega informações de milhões de sites de viagens e hotéis em um único local.

Viajantes, empresas e analistas podem usar esses dados para diversos fins:

• Comparação de preços: Compare preços em diferentes plataformas de reserva e sites de viagens para encontrar as melhores ofertas.
• Análise de dados: Os analistas podem usar os dados de preços de hotéis para descobrir tendências de preços, flutuações sazonais e oportunidades competitivas.
• Estratégias de precificação dinâmica: As empresas podem otimizar as taxas de receita e ocupação ajustando os preços com base na demanda, disponibilidade e preços dos concorrentes.
• Alertas personalizados: Monitore quedas de preços para alertar clientes ou para uso pessoal.
• Serviços de agregação de viagens: Forneça aos usuários uma visão consolidada dos preços e opções de hotéis de várias fontes.
• Orçamento e planejamento: Os viajantes podem antecipar os custos de acomodação e ajustar seus planos de acordo.

Em resumo, os usos para esses dados são vastos, mas antes que você possa obter insights, precisa coletá-los.

Como raspar os preços dos hotéis do Google com Node.js

Neste tutorial, escreveremos um script para coletar dados de preços de hotéis e classificar a lista de hotéis do mais barato para o mais caro, focando em hotéis em Nova York.

1. Pré-requisitos

Para seguir este tutorial, você precisa ter as seguintes ferramentas instaladas em seu computador:

• Node.js 18+ e NPM
• Conhecimento básico de JavaScript e da API do Node.js

2. Configurando o projeto

Crie uma pasta de projeto:

mkdir google-hotel-scraper

Em seguida, inicialize um projeto Node.js executando o seguinte comando:

cd google-hotel-scraper  
npm init -y

Este comando criará um arquivo package.json na pasta. Crie um arquivo index.js e adicione uma instrução JavaScript simples:

touch index.js  
echo "console.log('Hello world!');" > index.js

Execute o arquivo index.js usando o tempo de execução do Node.js:

node index.js

Se "Hello world!" for impresso no terminal, seu projeto está funcionando.

3. Instalando as dependências necessárias

Para construir nosso raspador, precisamos de dois pacotes Node.js:

• Puppeteer: Para carregar páginas de hotéis do Google e baixar o conteúdo HTML.
• Cheerio: Para extrair informações do hotel do HTML baixado pelo Puppeteer.

Instale esses pacotes com o seguinte comando:

npm install puppeteer cheerio

4. Identificando informações para raspar da página do Hotel Google

Para extrair informações de uma página da web, primeiro precisamos identificar os seletores DOM que direcionam os elementos HTML desejados.

Aqui está uma tabela dos seletores DOM para cada parte dos dados relevantes:

5. Raspagem da página do Hotel Google

Com os seletores DOM identificados, vamos usar o Puppeteer para baixar o HTML da página. A página inicial que estamos direcionando é: https://www.google.com/travel/search.

Em alguns países (principalmente na Europa), uma página de consentimento será exibida antes de redirecionar para a URL. Adicionaremos código para clicar no botão "Rejeitar todos", esperar três segundos e garantir que a página do Hotel Google esteja totalmente carregada.

Atualize o arquivo index.js com o seguinte código:

const puppeteer = require('puppeteer');

const PAGE_URL = 'https://www.google.com/travel/search';

const waitFor = (timeInMs) => new Promise(r => setTimeout(r, timeInMs));

const main = async () => {
    const browser = await puppeteer.launch({ headless: 'new' });
    const page = await browser.newPage();

    await page.goto(PAGE_URL);

    const buttonConsentReject = await page.$('.VfPpkd-LgbsSe[aria-label="Reject all"]');
    await buttonConsentReject?.click();
    await waitFor(3000);

    const html = await page.content();
    await browser.close();

    console.log(html);
}

void main();

Execute o código usando node index.js. O terminal exibirá o conteúdo HTML da página.

6. Extraindo informações do HTML

Embora tenhamos o HTML da página, extrair dados valiosos diretamente do HTML bruto é desafiador. É aqui que o Cheerio entra em ação.

O código a seguir carrega o HTML e extrai o preço do quarto para cada hotel:

const cheerio = require("cheerio");

const $ = cheerio.load(html);

$('.uaTTDe').each((i, el) => {
    const priceElement = $(el).find('.kixHKb span').first();

    console.log(priceElement.text());
});

Atualize o arquivo index.js para extrair o conteúdo com Cheerio, armazená-lo em um array e classificá-lo por preço do mais baixo para o mais alto:

const cheerio = require("cheerio");
const puppeteer = require("puppeteer");
const { sanitize } = require("./utils");

const waitFor = (timeInMs) => new Promise(r => setTimeout(r, timeInMs));

const GOOGLE_HOTEL_PRICE = 'https://www.google.com/travel/search';

const main = async () => {
  const browser = await puppeteer.launch({ headless: 'new' });
  const page = await browser.newPage();

  await page.goto(GOOGLE_HOTEL_PRICE);

  const buttonConsentReject = await page.$('.VfPpkd-LgbsSe[aria-label="Reject all"]');
  await buttonConsentReject?.click();
  await waitFor(3000);

  const html = await page.content();
  await browser.close();

  const hotelsList = [];
  const $ = cheerio.load(html);

  $('.uaTTDe').each((i, el) => {
    const titleElement = $(el).find('.QT7m7 > h2');
    const priceElement = $(el).find('.kixHKb span').first();
    const reviewsElement = $(el).find('.oz2bpb > span');
    const hotelStandingElement = $(el).find('.HlxIlc .UqrZme');

    const options = [];
    const pictureURLs = [];

    $(el).find('.HlxIlc .XX3dkb').each((i, element) => {
      options.push($(element).find('span').last().text());
    });

    $(el).find('.EyfHd .x7VXS').each((i, element) => {
      pictureURLs.push($(element).attr('src'));
    });

    const hotelInfo = sanitize({
      title: titleElement.text(),
      price: priceElement.text(),
      standing: hotelStandingElement.text(),
      averageReview: reviewsElement.eq(0).text(),
      reviewsCount: reviewsElement.eq(1).text(),
      options,
      pictures: pictureURLs,
    });

    hotelsList.push(hotelInfo);
  });

  const sortedHotelsList = hotelsList.slice().sort((hotelOne, hotelTwo) => {
    if (!hotelTwo.price) {
      return 1;
    }

    return hotelOne.price - hotelTwo.price;
  });

  console.log(sortedHotelsList);
}

void main();

Execute o código e veja os resultados. Você acabou de coletar informações sobre todos os hotéis em.

No conteúdo anterior, implementamos a raspagem dos preços dos hotéis do Google por meio do Node.js e do Puppeteer. Embora esse método possa atender às necessidades básicas, ele requer a escrita de muito código e pode encontrar muitos desafios ao lidar com mecanismos complexos de anti-raspagem.

Para concluir a tarefa de forma mais eficiente, podemos recomendar um método mais simples: usar a Scrapeless Deep SerpAPI.

Use a Scrapeless Deep SerpApi para rastrear informações de hotéis do Google

Deep SerpApi é um mecanismo de busca dedicado para modelos de linguagem grandes (LLM) e agentes de IA, com o objetivo de fornecer informações em tempo real, precisas e imparciais para ajudar os aplicativos de IA a recuperar e processar dados de forma eficiente.

Ele pode ajudar os desenvolvedores a obter rapidamente resultados para mais de 20 cenários diferentes de mecanismos de busca do Google. Ele suporta várias configurações de parâmetros, pode personalizar pesquisas com base na região, idioma e tipo de dispositivo e fornece dados JSON estruturados para os desenvolvedores usarem diretamente.

Vantagens do Deep SerpAPI

1. Preço mais baixo: O Deep SerpAPI tem o preço de apenas US$ 0,1/mil. É o menor preço do mercado.

2. Fácil de usar: Não há necessidade de escrever código complexo, basta obter dados por meio de chamadas de API.

3. Em tempo real: Cada solicitação pode retornar instantaneamente os resultados de pesquisa mais recentes para garantir a atualidade dos dados.

4. Suporte global: Por meio de endereços IP globais e clusters de navegadores, garanta que os resultados da pesquisa sejam consistentes com a experiência de usuários reais.

5. Tipos de dados ricos: Suporta mais de 20 tipos de pesquisa, como Pesquisa Google, Google Maps, Google Shopping etc.

6. Alta taxa de sucesso: Fornece até 99,995% de disponibilidade de serviço (SLA).

Como usar o playground Deep SerpAPI para raspar informações de hotéis do Google

Deep SerpAPI fornece uma ferramenta online poderosa, Playground, que permite aos desenvolvedores raspar rapidamente informações de hotéis do Google sem escrever código. O Playground é uma interface visual que pode obter dados estruturados de resultados de pesquisa por meio de configurações simples de parâmetros e operações de clique. As etapas detalhadas para usar o Deep SerpAPI Playground para raspar informações de hotéis do Google são as seguintes.

Como obter a CHAVE DA API do Deep SerpAPI:

• Depois de criar uma conta gratuita no Scrapeless, você recebe 20.000 consultas de pesquisa gratuitas.
• Navegue até Gerenciamento de chave API. Em seguida, clique em Criar para gerar uma chave API exclusiva. Depois de criada, basta clicar em AP para copiá-la.

1. Cadastre-se e acesse o Playground

• Crie uma conta: Se ainda não o fez, inscreva-se em uma conta Deep SerpAPI.
• Acesse o Deep SerpApi Playground: Depois de fazer login, navegue até a seção "Deep SerpApi".

2. Defina os parâmetros de pesquisa

• No Playground, insira sua palavra-chave de pesquisa, como "hotéis em Nova York".
• Defina outros parâmetros, como data de check-in, data de check-out, país, idioma etc.

Você também pode clicar para visualizar a documentação oficial da API do Scrapeless para aprender sobre os parâmetros dos Hotéis do Google.

3. Realize uma pesquisa

• Clique no botão "Iniciar pesquisa" e o Playground enviará uma solicitação à API Deep Serp e retornará dados JSON estruturados.
• Os dados retornados incluirão o nome do hotel, detalhes da marca, informações de preço, descrição, classificação, instalações, local próximo, classificação do hotel etc.

4. Visualize e exporte dados

• Navegue pelos dados JSON retornados para visualizar informações detalhadas para cada hotel.
• Se necessário, você pode clicar em "Exportar" no canto superior direito para exportar os dados para o formato CSV ou JSON para análise posterior.

5. Integre ao seu projeto

• Se você precisar integrar os dados ao seu aplicativo, o Deep SerpAPI fornece suporte de biblioteca para várias linguagens de programação, incluindo Python, JavaScript, Ruby, PHP, Java, C#, C++, Swift, Go e Rust.

Código de exemplo (Python)

import json
import requests

class Payload:
    def __init__(self, actor, input_data):
        self.actor = actor
        self.input = input_data

def send_request():
    host = "api.scrapeless.com"
    url = f"https://{host}/api/v1/scraper/request"
    token = "your_token"

    headers = {
        "x-api-token": token
    }

    input_data = {
    "engine": "google_hotel",
       q: query,
       engine: 'google',
       gl: 'us', 
       hl: 'en'  
    }

    payload = Payload("scraper.google.hotel", input_data)

    json_payload = json.dumps(payload.__dict__)

    response = requests.post(url, headers=headers, data=json_payload)

    if response.status_code != 200:
        print("Error:", response.status_code, response.text)
        return

    print("body", response.text)


if __name__ == "__main__":
    send_request()

Plano de preços Deep SerpAPI: acessível e poderoso

Deep SerpAPI fornece uma solução econômica para ajudar os desenvolvedores a obter rapidamente dados da página de resultados de pesquisa do Google (SERP). Seu plano de preços é muito competitivo, com preços a partir de US$ 0,1 por 1.000 consultas, aplicável a mais de 20 cenários de resultados de pesquisa do Google.

Programa de suporte gratuito para desenvolvedores

O Deep SerpAPI agora também oferece um programa de suporte gratuito para desenvolvedores para ajudar os desenvolvedores a integrar e usar melhor sua API. Aqui estão os detalhes do programa:

• Suporte de integração: Integre o Deep SerpAPI às suas ferramentas de IA, aplicativos ou projetos. Já suportamos o Dify e em breve também daremos suporte ao Langchain, Langflow, FlowiseAI e outras estruturas.
• Duração do suporte gratuito: Após a integração, os desenvolvedores podem obter de 1 a 12 meses de suporte gratuito para desenvolvedores compartilhando seus resultados no GitHub ou nas redes sociais.
• Cota de uso: Até 500 mil usos por mês, ajudando os desenvolvedores a não se preocupar com problemas de custo nos estágios iniciais do projeto.

Você pode entrar no Discord para entrar em contato com Liam para saber mais sobre a participação no evento

Conclusão

Em resumo, raspar os preços de hotéis do Google com Node.js pode ser um método valioso para coletar dados de preços, mas apresenta desafios como lidar com conteúdo dinâmico e evitar a detecção. Embora ferramentas como Puppeteer ou Playwright possam ajudar, elas exigem manutenção contínua e experiência técnica. Para otimizar o processo, recomendamos o uso do Scrapeless, que fornece uma solução sem complicações e sem código para extrair dados de preços de hotéis de forma eficiente e confiável. Com o Scrapeless, você pode se concentrar nos insights em vez das complexidades da raspagem da web. Experimente hoje mesmo e simplifique sua coleta de dados!

Recursos adicionais

Como raspar notícias do Google com Python
Como usar o Selenium com o PowerShell
Raspando detalhes do produto do Google Shopping com Scrapeless