One click records the screen, the console, the network calls and the exact environment — then AI writes the summary, the likely root cause and the steps to reproduce. The ticket lands in Jira before you've finished describing it.
Free forever plan · No credit card · Works on any site, including localhost
AI analysis
Root cause — POST /api/cart/coupon returned 500 after the discount pushed the total below zero. The client reads res.data.total.toFixed() without a null guard, so the cart component throws and unmounts the checkout tree.
✕ TypeError: Cannot read properties of null (reading 'toFixed') at CartTotal (Cart.tsx:118:24)⚠ POST /api/cart/coupon → 500 (412 ms) { code: "NEGATIVE_TOTAL", cartId: "c_9f3a1" }A screenshot in Slack starts a negotiation, not a fix. The developer asks which browser. QA asks which build. Somebody asks for the console. By the time the context exists, the tab is closed and the state is gone.
Without BugCatch
With BugCatch
The reporter clicks once. BugCatch does the interrogation.
BugCatch keeps a rolling buffer of the last two minutes of screen activity in an isolated offscreen document, capped to bound memory. Something breaks, you hit Rewind, and the recording of what led up to it is already there. No "can you do it again?"
Grab the full page or a region, then arrow, box, blur and caption it in place. Sensitive fields blur before the capture ever leaves the browser.
Record a tab, a window or the whole desktop with mic and narration. WebM is transcoded to MP4 on the queue so it plays anywhere your team pastes it.
Errors, warnings, stack traces, failed requests with status codes, timings and payloads — attached to the report automatically, not pasted in by hand.
Browser and version, OS, viewport and device pixel ratio, URL, release build, locale, timezone and the signed-in user — every field a triage engineer checks first.
A ~4 kB browser SDK puts a Report a bug button inside your own product, so customers and non-technical staff file the same complete report — screenshot, console, network and environment — without installing anything. Two lines to initialise, and the widget inherits your theme.
Published on npm as @sphoro/bugcatch-web-sdk — MIT licensed, zero dependencies, ESM or a single script tag.
View on npmimport BugCatch from '@sphoro/bugcatch-web-sdk'
BugCatch.init({
apiKey: 'bc_live_…',
projectId: 'prj_8f21c',
captureConsole: true,
captureNetwork: true,
})Every report is analysed the moment it lands. BugCatch writes a one-line summary, proposes a root cause from the stack trace and failed requests, drafts numbered reproduction steps, and suggests a severity — then sorts the queue by it.
Every switch here is off until you turn it on, and the row that stores them does not exist until you do. Nothing on this list overrules a person, hides a report, or writes to a bug by a route that skips your reporter’s timeline.
The severity the analysis concluded is applied over “nobody has an opinion yet” and never over one a member or the reporter chose. The record knows which of those it is holding, so automation can tell the difference.
Ordered rules matching on severity, tag or URL, each handing the report to somebody — or round-robin across the project. The first rule that matches wins, and the timeline says which one did.
Above a confidence floor you set, a repeat report is linked to the one that already says it — linked, not merged and not closed. Both keep their own thread, and the second reporter still hears about the fix.
Per priority, per project, measured against when your team actually first answered. A missed target escalates the report to a second owner and is recorded once — because a sweep that re-alerts every five minutes is how an alert becomes a filter rule.
Nudge the reporter after so many days, settle it after so many more. Nothing else in the system can notice that time has passed — every other job waits for something to arrive, and a report simply sitting there arrives nowhere.
Close the Jira, GitHub or Linear issue where you already are, and the bug settles here: resolution time stamped, the knowledge base told, the reporter’s thread updated. Signed webhooks, on a secret you can rotate.
Most bug tools end at the ticket. BugCatch keeps the reporter in the conversation — one live thread they can answer in, carrying everything your team chooses to share and nothing it doesn’t.
Raised to Critical4 minutes after you reported it
Someone owns this nowYou’ll hear back in this thread
Reproduced it — the coupon takes the total below zero and the cart throws. The fix is in review and ships today.
It does it on the annual plan too. Recorded what I did:
0:14Same root cause as BC-3902. Check the other coupon paths before we call this one fixed.
A settled bug is worth more than its fix. BugCatch distils each one into a note and hands it back the next time something similar arrives — to your engineers, and, when you allow it, to the person doing the reporting.
When a bug is settled, what actually fixed it is distilled into a short note filed under that project — the thing nobody can find a year later when the same class of failure comes back.
A new report is matched against the open bugs on the same project the moment it lands, so the third person to hit one crash joins a thread instead of opening a third ticket nobody links up.
What your team writes back to a reporter is a second corpus, kept apart from the first. A resolution note names the file that was at fault; an answer names none of it, because it is written for the customer.
Switch it on and a report that closely matches a question you have already answered gets that answer straight away, in the reporter’s own thread. It stays off until you turn it on. It waits behind a confidence floor you set. And every automatic answer is counted on Analytics beside how many of them a person still had to follow — because a deflection rate nobody measures is just a queue you stopped reading.
Auto-answerlast 30 days
Off by default. Team and Enterprise, with your own model key.
Hit the extension or the in-app button. Screenshot, recording or Rewind — plus console, network and environment, collected in the same moment.
Media goes straight to object storage over a presigned URL, so a 60 MB recording never queues behind the API. The report is created the instant the upload lands.
Background workers run AI analysis, redact secrets, transcode the video and push the issue to your tracker. Seconds, not a build step.
It appears in the queue ranked by severity, with the video, the logs and the repro on one screen. Assign, comment, resolve, or share a read-only link.
One internal bug shape maps to every tracker through small per-provider adapters — so the same capture becomes a Jira issue, a GitHub issue and a Slack message with the fields each one expects.
Per project or across the whole workspace, with one filter row that scopes every figure beneath it — and a written read of the slice you are looking at, from your workspace’s own model.
Every team already has a way of reporting bugs. This is what each one actually hands to the engineer who has to fix it.
| What the developer gets | Screenshot in a thread | A screen recorder | BugCatch |
|---|---|---|---|
| The moment it broke | A still, usually cropped | Video, if recording was already running | Video, plus the two minutes before it |
| Console errors and stack traces | Ask, and hope the tab is still open | Not captured | Attached, with the failing line |
| Failed network calls | Not captured | Not captured | Status, timing and payload |
| Browser, OS, viewport, build | A follow-up question | Sometimes visible in frame | Recorded as fields you can filter |
| Who writes the repro steps | The reporter, from memory | Nobody | Drafted from the session, edited by you |
| Where the ticket ends up | Somebody re-types it | Somebody re-types it | Jira, GitHub, Linear or Slack on arrival |
| What the reporter hears back | Silence, then a chase | Silence, then a chase | A live thread they can answer in |
| Secrets caught in the logs | Whatever was on the screen | Whatever was on the screen | Scrubbed in the browser and again at the API |
File from staging, localhost or a build behind a login, with the environment already attached. Rewind catches the flaky one you were not recording.
Turn “it’s not working” into a reproducible report without a call — then answer the customer in the same thread, from the same screen.
A private project per client, grouped in the sidebar, with a read-only link you can share into a review call. Clients report through your app, not your inbox.
One queue across every project, ranked by severity, with time-to-resolve measured rather than guessed and an owner on every report.
A recording of a checkout flow contains a real cart, a real session and sometimes a real card field. Encryption and redaction are the default, not an enterprise upsell.
On Team and Enterprise, every content column is sealed with AES-256-GCM under a per-workspace data key, itself wrapped by a master key. Ciphertext is self-describing, so a plan change or a half-finished backfill stays readable.
Bearer tokens, API keys, cookies and presigned URLs are removed in the browser, again at the API, and once more when an older report is read back — so a public share link cannot leak a key captured before the rule existed. Card numbers and your own patterns layer on top.
Every tenant resource is checked against membership. Projects are public to the workspace or restricted to an explicit member list, enforced inside the guard so no endpoint can ship without the check.
A session is private by default and inherits its project's setting. Share one publicly and the API serves a purpose-built payload at a token URL — never the internal record.
Owner, admin, member and viewer, applied per workspace with an audit trail on every triage action — and a report can only be edited by the people who actually own it. SSO/SAML and SCIM provisioning on Enterprise.
A sweep prunes past the window on every plan — 7 days on Free, 90 on Team, 365 on Enterprise — taking the knowledge-base passages first, then the stored media, then the row. It is not sold as a feature and not gated behind one: it is the promise the plan already made. Custom windows, data residency and self-hosted deployment on Enterprise.
Every limit on this page is enforced by the API, not just printed here.
For solo devs and trying things out.
$0/member/mo
One project, and nothing to add on
Start freeFor product teams shipping every week.
$19/member/mo
+ $9 per additional project /mo
+ $5 per member /mo for the mobile app
Get Team accessFor orgs with compliance and scale needs.
Custom
Seats and projects inside the contract
Talk to salesYearly prices are what you pay each month when billed annually — for members and for projects alike. There is no card form yet: Team is switched on by us, or with a single-use code you redeem in the dashboard, and it converts your existing data in place.
Your team installs the Chrome extension, which works on any site including localhost and staging behind auth. For customers and non-technical staff, drop the ~4 kB SDK into your app and they file the same complete report from a button in your own UI — nothing to install.
Once you enable it, BugCatch continuously records into a rolling in-memory buffer holding the last ~2 minutes, discarding everything older. Nothing is uploaded until you press Rewind. If you never press it, nothing ever leaves the machine.
Two layers. In the browser you can mark elements to blur, and password fields are masked by default. Server-side, redaction rules strip tokens, cookies, auth headers and card patterns from logs and payloads before the record is written — and redaction runs before encryption, so the sealed row never contains the secret.
No — not unless somebody decides they should. Comments are internal by default and shared one at a time, and the dashboard’s toggle states the consequence rather than the setting: “Only your team will see this” or “Dana will see this”. The reporter’s side of the thread is built from a separate, reviewed object — it carries severity, the fact that the report has an owner, and shared replies. It never carries who the assignee is.
Every switch is off until you turn it on, and the settings row does not exist until you do — so “has this team configured automation” stays a question with an answer rather than a set of defaults somebody inherited. Once on, it still will not overrule a person: a severity is applied over “nobody has an opinion yet” and never over one a member or the reporter chose, and a duplicate is linked rather than merged or closed, so both reports keep their own thread. Every automatic change is written through the same path a person’s change takes, which means it is attributed as automation, lands on the reporter’s timeline, and replays there like anything else. The one thing that runs whatever you configure is the retention sweep, on every plan including Free — deleting your data on the schedule we sold you is a promise being kept, not a feature.
Yes. Plenty of teams treat BugCatch as the capture and evidence layer only: the issue is created in Jira, GitHub or Linear on ingest, and the BugCatch link carries the video, logs and environment. Status changes sync back so the queue doesn't drift.
Yes. A bug has an assignee, and it can be escalated to a second owner who carries exactly the same authority — not a watcher. An escalation where the person it was escalated to has to ask the first owner to make every change is the situation escalating is meant to end. Everyone else sees the report; only its owners and workspace admins can edit it, and an unassigned bug offers to be claimed by whoever opens it.
You choose, and you bring the key: Claude (Anthropic) or ChatGPT (OpenAI), set under Settings → Integrations → AI Provider on Team and Enterprise. The plan unlocks the feature; the tokens are billed to your own account at cost rather than marked up into the subscription. The model sees the redacted report — stack traces, failed requests and environment. Without a key, reports are still captured in full and simply aren't analysed.
Because a project is what actually costs us to run: its own retention window, its own duplicate index, its own knowledge base. The first project is covered by the member price and each one after it is $9 a month ($7.50 billed yearly), so a team shipping one product isn't paying an average that includes workspaces running twenty. Free is a single project; on Enterprise, projects sit inside the contract and aren't metered.
Talk to us and we switch the workspace over, or we mint you a single-use code you redeem in the dashboard yourself — same tier either way, the code just lets you pick the moment. Nobody sets their own plan from the browser: Team turns on encryption at rest, and a security posture that changes on an unattended click is one nobody agreed to. Redemption applies immediately and converts your existing data in place.
You keep everything you already have. Limits apply when you create something new, so a workspace over its new plan's cap is simply blocked from adding more rather than losing data. Encryption converts in place and is re-runnable in either direction.
On Enterprise, yes — in your own cloud or a dedicated private instance, with your object storage and your key management. The stack is Postgres, Redis and a Node API, deployable with Docker Compose or your own orchestration.
Yes. The extension captures whatever the tab is showing, so a local dev server, a preview deployment and a staging environment behind SSO all work the same as production — nothing has to be publicly reachable for a report to carry its video, console and network log. The SDK works the same way inside your own app.
BugCatch is built by Sphoro. We spent years on the receiving end of three-line bug reports — reproducing from guesswork, asking for the console log a week after it scrolled away — and decided the report should arrive carrying its own evidence.
Company updates go out on Sphoro on LinkedIn.
The same queue, the same reports, the same calls with whoever filed them — as an app, so the session survives being left alone and the bug you were reading is still there tomorrow.
Android today — it installs straight from your browser. iOS when there is a build to sign.
Install the extension, capture one bug, and see what a complete report looks like. Free forever for solo work — no card, no sales call.
Works in Chrome and Edge · Firefox and Safari support in beta