PintellyPintelly
← All posts
Comparison·

Usersnap vs Marker.io: Console and Network Log Capture Compared (With Sources)

How Usersnap and Marker.io actually capture console and network logs in React, Vue, GraphQL, and WebSocket SPAs, verified against each vendor's own help docs, not marketing pages.

We're Pintelly, and we build bug-reporting tools ourselves, so console and network log capture is something we track closely across the market, not just our own product.

If you build on React, Vue, or any GraphQL/WebSocket-heavy SPA, you've probably had this experience: a user or client submits a bug report, and the actual failure, a rejected API call, a dropped WebSocket message, a silently failing GraphQL mutation, never shows up anywhere in the report. You end up asking "can you reproduce this?" instead of just reading the network log.

Usersnap and Marker.io both promise to fix this, but they capture console and network data under very different conditions, and most comparison pages that rank for "usersnap vs marker.io" are written by one of the two vendors (or a smaller competitor) with an obvious incentive to flatter itself. We sourced this article entirely from each vendor's own help center documentation, quoting directly, so you can check the claims yourself before picking a tool.

Why Network Capture Matters More in SPAs

In a traditional server-rendered app, a broken request usually produces a visible error page. In a single-page application, a failed fetch, a rejected GraphQL query, or a WebSocket that silently disconnects often just leaves the UI looking "stuck" or "a bit off", with no error message a non-technical reporter would notice or describe.

That's why the request itself, its URL, payload, and response status, matters as much as the console error. A screenshot and a console log tell you that something broke. The network log tells you what broke and why.

Does Usersnap Capture Network Requests? Clearing Up a Common Search

A lot of people search "usersnap doesn't capture network requests," and based on Usersnap's own documentation, that phrasing isn't accurate.

Usersnap's help center describes a "Console Recorder" feature that captures both console output and network activity: "Our console recorder also logs network requests (XHR and Fetch)" (help.usersnap.com/docs/console-recorder-feature).

The real catch is activation, not capability. The feature is off by default and has to be turned on manually: go into the feedback project, open Configure → Manage → Settings, and enable it there before it starts recording anything. If a team never does that, every report they receive will look exactly like network capture doesn't exist, which is likely where the "Usersnap doesn't capture network requests" search phrase comes from.

The same documentation lists several practical limits worth knowing before you rely on it:

  • Errors firing very early in the page lifecycle (for example, inside an onload handler) can be missed, since the recorder loads asynchronously.
  • It does not record on mobile devices.
  • It does not work in sessions where a browser extension was used to submit feedback.
  • AngularJS apps need an extra small library for the recorder to work correctly.
  • Console logs currently cannot be exported.

One more thing worth flagging: Marker.io's own blog comparison claims Usersnap "captures environment and console logs but not network logs" (marker.io/blog/usersnap-vs-userback-vs-markerio). That's a competitor's claim about another competitor, and it doesn't match what Usersnap's own help docs say. It's a useful reminder to check a vendor's own documentation rather than a rival's comparison page before making a decision.

Usersnap's public docs also don't say anything about how GraphQL requests or WebSocket connections are handled specifically. If your app leans heavily on either, that's a question to put directly to Usersnap support rather than assume an answer either way.

Marker.io's Network Capture: Two Documented Limits

Marker.io captures network requests automatically, with no manual setup required, that's the main practical difference from Usersnap. But its own help center is explicit about two limitations that matter specifically for GraphQL and real-time apps (help.marker.io/en/articles/6562135-network-requests):

1. Repeated requests, GraphQL in particular, get grouped. The docs state: "If some API calls (especially GraphQL queries) are missing from the logs, it may be because Marker.io groups identical, repetitive requests." In practice, if your app fires the same GraphQL query repeatedly (a common pattern with polling, refetching, or component re-mounts), some of those calls simply won't appear in the captured log. Marker.io's suggested workaround is to append unique parameters or use distinct operation names per call, which means asking your engineering team to adjust how requests are made, not a setting you flip in the dashboard.

2. WebSocket connections aren't supported. The same article lists WebSocket explicitly under "not yet supported," alongside Server-Sent Events, WebRTC data channels, Service Worker requests, and the Beacon API. If a feature depends on a live socket connection, chat, real-time notifications, collaborative editing, Marker.io's network log won't show any of that traffic when it breaks.

In practice: a GraphQL-heavy app may see some genuinely relevant calls silently missing from the log, and any WebSocket-based feature is a blind spot for Marker.io's network capture entirely, regardless of settings.

Comparison Table: Console and Network Log Capture

