# How to get users on your new Chrome extension version faster

> Your fix is live on the Chrome Web Store, but users keep running the broken version for hours. Why browsers update extensions slowly, and how to ask installed copies to fetch the published version now, with a pilot first.

Canonical: https://extension.report/guides/get-users-on-new-extension-version-faster
Updated: 2026-11-21
Publisher: Extension Report (https://extension.report)

![A version published on the store reaches installed browsers after an update request, instead of waiting for the next periodic check.](https://extension.report/guides/get-users-on-new-extension-version-faster/cover.svg)

You shipped a bug. The fix passed review and the store shows the new version. Yet the errors keep coming, because most of your users still run the old one. Nothing is wrong with the store: browsers simply do not fetch extension updates the moment they are published.

This guide explains when a browser actually updates an extension, and how Extension Report's release update requests ask installed copies to check the store now, starting with a pilot group. It cannot make the store review faster. It shortens what comes after.

## In short

- Chrome checks for extension updates on startup and every few hours, and installs them when the extension is idle.
- An update request asks installed copies to check now, through the browser's own update mechanism.
- It only fetches a version the store already serves. It never ships code.
- Start with a 10% pilot, watch errors, then widen.

## Why your fix does not reach users right away

Two delays add up. First the store review: Chrome says most reviews finish within a few days but can take up to a few weeks, and Microsoft gives up to seven business days for an Edge update. Nobody can shorten that part for you.

Then the browser. Chrome checks for extension updates on startup and every few hours. When it finds one, it installs it only once the extension is idle, which in Manifest V3 mostly means the service worker is not running. If the worker never goes idle, the update waits until the browser restarts.

![Two timelines after the store publishes a fix. Without a request, the browser finds it at its next periodic check, hours later, and installs it when the extension is idle. With a request, the SDK asks the browser to check at its next configuration refresh, the update is found and applied, and the new version reports back.](https://extension.report/guides/get-users-on-new-extension-version-faster/update-timeline.svg)

_The store review is the same in both cases. The wait after it is not._

## How a release update request works

The browser already has everything needed to update an extension on demand. Chrome and Edge expose `runtime.requestUpdateCheck()`, and Chrome, Edge and Firefox fire `runtime.onUpdateAvailable` once a new version is downloaded. What is missing is someone telling the installed copies that now is the time. That is the request.

![Flow: the store publishes version 1.4.2. In Extension Report's Releases screen, the owner sends an update request to a 10% pilot. Installed copies read it at their next configuration refresh. On Chrome and Edge the SDK calls runtime.requestUpdateCheck once. The browser downloads the update and fires onUpdateAvailable. The extension reloads if allowed, or the browser applies it when idle. Version 1.4.2 starts and reports back as applied.](https://extension.report/guides/get-users-on-new-extension-version-faster/update-request-flow.svg)

_Every step uses the browser's own update mechanism and the store's own package._

1. The store publishes the new version. Extension Report reads it from your connected store listing.
2. In Releases, you choose that version, an audience (10% pilot, 25%, or all eligible installations) and what happens once the update is downloaded. A coding agent connected through MCP can do the same with `request_release_update`.
3. Installed copies running SDK 0.6.7 or later, with the option enabled, read the request a few seconds after they next send events: creating or stopping a request changes the project's configuration version, and the SDK reloads its configuration as soon as an ingestion response carries a new version. A copy that is idle reads it at its next wake that sends an event (browser start, user action, or the daily heartbeat).
4. On Chrome and Edge, the SDK calls `runtime.requestUpdateCheck()` once for that request. The browser answers that an update is available, that there is none, or that the check is throttled.
5. When the browser has downloaded the update, it fires `runtime.onUpdateAvailable`. Depending on your choice, the SDK reloads the extension to apply it, or lets the browser apply it when the extension is idle.
6. The new version starts and reports back. The request shows how many installations it reached, how many checks started, how many packages are ready, and how many are confirmed on the new version, with the exceptions (no update offered, check limited by the browser, reload deferred, error).

## Set it up

Release update requests are opt-in. Enable them in the background, with SDK 0.6.9 or any version from 0.6.7. The WXT and Plasmo helpers take the same option.

background.ts:

```ts
// background.ts
import { initExtensionReport } from "@extension-report/js";

let exportInProgress = false; // your own "busy" state

export const sdk = initExtensionReport({
  projectPublicKey: "pk_er_...",
  releaseUpdates: {
    enabled: true,
    // Asked before a requested reload. Return false to defer it: the SDK
    // reports "deferred" and asks again at a later configuration refresh.
    canReload: () => !exportInProgress,
  },
});
```

- Link the store in Extension Report. Chrome needs the Chrome Web Store connection, which you approve once with Google in Settings. Edge and Firefox use the public listing.
- Publish the next version as usual. Requests only exist for a version the store currently serves: Extension Report reads it from the store, so you cannot request a version that is not published.
- Requests reach installations that have this option in their build. The first release that enables it reaches users the normal way.

## What happens on each browser

| Browser | What the request does |
| --- | --- |
| Chrome, Edge | Calls `runtime.requestUpdateCheck()` once per request and installation. You choose: let the browser apply the update when idle, or reload the extension as soon as it is downloaded. |
| Firefox | Firefox checks for updates on its own. Once it has downloaded the new version, the request reloads the extension to apply it. |
| Safari | Not supported. Safari extensions update with their containing app. |

## Pilot first, then widen

![The Accelerate rollout dialog in Extension Report with fictional numbers: published release Chrome v1.4.2, 1,840 eligible installations seen in the last 7 days, the audience set to a 10% pilot, and the choice between letting the browser apply the update and reloading the extension.](https://extension.report/guides/get-users-on-new-extension-version-faster/release-update-dialog.webp)

_Requesting an update for a published Chrome version (fictional numbers)._

The same steps, done by your agent through MCP:

```text
get_release_updates({ projectId })   // published versions you can target, eligible installations
request_release_update({ projectId, browser: "chrome", version: "1.4.2", mode: "check", rollout: 10 })
get_release_updates({ projectId })   // progress of the pilot: applied, deferred, errors
stop_release_update({ projectId, requestId })   // then a wider request, rollout 25 or 100
```

Each installation falls in or out of the audience by a stable hash of its id and the request, so a 10% pilot is the same 10% for the whole request. Watch the request's progress and the errors of the new version, then send a wider request once the pilot has expired or been cancelled.

- One active request per browser at a time. A request expires after 24 hours, and you can cancel it earlier.
- Development installs and installations where the user turned telemetry off never take part.
- If the store itself is rolling the version out to part of its users, the dialog says so: a browser outside the store's rollout finds no update.

## Limits, stated plainly

- **It does not skip the store review.** The version must be published first.
- **It does not ship code.** Manifest V3 forbids remotely hosted code, and this feature does not need any: the browser installs the store's package.
- **It needs the copy to be awake.** An active copy sees the request seconds after its next events. An idle one sees it at its next wake, and a browser that stays closed sees it later. Chrome may also refuse an on-demand check (it reports `throttled`); the update then waits for the browser's own periodic check.
- **The browser has the last word.** Chrome and Edge can throttle update checks, and the request reports it.
- **A reload interrupts.** It can close an open popup or stop work in progress. Use `canReload`, or let the browser apply the update when idle.

> **Why not call requestUpdateCheck yourself?** Chrome's documentation says most extensions should not, because the browser already checks every few hours. A request calls it once, only when you decide a published version matters, and only for the audience you chose.

## Do it with your AI agent

Paste the request below into Claude Code, Codex or Cursor. Your agent connects to Extension Report through MCP, creates your account and the project, installs the SDK in your code and checks that events arrive. You sign in once and approve access. Extension Report never sees your code: the agent edits it on your machine.

Request to paste:

> Add Extension Report to this extension with release update requests enabled (releaseUpdates: { enabled: true }), and a canReload guard if the extension does long-running work. Follow https://extension.report/docs/agents.txt.

Connect the MCP server (https://mcp.extension.report):

```bash
claude mcp add --transport http extension-report https://mcp.extension.report
codex mcp add extension-report --url https://mcp.extension.report
```

Agent playbook: https://extension.report/docs/agents (text: https://extension.report/docs/agents.txt)

Or set it up yourself: https://extension.report/auth. Free plan: 1 extension, 1,000 monthly active users, 30-day history.

## Sources

- [Chrome for Developers: The extension update lifecycle](https://developer.chrome.com/docs/extensions/develop/concepts/extensions-update-lifecycle)
- [Chrome for Developers: runtime.requestUpdateCheck and onUpdateAvailable](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-requestUpdateCheck)
- [Chrome Web Store: review process](https://developer.chrome.com/docs/webstore/review-process)
- [Microsoft Edge: Update a Microsoft Edge extension](https://learn.microsoft.com/en-us/microsoft-edge/extensions/update/update-extension)
- [Chrome for Developers: Improve extension security (remotely hosted code)](https://developer.chrome.com/docs/extensions/develop/migrate/remote-hosted-code)

## Related guides

- [How to monitor errors in a browser extension in production](https://extension.report/guides/browser-extension-error-monitoring.md)
- [How to track browser extension uninstalls and ask users why they left](https://extension.report/guides/track-browser-extension-uninstalls.md)
- [How to add analytics to a Manifest V3 extension (and why Google Analytics breaks)](https://extension.report/guides/analytics-manifest-v3-extension.md)
