Payment Request API

This specification standardizes an API to allow merchants (i.e. web sites selling physical or digital goods) to utilize one or more payment methods with minimal integration. User agents (e.g., browsers) facilitate the payment flow between merchant and user.

The working group maintains a list of all bug reports that the group has not yet addressed. Pull requests with proposed specification text for outstanding issues are strongly encouraged.

The working group will demonstrate implementation experience by producing an implementation report. The report will show two or more independent implementations passing each mandatory test in the test suite (i.e., each test corresponds to a MUST requirement of the specification).

There has been no change in dependencies on other workings groups during the development of this specification.

Changes since last publication

This version of the specification removes data features from the API, essentially pushing data details to payment method descriptions. The complete list of changes, including all editorial changes, is viewable in the commit history. Key set of changes are viewable in the Changelog.

Introduction

This specification describes an API that allows user agents (e.g., browsers) to act as an intermediary between three parties in a transaction:

The details of how to fulfill a payment request for a given payment method is an implementation detail of a payment handler, which is an application or service that handles requests for payment. Concretely, a payment handler defines:

Steps to check if a payment can be made:
How a payment handler determines whether it, or the user, can potentially "make a payment" is also an implementation detail of a payment handler.
Steps to respond to a payment request:
Steps that return an object or dictionary that a merchant uses to process or validate the transaction. The structure of this object is specific to each payment method.
Steps for when a user changes payment method (optional)

Steps that describe how to handle the user changing payment method or monetary instrument (e.g., from a debit card to a credit card) that results in a dictionary or {{object}} or null.

This API also enables web sites to take advantage of more secure payment schemes (e.g., tokenization and system-level authentication) that are not possible with standard JavaScript libraries. This has the potential to reduce liability for the merchant and helps protect sensitive user information.

Goals and scope

The following are out of scope for this specification:

Examples of usage

In order to use the API, the developer needs to provide and keep track of a number of key pieces of information. These bits of information are passed to the {{PaymentRequest}} constructor as arguments, and subsequently used to update the payment request being displayed to the user. Namely, these bits of information are:

Once a {{PaymentRequest}} is constructed, it's presented to the end user via the {{PaymentRequest/show()}} method. The {{PaymentRequest/show()}} returns a promise that, once the user confirms request for payment, results in a {{PaymentResponse}}.

Declaring multiple ways of paying

When constructing a new {{PaymentRequest}}, a merchant uses the first argument (|methodData|) to list the different ways a user can pay for things (e.g., credit cards, Apple Pay, Google Pay, etc.). More specifically, the |methodData| sequence contains PaymentMethodData dictionaries containing the payment method identifiers for the payment methods that the merchant accepts and any associated payment method specific data (e.g., which credit card networks are supported).

          const methodData = [
            {
              supportedMethods: "https://example.com/payitforward",
              data: {
                payItForwardField: "ABC",
              },
            },
            {
              supportedMethods: "https://example.com/bobpay",
              data: {
                merchantIdentifier: "XXXX",
                bobPaySpecificField: true,
              },
            },
          ];
        

Describing what is being paid for

When constructing a new {{PaymentRequest}}, a merchant uses the second argument of the constructor (|details|) to provide the details of the transaction that the user is being asked to complete. This includes the total of the order and, optionally, some line items that can provide a detailed breakdown of what is being paid for.

          const details = {
            id: "super-store-order-123-12312",
            displayItems: [
              {
                label: "Sub-total",
                amount: { currency: "GBP", value: "55.00" },
              },
              {
                label: "Value-Added Tax (VAT)",
                amount: { currency: "GBP", value: "5.00" },
              },
              {
                label: "Standard shipping",
                amount: { currency: "GBP", value: "5.00" },
              },
            ],
            total: {
              label: "Total due",
              // The total is GBP£65.00 here because we need to
              // add tax and shipping.
              amount: { currency: "GBP", value: "65.00" },
            },
          };
        

Conditional modifications to payment request

Here we see how to add a processing fee for using a card on a particular network. Notice that it requires recalculating the total.

          // Certain cards incur a $3.00 processing fee.
          const cardFee = {
            label: "Card processing fee",
            amount: { currency: "AUD", value: "3.00" },
          };

          // Modifiers apply when the user chooses to pay with
          // a card.
          const modifiers = [
            {
              additionalDisplayItems: [cardFee],
              supportedMethods: "https://example.com/cardpay",
              total: {
                label: "Total due",
                amount: { currency: "AUD", value: "68.00" },
              },
              data: {
                supportedNetworks: networks,
              },
            },
          ];
          Object.assign(details, { modifiers });
        

Constructing a PaymentRequest

Having gathered all the prerequisite bits of information, we can now construct a {{PaymentRequest}} and request that the browser present it to the user:

          async function doPaymentRequest() {
            try {
              const request = new PaymentRequest(methodData, details, options);
              const response = await request.show();
              await validateResponse(response);
            } catch (err) {
              // AbortError, SecurityError
              console.error(err);
            }
          }
          async function validateResponse(response) {
            try {
              const errors = await checkAllValuesAreGood(response);
              if (errors.length) {
                await response.retry(errors);
                return validateResponse(response);
              }
              await response.complete("success");
            } catch (err) {
              // Something went wrong...
              await response.complete("fail");
            }
          }
          // Must be called as a result of a click
          // or some explicit user action.
          doPaymentRequest();
        

POSTing payment response back to a server

It's expected that data in a {{PaymentResponse}} will be POSTed back to a server for processing. To make this as easy as possible, {{PaymentResponse}} can use the [=default toJSON steps=] (i.e., `.toJSON()`) to serializes the object directly into JSON. This makes it trivial to POST the resulting JSON back to a server using the [[[fetch]]]:

          async function doPaymentRequest() {
            const payRequest = new PaymentRequest(methodData, details, options);
            const payResponse = await payRequest.show();
            let result = "";
            try {
              const httpResponse = await fetch("/process-payment", {
                method: "POST",
                headers: { "Content-Type": "application/json" },
                body: payResponse.toJSON(),
              });
              result = httpResponse.ok ? "success" : "fail";
            } catch (err) {
              console.error(err);
              result = "fail";
            }
            await payResponse.complete(result);
          }
          doPaymentRequest();
        

Using with cross-origin iframes

To indicate that a cross-origin [^iframe^] is allowed to invoke the payment request API, the [^iframe/allow^] attribute along with the "payment" keyword can be specified on the [^iframe^] element.

          <iframe
            src="https://cross-origin.example"
            allow="payment">
          </iframe>
        

If the [^iframe^] will be navigated across multiple origins that support the Payment Request API, then one can set [^iframe/allow^] to `"payment *"`. The [[[permissions-policy]]] specification provides further details and examples.

PaymentRequest interface

        [SecureContext, Exposed=Window]
        interface PaymentRequest : EventTarget {
          constructor(
            sequence<PaymentMethodData> methodData,
            PaymentDetailsInit details
          );
          [NewObject]
          Promise<PaymentResponse> show(optional Promise<PaymentDetailsUpdate> detailsPromise);
          [NewObject]
          Promise<undefined> abort();
          [NewObject]
          Promise<boolean> canMakePayment();

          readonly attribute DOMString id;

          attribute EventHandler onpaymentmethodchange;
        };
      

A developer creates a {{PaymentRequest}} to make a payment request. This is typically associated with the user initiating a payment process (e.g., by activating a "Buy," "Purchase," or "Checkout" button on a web site, selecting a "Power Up" in an interactive game, or paying at a kiosk in a parking structure). The {{PaymentRequest}} allows developers to exchange information with the user agent while the user is providing input (up to the point of user approval or denial of the payment request).

A |request|'s payment-relevant browsing context is that {{PaymentRequest}}'s [=relevant global object=]'s browsing context's top-level browsing context. Every payment-relevant browsing context has a payment request is showing boolean, which prevents showing more than one payment UI at a time.

The payment request is showing boolean simply prevents more than one payment UI being shown in a single browser tab. However, a payment handler can restrict the user agent to showing only one payment UI across all browser windows and tabs. Other payment handlers might allow showing a payment UI across disparate browser tabs.

Constructor

