Introduction
While you might be paying for Hotjar (now part of Contentsquare) or FullStory beyond their free plans, Microsoft Clarity sits quietly in the corner doing much the same thing. For free, forever. No traffic caps and no sampling. The real limits are generous: up to 100,000 recorded sessions per project per day, and up to 100,000 page views per heatmap (Clarity FAQ). No “upgrade to see more features” popups.
Sounds too good to be true? I thought so too. But after implementing Clarity across multiple projects over the past years, I can tell you: it’s legitimate, it’s powerful, and it’s criminally underused.
This guide will walk you through everything you need to know about Microsoft Clarity: what it is, why it matters, how to implement it properly, and real-world use cases that prove its value.
What is Microsoft Clarity?
Microsoft Clarity is a free behavioral analytics tool that helps you understand how users actually interact with your website. It’s not about pageviews or bounce rates (you have Google Analytics for that). Clarity shows you the why behind the numbers.
Think of it this way: Google Analytics tells you that 80% of users are bouncing from your product page. Clarity shows you why they’re bouncing by letting you watch exactly what they did before leaving.
The tool was launched by Microsoft. It’s open-source (you can check the code on GitHub), designed to be GDPR-ready (you still have to collect consent where required, see the FAQ), and genuinely free forever. No catch. No bait-and-switch.
Core Features
1. Session Recordings
Session recordings are exactly what they sound like: video-like replays of real user sessions on your site. You can watch users:
- Click and scroll through pages
- Fill out forms (with sensitive data automatically masked)
- Navigate your menu
- Interact with elements
- Abandon processes
Unlike actual video recordings, these are DOM reconstructions, which means:
- They’re lightweight (the script loads asynchronously)
- Privacy-safe (no actual screenshots)
- They capture everything including dynamic content changes
2. Heatmaps
Clarity generates five types of heatmaps: click, scroll, area, conversion and attention maps (Heatmaps overview). The three you’ll use most:
- Click maps: Shows where users click most frequently
- Scroll maps: Indicates how far down the page users scroll
- Area maps: Highlights which sections get the most attention
These heatmaps are aggregated data visualizations. The hotter the color, the more activity in that area.
3. Rage Clicks & Dead Clicks Detection
This is where Clarity gets really interesting:
- Rage clicks: several rapid clicks in the same small area (Clarity semantic metrics). This indicates frustration—typically because something looks clickable but isn’t working as expected.
- Dead clicks: Clicks on elements that don’t do anything. Users expect interaction but get nothing.
- Excessive scrolling: When users scroll back and forth repeatedly, often trying to find something.
- Quick backs: users who leave a page and come straight back to it, a sign the navigation didn’t help.
These automatic frustration signals help you identify UX problems without manually reviewing hundreds of sessions.
4. Dashboard Insights
Clarity’s dashboard provides:
- Traffic overview (sessions, users, pages per session)
- Popular pages ranked by engagement
- JavaScript errors detected on your site
- Scroll depth metrics
- Device and browser breakdowns
- Geographic distribution
5. Filtering and Segmentation
You can filter sessions and heatmaps by:
- Device type (mobile, desktop, tablet)
- Browser
- OS
- Country
- Referral source
- Custom tags (using the Clarity API)
- JavaScript errors
- Rage clicks, dead clicks, excessive scrolling
- Session duration
You can save these filters as custom segments for quick access.
Why Use Clarity? (The Real Benefits)
1. It’s Completely Free
Let me be clear: completely free means:
- No traffic limit: every session is tracked. Recordings are capped at 100,000 sessions per project per day.
- No user limits
- No feature restrictions
- No time limits
- No “upgrade to unlock” nonsense
Paid competitors charge by session volume once you leave their free plans (check their current pricing pages).
Pricing & limits (2026)
Clarity has no paid plan. The limits that do exist, all from the official Clarity FAQ:
| Item | Limit |
|---|---|
| Price | Free forever, no traffic limits, no sampling |
| Recorded sessions | Up to 100,000 per project per day |
| Heatmaps | Up to 100,000 page views per heatmap |
| Recording retention | Up to 30 days from the time of recording |
| Projects, team members, admins | No limit (max 10 pending invites at a time) |
| Custom tags | No more than 128 per page |
Source: https://learn.microsoft.com/en-us/clarity/faq
2. Privacy-First Design
Clarity automatically:
- Masks sensitive form fields (passwords, credit cards, etc.)
- Is designed to be GDPR-ready (you still have to collect consent where required)
- Doesn’t use cross-site tracking
- Provides cookie consent APIs
- Allows you to configure masking rules
Since October 31, 2025, Clarity requires a consent signal for visitors from the EEA, UK and Switzerland; without it, recordings and journeys are fragmented (Consent API v2).
3. Lightweight Script
Clarity is built to be lightweight:
- Async script loading
- Minimal bandwidth usage
- Tested on sites with millions of visitors
4. Works with Everything
Clarity integrates with:
- Google Analytics (session linking)
- Google Tag Manager
- WordPress, Shopify, Wix, Squarespace
- Custom implementations via NPM package
- Most modern websites and frameworks
5. AI-Powered Insights (Copilot)
Clarity’s AI features automatically:
- Summarize session recordings
- Identify common patterns
- Highlight frustration points
- Generate insights from heatmaps
This saves hours of manual analysis.
How to Implement Microsoft Clarity
Clarity must run client-side in the browser because it needs to:
- Access the DOM
- Capture user interactions (clicks, scrolls, mouse movements)
- Record DOM mutations
- Use browser APIs
There’s no server-side implementation option—this is fundamental to how behavioral analytics works.
Method 1: Direct Installation (Recommended for Quick Setup)
Step 1: Create a Clarity project
- Go to https://clarity.microsoft.com
- Sign in with a Microsoft account
- Create a new project
- Get your Project ID (looks like:
abc123xyz)
Step 2: Get the tracking code
- Navigate to Settings → Setup → Install manually
- Copy the JavaScript snippet
The code looks like this:
<script type="text/javascript">
(function(c,l,a,r,i,t,y){
c[a]=c[a]||function(){(c[a].q=c[a].q||[]).push(arguments)};
t=l.createElement(r);t.async=1;t.src="https://www.clarity.ms/tag/"+i;
y=l.getElementsByTagName(r)[0];y.parentNode.insertBefore(t,y);
})(window, document, "clarity", "script", "YOUR_PROJECT_ID");
</script>
Step 3: Add to your site
- Paste the code in the
<head>section of your website - Deploy to production
- Wait a few minutes for data to appear
Verification: Within minutes, you should see live sessions in your Clarity dashboard.
Method 2: Google Tag Manager (Recommended for Tag Management)
If you use GTM, there are two approaches:
Option A: Official Microsoft Clarity Template (Easiest)
- In GTM, create a new tag
- Click “Discover more tag types in the Community Template Gallery”
- Search for “Microsoft Clarity – Official”
- Select the template by Microsoft
- Click “Add to workspace”
- Enter your Clarity Project ID
- Set trigger to “All Pages”
- Save and publish
Option B: Custom HTML Tag (More Control)
- In GTM, create a new tag
- Choose “Custom HTML” as tag type
- Paste the Clarity tracking code
- Set trigger to “All Pages”
- Save and publish
Important Notes:
- Use your actual Project ID (found in Clarity Settings → Overview)
- Test in GTM Preview mode before publishing
- Clarity requires client-side GTM (web container), not server-side
Method 3: NPM Package (For JavaScript Projects)
If you’re building a React/Vue/Angular app:
npm install @microsoft/clarity
Then in your code:
import Clarity from '@microsoft/clarity';
Clarity.init('YOUR_PROJECT_ID');
Advanced Configuration
Custom User Identification
You can identify users with custom IDs:
window.clarity("identify", "CRM-48213", null, null, "Customer 48213");
Use an internal ID, never an email or a real name: Clarity hashes the ID, but the friendly name is shown in clear in the dashboard (Identify API).
This allows you to:
- Filter sessions by specific users
- Track users across sessions
- Correlate Clarity data with your CRM
Custom Tags
Set custom tags for segmentation:
clarity("set", "plan", "premium");
clarity("set", "experiment", "variantA");
Cookie Consent
For GDPR compliance:
// With the tag snippet: grant consent
window.clarity('consentv2', { ad_Storage: 'granted', analytics_Storage: 'granted' });
// With the tag snippet: deny consent
window.clarity('consentv2', { ad_Storage: 'denied', analytics_Storage: 'denied' });
// With the NPM package
Clarity.consentV2({ ad_Storage: 'denied', analytics_Storage: 'granted' });
Source: Clarity Consent API v2
Masking Configuration
By default, Clarity masks sensitive content. You can customize:
<!-- Mask specific elements -->
<div data-clarity-mask="True">Sensitive data</div>
<!-- Unmask specific elements -->
<div data-clarity-unmask="true">Public data</div>
You can also set masking rules in Settings → Masking (Clarity masking).
Real-World Use Cases
Here is how three companies featured in Microsoft’s Clarity case studies used the tool. I’ve left out the headline percentages: Microsoft’s case-studies page was offline when I updated this article (October 2026), so I couldn’t check them against the originals.
Case Study 1: Scrape.do (Trial Signups)
Problem: High bounce rate on trial signup page, but unclear why.
Clarity Insights:
- Session recordings showed users clicking secondary elements instead of the main CTA
- Heatmaps revealed most clicks were on non-primary buttons
- Landing pages from ads had confusing layouts
Actions Taken:
- Redesigned signup flow with single, clear CTA
- Removed distracting elements
- Focused benefits above the fold
- Simplified ad landing pages
Results:
- More trial signups
- More conversions from ad campaigns
- Better return on ad spend
Case Study 2: Supademo (Onboarding Completion)
Problem: Users dropping off during onboarding, but couldn’t pinpoint where or why.
Clarity Insights:
- Session replays showed users getting stuck at specific steps
- Many users didn’t understand how to reach key milestones
- Confusion about where to find core features
Actions Taken:
- Redesigned onboarding flow based on observed behavior
- Added contextual guidance at friction points
- Streamlined path to core features
Results:
- Higher onboarding completion rate
- Better long-term user engagement
- Reduced support tickets about onboarding
Case Study 3: Places for People (Page Views)
Problem: Content sliders getting rage clicks, unclear content hierarchy.
Clarity Insights:
- Rage clicks on content sliders that didn’t work as expected
- Users frustrated scrolling through irrelevant content
- Certain pages had exceptionally high scroll depth
Actions Taken:
- Removed problematic sliders
- Reorganized content based on user intent
- Highlighted high-performing pages
- Improved navigation structure
Results:
- More page views
- Fewer rage clicks
- Better content discovery
Common Patterns Across Case Studies
- Identify frustration signals (rage clicks, dead clicks, quick backs)
- Watch session recordings to understand context
- Analyze heatmaps for patterns
- Hypothesize solutions based on observed behavior
- Implement changes
- Measure impact with before/after comparison
Clarity vs. Competitors
Clarity vs. Hotjar
| Feature | Clarity | Hotjar |
|---|---|---|
| Price | Free forever | Free plan + paid plans (see pricing page, checked October 2026) |
| Session limit | Up to 100,000 recorded sessions per day | Depends on plan |
| Heatmaps | ✓ | ✓ |
| Session recordings | ✓ | ✓ |
| Rage/dead clicks | ✓ Auto-detected | Limited |
| Surveys/Feedback | ✗ | ✓ |
| Funnels | ✓ Basic | ✓ Advanced |
Verdict: Clarity wins on cost and session volume. Hotjar wins if you need surveys and advanced funnels.
Clarity vs. Google Analytics 4
These tools complement each other:
- GA4: Tells you what is happening (metrics, conversions, acquisition)
- Clarity: Shows you why it’s happening (user behavior, friction points)
Best practice: Use both. GA4 identifies problems in your funnel, Clarity helps you understand and fix them.
Clarity vs. FullStory/LogRocket
| Feature | Clarity | FullStory/LogRocket |
|---|---|---|
| Price | Free | Free plan + quote-based / tiered paid plans (FullStory, LogRocket) |
| Session replay | ✓ | ✓ Advanced |
| Error tracking | ✓ Basic | ✓ Advanced |
| Console logs | Limited | ✓ Full |
| Network requests | ✗ | ✓ |
| Target audience | Marketers, UX | Developers, Product |
Verdict: For pure behavioral analytics, Clarity is sufficient. For technical debugging, FullStory/LogRocket provide deeper dev tools.
Limitations and Gotchas
Let’s be honest about what Clarity can’t do:
1. Cannot Render Third-Party iFrames or Canvas
Clarity can’t render content inside the elements below; clicks on first-party iframes are captured (FAQ):
- Third-party iframes (ads, embedded content)
- HTML5 canvas elements
- Cross-origin frames
2. Client-Side Only
As we established earlier, there’s no server-side implementation. Clarity must run in the browser.
3. No Built-in A/B Testing
Clarity shows you behavior but doesn’t run experiments. You’ll need separate tools for A/B testing.
4. Basic Funnel Analysis
Clarity’s funnel features are basic compared to dedicated funnel analytics tools.
5. Data Retention
Recordings are kept up to 30 days from the time of recording, so note or export what you want to keep (FAQ).
6. No Co-Browsing
Live recordings exist (Clarity live), but there’s no co-browsing or shared live annotation.
Best Practices
1. Filter Intelligently
Don’t watch random sessions. Use filters to focus on:
- Sessions with JavaScript errors
- Sessions with rage/dead clicks
- Sessions from specific traffic sources
- Mobile vs. desktop behavior
- Converters vs. non-converters
2. Combine with GA4 Data
Link Clarity with Google Analytics to:
- See Clarity recordings for specific GA4 segments
- Understand qualitative context behind quantitative data
- Validate hypotheses from GA4 reports
3. Create Custom Tags
Use the Clarity API to tag sessions with:
- User type (free, paid, trial)
- Experiment variants
- User journey stage
- Feature flags
This enables powerful segmentation.
4. Review Regularly
Make session review part of your routine:
- Weekly reviews of high-frustration sessions
- Monthly analysis of popular pages
- Quarterly deep dives into user flows
5. Respect Privacy
Always:
- Implement cookie consent properly
- Mask sensitive data
- Inform users about tracking
- Follow GDPR/CCPA requirements
6. Act on Insights
Clarity is useless if you don’t act. When you spot issues:
- Document them
- Prioritize fixes
- Implement changes
- Measure impact
- Iterate
Advanced Use Cases
Developer Debugging
Filter by JavaScript errors to:
- See exact user actions before errors occur
- Identify browser-specific bugs
- Understand error context
- Reproduce hard-to-catch issues
Form Optimization
Watch users fill out forms to identify:
- Confusing field labels
- Validation errors that block submission
- Fields users skip or struggle with
- Mobile keyboard issues
Mobile UX Testing
Filter for mobile sessions to:
- Check tap target sizes
- Identify horizontal scroll issues
- Test responsive layouts
- Validate mobile navigation
Content Strategy
Use scroll heatmaps to:
- Determine optimal article length
- Place CTAs at scroll thresholds
- Identify ignored content sections
- Optimize content hierarchy
E-commerce Optimization
Track shopping behavior:
- Product page interactions
- Cart abandonment patterns
- Checkout friction points
- Payment process issues
Integration with Other Tools
Google Analytics Integration
Bring your GA4 data into Clarity:
- In Clarity, go to Settings → Setup → Google Analytics integration
- Connect your GA4 property
- Clarity then shows your GA data (and GA segments) inside Clarity; one GA property per project
The data flows from GA into Clarity, not the other way round (Google Analytics integration).
API Access
Clarity provides a client API (identify, tags, events, consent) and a Data Export API (token from Settings → Data Export). Use them for:
- Custom reporting
- Data export
- Integration with internal tools
Conclusion
Microsoft Clarity is the rare combination of “free” and “actually good.” It won’t replace your entire analytics stack, but it fills a crucial gap: understanding why users behave the way they do.
The barrier to entry is non-existent (literally 5 minutes to install), and the insights are actionable. On most sites I’ve set it up on, the first week of recordings surfaced a few quick UX fixes.
If you’re paying for Hotjar or similar tools and only using basic session recording and heatmaps, you’re overpaying. If you’re not using any behavioral analytics tool, you’re flying blind.
Try Clarity. You have nothing to lose (it’s free) and potentially significant UX improvements to gain.
Resources
- Official Documentation: https://learn.microsoft.com/en-us/clarity/
- Case Studies: https://clarity.microsoft.com/case-studies/
- Clarity Blog: https://clarity.microsoft.com/blog/
- GitHub Repository: https://github.com/microsoft/clarity
- NPM Package: https://www.npmjs.com/package/@microsoft/clarity