If you've searched for "Chrome extension analytics" you've seen the same six product pages a dozen times, and none of them say what the tradeoff actually is for an extension. Most of these tools were built for websites. A couple were built for mobile apps. One — ours — was built for extensions. Below is the honest version of who fits where, what breaks in Manifest V3, and which tool to pick depending on what you actually need to learn from your extension.
The criteria that actually matter
Before we get into tools, here's the rubric we're using. Every "chrome extension analytics" tool can do basic events; the differences hide in the constraints below.
- MV3-compliant SDK. No remotely-loaded code, no
document.write, no eval. Must be bundled and small enough not to hurt cold-start time. - Survives service-worker termination. Chrome kills the background worker after about 30 seconds idle. Any tool that batches events in memory and flushes on a JS timer drops a large share of real-world traffic. Reliable tracking needs storage-backed queueing and
chrome.alarms-driven flushing. - Native install & uninstall. Plumbing for
chrome.runtime.onInstalledandchrome.runtime.setUninstallURLout of the box, not an exercise left to the user. - Retention & cohort model. D1/D7/D30 retention anchored to install date — not web-session-based retention.
- Privacy-respecting defaults. No URL collection from content scripts by default, IP truncation, anonymous IDs, per-user delete. (We wrote a longer piece on privacy-first extension analytics if you want to dig in.)
- Chrome Web Store policy fit. Doesn't structurally push you toward disclosures that'll get the listing flagged.
- Price for the indie / small-team case. Most extensions don't need an enterprise tier; the question is whether the free tier is honest.
TL;DR — which tool fits which use case
- You want extension-native KPIs (installs, uninstalls, retention, errors) with minimal setup → Crxlytics.
- You want a simple, privacy-leaning event count and will skip retention/uninstalls → Aptabase.
- You already use PostHog company-wide and accept some MV3 plumbing work → PostHog.
- You're doing deep product analytics on a paid extension with budget → Mixpanel or Amplitude, but you'll write the MV3 transport layer yourself.
- You only want to count active users, lightly → Plausible / Fathom, with caveats.
- You're thinking about GA4 → don't, unless it's the only thing your team can support.
Crxlytics
Built for: Chrome (and Chromium) extensions specifically. Manifest V3 from day one.
Disclosure: this is our product, so take the framing with that in mind — but the technical specifics are easy to verify. Crxlytics is a ~5 KB bundled SDK that does the MV3 plumbing for you: persistent event queue in chrome.storage, flushes via chrome.alarms so it survives service worker termination, install attribution from chrome.runtime.onInstalled, uninstall capture wired to setUninstallURL with a single snippet. The dashboard shows installs, DAU/WAU/MAU, retention cohorts, feature usage, error rates, uninstalls (with last-action and last-domain context), and per-version rollout health.
Pros: install/uninstall/retention work without configuration. Privacy defaults are conservative — no URL collection from content scripts, anonymous IDs only, strict event schema. Free tier covers most indie extensions.
Cons: not a general-purpose product analytics tool — it won't replace Mixpanel for a web app team. Younger project than the established names, so the ecosystem is smaller. No session replay (intentional).
Best for: almost every Chrome extension team that wants the KPIs that matter without writing infrastructure.
Aptabase
Built for: mobile and desktop apps, with a community-contributed Chrome extension wrapper.
Aptabase is privacy-first lightweight analytics, originally for Tauri / Electron / Flutter apps. The Chrome extension support exists but is shallower than the app-store integrations. You'll get event counts, country breakdown, and active users — but no native install/uninstall handling, no install attribution, no retention cohorts in the same shape an extension team usually wants.
Pros: very privacy-leaning, simple to set up, EU/self-hosted options.
Cons: built for apps, not extensions. The gaps (no uninstall, no setUninstallURL helper, no extension-version rollout view) are not closing.
Best for: developers who already use Aptabase for an app and want a single dashboard, accepting that extension-specific metrics will be missing. We compared the two in detail in the Aptabase alternative write-up.
PostHog
Built for: SaaS product analytics. Web first, with an extension JS SDK that mostly works.
PostHog is the obvious pick if your team already uses it company-wide. The JS SDK can run inside an extension popup or service worker if you configure it carefully — disable autocapture, drop session recording, switch to manual flush. With that setup, you'll get events, funnels, feature flags, and cohorts. You'll also write a small amount of MV3-aware plumbing for queueing and uninstall capture, because none of it is on by default.
Pros: rich feature set, feature flags + A/B testing in the same product, generous free tier, self-host option for compliance-sensitive shops.
Cons: SDK is bigger than what most extensions want shipped (~40 KB+ depending on options), and you have to actively turn off the auto-capture / replay features that are unsafe in an extension context. Install/uninstall and retention by install-date need custom work.
Best for: teams already on PostHog who want one dashboard for web + extension and can spend a day on the integration.
Mixpanel
Built for: deep product analytics for web and mobile.
Mixpanel's funnels, segmentation, and retention reports are still best-in-class. None of that is built with extensions in mind. The web SDK can be used, but you'll fight the auto-tracking defaults, write your own queue for service worker termination, and bring your own install/uninstall bookkeeping. The reports are powerful once data is flowing correctly, but getting there takes effort and Mixpanel won't meet you halfway.
Pros: mature analysis tooling, generous free tier for low MTU counts.
Cons: no extension-aware features, expensive as users grow, larger SDK than ideal for extension cold-start.
Best for: paid extensions with a strong PMF signal that need real funnel analysis and have engineering capacity to build the MV3 transport layer.
Amplitude
Built for: enterprise product analytics.
Same story as Mixpanel, with a heavier sales motion and an even broader analysis surface. The free tier is real for small teams but the value compounds at scale — most extension teams aren't at that scale. SDK constraints are similar: web and mobile first, extension support is "technically possible."
Pros: dashboards and analyses you can't easily reproduce elsewhere; strong cohort + retention model.
Cons: overkill for almost every extension; no MV3-specific support; high friction once you outgrow the free tier.
Best for: extensions inside a larger product that already runs on Amplitude.
Plausible & Fathom
Built for: privacy-friendly website analytics.
Both are excellent for what they are — lightweight, cookieless website counters. People sometimes drop them into an extension popup and call it "extension analytics." What you get is a count of popup opens, basically. No installs, no uninstalls, no retention, no feature usage, no errors.
Pros: tiny, privacy-respecting, straightforward pricing.
Cons: not designed for extensions; the questions you can answer are very limited.
Best for: a fast pulse check on whether anyone opens the popup, nothing more.
Google Analytics 4
Built for: websites. Adapted, awkwardly, to apps.
The default first attempt that almost everyone abandons. The full breakdown is in our Google Analytics for Chrome extensions post, but the short version: gtag.js is banned by MV3, the Measurement Protocol works as a raw pipe but doesn't fix any of the underlying issues, the data model misattributes extension contexts to web pages, and the URL-from-content-script pattern creates real Chrome Web Store policy risk.
Best for: nothing, in the extension context. Use anything else on this list.
Building your own
Worth considering if you genuinely want full control and have an engineering team that wants to own the data pipeline. The components you'll need:
- A bundled SDK with a storage-backed queue (we wrote about why this matters in the service worker keeps stopping piece).
- An ingest endpoint with strict schema validation and IP truncation.
- Aggregation jobs for DAU/WAU/MAU, retention cohorts, and churn.
- A dashboard your non-engineering co-founder can read.
- Privacy paperwork: data processing addendum, retention policy, deletion API.
Doable. Not cheap. Worth it only if extension analytics is somehow core to your product, not a measurement layer.
How to choose, in 30 seconds
- Do you need install / uninstall / retention out of the box? If yes → Crxlytics. Every other tool will have you wiring it manually.
- Are you already running PostHog company-wide? If yes → PostHog with manual MV3 plumbing.
- Is your extension inside a larger Mixpanel / Amplitude org? If yes → use that, knowing the extension-specific gaps will need custom work.
- Do you just want a popup-open counter? Plausible / Fathom is fine.
- None of the above? Default to Crxlytics — it's the smallest delta from "no analytics" to "the right KPIs."
FAQ
What's the single most important feature in a Chrome extension analytics tool?
Surviving service-worker termination without dropping events. Everything else is moot if half your events never arrive. That requires storage-backed queueing and chrome.alarms-driven flushing — a tool that doesn't do this is undercounting silently.
Can I use Mixpanel or Amplitude in a Chrome extension?
Yes, but you'll write a meaningful amount of glue code: disable autocapture, build your own queue, layer your own install/uninstall bookkeeping on top, manage the cold-start SDK size. Worth it for an extension inside a larger product that's already on these platforms; rarely worth it standalone.
Is Aptabase or Crxlytics better for a Chrome extension?
Aptabase is excellent at being a privacy-leaning lightweight event counter for desktop/mobile apps. Crxlytics is designed end-to-end for extensions specifically — installs, uninstalls, retention, and rollout health work without setup. If extension-specific KPIs are what you care about, Crxlytics is the closer fit. We have a longer comparison at Aptabase alternative.
What about session replay or heatmaps in an extension?
Practically, avoid both. Replay in an extension context will almost certainly capture content from third-party sites (via content scripts) and is a Chrome Web Store review hazard. Heatmaps don't translate to extension UI in a useful way. If you genuinely need a recording, scope it to popup interactions and gate it behind explicit user consent.
How much do these tools usually cost?
Most have a free tier that covers an indie extension. Costs scale with monthly active users (Mixpanel, Amplitude), ingested events (PostHog), or active extensions (Crxlytics). For a 10k–100k MAU extension you're typically looking at $0–$100/month for purpose-built tools, and $100–$1000+/month for the enterprise general-purpose products.