This guide details the complete extension update flow, covering the standard update process, manual overrides, developer APIs, and the significant impact of enterprise policies.
The standard update cycle
Chrome is designed to automatically update installed extensions to their latest versions, ensuring users have access to new features and security fixes. By default, Chrome checks for extension updates on startup and every few hours.
A critical aspect of the update process is that an update is only installed when the extension is considered idle. For an extension to be idle, its components must not be in active use. In the context of Manifest V3, this primarily means that the extension's service worker is not running. The service worker is designed to be event-driven and terminates after a period of inactivity. Additionally, any open extension pages, such as side panel, popup, or an options page, prevents the extension from being considered idle. An active content script does not affect whether an extension is considered idle or not.
This idle requirement can cause delays in updates for frequently active extensions. If an extension's service worker is constantly being triggered by events, it may never reach an idle state, and the update will be deferred until the browser is restarted.
Monitor extension update distribution
To find out how many of your users are on the latest version of your extension, use the Chrome WebStore analytics dashboard. Go to the Chrome WebStore developer dashboard and select one of your published extensions. In the side navigation bar go to: Analytics -> Users and scroll down to the Daily users by item chart. Here you can see how many users are already on your latest version.
Update extensions manually
If users want to receive the latest updates immediately, Chrome provides a manual update mechanism. This is also a useful tool when testing updates.
Individual users can force an update for all their installed extensions by following these steps:
- Navigate to chrome://extensions.
- Enable Developer mode using the toggle in the top-right corner.
- Click the Update button that appears.
This action prompts Chrome to immediately fetch the latest versions of all installed extensions from the Chrome Web Store.
Check for updates from an Extension
The chrome.runtime API provides tools for extensions to interact with the update mechanism.
Check for updates on demand
The chrome.runtime.requestUpdateCheck() function lets an extension initiate an update check programmatically. This is particularly useful for extensions that have a critical dependency on a backend service and need to ensure they are running the latest compatible version.
When this function is called, Chrome queries the Chrome Web Store for a new version and downloads the new version if available. The function's callback receives a status indicating the result of the check.
Listen for available updates
The chrome.runtime.onUpdateAvailable event fires when an update has been downloaded and is ready to be installed. This event provides the new version number in its details. By listening for this event, an extension can determine an update is available and consider going idle or causing a reload by using chrome.runtime.reload() when appropriate.
The following code shows a basic implementation pattern:
In exceptional cases, it's possible to force the browser to check for an extension update using chrome.runtime.requestUpdateCheck():
It's important to note that frequent calls to requestUpdateCheck() will be throttled by the browser. Use this function only when you know an update is available. For example, when an updated backend requires a newer version of the extension.
Controlling updates via enterprise policy
In managed enterprise environments, the standard extension update flow is subject to policies set by system administrators. These policies can override the default behavior to enforce security and stability.
Force installation
The ExtensionInstallForcelist policy lets administrators silently install specific extensions for their users. Users cannot disable or uninstall extensions installed with this policy.
Pin extension version
However, enterprises often need to control the exact version of an extension being used to ensure compatibility with other software. To achieve this, administrators can "pin" an extension to a specific version. This is done through the Google Admin console, where an administrator can select the required version for an organizational unit. When an extension is pinned, Chrome will not update it beyond that specified version.
Override the update source
Enterprises can host their own forked versions of extensions for security or customization reasons. To do so, use the ExtensionSettings policy with the override_update_url property set to true. This forces Chrome to fetch the extension and its updates from a specified URL, rather than the Chrome Web Store.
Set a minimum Chrome version
You can specify a minimum_chrome_version in your extension's manifest file. This ensures that the extension is only installed on versions of Chrome that support the APIs it uses.
For new installations, the Chrome Web Store will prevent users on older versions of Chrome from installing the extension, displaying a "Not compatible" message. For existing users, if an update to an extension increases the minimum_chrome_version to a version higher than the user's installed Chrome version, they will silently stop receiving updates for that extension. Developers should be aware of this and inform users if a significant portion of their user base might be affected.