The Push API enables sending of a push message to a webapp via a push service. An application server can send a push message at any time, even when a webapp or user agent is inactive. The push service ensures reliable and efficient delivery to the user agent. Push messages are delivered to a Service Worker that runs in the origin of the webapp, which can use the information in the message to update local state or display a notification to the user.

This specification is designed for use with the web push protocol, which describes how an application server or user agent interacts with a push service.

This specification defines conformance criteria that apply to a single product: the user agent that implements the interfaces that it contains.

Implementations that use ECMAScript to implement the APIs defined in this specification MUST implement them in a manner consistent with the ECMAScript Bindings defined in the Web IDL specification [[!WEBIDL]].

Dependencies

The terms current settings object, event handler, event handler event type, fire a simple event, queue a task and trusted event are defined in [[!HTML51]].

Promise, and JSON.parse are defined in [[!ECMASCRIPT]].

EventInit, DOMException, AbortError, InvalidStateError, InvalidAccessError, InvalidCharacterError, SecurityError, NetworkError, event listener, and steps for constructing events are defined in [[!DOM]].

The terms service worker, service worker registration, installing worker, waiting worker, and active worker, and the types ServiceWorkerRegistration, ServiceWorkerGlobalScope, ExtendableEvent, ExtendableEventInit, extend lifetime promises, the Clear Registration algorithm, and the Handle Functional Event algorithm are defined in [[!SERVICE-WORKERS]].

The term secure context is defined in [[!POWERFUL-FEATURES]].

The algorithms utf-8 encode, and utf-8 decode are defined in [[!ENCODING]].

Blob is defined in [[!FILEAPI]].

Any, ArrayBuffer, BufferSource, DOMString, NotAllowedError, and USVString are defined in [[!WEBIDL]].

The web push protocol [[!WEBPUSH-PROTOCOL]] describes a protocol that enables communication between a user agent or application server and a push service. Alternative protocols could be used in place of this protocol, but this specification assumes the use of this protocol; alternative protocols are expected to provide compatible semantics.

Concepts

Security and privacy considerations

User agents MUST NOT provide Push API access to webapps without the express permission of the user. User agents MUST acquire consent for permission through a user interface for each call to the subscribe() method, unless a previous permission grant has been persisted, or a prearranged trust relationship applies. Permissions that are preserved beyond the current browsing session MUST be revocable.

The user agent MAY consider the PushSubscriptionOptions when acquiring permission or determining the permission status.

When a permission is revoked, the user agent MAY fire the pushsubscriptionchange event for subscriptions created with that permission, with the service worker registration associated with the push subscription as registration, a PushSubscription instance representing the push subscription as oldSubscription, and null as newSubscription. The user agent MUST deactivate the affected subscriptions in parallel.

When a service worker registration is unregistered, any associated push subscription MUST be deactivated.

The push endpoint of a deactivated push subscription MUST NOT be reused for a new push subscription. This prevents the creation of a persistent identifier that the user cannot remove. This also prevents reuse of the details of one push subscription to send push messages to another push subscription.

User agents MUST implement the Push API to only be available in secure contexts. This provides better protection for the user against man-in-the-middle attacks intended to obtain push subscription data. Browsers may ignore this rule for development purposes only.

Extensions to the ServiceWorkerRegistration Interface

The Service Worker specification defines a ServiceWorkerRegistration interface [[!SERVICE-WORKERS]], which this specification extends.

        partial interface ServiceWorkerRegistration {
          readonly attribute PushManager pushManager;
        };
      

The pushManager attribute exposes a PushManager, which has an associated service worker registration represented by the ServiceWorkerRegistration on which the attribute is exposed.

PushManager interface

The PushManager interface defines the operations to access push services.

        interface PushManager {
          Promise<PushSubscription> subscribe(optional PushSubscriptionOptionsInit options);
          Promise<PushSubscription?> getSubscription();
          Promise<PushPermissionState> permissionState(optional PushSubscriptionOptionsInit options);
        };
      

The subscribe method when invoked MUST run the following steps:

1. Let promise be a new Promise.
2. Return promise and continue the following steps asynchronously.
3. If the current settings object is not a secure context, reject promise with a DOMException whose name is "SecurityError" and terminate these steps.
4. Let allOptions be the value of the options argument, if provided, or a PushSubscriptionOptions dictionary with default values.
5. If allOptions includes a non-null value for the applicationServerKey attribute, run the following substeps:
   1. Let applicationServerKey be the sequence of octets in applicationServerKey when provided as a BufferSource, or the sequence of octets that results from decoding applicationServerKey using the base64url encoding [[!RFC7515]] when provided as a DOMString. If decoding fails, reject promise with a DOMException whose name is "InvalidCharacterError" and terminate these steps.
   2. Ensure that applicationServerKey describes a valid point on the P-256 curve. If the applicationServerKey value is invalid, reject promise with a DOMException whose name is "InvalidAccessError" and terminate these steps.
6. Let registration be the PushManager's associated service worker registration.
7. If registration's active worker is null, reject promise with a DOMException whose name is "InvalidStateError" and terminate these steps.
8. Ask the user whether they allow the webapp to receive push messages, unless a prearranged trust relationship applies or the user has already granted or denied permission explicitly for this webapp.
9. If not granted, reject promise with a DOMException whose name is "NotAllowedError" and terminate these steps.
10. If the Service Worker is already subscribed, run the following substeps:
    1. Retrieve the push subscription associated with the Service Worker.
    2. If there is an error, reject promise with a DOMException whose name is "AbortError" and terminate these steps.
    3. Let subscription be the retrieved subscription.
    4. Compare allOptions with the options attribute of subscription. If any attribute on allOptions contains a different value to that stored for subscription, then reject promise with an InvalidStateError and terminate these steps. The contents of BufferSource values are compared for equality rather than references.
    5. When the request has been completed, resolve promise with subscription.
11. Make a request to the push service to create a new push subscription for the Service Worker.
12. If there is an error, reject promise with a DOMException whose name is "AbortError" and terminate these steps.
13. Let subscription be a new subscription.
14. Set the options attribute of subscription to be a copy of allOptions.
15. Generate a new P-256 ECDH key pair. Store the private key in an internal slot on subscription; this value MUST NOT be made available to applications. The public key is also stored in an internal slot and can be retrieved by calling the getKey method of the PushSubscription with an argument of p256dh.
16. Generate a new authentication secret, which is a sequence of octets as defined in [[!WEBPUSH-ENCRYPTION]]. Store the authentication secret in an internal slot on subscription. This key can be retrieved by calling the getKey method of the PushSubscription with an argument of auth.
17. When the request has been completed, resolve promise with a PushSubscription providing the details of the new push subscription.

The getSubscription method when invoked MUST run the following steps:

1. Let promise be a new Promise.
2. Return promise and continue the following steps asynchronously.
3. If the Service Worker is not subscribed, resolve promise with null.
4. Retrieve the push subscription associated with the Service Worker.
5. If there is an error, reject promise with a DOMException whose name is "AbortError" and terminate these steps.
6. When the request has been completed, resolve promise with a PushSubscription providing the details of the retrieved push subscription.

The permissionState method when invoked MUST run the following steps:

1. Let promise be a new Promise.
2. Return promise and continue the following steps asynchronously.
3. Retrieve the push permission status (PushPermissionState) of the requesting webapp.
4. If there is an error, reject promise with no arguments and terminate these steps.
5. When the request has been completed, resolve promise with PushPermissionState providing the push permission status.

Permission to use the push service can be persistent, that is, it does not need to be reconfirmed for subsequent subscriptions if a valid permission exists.

If there is a need to ask for permission, it needs to be done by invoking the subscribe method.

          dictionary PushSubscriptionOptionsInit {
            boolean userVisibleOnly = false;
            (BufferSource or DOMString)? applicationServerKey = null;
          };

          interface PushSubscriptionOptions {
            readonly attribute boolean userVisibleOnly;
            [SameObject] readonly attribute ArrayBuffer? applicationServerKey;
          };
        

PushSubscription interface

A PushSubscription object represents a push subscription.

        interface PushSubscription {
          readonly attribute USVString endpoint;
          [SameObject] readonly attribute PushSubscriptionOptions options;
          ArrayBuffer? getKey(PushEncryptionKeyName name);
          Promise<boolean> unsubscribe();
          serializer;
        };
      

When getting the endpoint attribute, the user agent MUST return the push endpoint associated with the push subscription.

The getKey method retrieves keying material that can be used for encrypting and authenticating messages. When getKey is invoked the following process is followed:

1. Find the internal slot corresponding to the key named by the name argument.
2. If a slot was not found, return null.
3. Initialize a variable key with a newly instantiated ArrayBuffer instance.
4. If the internal slot contains an asymmetric key pair, set the contents of key to the serialized value of the public key from the key pair. This uses the serialization format described in the specification that defines the name. For example, [[!WEBPUSH-ENCRYPTION]] specifies that the p256dh public key is encoded using the uncompressed format defined in [[X9.62]] Annex A (that is, a 65 octet sequence that starts with a 0x04 octet).
5. Otherwise, if the internal slot contains a symmetric key, set the contents of key to a copy of the value from the internal slot. For example, the auth parameter contains an octet sequence used by the user agent to authenticate messages sent by an application server.
6. Return key.

Keys named p256dh and auth MUST be supported, and their values MUST correspond to those necessary for the user agent to decrypt received push messages in accordance with [[!WEBPUSH-ENCRYPTION]].

The unsubscribe method when invoked MUST run the following steps:

1. Let promise be a new Promise.
2. Return promise and continue the following steps asynchronously.
3. If the push subscription has already been deactivated, resolve promise with false and terminate these steps.
4. Make a request to the push service to deactivate the push subscription.
5. If it was not possible to access the push service, reject promise with a "NetworkError" exception and terminate these steps.
6. When the request has been completed, resolve promise with true.

The serializer for a PushSubscription invokes the following steps:

1. Let map be an empty map.
2. Add an entry to map whose key name is endpoint and whose value is the result of converting the endpoint attribute of the PushSubscription to a serialized value. The user agent MUST use a serialization method that does not contain input-dependent branchs (that is, one that is constant time). Note that a URL - as ASCII text - will not ordinarily require special treatment.
3. Let keys be an empty map.
4. For each identifier i corresponding to keys in internal slots on the PushSubscription, ordered by the name of the key:
   1. If the internal slot corresponds to an asymmetric key pair, let b be the encoded value of the public key corresponding to the key name i, using the encoding defined for the key name (see getKey).
   2. Otherwise, let b be the value as returned by getKey.
   3. Let s be the URL-safe base64 encoding without padding [[!RFC4648]] of b as a USVString. The user agent MUST use a serialization method that does not branch based on the value of b.
   4. Add an entry to keys whose key name is the name of i and whose value is s.
5. Add an entry to map whose key name is keys and whose value is keys.
6. Return map.

Note that the options to a PushSubscription are not serialized.

          enum PushEncryptionKeyName {
            "p256dh",
            "auth"
          };
        

PushMessageData interface

        [Exposed=ServiceWorker]
        interface PushMessageData {
          ArrayBuffer arrayBuffer();
          Blob blob();
          any json();
          USVString text();
        };
      

PushMessageData objects have an associated bytes (a byte sequence) set on creation, which is null if there was no data in the push message.

The arrayBuffer method, when invoked, MUST return an ArrayBuffer whose contents are bytes. Exceptions thrown during the creation of the ArrayBuffer object are re-thrown.

The blob method, when invoked, MUST return a Blob whose contents are bytes and type is not provided.

The json method, when invoked, MUST return the result of invoking the initial value of JSON.parse with the result of running utf-8 decode on bytes as argument. Re-throw any exceptions thrown by JSON.parse.

The text method, when invoked, MUST return the result of running utf-8 decode on bytes.

To extract a byte sequence from object, run these steps:

1. Let bytes be an empty byte sequence.
2. Switch on object's type:

   BufferSource

   Set bytes to a copy of object's contents.

   USVString

   Set bytes to the result of running utf-8 encode on object.

3. Return bytes.

Events

          partial interface ServiceWorkerGlobalScope {
            attribute EventHandler onpush;
            attribute EventHandler onpushsubscriptionchange;
          };
        

          typedef (BufferSource or USVString) PushMessageDataInit;

          dictionary PushEventInit : ExtendableEventInit {
            PushMessageDataInit data;
          };

          [Constructor(DOMString type, optional PushEventInit eventInitDict), Exposed=ServiceWorker]
          interface PushEvent : ExtendableEvent {
            readonly attribute PushMessageData? data;
          };
        

            dictionary PushSubscriptionChangeInit : ExtendableEventInit {
              PushSubscription newSubscription = null;
              PushSubscription oldSubscription = null;
            };

            [Constructor(DOMString type, optional PushSubscriptionChangeInit eventInitDict), Exposed=ServiceWorker]
            interface PushSubscriptionChangeEvent : ExtendableEvent {
              readonly attribute PushSubscription? newSubscription;
              readonly attribute PushSubscription? oldSubscription;
            };
          

PushPermissionState Enumeration

        enum PushPermissionState {
          "denied",
          "granted",
          "prompt",
        };