Hotjar pioneered the idea that behavioral analytics — heatmaps, session recordings, user feedback — should be accessible to everyone, not just data scientists. Since 2014, it has been the default heatmap tool for product teams, UX designers, and marketers who want to see how people use their website, not just how many people visit.
The problem? Hotjar achieves this by loading approximately 350 KB of JavaScript (roughly 100 KB gzipped) on every page where it is installed. That is the equivalent of loading a medium-sized image every single time someone visits your site. And it uses cookies to identify returning visitors, which means you need a consent banner in the EU.
RevKlik takes a fundamentally different approach: the same behavioral insights delivered in a sub-1KB cookieless script. This is not a marketing trick — it is an architectural difference that changes what you can expect from heatmap tooling.
Script Size: The Numbers
Let us start with the most visible difference, because it affects every visitor to your site.
| Metric | RevKlik | Hotjar |
|---|---|---|
| Script size (uncompressed) | ~2 KB | ~350 KB |
| Script size (gzipped) | ~0.8 KB | ~100 KB |
| Additional network requests | 1 (tracking pixel) | 3-8 (script, modules, pixels) |
| Largest Contentful Paint impact | <5ms | 80-250ms |
| Total Blocking Time impact | 0ms | 50-120ms |
| CPU time on page load | ~2ms | ~80-150ms |
| Uses cookies | No | Yes (multiple) |
| Cookie banner required (EU) | No | Yes |
| Blocked by ad blockers | Rarely (custom endpoint) | Often (static.hotjar.com) |
To put the script size difference in perspective: Hotjar's script is roughly 125 times larger than RevKlik's. On a mobile 3G connection (typical for many regions), downloading 100 KB takes approximately 300-400ms. Downloading 0.8 KB takes under 5ms. That gap compounds on every single page load across every single visitor.
Heatmap tools are typically installed on every page of a site — you want behavioral data from your landing pages, pricing page, documentation, and checkout flow. This means the performance penalty is not a one-time cost. It is incurred on every single pageview, for every single visitor. A 100KB script on a site with 50,000 monthly visitors transfers 5 GB of JavaScript per month just for heatmaps.
Why Hotjar Is So Heavy
Understanding why Hotjar's script is large explains the architectural difference between the two tools.
Hotjar loads a monolithic JavaScript bundle that runs entirely in the browser. This bundle includes:
- Heatmap rendering engine: Captures DOM state, element positions, viewport coordinates, and click positions, then renders the visual heatmap overlay client-side.
- Session recording engine: Captures DOM mutations, input events, mouse movements, scroll positions, and resize events, building a full playback timeline in the browser.
- Survey and feedback widget: Renders popups, inline forms, and feedback buttons with their own styling and interaction logic.
- Consent management: Handles cookie consent detection and integration with third-party CMPs.
- Event batching: Buffers and sends event data to Hotjar's servers at regular intervals.
All of this runs in your visitor's browser. Every function, every rendering calculation, every event listener — loaded and executed on their device, on their battery, on their bandwidth.
RevKlik moves the heavy computation to Cloudflare Workers at the edge. The client-side script does only one thing: capture minimal event data (click coordinates, scroll depth, page context) and send it as a tiny payload to the nearest edge node. All rendering, aggregation, and replay happens server-side. The visitor's browser does zero heavy lifting beyond capturing a few numbers per interaction.
Feature Comparison
| Feature | RevKlik | Hotjar |
|---|---|---|
| Click heatmaps | Yes | Yes |
| Move heatmaps | Yes | Yes |
| Scroll depth maps | Yes | Yes |
| Attention maps | Coming soon | Yes |
| Session recordings | Yes | Yes |
| Recording filters | Device, country, page, event | Device, country, page, event, rage click |
| Surveys / feedback | No | Yes |
| Conversion funnels | Built-in drag & drop | Basic funnel (Observe plan) |
| Revenue attribution | Native, built-in | No |
| Web analytics (pageviews, etc.) | Full analytics suite | Basic (pageview counts only) |
| Real-time dashboard | Yes | No (data delayed 1+ hour) |
| Mobile app | iOS & Android | No |
| API access | Yes | Limited (Export API) |
| Cookieless | Yes, by default | No, uses cookies |
The key distinction: Hotjar is a behavior research tool with excellent survey and feedback capabilities. RevKlik is a complete analytics platform that happens to include behavioral features. If you need surveys and on-site feedback, Hotjar has an advantage. If you need heatmaps plus analytics plus revenue tracking in one tool, RevKlik covers more ground.
What about heatmap accuracy?
Both tools capture the same raw data: click positions (relative to the page), scroll depth (percentage and pixels), and mouse movement coordinates. The accuracy of the underlying data is comparable because it comes from the same browser APIs (MouseEvent.clientX/Y, window.scrollY, etc.).
The difference is in rendering. Hotjar renders heatmaps as visual overlays in your browser, combining the captured data with a screenshot of the page. RevKlik processes the data server-side and generates the heatmap visualization in its dashboard. Both approaches produce accurate representations of where users click and scroll — the methodology differs, but the output is functionally equivalent for making UX decisions.
Performance Impact: Real-World Measurements
We tested both tools on the same landing page (a typical SaaS marketing page, ~1.5 MB total, deployed on Vercel) using WebPageTest on a Moto G4 (mid-range Android) emulated on a 3G connection. Here are the results:
| Core Web Vital | Baseline (no analytics) | + RevKlik | + Hotjar |
|---|---|---|---|
| Largest Contentful Paint | 2.8s | 2.8s (+0.0s) | 3.4s (+0.6s) |
| First Input Delay | 12ms | 12ms (+0ms) | 45ms (+33ms) |
| Total Blocking Time | 180ms | 182ms (+2ms) | 290ms (+110ms) |
| Cumulative Layout Shift | 0.02 | 0.02 | 0.05 (survey widget) |
| Total page weight | 1.5 MB | 1.5 MB (+0.8 KB) | 1.6 MB (+100 KB) |
Adding Hotjar pushed the page's LCP from "good" (under 2.5s) into the "needs improvement" category on a mid-range mobile device. RevKlik's impact was statistically invisible.
The LCP increase from Hotjar (600ms) might not seem dramatic in isolation. But it pushes a borderline page from passing to failing Core Web Vitals. Since Google uses Core Web Vitals as a ranking signal, this directly impacts SEO performance. And on every page load, those extra 100 KB consume your visitors' mobile data allowance.
Privacy Compliance
Hotjar uses cookies for session identification and returning visitor tracking. Specifically, it sets:
_hjSessionUser_{site_id}— persistent user identifier (1 year expiry)_hjSession_{site_id}— session identifier (30 minutes)_hjAbsoluteSessionInProgress— session flag_hjFirstSeen— first visit timestamp
In the EU, under the ePrivacy Directive, these cookies require informed consent before they can be set. This means:
- You need a cookie consent banner
- You need a consent management platform ($20-200/month)
- You need to configure Hotjar to load only after consent is given
- You need to maintain documentation of consent for audits
RevKlik uses zero cookies. No session cookies, no tracking cookies, no persistent identifiers on the user's device. All processing happens server-side using transient HTTP request data. This qualifies for the ePrivacy Directive exemption described in our guide to analytics without cookie banners.
The practical impact: with RevKlik, you eliminate the consent banner for analytics, simplify your compliance documentation, and remove a source of friction that reduces engagement by 10-20%.
Pricing
| Plan | RevKlik | Hotjar |
|---|---|---|
| Free tier | 10K events/month (includes heatmaps) | 35 sessions/day (basic heatmaps) |
| Entry paid | $1/month (100K events) | $32/month (Observe Plus, 100 sessions/day) |
| Mid-tier | $9/month (500K events) | $64/month (Observe Business, 500 sessions/day) |
| Scale | $49/month (5M events) | Custom pricing |
| Heatmaps included | Yes, all plans | Yes, all plans |
| Session recordings | Yes, all plans | Yes (limited on free) |
| Web analytics | Full analytics dashboard | Basic pageview data |
| Revenue attribution | Yes, all plans | Not available |
| Funnel visualization | Yes, all plans | Observe plan and above |
At $32/month, Hotjar's Observe Plus gives you 100 recorded sessions per day with heatmaps but no web analytics, no revenue tracking, and no funnel builder. At $9/month, RevKlik gives you 500K tracked events with heatmaps, session recordings, funnels, revenue attribution, and a full web analytics dashboard. The per-feature value heavily favors RevKlik if you need more than just heatmaps.
When to Choose Hotjar
Hotjar remains the better choice in specific scenarios:
- You need surveys and user feedback: Hotjar's survey and feedback widget tools are genuinely excellent and well-integrated with the heatmap data. If on-site user research is your primary goal, Hotjar's all-in-one research toolkit is hard to beat.
- Your team is already proficient with Hotjar: If your product and design teams know Hotjar's interface inside out and use it daily, the switching cost may not be worth it.
- Performance is not a critical concern: For internal tools, admin dashboards, or sites where sub-second load times are not a priority, Hotjar's performance impact is acceptable.
- You already have a separate analytics tool: If you use GA4 or Mixpanel for analytics and only need heatmaps + recordings + surveys, Hotjar fills that gap well.
When to Choose RevKlik
RevKlik is the better fit when:
- You want one tool instead of three: Analytics + heatmaps + revenue tracking in a single platform, instead of running GA4 + Hotjar + a revenue dashboard separately.
- Page performance matters: You care about Core Web Vitals and do not want heatmap scripts adding 100KB to every page load.
- You need privacy compliance by default: No cookies means no consent banner for analytics, period.
- Budget is a factor: RevKlik delivers heatmap + analytics + revenue features at a fraction of the cost of combining Hotjar with a separate analytics tool.
- Revenue attribution is important: You sell something and need to connect user behavior (where they click, how far they scroll) with revenue outcomes (what they buy, how much they spend).
For a full analytics comparison beyond heatmaps, see our detailed breakdowns of RevKlik vs Google Analytics 4 and RevKlik vs Matomo.
FAQ
How accurate are RevKlik heatmaps compared to Hotjar?
Both tools capture the same underlying data using the same browser APIs (click coordinates, scroll positions, mouse movements). The accuracy is comparable for click and scroll heatmaps. The main difference is that Hotjar renders heatmaps as a browser overlay with a page screenshot, while RevKlik processes data server-side and renders in the dashboard. For practical UX optimization — "are users clicking the CTA?", "where do they drop off on mobile?" — both provide equivalent insights.
Does RevKlik support feedback widgets and surveys?
No. RevKlik focuses exclusively on behavioral analytics: heatmaps, session recordings, conversion funnels, revenue attribution, and web analytics. If surveys and on-site feedback are essential to your workflow, consider pairing RevKlik with a dedicated survey tool (Tally, Typeform, or even Hotjar's free tier for surveys only).
Why is Hotjar's script so large?
Hotjar loads a monolithic JavaScript bundle (~350 KB uncompressed) that includes the full heatmap rendering engine, session recording capture system, survey widget framework, feedback collector, and consent management — all running client-side in the visitor's browser. RevKlik moves the heavy processing to Cloudflare Workers at the edge, so the client-side script only needs to capture and send minimal event data.
Can I use RevKlik and Hotjar together?
Technically yes, but running both defeats the purpose of choosing a lightweight tool. RevKlik's 0.8 KB script adds negligible overhead during a comparison period, so you could run both for a week to evaluate. For production use, choose one — the combined JavaScript weight (101 KB) would erase RevKlik's performance advantage.
Does RevKlik session recording capture the actual page like Hotjar?
RevKlik captures interaction events (clicks, scrolls, mouse movements, page navigation) and replays them against the page structure, similar to how Hotjar and other recording tools work. It does not capture screenshots or full DOM snapshots during recording. The replay reconstructs the user's journey by replaying captured events. For understanding user behavior — where they get stuck, what they ignore, how they navigate — this provides the same actionable insights as Hotjar's approach.
One script tag. Under 1KB. Heatmaps, session recordings, funnels, revenue tracking — all included. Free for 10,000 events/month. Get started →