Web Scraping com Puppeteer: Blueprint para Dados Precisos

Neste tutorial, mostramos como configurar o Puppeteer, executar tarefas de scraping em sites complexos, e evitar bloqueios de bots com hacks e boas práticas. Ideal para desenvolvedores que buscam extrair dados web com precisão e fidelidade usando uma das ferramentas mais poderosas do Node.js.

Ah, o web scraping! Desde os tempos mais remotos da internet (ou, pelo menos, desde 2010, quando eu mesmo comecei a criar meus primeiros robôs), ele tem sido o sonho de consumo de desenvolvedores e empresas. Quem nunca se viu na necessidade quase heróica — ou desesperada — de coletar dados com a precisão cirúrgica de um bisturi?

Um Scraper Incompleto — E a Necessidade de um Novo Ato

Se você seguiu meu tutorial anterior (deletei, estava muito ruim e não mais funcional), provavelmente já enfrentou alguns percalços. Afinal, o web scraping básico que apresentei é como um cavaleiro medieval que vai à guerra apenas com uma adaga: nobre, corajoso, mas fadado à derrota (entende o motivo de ter apagado?). O problema é que muitas páginas hoje são dinâmicas, cheias de JavaScript que se desenrola em tempo real, moldando o HTML enquanto você tenta, em vão, capturar algo que nem sequer está lá ainda.

Imagine, leitor, a desilusão do pobre desenvolvedor, que vê um HTML na tela do navegador, mas que, ao rodar seu scraper, recebe… nada. Absolutamente nada. A página, aquela ingrata, escondeu o ouro nas profundezas de seus scripts. Nosso bravo scraper, no entanto, é como um leitor ingênuo que tenta decifrar “Dom Casmurro” sem entender a malícia de Capitu: ele jamais verá o que está nas entrelinhas.

Mas não temamos! Para todo problema existe uma solução, e é aí que entra o headless browser — aquele navegador que, como um bom espião, faz tudo o que um navegador comum faz, mas sem que você o veja. É como se ele fosse um espectador invisível no teatro da web, assistindo à peça inteira enquanto o pobre HTML estático morre de tédio.

O Incomparável Poder do Puppeteer

Como todo bom protagonista, precisamos de um aliado à altura. E o nome dele é Puppeteer. Ah, o Puppeteer… Não pensem vocês que ele é um simples navegador sem cabeça. Longe disso! Ele é o artista invisível que executa com perfeição cada script, cada detalhe, como se fosse o maestro de uma grande sinfonia.

Diferente de outros “browsers sem rosto”, o Puppeteer tem a graça de usar o Chrome, esse ícone da modernidade digital, em modo headless, ou seja, sem interface gráfica. Ele faz todo o trabalho pesado, como um empregado discreto que resolve seus problemas enquanto você aproveita o lado bom da vida. O Chrome, em sua plenitude silenciosa, renderiza páginas e executa scripts como um ator que não erra uma linha.

Se antes eu sofria com ferramentas como PhantomJS, que me deixavam na mão, o Puppeteer apareceu como o salvador da pátria. Imagine o alívio! Ele roda o JavaScript da página, carrega o DOM completo, e faz tudo isso sem a inconveniência de uma janela de navegador piscando na sua cara.

Preparando o Cenário: Instalando Puppeteer

Agora, caro leitor, se você é desses que gosta de colocar a mão na massa — porque em teoria tudo parece fácil, mas a prática exige suor —, vamos ver como configurar o Puppeteer. Primeiro, tenha certeza de que você já tem o Node.js instalado. Se não tiver, está perdendo o bonde da história! Após isso, vamos criar o projeto e instalar o Puppeteer:

npm init -y
npm install puppeteer

Em seguida, vamos escrever o esqueleto do nosso scraper. Veja que é simples, quase poético, como as palavras de um romancista ao descrever a cena:

const puppeteer = require('puppeteer');

async function scrap() {
    const browser = await puppeteer.launch({ headless: "new" });
    const page = await browser.newPage();
    await page.goto('http://books.toscrape.com/');
    await page.waitForNetworkIdle();

    const result = await page.evaluate(() => {
        const books = [];
        document.querySelectorAll('h3 > a').forEach(book => books.push(book.title));
        return books;
    });

    await browser.close();
    console.log(result);
}

scrap();

Aqui, invocamos o Puppeteer e ele, como um mago, lança o Chrome em modo headless, acessa a página e espera que todos os scripts e requisições se acalmem, como um público que aguarda o fim do espetáculo antes de aplaudir. Em seguida, coletamos os títulos dos livros. Simples, direto, sem enrolações.

Rasgando o Véu da Paginação

Mas você há de me perguntar: e quando a página tem paginação? Ah, jovem padawan, aí o jogo fica interessante! Um web scraper digno desse nome precisa navegar entre páginas como um detetive que segue as pistas de um caso complicado.

Vamos fazer isso no exemplo do Books to Scrape, onde cada página exibe uma lista de livros e um botão “next” para passar à página seguinte. Veja como nosso Puppeteer, sempre diligente, faz o trabalho:

