Analytics Script Benchmark 2026: We Tested 10 Tools for Speed

Your analytics script loads on every page of your website. If it is slow, heavy, or makes too many network requests, it taxes every single visitor. For high-traffic sites, this compounds into real performance degradation — slower Largest Contentful Paint (LCP), worse Core Web Vitals, lower search rankings.

We tested 10 popular analytics tools on the same page to measure their real-world performance impact. The goal was simple: quantify exactly how much each tool costs your visitors in load time.

Test methodology

We tested each analytics tool on an identical static HTML page hosted on a Hetzner VPS in Germany. The page contained a hero section with a heading, paragraph, and 400KB hero image — a realistic layout that gives us a meaningful LCP measurement.

Test setup:

• Baseline page: Static HTML, 400KB hero image, served via Nginx with HTTP/2
• Connection: Simulated 4G connection (9 Mbps down, 1.5 Mbps up, 50ms RTT) via Chrome DevTools throttling
• Browser: Chrome 124, incognito mode, cache disabled
• Measurements: 10 runs per tool, median values reported
• Metrics captured:
  • Script size (transferred over the wire, gzipped)
  • Number of network requests initiated by the script
  • LCP delta (difference from baseline LCP without any analytics)
  • Total blocking time contribution

Each tool was configured with default settings — no custom events, no enhanced tracking, no plugins. This represents the minimum cost of adding the tool to your site.

Results

Summary table

| Tool | Script Size (gzip) | Network Requests | LCP Delta | Total Blocking Time | |------|-------------------|-----------------|-----------|-------------------| | Baseline (no analytics) | 0 KB | 0 | 0 ms | 0 ms | | Plausible | 0.8 KB | 1 | +3 ms | < 1 ms | | Umami | 2.1 KB | 1 | +5 ms | < 1 ms | | Simple Analytics | 3.2 KB | 1 | +7 ms | < 1 ms | | DataSaaS | 4.8 KB | 1 | +9 ms | < 1 ms | | Fathom | 6.1 KB | 2 | +14 ms | 1 ms | | Hotjar | 15.3 KB | 4 | +48 ms | 12 ms | | Matomo | 22.4 KB | 3 | +62 ms | 18 ms | | GA4 (gtag.js) | 45.2 KB | 4 | +87 ms | 28 ms | | Segment | 71.8 KB | 6 | +142 ms | 45 ms | | PostHog | 82.6 KB | 5 | +158 ms | 52 ms |

Detailed analysis

Tier 1: Negligible impact (under 5 KB)

Plausible (0.8 KB, +3 ms LCP)

Plausible is the lightest analytics script we tested. At 0.8 KB gzipped, it is barely larger than a favicon. It makes a single network request (the pageview beacon) and has virtually zero impact on page performance. If raw script size is your primary concern, Plausible is the clear winner.

The trade-off: Plausible's minimal footprint comes from its focused feature set. It tracks pageviews, referrers, UTM parameters, and basic device/browser data. It does not track custom events by default (that requires an additional snippet), and it does not support revenue attribution natively.

Umami (2.1 KB, +5 ms LCP)

Umami is the lightest self-hosted option. At 2.1 KB, it is slightly heavier than Plausible but still negligible. Single network request, no measurable blocking time. A solid choice for developers who want full data ownership.

Simple Analytics (3.2 KB, +7 ms LCP)

Simple Analytics sits in the middle of the lightweight tier. Its script is slightly larger than Umami because it includes built-in event tracking and automated outbound link tracking. The performance impact is still negligible.

Tier 2: Minimal impact (5-10 KB)

DataSaaS (4.8 KB, +9 ms LCP)

DataSaaS is the heaviest script in the "lightweight" category, coming in at 4.8 KB gzipped. The additional size compared to Plausible and Umami comes from built-in features: SPA navigation detection via History API interception, automatic session management, visitor identification, and the data structure needed for revenue attribution.

The LCP impact of +9 ms is functionally imperceptible — no user will notice 9 milliseconds, and it is well within the margin of error for real-world page loads. A single network request keeps the overhead simple.

For founders who need revenue attribution (connecting traffic to Stripe/LemonSqueezy payments), DataSaaS offers the best balance of performance and functionality. The 4 KB premium over Plausible buys you a feature that would otherwise require a second, much heavier tool.

Fathom (6.1 KB, +14 ms LCP)

Fathom is slightly larger than DataSaaS and makes 2 network requests instead of 1 (the script load plus a separate configuration fetch). The LCP impact is still small at +14 ms. Fathom has been a reliable privacy-focused option for years, with a polished dashboard and good documentation.

