Windows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallOutdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchIf Cypress times out waiting for a page’s load event in GitHub Actions, first confirm that your app is running and reachable at the exact URL Cypress visits. Then check baseUrl, redirects, and resources that may not finish loading. cy.visit() waits for the browser’s load event—not just the initial HTML response—and Cypress’s default pageLoadTimeout is 60,000 ms. Increase it only when you have confirmed the page is healthy but consistently needs more time.
What a Cypress load-event timeout means
When a test calls cy.visit(), Cypress waits for the browser’s page load event before resolving the command. Receiving the first HTML response is not enough: the browser must reach that event, which can be delayed by resources such as scripts, stylesheets, and images. A server that has not started, a URL that the runner cannot reach, redirects, and requests to unavailable services can all lead to a timeout.
Cypress’s documented default pageLoadTimeout is 60,000 ms. The separate defaultCommandTimeout, which applies to most DOM commands, defaults to 4,000 ms. Changing the latter does not fix a visit waiting for the page load event.
Diagnose the failure in the right order
1. Start the app and wait for its reachable URL
In CI, do not assume that starting a server process means the app is ready to serve requests. Use the Cypress GitHub Action’s start and wait-on inputs so the action polls a URL from inside the runner before it launches tests. Wait on the URL and path your job can actually reach; a health endpoint is useful when it accurately indicates the app is ready.
Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Scan for outdated or missing drivers - takes under a minute3Repair Windows errors before they cause bigger problems- uses: cypress-io/github-action@v7
with:
start: npm start
wait-on: 'http://localhost:8080/health'
wait-on-timeout: 120The action’s default wait-on period is 60 seconds. Set wait-on-timeout in seconds when your measured startup time requires a longer allowance. A longer poll period gives a slow startup more time; it does not correct a server that fails to start or a health URL that is wrong.
2. Verify the exact URL from the runner
Set e2e.baseUrl to the URL Cypress can reach within the GitHub Actions job, including the protocol and port. A relative call such as cy.visit('/') is resolved against that value. If the app runs on a different port, binds to a different interface, or expects a path prefix, make those details consistent between the server, readiness check, and Cypress configuration.
Before Cypress starts, request the same URL from a job step with curl or use the action’s ping helper. This separates a DNS, port, or path problem from a browser-level load issue. A URL that works on a developer’s machine is not proof that it is reachable from the runner.
3. Inspect the page and its network activity
Open the failed URL in available CI browser artifacts, or inspect the Cypress and action logs. Look for failed or stalled resources, redirect chains, certificate errors, authentication loops, and requests to services that are not available from the runner. A page can return HTML successfully and still fail to fire load before the timeout if a required resource never completes.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Also confirm that the final URL is the one you intended. A redirect to a login page, a different origin, or an error page can make a URL or authentication problem look like a slow load. Fix the underlying route, credentials, certificate, or service availability issue instead of granting it an arbitrary extra minute.
4. Increase only the page-load timeout, when evidence supports it
If logs show that the page is healthy and its resources finish successfully, but the load event predictably takes longer than 60 seconds in this environment, increase pageLoadTimeout to a measured value. You can set it globally in Cypress configuration, pass it through the action’s config input, or set a timeout for an individual visit:
// cypress.config.js
const { defineConfig } = require('cypress')
module.exports = defineConfig({
e2e: {
baseUrl: 'http://localhost:3000',
pageLoadTimeout: 100000
}
})// For one visit only
cy.visit('/reports', { timeout: 100000 })In the action, the equivalent configuration can be passed as config: baseUrl=http://localhost:3000,pageLoadTimeout=100000. The example value of 100,000 ms is an illustration, not a universal recommendation: choose a value based on observed healthy load times. Cypress notes that increasing this timeout does not bypass operating-system network limits.
5. Wait for application requests explicitly after navigation
A page’s load event and the readiness of its later application data are different milestones. Register intercepts before visiting, give relevant routes aliases, and wait for those requests or assert on the UI state they produce. Cypress does not provide a magical wait for every XHR or Ajax request. Arbitrary fixed sleeps can make tests slower and less reliable than retryable assertions.
Recommended Free Tools
cy.intercept('GET', '/api/account').as('account')
cy.visit('/dashboard')
cy.wait('@account')
cy.get('[data-testid="account-name"]').should('be.visible')Use this approach when navigation completes but the test races with a specific API request. It is not a remedy for a cy.visit() command that is still waiting for the document’s load event.
A minimal GitHub Actions workflow
This example starts a local app, waits for it, sets the app URL and a larger page-load timeout, enables action logs, and puts a ceiling on the whole job. Adjust the port, startup command, and timeout values to match your application.
jobs:
cypress:
runs-on: ubuntu-latest
timeout-minutes: 10
steps:
- uses: actions/checkout@v4
- uses: cypress-io/github-action@v7
with:
start: npm start
wait-on: 'http://localhost:3000'
wait-on-timeout: 120
config: baseUrl=http://localhost:3000,pageLoadTimeout=100000
env:
DEBUG: '@cypress/github-action'The values above are a starting pattern, not proof that a timeout should be raised. If the app normally starts quickly, investigate why the readiness URL is not responding. If the health check passes but the browser still hangs, inspect page requests and redirects before deciding whether a longer page-load allowance is justified.
Make CI failures observable and bounded
Enable useful logs
- Set
DEBUG: '@cypress/github-action'to see action-level diagnostics. - Set
DEBUG: 'cypress:*'for Cypress logs when you need broader runner detail. - Enable GitHub Actions step debugging by setting the
ACTIONS_STEP_DEBUGsecret or variable totrue. - Preserve screenshots, videos, browser console output, and server logs as artifacts where your workflow supports them.
Prefer the narrowest logging that reveals the failure. Action logs can show whether startup and readiness checks completed; Cypress and browser output help distinguish a navigation hang from an application error.
Set a workflow-level timeout
A job-level timeout-minutes is a safety limit for a stuck process. It prevents one hung workflow from consuming CI minutes indefinitely, but it does not fix the page-load failure. Choose a job bound that leaves enough time for normal startup, test execution, and diagnostic artifacts.
Troubleshoot by symptom
| Symptom | Likely layer | What to check or change |
|---|---|---|
| The readiness check cannot reach the app | Server startup or URL reachability | Confirm the start command stays alive, the app binds to a runner-reachable address, and the wait-on URL has the right protocol, port, and path. |
The readiness check succeeds, but cy.visit() times out |
Browser navigation or page resources | Inspect redirects, certificates, authentication, failed requests, and resources that do not finish in the CI browser. |
| The visit works locally but not in Actions | Environment or network difference | Check that dependencies and external services are available to the runner, and that the configured URL is not machine-specific. |
| The page loads, but an element or data is late | Post-load application synchronization | Intercept the relevant request before navigation, wait for its alias, and use a retryable UI assertion. |
| Failures happen only on a genuinely slow, healthy page | Timeout allowance | Measure successful load times and raise only pageLoadTimeout enough to cover expected variation. |
| The workflow itself never finishes | Job safety bound | Add or review timeout-minutes, then use logs and artifacts to find the process that is stuck. |
Choose a fix by failure layer, not by guesswork
Match the change to the point where the run fails. Server readiness calls for a start command and a reachable wait-on URL. A routing or origin problem calls for correcting the URL and application configuration. An incomplete browser load calls for investigating page resources. A test that needs data after the document loads calls for request aliases and retryable assertions. A timeout increase is appropriate only for a confirmed healthy operation that predictably exceeds the current allowance.
These fixes have different costs. A longer readiness period or retry can add CI minutes; a global page-load timeout affects more visits than a per-visit setting. Logs and retained artifacts improve diagnosis but do not change page readiness. If your team needs hosted run recording, reporting, or parallelization, Cypress Cloud is a separate option to evaluate; check its current commercial terms before relying on them.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Or skip the browser setup
If your goal is to capture a website screenshot—not to run Cypress end-to-end tests—ScreenshotNeo can return an image or PDF through a single request. It is a screenshot API and MCP server; it does not replace the Cypress workflow or fix an application’s load-event timeout. The API accepts screenshot parameters also used by other screenshot APIs, which can make switching easier.
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →For example, this cURL request saves a WebP capture of Stripe:
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpSee the ScreenshotNeo documentation for request options. Before capture, it accepts cookie or consent banners like a visitor and removes more than 60 known consent platforms, newsletter popups, and chat widgets; each of those steps can be turned off. Bot checks or CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are not billed, and each response indicates the page verdict and billing status in headers. An MCP server provides take_screenshot, get_page_info, and capture_pdf tools for AI agents and other MCP clients. The free plan includes 1,000 screenshots per month without a card; paid plans start at $5 for 3,000 shots. Sign up for 1,000 free screenshots a month with no card.
FAQ
Why does the timeout mention the page load event rather than an element?
Because the failed command is waiting for the browser’s document-level load event. Element queries have their own retry behavior and command timeout, so diagnose which Cypress command actually failed before changing settings.
Can I use cy.wait(3000) to make the failure go away?
A fixed wait may delay later test steps, but it does not repair a stalled document load or make an unpredictable request dependable. For a specific API call, register an intercept before navigation and wait for its alias; for UI readiness, use an assertion Cypress can retry.
Does Cypress Cloud fix a page-load timeout?
Run recording, reporting, or parallelization can help teams analyze CI runs, but they do not make an unreachable app or an unfinished browser resource load. Resolve the failing readiness, navigation, or request layer first.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
