Playwright Wait for Page to Load: Cách Chờ Trang Tải Xong Chính Xác

Để chờ trang tải xong trong Playwright, bạn có thể dùng page.goto() với tùy chọn waitUntil, gọi page.waitForLoadState() hoặc chờ một tín hiệu cụ thể như locator, URL và API response. Tuy nhiên, với website hiện đại, sự kiện load chưa chắc đồng nghĩa nội dung cần dùng đã xuất hiện. Cách ổn định hơn thường là chờ đúng thành phần hoặc dữ liệu quyết định trạng thái “sẵn sàng” của trang.

Ví dụ ngắn dưới đây mở trang sau khi DOM được tạo, rồi chờ khu vực sản phẩm hiển thị:

await page.goto('https://example.com/products', {
  waitUntil: 'domcontentloaded',
});

await page.locator('[data-testid="product-list"]').waitFor({
  state: 'visible',
});

Đây là ý quan trọng nhất khi tìm hiểu Playwright wait for page to load: không nên hỏi “toàn bộ trang đã tải xong chưa?”, mà nên xác định “tín hiệu nào cho biết bước tiếp theo có thể chạy an toàn?”.

Vì sao trang đã load nhưng Playwright vẫn thiếu dữ liệu?

Website truyền thống thường trả về HTML chứa phần lớn nội dung. Khi tài liệu, CSS, JavaScript và hình ảnh hoàn tất, sự kiện load được kích hoạt. Với mô hình này, chờ load có thể đủ.

Nhiều website hiện nay hoạt động khác. Trình duyệt nhận HTML ban đầu, sau đó JavaScript gọi API, dựng giao diện, tải thêm danh sách hoặc cập nhật nội dung theo trạng thái người dùng. Một số trang còn duy trì kết nối phân tích, quảng cáo, thông báo hoặc polling trong suốt phiên truy cập.

Vì vậy, các mốc sau không hoàn toàn giống nhau:

  • Trình duyệt đã nhận phản hồi và bắt đầu đọc tài liệu.

  • DOM đã được tạo.

  • Tài nguyên phụ thuộc đã tải xong.

  • API quan trọng đã trả dữ liệu.

  • Thành phần cần thao tác đã hiển thị và hoạt động được.

Tài liệu Playwright cũng lưu ý rằng website hiện đại có thể tiếp tục tải dữ liệu và dựng giao diện sau sự kiện load. Playwright giải quyết phần lớn trường hợp bằng cơ chế auto-wait, nhưng người viết kịch bản vẫn cần chọn đúng tín hiệu đối với nội dung động.

Các trạng thái tải trang trong Playwright

page.goto() hỗ trợ bốn giá trị waitUntil: commit, domcontentloaded, load và networkidle. Trong khi đó, page.waitForLoadState() hỗ trợ domcontentloaded, load và networkidle.

Trạng thái Playwright chờ điều gì? Khi nào nên dùng?
commit Phản hồi mạng đã được nhận và tài liệu bắt đầu tải Cần tiếp tục sớm, sau đó tự chờ locator hoặc response
domcontentloaded HTML đã được phân tích và DOM ban đầu đã hình thành Đọc DOM cơ bản hoặc làm mốc đầu trước khi chờ nội dung động
load Sự kiện load đã xảy ra, gồm các tài nguyên phụ thuộc thông thường Chụp giao diện hoặc xử lý trang phụ thuộc nhiều tài nguyên
networkidle Không có kết nối mạng trong ít nhất 500 ms Chỉ dùng khi hiểu rõ luồng mạng; không nên chọn làm mặc định

commit: bắt đầu sớm nhất

commit chỉ xác nhận phản hồi chính đã đến và tài liệu bắt đầu được tải. Giai đoạn này còn quá sớm để đọc nội dung hoặc nhấp phần tử ngay lập tức, nhưng hữu ích khi bạn muốn tách điều hướng khỏi điều kiện sẵn sàng của ứng dụng.

