The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Set three timeout layers instead of one: an overall request timeout, a navigation timeout for the target site, and a readiness timeout for selectors, functions, or network conditions. Confirm the unit first—ScreenshotOne documents seconds, while Browserless REST uses milliseconds. A long total timeout cannot repair a page that never responds, a blocked request, or a readiness condition that can never become true.
What each timeout controls
Screenshot services run several operations before returning an image: open the URL, wait for navigation, allow JavaScript and assets to render, wait for a required element or event, and encode the result. Providers expose different controls for those stages.
Overall request timeout
This is the outer budget for the complete operation. It normally includes navigation, JavaScript execution, deliberate delays, selector waits and image generation. When it expires, the provider returns a timeout even if navigation itself succeeded.
Navigation timeout
Navigation is the attempt to receive and load the target document. A slow origin, DNS problem, TLS negotiation, overloaded server or redirect chain can consume this budget before your page is ready. Raising only the overall timeout does not necessarily raise the navigation limit.
Free tools Windows power users keep installed
One-click scans. No signup required.
#1 Best Overall
Readiness or element timeout
This applies after navigation when you wait for a CSS selector, function, event or network condition. It is useful for single-page applications that return an HTML shell and populate the visible content later.
Fixed delay
A delay waits a predetermined number of milliseconds or seconds whether the page is ready or not. It is predictable but wasteful when the page is fast and still insufficient when a page is slower than expected. Prefer an observable selector, function or network-idle condition.
Check the unit before writing code
Timeout units are not portable. ScreenshotOne’s documented timeout and navigation_timeout values are in seconds. Its default overall timeout is 60 seconds and its synchronous maximum is 90 seconds; navigation defaults to 30 seconds and is documented with a 30-second maximum. Browserless REST accepts a global timeout query parameter in milliseconds and offers millisecond controls for navigation, selectors, functions and events. BrowserQL’s screenshot mutation also defines screenshot.timeout in milliseconds, with a documented 30,000 ms default.
Local tools differ again: shot-scraper’s --timeout integer is measured in milliseconds. Treat every provider as a separate adapter rather than passing one value unchanged between services.
Rank #2
- Used Book in Good Condition
ScreenshotOne: set total and navigation budgets
A ScreenshotOne-style request places both values in the query string:
https://api.screenshotone.com/take?url=https%3A%2F%2Fexample.com&timeout=20&navigation_timeout=20&access_key=YOUR_KEYHere, both values are 20 seconds. Choose an overall timeout that covers the page’s normal render, then set navigation to the portion you are willing to spend waiting for the origin. If you need a long post-load delay or unusually heavy rendering, the synchronous maximum may be insufficient; use the provider’s asynchronous workflow and webhooks instead.
Choosing values
- Start with a navigation budget that reflects the site’s normal response time, not an arbitrary maximum.
- Make the overall budget large enough to contain navigation plus readiness waits and encoding.
- Do not spend the entire budget on a blind delay. A 20-second delay leaves no room for navigation or rendering in a 20-second request.
- When a site has a known readiness marker, wait for that marker rather than adding several seconds to every request.
Browserless REST: layer millisecond controls
Browserless separates the global request timeout from gotoOptions and element waits. A representative request body is:
{
"url": "https://example.com/",
"gotoOptions": {"timeout": 30000, "waitUntil": "networkidle2"},
"waitForSelector": {"selector": "#main-content", "timeout": 10000, "visible": true}
}Send that JSON to the Browserless /screenshot?token=YOUR_API_TOKEN_HERE endpoint and set the global query timeout high enough to contain the 30,000 ms navigation budget and the 10,000 ms selector wait. The outer timeout is in milliseconds too.
Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Clear out junk files and repair common Windows errorsFree Scan →Use waitFor deliberately
Browserless also accepts a waitFor value that can be a CSS selector, a number of milliseconds, or a page-context function. Use a selector when a specific element proves that the page is usable. Use a function when readiness depends on application state, such as a JavaScript flag or a count of rendered cards. Reserve a numeric delay for pages with no reliable signal.
Design a timeout policy
- Classify the page. Separate static documents, server-rendered pages, and client-heavy applications. The last category usually needs a readiness condition.
- Set navigation separately. Give the origin enough time to respond, but keep a bound that prevents a dead host from occupying a worker indefinitely.
- Define readiness. Select a stable element, function, event or network-idle state. Avoid selectors generated from volatile class names.
- Reserve encoding time. The screenshot operation still needs time after the page is ready, especially for full-page captures and large images.
- Use asynchronous jobs for legitimate long renders. A queue and webhook are safer than pushing a synchronous request to its hard limit.
- Record the decision. Log provider, URL, units, each timeout, readiness rule, elapsed time and returned error.
How to diagnose a timed-out screenshot
1. Verify scope and units
A value of 20 means 20 seconds for ScreenshotOne but 20 milliseconds for Browserless. The latter fails almost immediately. Conversely, accidentally sending 60,000 to a seconds-based API can exceed its allowed maximum.
2. Determine whether navigation is the bottleneck
Try a lightweight URL on the same host and inspect redirect behavior. If the document does not arrive before the navigation limit, adjust navigation settings or fix the origin; increasing only the outer request budget will not solve that failure.
3. Replace a blind delay
If the timeout follows a long delay or numeric waitFor, remove it temporarily and capture at navigation completion. Then add a selector, function or network-idle condition that represents actual readiness.
4. Check for page work that never ends
Continuous analytics requests, streaming connections, client-side polling and third-party widgets can prevent a network-idle condition. Wait for a specific content marker or block unnecessary requests instead of waiting forever for the network to become quiet.
5. Reduce the workload
Capture one element instead of an entire page, avoid loading nonessential resources, and remove needless delays. An excessive delay can consume the complete timeout even when the target page loaded promptly.
6. Inspect the provider error
ScreenshotOne’s timeout error states that the screenshot was not taken within the specified timeout and recommends changing timeout or navigation_timeout, reducing delay, changing wait_until, or using asynchronous requests and webhooks. Preserve that error in logs; it distinguishes a total-budget expiry from other failures.
Common failure patterns and fixes
| Symptom | Likely cause | Fix |
|---|---|---|
| Fails instantly | Milliseconds supplied where seconds are expected, or vice versa | Read the provider’s parameter reference and convert explicitly. |
| Navigation timeout despite a large total timeout | Navigation has its own lower cap | Raise or redesign the navigation budget within the documented maximum; investigate the origin. |
| HTML loads but screenshot is blank | Capture occurred before client rendering | Wait for a visible content selector or application-ready function. |
| Timeout after a fixed wait | Delay consumed the outer budget | Shorten it or replace it with an observable readiness condition. |
| Network-idle wait never finishes | Persistent polling, streaming or third-party requests | Use a selector/function, or block irrelevant requests. |
| Works locally but fails in hosted API | Different network access, authentication, cookies or bot defenses | Supply required headers/cookies where supported and inspect the provider’s page verdict or error. |
| Large pages exceed synchronous limits | Rendering genuinely takes longer than the provider’s synchronous maximum | Use asynchronous jobs and webhooks, or reduce page work. |
Performance, reliability and cost considerations
Timeouts are resource limits, not a speed setting. A high value keeps a slow request alive longer and can reduce throughput when many requests queue. A low value releases capacity quickly but increases false failures on legitimate slow pages. Use separate policies for interactive previews, scheduled monitoring and batch archives.
Best Value
- Interactive requests: use a bounded navigation wait and a specific readiness selector; return a clear retryable error.
- Monitoring: keep the same settings across runs so a timeout change is meaningful, and log elapsed time to detect gradual degradation.
- Batch work: prefer asynchronous jobs, bounded concurrency and retries with backoff. Do not retry a page that consistently fails navigation without investigating it.
- Cost control: avoid repeated long waits for pages that are blocked or empty. Cache successful captures where the provider supports caching, and stop retrying non-transient errors.
Or skip the browser setup
ScreenshotNeo provides a website screenshot API and MCP server. Its clean-shot pipeline accepts cookie and consent banners, then removes more than 60 known consent platforms, newsletter popups and chat widgets before capture; each step can be disabled. Bot checks or CAPTCHAs, blank pages, timeouts, failed loads and cache hits are not billed, and response headers identify the page verdict and billing result.
One GET request returns PNG, JPEG, WebP or PDF. The API supports full-page captures with lazy images loaded, CSS-selector element captures, device and viewport settings, retina scale, custom CSS and JavaScript, click-before-capture actions, selector waits, delays, network-idle waits, request blocking, headers, cookies, user agents, authorization, timezone, geolocation, transparent backgrounds, resizing, chosen cache TTLs, signed image links, asynchronous jobs with signed webhooks, bulk capture of up to 100 URLs per call, a usage API and an OpenAPI specification. Parameter names used by other screenshot APIs also work, which helps when migrating.
cURL
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpPython
import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)
open("shot.webp", "wb").write(r.content)Node.js
const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);See the ScreenshotNeo documentation for the complete parameter reference. The MCP server exposes take_screenshot, get_page_info and capture_pdf to Claude, Cursor and other MCP clients.
Plans include 1,000 screenshots per month free with no card; paid plans start at $5 for 3,000 shots. Every feature is available on every plan. Create a free ScreenshotNeo account.
Portability checklist
- Store timeout values with their units in configuration names, such as
navigation_timeout_secondsandselector_timeout_ms. - Translate settings in one adapter per provider instead of scattering conversions through application code.
- Keep total, navigation and readiness values separate in logs and metrics.
- Test a fast page, a slow page, a client-rendered page and a blocked page before switching providers.
- Document whether an asynchronous timeout means job expiration, webhook delay or browser operation failure.
Frequently Asked Questions
Should I retry every screenshot timeout?
No. Retry transient network or origin failures with bounded backoff, but investigate repeatable selector, bot-check, blank-page and configuration failures first.
Can a longer timeout make a blocked page succeed?
No. A page blocked by a bot check, authentication failure or unreachable origin needs access or request changes, not simply a larger time budget.
Is network idle always the best readiness condition?
No. Persistent polling and streaming can prevent network idle. A stable selector or application-state function is often more reliable.
When should I use an asynchronous screenshot job?
Use one when normal rendering, deliberate waits or large captures can exceed a provider’s synchronous limit and the provider offers webhooks for completion.
Recommended Free Tools
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.
