Why "page.goto()" is slowing down your Playwright tests in 2026

The page.goto() method in Playwright is a fundamental function that allows tests to load a specified URL and waits for the page to reach a specific state before the test continues.

This article explores the inner workings of page.goto(), common causes of slowdowns, and practical strategies to speed it up, helping you optimize test performance in 2026.

Understanding page.goto() in Playwright

The page.goto() method is a core function in Playwright used to navigate to a specified URL within a browser context during testing. When called, it directs the browser to load the page and, by default, waits until the entire page, including all dependent resources such as stylesheets, images, scripts, and iframes, is fully loaded and the load event is fired.

This comprehensive waiting ensures the page is completely ready for any interactions or assertions that follow in the test script. However, this default behavior can sometimes lead to slower test execution times, especially on resource-heavy pages.

Understanding how page.goto() manages navigation and loading helps in optimizing test performance effectively.

How page.goto() works in Playwright

page.goto() is typically one of the first actions in a test, as it opens the page or application you want to interact with.

Here’s a deeper look into how page.goto() works:

1. Navigates to a URL: The primary role of page.goto() is to navigate to the provided URL. For instance:

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

2. Waits for the page to load: By default, page.goto() will wait until the page load event is triggered. This means Playwright will wait for the browser to fully load all resources before continuing to the next step in the test.

3. Customizable Wait Mechanism: Playwright provides a waitUntil option that allows you to control what event or state should trigger the next action. You can specify different states for navigation, such as:

• “load”: Waits for the full page to load, including all resources (default behavior).
• “domcontentloaded”: Waits for the DOM to be fully parsed, but without waiting for images, styles, and scripts to load.
• “networkidle”: Waits until there are no more than 2 network connections for at least 500 ms. This is useful for SPAs but may be overkill in traditional page tests.
• “commit”: Waits until the navigation is committed, meaning the URL has changed, but doesn’t wait for the full load.

Example:

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

4. Timeout Handling: page.goto() also supports a timeout parameter that allows you to set a maximum amount of time to wait for the page to load. If the page doesn’t load within this time, a timeout error is thrown. This is especially useful in preventing tests from hanging indefinitely due to network or application issues.

