Some links on this page are affiliate links: if you buy through them we may earn a commission, at no extra cost to you.
A 499 status code means the client closed the connection before the server finished sending its response. It is a nonstandard status used primarily by Nginx and services built around it, including Cloudflare logging. The server may still be working, but once the browser, app, proxy or network ends the connection, there is nowhere to send a completed response. Treat 499 as a cancellation and timing signal—not automatic proof that your origin failed.
What does a 499 status code mean?
Nginx records 499 Client Closed Request when the requesting party disconnects while Nginx is processing the request. Because the connection is already gone, the client normally does not receive a standards-defined HTTP 499 response. You see the code in server, reverse-proxy, CDN or analytics logs.
The “client” can be a browser, mobile app, API consumer, load balancer or another proxy. A person closing a tab, cancelling a download, navigating away, losing mobile connectivity, or hitting a client-side timeout can all produce the same observation. A slow endpoint or large upload makes the event more likely because there is more time for something upstream to give up.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Cloudflare describes 499 in its Nginx-associated logging context. Its January 2026 HTTP/3 changelog says that when an HTTP/3 client cancels a request stream, Cloudflare immediately records 499; the underlying HTTP/3 connection can remain open even though that request stream has ended.
#1 Best Overall
- Used Book in Good Condition
Is a 499 the client’s fault or the server’s?
Neither label is sufficient by itself. The immediate event is client-side disconnection, but a slow or stuck server path may have caused the user, browser or intermediary to time out first. Conversely, a healthy endpoint can show 499 when users routinely cancel navigation or downloads.
- Expected cancellation: a user leaves a page, presses stop, cancels a download or closes an app.
- Network interruption: Wi-Fi or mobile connectivity disappears before the response completes.
- Timeout mismatch: a browser, SDK, proxy or CDN deadline expires while the origin continues working.
- Slow application work: database queries, third-party calls, report generation, large uploads or rendering exceed the patience of an upstream participant.
- HTTP/3 stream cancellation: Cloudflare can log a 499 when a client cancels one request stream while keeping the connection itself alive.
Do not infer a server defect from a 499 count alone. First determine which endpoints, methods, clients and elapsed times are involved and whether the user’s task completed.
499 compared with 522 and 524
| Signal | Meaning in Cloudflare documentation | What it tells you |
|---|---|---|
| 499 | The client closed before the server could send its response. | A request cancellation or connection ending; not proof that the origin returned an error. |
| 522 | Cloudflare could not establish the origin TCP connection within its documented connection-handshake behavior. | A connection-establishment problem, before normal response processing. |
| 524 | Cloudflare connected to the origin but did not receive an HTTP response within the applicable timeout. | An origin response-time problem after connection, distinct from a client closing first. |
These meanings are platform-specific. Another vendor may use 499 for something unrelated; ArcGIS, for example, uses 499 for “Token Required.” Always identify the product and component that emitted the code.
Outdated 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 matchPC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11How to investigate recurring Nginx 499 entries
- Filter and group the events. Break 499 records down by URI, HTTP method, status from upstream (if logged), user agent, client network, request ID and elapsed time. A single slow export endpoint is a different problem from cancellations spread across normal page loads.
- Measure request duration. Compare request time and upstream response time for 499s with successful requests. Where available, inspect p95 origin response time and the provider’s Top endpoints view; Cloudflare recommends this when origin response times are high.
- Correlate every hop. Follow one request ID through browser or SDK logs, CDN, load balancer, Nginx and the application. Record each timeout and the timestamp at which the connection or stream ended. The first component to close is the key fact.
- Check user outcome. A cancelled autocomplete request is usually harmless. A cancelled payment, upload or report may leave work running or create an ambiguous result and needs an idempotent product flow.
- Inspect the slow path. Profile database queries, upstream APIs, locks, queue waits, template rendering and response transfer. Fix the demonstrated bottleneck instead of raising every timeout.
- Reassess the timeout chain. Set deadlines deliberately across client, proxy, CDN and origin for the actual workload. There is no universal “correct” 499 timeout. Cloudflare’s documented handshake example—19 seconds for an initial SYN+ACK wait followed by one 15-second retry—is specific to that platform and is not an Nginx default or general threshold.
- Track a baseline. Compare rates by endpoint and completed-task success over time. No industry-wide abnormal-rate threshold is established; your own workload and user outcomes are the useful reference.
Ways to reduce avoidable 499s
Make interactive requests short
Paginate large responses, select only required fields, stream genuinely large downloads, and move report generation or image processing to a job queue. Return a job ID quickly and let the client poll or receive a callback rather than holding one request open for minutes.
Align deadlines with the operation
Choose separate limits for fast page requests, uploads, exports and background jobs. Ensure a proxy does not expire substantially earlier than the client, and ensure the application can stop or safely continue work when a caller disappears. Raising a timeout without reducing the underlying work merely delays cancellation.
Handle cancellation safely
Use idempotency keys for payments and other state-changing operations. Make retries conditional: a read can often be retried, while a write needs a request ID and a way to check whether the original operation committed. Cancel database or upstream work when your framework reliably reports a disconnected client, but do not assume every disconnect notification is immediate.
Rank #3
Improve client behavior
Debounce search-as-you-type calls, cancel superseded requests, use realistic SDK timeouts and retry only transient operations with backoff. For uploads, support resumable chunks so a mobile network drop does not restart the entire transfer.
Separate normal navigation from failures
Tag telemetry with route changes, explicit user cancellation and network type where privacy policy permits. Exclude known-abort patterns from availability alerts, while still watching for a new cluster on a revenue-critical endpoint.
Troubleshooting common 499 symptoms
| Symptom | Likely cause | Useful next step |
|---|---|---|
| 499s only on a slow export | Users or an intermediary time out while generation runs. | Profile generation; move it to an asynchronous job and provide status polling. |
| 499s spike on mobile networks | Roaming, radio changes or short client deadlines. | Compare elapsed time and network type; use resumable transfers and a client deadline suited to the operation. |
| 499s on every request after a deployment | Proxy, client or HTTP/3 cancellation behavior changed. | Correlate deployment time, protocol, request IDs and timeout configuration; verify which hop closes first. |
| 499 appears with high origin latency | The origin is slow enough for callers to abandon it. | Use endpoint-level traces and database/upstream timings; optimize the bottleneck before changing limits. |
| 499 appears but the user’s action succeeded | The response was cancelled after the server committed the work. | Make the operation idempotent and expose a status lookup so clients can safely reconcile the result. |
Logging fields that make 499s diagnosable
Include a request ID, start and end timestamps, total request time, upstream connect and response times, bytes received and sent, URI, method, protocol, authenticated client or service (without secrets), and an indication of whether the application began or completed the operation. Log cancellation separately from application exceptions. Never place cookies, authorization values or personal data in a diagnostic URL or shared log sample.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Or skip the browser setup
If the long-running work is taking website screenshots, a managed capture request avoids maintaining a browser process and its page-load timeouts. ScreenshotNeo accepts one GET request and returns PNG, JPEG, WebP or PDF. Before capture it accepts cookie or consent banners and removes more than 60 known consent platforms, newsletter popups and chat widgets; each cleanup step can be disabled. Bot checks, CAPTCHAs, blank pages, timeouts, failed loads and cache hits are not billed, and response headers identify the page verdict and billing result.
Use the API documentation at https://screenshotneo.com/docs/ for all options. A minimal cURL call is:
The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpThe equivalent Python request:
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)And 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}`);ScreenshotNeo also provides an MCP server with take_screenshot, get_page_info and capture_pdf for Claude, Cursor and other MCP clients. It supports full-page and element captures, device presets, retina scale, custom CSS and JavaScript, waits, request blocking, headers, cookies, geolocation, caching, signed links, async webhooks and bulk capture of up to 100 URLs per call. Plans include 1,000 screenshots a month free with no card; paid plans start at $5 for 3,000. Create a free ScreenshotNeo account to try it.
What to monitor after a fix
- 499s by endpoint, protocol and client type, not just a global count.
- p50 and p95 origin latency for affected routes.
- Completed business actions versus abandoned requests.
- Retries, duplicate writes and background jobs still running after disconnects.
- Changes after timeout, HTTP/3, proxy or application deployments.
A successful change reduces avoidable cancellations or improves completed-task rate without masking genuine slow work with arbitrarily long deadlines.
Frequently Asked Questions
Will a browser display a 499 page?
Usually no. In the Nginx and Cloudflare contexts described here, 499 is principally a server-side log or analytics observation recorded after the client connection has ended.
Should every 499 request be retried?
No. Retry only when the operation is safe and idempotent, or when you can query the original request’s result. Blindly retrying a cancelled write can duplicate work.
Does HTTP/3 make 499 an origin error?
No. Cloudflare’s HTTP/3 logging uses 499 for a client-cancelled request stream; the underlying connection may remain open.
Can I set an Nginx directive that eliminates 499?
No single directive eliminates the condition. Find which participant closes first, then address slow work, client behavior or mismatched deadlines for that request path.
The Bottom Line
Use 499 as evidence that a request ended before its response was delivered. Segment the events, correlate timeout owners, fix the slow path and design safe cancellation handling; do not treat the code alone as proof of an origin outage.
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.