Tier 3: Moderate impact (15-50 KB)

This tier is where analytics scripts start having a measurable impact on page performance, particularly on slower connections and lower-end devices.

Hotjar (15.3 KB, +48 ms LCP)

Hotjar is not a pure analytics tool — it is primarily a heatmap and session recording platform. Its script is larger because it needs to instrument the DOM for click tracking and scroll depth measurement. The 4 network requests include the main script, configuration data, and recording initialization.

If you need heatmaps, Hotjar's size is reasonable for what it does. If you just need pageview analytics, it is significantly heavier than necessary.

Matomo (22.4 KB, +62 ms LCP)

Matomo is the open-source alternative to Google Analytics, and its script size reflects that ambition. At 22.4 KB, it is roughly 28x heavier than Plausible. The 3 network requests include the tracking script, configuration, and the initial pageview beacon.

Matomo's script size is driven by its extensive feature set: custom dimensions, e-commerce tracking, content tracking, and form analytics are all bundled into the default script. If you use these features, the size is justified. If you just need basic analytics, it is substantial overhead.

GA4 / gtag.js (45.2 KB, +87 ms LCP)

Google Analytics 4 is the most widely used analytics tool in the world, and also one of the heaviest. The 45.2 KB script makes 4 network requests on initial load: the gtag.js library, the GA4 configuration, the measurement protocol beacon, and a cookie sync request.

The +87 ms LCP impact is meaningful. On a 4G connection, that is nearly a tenth of a second added to every page load. On slower 3G connections common in emerging markets, the impact is substantially larger.

GA4's weight is the cost of its comprehensive feature set: enhanced measurement, debug mode, consent mode integration, cross-domain tracking, and Google Ads integration. Most small to mid-size websites do not use the majority of these features, meaning they pay the performance cost without receiving the benefit.

For a detailed comparison of GA4 vs lighter alternatives, see our DataSaaS vs Google Analytics analysis.

Tier 4: Heavy impact (50+ KB)

Segment (71.8 KB, +142 ms LCP)

Segment is a Customer Data Platform (CDP), not a traditional analytics tool. Its script size reflects its role as a data routing layer — it needs to load adapters for every downstream integration (analytics, CRM, advertising, etc.). The 6 network requests include the core library, identity resolution, and multiple integration initializations.

For enterprise teams with complex data routing needs, Segment's size is an accepted trade-off. For indie hackers and small teams, it is massive overkill.

PostHog (82.6 KB, +158 ms LCP)

PostHog is the heaviest script in our test. At 82.6 KB, it is over 100x heavier than Plausible. PostHog bundles product analytics, session recording, feature flags, A/B testing, and surveys into a single platform — and the script size reflects this all-in-one approach.

The +158 ms LCP impact is significant. On mobile devices with slower processors, the total blocking time (52 ms) can push interactions into the "slow" category for Core Web Vitals.

PostHog is a powerful tool that replaces 3-4 separate products. If you use its full feature set, the weight is justified. If you only need pageview analytics, you are loading 82 KB of JavaScript you do not use.

Visual comparison

To put these numbers in perspective:

• Plausible's script (0.8 KB) is smaller than this sentence when gzipped
• DataSaaS's script (4.8 KB) is smaller than a typical favicon
• GA4's script (45.2 KB) is larger than many hero images after optimization
• PostHog's script (82.6 KB) is larger than jQuery

The real-world impact

On a fast broadband connection, even the heaviest scripts add under 200 ms to page load. That sounds small. But consider:

1. Mobile matters: Over 50% of web traffic is mobile. Mobile devices have slower processors and often use slower connections. A script that adds 87 ms on a simulated 4G connection can add 300+ ms on a real 3G connection on a mid-range Android phone.

2. Cumulative effect: Most websites do not run just one third-party script. If you have GA4 (45 KB), Hotjar (15 KB), and an ad pixel (20 KB), you are loading 80 KB of analytics JavaScript before your page even renders. Each script's network requests multiply the overhead.

3. Core Web Vitals: Google uses Core Web Vitals (LCP, FID, CLS) as a ranking signal. Heavy analytics scripts directly impact LCP and Total Blocking Time (which affects FID/INP). If your LCP is borderline (around 2.5s), adding a 45 KB analytics script could push you from "Good" to "Needs Improvement."

4. Conversion rates: Amazon's famous finding that every 100 ms of latency costs 1% of sales has been replicated across many contexts. If your analytics script adds 87 ms to every page load, it is not free — it has a measurable cost in conversions.

What we recommend

For most indie hackers and small teams