await page.goto('https://example.com/dashboard', {
  waitUntil: 'commit',
});

await page.getByRole('heading', { name: 'Dashboard' }).waitFor();

domcontentloaded: nhanh nhưng chưa đầy đủ

Khi DOMContentLoaded được kích hoạt, trình duyệt đã tạo DOM từ HTML. Hình ảnh, font hoặc dữ liệu được gọi bằng JavaScript vẫn có thể chưa sẵn sàng. Đây thường là lựa chọn tốt khi bước tiếp theo đã có một locator cụ thể để chờ.

await page.goto('https://example.com', {
  waitUntil: 'domcontentloaded',
});

load: giá trị mặc định của page.goto()

Nếu không truyền waitUntil, page.goto() chờ sự kiện load. Mốc này muộn hơn domcontentloaded và bao gồm những tài nguyên phụ thuộc như stylesheet, script, iframe và hình ảnh thông thường.

await page.goto('https://example.com');

// Tương đương về trạng thái chờ
await page.goto('https://example.com', { waitUntil: 'load' });

Dù vậy, dữ liệu được tải trễ qua API vẫn có thể xuất hiện sau load. Vì thế, việc gọi page.goto() thành công không tự động bảo đảm danh sách sản phẩm, biểu đồ hoặc bảng dữ liệu đã hoàn chỉnh.

networkidle: vì sao Playwright không khuyến nghị?

networkidle chờ đến khi không còn kết nối mạng trong ít nhất 500 ms. Nghe có vẻ phù hợp với trang động, nhưng tiêu chí này dễ sai lệch. Một website có analytics, WebSocket, quảng cáo hoặc polling có thể không bao giờ thực sự “yên”. Ngược lại, mạng tạm yên trong 500 ms cũng không chứng minh giao diện đã dựng xong.

Tài liệu API chính thức đánh dấu networkidle là discouraged đối với kiểm thử và khuyến nghị dùng web assertion để đánh giá trạng thái sẵn sàng. Vì vậy, không nên thêm networkidle vào mọi lệnh goto() chỉ để cảm thấy an toàn hơn.

page.waitForLoadState() dùng khi nào?

page.waitForLoadState() trả về khi tài liệu hiện tại đạt trạng thái được yêu cầu. Nếu trạng thái đó đã xảy ra trước khi phương thức được gọi, Promise sẽ hoàn thành ngay.

await page.goto('https://example.com', {
  waitUntil: 'domcontentloaded',
});

await page.waitForLoadState('load');

Phương thức này hữu ích khi bạn nhận một đối tượng Page mới từ popup hoặc một thao tác đã tạo điều hướng. Ví dụ:

const popupPromise = page.waitForEvent('popup');
await page.getByRole('link', { name: 'Xem hóa đơn' }).click();

const popup = await popupPromise;
await popup.waitForLoadState('domcontentloaded');

console.log(await popup.title());

Trong phần lớn thao tác thông thường, bạn không cần gọi waitForLoadState() sau mọi lần click. Locator của Playwright đã có auto-wait và thường phản ánh mục tiêu thực tế tốt hơn trạng thái tải chung của trang.

Auto-wait của Playwright hoạt động như thế nào?

Trước khi thực hiện một hành động, Playwright tự kiểm tra phần tử có ở trạng thái phù hợp hay không. Với locator.click(), công cụ thường đợi locator khớp đúng một phần tử, phần tử hiển thị, ổn định, nhận được sự kiện và đang được bật.

await page.goto('https://example.com/login');

await page.getByLabel('Email').fill('[email protected]');
await page.getByLabel('Mật khẩu').fill('example-password');
await page.getByRole('button', { name: 'Đăng nhập' }).click();

Bạn thường không cần chèn waitForTimeout() trước fill() hoặc click(). Nếu ô nhập liệu chưa sẵn sàng, locator sẽ tự chờ trong giới hạn timeout đã cấu hình.

Auto-wait không có nghĩa Playwright hiểu toàn bộ logic nghiệp vụ. Một nút có thể hiển thị và bấm được trong khi dữ liệu phía sau vẫn chưa nạp xong. Khi đó, cần chờ thêm URL, response hoặc một trạng thái DOM mang ý nghĩa nghiệp vụ.

Chờ phần tử bằng locator.waitFor()

Với trang tải nội dung động, chờ locator thường là lựa chọn rõ ràng nhất. locator.waitFor() hỗ trợ các trạng thái attached, detached, visible và hidden.

const productList = page.locator('[data-testid="product-list"]');

await productList.waitFor({
  state: 'visible',
  timeout: 15_000,
});

Trường hợp có biểu tượng loading, bạn có thể chờ nó biến mất:

const spinner = page.locator('[aria-label="Đang tải"]');
await spinner.waitFor({ state: 'hidden' });

Nếu viết test bằng @playwright/test, assertion tự retry thường diễn đạt ý định tốt hơn:

import { expect } from '@playwright/test';

await expect(page.getByTestId('product-list')).toBeVisible();
await expect(page.getByTestId('loading-spinner')).toBeHidden();

page.waitForSelector() vẫn xuất hiện trong nhiều hướng dẫn cũ, nhưng tài liệu Playwright ưu tiên locator và web-first assertion. Locator được tìm lại trước mỗi hành động nên phù hợp hơn với giao diện thường xuyên render lại.

Chờ API bằng page.waitForResponse()

Nếu nội dung chỉ xuất hiện sau một API cụ thể, chờ response thường chính xác hơn chờ load hoặc networkidle. Quan trọng nhất là phải khởi tạo Promise chờ trước thao tác kích hoạt request để tránh bỏ lỡ phản hồi.

const productsResponse = page.waitForResponse((response) =>
  response.url().includes('/api/products') &&
  response.status() === 200 &&
  response.request().method() === 'GET'
);

await page.getByRole('button', { name: 'Tải sản phẩm' }).click();
await productsResponse;

await page.getByTestId('product-list').waitFor();

Mẫu này kết hợp hai tín hiệu: API đã trả thành công và phần giao diện cần dùng đã xuất hiện. Nó ổn định hơn việc đoán rằng trang cần thêm hai hoặc ba giây.

Nếu chỉ cần xác nhận request đã được gửi, hãy dùng page.waitForRequest(). Tuy nhiên, request được tạo chưa đồng nghĩa máy chủ trả dữ liệu hợp lệ; bởi vậy waitForResponse() phù hợp hơn khi kết quả phản hồi mới là điều kiện quyết định.

Chờ chuyển trang bằng page.waitForURL()

Sau khi gửi biểu mẫu, bấm liên kết hoặc đi qua redirect, bạn có thể chờ URL đích thay vì chỉ chờ sự kiện load:

const dashboardPromise = page.waitForURL('**/dashboard', {
  waitUntil: 'domcontentloaded',
});

await page.getByRole('button', { name: 'Đăng nhập' }).click();
await dashboardPromise;

Có thể viết cùng logic bằng Promise.all():

await Promise.all([
  page.waitForURL('**/dashboard'),
  page.getByRole('button', { name: 'Đăng nhập' }).click(),
]);

page.waitForNavigation() đã được Playwright đánh dấu deprecated vì dễ gặp race condition. Với dự án mới, nên dùng waitForURL() khi URL đích là tín hiệu cần xác nhận.

Chờ điều kiện tùy chỉnh bằng page.waitForFunction()

Một số ứng dụng không có locator hoặc endpoint duy nhất thể hiện trạng thái sẵn sàng. Khi đó, page.waitForFunction() có thể liên tục đánh giá một điều kiện trong ngữ cảnh trang cho đến khi kết quả là truthy.

Ví dụ chờ bảng có ít nhất 20 dòng:

