Parsing HTML with Node.js and Cheerio

Master server-side HTML parsing with Cheerio's jQuery-compatible API. Learn to extract, manipulate, and transform HTML documents efficiently in your Node.js applications.

Introduction

In modern web development, the ability to parse and manipulate HTML programmatically opens doors to powerful capabilities--from extracting structured data from external websites to building content aggregation systems and automated testing pipelines. Cheerio, the fast and elegant HTML parsing library for Node.js, has become an essential tool in the modern JavaScript ecosystem, enabling developers to work with HTML with the same intuitive syntax they already know from jQuery.

Cheerio stands apart from other HTML parsing solutions because it implements a substantial subset of jQuery's API while operating entirely on the server side. Unlike browser-based DOM manipulation libraries, Cheerio doesn't require a full browser environment--it loads HTML into memory and provides a lightweight, high-performance API for traversing and modifying that structure. This makes it ideal for build scripts, data pipelines, API backends, and server-side applications where speed and efficiency matter.

For developers working with Next.js and modern JavaScript frameworks, Cheerio fits naturally into the server-side ecosystem. Whether you're building a web scraping service, creating a content migration pipeline, implementing SEO analysis tools, or simply need to extract specific data from HTML documents, Cheerio provides the flexibility and performance needed for production applications. Its jQuery-compatible syntax means minimal learning curve for developers already familiar with frontend development, while its server-side architecture ensures it integrates seamlessly with Node.js backends and API routes.

This guide explores Cheerio's capabilities comprehensively, from basic installation and syntax to advanced patterns for handling complex HTML documents and optimizing performance in production environments. We'll cover practical code examples, industry best practices, and real-world use cases that demonstrate how Cheerio powers sophisticated web development workflows.

Why Cheerio for HTML Processing

Key capabilities that make Cheerio the go-to choice for server-side HTML manipulation

jQuery-Compatible Syntax

Leverage familiar jQuery methods like .find(), .text(), .attr(), and .html() without browser dependencies.

High Performance

Optimized for speed with a lightweight DOM model that focuses on parsing and manipulation, not browser simulation.

Server-Side Operation

Works entirely in Node.js without requiring a headless browser, reducing resource requirements significantly.

Flexible Integration

Works seamlessly with Next.js, Express, and other Node.js frameworks for diverse application architectures.

Getting Started with Cheerio

Installation and Project Setup

Installing Cheerio in a Node.js project follows the standard pattern for npm packages. The library is published as cheerio on npm, and can be added to any Node.js or Next.js project with a single command. For projects using TypeScript, the type definitions are available as a separate package, providing full type safety and IDE support for Cheerio's API.

# Basic installation
npm install cheerio

# With TypeScript support
npm install cheerio @types/cheerio

The package exports a single function that serves as the entry point to Cheerio's API. This function, conventionally imported as $ or cheerio, creates a new Cheerio wrapper around parsed HTML. The syntax intentionally mirrors jQuery's $ function, reinforcing the library's jQuery-compatible design philosophy.

import cheerio from 'cheerio';

const html = `
<!DOCTYPE html>
<html>
<head>
 <title>Sample Page</title>
</head>
<body>
 <div class="content">
 <h1>Welcome</h1>
 <p>This is a sample paragraph.</p>
 </div>
</body>
</html>
`;

// Load HTML into Cheerio's DOM
const $ = cheerio.load(html);

// Use jQuery-like syntax to traverse and manipulate
$('h1').text(); // "Welcome"
$('.content p').text(); // "This is a sample paragraph."

For TypeScript projects, importing the type definitions provides autocomplete and type checking for Cheerio's methods. The type definitions cover all public API methods and are regularly updated with new Cheerio releases, making TypeScript integration straightforward and reliable.

In Next.js and other modern frameworks, Cheerio is typically used within server-side contexts--API routes, server components, build scripts, or backend services. Because Cheerio operates purely in JavaScript without browser dependencies, it works in any Node.js environment, including Next.js serverless functions and Edge runtime where Node.js APIs are available.

Loading HTML from Different Sources

Cheerio's load() function accepts HTML in various formats, enabling flexible integration with different data sources in your application. The most straightforward approach works with raw HTML strings, which might come from database records, file reads, or inline content.

const $ = cheerio.load('<html><body><h1>Hello</h1></body></html>');

