ProdutosIntegraçõesRecursosDocumentaçãoPreços
Começar agora

© 2026 CapSolver. All rights reserved.

Contacte-nos

Slack: lola@capsolver.com

Produtos

  • reCAPTCHA v2
  • reCAPTCHA v3
  • Cloudflare Turnstile
  • Cloudflare Challenge
  • AWS WAF
  • Extensão de Navegador
  • Mais tipos de CAPTCHA

Integrações

  • Selenium
  • Playwright
  • Puppeteer
  • n8n
  • Parceiros
  • Ver todas as integrações

Recursos

  • Programa de Referenciação
  • Documentação
  • Referência da API
  • Blog
  • FAQ
  • Glossário
  • Estado

Legal

  • Termos de Serviço
  • Política de Privacidade
  • Política de Reembolso
  • Não vender os meus dados pessoais
Blog/The Other CAPTCHA/Web scraping com Cheerio e Node.js 2026
Jun14, 2024

Web scraping com Cheerio e Node.js 2026

Adélia Cruz

Adélia Cruz

Neural Network Developer

O web scraping é uma técnica poderosa para extrair dados de sites, amplamente utilizada em análise de dados, pesquisas de mercado e agregação de conteúdo. Até 2026, utilizar o Cheerio e o Node.js para web scraping continua sendo uma abordagem popular e eficiente. Este artigo explorará o processo de uso do Cheerio e do Node.js para web scraping, fornecendo um guia completo e um exemplo prático.

Índice

  • O que é Cheerio?
  • Pré-requisitos
  • Configurando o Projeto
  • API de Seleção do Cheerio
  • Escrevendo o Script de Scraping
  • Executando o Script
  • Desafios do Web Scraping com Cheerio
  • Lidando com CAPTCHAs no Web Scraping
  • Lidando com Páginas Dinâmicas
  • Conclusão

O que é Cheerio?

Cheerio é uma implementação rápida, flexível e leve do jQuery projetada especificamente para aplicações no lado do servidor. Ele permite que os desenvolvedores analisem e manipulem documentos HTML usando uma sintaxe semelhante ao jQuery em um ambiente Node.js. Ao contrário de ferramentas baseadas em navegador, o Cheerio não realiza renderização real da web, mas manipula diretamente strings HTML, tornando-o extremamente eficiente para muitas tarefas de scraping. Por sinal, Puppeteer é uma excelente alternativa para scraping com Cheerio.

Pré-requisitos

Antes de mergulhar no código, certifique-se de que você tenha o Node.js e o npm (Node Package Manager) instalados no seu sistema. Se ainda não estiverem instalados, você pode baixá-los e instalá-los no site oficial do Node.js.

Configurando o Projeto

Passo 1: Criar um Novo Diretório do Projeto

Primeiro, crie um novo diretório para o seu projeto e inicialize-o como um projeto Node.js:

bash Copy
mkdir web-scraping
cd web-scraping
npm init -y

A opção -y responde automaticamente "sim" a todas as perguntas, configurando um arquivo package.json padrão.

Passo 2: Instalar Dependências

Em seguida, instale as dependências necessárias, incluindo axios para fazer solicitações HTTP e cheerio para analisar HTML:

bash Copy
npm install axios cheerio

Estou com dificuldades para resolver repetidamente o irritante CAPTCHA?

Descubra a resolução automática de CAPTCHA com a tecnologia de desbloqueio da web da Capsolver!

Claime seu Código de Bônus para as melhores soluções de CAPTCHA; CapSolver. |: WEBS. Após resgatá-lo, você receberá um bônus adicional de 5% após cada recarga, sem limite

API de Seleção do Cheerio

Cheerio é uma implementação rápida, flexível e leve do núcleo do jQuery projetada especificamente para o servidor. Ele permite que você use uma sintaxe semelhante ao jQuery para manipular documentos HTML em um ambiente Node.js.

