Microsoft Clarity MCP for AI. Pinpoint exactly where your users get stuck or confused.
Works with every AI agent you already use
…and any MCP-compatible client








Connect to your AI in seconds.
Microsoft Clarity uses behavioral analytics, heatmaps, and recorded sessions to show exactly how users interact with your website. It finds friction points by tracking clicks, scrolls, and user frustration patterns like rage clicking.
Connect it to your AI agent to ask questions about site performance—like 'Why are users abandoning checkout?'—and get actionable data instantly.
What your AI can do
Check clarity status
Verifies if the server is connected and running correctly.
Get dashboard
Retrieves aggregate metrics like total sessions, bounce rates, and engagement scores for a project.
Get heatmap
Gets detailed visual data showing click, scroll, and attention patterns on a specific page.
Retrieve high-level performance data including sessions, bounce rates, and average engagement scores across all tracked projects.
Generate heatmaps that show exactly where users click, scroll, or focus on a specific page layout.
Get live metrics detailing how many people are currently on the site and which pages they're viewing right now.
Identify specific technical failures like dead clicks or rage clicking to pinpoint broken UI components that frustrate users.
Access and analyze recorded user sessions, viewing the timeline of pages visited and the duration of engagement for deep research.
Ask an AI about this
Waiting for input…
Microsoft Clarity MCP Server: 13 Tools for Behavioral Analytics
Use these tools to analyze everything from live traffic counts to deep user frustration patterns like dead clicks and rage clicking.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using Microsoft Clarity on VinkiusCheck Clarity Status
Verifies if the server is connected and running correctly.
Get Dashboard
Retrieves aggregate metrics like total sessions, bounce rates, and engagement scores...
Get Heatmap
Gets detailed visual data showing click, scroll, and attention patterns on a...
Get Live Insights
Fetches real-time numbers for active users, current page views, and session duration.
Get Project
Retrieves specific details about a tracked website project.
Get Recording
Gets detailed information about a single recorded user session, including its duration and pages visited.
Get Scroll Depth
Calculates what percentage of the page content users actually scroll down to view.
List Dead Clicks
Lists specific instances where users click an element that doesn't respond...
List Heatmaps
Retrieves a list of available heatmaps for multiple pages or projects.
List Projects
Gets a list of all websites and projects currently being tracked by Clarity.
List Rage Clicks
Lists instances where users repeatedly click an element in frustration, pointing to...
List Recordings
Provides a list of all saved session recordings with their dates and durations.
List Top Pages
Generates a ranked list of the pages receiving the most traffic (sessions) on the site.
Security and governance baked right in.
Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with Microsoft Clarity, then connect any of our 5,100+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 5,100+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Microsoft Clarity. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Works with Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This connection provides 13 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
You know your site has leaks, but finding them is a nightmare.
Right now, figuring out why users drop off is a manual slog. You have to cross-reference support tickets with Google Analytics data, then copy/paste segments of the funnel into Jira for review. It’s slow, it involves three different dashboards, and you always miss that one critical failure point.
With this MCP server, your agent handles the plumbing. Instead of digging through tabs, you ask: 'Why did they leave?' The agent runs `list_rage_clicks` or `get_scroll_depth`, giving you a single diagnosis—a clear path to fixing the leak.
Spotting friction points with list_dead_clicks
Manually, QA testers find dead clicks by running through every element on test machines. But that only proves it works for *them*. Real users might be clicking a non-responsive area because the visual design makes it look like something else.
The server runs `list_dead_clicks` against real user traffic. This doesn't just show failures; it shows *where* and *how many times* those failures happened, giving you concrete data on your most broken UI elements.
What your AI can actually do with this
You're gonna use this server for deep behavioral analytics on your site. It pulls data from Microsoft Clarity, letting your AI client show you exactly how users interact with your web pages—where they click, where they get stuck, and what parts of the layout they ignore. You don't just guess why people leave; you look at the proof.
When you connect it to your agent, you can ask pointed questions about site performance, getting actionable data instantly without manually digging through dashboards. It’s all structured into specific tools that let your AI client work its magic.
Project Overview and Health Checks
You'll start by ensuring everything's running clean; the check_clarity_status tool verifies if the whole server is connected and working right. To see what sites you're tracking, you use list_projects, which gives you a rundown of every website project Clarity monitors. Once you pick one, you can get specific details about that tracked site using get_project.
For high-level performance checks, the get_dashboard tool pulls aggregate metrics like total sessions, bounce rates, and average engagement scores across all your projects.
Analyzing User Behavior Maps
The heatmaps are where you figure out what's going wrong. The list_heatmaps tool retrieves a list of available maps for multiple pages or projects. Then, the get_heatmap tool pulls detailed visual data showing exactly where users click, scroll, or focus on any specific page layout. You can also get a sense of how much content people actually see; get_scroll_depth calculates what percentage of the total page content users view.
To rank your pages by traffic, you use list_top_pages, which generates a ranked list showing the sites getting the most sessions.
Real-Time and Session Deep Dives
If you need to know what’s happening right now, the get_live_insights tool fetches real-time numbers for active users, current page views, and session duration. When you want to review past behavior, first use list_recordings to get a list of all saved sessions, showing their dates and durations. To dig into one specific instance, get_recording pulls detailed info about a single user session, letting you see its full timeline and how long they stayed.
Diagnosing User Frustration and Failure Points
This is where you find the bugs that frustrate users. You can pinpoint technical failures by using list_dead_clicks, which lists specific instances where users click an element that looks clickable but doesn't actually respond—that’s a UI failure waiting to happen. Similarly, list_rage_clicks tracks moments when users repeatedly click something out of pure frustration because the site isn't working right.
These tools show you exactly where your UI is broken.
Running Through All Your Data Points
You can also get overall metrics on project health using get_dashboard, and if you need to check specific details about a tracked website, get_project pulls those records. The server's capabilities are built for deep research, covering everything from simple page views to complex user frustration patterns, letting your AI client analyze the data like you’re sitting shoulder-to-shoulder with your teammate.
019dd0cd-f2e2-7026-82ab-9cba53ee0a02 Here's how it actually works
The bottom line is, instead of reading through a massive analytics dashboard, your AI client gives you a single diagnosis: 'Here's what's broken and where.'
Subscribe to this server and plug in your Clarity API key.
Ask your AI agent a question about user behavior (e.g., 'Where are users abandoning the checkout page?').
The agent runs the appropriate tool, returning structured data—like heatmap coordinates or list of dead clicks—that it translates into plain English insights for you.
Who is this actually for?
UX designers who are tired of guessing why users leave the checkout page. Product managers who need hard metrics to prove that feature adoption is dropping off. Growth engineers needing to automatically detect conversion blockers before they tank revenue.
Monitors engagement scores and tracks feature usage by running get_scroll_depth on key pages, allowing them to prioritize UX improvements with data.
Uses the server to run list_dead_clicks or list_rage_clicks when QA finds a broken element, verifying if it's a technical bug or just user confusion.
Runs live checks using get_live_insights to see traffic spikes and immediate engagement changes during a marketing campaign launch.
What Changes When You Connect
See who's failing to convert. Instead of guessing, run list_dead_clicks and list_rage_clicks to pinpoint the exact UI element that causes user frustration—whether it's a slow button or an invisible link.
Understand content value instantly. Use get_scroll_depth to see if your key message is below the fold. If 70% of users stop scrolling at the pricing tier, you know where to rework the layout.
Monitor site health in real time. With get_live_insights, you can watch user flow and engagement scores during a major marketing push without waiting for yesterday's reports.
Quickly audit your entire setup. Use list_projects before diving deep, ensuring your AI agent is pulling data from the correct site configuration or project ID.
Benchmark performance easily. Run get_dashboard to compare engagement metrics against previous periods and identify trends in overall bounce rates.
See it in action
Debugging a Broken Checkout Flow
A Product Manager noticed checkout drop-off was high, but couldn't tell why. They asked their agent to run list_dead_clicks on the payment page. The result showed 20 dead clicks on the 'Save Card Info' section—the field labels look clickable but aren't. This immediately told them the UI needed an overhaul.
Optimizing Homepage Content
A UX designer wants to know if their new value proposition is visible. They run get_scroll_depth and find that 65% of users never scroll past the hero section. This proves they need a more aggressive visual hook higher up on the page.
Investigating Unexpected Traffic Drops
A growth engineer sees a sudden drop in activity. They run get_live_insights and see that while traffic is still high, the average session duration has plummeted to 1 minute. This signals users are arriving but leaving immediately, suggesting an unexpected redirect or technical blocker.
Analyzing Top Page Performance
A marketing team wants to know which page drove the best user interaction last month. They use list_top_pages first, then run get_heatmap on the top result, revealing that users are clicking links in an unexpected order, pointing to a navigational issue.
The honest tradeoffs
Assuming basic metrics tell the whole story
Just looking at Google Analytics and seeing 'low conversion rate' without knowing why users got stuck.
Run list_rage_clicks and then view a session recording using get_recording. This combination tells you exactly which element caused the frustration, solving the mystery.
Ignoring user flow context
Reporting that 'users are leaving at checkout' without knowing if they failed on payment or abandoned due to cost.
Use get_heatmap specifically on the final steps of the funnel. The map shows if users are failing at the shipping input (a dead click) or spending too long looking at the total price.
Over-relying on 'page views' alone
Thinking that high page view counts mean high engagement, when in fact users might be bouncing between pages without accomplishing a goal.
Check get_scroll_depth and the dashboard metrics. These tools differentiate between merely visiting content and actually engaging with it.
When It Fits, When It Doesn't
Use this server if you need to know the 'why' behind your site’s performance, not just the 'what.' If you only care about basic traffic numbers (total visits, page views), stick to a standard web analytics tool. But if you want to debug conversion blockers—the things that make people click repeatedly or leave abruptly—you need this. Use list_dead_clicks when a button fails silently; use get_heatmap when you think users are paying attention but aren't clicking the right spot. Don't try to solve every problem with one tool; run them in sequence: first, check get_dashboard for the symptom (low engagement), then use list_rage_clicks to find the cause (the slow button).
Questions you might have
How do I find out if users are seeing my important content? +
Run get_scroll_depth. This tool tells you the percentage of people who actually scroll down to view your message, identifying exactly where user interest drops off.
What is the difference between using get_dashboard and list_top_pages? +
get_dashboard gives you aggregate metrics (the overall picture). list_top_pages provides a simple, actionable ranked list of pages that are driving the most sessions right now.
Can I check for UI bugs with list_rage_clicks? +
Yes. The list_rage_clicks tool detects repeated, frustrated clicking patterns. This usually means a button is slow, or an element isn't responding properly.
How do I get live data on user behavior right now? +
Use get_live_insights. This provides real-time counts for active users and the top pages they are viewing at this exact moment, great for launch day monitoring.
What does running the `check_clarity_status` tool tell me about my API key? +
It verifies your connection credentials instantly. If the status check fails, it means there is an issue with the provided API Key or project scope; you'll need to re-authenticate first.
If I run `list_projects`, how do I select the correct website for analysis? +
The tool returns a list of all sites connected to your account. You must use the unique ID or slug from that returned list when calling any other function, like get_heatmap.
When using `list_recordings`, what specific parameters do I need for the `get_recording` tool? +
You require both the unique recording ID and the parent project scope. Passing these two identifiers allows your agent to pull detailed session timelines and playbacks.
After listing heatmaps with `list_heatmaps`, what data points must I pass to `get_heatmap` for a full analysis? +
You need the specific page URL and the desired date range. This ensures you retrieve the raw click, scroll, and attention pattern data needed for accurate visualization.
Can I detect UX friction points like dead clicks and rage clicks? +
Yes! Use list_dead_clicks to find page elements where users click without any response — signaling non-interactive elements that look clickable. Use list_rage_clicks to detect pages where users repeatedly click in frustration, indicating broken buttons, slow-loading elements, or confusing UI patterns.
Can I analyze how far users scroll on each page? +
Yes. The get_scroll_depth tool returns scroll metrics for each page in your project, showing the percentage of users who reach each content section. This identifies exactly where engagement drops off — essential for optimizing content placement and CTA positioning.
Can I view real-time analytics while users are on my site? +
Yes. The get_live_insights tool provides real-time data for any project, including active user count, current page views, and live engagement metrics. For historical aggregates, use get_dashboard to access sessions, pages per session, and engagement scores over time.
We've already built the connector for Microsoft Clarity. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 13 tools are live and waiting.
You're up and running in seconds.
Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.
Built, hosted, and secured by Vinkius. You just connect and go.