
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.
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.
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.
Primeiro, crie um novo diretório para o seu projeto e inicialize-o como um projeto Node.js:
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.
Em seguida, instale as dependências necessárias, incluindo axios para fazer solicitações HTTP e cheerio para analisar HTML:
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
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:
Carregando um Documento HTML:
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);
Selecionando Elementos:
Selector de Elemento:
const h1 = $('h1'); // Seleciona todos os elementos <h1>
console.log(h1.text()); // Saída: Olá, mundo!
Selector de Classe:
const title = $('.title'); // Seleciona elementos com class="title"
console.log(title.text()); // Saída: Olá, mundo!
Selector de ID:
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:
const link = $('a[href="https://example.com"]'); // Seleciona o elemento <a> com um atributo href específico
console.log(link.text()); // Saída: Link
Navegando e Manipulando Elementos:
Navegando pelos Elementos:
$('p').each((index, element) => {
console.log($(element).text()); // Imprime o conteúdo de texto de cada elemento <p>
});
Modificando o Conteúdo dos Elementos:
$('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:
$('#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.
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:
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();
axios e cheerio.fetchData faz uma solicitação GET HTTP para a URL de destino usando axios. O conteúdo HTML da resposta é carregado no Cheerio.<title> e todos os elementos <h1>, <h2> e <h3>.
Para executar o script de scraping, execute o seguinte comando no seu terminal:
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.
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:
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.
Medidas Antiraspagem: Os sites implementam várias técnicas antiraspagem para impedir a extração automatizada de dados:
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:
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.
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.

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:
# 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.
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.
Aqui está um breve exemplo de como usar o Puppeteer em conjunto com o Cheerio:
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.
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!
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.

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.