The {{PaymentRequest}} is constructed using the supplied sequence of PaymentMethodData |methodData| including any payment method specific {{PaymentMethodData/data}}, and the PaymentDetailsInit |details|.

The PaymentRequest(|methodData|, |details|) constructor MUST act as follows:

  1. If the current settings object's [=environment settings object / responsible document=] is not allowed to use the "[=payment-permission|payment=]" permission, then [=exception/throw=] a {{"SecurityError"}} {{DOMException}}.
  2. Establish the request's id:
    1. If |details|.{{PaymentDetailsInit/id}} is missing, add an {{PaymentDetailsInit/id}} member to |details| and set its value to a UUID [[RFC4122]].
  3. Let |serializedMethodData| be an empty list.
  4. Process payment methods:
    1. If the length of the |methodData| sequence is zero, then [=exception/throw=] a {{TypeError}}, optionally informing the developer that at least one payment method is required.
    2. Let |seenPMIs:Set| be the empty [=set=].
    3. For each |paymentMethod| of |methodData|:
      1. Run the steps to validate a payment method identifier with |paymentMethod|.{{PaymentMethodData/supportedMethods}}. If it returns false, then throw a {{RangeError}} exception. Optionally, inform the developer that the payment method identifier is invalid.
      2. Let |pmi| be the result of parsing |paymentMethod|.{{PaymentMethodData/supportedMethods}} with [=basic URL parser=]:
        1. If failure, set |pmi| to |paymentMethod|.{{PaymentMethodData/supportedMethods}}.
      3. If |seenPMIs| [=set/contain|contains=] |pmi| throw a {{RangeError}} {{DOMException}} optionally letting the developer this [=payment method identifier=] is a duplicate.
      4. [=set/Append=] |pmi| to |seenPMIs|.
      5. If the {{PaymentMethodData/data}} member of |paymentMethod| is missing, let |serializedData| be null. Otherwise, let |serializedData| be the result of JSON-serializing |paymentMethod|.{{PaymentMethodData/data}} into a string. Rethrow any exceptions.
      6. If |serializedData| is not null, and if required by the specification that defines the |paymentMethod|.{{PaymentMethodData/supportedMethods}}:
        1. Let |object| be the result of JSON-parsing |serializedData|.
        2. [=converted to an IDL value|Convert=] |object| to an IDL value of the type specified by the specification that defines the |paymentMethod|.{{PaymentMethodData/supportedMethods}} Rethrow any exceptions.

          This step assures that any IDL type conversion errors are caught as early as possible.

      7. Add the tuple (|paymentMethod|.{{PaymentMethodData/supportedMethods}}, |serializedData|) to |serializedMethodData|.
  5. Process the total:
    1. Check and canonicalize total amount |details|.{{PaymentDetailsInit/total}}.{{PaymentItem/amount}}. Rethrow any exceptions.
  6. If the {{PaymentDetailsBase/displayItems}} member of |details| is present, then for each |item| in |details|.{{PaymentDetailsBase/displayItems}}:
    1. Check and canonicalize amount |item|.{{PaymentItem/amount}}. Rethrow any exceptions.
  7. Let |serializedModifierData| be an empty list.
  8. Process payment details modifiers:
    1. Let |modifiers| be an empty sequence<{{PaymentDetailsModifier}}>.
    2. If the {{PaymentDetailsBase/modifiers}} member of |details| is present, then:
      1. Set |modifiers| to |details|.{{PaymentDetailsBase/modifiers}}.
      2. For each |modifier| of |modifiers|:
        1. If the {{PaymentDetailsModifier/total}} member of |modifier| is present, then:
          1. Check and canonicalize total amount |modifier|.{{PaymentDetailsModifier/total}}.{{PaymentItem/amount}}. Rethrow any exceptions.
        2. If the {{PaymentDetailsModifier/additionalDisplayItems}} member of |modifier| is present, then for each |item| of |modifier|.{{PaymentDetailsModifier/additionalDisplayItems}}:
          1. Check and canonicalize amount |item|.{{PaymentItem/amount}}. Rethrow any exceptions.
        3. If the {{PaymentDetailsModifier/data}} member of |modifier| is missing, let |serializedData| be null. Otherwise, let |serializedData| be the result of JSON-serializing |modifier|.{{PaymentDetailsModifier/data}} into a string. Rethrow any exceptions.
        4. Add the tuple (|modifier|.{{PaymentDetailsModifier/supportedMethods}}, |serializedData|) to |serializedModifierData|.
        5. Remove the {{PaymentDetailsModifier/data}} member of |modifier|, if it is present.
    3. Set |details|.{{PaymentDetailsBase/modifiers}} to |modifiers|.
  9. Let |request:PaymentRequest| be a new {{PaymentRequest}}.
  10. Set |request|.{{PaymentRequest/[[handler]]}} to `null`.
  11. Set |request|.{{PaymentRequest/[[state]]}} to "[=PaymentRequest/created=]".
  12. Set |request|.{{PaymentRequest/[[updating]]}} to false.
  13. Set |request|.{{PaymentRequest/[[details]]}} to |details|.
  14. Set |request|.{{PaymentRequest/[[serializedModifierData]]}} to |serializedModifierData|.
  15. Set |request|.{{PaymentRequest/[[serializedMethodData]]}} to |serializedMethodData|.
  16. Set |request|.{{PaymentRequest/[[response]]}} to null.
  17. Return |request|.

id attribute

When getting, the {{PaymentRequest/id}} attribute returns this {{PaymentRequest}}'s {{PaymentRequest/[[details]]}}.{{PaymentDetailsInit/id}}.

For auditing and reconciliation purposes, a merchant can associate a unique identifier for each transaction with the {{PaymentDetailsInit/id}} attribute.

show() method

The {{PaymentRequest/show()}} method is called when a developer wants to begin user interaction for the payment request. The {{PaymentRequest/show()}} method returns a {{Promise}} that will be resolved when the user accepts the payment request. Some kind of user interface will be presented to the user to facilitate the payment request after the {{PaymentRequest/show()}} method returns.

Each payment handler controls what happens when multiple browsing context simultaneously call the {{PaymentRequest/show()}} method. For instance, some payment handlers will allow multiple payment UIs to be shown in different browser tabs/windows. Other payment handlers might only allow a single payment UI to be shown for the entire user agent.