Aqui está uma explicação detalhada da API de seleção do Cheerio com exemplos de código:

  1. Carregando um Documento HTML:

    javascript Copy
    const cheerio = require('cheerio');
    const html = `
      <html>
        <head>
          <title>Exemplo</title>
        </head>
        <body>
          <h1 class="title">Olá, mundo!</h1>
          <div id="content">
            <p>Este é um parágrafo.</p>
            <a href="https://example.com">Link</a>
          </div>
        </body>
      </html>
    `;
    const $ = cheerio.load(html);
  2. Selecionando Elementos:

    • Selector de Elemento:

      javascript Copy
      const h1 = $('h1'); // Seleciona todos os elementos <h1>
      console.log(h1.text()); // Saída: Olá, mundo!
    • Selector de Classe:

      javascript Copy
      const title = $('.title'); // Seleciona elementos com class="title"
      console.log(title.text()); // Saída: Olá, mundo!
    • Selector de ID:

      javascript Copy
      const content = $('#content'); // Seleciona o elemento com id="content"
      console.log(content.html()); // Saída: <p>Este é um parágrafo.</p><a href="https://example.com">Link</a>
    • Selector de Atributo:

      javascript Copy
      const link = $('a[href="https://example.com"]'); // Seleciona o elemento <a> com um atributo href específico
      console.log(link.text()); // Saída: Link
  3. Navegando e Manipulando Elementos:

    • Navegando pelos Elementos:

      javascript Copy
      $('p').each((index, element) => {
        console.log($(element).text()); // Imprime o conteúdo de texto de cada elemento <p>
      });
    • Modificando o Conteúdo dos Elementos:

      javascript Copy
      $('h1.title').text('Novo Título'); // Modifica o conteúdo de texto do elemento <h1>
      console.log($('h1.title').text()); // Saída: Novo Título
    • Adicionando e Removendo Elementos:

      javascript Copy
      $('#content').append('<p>Outro parágrafo.</p>'); // Adiciona um novo elemento <p> dentro de #content
      console.log($('#content').html()); // Saída: <p>Este é um parágrafo.</p><a href="https://example.com">Link</a><p>Outro parágrafo.</p>
      
      $('a').remove(); // Remove todos os elementos <a>
      console.log($('#content').html()); // Saída: <p>Este é um parágrafo.</p><p>Outro parágrafo.</p>

Esses exemplos ilustram como você pode usar a API de seleção do Cheerio para selecionar, navegar e manipular elementos HTML de forma semelhante ao jQuery, mas dentro de um ambiente Node.js.

Escrevendo o Script de Scraping

Crie um arquivo chamado scraper.js no seu diretório de projeto. Este arquivo conterá o script para extrair dados de um site de destino. Adicione o seguinte código ao scraper.js:

javascript Copy
const axios = require('axios');
const cheerio = require('cheerio');

// URL de destino
const url = 'https://example.com';

async function fetchData() {
  try {
    // Faz uma solicitação HTTP para buscar o conteúdo HTML
    const { data } = await axios.get(url);
    // Carrega o documento HTML no Cheerio
    const $ = cheerio.load(data);

    // Extrai dados do HTML
    const title = $('title').text();
    const headings = [];
    $('h1, h2, h3').each((index, element) => {
      headings.push($(element).text());
    });

    // Exibe os dados extraídos
    console.log('Título:', title);
    console.log('Títulos:', headings);
  } catch (error) {
    console.error('Erro ao buscar dados:', error);
  }
}

fetchData();

Explicação do Código

  1. Importando Módulos: O script começa importando os módulos axios e cheerio.
  2. Definindo a URL de Destino: A URL do site a ser raspado é definida.
  3. Buscando Dados: A função fetchData faz uma solicitação GET HTTP para a URL de destino usando axios. O conteúdo HTML da resposta é carregado no Cheerio.
  4. Analisando HTML: Usando a sintaxe semelhante ao jQuery do Cheerio, o script extrai o conteúdo da tag <title> e todos os elementos <h1>, <h2> e <h3>.
  5. Exibindo Resultados: Os dados extraídos são registrados no console.

Executando o Script

Para executar o script de scraping, execute o seguinte comando no seu terminal:

