Service Worker API

This is an experimental technology
Because this technology's specification has not stabilized, check the compatibility table for the proper prefixes to use in various browsers. Also note that the syntax and behavior of an experimental technology is subject to change in future versions of browsers as the spec changes.

Service workers essentially act as proxy servers that sit between web applications, and the browser and network (when available.) They are intended to (amongst other things) enable the creation of effective offline experiences, intercepting network requests and taking appropriate action based on whether the network is available and updated assets reside on the server. They will also allow access to push notifications and background sync APIs.

Service worker concepts and usage

A service worker is an event-driven worker registered against an origin and a path. It takes the form of a JavaScript file that can control the web page/site it is associated with, intercepting and modifying navigation and resource requests, and caching resources in a very granular fashion to give you complete control over how your app behaves in certain situations (the most obvious one being when the network is not available.)

A service worker is run in a worker context: it therefore has no DOM access, and runs on a different thread to the main JavaScript that powers your app, so it is not blocking. It is designed to be fully async; as a consequence, APIs such as synchronous XHR and localStorage can't be used inside a service worker.

Service workers only run over HTTPS, for security reasons. Having modified network requests wide open to man in the middle attacks would be really bad.

Note: Service Workers win over previous attempts in this area such as AppCache because they don't make assumptions about what you are trying to do and then break when those assumptions are not exactly right; you have granular control over everything.

Note: Service workers make heavy use of promises, as generally they will wait for responses to come through, after which they will respond with a success or failure action. The promises architecture is ideal for this.


A service worker is first registered using the ServiceWorkerContainer.register() method. If successful, your service worker will be downloaded to the client and attempt installation/activation (see below) for URLs accessed by the user inside the whole origin, or inside a subset specified by you.

Download, install and activate

At this point, your service worker will observe the following lifecycle:

  1. Download
  2. Install
  3. Activate

The service worker is immediately downloaded when a user first accesses a server worker–controlled site/page.

After that it is downloaded every 24 hours or so. It *may* be downloaded more frequently, but it must be downloaded every 24h to prevent bad scripts from being annoying for too long.

Installation is attempted when the downloaded file is found to be new — either different to an existing service worker (byte-wise compared), or the first service worker encountered for this page/site.

If this is the first time a service worker has been made available, installation is attempted, then after a successful installation it is activated.

If there is an existing service worker available, the new version is installed in the background, but not yet activated — at this point it is called the worker in waiting. It is only activated when there are no longer any pages loaded that are still using the old service worker. As soon as there are no more such pages still loaded, the new service worker activates (becoming the active worker).

You can listen out for the InstallEvent; a standard action is to prepare your service worker for usage when this fires, for example by creating a cache using the built in storage API, and placing assets inside it that you'll want for running your app offline.

There is also an activate event. The point where this event fires is generally a good time to clean up old caches and other things associated with the previous version of your service worker.

Your service worker can respond to requests using the FetchEvent event. You can modify the response to these requests in any way you want, using the FetchEvent.respondWith method.

Note: Because oninstall/onactivate could take a while to complete, the service worker spec provides a waitUntil method that, when called oninstall or onactivate, passes a promise. Functional events are not dispatched to the service worker until the promise successfully resolves.

For a complete tutorial to show how to build up your first basic example, read Using Service Workers.

Other use case ideas

Service workers are also intended to be used for such things as:

  • Background data synchronization
  • Responding to resource requests from other origins
  • Receiving centralized updates to expensive-to-calculate data such as geolocation or gyroscope, so multiple pages can make use of one set of data
  • Client-side compiling and dependency management of CoffeeScript, less, CJS/AMD modules, etc. for dev purposes
  • Hooks for background services
  • Custom templating based on certain URL patterns
  • Performance enhancements, for example pre-fetching resources that the user is likely to need in the near future, such as the new few pictures in a photo album.

In the future, service workers will be able to do a number of other useful things for the web platform that will bring it closer towards native app viability. Interestingly, other specifications can and will start to make use of the service worker context, for example:

  • Background synchronization: Start up a service worker even when no users are at the site, so caches can be updated, etc.
  • Reacting to push messages: Start up a service worker to send users a message to tell them new content is available.
  • Reacting to a particular time & date
  • Entering a geo-fence