await page.waitForFunction(() => {
  return document.querySelectorAll('[data-row]').length >= 20;
});

Hoặc chờ biến trạng thái do chính ứng dụng cung cấp:

await page.waitForFunction(() => window.appReady === true);

Phương thức này linh hoạt nhưng gắn chặt với chi tiết triển khai của website. Nếu có thể dùng locator, assertion hoặc response rõ ràng, các lựa chọn đó thường dễ bảo trì hơn.

Vì sao không nên dùng page.waitForTimeout() làm cách chờ chính?

page.waitForTimeout(3000) chỉ dừng kịch bản trong ba giây; nó không kiểm tra DOM, API hay trạng thái giao diện.

// Chỉ phù hợp khi debug, không nên là chiến lược chờ chính
await page.waitForTimeout(3000);

Nếu trang tải trong 500 ms, kịch bản lãng phí 2,5 giây. Nếu trang cần bốn giây, kịch bản vẫn lỗi. Khi chạy hàng trăm URL, thời gian dư thừa tăng nhanh và kết quả vẫn thiếu ổn định.

Cách sửa là thay thời gian đoán bằng điều kiện có ý nghĩa:

// Không nên
await page.waitForTimeout(3000);
const title = await page.locator('h1').textContent();

// Nên dùng
const heading = page.getByRole('heading', { level: 1 });
await heading.waitFor({ state: 'visible' });
const title = await heading.textContent();

Fixed timeout vẫn hữu ích trong quá trình debug hoặc mô phỏng một khoảng trễ có chủ đích, nhưng không nên dùng để che selector sai, API lỗi hoặc trang chưa sẵn sàng.

Xử lý TimeoutError và lỗi tải trang

Timeout cần phản ánh mức độ mong đợi của từng thao tác. Điều hướng có thể cần nhiều thời gian hơn việc chờ một nút xuất hiện. Bạn có thể đặt timeout cho từng lệnh hoặc cấu hình mặc định ở cấp page/context.

page.setDefaultTimeout(10_000);
page.setDefaultNavigationTimeout(30_000);

try {
  const response = await page.goto('https://example.com/products', {
    waitUntil: 'domcontentloaded',
  });

  if (!response || !response.ok()) {
    throw new Error(`HTTP status không hợp lệ: ${response?.status()}`);
  }

  await page.getByTestId('product-list').waitFor();
} catch (error) {
  console.error('Không thể tải trang hoặc tìm nội dung cần thiết:', error);
  throw error;
}

Cần lưu ý page.goto() không tự ném lỗi chỉ vì máy chủ trả HTTP 404 hoặc 500. Bạn nên kiểm tra response.status() hoặc response.ok() nếu mã trạng thái là một phần của điều kiện thành công.

Retry chỉ nên dành cho lỗi tạm thời như kết nối chập chờn. Nếu selector sai hoặc trang trả lỗi nghiệp vụ, lặp lại cùng thao tác nhiều lần thường không giải quyết được vấn đề. Log nên ghi URL, trạng thái HTTP, thời gian, selector đang chờ và ảnh chụp màn hình khi thất bại.

Cách chờ trang tải xong trong Playwright Python

Nguyên tắc trong Python giống JavaScript, chỉ khác quy ước đặt tên phương thức:

await page.goto(
    "https://example.com/products",
    wait_until="domcontentloaded",
)

product_list = page.locator('[data-testid="product-list"]')
await product_list.wait_for(state="visible")

Chờ một API response trong Python:

async with page.expect_response(
    lambda response: "/api/products" in response.url
    and response.status == 200
):
    await page.get_by_role("button", name="Tải sản phẩm").click()

await page.get_by_test_id("product-list").wait_for()

Nếu dự án dùng API đồng bộ, bỏ await và import từ playwright.sync_api. Dù dùng async hay sync, bạn vẫn nên chờ tín hiệu thật thay vì thêm time.sleep().

Chọn phương thức chờ theo từng tình huống

Tình huống Phương thức nên ưu tiên Lý do
Mở trang HTML đơn giản page.goto() với load Giá trị mặc định đã đủ trong nhiều trường hợp
Trang render dữ liệu bằng JavaScript domcontentloaded + locator Nhanh và gắn với nội dung thực sự cần dùng
Bấm nút rồi chuyển URL waitForURL() Xác nhận đúng địa chỉ đích
Dữ liệu đến từ endpoint xác định waitForResponse() + locator Kiểm tra cả dữ liệu mạng và giao diện
Chờ popup waitForEvent('popup') + popup.waitForLoadState() Làm việc đúng với đối tượng Page mới
Chờ spinner biến mất locator.waitFor({ state: 'hidden' }) Phản ánh trạng thái loading của giao diện
Điều kiện ứng dụng đặc thù waitForFunction() Cho phép kiểm tra logic tùy chỉnh
Kiểm thử giao diện Web-first assertion Có auto-retry và thông báo lỗi rõ ràng

Một quy tắc dễ nhớ là: chọn tín hiệu cụ thể nhất mà bạn kiểm soát được. Locator tốt hơn trạng thái load chung; response cụ thể tốt hơn toàn bộ mạng “yên”; assertion nghiệp vụ tốt hơn một khoảng chờ cố định.

Kết hợp Playwright với proxy có làm trang tải nhanh hơn không?

Proxy không thay thế chiến lược chờ của Playwright. Nó chỉ thay đổi tuyến kết nối và địa chỉ IP mà website nhìn thấy. Nếu locator sai hoặc kịch bản chờ không đúng API, thêm proxy sẽ không khắc phục lỗi.

Ngược lại, kết nối proxy chậm, xác thực sai hoặc IP không truy cập được website đích có thể khiến page.goto() và waitForResponse() timeout. Trước khi tích hợp, bạn nên hiểu proxy là gì và kiểm tra endpoint bằng Proxy Checker.

Playwright hỗ trợ cấu hình proxy khi khởi chạy browser hoặc tạo context. Nếu cần đối chiếu với một thư viện automation gần gũi, hướng dẫn dùng proxy với Puppeteer giải thích host, port và xác thực username/password. Với kiểm thử hiển thị theo khu vực hoặc thu thập dữ liệu công khai trong phạm vi được phép, bạn cũng có thể tìm hiểu proxy dùng để làm gì và cách hoạt động của Residential Proxy.

Khi dùng proxy cho automation, hãy đặt timeout phù hợp với độ trễ thực tế, duy trì session ổn định, giới hạn số luồng và tuân thủ điều khoản của website. Bạn có thể xem thêm các sản phẩm và hướng dẫn liên quan trên Proxify.

Những lỗi thường gặp khi chờ trang trong Playwright

Gọi waitForResponse() sau thao tác kích hoạt

Nếu click trước rồi mới bắt đầu chờ, API có thể phản hồi quá nhanh và sự kiện đã trôi qua. Hãy tạo Promise chờ trước, sau đó mới click.

Dùng networkidle cho mọi website

Trang có polling hoặc kết nối nền có thể không đạt network idle. Hãy chờ endpoint hoặc locator phản ánh đúng dữ liệu cần dùng.

Thấy phần tử trong DOM và cho rằng có thể thao tác

attached chỉ có nghĩa node tồn tại. Nếu cần người dùng nhìn thấy hoặc tương tác, hãy chờ visible và tận dụng actionability check của locator.

Tăng timeout để che lỗi logic

Từ 30 giây lên 120 giây không sửa được selector sai, HTTP 403/500 hoặc response predicate không bao giờ khớp. Trước khi tăng timeout, cần kiểm tra trace, network log và ảnh chụp khi lỗi.

Chờ toàn trang trong khi chỉ cần một thành phần

Widget, quảng cáo hoặc hình ảnh không liên quan có thể tải chậm. Nếu mục tiêu chỉ là bảng giá, hãy chờ bảng giá thay vì chờ mọi request kết thúc.