bash Copy
node scraper.js

Se tudo estiver configurado corretamente, você deverá ver o título da página raspada e o conteúdo de todas as tags de título impresso no console.

Desafios do Web Scraping com Cheerio

Embora o Cheerio ofereça várias vantagens para o web scraping, ele também apresenta seus próprios desafios que os desenvolvedores podem enfrentar:

  1. Sites Dinâmicos e JavaScript: Um dos principais desafios com o Cheerio é lidar com sites dinâmicos que dependem fortemente do JavaScript. Sites modernos frequentemente usam JavaScript para carregar conteúdo dinamicamente após o carregamento inicial da página. Como o Cheerio analisa HTML estático, ele pode não capturar conteúdo gerado dinamicamente, o que pode limitar a eficácia da raspagem.

  2. Medidas Antiraspagem: Os sites implementam várias técnicas antiraspagem para impedir a extração automatizada de dados:

    • CAPTCHAs: Problema grave que você pode encontrar na raspagem que é projetado para distinguir entre humanos e robôs, os CAPTCHAs exigem que os usuários completem tarefas como reconhecimento de imagens ou entrada de texto.
    • Bloqueio de IP: Os sites podem bloquear endereços IP associados a atividades de raspagem para evitar solicitações excessivas.
    • Detecção de User-Agent: Detectar user-agents não padrão ou suspeitos ajuda os sites a identificar e bloquear raspadores.
    • Páginas Web Dinâmicas: Sites que usam geração de conteúdo JavaScript dinâmico podem apresentar desafios, pois o conteúdo pode não estar diretamente acessível por meio da análise estática do Cheerio.

Como desenvolvedor de web scraping, entender esses desafios é crítico para abordá-los de forma eficaz. Existem muitas estratégias para mitigar soluções para esses problemas, e nas próximas páginas, explicaremos como resolver dois dos maiores problemas na raspagem com a solução de CAPTCHA e como lidar com páginas dinâmicas:

Lidando com CAPTCHAs no Web Scraping

CAPTCHAs representam um desafio significativo no web scraping, pois são projetados para distinguir humanos de robôs. Ao encontrá-los, seu script de raspagem deve resolvê-los para prosseguir de forma eficiente. Para empreendimentos de web scraping escaláveis, soluções como CapSolver oferecem alta precisão e capacidades rápidas de resolução de CAPTCHA.

Integração de Solucionadores de CAPTCHA

Vários serviços de resolução de CAPTCHA podem ser integrados aos seus scripts de raspagem. Aqui, focamos no CapSolver:

Passo 1: Registre-se no CapSolver

Para começar, acesse o painel do usuário do CapSolver e registre sua conta.

Passo 2: Obtenha sua Chave de API

Após o registro, recupere sua chave de API na página inicial do painel.

Código de Exemplo para Integração com CapSolver

Integrar o CapSolver ao seu projeto de web scraping ou automação é simples. Abaixo está um exemplo em Python mostrando como usar a API do CapSolver:

python Copy
# pip install requests
import requests
import time

# TODO: defina sua configuração
api_key = "SUA_CHAVE_API"  # sua chave de API do CapSolver
site_key = "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"  # chave do site reCAPTCHA
site_url = ""  # URL do seu site de destino


def resolver_captcha():
    payload = {
        "clientKey": api_key,
        "task": {
            "type": 'ReCaptchaV2TaskProxyLess',
            "websiteKey": site_key,
            "websiteURL": site_url
        }
    }
    res = requests.post("https://api.capsolver.com/createTask", json=payload)
    resp = res.json()
    task_id = resp.get("taskId")
    if not task_id:
        print("Falha ao criar tarefa:", res.text)
        return
    print(f"Obtive taskId: {task_id} / Recuperando resultado...")

    while True:
        time.sleep(3)  # atraso
        payload = {"clientKey": api_key, "taskId": task_id}
        res = requests.post("https://api.capsolver.com/getTaskResult", json=payload)
        resp = res.json()
        status = resp.get("status")
        if status == "ready":
            return resp.get("solution", {}).get('gRecaptchaResponse')
        if status == "failed" or resp.get("errorId"):
            print("Solução falhou! Resposta:", res.text)
            return


token_captcha = resolver_captcha()
print(token_captcha)

Este script ilustra como utilizar a API do CapSolver para resolver desafios de reCAPTCHA. Integrar uma solução como esta aos seus projetos de raspagem aumenta a eficiência ao automatizar a resolução de CAPTCHA, tornando o processo de extração de dados mais fluido.

Lidando com Páginas Dinâmicas

Para páginas web que carregam conteúdo dinamicamente por meio de JavaScript, você pode precisar usar um navegador sem cabeça como puppeteer. O Puppeteer pode simular um usuário real navegando na web, permitindo que você raspe conteúdo que aparece apenas após a execução do JavaScript.

Exemplo com Puppeteer

Aqui está um breve exemplo de como usar o Puppeteer em conjunto com o Cheerio:

javascript Copy
const puppeteer = require('puppeteer');
const cheerio = require('cheerio');

async function fetchData() {
  const browser = await puppeteer.launch();
  const page = await browser.newPage();
  await page.goto('https://example.com');

  const content = await page.content();
  const $ = cheerio.load(content);

  const title = $('title').text();
  const headings = [];
  $('h1, h2, h3').each((index, element) => {
    headings.push($(element).text());
  });

  console.log('Título:', title);
  console.log('Títulos:', headings);

  await browser.close();
}

fetchData();

Este script inicia um navegador sem cabeça, navega até a URL de destino e recupera o conteúdo HTML após a execução do JavaScript. Em seguida, ele usa o Cheerio para analisar o HTML e extrair os dados desejados.

Conclusão

O web scraping com Cheerio e Node.js é uma combinação poderosa para extrair dados de sites de forma eficiente. A sintaxe semelhante ao jQuery do Cheerio torna fácil navegar e manipular documentos HTML, enquanto o Node.js fornece um ambiente robusto para lidar com solicitações HTTP e processar dados.

No entanto, os desenvolvedores devem estar cientes dos desafios impostos por conteúdo dinâmico e medidas antiraspagem, como CAPTCHAs. Integrar soluções como CapSolver pode ajudar a superar esses obstáculos, garantindo que seus scripts de raspagem permaneçam eficazes e confiáveis.

Espero que este artigo o ajude a começar com o web scraping em 2026 e forneça dados úteis para seus projetos!

Ver mais

The Other CAPTCHAApr 03, 2026

Como lidar com os bloqueios de raspagem da web: métodos práticos que funcionam

Aprenda como lidar efetivamente com os bloqueios de scraping na web. Descubra métodos práticos, insights técnicos sobre detecção de bots e soluções confiáveis para extração de dados.

Ethan Collins
Ethan Collins
The Other CAPTCHAApr 03, 2026

Tempo de Resposta da API de Resolução de CAPTCHA Explicado: Fatores de Velocidade e Desempenho

Entenda o tempo de resposta da API de resolução de CAPTCHA, seu impacto na automação e os principais fatores que afetam a velocidade. Aprenda como otimizar o desempenho e aproveitar soluções eficientes como a CapSolver para resolução rápida de CAPTCHA.

Índice

Emma Foster
Emma Foster
The Other CAPTCHAApr 02, 2026

O que é uma API de resolução de CAPTCHA? Como Funciona e Quando Usá-la

Aprenda o que é uma API de resolução de CAPTCHA, como ela funciona e quando usá-la para automação. Descubra os benefícios da resolução de CAPTCHA com inteligência artificial para raspagem de dados.

Sora Fujimoto
Sora Fujimoto
The Other CAPTCHAFeb 27, 2026

Dominando os Desafios do CAPTCHA no Scraping de Dados de Empregos (Guia de 2026)

Um guia abrangente para compreender e superar o desafio CAPTCHA na raspagem de dados de vagas. Aprenda a lidar com o reCAPTCHA e outros obstáculos com nossas dicas especializadas e exemplos de código.

Anh Tuan
Anh Tuan