When working with files, the HTML content can be loaded using Node.js file system APIs and then passed to Cheerio's load function. This pattern is common for processing static HTML files, generating build-time content, or working with locally stored templates.

import fs from 'fs';
import path from 'path';
import cheerio from 'cheerio';

// Read HTML file asynchronously
const htmlPath = path.join(process.cwd(), 'content', 'page.html');
const html = await fs.promises.readFile(htmlPath, 'utf-8');
const $ = cheerio.load(html);

// Process the content
const headings = $('h1, h2, h3').map((i, el) => $(el).text()).get();

For web scraping scenarios, the HTML typically comes from HTTP responses. Combining Cheerio with an HTTP client like Axios or the native fetch API enables complete web scraping workflows. The pattern involves fetching the page content, loading it into Cheerio, and then using Cheerio's selectors to extract desired data.

import axios from 'axios';
import cheerio from 'cheerio';

async function scrapePage(url) {
 // Fetch the page content
 const response = await axios.get(url);

 // Load into Cheerio
 const $ = cheerio.load(response.data);

 // Extract data using selectors
 const title = $('title').text();
 const headings = $('h1, h2').map((i, el) => $(el).text()).get();
 const links = $('a[href]').map((i, el) => ({
 text: $(el).text().trim(),
 href: $(el).attr('href')
 })).get();

 return { title, headings, links };
}

Core API: Selecting and Traversing Elements

CSS Selector Fundamentals

Cheerio's selector engine supports standard CSS selectors, providing a familiar and powerful way to locate elements within parsed HTML. This compatibility means that skills developed for frontend development--selecting elements by class, ID, attribute, or structural relationship--transfer directly to server-side HTML manipulation with Cheerio.

Element selection by class name uses the dot notation that CSS developers know well. The $('.class-name') syntax returns a Cheerio collection containing all elements with the specified class. From this collection, developers can extract content, iterate over elements, or apply further filtering.

// Select by class
const articles = $('.article-content');

// Select by ID
const mainContent = $('#main-content');

// Select by tag name
const paragraphs = $('p');

// Combine selectors
const featuredLinks = $('a.featured-link');

Tag selection provides broad coverage when working with specific element types. When combined with attribute selectors, the selection becomes more precise. Attribute selectors use square bracket notation and support various matching strategies including exact matches, partial matches, and presence checks.

// Elements with specific attribute
const externalLinks = $('a[target="_blank"]');

// Partial attribute match
const httpsLinks = $('a[href^="https://"]');

// Attribute containing value
const mailLinks = $('a[href*="mailto:"]');

// Multiple conditions
const socialLinks = $('a[target="_blank"][rel="noopener"]');

The descendant and child combinators enable selection based on element relationships. The space combinator selects all descendants while the greater-than symbol restricts selection to direct children. These structural selectors are essential for navigating complex HTML hierarchies.

// All descendants
const listItems = $('.container li');

// Direct children only
const immediateChildren = $('.container > li');

// Next sibling
const secondParagraphs = $('p + p');

// All following siblings
const followingHeadings = $('h2 ~ h2');

Traversal Methods

Beyond basic selection, Cheerio provides a comprehensive set of traversal methods for moving through the DOM structure. These methods parallel jQuery's traversal API and enable flexible navigation to parent, sibling, and descendant elements relative to a currently selected collection.

The find() method searches within the current selection's descendants, while closest() searches upward through ancestors. These methods complement CSS selectors by allowing dynamic, programmatic element location based on runtime conditions.

// Find descendants
const allLinks = $('.content').find('a');

// Find closest ancestor
const section = $('.highlight').closest('section');

// Filter selection
const visibleParagraphs = $('p').filter('.visible');

// Get first or last
const firstSection = $('section').first();
const lastSection = $('section').last();

Parent and sibling traversal methods provide alternative navigation paths through the document structure. These methods are particularly useful when you need to move from a known element to its contextually related elements.

// Parent traversal
const parentSection = $('.item').parent();
const parents = $('.item').parents('.container');

// Sibling traversal
const nextItem = $('.item').next();
const prevItem = $('.item').prev();
const allSiblings = $('.item').siblings();

The each() method enables iteration over selected elements, providing access to each element's index and the Cheerio wrapper for that element. This pattern is fundamental for processing multiple elements and building data structures from HTML content.

