Skip to content

Chrome Extension Free-to-Paid Conversion: How to Measure It

6 min readModerok team

Chrome extension free-to-paid conversion: why the Web Store cannot report it, and how to instrument the upgrade funnel and compute the rate yourself.

Nothing in the Chrome Web Store gives you a free-to-paid conversion rate. The store's own metrics page says the Users stats only captures installations; it doesn't monitor whether users are active or not, and that Chrome Web Store grants you access only to non user-level data. Your billing provider knows who paid, but not how many free installs sat behind them. To measure chrome extension free-to-paid conversion you have to emit funnel events from inside the extension, tie payments to an id your own code creates, and divide inside a cohort instead of across all time.

TL;DR: Installs to date is the wrong denominator. Pick a cohort (installs in one week) and a window (upgrades within 30 days), instrument four events in the extension (paywall_viewed, upgrade_clicked, checkout_opened, license_activated), generate your own UUID in chrome.storage.local and pass it to checkout so billing can be joined back, and keep personal data out of event properties.

Why the Chrome Web Store cannot give you this number

Four systems hold pieces of this funnel, and no single one of them holds both halves of the ratio.

Where it livesWhat it reportsWhere to check
Web Store developer dashboardA daily install report and daily uninstalls analytics, with breakouts by country, language and operating system; weekly user retention, also by item version; impressionsChrome Web Store metrics
The store's opt-in analytics integrationStore item metrics, and only "non user-level data"Chrome Web Store metrics
Your billing providerSubscriptions, payments and refunds keyed to a billing customerYour provider's dashboard
Events you send from the extensionWhatever you instrument: paywall shown, upgrade clicked, license activatedYour analytics

The store cannot see inside your extension, so the join happens in your own data.

Pick the denominator before you write any code

The easy number to reach for is paying customers today divided by installs to date. It mixes windows: the store publishes a daily install report and daily uninstalls analytics, while your subscription count is a running total. What each store number actually counts is in how many users does my Chrome extension have.

Two denominators are defensible, and they answer different questions:

  • Install cohort conversion. Of the profiles that installed in one week, how many had an active subscription at the end of a window you pick (30 days suits a monthly plan)? Track this over releases: it is the same measurement every week.
  • Paywall conversion. Of the profiles that saw your upgrade screen, how many paid? This isolates pricing and copy from discovery and onboarding.

Publish one, label it with the cohort and window, and do not mix them.

The four events that make the funnel legible

Give every step its own event name. Counting happens at the name level, so one upgrade event with a step property reads worse than four named events. The SDK has no message bus, so keep every track() call in the background service worker and forward UI steps with chrome.runtime.sendMessage, which is the documented pattern:

// background.js
import { Moderok } from "@moderok/sdk";

Moderok.init({ appKey: "mk_your_app_key_here" });

// The popup sends { type: "track", name, props } via chrome.runtime.sendMessage
chrome.runtime.onMessage.addListener((msg) => {
  if (msg?.type !== "track") return;
  Moderok.track(msg.name, msg.props);
});

// The four steps:
// paywall_viewed     { surface: "popup", trigger: "quota_reached" }
// upgrade_clicked    { plan: "pro_monthly", surface: "popup" }
// checkout_opened    { plan: "pro_monthly" }
// license_activated  { plan: "pro_monthly", days_since_install: 6 }   // example values

Properties must be flat: a string, a number or a boolean. Nested objects, arrays and null are dropped on the way out, documented under events and properties. Avoid the five names the SDK already sends automatically, __first_open, __install, __update, __daily_ping and __error: nothing stops you, but your reports stop making sense.

Carrying an id from the extension to checkout

The join key has to be something you control on both sides. Generate it yourself, persist it, and send it to checkout as a query parameter:

// background.js
async function licenseRef() {
  const stored = await chrome.storage.local.get("licenseRef");
  if (stored.licenseRef) return stored.licenseRef;
  const next = crypto.randomUUID();
  await chrome.storage.local.set({ licenseRef: next });
  return next;
}

async function openCheckout(plan) {
  const ref = await licenseRef();
  Moderok.track("checkout_opened", { plan });
  await chrome.tabs.create({ url: `https://example.com/upgrade?plan=${plan}&ref=${ref}` });
}

MDN notes that crypto.randomUUID() is available in Web Workers and only in secure contexts; the SDK calls it when present and falls back to a generated id. Two notes on identity:

  • Keep your own ref. The Moderok SDK does not expose its anonymous profile id: no method on the Moderok object returns it, and the methods you get are init, track, flush, shutdown, isInitialized, captureError and captureLastError. Analytics ids are for counting, billing refs are for joining.
  • Keep the customer's email, name and license key out of your event properties: they are only what you pass into track() (privacy). Error capture is on by default, so check what your exception messages carry too.

MV3 details that quietly break the funnel

Your worker is probably not alive when the payment completes. Chrome's lifecycle docs put the idle timeout at "After 30 seconds of inactivity", and the checkout tab is a separate page that does not keep your extension running. An incoming message can revive a dormant worker, but a thank-you page that fails to reach your extension loses the step silently. The durable place to report license_activated is the next service worker start that verifies the license, with a guard:

const { upgradeReported } = await chrome.storage.local.get("upgradeReported");
if (license.active && !upgradeReported) {
  Moderok.track("license_activated", { plan: license.plan });
  await chrome.storage.local.set({ upgradeReported: true });
}

Without the flag, every worker startup re-reports the activation and the count climbs on its own.

Nothing here is guaranteed delivery. The queue is capped and debounced, and retryable failures are persisted and retried with backoff, which is not the same as never losing an event. Treat these event counts as relative step sizes, not as a ledger. Your billing provider is the ledger.

A profile is not a person. One developer with a work profile and a personal profile is two free users and at most one payer, which drags the measured rate down. The analytics id can also recover through browser sync after a profile reset, so it is more stable than chrome.storage.local alone, not closer to being a human.

Computing a chrome extension free-to-paid conversion rate

Both halves of the ratio come out of systems you own, not out of the event funnel:

  • Denominator. Installs during the cohort week, from the store's daily install report or from your own install events.
  • Numerator. Subscriptions in your billing data whose ref your server first saw during that same week. Record first-seen when the extension first calls your license endpoint: that is the one place the ref and a date sit together.
conversion = refs with a paid subscription within N days of first being seen
           / refs first seen during the cohort week

Your event counts do the job in between: daily counts per event name, so paywall_viewed against upgrade_clicked against checkout_opened shows which step leaks, while the paid number stays in billing where it is exact. Keep the same window on both halves, use whole weeks, and stamp days in UTC so a traveller cannot land in two cohorts.

After the sale, watch the other direction

Conversion without churn is half a picture, and the half that flatters you. Uninstall tracking sets chrome.runtime.setUninstallURL() so a removal can be attributed to the same anonymous profile, but Chrome reports it by opening that URL in a tab, and the docs list what never arrives: an offline browser, an uninstalled Chrome or deleted profile, a managed Chromebook wiping its profile at sign-out, and an admin policy removal. So the uninstalls number is a floor. Paired with uninstalls by tenure, it tells you whether the people leaving are day-one triers or month-three subscribers. There is more on reading that number in Chrome extension uninstall rate.

Moderok sends first-open, install, update and daily activity events without you wiring them up, takes the four funnel events above as custom events with flat properties, and attributes uninstalls once you turn trackUninstalls on. See what Moderok measures.