Amazon Pay Drop-in

Our Web Drop-in renders Amazon Pay in your payment form. When clicking the Amazon Pay button, the component redirects the shopper to an Amazon Pay hosted page where they select the details of the purchase before reviewing and confirming the order. This is supported from Web Drop-in 4.1.0.

Requirements

Register for Amazon Pay

Sign up for a merchant account on the Amazon Pay website. After the registration is complete, return to this page. Select the correct region for your account from the list below.

• EU Registration — For merchants with a legal entity in one of the following locations: Austria, Belgium, Cyprus, Denmark, France, Germany, Hungary, Ireland, Italy, Luxembourg, the Netherlands, Portugal, Spain, Sweden, or Switzerland. Select EUR as a currency in the registration page.
• UK Registration — For merchants with a legal entity in the United Kingdom.
• US Registration - For merchants with a legal entity in the United States.

Create an Amazon Pay Sandbox test buyer account

Use Sandbox to conduct end-to-end tests of your integration before going live. For details, see Amazon Pay Sandbox accounts. After creating an Amazon Pay Sandbox account, return to this page.

Get your PublicKeyId and give information to Adyen

Amazon Pay uses asymmetric encryption to secure communication. Therefore, you need a public/private key pair.

To set this up, you must have one of the following user roles.

• Merchant admin
• Manage API Credentials

1. Log in to your Customer Area and select the merchant account you want to set up Amazon Pay for.
2. Select Developers > API credentials. Select the web service user that you will use for Amazon Pay transactions.
3. In Wallet payment methods > Amazon Pay certificate, select + Add.
4. Select Generate key pair.
5. Copy the the public key and send it to your Amazon Pay contact.
6. Receive the publicKeyId from your Amazon Pay contact.
7. Send the following to our Support Team:
   • publicKeyId
   • amazonMerchantId: You can find this in your Amazon Seller Central or ask your Amazon Pay contact for it.
   • amazonStoreId: You can find this in your Amazon Seller Central or ask your Amazon Pay contact for it.
     We configure Amazon Pay for you after receiving your information.

Import resources for v6

If you are using Web Drop-in v6, import the resources you need for Amazon Pay:

import { AdyenCheckout, AmazonPay} from '@adyen/adyen-web'

Show Amazon Pay in your payment page

After you have finished configuring Amazon Pay, you can show the Amazon Pay button in your payment form:

1. Make a /paymentMethods request with one of the supported combinations of countryCode and amount.currency.
2. When creating an instance of Drop-in, make sure you are adding an amount object containing the currency and value of the payment, in minor units.

When the shopper clicks the Amazon Pay button, they are redirected to the Amazon website to log in and select the payment details.

Drop-in configuration

When creating an instance of Drop-in, you can also:

• Configure the appearance of the Amazon Pay button.
• Change productType.
• Include additional data, such as address and merchant metadata.

Here's an example of the Amazon Pay Drop-in configuration for a payment of USD 30 once a month:

const dropin = checkout
    .create('dropin', {
        // ...
        paymentMethodsConfiguration: {
            amazonpay: { // Optional configuration for Amazon Pay
                productType: 'PayAndShip',
                merchantMetadata: {
                    merchantReferenceId: 'Merchant-order-123',
                    merchantStoreName: 'MyStore',
                    noteToBuyer: 'Thank you for your order'
                },
                chargePermissionType: 'Recurring', // For a recurring payment
                recurringMetadata: { // For a payment that happens once a month
                  frequency: {
                    unit: 'Month',
                    value: '1'
                  },
                  amount: {
                    amount: '30'
                    currencyCode: 'USD'
                  }
                },
                addressDetails: {
                    name: 'Simon Hopper',
                    addressLine1: 'Broadway 8-10',
                    city: 'London',
                    postalCode: 'SW1H 0BG',
                    countryCode: 'GB',
                    phoneNumber: '+44 203 936 4029'
                },
                environment: 'test',
                returnUrl: 'https://example.com/process_payment'
            }
        }
    })
    .mount('#dropin');

Handle the redirect

When the shopper confirms the payment, they are redirected back to the returnUrl with the amazonCheckoutSessionId attached to the URL. Use the amazonCheckoutSessionId to create an instance of the Amazon Pay Component to make the actual payment.

1. Create a DOM element for the Component, placing it where you want it to be rendered. At this point of the flow, the Component doesn't show anything. This page executes the logic of the payment and handles any additional shopper interaction. The Component uses this node, for example, in case a 3D Secure 2 challenge needs to be displayed.

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