async function scrap() {
    const browser = await puppeteer.launch({ headless: "new" });
    const page = await browser.newPage();
    await page.goto('http://books.toscrape.com/');
    await page.waitForNetworkIdle();

    let hasNextPage = true;
    const allBooks = [];

    while (hasNextPage) {
        const booksOnPage = await page.evaluate(() => {
            const books = [];
            document.querySelectorAll('h3 > a').forEach(book => books.push(book.title));
            return books;
        });
        allBooks.push(...booksOnPage);

        // Verifica se existe uma próxima página
        hasNextPage = await page.evaluate(() => {
            const nextButton = document.querySelector('.next > a');
            return !!nextButton;
        });

        if (hasNextPage) {
            await Promise.all([
                page.click('.next > a'),
                page.waitForNetworkIdle(),
            ]);
        }
    }

    await browser.close();
    console.log(allBooks);
}

Conclusão: Um Final Feliz?

Nem sempre, meu caro leitor. No mundo do web scraping, o final feliz depende de muitas variáveis: o servidor pode bloqueá-lo, o site pode mudar sua estrutura, ou o JavaScript pode se rebelar como um personagem trágico que decide mudar o rumo da história. Mas com Puppeteer, você estará mais preparado do que nunca para enfrentar esses desafios e criar scrapers que capturam dados com maestria.

Por hoje, deixo aqui a promessa de que o web scraping com Node.js e Puppeteer é um caminho sem volta, mas daqueles que vale a pena trilhar. Até a próxima, e boa sorte nas suas aventuras digitais!

Hacks e Links Úteis para Masterizar Puppeteer e Node.js

Antes de encerrar, meu estimado leitor, vou lhe poupar alguns tropeços pelo caminho — afinal, não quero que sua jornada com o Puppeteer e Node.js termine como uma peça de teatro mal ensaiada. Aqui vão alguns hacks e atalhos valiosos para otimizar seu trabalho e garantir que seu web scraper opere com a eficiência de um mestre dos bastidores.

Hacks para Puppeteer

1. Use waitForSelector para Garantir a Existência de Elementos
   • Ao invés de esperar cegamente que a página esteja pronta, use await page.waitForSelector('.classe-do-seletor'). Isso garante que seu scraper só avance quando o elemento que você quer manipular estiver disponível. Menos chance de erros, mais precisão!

await page.waitForSelector('h3 > a');

Manipule Cookies para Contornar Bloqueios

• Alguns sites podem tentar bloquear scrapers por meio de verificações repetidas de IP. Manipular cookies e sessões pode ajudar seu bot a se passar por um usuário real, evitando o bloqueio.

const cookies = await page.cookies();
await page.setCookie(...cookies);

Cuidado com o Consumo de Memória

• Puppeteer pode ser uma fera faminta por memória. Abra o navegador em modo headless, mas feche as abas que não estão sendo usadas. Você pode usar browser.newPage() com moderação e fechar abas antigas com page.close().

Automatize Tarefas com evaluate()

• O page.evaluate() é um canivete suíço. Use-o para rodar JavaScript diretamente no contexto da página que você está raspando. Ele pode clicar em botões, preencher formulários e até fazer scroll automático, como um assistente que trabalha sem parar nos bastidores.

await page.evaluate(() => {
    document.querySelector('input[name="search"]').value = 'Node.js';
    document.querySelector('button[type="submit"]').click();
});

Defina User-Agents Diferentes para Evitar Detecção

• Mude seu User-Agent regularmente para evitar que seu scraper seja identificado como um bot. Isso é especialmente útil para sites que detectam e bloqueiam scrapers com base em padrões de comportamento.

await page.setUserAgent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36');

Use setViewport() para Simular Resoluções de Tela

• Quer que seu scraper se passe por um usuário móvel? Ajuste a resolução com setViewport() para simular diferentes dispositivos.

await page.setViewport({ width: 1280, height: 800 });

Links Úteis

Agora, para aqueles que desejam se aprofundar nesse fascinante mundo de Puppeteer e Node.js, seguem alguns recursos essenciais para aprender mais e aprimorar suas habilidades:

• Documentação Oficial do Puppeteer: A bíblia para qualquer desenvolvedor que queira entender tudo sobre esta biblioteca.
  • https://pptr.dev/
• Introdução ao Node.js: Se você é iniciante ou precisa revisar os conceitos básicos de Node.js, esse guia oficial é o melhor lugar para começar.
  • https://nodejs.org/en/docs/guides/getting-started-guide/
• Artigo do Google sobre Web Scraping com Puppeteer: Um tutorial detalhado e oficial sobre como usar o Puppeteer para scraping.
  • https://developers.google.com/web/tools/puppeteer/articles
• Cheatsheet de Puppeteer: Se você gosta de atalhos e referências rápidas, esse cheatsheet é uma mão na roda.
  • https://github.com/cheatsheetseries/puppeteer-cheatsheet
• Playwright: Alternativa mais robusta ao Puppeteer, caso você queira testar algo diferente (suporta múltiplos navegadores, incluindo Firefox e Safari).
  • https://playwright.dev/
• Crie um Bot com Node.js e Puppeteer: Um artigo com passo a passo de como criar bots automatizados, que pode ser muito útil para quem está começando.
  • https://www.smashingmagazine.com/2020/05/headless-chrome-puppeteer-node-bots/

Com esses recursos em mãos, você estará mais do que preparado para enfrentar o cenário caótico da web e seus desafios, enquanto continua refinando suas habilidades em Node.js e web scraping.