Puppeteer Infinite Scroll: Cách thu thập đầy đủ dữ liệu trang cuộn vô hạn
Mục lục bài viết
- •Infinite scroll hoạt động như thế nào?
- •Có nhất thiết phải dùng Puppeteer không?
- •Cài đặt Puppeteer
- •Cách 1: Cuộn xuống cuối và chờ chiều cao tăng
- •Cách 2: Theo dõi số lượng phần tử
- •Cách 3: Cuộn theo từng viewport
- •Cách cuộn một container thay vì toàn trang
- •Cuộn phần tử sentinel vào viewport
- •Chờ response thay vì dùng thời gian cố định
- •Ví dụ Puppeteer Infinite Scroll hoàn chỉnh
- •Cách nhận biết đã cuộn hết dữ liệu
- •Xử lý ảnh lazy load
- •Tránh trùng dữ liệu
- •Giảm bộ nhớ khi thu thập dữ liệu lớn
- •Cấu hình proxy cho Puppeteer
- •Các lỗi Puppeteer Infinite Scroll thường gặp
- •Thu thập dữ liệu có trách nhiệm
- •Checklist trước khi chạy
- •Câu hỏi thường gặp
- •Kết luận
Trang infinite scroll không chia dữ liệu thành các URL như page=2 hoặc page=3. Khi người dùng cuộn gần cuối, JavaScript gửi thêm request, nhận dữ liệu rồi chèn sản phẩm, bài viết hoặc bình luận mới vào trang.
Nếu chỉ tải HTML ban đầu bằng một HTTP client, bạn có thể nhận được khung trang và nhóm nội dung đầu tiên. Những mục xuất hiện sau khi cuộn chưa tồn tại trong DOM.
Puppeteer giải quyết vấn đề này bằng cách chạy Chromium, kích hoạt thao tác cuộn và chờ nội dung mới xuất hiện trước khi tiếp tục.
Một vòng lặp cơ bản gồm bốn bước:
-
Đếm số phần tử hiện có.
-
Cuộn xuống cuối trang.
-
Chờ số phần tử hoặc chiều cao trang tăng.
-
Dừng khi không còn dữ liệu mới.
Đoạn mã ngắn dưới đây thể hiện nguyên tắc đó:
const previousCount = await page.$$eval(
'.product-card',
elements => elements.length
);
await page.evaluate(() => {
window.scrollTo(0, document.body.scrollHeight);
});
await page.waitForFunction(
(selector, oldCount) =>
document.querySelectorAll(selector).length > oldCount,
{ timeout: 5000 },
'.product-card',
previousCount
);
Phần khó không nằm ở lệnh cuộn. Bạn cần xác định website tải dữ liệu theo cách nào và chọn đúng tín hiệu để chờ.
Infinite scroll hoạt động như thế nào?
Các website thường dùng một trong hai cơ chế.
Theo dõi vị trí cuộn
JavaScript lắng nghe sự kiện scroll. Khi khoảng cách từ viewport đến cuối trang nhỏ hơn một ngưỡng, trang gửi request lấy dữ liệu tiếp theo.
IntersectionObserver
Trang đặt một phần tử đánh dấu ở cuối danh sách. Khi phần tử này đi vào viewport, IntersectionObserver gọi hàm tải dữ liệu.
Sau khi nhận phản hồi, JavaScript tạo thêm node trong DOM. Chiều cao tài liệu tăng và phần tử đánh dấu lại được đẩy xuống dưới. Chu trình tiếp tục cho đến khi API báo hết dữ liệu.
Một số website còn sử dụng danh sách ảo. Các mục đã cuộn qua bị xóa khỏi DOM và được thay bằng mục mới. Trong trường hợp này, số node có thể không tăng dù người dùng vẫn thấy dữ liệu mới.
Có nhất thiết phải dùng Puppeteer không?
Không phải mọi trang infinite scroll đều cần trình duyệt.
Trước khi viết vòng lặp, hãy mở DevTools, chọn tab Network, lọc Fetch/XHR rồi cuộn trang.
Nếu mỗi lần cuộn tạo một request JSON rõ ràng, gọi trực tiếp endpoint đó thường nhanh và nhẹ hơn điều khiển trình duyệt. Bạn vẫn phải tuân thủ điều khoản sử dụng, giới hạn truy cập và quyền đối với dữ liệu.
Puppeteer phù hợp khi:
-
Endpoint khó tái sử dụng bên ngoài trình duyệt
-
Request cần cookie hoặc token được tạo trong phiên
-
Dữ liệu được xử lý thêm bằng JavaScript
-
Nội dung chỉ xuất hiện sau tương tác giao diện
-
Website dùng iframe hoặc shadow DOM
-
Bạn cần chụp ảnh, tạo PDF hoặc kiểm tra giao diện cùng lúc
Nếu dữ liệu có URL phân trang ổn định, nên dùng phân trang thay cho cuộn mô phỏng.
Cài đặt Puppeteer
Khởi tạo project:
npm init -y
npm pkg set type=module
npm install puppeteer
Tạo tệp scrape.js:
import puppeteer from 'puppeteer';
const browser = await puppeteer.launch({
headless: true
});
const page = await browser.newPage();
await page.goto('https://example.com/products', {
waitUntil: 'domcontentloaded',
timeout: 30000
});
console.log(await page.title());
await browser.close();
Puppeteer cài một phiên bản Chromium tương thích theo cấu hình package. Nếu dùng puppeteer-core, bạn cần tự cung cấp đường dẫn trình duyệt.
Cách 1: Cuộn xuống cuối và chờ chiều cao tăng
Đây là cách đơn giản nhất với trang nối thêm nội dung vào cuối DOM.
async function scrollByHeight(page, {
maxScrolls = 50,
waitTimeout = 5000
} = {}) {
let unchangedRounds = 0;
for (let round = 0; round < maxScrolls; round += 1) {
const previousHeight = await page.evaluate(
() => document.documentElement.scrollHeight
);
await page.evaluate(() => {
window.scrollTo(
0,
document.documentElement.scrollHeight
);
});
try {
await page.waitForFunction(
oldHeight =>
document.documentElement.scrollHeight > oldHeight,
{ timeout: waitTimeout },
previousHeight
);
unchangedRounds = 0;
} catch {
unchangedRounds += 1;
}
if (unchangedRounds >= 2) {
break;
}
}
}
Hàm đặt hai điều kiện dừng:
-
Tối đa 50 lần cuộn
-
Chiều cao không thay đổi trong hai vòng liên tiếp
Giới hạn số vòng ngăn script chạy mãi nếu website không có tín hiệu kết thúc rõ ràng.
Khi nào cách này không hiệu quả?
Chiều cao trang có thể không tăng nếu website:
-
Dùng virtual list
-
Cuộn bên trong một container
-
Thay thế node cũ bằng node mới
-
Hiển thị nút “Tải thêm”
-
Cần cuộn phần tử sentinel vào viewport
-
Tải dữ liệu nhưng không làm thay đổi chiều cao đáng kể
Khi đó, cần theo dõi số lượng mục, ID dữ liệu hoặc một phần tử kết thúc.
Cách 2: Theo dõi số lượng phần tử
Nếu mỗi mục có selector ổn định, đếm số phần tử thường chính xác hơn đo chiều cao trang.
async function scrollUntilNoNewItems(page, {
itemSelector,
maxScrolls = 100,
stagnantLimit = 3,
waitTimeout = 5000
}) {
let stagnantRounds = 0;
for (let round = 0; round < maxScrolls; round += 1) {
const previousCount = await page.$$eval(
itemSelector,
elements => elements.length
);
await page.evaluate(() => {
window.scrollTo(
0,
document.documentElement.scrollHeight
);
});
try {
await page.waitForFunction(
(selector, oldCount) =>
document.querySelectorAll(selector).length > oldCount,
{ timeout: waitTimeout },
itemSelector,
previousCount
);
} catch {
// Kiểm tra lại ở phía dưới
}
const currentCount = await page.$$eval(
itemSelector,
elements => elements.length
);
if (currentCount > previousCount) {
stagnantRounds = 0;
} else {
stagnantRounds += 1;
}
console.log({
round: round + 1,
previousCount,
currentCount,
stagnantRounds
});
if (stagnantRounds >= stagnantLimit) {
break;
}
}
}
Cách này phù hợp với danh sách sản phẩm, bài viết hoặc bình luận được nối vào DOM.
Không dùng số lượng node làm điều kiện duy nhất cho virtual list. Với danh sách ảo, hãy lưu ID hoặc URL của từng mục qua mỗi vòng.
Cách 3: Cuộn theo từng viewport
Một số trang chỉ tải dữ liệu khi phần tử sentinel thực sự đi vào viewport. Cuộn thẳng xuống đáy có thể bỏ qua một số sự kiện.
Cuộn theo từng đoạn giúp mô phỏng cách người dùng di chuyển trên trang:
const delay = milliseconds =>
new Promise(resolve => setTimeout(resolve, milliseconds));
async function scrollByViewport(page, {
maxSteps = 100,
delayBetweenSteps = 300
} = {}) {
for (let step = 0; step < maxSteps; step += 1) {
const reachedBottom = await page.evaluate(() => {
const root = document.documentElement;
window.scrollBy({
top: window.innerHeight * 0.8,
behavior: 'auto'
});
return (
window.scrollY + window.innerHeight >=
root.scrollHeight - 5
);
});
await delay(delayBetweenSteps);
if (reachedBottom) {
break;
}
}
}
Thời gian chờ cố định trong ví dụ chỉ phù hợp với bước cuộn nhỏ. Với dữ liệu mạng, nên chờ một điều kiện cụ thể thay vì dựa hoàn toàn vào delay.
Cách cuộn một container thay vì toàn trang
Nhiều website đặt danh sách trong một phần tử có overflow: auto. Lúc này, window.scrollTo() không làm danh sách di chuyển.
Trước tiên, xác định container:
const containerSelector = '.results-container';
Sau đó thay đổi scrollTop:
await page.$eval(containerSelector, element => {
element.scrollTop = element.scrollHeight;
});
Theo dõi chiều cao của container:
const previousHeight = await page.$eval(
containerSelector,
element => element.scrollHeight
);
await page.$eval(containerSelector, element => {
element.scrollTop = element.scrollHeight;
});
await page.waitForFunction(
(selector, oldHeight) => {
const element = document.querySelector(selector);
return (
element &&
element.scrollHeight > oldHeight
);
},
{ timeout: 5000 },
containerSelector,
previousHeight
);
Nếu container được tạo sau khi trang tải, hãy chờ selector xuất hiện trước.
Cuộn phần tử sentinel vào viewport
Nếu website dùng IntersectionObserver, cuộn trực tiếp sentinel thường đáng tin cậy hơn cuộn toàn trang.
async function scrollSentinelIntoView(
page,
sentinelSelector
) {
await page.$eval(sentinelSelector, element => {
element.scrollIntoView({
block: 'center'
});
});
}
Sau khi cuộn, cần chờ số lượng item tăng, request hoàn tất hoặc sentinel mới xuất hiện.
Không nên chỉ gọi scrollIntoView() liên tục mà không có điều kiện dừng.
Chờ response thay vì dùng thời gian cố định
Nếu biết endpoint tải dữ liệu, page.waitForResponse() cho tín hiệu rõ ràng hơn một lệnh sleep.
const responsePromise = page.waitForResponse(
response =>
response.url().includes('/api/products') &&
response.request().method() === 'GET',
{ timeout: 10000 }
);
await page.evaluate(() => {
window.scrollTo(
0,
document.documentElement.scrollHeight
);
});
const response = await responsePromise;
if (!response.ok()) {
throw new Error(
`API trả về HTTP ${response.status()}`
);
}
const data = await response.json();
console.log(data);
Hãy tạo promise chờ response trước khi cuộn. Nếu gọi waitForResponse() sau thao tác, request có thể đã kết thúc và script sẽ chờ đến timeout.
Ví dụ Puppeteer Infinite Scroll hoàn chỉnh
Ví dụ dưới đây:
-
Giới hạn số vòng cuộn
-
Đếm số item
-
Chờ item mới
-
Dừng sau ba vòng không thay đổi
-
Loại dữ liệu trùng theo URL
-
Đóng browser trong
finally
import puppeteer from 'puppeteer';
const TARGET_URL = 'https://example.com/products';
const ITEM_SELECTOR = '.product-card';
const MAX_SCROLLS = 100;
const STAGNANT_LIMIT = 3;
const browser = await puppeteer.launch({
headless: true
});
try {
const page = await browser.newPage();
await page.goto(TARGET_URL, {
waitUntil: 'domcontentloaded',
timeout: 30000
});
await page.waitForSelector(ITEM_SELECTOR, {
timeout: 10000
});
const itemsByUrl = new Map();
let stagnantRounds = 0;
for (
let round = 0;
round < MAX_SCROLLS;
round += 1
) {
const currentItems = await page.$$eval(
ITEM_SELECTOR,
elements => elements.map(element => ({
title:
element.querySelector('h2')?.textContent?.trim() ??
'',
url:
element.querySelector('a')?.href ??
''
}))
);
for (const item of currentItems) {
if (item.url) {
itemsByUrl.set(item.url, item);
}
}
const countBefore = itemsByUrl.size;
await page.evaluate(() => {
window.scrollTo(
0,
document.documentElement.scrollHeight
);
});
try {
await page.waitForFunction(
(selector, oldCount) =>
document.querySelectorAll(selector).length >
oldCount,
{ timeout: 5000 },
ITEM_SELECTOR,
currentItems.length
);
} catch {
// Không có item mới trong thời gian chờ
}
const updatedItems = await page.$$eval(
ITEM_SELECTOR,
elements => elements.map(element => ({
title:
element.querySelector('h2')?.textContent?.trim() ??
'',
url:
element.querySelector('a')?.href ??
''
}))
);
for (const item of updatedItems) {
if (item.url) {
itemsByUrl.set(item.url, item);
}
}
if (itemsByUrl.size > countBefore) {
stagnantRounds = 0;
} else {
stagnantRounds += 1;
}
console.log({
round: round + 1,
uniqueItems: itemsByUrl.size,
stagnantRounds
});
if (stagnantRounds >= STAGNANT_LIMIT) {
break;
}
}
const results = [...itemsByUrl.values()];
console.log(`Đã lấy ${results.length} mục`);
console.log(results);
} finally {
await browser.close();
}
Bạn phải đổi selector theo cấu trúc website thực tế. Không nên dùng nguyên .product-card, h2 và a nếu trang đích sử dụng tên khác.
Cách nhận biết đã cuộn hết dữ liệu
Không có một tín hiệu phù hợp với mọi website. Một script tốt thường kết hợp nhiều điều kiện:
Số item không tăng
Phù hợp với danh sách nối thêm node và giữ toàn bộ nội dung trong DOM.
Chiều cao trang không tăng
Dễ triển khai nhưng có thể sai với virtual list hoặc container riêng.
Xuất hiện thông báo kết thúc
Ví dụ:
const endReached = await page.$(
'.end-of-results'
);
if (endReached) {
break;
}
API trả về mảng rỗng
Nếu theo dõi được response JSON, đây thường là tín hiệu đáng tin cậy.
API trả về hasNext bằng false
Nên ưu tiên dữ liệu phân trang của API nếu trường này có ý nghĩa rõ ràng.
Đạt giới hạn an toàn
Luôn đặt maxScrolls, maxItems hoặc thời gian chạy tối đa. Đây là lớp bảo vệ khi selector hoặc logic kết thúc bị sai.
Xử lý ảnh lazy load
Ảnh lazy load chỉ bắt đầu tải khi đi gần viewport. Sau khi lấy đủ item, URL ảnh có thể vẫn nằm trong data-src thay vì src.
Bạn có thể cuộn lại từ đầu đến cuối theo từng viewport:
await page.evaluate(() => {
window.scrollTo(0, 0);
});
let lastPosition = -1;
while (true) {
const position = await page.evaluate(() => {
window.scrollBy(0, window.innerHeight * 0.8);
return window.scrollY;
});
if (position === lastPosition) {
break;
}
lastPosition = position;
await new Promise(resolve =>
setTimeout(resolve, 200)
);
}
await page.waitForNetworkIdle({
idleTime: 500,
timeout: 10000
});
Khi trích xuất, kiểm tra cả src, data-src và srcset:
const images = await page.$$eval(
'img',
elements => elements.map(image => ({
src:
image.currentSrc ||
image.src ||
image.dataset.src ||
'',
alt: image.alt || ''
}))
);
Không phải website nào cũng dùng data-src. Hãy xem DOM thực tế trước khi chọn thuộc tính.
Tránh trùng dữ liệu
Infinite scroll dễ tạo bản ghi trùng nếu:
-
API trả lại item ở ranh giới hai trang
-
DOM giữ cả bản placeholder và bản hoàn chỉnh
-
Website đưa nội dung được ghim vào nhiều vị trí
-
Script cuộn ngược rồi đọc lại item cũ
-
Một sản phẩm có nhiều biến thể cùng tiêu đề
Nên chọn một khóa ổn định như:
-
ID sản phẩm
-
URL chuẩn hóa
-
Mã bài viết
-
Thuộc tính
data-id -
Khóa kết hợp giữa nguồn và ID
Dùng Map:
const uniqueItems = new Map();
for (const item of items) {
uniqueItems.set(item.id, item);
}
Không nên chỉ dùng tiêu đề làm khóa vì nhiều mục có thể trùng tên.
Giảm bộ nhớ khi thu thập dữ liệu lớn
Nếu trang có hàng chục nghìn mục, giữ toàn bộ dữ liệu và DOM trong bộ nhớ có thể làm Chromium chậm dần.
Một số cách giảm tải:
-
Ghi dữ liệu theo từng lô
-
Chỉ giữ ID đã gặp trong
Set -
Chặn font và tài nguyên không cần thiết
-
Đóng page sau khi hoàn thành
-
Khởi động lại browser theo từng nhóm URL
-
Dùng API trực tiếp nếu đã tìm thấy endpoint
-
Giới hạn số tab chạy đồng thời
Không nên chặn JavaScript hoặc request XHR vì chúng có thể là thành phần tải dữ liệu infinite scroll.
Cấu hình proxy cho Puppeteer
Có thể khai báo proxy khi khởi động Chromium:
const browser = await puppeteer.launch({
headless: true,
args: [
'--proxy-server=http://proxy-host:port'
]
});
Nếu proxy yêu cầu username và password:
const page = await browser.newPage();
await page.authenticate({
username: process.env.PROXY_USERNAME,
password: process.env.PROXY_PASSWORD
});
Không ghi mật khẩu proxy trực tiếp trong mã hoặc log.
Nếu cần đổi IP giữa nhiều phiên, hãy tìm hiểu sự khác nhau giữa rotating proxy và sticky session. Với tác vụ cần kiểm tra nội dung theo khu vực, có thể tham khảo proxy dân cư.
Sau khi cấu hình, dùng Proxy Checker để xác nhận IP và giao thức trước khi chạy tác vụ dài.
Các lỗi Puppeteer Infinite Scroll thường gặp
Script chỉ lấy được nhóm dữ liệu đầu tiên
Nguyên nhân thường là script trích xuất trước khi nội dung mới xuất hiện.
Hãy chờ số item tăng, response hoàn tất hoặc DOM thay đổi trước khi đọc dữ liệu.
Script cuộn nhưng trang không di chuyển
Danh sách có thể nằm trong container riêng. Kiểm tra thuộc tính overflow và thay đổi scrollTop của đúng phần tử.
Vòng lặp không bao giờ dừng
Logic chỉ kiểm tra chiều cao nhưng website liên tục thêm footer, quảng cáo hoặc placeholder.
Cần thêm maxScrolls, giới hạn thời gian và số vòng không có item mới.
Script dừng quá sớm
Một response có thể chậm hơn timeout hoặc website chỉ tải khi sentinel đi vào viewport.
Thử cuộn theo từng viewport, chờ response phù hợp và cho phép hai đến ba vòng không thay đổi trước khi dừng.
Có đủ item nhưng thiếu ảnh
Ảnh dùng lazy loading và chưa từng đi vào viewport. Cần thực hiện thêm một lượt cuộn để kích hoạt ảnh hoặc đọc thuộc tính dữ liệu phù hợp.
Dữ liệu bị trùng
Hãy lưu theo ID hoặc URL chuẩn hóa trong Map. Không nối thẳng toàn bộ kết quả sau mỗi vòng.
Lỗi Execution context was destroyed
Trang có thể đã điều hướng hoặc reload trong lúc page.evaluate() đang chạy.
Nếu một thao tác gây điều hướng, tạo promise chờ trước:
await Promise.all([
page.waitForNavigation({
waitUntil: 'domcontentloaded'
}),
page.click('.load-more')
]);
Thu thập dữ liệu có trách nhiệm
Puppeteer có thể chạy JavaScript và mô phỏng thao tác trình duyệt, nhưng không tạo quyền truy cập vào dữ liệu.
Trước khi thu thập, cần kiểm tra:
-
Điều khoản sử dụng
-
Robots.txt
-
Giới hạn request
-
Quyền đối với dữ liệu
-
Yêu cầu bảo vệ thông tin cá nhân
-
Tác động đến máy chủ
Giảm tốc độ khi nhận HTTP 429 hoặc 503. Dừng tác vụ nếu website yêu cầu xác minh hoặc từ chối truy cập.
Nếu thường xuyên gặp CAPTCHA, hãy xem lại tần suất request, số tab đồng thời và loại dữ liệu đang thu thập. Bài cách xử lý CAPTCHA khi web scraping phân tích các bước kiểm tra an toàn hơn.
Checklist trước khi chạy
-
Xác định dữ liệu nằm trong HTML hay được tải qua API.
-
Kiểm tra trang cuộn toàn bộ window hay một container riêng.
-
Tìm selector ổn định cho item.
-
Xác định tín hiệu dữ liệu mới.
-
Xác định điều kiện kết thúc.
-
Đặt số vòng cuộn tối đa.
-
Đặt timeout cho navigation và wait.
-
Loại dữ liệu trùng bằng ID hoặc URL.
-
Ghi log số item sau mỗi vòng.
-
Kiểm tra ảnh lazy load.
-
Giới hạn số browser và page chạy đồng thời.
-
Xác nhận hoạt động thu thập được website cho phép.
Câu hỏi thường gặp
Puppeteer xử lý infinite scroll như thế nào?
Puppeteer chạy Chromium và kích hoạt thao tác cuộn. JavaScript của website nhận sự kiện, tải dữ liệu mới rồi cập nhật DOM. Script cần chờ thay đổi đó trước khi tiếp tục.
Nên chờ bao lâu sau mỗi lần cuộn?
Không có thời gian cố định phù hợp với mọi website. Nên chờ số item tăng, chiều cao thay đổi hoặc response hoàn tất. Chỉ dùng delay ngắn khi cần tạo khoảng cách giữa các bước cuộn.
Khi nào nên gọi API thay vì dùng Puppeteer?
Nếu DevTools cho thấy endpoint JSON rõ ràng, có cơ chế phân trang và bạn được phép truy cập, gọi API thường nhanh, nhẹ và dễ tiếp tục sau lỗi hơn.
Làm sao biết đã đến cuối trang?
Có thể kiểm tra số item, chiều cao, thông báo kết thúc hoặc trường hasNext trong API. Luôn bổ sung giới hạn số vòng để tránh vòng lặp vô hạn.
Có thể dùng proxy với Puppeteer không?
Có. Khai báo proxy qua tham số --proxy-server khi khởi động browser. Nếu proxy yêu cầu xác thực, có thể dùng page.authenticate().
Vì sao số phần tử không tăng dù trang vẫn có dữ liệu mới?
Website có thể sử dụng virtual list và thay thế node cũ. Hãy lưu ID của item qua từng vòng hoặc theo dõi response API thay vì chỉ đếm node trong DOM.
Kết luận
Một script Puppeteer xử lý infinite scroll ổn định cần ba thành phần: tín hiệu cuộn đúng, điều kiện chờ đúng và điều kiện dừng rõ ràng.
Trước khi mở Chromium, hãy kiểm tra Network để xem dữ liệu có thể lấy trực tiếp từ API hay không. Nếu cần browser, ưu tiên chờ theo số item hoặc response thay vì dùng thời gian cố định.
Cuối cùng, luôn giới hạn số vòng, loại dữ liệu trùng và ghi log số mục sau mỗi lượt. Ba bước này giúp phát hiện sớm phần lớn lỗi cuộn vô hạn.