2. Define a handleOnSubmit function to be passed to the Component configuration object as a value for the onSubmit parameter. The function should accept the state.data object from the Drop-in as an input, and trigger the backend function that you define, which executes the /payments API call.

   onSubmit: (state, component) => {
     component.setStatus('loading');
   
     // Merchant's function to make a payment
     return makePayment(state.data)
         .then(response => {
             component.setStatus('ready');
             if (response.action) {
                 // Handle additional action (3D Secure / redirect / other)
                 component.handleAction(response.action);
             } else {
                 // The merchant's function to show the final result or redirect to a final status page
                 handleFinalResult(response);
             }
         })
         .catch(error => {
             // Handle error;
         });
   }

3. Create an instance of the Amazon Pay Component and pass amazonCheckoutSessionId. Hide the Order button by setting showOrderButton to false. After the Component is mounted, trigger the submit function which should be defined in the Adyen Checkout constructor.

   const amazonPayComponent = checkout
     .create('amazonpay', {
         amazonCheckoutSessionId: '...',
         showOrderButton: false
     })
     .mount('#amazonpay_payment-container');
   
   amazonPayOrder.submit();

   This will call the onSubmit event, which contains a state.data object. Pass the object to the server to make a payment and parse the result of the payment.

Make a payment

From your server, make a /payments request, specifying the following parameters:

• paymentMethod: The state.data.paymentMethod from the onSubmit event from your front end.
• returnUrl: The URL where the shopper will be redirected back to after completing the payment. The URL should include the protocol: http:// or https://. For example, https://your-company.com/checkout/. You can also include your own additional query parameters, for example, shopper ID or order reference number.

The /payments response contains:

• pspReference: Adyen's unique reference for the payment.
• resultCode: Authorised

Handle the decline flow

In case of a credit card decline due to card expiration or insufficient funds, redirect the shopper back to the Amazon Pay payment method selection page. You can do this by calling the handleDeclineFlow from the Amazon Pay Component.

This flow lets you recover from a declined payment as described in the Amazon Pay documentation.

onSubmit: async (state, component) => {
    try {
        const response = await makePayment(state.data);
        // Check the result code
        if (response.resultCode && checkPaymentResponse(response.resultCode)) {
            // Show successful message
        } else {
            // Handle decline flow
            amazonPayComponent.handleDeclineFlow();
        }
    } catch (error) {
        // Fatal error
    }
},
onError: (error) => {
    if (error.resultCode) {
        // Show payment failed message or start over the flow.
    } else {
        // Fatal error
    }
}

Present the payment result

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

The resultCode values you can receive for Amazon Pay are:

If the shopper failed to return to your website or app, wait for webhooks to know the outcome of the payment. The webhooks you can receive for Amazon Pay are:

Optional. Sign out from Amazon

After the transaction is finished, and the result is shown to the shopper, display a button to let them sign out from the Amazon account.

1. Create a DOM element for the Sign out button, placing it where you want it to be rendered:

   <div id="amazonpay_signout"></div>

2. Create an instance of the Amazon Pay Component and pass the amazonCheckoutSessionId along with showSignOutButton set to true.

   const amazonPayComponent = checkout
     .create('amazonpay', {
         amazonCheckoutSessionId: '...',
         showSignOutButton: true
     })
     .mount('#amazonpay_signout');

Recurring payments

We support recurring transactions for Amazon Pay. To make recurring payments, you need to:

1. Create a shopper token.
2. Use the token to make future payments for the shopper.

Create a token

To create a token, include in your /payments request:

• storePaymentMethod: true
• shopperReference: Your unique identifier for the shopper.

When the payment has been settled, you receive a webhook containing:

• eventCode: RECURRING_CONTRACT
• originalReference: The pspReference of the initial payment.
• pspReference: This is the token that you need to make recurring payments for this shopper.

Make a payment with a token

To make a payment with the token, include in your /payments request:

• paymentMethod.storedPaymentMethodId: The pspReference from the RECURRING_CONTRACT.

  You can also get this value using the /listRecurringDetails endpoint.

• shopperReference: The unique shopper identifier that you specified when creating the token.

• shopperInteraction: ContAuth.

• recurringProcessingModel: Subscription or UnscheduledCardOnFile.

For more information about the shopperInteraction and recurringProcessingModel fields, refer to Tokenization.

Test and go live

To test Amazon Pay, you must follow the Amazon Pay testing guidelines.

You can check the status of an Amazon Pay test payment in your Customer Area > Transactions > Payments.

Before you can accept live Amazon Pay payments, you need to submit a request for Amazon Pay in your live Customer Area.

See also