Represents the storage for Request / Response object pairs that are cached as part of the ServiceWorker life cycle.
Represents the storage for Cache objects. It provides a master directory of all the named caches that a ServiceWorker can access and maintains a mapping of string names to corresponding Cache objects.
Represents the scope of a service worker client. A service worker client is either a document in a browser context or a SharedWorker, which is controlled by an active worker.
Represents a container for a list of Client objects; the main way to access the active service worker clients at the current origin.
Extends the lifetime of the install and activate events dispatched on the ServiceWorkerGlobalScope as part of the service worker lifecycle. This ensures that any functional events (like FetchEvent) are not dispatched to the ServiceWorker until it upgrades database schemas, deletes outdated cache entries, etc.
The parameter passed into the ServiceWorkerGlobalScope.onfetch handler, FetchEvent represents a fetch action that is dispatched on the ServiceWorkerGlobalScope of a ServiceWorker. It contains information about the request and resulting response, and provides the FetchEvent.respondWith() method, which allows us to provide an arbitrary response back to the controlled page.
The parameter passed into the oninstall handler, the InstallEvent interface represents an install action that is dispatched on the ServiceWorkerGlobalScope of a ServiceWorker. As a child of ExtendableEvent, it ensures that functional events such as FetchEvent are not dispatched during installation. 
Returns a ServiceWorkerContainer object, which provides access to registration, removal, upgrade, and communication with the ServiceWorker objects for the associated document.
The parameter passed into the onnotificationclick handler, the NotificationEvent interface represents a notification click event that is dispatched on the ServiceWorkerGlobalScope of a ServiceWorker.

The parameter passed into the sync handler, the SyncEvent interface represents a periodic sync action that is dispatched on the ServiceWorkerGlobalScope of a ServiceWorker. 

Provides an interface for registering and retrieving PeriodicSyncRegistration objects.
Provides an object for managing periodic background synchronization. 
Represents a service worker. Multiple browsing contexts (e.g. pages, workers, etc.) can be associated with the same ServiceWorker object.
Provides an object representing the service worker as an overall unit in the network ecosystem, including facilities to register, unregister and update service workers, and access the state of service workers and their registrations.
Represents the global execution context of a service worker.
Contains information about an event sent to a navigator.serviceWorker target. 
Represents a service worker registration.

The parameter passed into the sync handler, the SyncEvent interface represents a sync action that is dispatched on the ServiceWorkerGlobalScope of a ServiceWorker. 

Provides an interface for registering and retrieving SyncRegistration objects.
Provides an object for managing background synchronization. 
Represents the scope of a service worker client that is a document in a browser context, controlled by an active worker. This is a special type of Client object, with some additional methods and properties available.


Specification Status Comment
Service Workers Working Draft Initial definition.

Browser compatibility

Feature Chrome Firefox (Gecko) Internet Explorer Opera Safari (WebKit)


33.0 (33.0) Not supported 24 Not supported
install/activate events 40.0 33.0 (33.0) Not supported (Yes) Not supported
fetch event/request/
40.0 33.0 (33.0) Not supported Not supported Not supported


41.0 (41.0) Not supported Not supported Not supported
Feature Android Chrome Mobile Firefox Mobile (Gecko) Firefox OS IE Phone Opera Mobile Safari Mobile
Not supported 40.0 (Yes) (Yes) Not supported (Yes) Not supported
 install/activate events Not supported 40.0 (Yes) (Yes) Not supported (Yes) Not supported
fetch event/request/
Not supported 40.0 (Yes) (Yes) Not supported Not supported Not supported
caches/cache Not supported 40.0 (Yes) (Yes) Not supported Not supported Not supported


Service Workers features are currently hidden behind a pref in many cases (Chrome now enables some of it by default.) To enable them:

  • Firefox Nightly: Go to about:config and set dom.serviceWorkers.enabled to true; restart browser. In Firefox you can also disable https-only checks by setting dom.serviceWorkers.testing.enabled to true. In the future we’ll likely have a whole slew of preferences that need enabling to access things like the fetch() API (XHR replacement) and other features. But for now this will get you access to the features included so far.
  • Chrome Canary: Go to chrome://flags and turn on experimental-web-platform-features; restart browser. enable-service-worker-sync is also available in Chrome if you want to play with background sync for service workers.
  • Opera: Go to opera://flags and enable Support for ServiceWorker; restart browser.

Note: You can find special service worker builds of Firefox with service workers enabled by default, and nascent features available that aren't yet available in Nightly.

Note: For backwards compatibility, you could choose to use service workers and AppCache on the same web app to do equivalent things (if the AppCache will support doing those things, of course.) What happens in such a case is that browsers that don’t support Service Workers will use AppCache, and those that do will ignore the AppCache and let the service worker take over.

See also

Document Tags and Contributors

Contributors to this page: jpmedley, chrisdavidmills, teoli, rassoodock, fscholz, Meggin
Last updated by: jpmedley,