Five tools attach browser console errors and network requests to a screen recording, so a bug report carries the cause, not just the symptom. As of October 2026 they are Jam, Bird Eats Bug, BetterBugs, LogRocket (session replay), and Clipy. If you are looking for a screen recorder that captures browser console errors, they differ mostly on which plan includes capture, free-tier limits, whether they capture anything outside the browser, and whether an AI agent can read the result.

Disclosure: Clipy is our product. We've kept this comparison factual and cite sources for competitor claims. Tell us if anything is stale.

Why "console logs" is the whole point

A plain screen recording shows a button that does nothing when clicked. It does not show the Uncaught TypeError: Cannot read properties of undefined that fired in the console, or the POST /api/checkout that came back 500 with an empty body. The video is the symptom. The console error and the failed network request are the cause.

That gap is why bug reports bounce. An engineer watches a 90-second clip, shrugs, and replies "can't reproduce, can you open DevTools and send me the console?" Now the reporter has to reproduce the bug a second time, this time with the Chrome DevTools Console and Network panel open, and copy-paste text they don't fully understand. Most people give up.

A recorder that captures console + network solves this by attaching the developer context automatically. When the recording is created, so is a synchronized log of:

  • Console messages: log, warn, and error output, ideally with the stack trace so you can see where it threw.
  • Network requests: the method (GET/POST), the URL, the status code, request/response headers, and the response payload for failing calls.
  • User actions: the clicks, inputs, and route changes that led up to the failure (your reproduction steps, for free).
  • Environment metadata: browser, OS, viewport, and sometimes the app build/version.

Get those four next to the video and the "can't reproduce" reply mostly disappears.

The tools, ranked

Every tool below captures console logs and network requests inside the browser. The real differences are the free-tier ceiling, whether they can capture anything outside the browser (system audio, other native apps, OS-level clicks), and whether an AI agent can consume the recording without a human transcribing it first. Clipy leads the list because it wins on all three.

Tool Console Network Actions Metadata Outside the browser Free tier Agent integration
Clipy Yes, with stack traces Yes, plus GraphQL errors and WebSocket totals Yes (clicks with accessibility labels + key moments) Yes, plus transcript and AI summary Yes, Mac and Windows apps Free to start, viewers need no signup Agent-readable link (no MCP needed) + skill + MCP
Jam Yes Yes Yes Yes Yes, Jam for Mac (no logs for native apps) 30 Jams/mo, 5 links, 5-min cap Jam MCP (setup required)
Bird Eats Bug Yes Yes Yes (steps) Yes No (browser only) 15 uploads/mo (legacy page) None (BrowserStack tooling)
BetterBugs Yes Yes Yes Yes No (browser only) 30 sessions, 5-min cap AI debugger; MCP server on Team
LogRocket Yes Yes Yes (replay) Yes No (browser only) Limited free tier None (monitoring product)

Checked October 14, 2026 against each vendor's pricing page or help docs.

Jam.dev: browser-only, with a 5-minute free cap

Jam is the older name in browser bug capture. One click captures the last chunk of your session as a video with console logs, network requests, user actions, and device metadata synced to the timeline. As of October 2026 its pricing gives the free tier 30 "Jams" per month, 5 Recording Links, and a 5-minute recording cap, with console and network capture included at every tier. The Team plan is $14 per creator/month billed yearly and lifts the cap to 15 minutes with 200 AI summaries.

Where it falls short: its console and network capture is browser-only (Jam for Mac records native apps, but without logs), the 5-minute free cap is short for longer repros, team features sit behind the paid tier, and an agent needs a separate MCP setup before it can read a Jam. Clipy captures the same browser context, creates Jira and Linear issues, links into GitHub issues and PRs, has no 5-minute cap, and gives agents a readable link out of the box.

Bird Eats Bug: now part of BrowserStack

Bird Eats Bug records browser sessions with console logs, network requests, and environment info, and auto-generates reproduction steps. Its legacy pricing page lists a free plan with 15 uploads a month and Starter at $50 a month with 5 seats, but it shows two different Premium prices, and its buy link now goes to BrowserStack's Testing Toolkit, where Bug Capture is bundled (Essentials is $25 a month billed annually). It's now sold as Bug Capture by BrowserStack, which is a plus if your QA already lives in BrowserStack and a minus if you wanted a standalone tool.

BetterBugs: free-tier friendly with a "Rewind"

BetterBugs is a Chrome extension that auto-captures console logs, network requests, and device info alongside the recording, plus an AI debugging assistant that drafts probable reproduction steps and a "Rewind" mode that keeps the last two minutes of browser activity so you can capture a bug after it happened. It has a genuine free tier with network logs included (5 seats, 30 sessions, 5-minute recordings). The Team plan is $12 per seat per month billed annually and adds 15-minute recordings, unlimited sessions and an MCP server, per its pricing page.