CapabilityUsersnapMarker.ioPintelly
Console log captureYes (Console Recorder)Yes, automaticYes, log, error, warn, info, debug levels, selectable per project
Network request (XHR/Fetch) captureYes, but off by default; requires manual activation in project settingsYes, on by defaultNot currently available (see below)
Handling of repeated / GraphQL requestsNot documented publiclyIdentical/repeated requests are grouped; some GraphQL calls may be missing from the logNot applicable, no network capture feature
WebSocket connectionsNot documented publiclyExplicitly listed as "not yet supported"Not applicable, no network capture feature
Known capture gaps (per vendor docs)Mobile devices, browser-extension sessions, very early page errors, AngularJS needs extra setupGraphQL request grouping, WebSocket, SSE, WebRTC, Service Worker, Beacon APINetwork/XHR/GraphQL/WebSocket capture is not built yet

Sources: [help.usersnap.com/docs/console-recorder-feature](https://help.usersnap.com/docs/console-recorder-feature), [help.marker.io/en/articles/6562135-network-requests](https://help.marker.io/en/articles/6562135-network-requests), [marker.io/blog/usersnap-vs-userback-vs-markerio](https://marker.io/blog/usersnap-vs-userback-vs-markerio).

What to Check Before You Pick a Tool

  • Is the feature on by default, or do you have to enable it? Usersnap's network capture requires a manual settings change per project, a step teams frequently skip and then assume doesn't exist.
  • Do you rely on GraphQL? Test how repeated queries are handled before committing. Marker.io's behavior here is documented; Usersnap's isn't, so you'd need to test it yourself.
  • Do you have a WebSocket-dependent feature? Marker.io's network log will not show it, full stop. You'll still need browser DevTools or server-side logging to debug that class of bug.
  • Can you scope console log levels? Keeping only error enabled in production reduces the risk of leaking sensitive data through logged objects.

What Pintelly Actually Captures Today (And What It Doesn't)

Our Feedback Widget automatically attaches console logs to every bug report. Log levels (log, error, warn, info, debug) are configured per project from the dashboard, and, same advice as above, keeping only error enabled in production is the safer default. Every report also carries the CSS selector of the DOM element the reporter selected, a full-viewport screenshot, and the analytics session ID for that visitor, so a report can be cross-referenced with that user's session.

To be direct about it: as of this writing, we don't have a separate network request (XHR/Fetch/GraphQL/WebSocket) capture feature. If automatically capturing network traffic across your SPA is your primary requirement, we currently sit behind Marker.io's default-on capture (with the GraphQL and WebSocket limits documented above) and behind Usersnap's Console Recorder once it's manually enabled.

If what you actually need is console logs, a screenshot, and DOM context bundled into one report without extra configuration, that's what we do out of the box today. Network capture is a known gap on our side too, and it's something our product team is evaluating.

You can try Pintelly free to see how we attach console logs, screenshots, and DOM context to every report by default.

Closing

Both Usersnap and Marker.io look "complete" on their marketing pages, but each has specific, documented limits: Usersnap's network capture is opt-in, and Marker.io groups repeated requests and doesn't support WebSocket. Match these limits against your own architecture, do you lean on GraphQL, do you depend on a live socket connection, before deciding.

If your priority is getting console logs, a screenshot, and DOM context into every bug report with no extra setup, try Pintelly free, it's what we built for exactly that.

Note: a dedicated "Marker.io alternative" comparison piece isn't published yet, so no link to it is included here.

FAQ

Does Usersnap ever capture network requests?+

Yes. Its Console Recorder logs both XHR and Fetch requests, but the feature is off by default and must be turned on manually in project settings, that's usually why teams assume it doesn't exist.

Why do some of my GraphQL calls not show up in Marker.io?+

Marker.io groups identical, repeated requests to reduce noise, and GraphQL queries are the most common case affected. Using unique parameters or distinct operation names per call helps them appear separately in the log.

Does Marker.io capture WebSocket traffic?+

No. Marker.io's own documentation lists WebSocket connections under features that are "not yet supported," along with SSE, WebRTC data channels, Service Worker requests, and the Beacon API.

Does Pintelly capture network requests?+

Not currently. Our Feedback Widget automatically captures console logs, a screenshot, and the selected DOM element with every report; we don't have a dedicated network/XHR/GraphQL/WebSocket capture feature as of this writing.

Which tool should I pick?+

It depends on your priority. If automatic, default-on network capture matters most, Marker.io fits better, as long as you account for its GraphQL grouping and WebSocket gap. If you're fine manually enabling network capture, Usersnap is an option. If console logs, screenshot, and DOM context in one report with zero setup is what you need, that's what we cover today.

Recommended