Client-side error
A client-side error is a failure that happens in the user's browser rather than on the server: a script that throws, a resource that fails to load, a layout that breaks or a request the browser never sends. A server-side error happens in the backend and usually appears in server logs; a client-side error leaves a trace only in the browser it happened in, unless something running there captured it.
The longer version
The browser runs a large part of a modern application: it renders the page, executes the JavaScript that responds to clicks, validates forms, calls APIs and manages state. Any of that can fail without the server being involved. The script may reference a property that is undefined on this data, the CSS may be missing a rule for this viewport, a browser extension may have altered the page, or a third-party tag may have thrown inside a handler the page's own code shared with it. The server handled every request it received correctly and knows nothing about the failure.
The contrast with server-side errors is where the evidence lives. A server error produces a response with an error status, a stack trace in the application log and an entry in monitoring; the developer can find it without the user. A client error produces an entry in one person's browser console and a wrong screen in front of them, then the page is reloaded and both are gone. The two are also confused when a client error is triggered by a server response, such as a script that assumes a field the API stopped returning; the root cause is on the server but the failure is in the browser.
The report describes the symptom and the developer cannot find it. The submit button does nothing, the server shows a clean request log, and the developer marks it cannot reproduce. The missing pieces are the console output, the browser and version, the device and viewport, and which requests the page did or did not send. Client errors are also the class most dependent on environment, since the same code runs on every browser and extension combination its users happen to have, which is why a report without that context is a guess.
Common questions
What is the difference between a client-side and a server-side error?
A server-side error happens in the backend, returns an error status and is written to server logs where a developer can find it. A client-side error happens in the browser, in JavaScript, CSS or resource loading, and is recorded only in that user's console unless a script on the page captured it. Server errors are visible to the team by default; client errors are visible only to the person who hit them.
Why can't the developer see a client-side error in the logs?
Server logs record requests the server received and what it did with them. A client-side error happens before, after or instead of a request, in code running on the user's machine, so the server has nothing to record. Seeing it requires the browser console from the affected session or a tool that captured it.
What should a bug report for a client-side error include?
The console output at the moment of failure, the browser and its version, the operating system and device, the viewport size, the page URL and the network requests the page made or failed to make. With those, a developer can usually reproduce the error on the first attempt; without them the report reads as cannot reproduce.
What does "Application error: a client-side exception has occurred" mean?
That message is the error screen a Next.js application shows when an uncaught exception is thrown in the browser after the page has loaded and React can no longer render it. The server delivered the page correctly; the failure is in the JavaScript that ran afterwards. Capture the console entry beneath it, which names the file and line, plus the browser, the URL and the action that came before, since the screen says nothing about the cause.
Can client-side errors be monitored automatically?
Error-monitoring scripts on the page listen for the browser's error and unhandled rejection events and send each occurrence to a service with the browser, URL and stack trace. They catch thrown exceptions well. They do not see a layout that broke, a button that quietly did the wrong thing or a request the page never sent, which is why a person's report still matters.
Bug reports that arrive ready to triage.
Collect replay, console, network and browser context with the Free plan.