Session Replay That Shows You What Your Users See
Real-time session replay and diagnostics — built for engineering teams who need to close the gap between bug reports and reality.
No credit card required.
How it works
Debug in three steps
Install the snippet
Add a single <1 kB JavaScript file onto your site, one script tag, no build step, no dependencies. Clairvio stays dormant until a diagnostic session is triggered via a magic link, so there's zero impact on your normal users.
Trigger a session — your way
Generate a magic link from your dashboard and paste it into a support chat or email, or let users start a session themselves via the embedded support widget. Either way, the session starts instantly — no account, no plugins, no install required on their end.
Watch live or review the full replay
Join the session as it happens and follow along in real time, or scrub through the completed recording with console, network, and navigation data all timestamped alongside the replay.
Demo
See it in action
Under the hood
How Clairvio captures sessions
A look at the technical architecture that makes on-demand session replay possible without sacrificing performance or privacy.
The loader and the capture library
The Clairvio integration is split into two distinct JavaScript artifacts. The first is a
small loader — under 1 kB minified and gzipped — that you add to every page via a
single <script> tag. The loader does almost nothing
on a normal page load: it registers one listener and exits. Because it contains no replay
logic, no tracking code, and no third-party dependencies, it has zero measurable impact on
Lighthouse scores or Core Web Vitals for your ordinary visitors.
The second artifact is the full capture library. It is never fetched unless a valid magic link token is present in the URL query string. When a customer opens a diagnostic link, the loader detects the token, dynamically inserts the capture script, and initialises a WebSocket connection back to the Clairvio ingestion endpoint. This lazy-load architecture means your regular users are never exposed to the capture overhead.
DOM serialisation
Once active, Clairvio records the session. It works by taking a full snapshot of the DOM
at session start — serialising every element, attribute, text node, and computed style
into a compact JSON representation — and then continuously listening to a MutationObserver for incremental changes. Rather than storing pixel frames like a screen recording, it stores
a stream of structural diffs. A typical session produces under 1 MB of replay data, compared
to hundreds of megabytes for an equivalent video file.
Pointer position, scroll depth, viewport resizes, and form inputs are recorded as discrete timestamped events on the same clock as the DOM mutations. During playback, Clairvio re-hydrates the serialised DOM inside an isolated iframe and re-applies the event stream frame by frame, producing a pixel-perfect reconstruction of exactly what the customer saw.
Four parallel capture streams
In addition to the DOM replay, Clairvio captures three supplementary streams
simultaneously: console output (every console.log, console.warn, and console.error call with its arguments and stack trace), network activity (every XMLHttpRequest and fetch call with request method, URL, status code,
timing, and configurable payload capture), and navigation events (every pushState, replaceState, and popstate transition). All four streams share the same millisecond-resolution
clock so you can scrub to any point in the replay and immediately see which network request
was in-flight, which error had just been thrown, and which route the user was on.
Privacy and sensitive data
Clairvio supports element-level masking via CSS selectors or data attributes. Any input[type=password] is masked by default. Masked elements
are replaced with a solid block in the replay — the actual value never leaves the browser.
You can mask any other element by simply adding a data attribute to the html tag.
Use cases
Built for every technical team
Clairvio fits naturally into support, QA, and engineering workflows without requiring a platform change.
Customer Support
A customer files a ticket describing a checkout issue. Paste a Clairvio magic link into your support reply — or let them trigger it themselves via the embedded widget. Either way, you get a full replay of exactly what happens: the clicks, the network requests that returned 500, the console error that fired silently. Watch live as the session records, then hand the replay URL to engineering.
- Send a magic link or embed a self-service widget in your app
- Get an email when recording starts so you can join the live session
- Share the completed replay URL with engineering for instant handoff
QA & Testing
Intermittent bugs are the hardest to reproduce in a test environment. Clairvio lets QA engineers send magic links to internal testers or beta users for specific test scenarios. The resulting replay captures every interaction, network call, and JavaScript error with millisecond precision — giving you a deterministic record of what actually happened without relying on the tester to remember or describe the exact reproduction steps.
- Generate links scoped to specific workspaces or test environments
- Attach session replays directly to bug reports in your issue tracker
- Verify fixes by comparing replays before and after a deployment
Engineering Debugging
Production bugs rarely reproduce locally. The state is different, the data is different, the race condition only surfaces under real load. With Clairvio, engineers can request a session from the exact user who hit the problem and get a full diagnostic trace: the DOM state at every frame, every API call with request and response payloads, every unhandled promise rejection and caught exception logged to the console, and the full navigation path that led to the failure. No log scraping, no asking users for screenshots, no guessing.
- Correlate frontend errors with specific API responses on the same timeline
- Inspect the DOM state at the exact moment an exception was thrown
- Replay sessions across team members without sharing credentials
Comparison
Clairvio vs. traditional session replay
Always-on session replay tools were designed for product analytics. Clairvio was designed for debugging.
| Clairvio | LogRocket / FullStory | |
|---|---|---|
| Recording model | On-demand Magic link or self-service widget | Always-on Every user, every session |
| Impact on real users | None Loader is dormant for all other users | Measurable 100–300 kB SDK on every page load |
| SDK payload | <1 kB loader Capture lib loaded lazily on demand | 100–300 kB Bundled on every page load |
| GDPR / consent | Simple Explicit consent for support session | Complex Passive consent required for all users |
| Data volume | Only what you need One session per ticket | Enormous Every visitor, most never reviewed |
| Primary use case | Debugging & support Reproduce a specific reported issue | Product analytics UX research and funnel analysis |
| Pricing model | Starts free $0 – $99 / month | Enterprise Typically $200+ / month |
Features
Everything you need to reproduce bugs
Stop asking customers to describe what happened.
Let them show you.
Live & Recorded Replay
Watch a session update in real time while the user is still active, or scrub through the full recording once it completes — same pixel-perfect DOM replay either way.
Console Capture
Every console.error, console.warn, and console.log is intercepted and timestamped alongside the replay.
Network Inspector
All XHR and fetch requests — URLs, status codes, request bodies, response payloads, and timing — in one timeline.
Magic Link & Support Widget
Send a one-click diagnostic link to any customer, or embed a self-service widget so users can initiate a recording themselves. Either path captures the same full session with no install required.
Zero-friction Setup
One script tag under 1 kB. No build step, no npm install, no configuration. Stays dormant until a session is triggered — invisible to normal users. Set window.__clairvio_debug = true for SDK console logging during development.
Navigation Timeline
Every page transition — pushState, replaceState, and popstate — is captured and timestamped. Follow a multi-step flow exactly as the customer experienced it, across as many pages as it takes.
Pricing
Simple, predictable pricing
Start for free. Upgrade when you need more sessions or longer retention.
Free
- 25 sessions / month
- 7-day session retention
- Session replay
- Console capture
- Network inspector
- 1 workspace
Starter
- 200 sessions / month
- 30-day session retention
- Session replay
- Console capture
- Network inspector
- 3 workspaces
Growth
- 1,000 sessions / month
- 90-day session retention
- Session replay
- Console capture
- Network inspector
- Unlimited workspaces
Scale
- 5,000 sessions / month
- 1-year session retention
- Session replay
- Console capture
- Network inspector
- Unlimited workspaces
FAQ
Common questions
- 01
What is session replay?
Session replay is a tool that records every click, scroll, form input, and page transition a user makes on a website, then plays it back as a video-like recording. Engineering and support teams use session replays to reproduce bugs exactly as a real user experienced them, without asking the customer to describe what happened.
- 02
How does session replay work?
Session replay works by injecting a lightweight JavaScript snippet into your website that records DOM mutations using the browser's MutationObserver API. Mouse movements, clicks, scrolls, and form interactions are streamed alongside these snapshots to a server, where they are reassembled into a pixel-perfect, scrubbable playback.
- 03
How is Clairvio different from LogRocket or FullStory?
Clairvio is built for engineering support workflows, not passive product analytics. Unlike LogRocket or FullStory, Clairvio only records a session when a specific diagnostic link is sent to a customer — your normal users are never recorded. There is no persistent SDK overhead, no background data collection, and no GDPR complexity on sessions you didn't ask for.
- 04
Does Clairvio slow down my website?
No. The Clairvio SDK loader is under 1 kB and does nothing until a diagnostic session is explicitly triggered via a magic link. It adds zero overhead to normal page loads for real users — no background tracking, no network requests, and no performance budget consumed during ordinary site visits.
Get started today
See what your customers see.
Create your free account and send your first diagnostic
session in minutes.
No credit card required.