const products = [];

$('.product-item').each((index, element) => {
 const product = {
 name: $(element).find('.name').text(),
 price: $(element).find('.price').text(),
 url: $(element).find('a').attr('href')
 };
 products.push(product);
});

Extracting and Modifying Content

Getting Element Content

Cheerio provides multiple methods for extracting content from selected elements, each serving different use cases. The text() method retrieves all text content within an element, while html() returns the inner HTML structure. The attr() method extracts attribute values, enabling access to href, src, and other element attributes.

Text extraction automatically normalizes whitespace, collapsing multiple spaces and removing leading/trailing whitespace. This behavior mirrors jQuery's text() method and produces clean, readable text content without manual trimming.

// Get text content
const headingText = $('h1').text();
const allParagraphText = $('article p').text();

// Get HTML content
const articleHTML = $('article').html();

// Get attribute values
const linkHref = $('a').attr('href');
const imageSrc = $('img').attr('src');
const imageAlt = $('img').attr('alt');

// Handle multiple elements
const allLinks = $('a').map((i, el) => $(el).attr('href')).get();

When working with elements that may or may not exist, it's important to handle empty selections gracefully. Cheerio methods on empty selections return empty strings or null values rather than throwing errors, but the calling code should account for these cases to avoid unexpected behavior.

For more complex content extraction, Cheerio supports data attributes and custom attributes. HTML5 data attributes are accessed like any other attribute, enabling structured metadata extraction from elements.

// Extract data attributes
const productId = $('.product').data('id');
const category = $('.product').data('category');

// Get all links with structured data
const navItems = $('.nav-link').map((i, el) => ({
 label: $(el).text(),
 url: $(el).attr('href'),
 active: $(el).data('active')
})).get();

Modifying HTML Documents

Cheerio's modification capabilities enable programmatic transformation of HTML documents. Methods for setting text, HTML, and attributes support both single-value assignment and function-based dynamic values that compute new content based on existing element state.

Content modification methods operate on the DOM in memory, enabling sophisticated transformations before serialization. The modified DOM can be serialized back to an HTML string using the html() method without arguments.

// Modify text content
$('h1').text('New Title');

// Modify HTML content
$('.description').html('<p>Updated description</p>');

// Set attributes
$('img').attr('alt', 'New alt text');
$('a').attr('target', '_blank');

// Add classes
$('.button').addClass('primary');
$('.item').addClass('featured', 'highlighted');

// Remove classes
$('.old').removeClass('deprecated');

// Toggle classes
$('.expandable').toggleClass('expanded');

Creating new elements and inserting them into the DOM follows the familiar jQuery pattern. Elements can be created from HTML strings and then inserted at specific positions relative to existing elements.

// Create new elements
const newLink = $('<a>', {
 href: '/about',
 text: 'About Us',
 class: 'nav-link'
});

// Insert elements
$('.navigation').append(newLink);
$('.sidebar').prepend('<h3>Contents</h3>');

// Insert before or after
$('.featured').before('<hr class="divider">');
$('.featured').after('<div class="meta">Featured</div>');

// Wrap elements
$('.needs-container').wrap('<div class="container"></div>');

// Remove elements
$('.advertisement').remove();
$('.sidebar').empty();

These modification capabilities make Cheerio suitable for content migration projects where source HTML needs significant restructuring.

Performance Optimization

Understanding Cheerio's Performance Characteristics

Cheerio's performance stems from its focused design philosophy. Unlike JSDOM, which implements a substantial portion of browser DOM specification including event handling and rendering, Cheerio concentrates on parsing and manipulation capabilities. This narrower scope enables significant performance advantages in common HTML processing scenarios.

The library uses htmlparser2 as its underlying parser, which is itself optimized for speed and memory efficiency. The combination of a fast parser with a lightweight DOM model produces parsing and traversal performance that frequently exceeds alternatives by orders of magnitude in benchmark scenarios.

Performance characteristics vary based on document size, selector complexity, and the specific operations being performed. Small to medium documents (under 100KB) parse and traverse nearly instantaneously. Larger documents require proportionally more time, but Cheerio's efficient implementation maintains good performance even for substantial HTML files.

Selector performance depends heavily on the selector type. Tag name and ID selectors are fastest, followed by class selectors. More complex selectors involving attribute conditions or combinators add modest overhead but remain performant for typical use cases.