Use a Tier 1 or Tier 2 tool. The performance difference between these tools and GA4 is real and measurable. Unless you need a specific GA4 feature (Google Ads integration, enhanced e-commerce), there is no reason to load 45 KB of JavaScript on every page.

If you need revenue attribution, DataSaaS (4.8 KB) offers the best performance-to-functionality ratio — you get traffic-to-revenue tracking at roughly 1/10th the script weight of GA4.

If you need only basic pageview analytics, Plausible (0.8 KB) or Umami (2.1 KB) are the lightest options.

For teams that need session recordings

If you need heatmaps or session recordings, Hotjar (15.3 KB) is the lightest option. Consider loading it conditionally — only on pages where you actually need recording data, not site-wide.

For teams currently using GA4

Audit your GA4 usage. If you use fewer than 5 custom events and do not need Google Ads integration, you can almost certainly switch to a lighter tool without losing meaningful functionality — and gain 80+ ms of page speed improvement.

If you must keep GA4, consider loading it asynchronously and deferring it until after the page is interactive. This does not reduce the total bytes loaded, but it prevents GA4 from blocking your page render.

For teams using PostHog or Segment

These are legitimate tools for teams that use their full feature sets. If you are using PostHog only for pageview analytics, you are loading 82 KB of JavaScript for a feature that a 1 KB script can provide. Consider whether you actually use the session recording, feature flags, and A/B testing features. If not, switch to a lighter tool for analytics and add PostHog only when you need those additional capabilities.

Methodology notes and limitations

What we did not test:

• Performance under heavy concurrent load (all tests were single-user)
• Impact of ad blockers (some tools are blocked by default in popular ad blockers, which paradoxically improves page performance for those users)
• Long-term cookie/storage overhead
• Server-side processing load
• Second and subsequent page loads (with cached scripts)

Caveats:

• Script sizes change with updates. The numbers here are accurate as of March 2026 but may drift by a few KB over time.
• Some tools (PostHog, Segment) are configurable — you can reduce their footprint by disabling features you do not use. Our tests used default configurations.
• LCP impact varies based on page content, server location, and connection speed. Our numbers are specific to our test setup. Your results will be directionally similar but may differ in absolute terms.
• We are the makers of DataSaaS. We have tried to be fair and honest in this benchmark — DataSaaS ranks 4th, not 1st — but readers should be aware of this potential bias.

The bottom line

Analytics scripts are not free. They consume bandwidth, block rendering, and impact Core Web Vitals. The difference between the lightest option (Plausible, 0.8 KB) and the heaviest (PostHog, 82.6 KB) is a 100x factor in script size and a 50x factor in LCP impact.

For most websites, a Tier 1 or Tier 2 analytics tool provides all the data you need at a fraction of the performance cost. The days of accepting a 45 KB analytics script as the default are over — lighter alternatives exist, they work, and they give your visitors a faster experience.

Choose the lightest tool that covers your actual needs. If you need revenue attribution, that is DataSaaS at 4.8 KB. If you need only pageview analytics, Plausible at 0.8 KB. If you need the full Google Ads ecosystem, GA4 at 45.2 KB is the cost of doing business — but make sure you are actually using what you are paying for in page speed.

How script loading strategy affects results

The way you load an analytics script matters almost as much as its size. All tools in our test were loaded with the defer attribute, which is the recommended default. Here is how different loading strategies change the impact:

defer (recommended): The script downloads in parallel with HTML parsing and executes after the document is parsed. This is why LCP deltas in our test are relatively small — the script does not block rendering. All modern analytics tools recommend this approach.

async: The script downloads in parallel but executes as soon as it is ready, potentially interrupting HTML parsing. This can increase LCP impact by 20-40% compared to defer for heavier scripts. Some older GA4 installation guides recommend async, which is suboptimal.

No attribute (synchronous): The script blocks HTML parsing entirely while it downloads and executes. This is the worst case and can double or triple LCP impact. Never load analytics scripts synchronously.

Dynamic injection: Some tools (Segment, PostHog) dynamically inject additional scripts after the initial load. These secondary scripts do not affect LCP but can impact Total Blocking Time and Interaction to Next Paint (INP) if they execute heavy JavaScript on the main thread.

If you are using a heavier tool and cannot switch, ensure you are at minimum using defer. For GA4 specifically, switching from async to defer can recover 15-25 ms of LCP on typical pages.

---

Related reading:

• Revenue Attribution Analytics — how DataSaaS tracks revenue in a 4.8 KB script
• DataSaaS vs Google Analytics — feature comparison beyond script size
• How to Track Which Marketing Channel Drives Revenue — setup guide