Checklist tối ưu Playwright wait for page to load

Trước khi hoàn thiện kịch bản, hãy kiểm tra:

  1. Xác định rõ phần tử, URL hoặc API nào biểu thị trang đã sẵn sàng.

  2. Ưu tiên locator và web-first assertion trước explicit wait chung.

  3. Khởi tạo Promise chờ response, URL hoặc popup trước hành động kích hoạt.

  4. Không dùng networkidle làm lựa chọn mặc định.

  5. Hạn chế waitForTimeout() trong code production.

  6. Tách navigation timeout và action timeout theo đặc điểm tác vụ.

  7. Kiểm tra mã HTTP thay vì chỉ dựa vào việc page.goto() không ném lỗi.

  8. Ghi log, trace và screenshot để phân biệt lỗi trang, lỗi mạng và lỗi selector.

  9. Chỉ retry các lỗi có khả năng tạm thời, kèm giới hạn số lần rõ ràng.

  10. Dùng automation và proxy trong phạm vi được phép, không gây tải quá mức cho website.

Câu hỏi thường gặp

page.goto() có tự chờ trang tải xong không?

Có. Nếu không cấu hình waitUntil, page.goto() mặc định chờ sự kiện load. Tuy nhiên, nội dung được tải trễ bằng API có thể vẫn chưa xuất hiện, nên đôi khi cần chờ locator hoặc response cụ thể.

waitForLoadState('load') khác networkidle thế nào?

load chờ sự kiện load của tài liệu. networkidle chờ không còn kết nối mạng trong ít nhất 500 ms. Playwright không khuyến nghị dùng networkidle làm tiêu chí sẵn sàng mặc định cho kiểm thử.

Nên dùng waitForSelector() hay locator.waitFor()?

Nên ưu tiên locator.waitFor() hoặc web-first assertion. Locator phù hợp hơn với giao diện render lại và là hướng tiếp cận được Playwright khuyến nghị cho code mới.

Vì sao waitForTimeout(5000) vẫn bị lỗi?

Vì năm giây chỉ là con số dự đoán. Trang có thể cần lâu hơn, trả lỗi hoặc không bao giờ tạo phần tử do selector sai. Hãy chờ đúng locator, URL hoặc response thay vì thời gian cố định.

Làm sao chờ trang sau khi click trong Playwright?

Nếu click chuyển URL, dùng waitForURL(). Nếu click gọi API, dùng waitForResponse(). Nếu click chỉ thay đổi DOM, chờ locator hoặc assertion tương ứng. Promise chờ nên được tạo trước thao tác kích hoạt khi có nguy cơ bỏ lỡ sự kiện.

Có nên tăng timeout lên thật cao không?

Chỉ tăng khi dữ liệu đo đạc cho thấy thao tác hợp lệ thực sự cần thêm thời gian. Timeout quá cao làm lỗi xuất hiện chậm hơn và có thể che vấn đề cấu hình, mạng hoặc selector.

Kết luận

Không có một lệnh duy nhất phù hợp với mọi trường hợp Playwright wait for page to load. page.goto() và waitForLoadState() giúp chờ các mốc điều hướng chung; locator và assertion phù hợp với trạng thái giao diện; waitForResponse() phù hợp với dữ liệu API; còn waitForURL() xác nhận chuyển trang.

Chiến lược ổn định nhất là bắt đầu bằng domcontentloaded hoặc load, sau đó chờ tín hiệu cụ thể liên quan trực tiếp đến bước tiếp theo. Hạn chế networkidle, tránh timeout cố định và luôn ghi nhận lỗi đầy đủ. Cách làm này giúp test và quy trình automation chạy nhanh hơn, ít flaky hơn và dễ bảo trì khi website thay đổi.

© 2026 Proxify.vn. All rights reserved.

Bảo mật · An toàn · Tự động