Optimization Strategies

Several strategies can maximize Cheerio's performance in production applications. Caching parsed Cheerio instances avoids repeated parsing when the same document needs multiple processing passes. Rather than reloading and reparsing HTML for each operation, keep a reference to the $ object and use it throughout the processing pipeline.

// Parse once, use many times
const $ = cheerio.load(htmlDocument);

// Multiple operations on same document
const titles = $('h1, h2, h3').map((i, el) => $(el).text()).get();
const links = $('a[href]').map((i, el) => $(el).attr('href')).get();
const images = $('img[src]').map((i, el) => ({
 src: $(el).attr('src'),
 alt: $(el).attr('alt') || ''
})).get();

Selector optimization improves traversal performance. When possible, use more specific selectors that directly target needed elements rather than broad selectors followed by filtering. The difference is minimal for single operations but compounds when processing large document collections.

// Less efficient
const activeLinks = $('a').filter('[data-active="true"]');

// More efficient
const activeLinks = $('a[data-active="true"]');

For large-scale scraping operations, consider batching and parallelization strategies. Processing multiple pages concurrently can significantly improve throughput, though practical limits apply based on target server rate limiting and local system resources.

Memory management becomes important when processing many documents or very large HTML files. Ensure that Cheerio instances and large HTML strings don't accumulate unnecessarily. Using local scope for parsing operations and allowing references to go out of scope enables garbage collection.

These performance considerations are critical when building scalable web applications that process substantial volumes of HTML content as part of their core functionality.

Common Patterns and Practical Examples

Web Scraping Workflow

A complete web scraping workflow combines HTTP fetching, HTML parsing with Cheerio, and data extraction into a cohesive process. This pattern underlies countless applications from price monitoring to competitive intelligence gathering.

import axios from 'axios';
import cheerio from 'cheerio';

async function scrapeProductListings(url) {
 const response = await axios.get(url, {
 headers: {
 'User-Agent': 'Mozilla/5.0 (compatible; MyScraper/1.0)'
 }
 });

 const $ = cheerio.load(response.data);
 const products = [];

 $('.product-card').each((i, element) => {
 const $el = $(element);

 products.push({
 name: $el.find('.product-title').text().trim(),
 price: $el.find('.price').text().trim(),
 rating: $el.find('.rating').attr('data-rating'),
 url: $el.find('a.product-link').attr('href'),
 image: $el.find('img.product-image').attr('src')
 });
 });

 return products;
}

Handling pagination requires either sequential processing of numbered pages or dynamic discovery of next-page links. Sequential processing is more predictable while link-based discovery adapts to variable pagination structures.

async function scrapeAllPages(baseUrl, maxPages = 50) {
 const allProducts = [];
 let currentPage = 1;
 let hasNextPage = true;

 while (hasNextPage && currentPage <= maxPages) {
 const pageUrl = `${baseUrl}?page=${currentPage}`;
 const pageProducts = await scrapeProductListings(pageUrl);

 if (pageProducts.length === 0) {
 hasNextPage = false;
 } else {
 allProducts.push(...pageProducts);
 currentPage++;
 }
 }

 return allProducts;
}

Content Extraction for Migration

Content migration scenarios often require extracting structured content from source HTML and transforming it for a target system. Cheerio's traversal and modification capabilities support sophisticated migration transformations.

function migrateArticle(sourceHtml) {
 const $ = cheerio.load(sourceHtml);

 // Extract metadata
 const metadata = {
 title: $('h1.title').text().trim(),
 author: $('meta[name="author"]').attr('content'),
 publishedDate: $('time').attr('datetime'),
 categories: $('.category-tag').map((i, el) => $(el).text()).get()
 };

 // Transform content structure
 $('.ad-banner').remove();
 $('.related-articles').remove();

 // Wrap paragraphs in proper structure
 $('article p:not(.dropcap)').each((i, el) => {
 $(el).wrap('<div class="paragraph"></div>');
 });

 // Update image references
 $('img').each((i, el) => {
 const oldSrc = $(el).attr('src');
 const newSrc = oldSrc.replace('/old-uploads/', '/new-uploads/');
 $(el).attr('src', newSrc);
 $(el).attr('loading', 'lazy');
 });

 // Generate output
 return {
 metadata,
 content: $('article').html()
 };
}