await page.goto(‘https://example.com’, { timeout: 30000 }); // 30 seconds timeout

5. Browser Context: If you are running multiple tests, page.goto() can be used within different browser contexts or pages. This allows for isolated tests where each test runs in a clean session, ensuring that no state is shared between tests.

Common Reasons for page.goto() Slowdowns

Several factors can contribute to slowdowns when using page.goto() in Playwright tests. Understanding these reasons can help you identify and resolve performance bottlenecks in your tests. Here are the most common culprits:

Heavy Pages with Multiple Resources

Web pages today often contain numerous resources like images, scripts, stylesheets, and third‑party services (ads, analytics, etc.). By default, Playwright waits for all of these resources to load when using page.goto(). 

Large or resource‑intensive pages can cause significant delays as Playwright waits for these resources to finish loading.

Using waitUntil:”load”

The default waitUntil: “load” causes Playwright to wait until the entire page and all resources (images, scripts, styles, etc.) are fully loaded.

For many tests, waiting for the entire page to load is unnecessary and can lead to delays. Opting for lighter wait options like “domcontentloaded” can significantly reduce the wait time.

Third Party Resources

External resources such as third’#145;party JavaScript (analytics, social media widgets, ads) can slow down page load times, as they often introduce additional network requests or have variable response times. Playwright waits for all these resources to load unless explicitly instructed not to.

Network Conditions and Backend Latency

Slow network connections, either due to local setup (like throttling) or backend delays (slow API responses, database calls), can cause page.goto() to take longer to complete.

The networkidle option, while useful for some applications, can also introduce delays if network requests continue to be made in the background.

Misconfigured waitUntil Options

Using “networkidle” or “load” when it’s not necessary can result in unnecessarily long waits. For instance, Playwright will wait for idle network connections or full page loads, even if your test only needs the DOM to be ready or a specific part of the page loaded. Adjusting this based on your test requirements can speed up navigation significantly.

Test Environment and CI Constraints

Testing environments, especially in CI/CD pipelines, can add overhead that impacts performance. For instance, running tests on virtualized or containerized environments with limited resources (memory, CPU) can slow down navigation.

Additionally, if caching is disabled, browsers may need to load resources from scratch each time, further increasing test times.

Browser State and Caching

If tests are running in a fresh browser context or on cold browser sessions (where the cache isn’t used), Playwright may need to load everything from scratch for every test, causing delays. On the other hand, if caching is enabled, subsequent navigations may be faster as resources are retrieved from the cache instead of being downloaded again.

By understanding these common factors, you can identify which aspects of your tests or environment may be contributing to slow page.goto() times and take steps to optimize them.

Analyzing Your page.goto() Bottlenecks

To identify the causes of slow page.goto() executions in Playwright, it’s crucial to assess multiple factors that may be contributing to delays. Here’s how you can analyze and pinpoint the bottlenecks:

1. Measure Navigation Time

Log start and end times around page.goto() to understand how long navigation takes. This helps quantify the delay.

const start = Date.now();

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

const duration = Date.now() – start;

console.log(`Navigation took ${duration}ms`);

Use Playwright Trace Viewer for a detailed breakdown of navigation and resource loading.

2. Inspect Network Requests

Monitor network logs to identify slow or unnecessary requests (images, third-party scripts) that could be slowing down navigation.

page.on(‘response’, response => {

console.log(`Resource URL: ${response.url()} – Status: ${response.status()}`);

});

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

Block non-critical resources (like ads or trackers) to reduce load times.

await page.route(‘**/*.{jpg,png,css,js}’, route => route.abort());

3. Review waitUntil Settings

Adjust the waitUntil parameter to be more efficient. Instead of waiting for “load”, use “domcontentloaded” or “commit” to reduce waiting time for unnecessary resources.

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

4. Check for Backend/API Latency

Analyze the backend response time for APIs or databases that might slow down page load. Inspect network logs to see if any calls are causing delays.

5. Evaluate Test Environment

• Assess the CI/CD environment’s resource limitations, as a constrained environment can slow down page navigation. Ensure that test environments (especially cloud or container setups) have sufficient resources.
• Cold browser sessions (without cache) can slow down the test. Reuse sessions or browser contexts when possible.

6. Examine JavaScript or DOM Blocking

Identify if heavy JavaScript execution or rendering issues are delaying page readiness. Tools like Playwright’s performance insights can help you detect rendering or script bottlenecks.

By analyzing these aspects, you can isolate which part of the process is slowing down page.goto() and take the necessary steps to optimize navigation speed in your Playwright tests.

How to Speed Up page.goto() in Playwright Tests

Optimizing page.goto() in Playwright can significantly improve the speed of your tests. Here are several strategies to speed up navigation:

1. Use a Lighter waitUntil Option

Instead of waiting for the entire page to load with the default waitUntil: ‘load’, use “domcontentloaded” or “commit”. These options reduce wait times by only waiting for the DOM or URL change, not all resources to finish loading.

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

2. Block Non-Essential Resources

Block unnecessary resources like images, third-party scripts, or ads that aren’t needed for your test. This can speed up page loading by preventing these items from loading.

await page.route(‘**/*.{jpg,png,css,js}’, route => route.abort());

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

3. Reuse Browser Contexts

Reuse the same browser context or page across tests to avoid the overhead of reloading resources (like logging in) for each test. This reduces setup time.

const context = await browser.newContext();

const page = await context.newPage();

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

4. Avoid Over Waiting

Playwright’s auto-waiting mechanisms are efficient, so avoid using page.waitForTimeout() or unnecessary explicit waits. This allows Playwright to automatically proceed when elements are ready.

await page.click(‘#submit’); // Waits for the button to be clickable before clicking

5. Mock or Stub Backend/API Responses

If your tests depend on slow backend responses, mock or intercept API calls to return faster responses, reducing the wait for network requests.

await page.route(‘https://api.example.com/*’, route =>

route.fulfill({

status: 200,

body: JSON.stringify({ data: ‘mocked data’ }),

})

);

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

6. Optimize Test Environment Resources

Ensure your test environment has enough resources (CPU, memory, bandwidth). Avoid slow network conditions unless necessary, and run tests on a machine with adequate resources to prevent slowdowns.

7. Leverage Browser Caching

Reuse cached resources between tests by preventing cache clearing. This avoids re-downloading assets and speeds up navigation.

const context = await browser.newContext({ cacheEnabled: true });

const page = await context.newPage();

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

8. Run Tests in Parallel

Parallel tests help to reduce total test suite runtime. Playwright supports parallel test execution, allowing multiple tests to run at once, speeding up overall execution.

9. Use Persistent Storage for Sessions

Persist cookies or local storage across tests to avoid re-logging in or resetting sessions, which can save time and speed up navigation.

const cookies = await context.cookies();

await page.context().addCookies(cookies); // Reuse cookies for subsequent tests

10. Continuously Monitor and Optimize Performance

Regularly track navigation times and performance. Use Playwright’s tracing and logging to identify slowdowns and optimize tests accordingly.

Best Practices for Faster Navigation in Playwright

To speed up navigation in your Playwright tests, follow these best practices:

• Optimize waitUntil Settings: Use “domcontentloaded” or “commit” instead of the default “load” to speed up navigation by waiting only for the DOM or URL change, not all resources to finish loading.
• Block Unnecessary Resources: Block images, CSS files, and third-party scripts (ads, analytics) that aren’t needed for your test to reduce page load time.
• Use Browser Contexts and Page Reuse: Reuse browser contexts or pages across tests to avoid redundant resource loading (e.g., login states or session data), speeding up test execution.
• Leverage Browser Caching: Enable caching between tests to prevent reloading the same resources like images and scripts, saving time.
• Use Persistent Sessions for Authentication: Persist cookies or local storage to maintain authentication states across tests, avoiding repeated login steps and saving time.
• Minimize Explicit Waits: Rely on Playwright’s auto-waiting features to automatically wait for elements to be ready, instead of using arbitrary waitForTimeout() calls.
• Use Mocking for Slow Network Calls: Mock or stub slow backend API responses to eliminate delays caused by network requests, speeding up tests that don’t require real-time data.
• Parallelize Tests: Run tests in parallel to reduce total test execution time by distributing tests across multiple workers.
• Avoid Unnecessary Navigation: Skip redundant page loads or reuse already-loaded pages when possible to save time on navigation.
• Monitor Performance and Continuously Optimize: Regularly track navigation times and use Playwright’s tracing tools to identify bottlenecks and optimize accordingly.

How these Optimizations Impact Your CI/CD Pipeline

Optimizing Playwright tests, especially for faster navigation, can have a profound impact on the performance and efficiency of your CI/CD pipeline. Here’s how:

1. Faster Feedback Loops

• Quick test execution: By minimizing waits, reusing browser contexts, and blocking unnecessary resources, tests run faster, leading to quicker feedback.
• Early issue detection: Developers can identify and address issues faster, ensuring that bugs are caught early in the development process.

2. Reduced Test Suite Runtime

• Efficiency gains: Reducing the time spent on page.goto() and other resource-heavy operations will drastically cut down overall test suite runtime.
• Lower resource consumption: Shorter tests use fewer resources (CPU, memory, bandwidth), which is particularly important in cloud-based CI environments where you incur costs for time and resources.

3. Improved Scalability

• Handling larger test suites: Optimizations like parallelizing tests and caching resources allow your test suite to scale efficiently as your application grows.
• Increased test capacity: Faster tests mean more tests can be run within the same time window, ensuring that new features and changes are thoroughly tested without delaying the pipeline.

4. Increased Stability and Reliability

• Reduced flakiness: Optimizing the network and resource management reduces dependencies on external factors (e.g., slow backend or third-party services), leading to more consistent and stable tests.
• More predictable results: With fewer false negatives (tests failing due to network delays or third-party service issues), the results are more reliable, providing developers with accurate feedback.

5. Cost-Efficiency

• Lower infrastructure costs: By reducing test runtime and optimizing resource usage, your CI/CD pipeline becomes more cost-effective. This is particularly valuable in cloud-based CI services where you pay for compute time.
• Faster releases: Optimizations reduce the bottleneck that slow tests can create in the pipeline, leading to faster delivery of new features and bug fixes.

6. Increased Developer Velocity

• Faster deployments: With quicker test execution, the time taken from code commit to deployment is shortened, accelerating the overall development cycle.
• More frequent releases: Continuous testing with optimized navigation allows for more frequent, reliable releases, ensuring that new features or fixes are deployed faster.

Boost Playwright Test Speed and Reliability with BrowserStack Automate

Integrating Playwright with BrowserStack Automate enhances your test speed, scalability, and reliability. By leveraging BrowserStack’s cloud infrastructure, you can run tests across multiple browsers, devices, and OS combinations simultaneously, drastically reducing test execution time.

• Parallel Test Execution: Run Playwright tests concurrently on multiple browsers and devices to speed up overall test time.
• Cross-Browser and Real Device Coverage: Test your application on real browsers and physical devices, ensuring consistent performance across all environments.
• Cloud-Based Testing: Eliminate local resource limitations and run tests in a stable, high-performance cloud environment.
• Seamless CI/CD Integration: Easily integrate with popular CI/CD tools, automating tests in your pipeline for faster feedback.
• Rich Test Insights: Gain valuable insights with video recordings, logs, and screenshots to debug and optimize your tests.
• Scalability: Easily scale your testing as your test suite grows, without worrying about managing infrastructure.

By offloading testing to the cloud, BrowserStack allows for faster, more reliable Playwright tests, improving both your test coverage and CI/CD pipeline efficiency.

Talk to Expert

Conclusion

Optimizing page.goto() and integrating Playwright with tools like BrowserStack Automate can significantly enhance the speed, reliability, and scalability of your automated testing. By fine-tuning navigation, leveraging cloud infrastructure, and running tests across real browsers and devices, you can ensure faster feedback, more consistent results, and broader coverage.

These optimizations not only reduce the overall test suite runtime but also improve the stability of your CI/CD pipeline, allowing for faster releases and higher-quality software.

By adopting these strategies, you can streamline your testing process, catch issues earlier, and maintain a robust, efficient testing workflow, ultimately boosting the performance of your applications and development cycles.

Try BrowserStack Now

Useful Resources for Playwright

• Playwright Automation Framework
• Playwright Java Tutorial
• Playwright Python tutorial
• Playwright Debugging
• End to End Testing using Playwright
• Visual Regression Testing Using Playwright
• Mastering End-to-End Testing with Playwright and Docker
• Page Object Model in Playwright
• Scroll to Element in Playwright
• Understanding Playwright Assertions
• Cross Browser Testing using Playwright
• Playwright Selectors
• Playwright and Cucumber Automation

Tool Comparisons:

• Playwright vs Puppeteer
• Playwright vs Cypress
• Playwright vs Selenium
• Cypress vs Selenium vs Playwright vs Puppeteer