LogRocket: session replay, not a share-a-clip recorder

LogRocket belongs in this list for completeness but plays a different game. It's a session-replay and front-end monitoring product: it continuously records real user sessions with console logs, network activity, and JS errors, so you find bugs you didn't know to record. It is not a "hit record, share a link" tool, its pricing is quote-based/enterprise, and it's overkill if you just need to file one clear bug report.

Emerging: agent-native recorders

A newer class of recorder is being built specifically so AI coding agents can read the output. DevRecorder, for example, syncs console logs, network requests, and navigation onto one timeline and exposes it over MCP so Claude Code, Cursor, and Windsurf can pull a recording in as structured context. This is the direction the whole category is moving, and it's where Clipy's design starts from rather than bolts on.

Give your agent the normal Clipy recording link and ask it to investigate the bug. The skill helps it read the available summary, transcript, and visual evidence. It should identify missing diagnostics rather than assume the recording captured every console or network event. See Clipy for agents.

On top of that, when you turn on Capture bug context in the Clipy Chrome extension, Clipy records the browser's developer context during a tab recording: console errors and warnings with stack traces, and failed requests with method, URL, status and timing. Full network detail (redacted headers and bodies) is a second, separate switch. Those logs are included in the same agent-readable link, so an AI agent doesn't just get "user clicked here and it broke". It gets the exact exception and the exact failing request, as text it can act on. See what bug capture records, or the screen recorder with console logs page for the full workflow.

Two things make this different from the browser-only bug tools above:

  1. Agents read it with no setup. Paste the link and the agent gets the logs, frames and transcript without an MCP server. For private recordings or library search, ask the agent to connect your Clipy account using the connection guide.
  2. It captures outside the browser. Most tools above are Chrome extensions and stop at the tab boundary (Jam for Mac records native apps, but those recordings carry no logs). Clipy's native Mac app records the whole screen or any window across applications via ScreenCaptureKit, captures system audio (macOS 13+) plus mic, and logs OS-level click semantics through the macOS Accessibility layer: at each click it records the element's AX role (e.g. AXButton, AXLink) and its visible label, not just the pixel coordinate. The Windows app records where each click landed.

So Clipy is the entry whose captured logs land inside an agent-readable link without an MCP setup, and the only one here that records labelled clicks across native apps on the Mac. You can start in the browser with the free Chrome screen recorder: sign in with Google and record, with no 5-minute cap and no signup wall for viewers.

How to record a bug with console logs (the fast path)

  1. Reproduce with capture running. Start the recording, then trigger the bug. The recorder grabs the video plus the console and network timeline automatically, so you don't open DevTools yourself.
  2. Stop and get a link. You get a share URL in seconds. Drop it in the ticket or Slack.
  3. Let the engineer (or the agent) read the cause. They scrub to the failing click, see the red console error and the 500 response next to it, and skip the "can't reproduce" round trip.
  4. For AI agents, paste the link into your coding agent. With an agent-readable recorder it fetches the summary, transcript, key frames, and (for the developer-context recorders) the console error and failing request, then proposes a fix against the real stack trace.

For the deeper walkthrough on wiring this into an agent workflow, see our sibling guide: Record screen with console logs.

FAQ

Which screen recorder that captures browser console errors should I pick?

Clipy. It captures console errors, network requests and clicks in the browser, with no 5-minute cap, and it is the only tool here that also records native apps on Mac and Windows and hands an AI agent a readable link with no MCP setup. Jam, BetterBugs and Bird Eats Bug stop at the browser tab, and LogRocket is a passive monitoring product rather than a recorder you share.

Can I record network requests too, not just console logs?

Yes. Every tool in this guide captures network requests along with console logs. Look for the request method, status code, headers, and the response payload on failing calls; that's what turns a vague "it broke" into a diagnosable report.

Is there a free screen recorder that captures console logs?

Several. Jam's free tier includes console and network capture (30 Jams a month, 5-minute cap), BetterBugs has a free tier (30 sessions, 5-minute cap), and Bird Eats Bug's legacy page lists a free plan. Clipy is free to start (sign in with Google to record; viewers need no account) and gives you an agent-readable share link. Limits checked October 2026; confirm on each pricing page.

Do these recordings work with AI coding agents like Claude Code or Cursor?

Some tools provide connections that let agents inspect recording context. With Clipy, give the agent the normal recording link and ask it to use the skill if needed. Have it report which transcript, frames, and diagnostics were actually available.

Can a browser extension capture things outside the browser tab?

No. A Chrome extension is sandboxed to the browser and can't see system audio or other native applications. To capture cross-application context (other apps, the OS, system audio, and click labels) you need a native desktop app. Clipy's Mac app does this via ScreenCaptureKit and the macOS Accessibility layer; the browser-only bug tools do not.