Microsoft Clarity is a behavior analytics tool. It gives teams session recordings, heatmaps and insights that show how people actually move through a page: where they click, where they scroll, where they get stuck. For understanding human experience on a website, few things are as direct as watching it happen.
Websites now serve more than people with a mouse. AI agents fetch pages and complete tasks for real customers. People browse with an AI assistant at their side. Some traffic cannot be explained at all. Teams want to know how much of each is reaching them and what their application should do about it. That job belongs to Proof of Actor, the actor intelligence product from AgentCredia.
This page compares the two fairly. Clarity facts below come from Microsoft's own documentation and the official Clarity blog as of November 2026.
The short version
| Microsoft Clarity | Proof of Actor | |
|---|---|---|
| Main question | How do people interact with my pages? | Who or what is acting on this interaction, and what is the evidence? |
| Primary data collection | A JavaScript tracking code in the page head | Server middleware, edge, HTTP API, MCP servers, plus an approved browser collector |
| Bot sessions | Detected and excluded by default; the setting can be turned off | Classified and kept, so you can see and route them |
| AI crawler activity | Bot Activity reporting from CDN and server log integrations | Agent results per interaction, with verified, declared or inferred basis |
| AI-assisted people | Not described as a separate class | A first-class result: Human + AI |
| Unclear traffic | Counted as a session unless detected as a bot | Reported as Unknown, with a fallback you choose |
| Acts on traffic | No, it reports and records | Routes per your policies in your own code, after observation |
The rest of this page explains each row.
What recordings and heatmaps are built to show
Clarity is built to show the experience on a page. A session recording replays one visit: the cursor path, the scrolls, the hesitations and the clicks that led nowhere. A heatmap aggregates clicks and scroll depth across many visits so you can see which parts of a page get attention. Insights use machine learning to surface the sessions and patterns that matter most. Every one of those views answers a design question, and every one of them assumes a person with a browser on the other side.
That assumption is reasonable for a recording tool. A recording is only useful when there is an experience to watch, and an agent that fetches HTML without running the page script leaves nothing to replay. It also means that a heatmap mixing people, AI-assisted people and browser automation can point a design team at the wrong problem.
Proof of Actor answers the question that comes before the recording: who or what was behind this interaction. It returns Human when the signals indicate a person, Human + AI when a person acted with AI assistance that was declared or observed through a supported integration, Agent for automated or agent-origin interaction, and Unknown when the evidence does not support a reliable call. Each result carries an evidence basis, verified, declared, inferred or unknown, so you know how much weight a label on a recording can bear.
Where each one runs
According to Microsoft's Clarity setup documentation, you install Clarity by adding its tracking code to the <head> of your site, through a supported third-party platform, or through an NPM package. Data is sent from the browser to Clarity's collection endpoint. Microsoft also notes that Clarity cannot capture what is inside Canvas or third-party iframe elements.
A browser script sees browsers. Many agents fetch HTML without running JavaScript, call your API directly, or connect to an MCP server, and none of those paths load a page script.
Proof of Actor runs where your application logic lives: Node.js middleware, Next.js, the edge layer you control, a generic HTTP API and MCP servers, with an optional browser collector on pages you approve. See the integrations page. It classifies interactions whether or not a page is ever rendered.
How Clarity treats bots and AI agents
Clarity takes bots seriously, in two distinct ways.
Bot detection in session data. Microsoft's setup documentation states that, by default, Clarity detects bot traffic and excludes it from the total session count and analytics, and that you can view the number of excluded bot sessions at the top of your dashboard. The Bot Detection setting can be toggled off or back on. When it is off, Clarity does not detect bot traffic or exclude it from the session count.
Bot Activity reporting. Under AI Visibility, Clarity offers a Bot Activity view. According to the official Clarity blog, this view is powered by server-side logs collected through CDN integrations, with Fastly, Amazon CloudFront and Cloudflare named as supported providers, rather than by the page script. The blog describes it as showing the share of requests that come from AI bots, bot activity grouped by purpose, crawler requests by operator, and the paths automated systems request most.
Both are useful for keeping session analytics clean and for understanding crawling at a site level. Neither is described as a per-interaction answer your application receives at request time, and Microsoft's documentation does not describe a class for people working with AI assistance.
Bot Activity versus a per-request actor class
Clarity's Bot Activity view and a Proof of Actor result look related, but they answer different questions at different layers.
| Clarity Bot Activity | Proof of Actor result | |
|---|---|---|
| Source | Server-side logs from CDN integrations, per the official Clarity blog | Signals in your request path: server, edge, HTTP API, MCP server, approved browser pages |
| Unit | Crawler requests grouped by operator, purpose and path | One interaction, with a class and a basis |
| Who reads it | People looking at a site-level dashboard | Your application code at request time, and your team in actor analytics |
| AI-assisted people | Not in scope; it reports crawling | A first-class result: Human + AI |
| Can change the response | No | Yes, through policies you write in your code |
The practical differences follow from that table.
An answer while the request is open. Bot Activity summarizes crawling after the fact. Proof of Actor returns its result to your application during the interaction, so the same classification you analyze later can shape the response now.
Evidence instead of an operator name. A verified Agent result means a request signature was checked against a published key, for example using HTTP Message Signatures as defined in RFC 9421. Declared and inferred results are labeled as such. A crawler name on its own rests on a user agent string, which can be imitated, as the user agent spoofing entry explains.
Agents kept in view, not just excluded. Clarity's Bot Detection keeps bot sessions out of your human analytics, which is right for recordings and heatmaps. Proof of Actor reports those visitors as Agent results so you can see which routes they use and serve them well. The guide on serving AI agents structured content shows how.
Unknown, made visible. Traffic that is neither detected as a bot nor clearly human becomes an ordinary session in a recording tool. Proof of Actor returns Unknown and tracks its rate by route; the guide on handling Unknown traffic explains how to set a fallback.
Policies you control. Policies are written per route, actor class and basis: allow, adapt, challenge, send to review or rate-limit. Proof of Actor starts in observation mode, so installing it changes nothing until you choose to enforce.
Filtering recordings and heatmaps by actor class
The most direct way to combine the two is to bring the actor class into Clarity itself:
- Classify each interaction with Proof of Actor at the server, edge, API or MCP layer, with its basis.
- Tag the Clarity session. On pages where Clarity runs, pass the actor class to Clarity as a custom tag through its client API.
- Filter recordings by class. Watch Human + AI sessions next to unassisted Human sessions to see where AI-assisted people move faster or get stuck, and review Unknown sessions to see what unexplained traffic actually does on a page.
- Split heatmaps by class. A heatmap filtered to Human sessions shows the design problem your people actually have, without automation skewing the clicks.
- Keep Bot Detection on for clean human analytics, and use Proof of Actor actor analytics by route for the agent traffic Clarity sets aside or never sees, such as API and MCP calls.
- Act where it matters. When the picture is clear, write policies for the routes where actor class should change the experience. The guide on rolling out actor-aware policies safely covers the steps, and the websites use case shows the full flow on a production site.
When to choose which
Choose Microsoft Clarity when your question is about experience: how people use a page, where they hesitate, what they ignore, and where the design gets in their way. Its Bot Activity view is a useful site-level picture of AI crawling.
Add Proof of Actor when you need to know who is behind each recording or request with stated evidence, when AI-assisted people should be visible as their own group, when agents reach you through APIs and MCP servers that no page script sees, or when your application should respond differently per actor. Clarity shows you the experience. Proof of Actor tells you who is having it, and gives your code a way to respond.
Get started
Proof of Actor is in private beta. Through the founding developer program, selected teams can receive up to 12 months of free access within agreed usage limits, with no automatic billing. Apply for early access and tell us about your site and the traffic you want to understand.
Microsoft Clarity is a trademark of Microsoft Corporation.