Validation and Testing

Quality assurance workflows can use Cheerio to validate HTML structure, check for required elements, and verify content accuracy. This approach complements visual testing with precise structural validation.

function validateArticlePage(html) {
 const $ = cheerio.load(html);
 const errors = [];

 // Check required elements
 if ($('h1').length === 0) {
 errors.push('Missing page heading');
 }

 if ($('article').length === 0) {
 errors.push('Missing article container');
 }

 // Validate heading hierarchy
 const headings = $('h1, h2, h3, h4, h5, h6').map((i, el) =>
 parseInt(el.tagName[1])
 ).get();

 for (let i = 1; i < headings.length; i++) {
 if (headings[i] - headings[i - 1] > 1) {
 errors.push(`Heading level jump from h${headings[i-1]} to h${headings[i]}`);
 }
 }

 // Check for images without alt text
 $('img:not([alt])').each((i, el) => {
 const src = $(el).attr('src');
 errors.push(`Image missing alt attribute: ${src}`);
 });

 // Verify links are valid
 $('a[href^="http"]').each((i, el) => {
 const href = $(el).attr('href');
 if (href.includes('javascript:') || href === '#') {
 errors.push(`Suspicious link target: ${href}`);
 }
 });

 return {
 valid: errors.length === 0,
 errors
 };
}

Best Practices for Production Use

Error Handling and Robustness

Production applications must handle malformed HTML gracefully. Cheerio's parser is tolerant of many HTML errors, but extreme cases may require additional handling. Wrapping parsing operations in try-catch blocks prevents unexpected errors from crashing entire processes.

async function safelyParseHtml(html, fallback = '') {
 try {
 return cheerio.load(html);
 } catch (error) {
 console.error('HTML parsing failed:', error.message);
 return cheerio.load(fallback || '<html><body></body></html>');
 }
}

When extracting data that might not exist, defensive coding prevents undefined values from propagating through the application. Using optional chaining and providing default values ensures predictable behavior regardless of document structure.

function extractProductData($) {
 return {
 name: $('h1.product-title').text().trim() || 'Unnamed Product',
 price: parseFloat($('.price').text().replace(/[^0-9.]/g, '')) || 0,
 sku: $('[data-sku]').data('sku') || 'N/A',
 inStock: $('.stock-status').text().includes('In Stock')
 };
}

Respecting Robots and Rate Limits

When scraping external websites, ethical and practical considerations guide responsible behavior. Checking robots.txt and respecting crawl delays prevents abuse and maintains good relationships with target sites. Rate limiting protects both the scraper and target server from overload situations.

import rateLimit from 'axios-rate-limit';

const http = rateLimit(axios.create(), {
 maxRequests: 2,
 perMilliseconds: 1000,
 maxRPS: 2
});

async function respectfulScrape(url) {
 // Check robots.txt first (implementation depends on requirements)

 // Add delay between requests
 await new Promise(resolve => setTimeout(resolve, 1000));

 return http.get(url, {
 headers: {
 'User-Agent': 'MyApp/1.0 ([email protected])'
 }
 });
}

Testing Cheerio Code

Unit testing Cheerio-based code requires creating test HTML fixtures and asserting on the extracted or modified content. Testing libraries integrate naturally with Cheerio's programmatic interface.

import { describe, it, expect } from 'vitest';
import cheerio from 'cheerio';

describe('HTML Processing', () => {
 it('extracts article titles', () => {
 const html = '<article><h1>Test Title</h1></article>';
 const $ = cheerio.load(html);

 expect($('article h1').text()).toBe('Test Title');
 });

 it('transforms content correctly', () => {
 const html = '<p>Original</p>';
 const $ = cheerio.load(html);

 $('p').text('Transformed');

 expect($('p').text()).toBe('Transformed');
 });

 it('handles missing elements gracefully', () => {
 const html = '<div></div>';
 const $ = cheerio.load(html);

 expect($('.missing').text()).toBe('');
 expect($('.missing').attr('href')).toBeUndefined();
 });
});

Following these best practices ensures your automated testing and quality assurance processes are robust and reliable when incorporating Cheerio for HTML validation.

Integration with Next.js and Modern Frameworks

Cheerio integrates naturally with Next.js server-side contexts including API routes, server components, and build-time processing. In the App Router, server components can directly use Cheerio for HTML processing without client-side bundle concerns.

// app/api/analyze/route.ts
import { NextResponse } from 'next/server';
import cheerio from 'cheerio';

export async function POST(request) {
 const { html } = await request.json();
 const $ = cheerio.load(html);

 const analysis = {
 headings: $('h1, h2, h3, h4, h5, h6').map((i, el) => ({
 level: el.tagName,
 text: $(el).text().trim()
 })).get(),
 links: $('a[href]').map((i, el) => ({
 text: $(el).text().trim(),
 href: $(el).attr('href')
 })).get(),
 images: $('img[src]').map((i, el) => ({
 src: $(el).attr('src'),
 alt: $(el).attr('alt') || ''
 })).get()
 };

 return NextResponse.json(analysis);
}

For build-time processing, Cheerio can analyze or transform content as part of static generation. This pattern is useful for content sites that need to process HTML before rendering, such as adding anchor links to headings or extracting metadata from imported content. This approach is particularly valuable for Next.js implementations that require sophisticated content processing.

The library also works well with Express.js for building API backends that handle HTML processing, making it versatile for various backend development scenarios. Whether you're building microservices that scrape external sources, APIs that transform HTML content, or batch processing systems, Cheerio provides consistent capabilities across different Node.js frameworks.

Conclusion

Cheerio has established itself as an essential tool in the Node.js ecosystem, bringing jQuery's intuitive DOM manipulation to server-side HTML processing. Its combination of familiar syntax, high performance, and flexible capabilities makes it suitable for a wide range of applications--from simple data extraction tasks to complex content migration pipelines and sophisticated testing infrastructure.

The library's jQuery-compatible API reduces the learning curve for developers transitioning from frontend to backend development, while its focused design delivers performance characteristics that suit production applications. As web development continues to emphasize server-side rendering, API-driven architectures, and static site generation, tools like Cheerio that enable programmatic HTML manipulation become increasingly valuable.

Whether you're building web scrapers, content processors, testing utilities, or data pipelines, Cheerio provides the foundation for working with HTML in Node.js environments. Its active maintenance, comprehensive documentation, and large user community ensure continued relevance and support for modern web development workflows.

For organizations building comprehensive web solutions, Cheerio represents a reliable, well-supported choice for HTML processing needs. Its integration with Next.js and other modern frameworks makes it particularly valuable for teams working with contemporary JavaScript technologies and seeking efficient, server-side HTML manipulation capabilities.

Frequently Asked Questions

What is Cheerio used for?

Cheerio is used for server-side HTML parsing and manipulation in Node.js. Common use cases include web scraping, data extraction, content migration, HTML validation, and automated testing.

How does Cheerio differ from jQuery?

Cheerio implements a subset of jQuery's API but operates without a browser. It parses HTML into memory and provides traversal/manipulation methods without DOM simulation, making it faster and suitable for server environments.

Can Cheerio parse XML documents?

Yes, Cheerio can parse both HTML and XML documents. The XML mode can be enabled through load options when working with XML content that requires strict parsing rules.

Is Cheerio suitable for web scraping?

Cheerio is excellent for web scraping when combined with an HTTP client. It provides efficient HTML parsing and powerful CSS selector support for extracting structured data from web pages.

How do I handle malformed HTML with Cheerio?

Cheerio's parser (htmlparser2) is tolerant of many HTML errors. For extreme cases, wrap parsing in try-catch blocks and provide fallback HTML or error handling logic.

Testing Next.js Apps with Jest

Learn comprehensive strategies for testing Next.js applications using Jest, covering unit tests, integration tests, and end-to-end testing patterns.

Learn more

Web Development Trends

Explore the latest trends shaping modern web development, from new frameworks and tools to emerging best practices and architectural patterns.

Learn more

Google Maps API Integration

Master Google Maps API integration in web applications, including maps, directions, places, and location-based features.

Learn more

Need Custom Web Development Solutions?

Our team specializes in building high-performance web applications with modern technologies. From Next.js implementations to custom data pipelines, we deliver solutions that scale.

Sources

Cheerio.js Official Site - Primary source for library capabilities, syntax, and performance claims
ScrapingBee: Using Cheerio NPM Package - Practical implementation patterns and web scraping guide
MarsProxies: Cheerio Web Scraping Guide - Web scraping applications and practical examples