Apple Pay Component

Our Apple Pay Component renders Apple Pay in your payment form. When the shopper selects Apple Pay, the Component invokes the payment sheet where shoppers select the card they want to use, provide contact details and shipping address, and then authenticate the payment through Face ID or Touch ID.

Before you begin

This page explains how to add Apple Pay to your existing Web Components integration. The Web Components integration works the same way for all payment methods. If you haven't done this integration yet, refer to our Components integration guide.

You can either use Adyen's Apple Pay certificate which makes it quicker to set up Apple Pay, or you can also use your own Apple Developer account and certificate which requires extra configuration steps:

Show Apple Pay in your payment form

After you have finished enabling Apple Pay, you can present the Apple Pay Component in your payment form:

1. Make a POST /paymentMethods request specifying:
   • countryCode: Country where Apple Pay is supported. For example, NL.
   • amount.currency: Any supported currency. For example, EUR.

2. Pass the full response from the /paymentMethods call as the paymentMethodsResponse object when creating an instance of the AdyenCheckout.

3. Add the Apple Pay Component:

   a. Create a DOM element, placing it where you want the Apple Pay button to be rendered:

   <div id="applepay-container"></div>

   b. Create an instance of the Apple Pay Component, specifying:

   • amount.currency: The three-character currency code.
   • amount.value: The value of the transaction.
   • countryCode: The two-letter country code of your merchant account.
   • configuration: Object that specifies the merchantName (name that will be displayed on the form) and your Apple merchantId.
     • Required if you're using an Apple Pay Web Component version earlier than v3.17.1.
     • In 3.17.1 and later versions, you can omit this object. By default, the Component takes the values from the paymentMethodsResponse in the AdyenCheckout instance configuration.
   • onValidateMerchant: Event called when the payment sheet is displayed.
     • Required if you're using your own Apple Pay certificate, if you're using a Web Components version earlier than 3.16.0, or if you want to call the event manually. Follow the code samples to learn how to call onValidateMerchant manually. For more information, see Apple Pay documentation.
     • If you're using Adyen's Apple Pay certificate or if you're using 3.16.0 and later versions, you can omit this because the Component calls the event by default.
       If your integration is set up correctly, the Component renders Apple Pay. Otherwise, check if you are receiving correct values in the configuration object from the /paymentMethods response and if you are passing the object to your front end as part of the paymentMethodsResponse in the AdyenCheckout instance configuration.
   https://docs.adyen.com/payment-methods/apple-pay/web-component#component-configuration

   Component configuration

   const appleNode = document.getElementById("applepay-field");
   const applepay = checkout.create("applepay", {
       amount: {
           currency: "EUR",
           value: 1000
         },
       countryCode: "DE",
       // Configuration object is required if using version earlier than v 3.17.1.
       // Omit this object when using version 3.17.1 and later.
       configuration: {
          // Name to be displayed on the form.
          merchantName: "Adyen Test merchant",
          // Your Apple merchant identifier as described in https://developer.apple.com/documentation/apple_pay_on_the_web/applepayrequest/2951611-merchantidentifier
          merchantId: "adyen.test.merchant"
       },
       // Button config
       // Optional. The type of button you want to be displayed in the payments form
       buttonType: "plain",
       // Optional. Specify the color of the button
       buttonColor: "black",
       // onValidateMerchant is required if using your own Apple Pay certificate or Web Components earlier than v3.16.0.
       // Omit this object when using version 3.16.0 and later.
       onValidateMerchant: (resolve, reject, validationURL) => {
           // Your server uses the validation URL to request a session from the Apple Pay server.
           // Call resolve(MERCHANTSESSION) or reject() to complete merchant validation.
         validateMerchant(validationURL)
           .then(response => {
             // Complete merchant validation with resolve(MERCHANTSESSION) after receiving an opaque merchant session object, MerchantSession
             resolve(response);
           })
           .catch(error => {
             // Complete merchant validation with reject() if any error occurs
             reject();
           });
       },
       // You can optionally override the onSubmit or onChange already defined in your AdyenCheckout instance
       onChange: (state, component) => {
         // Call your server to make `/payments` request
         makePayment(state.data)
           .then(response => {
             // Your function to show the final result to the shopper
             showFinalResult(response);
           })
           .catch(error => {
             throw Error(error);
           });
       }
   });

   c. Check whether Apple Pay is available to the shopper. If it is, mount the Component:

   Do not mount the Component if Apple Pay is not available to the shopper.

   applepay
       .isAvailable()
       .then(() => {
           applepay.mount("#applepay-container");
       })
       .catch(e => {
           // Apple Pay is not available
       });

Optional Component configuration

With the Apple Pay Component, you can also:

• Configure the appearance of the Apple Pay button.
• Include additional data such as transaction information, fields for billing and shipping contact information.
• Add logic for specific events on your payment form.

Button configuration

Payment request data

Events

The following event handlers are supported for Apple Pay. Select the event handler names to see the related Apple Pay documentation.

Event	Required	Description
onChange or onSubmit		Called after the shopper authorizes the payment with Apple Pay. The first parameter (state) of this function contains all the necessary data to make a payment using the /payments API.
onClick(resolve,reject)		Called when the shopper clicks the Apple Pay button. Call resolve() to continue or reject() stop the payment flow. You must create the Apple Pay session from a user gesture handler.
onValidateMerchant		Called when the payment sheet is displayed.
onAuthorized		Also called after the shopper authorizes the payment with Apple Pay. This contains all the raw event from Apple Pay.
onPaymentMethodSelected		Called when the shopper selects a new payment method.
onShippingContactSelected		Called when the shopper selects a shipping contact.
onShippingMethodSelected		Called when the shopper selects a shipping method.

    //onSubmit or onChange defined in your AdyenCheckout instance
    const applepay = checkout.create("applepay", {
        ...
        onValidateMerchant: (resolve, reject, validationURL) => {
        // Calls your server with validationURL, which then requests a payment session from Apple Pay servers.
        // Your server then receives the session and calls resolve(MERCHANTSESSION) or reject() to complete merchant validation.
        },

        onAuthorized: (resolve, reject, event) => {},

        /*
        * @param resolve(ApplePayPaymentMethodUpdate update) Completes the selection of a payment method with an update. This will call https://developer.apple.com/documentation/apple_pay_on_the_web /applepaysession/1777995-completepaymentmethodselection.
        * @param reject(ApplePayPaymentMethodUpdate update)
        * @param event The event parameter contains the paymentMethod attribute.
        */
        onPaymentMethodSelected: (resolve, reject, event) => {},

        /*
        * @param resolve(ApplePayShippingContactUpdate update) Completes the selection of a shipping contact with an update. This will call https://developer.apple.com/documentation/apple_pay_on_the_web/applepaysession/1778008-completeshippingcontactselection.
        * @param reject(ApplePayShippingContactUpdate update)
        * @param event The event parameter contains the shippingContact attribute.
        */
        onShippingContactSelected: (resolve, reject, event) => {},

        /*
        * @param resolve(ApplePayShippingMethodUpdate update) Completes the selection of a shipping method with an update. Will call https://developer.apple.com/documentation/apple_pay_on_the_web/applepaysession/1778024-completeshippingmethodselection
        * @param reject(ApplePayShippingMethodUpdate update)
        * @param event The event parameter contains the shippingMethod attribute.
        */
        onShippingMethodSelected: (resolve, reject, event) => {}
        ...

Make a payment

When the shopper selects to pay, the Component calls the onChange event, which contains a state.data.

1. If state.isValid is true, collect the state.data and pass this to your server.

2. From your server, make a /payments, specifying:

   • paymentMethod: The state.data.paymentMethod from the onChange event from your front end.
   https://docs.adyen.com/payment-methods/apple-pay/web-component#apple-pay-api

   • curl
   • Ruby
   • Java
   • PHP
   • Python
   • C#
   • NodeJS

   curl Ruby Java PHP Python C# NodeJS

   curl https://checkout-test.adyen.com/v66/payments \
   -H "x-API-key: YOUR_X-API-KEY" \
   -H "content-type: application/json" \
   -d '{
     "merchantAccount":"YOUR_MERCHANT_ACCOUNT",
     "reference":"YOUR_ORDER_NUMBER",
     "amount":{
       "currency":"EUR",
       "value":1000
     },
     "{hint:state.data.paymentMethod from onChange or onSubmit}paymentMethod{/hint}":{
       "type":"applepay",
       "applePayToken": "QWIwMmI0YzAhQlFBQkFnQjMv.."
     }
   }'

   # Set your X-API-KEY with the API key from the Customer Area.
   adyen = Adyen::Client.new
   adyen.api_key = "YOUR_X-API-KEY"
    
   response = adyen.checkout.payments({
     :amount => {
       :currency => "EUR",
       :value => 1000
     },
     :reference => "YOUR_ORDER_NUMBER",
     :paymentMethod => {
       :type => "applepay",
       :applePayToken => "QWIwMmI0YzAhQlFBQkFnQjMv.."
     },
     :merchantAccount => "YOUR_MERCHANT_ACCOUNT"
   })

   // Set YOUR_X-API-KEY with the API key from the Customer Area.
   // Change to Environment.LIVE and add the Live URL prefix when you're ready to accept live payments.
       Client client = new Client("YOUR_X-API-KEY", Environment.TEST);
       Checkout checkout = new Checkout(client);
   
       PaymentsRequest paymentsRequest = new PaymentsRequest();
   
       String merchantAccount = "YOUR_MERCHANT_ACCOUNT";
       paymentsRequest.setMerchantAccount(merchantAccount);
   
       Amount amount = new Amount();
       amount.setCurrency("EUR");
       amount.setValue(15000L);
       paymentsRequest.setAmount(amount);
   
       ApplePayDetails applePayDetails = new ApplePayDetails();
   
       applePayDetails.setApplePayToken(state.data.paymentMethod.applePayToken);
       paymentsRequest.setPaymentMethod(applePayDetails);
   
       paymentsRequest.setReference("YOUR_ORDER_NUMBER");
   
       PaymentsResponse paymentsResponse = checkout.payments(paymentsRequest);

   // Set your X-API-KEY with the API key from the Customer Area.
   $client = new \Adyen\Client();
   $client->setXApiKey("YOUR_X-API-KEY");
   $service = new \Adyen\Service\Checkout($client);
   
   $params = array(
     "amount" => array(
       "currency" => "EUR",
       "value" => 1000
     ),
     "reference" => "YOUR_ORDER_NUMBER",
     "paymentMethod" => array(
       "type" => "applepay",
       "applePayToken" => "QWIwMmI0YzAhQlFBQkFnQjMv.."
     ),
     "merchantAccount" => "YOUR_MERCHANT_ACCOUNT"
   );
   $result = $service->payments($params);

   #Set your X-API-KEY with the API key from the Customer Area.
   adyen = Adyen.Adyen()
   adyen.client.xapikey = 'YOUR_X-API-KEY'
   
   result = adyen.checkout.payments({
      'amount': {
         'value': 1000,
         'currency': 'EUR'
      },
      'reference': 'YOUR_ORDER_NUMBER',
      'paymentMethod': {
         'type': 'applepay',
         'applePayToken': 'QWIwMmI0YzAhQlFBQkFnQjMv..'
      },
      'merchantAccount': 'YOUR_MERCHANT_ACCOUNT'
   })

   // Set your X-API-KEY with the API key from the Customer Area.
   var client = new Client ("YOUR_X-API-KEY", Environment.Test);
   var checkout = new Checkout(client);
   
   var amount = new Model.Checkout.Amount("EUR", 1000);
   var details = new Model.Checkout.DefaultPaymentMethodDetails{
     Type = "applepay",
     ApplePayToken = "QWIwMmI0YzAhQlFBQkFnQjMv.."
   };
   var paymentRequest = new Adyen.Model.Checkout.PaymentRequest
   {
     Reference = "YOUR_ORDER_NUMBER",
     Amount = amount,
     MerchantAccount = "YOUR_MERCHANT_ACCOUNT",
     PaymentMethod = details
   };
   
   var paymentResponse = checkout.Payments(paymentsRequest);

   // Set your X-API-KEY with the API key from the Customer Area.
   const {Client, Config, CheckoutAPI} = require('@adyen/api-library');
   const config = new Config();
   // Set your X-API-KEY with the API key from the Customer Area.
   config.apiKey = '[API_KEY]';
   config.merchantAccount = '[YOUR_MERCHANT_ACCOUNT]';
   const client = new Client({ config });
   client.setEnvironment("TEST");
   const checkout = new CheckoutAPI(client);
   checkout.payments({
       amount: { currency: "EUR", value: 1000 },
       paymentMethod: {
           type: 'applepay',
           applePayToken: 'QWIwMmI0YzAhQlFBQkFnQjMv..'
       },
       reference: "YOUR_ORDER_NUMBER",
       merchantAccount: config.merchantAccount
   }).then(res => res);

   The response contains the result of the payment.

   https://docs.adyen.com/payment-methods/apple-pay/web-component#-payments-response

   /payments response

   {
     "pspReference": "881539337151149C",
     "resultCode": "Authorised"
   }

Present the payment result

Use the resultCode that you received in response to your /payments call to present the payment result to your shopper.

The resultCode values you can receive for Apple Pay are:

Recurring payments

To make recurring Apple Pay payments, you first need to create a shopper token and then make subsequent recurring transactions with the token.

Refer to Tokenization for more information and detailed instructions.

Test and go live

Use Apple's test card numbers to test your integration.

For a full list of test cards and instructions how to add these to your test device, see Sandbox testing on Apple's Developer website.

Check the status of an Apple Pay test payment in your Customer Area > Transactions >  Payments.

Going live

To process live Apple Pay payments, your API credential needs to have the API Clientside Encryption Payments role. You can check this in your live Customer Area or ask your Admin user to verify.

Make sure you follow Apple's guidelines on:

• Designing your Apple Pay integration.

See also