The show(optional |detailsPromise|) method MUST act as follows:

  1. Let |request:PaymentRequest| be [=this=].
  2. If the [=relevant global object=] of [=request=] does not have [=transient activation=]:
    1. Return [=a promise rejected with=] with a {{"SecurityError"}} {{DOMException}}.
  3. [=Consume user activation=] of the [=relevant global object=].
  4. Let |document| be |request|'s [=relevant global object=]'s [=associated `Document`=].
  5. If |document| is not [=Document/fully active=], then return a promise rejected with an {{"AbortError"}} {{DOMException}}.
  6. Optionally, if the user agent wishes to disallow the call to {{PaymentRequest/show()}} to protect the user, then return a promise rejected with a {{"SecurityError"}} {{DOMException}}. For example, the user agent may limit the rate at which a page can call {{PaymentRequest/show()}}, as described in section .

  7. If |request|.{{PaymentRequest/[[state]]}} is not "[=PaymentRequest/created=]" then return a promise rejected with an {{"InvalidStateError"}} {{DOMException}}.
  8. If the user agent's payment request is showing boolean is true, then:
    1. Set |request|.{{PaymentRequest/[[state]]}} to "[=PaymentRequest/closed=]".
    2. Return a promise rejected with an {{"AbortError"}} {{DOMException}}.
  9. Set |request|.{{PaymentRequest/[[state]]}} to "[=PaymentRequest/interactive=]".
  10. Let |acceptPromise:Promise| be a new promise.
  11. Set |request|.{{PaymentRequest/[[acceptPromise]]}} to |acceptPromise|.
  12. Optionally:

    1. Reject |acceptPromise| with an {{"AbortError"}} {{DOMException}}.
    2. Set |request|.{{PaymentRequest/[[state]]}} to "[=PaymentRequest/closed=]".
    3. Return |acceptPromise|.

    This allows the user agent to act as if the user had immediately [=user aborts the payment request|aborted the payment request=], at its discretion. For example, in "private browsing" modes or similar, user agents might take advantage of this step.

  13. Set |request|'s payment-relevant browsing context's payment request is showing boolean to true.
  14. Return |acceptPromise| and perform the remaining steps in parallel.
  15. Let |handlers:list| be an empty list.
  16. For each |paymentMethod| tuple in |request|.{{PaymentRequest/[[serializedMethodData]]}}:
    1. Let |identifier| be the first element in the |paymentMethod| tuple.
    2. Let |data| be the result of JSON-parsing the second element in the |paymentMethod| tuple.
    3. If required by the specification that defines the |identifier|, then [=converted to an IDL value|convert=] |data| to an IDL value of the type specified there. Otherwise, [=converted to an IDL value|convert=] to {{object}}.
    4. If conversion results in an exception |error|:
      1. Set |request|.{{PaymentRequest/[[state]]}} to "[=PaymentRequest/closed=]".
      2. Reject |acceptPromise| with |error|.
      3. Set |request|'s payment-relevant browsing context's payment request is showing boolean to false.
      4. Terminate this algorithm.
    5. Let |registeredHandlers| be a list of registered payment handlers for the payment method |identifier|.
    6. For each |handler| in |registeredHandlers|:
      1. Let |canMakePayment| be the result of running |handler|'s steps to check if a payment can be made with |data|.
      2. If |canMakePayment| is true, then append |handler| to |handlers|.
  17. If |handlers| is empty, then:
    1. Set |request|.{{PaymentRequest/[[state]]}} to "[=PaymentRequest/closed=]".
    2. Reject |acceptPromise| with {{"NotSupportedError"}} {{DOMException}}.
    3. Set |request|'s payment-relevant browsing context's payment request is showing boolean to false.
    4. Terminate this algorithm.
  18. Present a user interface that will allow the user to interact with the |handlers|. The user agent SHOULD prioritize the user's preference when presenting payment methods. The user interface SHOULD be presented using the language and locale-based formatting that matches the |document|'s [=document element|document element's=] [=Node/language=], if any, or an appropriate fallback if that is not available.

  19. If |detailsPromise| was passed, then:
    1. Run the update a PaymentRequest's details algorithm with |detailsPromise|, |request|, and null.
    2. Wait for the |detailsPromise| to settle.

      Based on how the |detailsPromise| settles, the update a PaymentRequest's details algorithm determines how the payment UI behaves. That is, upon rejection of the |detailsPromise|, the payment request aborts. Otherwise, upon fulfillment |detailsPromise|, the user agent re-enables the payment request UI and the payment flow can continue.

  20. Set |request|.{{PaymentRequest/[[handler]]}} be the payment handler selected by the end-user.
  21. Let |modifiers:list| be an empty list.
  22. For each |tuple| in {{PaymentRequest/[[serializedModifierData]]}}:
    1. If the first element of |tuple| (a PMI) matches the payment method identifier of |request|.{{PaymentRequest/[[handler]]}}, then append the second element of |tuple| (the serialized method data) to |modifiers|.
  23. Pass the [=converted to an IDL value|converted=] second element in the |paymentMethod| tuple and |modifiers|. Optionally, the user agent SHOULD send the appropriate data from |request| to the user-selected payment handler in order to guide the user through the payment process. This includes the various attributes and other internal slots of |request| (some MAY be excluded for privacy reasons where appropriate).

    Handling of multiple applicable modifiers in the {{PaymentRequest/[[serializedModifierData]]}} internal slot is payment handler specific and beyond the scope of this specification. Nevertheless, it is RECOMMENDED that payment handlers use a "last one wins" approach with items in the {{PaymentRequest/[[serializedModifierData]]}} list: that is to say, an item at the end of the list always takes precedence over any item at the beginning of the list (see example below).

    The |acceptPromise| will later be resolved or rejected by either the user accepts the payment request algorithm or the user aborts the payment request algorithm, which are triggered through interaction with the user interface.

    If |document| stops being [=Document/fully active=] while the user interface is being shown, or no longer is by the time this step is reached, then:

    1. Close down the user interface.
    2. Set |request|'s payment-relevant browsing context's payment request is showing boolean to false.

abort() method

The {{PaymentRequest/abort()}} method is called if a developer wishes to tell the user agent to abort the payment |request| and to tear down any user interface that might be shown. The {{PaymentRequest/abort()}} can only be called after the {{PaymentRequest/show()}} method has been called (see [=PaymentRequest/states=]) and before this instance's {{PaymentRequest/[[acceptPromise]]}} has been resolved. For example, developers might choose to do this if the goods they are selling are only available for a limited amount of time. If the user does not accept the payment request within the allowed time period, then the request will be aborted.

A user agent might not always be able to abort a request. For example, if the user agent has delegated responsibility for the request to another app. In this situation, {{PaymentRequest/abort()}} will reject the returned {{Promise}}.

See also the algorithm when the user aborts the payment request.

The {{PaymentRequest/abort()}} method MUST act as follows:

  1. Let |request:PaymentRequest| be [=this=].
  2. If |request|.{{PaymentRequest/[[response]]}} is not null, and |request|.{{PaymentRequest/[[response]]}}.{{PaymentResponse/[[retryPromise]]}} is not null, return a promise rejected with an {{"InvalidStateError"}} {{DOMException}}.
  3. If the value of |request|.{{PaymentRequest/[[state]]}} is not "[=PaymentRequest/interactive=]" then return a promise rejected with an {{"InvalidStateError"}} {{DOMException}}.
  4. Let |promise:Promise| be a new promise.
  5. Return |promise| and perform the remaining steps in parallel.
  6. Try to abort the current user interaction with the payment handler and close down any remaining user interface.
  7. Queue a task on the user interaction task source to perform the following steps:
    1. If it is not possible to abort the current user interaction, then reject |promise| with {{"InvalidStateError"}} {{DOMException}} and abort these steps.
    2. Set |request|.{{PaymentRequest/[[state]]}} to "[=PaymentRequest/closed=]".
    3. Reject the promise |request|.{{PaymentRequest/[[acceptPromise]]}} with an {{"AbortError"}} {{DOMException}}.
    4. Resolve |promise| with undefined.

canMakePayment() method

The {{PaymentRequest/canMakePayment()}} method can be used by the developer to determine if the user agent has support for one of the desired payment methods. See [[[#canmakepayment-protections]]].

A true result from {{PaymentRequest/canMakePayment()}} does not imply that the user has a provisioned instrument ready for payment.

The {{PaymentRequest/canMakePayment()}} method MUST run the can make payment algorithm.

onpaymentmethodchange attribute

A {{PaymentRequest}}'s {{PaymentRequest/onpaymentmethodchange}} attribute is an {{EventHandler}} for a {{PaymentMethodChangeEvent}} named "paymentmethodchange".

Internal Slots

Instances of {{PaymentRequest}} are created with the internal slots in the following table:

Internal Slot Description (non-normative)
[[\serializedMethodData]] The methodData supplied to the constructor, but represented as tuples containing supported methods and a string or null for data (instead of the original object form).
[[\serializedModifierData]] A list containing the serialized string form of each {{PaymentDetailsModifier/data}} member for each corresponding item in the sequence {{PaymentRequest/[[details]]}}.{{PaymentDetailsBase/modifier}}, or null if no such member was present.
[[\details]] The current {{PaymentDetailsBase}} for the payment request initially supplied to the constructor and then updated with calls to {{PaymentRequestUpdateEvent/updateWith()}}. Note that all {{PaymentDetailsModifier/data}} members of {{PaymentDetailsModifier}} instances contained in the {{PaymentDetailsBase/modifiers}} member will be removed, as they are instead stored in serialized form in the {{PaymentRequest/[[serializedModifierData]]}} internal slot.
[[\state]]

The current state of the payment request, which transitions from:

"created"
The payment request is constructed and has not been presented to the user.
"interactive"
The payment request is being presented to the user.
"closed"
The payment request completed.

The [=PaymentRequest/state=] transitions are illustrated in the figure below:

The constructor sets the initial [=PaymentRequest/state=] to "[=PaymentRequest/created=]". The {{PaymentRequest/show()}} method changes the [=PaymentRequest/state=] to "[=PaymentRequest/interactive=]". From there, the {{PaymentRequest/abort()}} method or any other error can send the [=PaymentRequest/state=] to "[=PaymentRequest/closed=]"; similarly, the user accepts the payment request algorithm and user aborts the payment request algorithm will change the [=PaymentRequest/state=] to "[=PaymentRequest/closed=]".
[[\updating]] True if there is a pending {{PaymentRequestUpdateEvent/updateWith()}} call to update the payment request and false otherwise.
[[\acceptPromise]] The pending {{Promise}} created during {{PaymentRequest/show()}} that will be resolved if the user accepts the payment request.
[[\response]] Null, or the {{PaymentResponse}} instantiated by this {{PaymentRequest}}.
[[\handler]] The Payment Handler associated with this {{PaymentRequest}}. Initialized to `null`.

PaymentMethodData dictionary

        dictionary PaymentMethodData {
          required DOMString supportedMethods;
          object data;
        };
      

A PaymentMethodData dictionary is used to indicate a set of supported payment methods and any associated payment method specific data for those methods.

supportedMethods member
A payment method identifier for a payment method that the merchant web site accepts.
data member
An object that provides optional information that might be needed by the supported payment methods. If supplied, it will be JSON-serialized.

The value of supportedMethods was changed from array to string, but the name was left as a plural to maintain compatibility with existing content on the Web.

PaymentCurrencyAmount dictionary

        dictionary PaymentCurrencyAmount {
          required DOMString currency;
          required DOMString value;
        };
      

A {{PaymentCurrencyAmount}} dictionary is used to supply monetary amounts.

currency member

An [[ISO4217]] well-formed 3-letter alphabetic code (i.e., the numeric codes are not supported). Their canonical form is upper case. However, the set of combinations of currency code for which localized currency symbols are available is implementation dependent.

When displaying a monetary value, it is RECOMMENDED that user agents display the currency code, but it's OPTIONAL for user agents to display a currency symbol. This is because currency symbols can be ambiguous due to use across a number of different currencies (e.g., "$" could mean any of USD, AUD, NZD, CAD, and so on.).

User agents MAY format the display of the {{PaymentCurrencyAmount/currency}} member to adhere to OS conventions (e.g., for localization purposes).

User agents implementing this specification enforce [[ISO4217]]'s 3-letter codes format via ECMAScript’s isWellFormedCurrencyCode abstract operation, which is invoked as part of the check and canonicalize amount algorithm. When a code does not adhere to the [[ISO4217]] defined format, a {{RangeError}} is thrown.

Current implementations will therefore allow the use of well-formed currency codes that are not part of the official [[ISO4217]] list (e.g., XBT, XRP, etc.). If the provided code is a currency that the browser knows how to display, then an implementation will generally display the appropriate currency symbol in the user interface (e.g., "USD" is shown as U+0024 Dollar Sign ($), "GBP" is shown as U+00A3 Pound Sign (£), "PLN" is shown as U+007A U+0142 Złoty (zł), and the non-standard "XBT" could be shown as U+0243 Latin Capital Letter B with Stroke (Ƀ)).

Efforts are underway at ISO to account for digital currencies, which may result in an update to the [[ISO4217]] registry or an entirely new registry. The community expects this will resolve ambiguities that have crept in through the use of non-standard 3-letter codes; for example, does "BTC" refer to Bitcoin or to a future Bhutan currency? At the time of publication, it remains unclear what form this evolution will take, or even the time frame in which the work will be completed. The W3C Web Payments Working Group is liaising with ISO so that, in the future, revisions to this specification remain compatible with relevant ISO registries.

value member
A valid decimal monetary value containing a monetary amount.
        {
           "currency": "OMR",
           "value": "1.234"
        }
     

Validity checkers

A [=JavaScript string=] is a valid decimal monetary value if it consists of the following [=code points=] in the given order:

  1. Optionally, a single U+002D (-), to indicate that the amount is negative.
  2. One or more [=code points=] in the range U+0030 (0) to U+0039 (9).
  3. Optionally, a single U+002E (.) followed by one or more [=code points=] in the range U+0030 (0) to U+0039 (9).
The following regular expression is an implementation of the above definition.
^-?[0-9]+(\.[0-9]+)?$

To check and canonicalize amount given a {{PaymentCurrencyAmount}} |amount|, run the following steps:

  1. If the result of IsWellFormedCurrencyCode(|amount|.{{PaymentCurrencyAmount/currency}}) is false, then throw a {{RangeError}} exception, optionally informing the developer that the currency is invalid.
  2. If |amount|.{{PaymentCurrencyAmount/value}} is not a valid decimal monetary value, throw a {{TypeError}}, optionally informing the developer that the currency is invalid.
  3. Set |amount|.{{PaymentCurrencyAmount/currency}} to the result of ASCII uppercase |amount|.{{PaymentCurrencyAmount/currency}}.

To check and canonicalize total amount given a {{PaymentCurrencyAmount}} |amount:PaymentCurrencyAmount|, run the following steps:

  1. Check and canonicalize amount |amount|. Rethrow any exceptions.
  2. If the first code point of |amount|.{{PaymentCurrencyAmount/value}} is U+002D (-), then throw a {{TypeError}} optionally informing the developer that a total's value can't be a negative number.

Payment details dictionaries

PaymentDetailsBase dictionary

        dictionary PaymentDetailsBase {
          sequence<PaymentItem> displayItems;
          sequence<PaymentDetailsModifier> modifiers;
        };
        
displayItems member
A sequence of {{PaymentItem}} dictionaries contains line items for the payment request that the user agent MAY display.
modifiers member
A sequence of {{PaymentDetailsModifier}} dictionaries that contains modifiers for particular payment method identifiers. For example, it allows you to adjust the total amount based on payment method.

PaymentDetailsInit dictionary

          dictionary PaymentDetailsInit : PaymentDetailsBase {
            DOMString id;
            required PaymentItem total;
          };
        

In addition to the members inherited from the {{PaymentDetailsBase}} dictionary, the following members are part of the PaymentDetailsInit dictionary:

id member
A free-form identifier for this payment request.
total member
A {{PaymentItem}} containing a non-negative total amount for the payment request.

PaymentDetailsUpdate dictionary

          dictionary PaymentDetailsUpdate : PaymentDetailsBase {
            PaymentItem total;
            object paymentMethodErrors;
          };
        

The {{PaymentDetailsUpdate}} dictionary is used to update the payment request using {{PaymentRequestUpdateEvent/updateWith()}}.

In addition to the members inherited from the {{PaymentDetailsBase}} dictionary, the following members are part of the {{PaymentDetailsUpdate}} dictionary:

total member
A {{PaymentItem}} containing a non-negative {{PaymentItem/amount}}.

Algorithms in this specification that accept a {{PaymentDetailsUpdate}} dictionary will throw if the {{PaymentDetailsUpdate/total}}.{{PaymentItem/amount}}.{{PaymentCurrencyAmount/value}} is a negative number.

paymentMethodErrors member

Payment method specific errors.

PaymentDetailsModifier dictionary

        dictionary PaymentDetailsModifier {
          required DOMString supportedMethods;
          PaymentItem total;
          sequence<PaymentItem> additionalDisplayItems;
          object data;
        };
      

The {{PaymentDetailsModifier}} dictionary provides details that modify the {{PaymentDetailsBase}} based on a payment method identifier. It contains the following members:

supportedMethods member
A payment method identifier. The members of the {{PaymentDetailsModifier}} only apply if the user selects this payment method.
total member
A {{PaymentItem}} value that overrides the {{PaymentDetailsInit/total}} member in the PaymentDetailsInit dictionary for the payment method identifiers of the {{PaymentDetailsModifier/supportedMethods}} member.
additionalDisplayItems member
A sequence of {{PaymentItem}} dictionaries provides additional display items that are appended to the {{PaymentDetailsBase/displayItems}} member in the {{PaymentDetailsBase}} dictionary for the payment method identifiers in the {{PaymentDetailsModifier/supportedMethods}} member. This member is commonly used to add a discount or surcharge line item indicating the reason for the different {{PaymentDetailsModifier/total}} amount for the selected payment method that the user agent MAY display.

It is the developer's responsibility to verify that the {{PaymentDetailsModifier/total}} amount is the sum of the {{PaymentDetailsBase/displayItems}} and the {{PaymentDetailsModifier/additionalDisplayItems}}.

data member
An object that provides optional information that might be needed by the supported payment methods. If supplied, it will be JSON-serialized.

PaymentItem dictionary

        dictionary PaymentItem {
          required DOMString label;
          required PaymentCurrencyAmount amount;
          boolean pending = false;
        };
      

A sequence of one or more {{PaymentItem}} dictionaries is included in the {{PaymentDetailsBase}} dictionary to indicate what the payment request is for and the value asked for.

label member
A human-readable description of the item. The user agent may display this to the user.
amount member
A {{PaymentCurrencyAmount}} containing the monetary amount for the item.
pending member
A boolean. When set to true it means that the {{PaymentItem/amount}} member is not final. This is commonly used to show items such as shipping or tax amounts that depend upon selection of shipping address or shipping option. User agents MAY indicate pending fields in the user interface for the payment request.

PaymentComplete enum

        enum PaymentComplete {
          "fail",
          "success",
          "unknown"
        };
      
"fail"
Indicates that processing of the payment failed. The user agent MAY display UI indicating failure.
"success"
Indicates the payment was successfully processed. The user agent MAY display UI indicating success.
"unknown"
The developer did not indicate success or failure and the user agent SHOULD NOT display UI indicating success or failure.

PaymentResponse interface

        [SecureContext, Exposed=Window]
        interface PaymentResponse : EventTarget  {
          [Default] object toJSON();

          readonly attribute DOMString requestId;
          readonly attribute DOMString methodName;
          readonly attribute object details;

          [NewObject]
          Promise<undefined> complete(optional PaymentComplete result = "unknown");
          [NewObject]
          Promise<undefined> retry(optional PaymentValidationErrors errorFields = {});
        };
      

A {{PaymentResponse}} is returned when a user has selected a payment method and approved a payment request.

retry() method

The retry(|errorFields:PaymentValidationErrors|) method MUST act as follows:

  1. Let |response:PaymentResponse| be [=this=].
  2. Let |request:PaymentRequest| be |response|.{{PaymentResponse/[[request]]}}.
  3. Let |document:Document| be |request|'s relevant global object's associated Document.
  4. If |document| is not [=Document/fully active=], then return a promise rejected with an {{"AbortError"}} {{DOMException}}.
  5. If |response|.{{PaymentResponse/[[complete]]}} is true, return a promise rejected with an {{"InvalidStateError"}} {{DOMException}}.
  6. If |response|.{{PaymentResponse/[[retryPromise]]}} is not null, return a promise rejected with an {{"InvalidStateError"}} {{DOMException}}.
  7. Set |request|.{{PaymentRequest/[[state]]}} to "[=PaymentRequest/interactive=]".
  8. Let |retryPromise:Promise| be a new promise.
  9. Set |response|.{{PaymentResponse/[[retryPromise]]}} to |retryPromise|.
  10. If |errorFields:PaymentValidationErrors| was passed:
    1. If |errorFields:PaymentValidationErrors|.{{PaymentValidationErrors/paymentMethod}} member was passed, and if required by the specification that defines |response|.{{PaymentResponse/payment}}/a>, then [=converted to an IDL value|convert=] |errorFields|'s {{PaymentValidationErrors/paymentMethod}} member to an IDL value of the type specified there. Otherwise, [=converted to an IDL value|convert=] to {{object}}.
    2. Set |request|'s payment-relevant browsing context's payment request is showing boolean to false.
    3. If conversion results in a exception |error|:
      1. Reject |retryPromise| with |error|.
      2. Set user agent's payment request is showing boolean to false.
      3. Return.
    4. By matching the members of |errorFields| to input fields in the user agent's UI, indicate to the end user that something is wrong with the data of the payment response. For example, a user agent might draw the user's attention to the erroneous |errorFields| in the browser's UI and display the value of each field in a manner that helps the user fix each error. Similarly, if the {{PaymentValidationErrors/error}} member is passed, present the error in the user agent's UI. In the case where the value of a member is the empty string, the user agent MAY substitute a value with a suitable error message.
  11. Otherwise, if |errorFields| was not passed, signal to the end user to attempt to retry the payment. Re-enable any UI element that affords the end user the ability to retry accepting the payment request.
  12. If |document| stops being [=Document/fully active=] while the user interface is being shown, or no longer is by the time this step is reached, then:
    1. Close down the user interface.
    2. Set |request|'s payment-relevant browsing context's payment request is showing boolean to false.
  13. Finally, when |retryPromise| settles, set |response|.{{PaymentResponse/[[retryPromise]]}} to null.
  14. Return |retryPromise|.

    The |retryPromise| will later be resolved by the user accepts the payment request algorithm, or rejected by either the user aborts the payment request algorithm or abort the update.

PaymentValidationErrors dictionary

            dictionary PaymentValidationErrors {
              DOMString error;
              object paymentMethod;
            };
          
error member
A general description of an error with the payment from which the user can attempt to recover. For example, the user may recover by retrying the payment. A developer can optionally pass the {{PaymentValidationErrors/error}} member on its own to give a general overview of validation issues, or it can be passed in combination with other members of the {{PaymentValidationErrors}} dictionary.
paymentMethod member
A payment method specific errors.

methodName attribute

The payment method identifier for the payment method that the user selected to fulfill the transaction.

details attribute

An {{object}} or dictionary generated by a payment method that a merchant can use to process or validate a transaction (depending on the payment method).

requestId attribute

The corresponding payment request {{PaymentRequest/id}} that spawned this payment response.

complete() method

The {{PaymentResponse/complete()}} method is called after the user has accepted the payment request and the {{PaymentRequest/[[acceptPromise]]}} has been resolved. Calling the {{PaymentResponse/complete()}} method tells the user agent that the payment interaction is over (and SHOULD cause any remaining user interface to be closed).

After the payment request has been accepted and the {{PaymentResponse}} returned to the caller, but before the caller calls {{PaymentResponse/complete()}}, the payment request user interface remains in a pending state. At this point the user interface SHOULD NOT offer a cancel command because acceptance of the payment request has been returned. However, if something goes wrong and the developer never calls {{PaymentResponse/complete()}} then the user interface is blocked.

For this reason, implementations MAY impose a timeout for developers to call {{PaymentResponse/complete()}}. If the timeout expires then the implementation will behave as if {{PaymentResponse/complete()}} was called with no arguments.

The {{PaymentResponse/complete()}} method MUST act as follows:

  1. Let |response:PaymentResponse| be [=this=].
  2. If |response|.{{PaymentResponse/[[complete]]}} is true, return a promise rejected with an {{"InvalidStateError"}} {{DOMException}}.
  3. If |response|.{{PaymentResponse/[[retryPromise]]}} is not null, return a promise rejected with an {{"InvalidStateError"}} {{DOMException}}.
  4. Let |promise:Promise| be a new promise.
  5. Set |response|.{{PaymentResponse/[[complete]]}} to true.
  6. Return |promise| and perform the remaining steps in parallel.
  7. If |document| stops being [=Document/fully active=] while the user interface is being shown, or no longer is by the time this step is reached, then:
    1. Close down the user interface.
    2. Set |request|'s payment-relevant browsing context's payment request is showing boolean to false.
  8. Otherwise:
    1. Close down any remaining user interface. The user agent MAY use the value |result| to influence the user experience.
    2. Set |request|'s payment-relevant browsing context's payment request is showing boolean to false.
    3. Resolve |promise| with undefined.

Internal Slots

Instances of {{PaymentResponse}} are created with the internal slots in the following table:

Internal Slot Description (non-normative)
[[\complete]] Is true if the request for payment has completed (i.e., {{PaymentResponse/complete()}} was called, or there was a fatal error that made the response not longer usable), or false otherwise.
[[\request]] The {{PaymentRequest}} instance that instantiated this {{PaymentResponse}}.
[[\retryPromise]] Null, or a {{Promise}} that resolves when a user accepts the payment request or rejects if the user aborts the payment request.

Permissions Policy integration

This specification defines a [=policy-controlled feature=] identified by the string "payment" [[permissions-policy]]. Its default allowlist is 'self'.

Events

Summary

Event name Interface Dispatched when… Target
paymentmethodchange {{PaymentMethodChangeEvent}} The user chooses a different payment method within a payment handler. {{PaymentRequest}}

PaymentMethodChangeEvent interface

          [SecureContext, Exposed=Window]
          interface PaymentMethodChangeEvent : PaymentRequestUpdateEvent {
            constructor(DOMString type, optional PaymentMethodChangeEventInit eventInitDict = {});
            readonly attribute DOMString methodName;
            readonly attribute object? methodDetails;
          };
        

methodDetails attribute

When getting, returns the value it was initialized with. See {{PaymentMethodChangeEventInit/methodDetails}} member of {{PaymentMethodChangeEventInit}} for more information.

methodName attribute

When getting, returns the value it was initialized with. See {{PaymentMethodChangeEventInit/methodName}} member of {{PaymentMethodChangeEventInit}} for more information.

PaymentMethodChangeEventInit dictionary

            dictionary PaymentMethodChangeEventInit : PaymentRequestUpdateEventInit {
              DOMString methodName = "";
              object? methodDetails = null;
            };
          
methodName member
A string representing the payment method identifier.
methodDetails member
An object representing some data from the payment method, or null.

PaymentRequestUpdateEvent interface

          [SecureContext, Exposed=Window]
          interface PaymentRequestUpdateEvent : Event {
            constructor(DOMString type, optional PaymentRequestUpdateEventInit eventInitDict = {});
            undefined updateWith(Promise<PaymentDetailsUpdate> detailsPromise);
          };
        

The {{PaymentRequestUpdateEvent}} enables developers to update the details of the payment request in response to a user interaction.

Constructor

The {{PaymentRequestUpdateEvent}}'s {{PaymentRequestUpdateEvent/constructor(type, eventInitDict)}} MUST act as follows:

  1. Let |event:PaymentRequestUpdateEvent| be the result of calling the [=Event/constructor=] of {{PaymentRequestUpdateEvent}} with |type| and |eventInitDict|.
  2. Set |event|.{{PaymentRequestUpdateEvent/[[waitForUpdate]]}} to false.
  3. Return |event|.

updateWith() method

The {{PaymentRequestUpdateEvent/updateWith()}} with |detailsPromise:Promise| method MUST act as follows:

  1. Let |event:PaymentRequestUpdateEvent| be [=this=].
  2. If |event|'s {{Event/isTrusted}} attribute is false, then [=exception/throw=] an {{"InvalidStateError"}} {{DOMException}}.
  3. If |event|.{{PaymentRequestUpdateEvent/[[waitForUpdate]]}} is true, then [=exception/throw=] an {{"InvalidStateError"}} {{DOMException}}.
  4. If |event|'s [=Event/target=] is an instance of {{PaymentResponse}}, let |request:PaymentRequest| be |event|'s [=Event/target=]'s {{PaymentResponse/[[request]]}}.
  5. Otherwise, let |request:PaymentRequest| be the value of |event|'s [=Event/target=].
  6. Assert: |request| is an instance of {{PaymentRequest}}.
  7. If |request|.{{PaymentRequest/[[state]]}} is not "[=PaymentRequest/interactive=]", then [=exception/throw=] an {{"InvalidStateError"}} {{DOMException}}.
  8. If |request|.{{PaymentRequest/[[updating]]}} is true, then [=exception/throw=] an {{"InvalidStateError"}} {{DOMException}}.
  9. Set |event|'s [=Event/stop propagation flag=] and [=Event/stop immediate propagation flag=].
  10. Set |event|.{{PaymentRequestUpdateEvent/[[waitForUpdate]]}} to true.
  11. Let |pmi:URL or null| be null.
  12. If |event| has a {{PaymentMethodChangeEvent/methodName}} attribute, set |pmi| to the {{PaymentMethodChangeEvent/methodName}} attribute's value.
  13. Run the update a PaymentRequest's details algorithm with |detailsPromise|, |request|, and |pmi|.

Internal Slots

Instances of {{PaymentRequestUpdateEvent}} are created with the internal slots in the following table:

Internal Slot Description (non-normative)
[[\waitForUpdate]] A boolean indicating whether an {{PaymentRequestUpdateEvent/updateWith()}}-initiated update is currently in progress.

PaymentRequestUpdateEventInit dictionary

            dictionary PaymentRequestUpdateEventInit : EventInit {};
          

Algorithms

When the internal slot {{PaymentRequest/[[state]]}} of a {{PaymentRequest}} object is set to "[=PaymentRequest/interactive=]", the user agent will trigger the following algorithms based on user interaction.

Can make payment algorithm

The can make payment algorithm checks if the user agent supports making payment with the payment methods with which the {{PaymentRequest}} was constructed.

  1. Let |request:PaymentRequest| be the {{PaymentRequest}} object on which the method was called.
  2. If |request|.{{PaymentRequest/[[state]]}} is not "[=PaymentRequest/created=]", then return a promise rejected with an {{"InvalidStateError"}} {{DOMException}}.
  3. Optionally, at the top-level browsing context's discretion, return a promise rejected with a {{"NotAllowedError"}} {{DOMException}}.

    This allows user agents to apply heuristics to detect and prevent abuse of the calling method for fingerprinting purposes, such as creating {{PaymentRequest}} objects with a variety of supported payment methods and triggering the can make payment algorithm on them one after the other. For example, a user agent may restrict the number of successful calls that can be made based on the top-level browsing context or the time period in which those calls were made.

  4. Let |hasHandlerPromise:Promise| be a new promise.
  5. Return |hasHandlerPromise|, and perform the remaining steps in parallel.
  6. For each |paymentMethod| tuple in |request|. {{PaymentRequest/[[serializedMethodData]]}}:
    1. Let |identifier| be the first element in the |paymentMethod| tuple.
    2. If the user agent has a payment handler that supports handling payment requests for |identifier|, resolve |hasHandlerPromise| with true and terminate this algorithm.
  7. Resolve |hasHandlerPromise| with false.

Payment method changed algorithm

A payment handler MAY run the payment method changed algorithm when the user changes payment method with |methodDetails|, which is a dictionary or an {{object}} or null, and a |methodName|, which is a DOMString that represents the payment method identifier of the payment handler the user is interacting with.

  1. Let |request:PaymentRequest| be the {{PaymentRequest}} object that the user is interacting with.
  2. Queue a task on the user interaction task source to run the following steps:
    1. Assert: |request|.{{PaymentRequest/[[updating]]}} is false. Only one update can take place at a time.
    2. Assert: |request|.{{PaymentRequest/[[state]]}} is "[=PaymentRequest/interactive=]".
    3. Fire an event named "paymentmethodchange" at |request| using {{PaymentMethodChangeEvent}}, with its {{PaymentMethodChangeEvent/methodName}} attribute initialized to |methodName|, and its {{PaymentMethodChangeEvent/methodDetails}} attribute initialized to |methodDetails|.

PaymentRequest updated algorithm

The PaymentRequest updated algorithm is run by other algorithms above to fire an event to indicate that a user has made a change to a {{PaymentRequest}} called |request| with an event name of |name|:

  1. Assert: |request|.{{PaymentRequest/[[updating]]}} is false. Only one update can take place at a time.
  2. Assert: |request|.{{PaymentRequest/[[state]]}} is "[=PaymentRequest/interactive=]".
  3. Let |event:PaymentRequestUpdateEvent| be the result of creating an event using the {{PaymentRequestUpdateEvent}} interface.
  4. Initialize |event|'s {{Event/type}} attribute to |name|.
  5. Dispatch |event| at |request|.
  6. If |event|.{{PaymentRequestUpdateEvent/[[waitForUpdate]]}} is true, disable any part of the user interface that could cause another update event to be fired.
  7. Otherwise, set |event|.{{PaymentRequestUpdateEvent/[[waitForUpdate]]}} to true.

User accepts the payment request algorithm

The user accepts the payment request algorithm runs when the user accepts the payment request and confirms that they want to pay. It MUST queue a task on the user interaction task source to perform the following steps:

  1. Let |request:PaymentRequest| be the {{PaymentRequest}} object that the user is interacting with.
  2. If the |request|.{{PaymentRequest/[[updating]]}} is true, then terminate this algorithm and take no further action. The user agent user interface SHOULD ensure that this never occurs.
  3. If |request|.{{PaymentRequest/[[state]]}} is not "[=PaymentRequest/interactive=]", then terminate this algorithm and take no further action. The user agent user interface SHOULD ensure that this never occurs.
  4. Let |isRetry:boolean| be true if |request|.{{PaymentRequest/[[response]]}} is not null, false otherwise.
  5. Let |response:PaymentResponse| be |request|.{{PaymentRequest/[[response]]}} if |isRetry| is true, or a new {{PaymentResponse}} otherwise.
  6. If |isRetry| if false, initialize the newly created |response|:
    1. Set |response|.{{PaymentResponse/[[request]]}} to |request|.
    2. Set |response|.{{PaymentResponse/[[retryPromise]]}} to null.
    3. Set |response|.{{PaymentResponse/[[complete]]}} to false.
    4. Set the {{PaymentResponse/requestId}} attribute value of |response| to the value of |request|.{{PaymentRequest/[[details]]}}.{{PaymentDetailsInit/id}}.
    5. Set |request|.{{PaymentRequest/[[response]]}} to |response|.
  7. Let |handler:payment handler| be |request|.{{PaymentRequest/[[handler]]}}.
  8. Set the {{PaymentResponse/methodName}} attribute value of |response| to the payment method identifier of |handler|.
  9. Set the {{PaymentResponse/details}} attribute value of |response| to an object resulting from running the |handler|'s steps to respond to a payment request.
  10. Set |request|.{{PaymentRequest/[[state]]}} to "[=PaymentRequest/closed=]".
  11. If |isRetry| is true, resolve |response|.{{PaymentResponse/[[retryPromise]]}} with undefined. Otherwise, resolve |request|.{{PaymentRequest/[[acceptPromise]]}} with |response|.

User aborts the payment request algorithm

The user aborts the payment request algorithm runs when the user aborts the payment request through the currently interactive user interface. It MUST queue a task on the user interaction task source to perform the following steps:

  1. Let |request:PaymentRequest| be the {{PaymentRequest}} object that the user is interacting with.
  2. If |request|.{{PaymentRequest/[[state]]}} is not "[=PaymentRequest/interactive=]", then terminate this algorithm and take no further action. The user agent user interface SHOULD ensure that this never occurs.
  3. Set |request|.{{PaymentRequest/[[state]]}} to "[=PaymentRequest/closed=]".
  4. Set |request|'s payment-relevant browsing context's payment request is showing boolean to false.
  5. Let |error| be an {{"AbortError"}} {{DOMException}}.
  6. Let |response:PaymentResponse| be |request|.{{PaymentRequest/[[response]]}}.
  7. If |response| is not null:
    1. Set |response|.{{PaymentResponse/[[complete]]}} to true.
    2. Assert: |response|.{{PaymentResponse/[[retryPromise]]}} is not null.
    3. Reject |response|.{{PaymentResponse/[[retryPromise]]}} with |error|.
  8. Otherwise, reject |request|.{{PaymentRequest/[[acceptPromise]]}} with |error|.
  9. Abort the current user interaction and close down any remaining user interface.

Update a PaymentRequest's details algorithm

The update a PaymentRequest's details algorithm takes a {{PaymentDetailsUpdate}} |detailsPromise|, a {{PaymentRequest}} |request|, and |pmi| that is either a DOMString or null (a payment method identifier). The steps are conditional on the |detailsPromise| settling. If |detailsPromise| never settles then the payment request is blocked. The user agent SHOULD provide the user with a means to abort a payment request. Implementations MAY choose to implement a timeout for pending updates if |detailsPromise| doesn't settle in a reasonable amount of time.

In the case where a timeout occurs, or the user manually aborts, or the payment handler decides to abort this particular payment, the user agent MUST run the user aborts the payment request algorithm.

  1. Set |request|.{{PaymentRequest/[[updating]]}} to true.
  2. In parallel, disable the user interface that allows the user to accept the payment request. This is to ensure that the payment is not accepted until the user interface is updated with any new details.
  3. Upon rejection of |detailsPromise|:
    1. Abort the update with |request| and an {{"AbortError"}} {{DOMException}}.
  4. Upon fulfillment of |detailsPromise| with value |value|:
    1. Let |details:PaymentDetailsUpdate| be the result of [=converted to an IDL value|converting=] |value| to a {{PaymentDetailsUpdate}} dictionary. If this [=exception/throw=] an exception, abort the update with |request| and with the thrown exception.
    2. Let |serializedModifierData| be an empty list.
    3. Validate and canonicalize the details:
      1. If the {{PaymentDetailsUpdate/total}} member of |details| is present, then:
        1. Check and canonicalize total amount |details|.{{PaymentDetailsUpdate/total}}.{{PaymentItem/amount}}. If an exception is thrown, then abort the update with |request| and that exception.
      2. If the {{PaymentDetailsBase/displayItems}} member of |details| is present, then for each |item| in |details|.{{PaymentDetailsBase/displayItems}}:
        1. Check and canonicalize amount |item|.{{PaymentItem/amount}}. If an exception is thrown, then abort the update with |request| and that exception.
      3. If the {{PaymentDetailsBase/modifiers}} member of |details| is present, then:
        1. Let |modifiers| be the sequence |details|.{{PaymentDetailsBase/modifiers}}.
        2. Let |serializedModifierData| be an empty list.
        3. For each {{PaymentDetailsModifier}} |modifier| in |modifiers|:
          1. Run the steps to validate a payment method identifier with |modifier|.{{PaymentDetailsModifier/supportedMethods}}. If it returns false, then abort the update with |request| and a {{RangeError}} exception. Optionally, inform the developer that the payment method identifier is invalid.
          2. If the {{PaymentDetailsModifier/total}} member of |modifier| is present, then:
            1. Check and canonicalize total amount |modifier|.{{PaymentDetailsModifier/total}}.{{PaymentItem/amount}}. If an exception is thrown, then abort the update with |request| and that exception.
          3. If the {{PaymentDetailsModifier/additionalDisplayItems}} member of |modifier| is present, then for each {{PaymentItem}} |item| in |modifier|.{{PaymentDetailsModifier/additionalDisplayItems}}:
            1. Check and canonicalize amount |item|.{{PaymentItem/amount}}. If an exception is thrown, then abort the update with |request| and that exception.
          4. If the {{PaymentDetailsModifier/data}} member of |modifier| is missing, let |serializedData| be null. Otherwise, let |serializedData| be the result of JSON-serializing |modifier|.{{PaymentDetailsModifier/data}} into a string. If JSON-serializing throws an exception, then abort the update with |request| and that exception.
          5. Add |serializedData| to |serializedModifierData|.
          6. Remove the {{PaymentDetailsModifier/data}} member of |modifier|, if it is present.
    4. If the {{PaymentDetailsUpdate/paymentMethodErrors}} member is present and |identifier| is not null:
      1. If required by the specification that defines the |pmi|, then [=converted to an IDL value|convert=] {{PaymentDetailsUpdate/paymentMethodErrors}} to an IDL value.
      2. If conversion results in a exception |error|, abort the update with |error|.
      3. The payment handler SHOULD display an error for each relevant erroneous field of {{PaymentDetailsUpdate/paymentMethodErrors}}.
    5. Update the {{PaymentRequest}} using the new details:
      1. If the {{PaymentDetailsUpdate/total}} member of |details| is present, then:
        1. Set |request|.{{PaymentRequest/[[details]]}}.{{PaymentDetailsInit/total}} to |details|.{{PaymentDetailsUpdate/total}}.
      2. If the {{PaymentDetailsBase/displayItems}} member of |details| is present, then:
        1. Set |request|.{{PaymentRequest/[[details]]}}.{{PaymentDetailsBase/displayItems}} to |details|.{{PaymentDetailsBase/displayItems}}.
      3. If the {{PaymentDetailsBase/modifiers}} member of |details| is present, then:
        1. Set |request|.{{PaymentRequest/[[details]]}}.{{PaymentDetailsBase/modifiers}} to |details|.{{PaymentDetailsBase/modifiers}}.
        2. Set |request|.{{PaymentRequest/[[serializedModifierData]]}} to |serializedModifierData|.
  5. Set |request|.{{PaymentRequest/[[updating]]}} to false.
  6. Update the user interface based on any changed values in |request|. Re-enable user interface elements disabled prior to running this algorithm.

Abort the update

To abort the update with a {{PaymentRequest}} |request| and exception |exception|:

  1. Optionally, show an error message to the user when letting them know an error has occurred.
  2. Abort the current user interaction and close down any remaining user interface.
  3. Queue a task on the user interaction task source to perform the following steps:
    1. Set |request|'s payment-relevant browsing context's payment request is showing boolean to false.
    2. Set |request|.{{PaymentRequest/[[state]]}} to "[=PaymentRequest/closed=]".
    3. Let |response:PaymentResponse| be |request|.{{PaymentRequest/[[response]]}}.
    4. If |response| is not null, then:
      1. Set |response|.{{PaymentResponse/[[complete]]}} to true.
      2. Assert: |response|.{{PaymentResponse/[[retryPromise]]}} is not null.
      3. Reject |response|.{{PaymentResponse/[[retryPromise]]}} with |exception|.
    5. Otherwise, reject |request|.{{PaymentRequest/[[acceptPromise]]}} with |exception|.
    6. Set |request|.{{PaymentRequest/[[updating]]}} to false.
  4. Abort the algorithm.

Abort the update runs when there is a fatal error updating the payment request, such as the supplied |detailsPromise| rejecting, or its fulfillment value containing invalid data. This would potentially leave the payment request in an inconsistent state since the developer hasn't successfully handled the change event.

Consequently, the {{PaymentRequest}} moves to a "[=PaymentRequest/closed=]" state. The error is signaled to the developer through the rejection of the {{PaymentRequest/[[acceptPromise]]}}, i.e., the promise returned by {{PaymentRequest/show()}}.

Similarly, abort the update occurring during {{PaymentResponse/retry()}} causes the {{PaymentResponse/[[retryPromise]]}} to reject, and the corresponding {{PaymentResponse}}'s {{PaymentResponse/[[complete]]}} internal slot will be set to true (i.e., it can no longer be used).

Privacy and Security Considerations

User protections with show() method

To help ensure that users do not inadvertently share sensitive credentials with an origin, this API requires that PaymentRequest's {{PaymentRequest/show()}} method be invoked while the relevant {{Window}} has [=transient activation=] (e.g., via a click or press).

To avoid a confusing user experience, this specification limits the user agent to displaying one at a time via the {{PaymentRequest/show()}} method. In addition, the user agent can limit the rate at which a page can call {{PaymentRequest/show()}}.

Secure contexts

The API defined in this specification is only exposed in a [=secure context=] - see also the [[[secure-contexts]]] specification for more details. In practice, this means that this API is only available over HTTPS. This is to limit the possibility of payment method data (e.g., credit card numbers) being sent in the clear.

Cross-origin payment requests

It is common for merchants and other payees to delegate checkout and other e-commerce activities to payment service providers through an iframe. This API supports payee-authorized cross-origin iframes through [[HTML]]'s [^iframe/allow^] attribute.

Payment handlers have access to both the origin that hosts the iframe and the origin of the iframe content (where the {{PaymentRequest}} initiates).

Encryption of data fields

The {{PaymentRequest}} API does not directly support encryption of data fields. Individual payment methods may choose to include support for encrypted data but it is not mandatory that all payment methods support this.

How user agents match payment handlers

As part of {{PaymentRequest/show()}}, the user agent typically displays a list of matching payment handlers that satisfy the payment methods accepted by the merchant and other conditions. Matching can take into account payment method information provided as input to the API, information provided by the payment method owner, the payment handlers registered by the user, user preferences, and other considerations.

For security reasons, a user agent can limit matching (in {{PaymentRequest/show()}} and {{PaymentRequest/canMakePayment()}}) to payment handlers from the same origin as a URL payment method identifier.

Data usage

Payment method owners establish the privacy policies for how user data collected for the payment method may be used. Payment Request API sets a clear expectation that data will be used for the purposes of completing a transaction, and user experiences associated with this API convey that intention. It is the responsibility of the payee to ensure that any data usage conforms to payment method policies. For any permitted usage beyond completion of the transaction, the payee should clearly communicate that usage to the user.

Exposing user information

The user agent MUST NOT share information about the user with a developer without user consent.

In particular, the {{PaymentMethodData}}'s {{PaymentMethodData/data}} and {{PaymentResponse}}'s {{PaymentResponse/details}} members allow for the arbitrary exchange of data. In light of the wide range of data models used by existing payment methods, prescribing data specifics in this API would limit its usefulness. The {{PaymentResponse/details}} member carries data from the payment handler, whether Web-based (as defined by the [[[payment-handler]]]) or proprietary. The [=user agent=] MUST NOT support payment handlers unless they include adequate user consent mechanisms (such as awareness of parties to the transaction and mechanisms for demonstrating the intention to share data).

The user agent MUST NOT share the values of the {{PaymentDetailsBase/displayItems}} member or {{PaymentDetailsModifier/additionalDisplayItems}} member with a third-party payment handler without user consent.

The {{PaymentMethodChangeEvent}} enables the payee to update the displayed total based on information specific to a selected payment method. For example, the billing address associated with a selected payment method might affect the tax computation (e.g., VAT), and it is desirable that the user interface accurately display the total before the payer completes the transaction. At the same time, it is desirable to share as little information as possible prior to completion of the payment. Therefore, when a payment method defines the steps for when a user changes payment method, it is important to minimize the data shared via the {{PaymentMethodChangeEvent}}'s {{PaymentMethodChangeEvent/methodDetails}} attribute. Requirements and approaches for minimizing shared data are likely to vary by payment method.

Where sharing of privacy-sensitive information might not be obvious to users (e.g., when [=payment handler/payment method changed algorithm | changing payment methods =]), it is RECOMMENDED that user agents inform the user of exactly what information is being shared with a merchant.

canMakePayment() protections

The {{PaymentRequest/canMakePayment()}} method provides feature detection for different payment methods. It may become a fingerprinting vector if in the future, a large number of payment methods are available. purposes. User agents are expected to protect the user from abuse of the method. For example, user agents can reduce user fingerprinting by:

For rate-limiting the user agent might look at repeated calls from:

These rate-limiting techniques intend to increase the cost associated with repeated calls, whether it is the cost of managing multiple eTLDs or the user experience friction of opening multiple windows (tabs or pop-ups).

Accessibility Considerations

For the user-facing aspects of Payment Request API, implementations integrate with platform accessibility APIs via form controls and other input modalities.

Dependencies

This specification relies on several other underlying specifications.

ISO 3166-2
Country subdivision name and country subdivision code element are defined in [[ISO3166-2]].
ECMAScript
The terms internal slot, and JSON.stringify are defined by [[ECMASCRIPT]].

JSON-serialize runs JSON.stringify, passing the supplied object as the sole argument, and returns the resulting string. This can throw an exception.

There is only one class of product that can claim conformance to this specification: a user agent.

Although this specification is primarily targeted at web browsers, it is feasible that other software could also implement this specification in a conforming manner.

User agents MAY implement algorithms given in this specification in any way desired, so long as the end result is indistinguishable from the result that would be obtained by the specification's algorithms.

User agents MAY impose implementation-specific limits on otherwise unconstrained inputs, e.g., to prevent denial of service attacks, to guard against running out of memory, or to work around platform-specific limitations. When an input exceeds implementation-specific limit, the user agent MUST throw, or, in the context of a promise, reject with, a {{TypeError}} optionally informing the developer of how a particular input exceeded an implementation-specific limit.

Acknowledgements

This specification was derived from a report published previously by the Web Platform Incubator Community Group.

Changelog

Changes from between CR2 until now:

Changes from between CR1 and CR2: