What Is BugCapturer? A Free Visual Feedback Tool for the Web

Why BugCapturer

How painful traditional bug feedback is

You spot a problem on a website and want to report it. The traditional flow looks like this:
  • Press Print Screen
  • Open Paint and paste
  • Circle the problem area with a brush (ugly and imprecise)
  • Open your email client
  • Type the URL by hand
  • Look up and type your browser version by hand
  • Try to open DevTools and copy the error (if you know how)
  • Write a description
  • Attach the screenshot
  • Send it to someone, then wait for them to move it into a tracker
  • Total time: 5-15 minutes. And key details are usually missing, so developers have to come back with follow-up questions.

    How BugCapturer does it

  • Click the extension icon
  • Drag to select the problem area
  • Add arrows or text annotations
  • Write one sentence
  • Click Share to get a link, or send the report straight into your team's table
  • Total time: 30 seconds. URL, browser info, console errors, failed requests — all captured automatically and delivered with the report.

    Core features

    Region screenshot

    Click the extension icon, then drag anywhere on the page to select an area. No full-screen capture and no cropping afterwards — you pick exactly the region you want to report.
    • 8 resize handles for precise selection
    • Everything outside the selection is dimmed automatically
    • Right-click menu shortcut ("Screenshot feedback")

    5 annotation tools

    After capturing, the annotation editor gives you five tools:
    Tool Use Example
    Arrow Point at the problematic element A red arrow at overlapping buttons
    Rectangle Frame the problem area A box around a broken layout block
    Text Add a written note "Text is cut off here"
    Brush Draw freely Circle, underline, tick
    Mosaic Blur sensitive information Mask usernames, emails, API keys
    When you finish annotating, the screenshot is saved with the report. You can turn it into a public share link for anyone, or submit it straight into the table or webhook your team has connected.

    Automatic technical metadata

    When a report is submitted, BugCapturer captures the following automatically — nothing to type:
    Data Why it matters
    Page URL Pinpoint the exact page
    Browser name and version Diagnose browser compatibility issues
    Operating system Diagnose OS-specific problems
    Screen resolution Diagnose layout issues at different resolutions
    Viewport size Judge responsive layout problems
    Device pixel ratio (DPR) Diagnose Retina/HiDPI rendering issues
    Timestamp Record when the problem happened
    Filling this in by hand takes at least 2-3 minutes and is error-prone. BugCapturer does it in one click.

    Automatic console error capture

    When a webpage breaks, the browser console almost always has something to say. But most people don't know how to open it, let alone copy the error. BugCapturer captures console errors for you:
    • Only error level (info/warn noise is filtered out)
    • Includes the error message plus source location (file:line:column)
    • Up to the last 10 entries
    • Captured when the report is submitted, with no background listening
    • You can uncheck it — full control stays with you
    That means even the least technical user can submit a bug report with professional diagnostics attached.

    Automatic failed-request capture

    Many webpage problems aren't rendering bugs at all — an API call failed and the data never arrived. BugCapturer captures failed network requests:
    • Only requests with status ≥ 400 (real failures)
    • Includes URL, HTTP method, status code and status text
    • Up to the last 5 entries
    • Sensitive URL parameters are redacted automatically (token, key, secret, password and similar become *)
    • Captured when the report is submitted, with no background listening

    One-click share, or straight into your team's workflow

    Once the description is in, a report can go one of two ways — your choice:
    • Generate a share link: one click gives you a public link. The recipient doesn't install anything and doesn't need an account — they open it in a browser and see the annotated screenshot, page URL and full diagnostics. Drop it in a chat, an email or a ticket.
    • Route it to a destination: with the destination dropdown, send the report straight into Lark Bitable or your own webhook. Screenshots, console errors and failed requests arrive with it, so it becomes a row in your team's table — or it kicks off any flow in your own systems.
    Neither path needs you to tidy anything up by hand, and neither needs a middleman to move the report into the system.

    Team collaboration: configure once, everyone shares it

    • Teams and members: the owner configures an integration once and the whole team can use it. Invites require an explicit accept step.
    • Credentials stay private: team members can submit through a shared integration but never see the credentials themselves.
    • Projects and domains: one project per site, with a whitelist of domains allowed to submit — which keeps your SDK keys from being abused.
    • Share links stay manageable: signed-in users can manage or delete any report link they've shared from the "My shares" page.
    Feedback stops living in somebody's inbox and lands somewhere the whole team can reach — anyone can find it, anyone can pick it up.

    Integrations: reports flow into the tools you already use

    Integration Best for Notes
    Lark Bitable Teams in China No Lark app needed — write into your table through an automation webhook and use Lark's native automations for group notifications
    Generic webhook Teams with their own systems Signed, versioned JSON payloads that plug into n8n / Zapier / Make / your own services, with automatic retries, a delivery log and manual replay

    7 languages

    BugCapturer supports 7 interface languages:
    • 中文(简体)
    • English
    • Deutsch
    • Français
    • Español
    • Português (Brasil)
    • 日本語
    The extension follows your browser language automatically, and you can switch manually.

    Data security and privacy

    BugCapturer is a cloud collaboration platform, and it turns "what gets processed, how long it's kept and who can see it" into explicit rules:
    Practice How it works
    Encrypted in transit and at rest Reports travel over HTTPS and are stored encrypted on the server
    Automatic URL redaction token, key, secret, password and similar parameters in request URLs become *
    Link retention Anonymous share links last 30 days, signed-in links 90 days, then they're cleaned up automatically — and you can delete them by hand any time
    Unguessable links Share links use random IDs, so nobody can enumerate other people's reports
    Permission isolation Team integrations are configured by the owner; members use them without ever seeing the credentials, and projects are visible only inside the team
    Captured on submit Console errors and network requests are captured when a report is submitted, not continuously in the background
    User control Technical diagnostics are on by default but can be unchecked in one step
    A report isn't something you lose control of the moment you send it: you can see where each one went and when it was delivered, failed deliveries retry automatically and leave a log. For teams with data governance and audit requirements, those are things you can write into a process.

    Who BugCapturer is for

    QA / test engineers

    The core audience. Reporting a lot of bugs every day, BugCapturer cuts each report from 5-15 minutes to 30-60 seconds while attaching the technical diagnostics that prevent "can't reproduce" back-and-forth.

    Front-end developers

    When debugging cross-browser issues you need to record how a page behaves in each browser. BugCapturer captures browser version, resolution and viewport automatically, so there's nothing to write down.

    Product managers

    When feedback is vague, you need to see it. Embed the Web SDK on your site and visitors can point at the problem directly, with the technical context attached so there's nothing to chase.

    UI/UX designers

    For visual review you need to mark the difference between the design and the live page. BugCapturer's five annotation tools are precise enough for visual issues, and the share link can go straight to a client for sign-off.

    Team leads / project managers

    The UAT and acceptance stage suffers most when feedback is scattered across everyone's own devices. BugCapturer routes it into one place — your Lark table or your existing system — so progress, owners and status are all visible in one spot. This is exactly where organisational efficiency tends to stall.

    Everyday web users

    Anyone who spots a website problem and wants to report it. No technical background, no DevTools, and 30 seconds to submit a professional report.

    BugCapturer vs other approaches

    Dimension Manual screenshot + email Phone photo in a chat Dedicated feedback platform BugCapturer
    Time 5-15 minutes 2 minutes 3-5 minutes 30 seconds
    Annotation None / weak None Strong 5 tools
    Technical info Typed by hand None Captured automatically Captured automatically
    Console errors Requires DevTools None Partial Captured automatically
    Network errors Requires DevTools None Partial Captured automatically
    Where reports land Personal inbox Group chat Inside the platform Lark table / webhook / share link
    Team collaboration Weak Weak Strong Shared integrations + public links
    Price Free Free Paid Free to start

    Install and use

    Install

  • Visit the Chrome Web Store
  • Click "Add to Chrome"
  • Confirm
  • Install time: about 5 seconds.

    Use

  • Browse and spot a problem
  • Click the BugCapturer icon in the toolbar (or right-click → "Screenshot feedback")
  • Drag to select the problem area
  • Annotate with arrows, text and the rest
  • Pick a feedback type (Bug / Suggestion / Question)
  • Write a description (one sentence is enough)
  • Leave "Include technical diagnostics" checked (it is by default)
  • Choose where it goes: generate a public share link, or send it to your team's Lark table / webhook
  • Click Submit
  • Done. A complete report — screenshot, annotations, technical metadata, console errors, network errors — is now in place: possibly as a link, possibly as a row in your team's table.

    FAQ

    Is BugCapturer free?

    It's free to start. The free plan includes 1 seat, 3 projects and 1 integration, and covers the core features: screenshot annotation, recording, automatic diagnostics and share links. Upgrade only as your team grows. No trial countdown.

    Is my data safe?

    Reports travel over HTTPS and are stored encrypted; sensitive URL parameters are redacted to *; share links have a retention period (30 days anonymous, 90 days signed-in) and can be deleted any time; team integration credentials are visible only to the owner. See the privacy policy for the full picture.

    Do I need an account?

    Submitting reports, managing share links and configuring integrations need a free account — signing up takes a couple of minutes. Recipients, on the other hand, open your share links with no account and nothing installed.

    Do you support Firefox / Safari?

    Chrome and Edge (Chromium-based browsers) for now. Firefox and Safari are planned.

    Are screenshots uploaded to the cloud?

    When you generate a share link or submit into a table/webhook, the report (screenshot included) is uploaded and stored so the recipient can open it and the team can find it. Anything you haven't shared isn't uploaded automatically.

    Does BugCapturer listen to the console all the time?

    No. Console errors and failed requests are captured at submit time for the current page; there's no continuous background listening. You can also switch the whole thing off by unchecking "Include technical diagnostics".

    Can reports land in our Lark table or an internal system?

    Yes. Lark Bitable connects through an automation webhook with no Lark app required; other systems receive a signed JSON payload via a generic webhook, with automatic retries, a delivery log and manual replay.

    Which languages are supported?

    Chinese (Simplified), English, German, French, Spanish, Portuguese (Brazil) and Japanese — 7 in total. The interface follows your browser language automatically.

    Ready to get started?

    BugCapturer is free to start, in 7 languages. From spotting a problem to reaching your team, it takes 30 seconds. Add BugCapturer to Chrome — free