# How to get console logs and network errors from a user's browser without asking them to open developer tools

> Five ways to get console logs and failed network requests from someone else's browser: walking them through DevTools, a HAR file, an error tracking service, session replay and a capture extension. What each needs from the user, what each misses, and when to pick it.

Published 2026-11-18, about Snag.

You can get console logs and network errors from a user's browser without developer tools in three ways: an error tracking service already installed in your app, a session replay tool already installed in your app, or a capture extension the user installs once and clicks when they see a bug.
The two older ways, walking the user through developer tools and asking for a HAR file, need the user to open developer tools and make the bug happen again.
Which one fits depends on whether the user can install something, whether you can change the app's code, and whether anyone reported the bug at all.

## What are console logs and network errors, and why do you need them?

Console logs are the messages a web page's code writes while it runs, including the errors the browser raises when that code fails.
Network errors are requests from the page to a server that failed, each with an address and a status code such as 404 or 500.
The pair usually names the cause of a front-end bug: the console gives the error and often the file and line, and the failed request gives the endpoint and what the server answered.
Both live in the user's browser, and a screenshot holds neither.

## The five options side by side

| Option | What the user does | What you change | Sees a bug nobody reported | Best when |
|---|---|---|---|---|
| Walk them through DevTools | Opens developer tools, repeats the bug, copies or screenshots the errors | Nothing | No | One bug, a willing user, a call you are both on |
| A HAR file | Opens developer tools, repeats the bug, exports a file and sends it | Nothing | No | You need every request in full, once |
| An error tracking service | Nothing | Add the service's code to your app | Yes | You want every error in production, reported or not |
| Session replay | Nothing | Add the service's code to your app | Yes | You need to watch what a visitor did |
| A capture extension | Installs it once, clicks it when a bug shows | Nothing | No | Testers, clients and teammates who report bugs to you |

## Walking a user through DevTools

DevTools is the set of developer tools built into Chrome.
On 18 November 2026, [Chrome's documentation](https://developer.chrome.com/docs/devtools/open) lists the shortcut for the Console panel as Cmd + Option + J on a Mac and Ctrl + Shift + J on Windows and Linux, with More Tools, then Developer Tools in the browser menu as the other route.

A script that works on a call:

```text
1. Go to the page where the problem happens.
2. Press Ctrl + Shift + J (on a Mac: Cmd + Option + J). A panel opens.
3. Do the thing that goes wrong again.
4. Take a screenshot of the whole window, including the panel, and send it to me.
```

Chrome records network requests only while DevTools is open ([Chrome's Network reference](https://developer.chrome.com/docs/devtools/network/reference), 18 November 2026), which is why step 2 comes before step 3.
Pick this when it is one bug and the user is patient, ideally with you on a call.
It fails when the bug does not happen a second time, and it is too slow for a group of testers.

## Asking for a HAR file

A HAR file is a saved copy of the network requests a page made, exported from the Network panel of developer tools.
It holds every request with its headers, timing and response, so it answers questions a screenshot of the panel cannot.

On 18 November 2026, [Chrome's Network reference](https://developer.chrome.com/docs/devtools/network/reference) describes the export as "Export HAR (sanitized)" in the Network panel's action bar.
The sanitized file leaves out sensitive information such as the `Cookie`, `Set-Cookie` and `Authorization` headers.
The same page says to tick Preserve log to keep requests across page loads.

Pick a HAR file when you need the full picture of one failure: a slow page, a sign-in redirect loop, a request whose body matters.
The user still has to open developer tools before repeating the bug.
A HAR file can hold private data in addresses and response bodies even when the headers are removed, so ask for it over a private channel and delete it when you are done.
A HAR file has no console messages.

## An error tracking service

An error tracking service is code you add to your app that reports errors from every visitor's browser to a dashboard, with no action from the visitor.
Sentry is one example: on 18 November 2026, [Sentry's error monitoring page](https://sentry.io/product/error-monitoring/) describes installing its JavaScript SDK with npm, stack traces for each error, and breadcrumbs that "show you the events your app and users took prior to an error".

Pick an error tracker for errors nobody reports.
When a visitor hits an error and leaves without telling you, only code running in the app sees it.
What an error tracker does not hold is the person's side: what they expected, and the bugs that throw no error at all, such as a wrong total, a missing button or a layout that overlaps at one window width.
It also needs a change to your code and a deploy, which rules it out for a site you do not control.

## Session replay

Session replay is code you add to your app that records what a visitor did so that you can watch it back, and some replay tools show the console and network beside the recording.
Pick session replay when the question is what the visitor did before the bug, across many visitors, without asking any of them.
It carries the same cost as an error tracker (your code, a deploy) plus two of its own: you are recording people's sessions, which your privacy policy has to cover and sensitive fields have to be masked for, and you have to find the right session among all the recorded ones.

## A capture extension

A capture extension is a browser extension that keeps the recent console messages, network requests and clicks in memory while a person browses, and attaches them to a bug report when the person clicks its button.
The user never opens developer tools.
The bug does not have to happen twice, because the evidence was already being kept when it happened the first time.

Pick a capture extension when the people who find your bugs are people you can ask to install something once: testers, clients in user acceptance testing, support staff, your own team.
It needs no change to the app, so it works on staging, on production and on a site you do not own the code for.

A capture extension sees only what someone chose to report, so it cannot tell you about the visitor who left.
It also cannot help with a member of the public you cannot ask to install an extension.

## Which one should I pick?

- A customer you will talk to once: walk them through DevTools, or ask for a HAR file if the network is the question.
- Errors across all visitors, including the ones nobody reports: an error tracking service.
- What visitors did, across many of them: session replay.
- A known group who report bugs to you regularly: a capture extension.

The options combine: an error tracker in production covers what nobody reports, and a capture extension covers the people who report bugs to you.

## Where Snag fits

[Snag by TestFinch](https://testfinch.com/snag/) is a capture extension with a tracker included.
The extension works in Chrome and other Chromium browsers that support Chrome extensions, such as Edge and Brave.
While a person browses, it keeps the last clicks and navigations, console errors and failed network requests in memory; when they capture a bug, those are attached to a marked-up screenshot or up to 90 seconds of recording, with the page and browser.
Nothing is sent until the person files a bug.
On the bug's page your team sees the console errors and the failed requests next to the screenshot, and a coding agent connected to TestFinch can read the same evidence.

Snag Free covers 1 project and 50 bugs a month.
[Capture and triage bugs with Snag](https://testfinch.com/docs/snag-capture/) lists what each way of reporting captures.

Snag does not catch errors nobody reports, and it does not record sessions.
If you run Sentry, Snag's Sentry integration shows backend errors on each bug, so the two cover each other's gap.
For the first reply to a report that arrived with no details at all, see [My client says the site is broken and sends no details](https://testfinch.com/blog/client-says-it-is-broken-no-details/).
