---
title: "Amazon Pay for API-only"
description: "Add Amazon Pay to an existing API-only integration."
url: "https://docs.adyen.com/payment-methods/amazon-pay/api-only"
source_url: "https://docs.adyen.com/payment-methods/amazon-pay/api-only.md"
canonical: "https://docs.adyen.com/payment-methods/amazon-pay/api-only"
last_modified: "2023-11-13T10:09:00+01:00"
language: "en"
---

# Amazon Pay for API-only

Add Amazon Pay to an existing API-only integration.

These instructions explain how to add Amazon Pay to your existing API only integration.

## Requirements

| Requirement          | Description                                                                                                                                          |
| -------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Integration type** | Make sure that you have built an [API-only integration](/online-payments/build-your-integration/advanced-flow?platform=Web\&integration=API%20only). |
| **Setup steps**      | Before you begin, [add Amazon Pay in your test Customer Area](/payment-methods/add-payment-methods).                                                 |

## Prepare your integration

Before starting your Amazon Pay integration:

1. [Register with Amazon for an Amazon Pay account](https://developer.amazon.com/docs/amazon-pay-checkout/get-set-up-for-integration.html).
2. Follow the steps on [Amazon Pay's documentation](https://developer.amazon.com/docs/amazon-pay-checkout/overview.html) to integrate with Amazon Pay.
3. [Check if your payments are affected by PSD2](/online-payments/psd2-sca-compliance-and-implementation-guide#are-my-payments-affected). If your payments are affected, [implement 3D Secure authentication](/online-payments/3d-secure#your-3d-secure-implementation-options) to comply with PSD2.

## Build your payment form for Amazon Pay

Show Amazon Pay as an available payment method in [countries/regions where Amazon Pay is supported](/payment-methods/amazon-pay/#supported-countries). When the shopper selects Amazon Pay, they are presented with the payment form.

We provide logos for Amazon Pay which you can use on your payment form. For more information, refer to [Downloading logos](/online-payments/build-your-integration/advanced-flow/?platform=Web\&integration=API%20only#downloading-logos).

You can also submit a [/paymentMethods](https://docs.adyen.com/api-explorer/Checkout/latest/post/paymentMethods) request specifying:

* [countryCode](https://docs.adyen.com/api-explorer/Checkout/latest/post/paymentMethods): Countries/regions where Amazon Pay is supported. For example, **NL**.
* [amount.currency](https://docs.adyen.com/api-explorer/Checkout/latest/post/paymentMethods#request-amount): You can only accept payments in the currency that you used when you registered with Amazon Pay. For example, **EUR**.

In the response, you receive `paymentMethod.type`: **amazonpay**.

**/paymentMethods response**

```json
{
    "configuration": {
          "merchantId": "YOUR_AMAZON_PAY_MERCHANT_ID",
          "storeId": "YOUR_AMAZON_PAY_STORE_ID",
          "publicKeyId": "YOUR_AMAZON_PAY_PUBLIC_KEY_ID"
    },
    "details": [
        {
            "key": "amazonPayToken",
            "type": "text"
        }
    ],
    "name": "Amazon Pay",
    "type": "amazonpay",
}
```

## Make a payment

Refer to [Amazon Pay's documentation](https://developer.amazon.com/docs/amazon-pay-checkout/overview.html) to integrate with Amazon Pay.

1. [Create a checkout session](https://developer.amazon.com/docs/amazon-pay-api-v2/checkout-session.html) and follow all subsequent steps as described in Amazon Pay's documentation.

2. Make a [Get Checkout Session call](https://developer.amazon.com/docs/amazon-pay-api-v2/checkout-session.html#get-checkout-session) to get the [ `amazonPayToken` ](https://amazonpaylegacyintegrationguide.s3.amazonaws.com/docs/amazon-pay-onetime/access-tokens.html)from the response.

3. From your server, make a [/payments](https://docs.adyen.com/api-explorer/Checkout/latest/post/payments) request, providing:

   * `paymentMethod.type`: **amazonpay**
   * `paymentMethod.amazonPayToken`: This is the `amazonPayToken` that you obtained from the [Get Checkout Session](https://developer.amazon.com/docs/amazon-pay-api-v2/checkout-session.html#get-checkout-session) response.
   * `browserInfo`: Required if you are implementing 3D Secure. The shopper's browser information.

If you are implementing [native 3D Secure](/online-payments/3d-secure#implementation-options), you also need to include other [additional parameters](/online-payments/3d-secure/native-3ds2/web-component#make-a-payment) in your request.

The following example shows how to make a payment request for Amazon Pay if you are not implementing 3D Secure.

#### curl

```bash
curl https://checkout-test.adyen.com/v68/payments \
-H 'x-api-key: ADYEN_API_KEY' \
-H 'content-type: application/json' \
-d '{
  "amount": {
    "currency": "EUR",
    "value": 1000
  },
  "reference": "YOUR_ORDER_NUMBER",
  "paymentMethod": {
    "type": "amazonpay",
    "amazonPayToken":"160583287597AMZN"
  },
  "returnUrl": "https://your-company.example.com/checkout?shopperOrder=12xy..",
  "merchantAccount": "ADYEN_MERCHANT_ACCOUNT"
}'
```

#### Java

```java
// Adyen Java API Library v27.0.0
import com.adyen.Client;
import com.adyen.enums.Environment;
import com.adyen.model.checkout.*;
import java.time.OffsetDateTime;
import java.util.*;
import com.adyen.model.RequestOptions;
import com.adyen.service.checkout.*;

// For the live environment, additionally include your liveEndpointUrlPrefix.
Client client = new Client("ADYEN_API_KEY", Environment.TEST);

// Create the request object(s)
Amount amount = new Amount()
  .currency("EUR")
  .value(1000L);

AmazonPayDetails amazonPayDetails = new AmazonPayDetails()
  .type(AmazonPayDetails.TypeEnum.AMAZONPAY)
  .amazonPayToken("160583287597AMZN");

PaymentRequest paymentRequest = new PaymentRequest()
  .reference("YOUR_ORDER_NUMBER")
  .amount(amount)
  .merchantAccount("ADYEN_MERCHANT_ACCOUNT")
  .paymentMethod(new CheckoutPaymentMethod(amazonPayDetails))
  .returnUrl("https://your-company.example.com/checkout?shopperOrder=12xy..");

// Send the request
PaymentsApi service = new PaymentsApi(client);
PaymentResponse response = service.payments(paymentRequest, new RequestOptions().idempotencyKey("UUID"));
```

#### PHP

```php
// Adyen PHP API Library v19.0.0
use Adyen\Client;
use Adyen\Environment;
use Adyen\Model\Checkout\Amount;
use Adyen\Model\Checkout\CheckoutPaymentMethod;
use Adyen\Model\Checkout\PaymentRequest;
use Adyen\Service\Checkout\PaymentsApi;

$client = new Client();
$client->setXApiKey("ADYEN_API_KEY");
// For the live environment, additionally include your liveEndpointUrlPrefix.
$client->setEnvironment(Environment::TEST);


// Create the request object(s)
$amount = new Amount();
$amount
  ->setCurrency("EUR")
  ->setValue(1000);

$checkoutPaymentMethod = new CheckoutPaymentMethod();
$checkoutPaymentMethod
  ->setType("amazonpay")
  ->setAmazonPayToken("160583287597AMZN");

$paymentRequest = new PaymentRequest();
$paymentRequest
  ->setReference("YOUR_ORDER_NUMBER")
  ->setAmount($amount)
  ->setMerchantAccount("ADYEN_MERCHANT_ACCOUNT")
  ->setPaymentMethod($checkoutPaymentMethod)
  ->setReturnUrl("https://your-company.example.com/checkout?shopperOrder=12xy..");

$requestOptions['idempotencyKey'] = 'UUID';

// Send the request
$service = new PaymentsApi($client);
$response = $service->payments($paymentRequest, $requestOptions);
```

#### C\#

```cs
// Adyen .net API Library v17.0.0
using Adyen;
using Environment = Adyen.Model.Environment;
using Adyen.Model;
using Adyen.Model.Checkout;
using Adyen.Service.Checkout;

// For the live environment, additionally include your liveEndpointUrlPrefix.
var config = new Config()
{
    XApiKey = "ADYEN_API_KEY",
    Environment = Environment.Test
};
var client = new Client(config);

// Create the request object(s)
Amount amount = new Amount
{
  Currency = "EUR",
  Value = 1000
};

AmazonPayDetails amazonPayDetails = new AmazonPayDetails
{
  Type = AmazonPayDetails.TypeEnum.Amazonpay,
  AmazonPayToken = "160583287597AMZN"
};

PaymentRequest paymentRequest = new PaymentRequest
{
  Reference = "YOUR_ORDER_NUMBER",
  Amount = amount,
  MerchantAccount = "ADYEN_MERCHANT_ACCOUNT",
  PaymentMethod = new CheckoutPaymentMethod(amazonPayDetails),
  ReturnUrl = "https://your-company.example.com/checkout?shopperOrder=12xy.."
};

// Send the request
var service = new PaymentsService(client);
var response = service.Payments(paymentRequest, requestOptions: new RequestOptions { IdempotencyKey = "UUID"});
```

#### NodeJS (JavaScript)

```js
// Adyen Node API Library v18.0.0
// Require the parts of the module you want to use
const { Client, CheckoutAPI } = require('@adyen/api-library');
// Initialize the client object
// For the live environment, additionally include your liveEndpointUrlPrefix.
const client = new Client({apiKey: "ADYEN_API_KEY", environment: "TEST"});

// Create the request object(s)
const paymentRequest = {
  amount: {
    currency: "EUR",
    value: 1000
  },
  reference: "YOUR_ORDER_NUMBER",
  paymentMethod: {
    type: "amazonpay",
    amazonPayToken: "160583287597AMZN"
  },
  returnUrl: "https://your-company.example.com/checkout?shopperOrder=12xy..",
  merchantAccount: "ADYEN_MERCHANT_ACCOUNT"
}

// Send the request
const checkoutAPI = new CheckoutAPI(client);
const response = checkoutAPI.PaymentsApi.payments(paymentRequest, { idempotencyKey: "UUID" });
```

#### Go

```go
// Adyen Go API Library v10.4.0
import (
  "context"
  "github.com/adyen/adyen-go-api-library/v9/src/common"
  "github.com/adyen/adyen-go-api-library/v9/src/adyen"
  "github.com/adyen/adyen-go-api-library/v9/src/checkout"
)
// For the live environment, additionally include your liveEndpointUrlPrefix.
client := adyen.NewClient(&common.Config{
  ApiKey:      "ADYEN_API_KEY",
  Environment: common.TestEnv,
})

// Create the request object(s)
amount := checkout.Amount{
  Currency: "EUR",
  Value: 1000,
}

amazonPayDetails := checkout.AmazonPayDetails{
  Type: common.PtrString("amazonpay"),
  AmazonPayToken: common.PtrString("160583287597AMZN"),
}

paymentRequest := checkout.PaymentRequest{
  Reference: "YOUR_ORDER_NUMBER",
  Amount: amount,
  MerchantAccount: "ADYEN_MERCHANT_ACCOUNT",
  PaymentMethod: checkout.AmazonPayDetailsAsCheckoutPaymentMethod(&amazonPayDetails),
  ReturnUrl: "https://your-company.example.com/checkout?shopperOrder=12xy..",
}

// Send the request
service := client.Checkout()
req := service.PaymentsApi.PaymentsInput().IdempotencyKey("UUID").PaymentRequest(paymentRequest)
res, httpRes, err := service.PaymentsApi.Payments(context.Background(), req)
```

#### Python

```py
# Adyen Python API Library v12.5.1
import Adyen

adyen = Adyen.Adyen()
adyen.client.xapikey = "ADYEN_API_KEY"
# For the live environment, additionally include your liveEndpointUrlPrefix.
adyen.client.platform = "test" # The environment to use library in.

# Create the request object(s)
json_request = {
  "amount": {
    "currency": "EUR",
    "value": 1000
  },
  "reference": "YOUR_ORDER_NUMBER",
  "paymentMethod": {
    "type": "amazonpay",
    "amazonPayToken": "160583287597AMZN"
  },
  "returnUrl": "https://your-company.example.com/checkout?shopperOrder=12xy..",
  "merchantAccount": "ADYEN_MERCHANT_ACCOUNT"
}

# Send the request
result = adyen.checkout.payments_api.payments(request=json_request, idempotency_key="UUID")
```

#### Ruby

```rb
# Adyen Ruby API Library v9.5.1
require "adyen-ruby-api-library"

adyen = Adyen::Client.new
adyen.api_key = 'ADYEN_API_KEY'
# For the live environment, additionally include your liveEndpointUrlPrefix.
adyen.env = :test # Set to "live" for live environment

# Create the request object(s)
request_body = {
  :amount => {
    :currency => 'EUR',
    :value => 1000
  },
  :reference => 'YOUR_ORDER_NUMBER',
  :paymentMethod => {
    :type => 'amazonpay',
    :amazonPayToken => '160583287597AMZN'
  },
  :returnUrl => 'https://your-company.example.com/checkout?shopperOrder=12xy..',
  :merchantAccount => 'ADYEN_MERCHANT_ACCOUNT'
}

# Send the request
result = adyen.checkout.payments_api.payments(request_body, headers: { 'Idempotency-Key' => 'UUID' })
```

#### NodeJS (TypeScript)

```ts
// Adyen Node API Library v18.0.0
// Require the parts of the module you want to use
import { Client, CheckoutAPI, Types } from "@adyen/api-library";
// Initialize the client object
// For the live environment, additionally include your liveEndpointUrlPrefix.
const client = new Client({apiKey: "ADYEN_API_KEY", environment: "TEST"});

// Create the request object(s)
const amount: Types.checkout.Amount = {
  currency: "EUR",
  value: 1000
};

const amazonPayDetails: Types.checkout.AmazonPayDetails = {
  type: Types.checkout.AmazonPayDetails.TypeEnum.Amazonpay,
  amazonPayToken: "160583287597AMZN"
};

const paymentRequest: Types.checkout.PaymentRequest = {
  reference: "YOUR_ORDER_NUMBER",
  amount: amount,
  merchantAccount: "ADYEN_MERCHANT_ACCOUNT",
  paymentMethod: amazonPayDetails,
  returnUrl: "https://your-company.example.com/checkout?shopperOrder=12xy.."
};

// Send the request
const checkoutAPI = new CheckoutAPI(client);
const response = checkoutAPI.PaymentsApi.payments(paymentRequest, { idempotencyKey: "UUID" });
```

The [/payments](https://docs.adyen.com/api-explorer/Checkout/latest/post/payments) response depends on whether the transaction was routed to 3D Secure. With 3D Secure you receive an `action` object, and need to handle the corresponding [3D Secure flow](/online-payments/3d-secure#implementation-options).

Without 3D Secure, the [/payments](https://docs.adyen.com/api-explorer/Checkout/latest/post/payments) response contains:

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

**/payments response**

```json
{
   "pspReference": "8815658961765250",
   "resultCode": "Authorised"
}
```

## Present the payment result

Use the `resultCode` that you received in the [/payments](https://docs.adyen.com/api-explorer/Checkout/latest/post/payments) response to present the payment result to your shopper.

The `resultCode` values you can receive for Amazon Pay are:

| resultCode     | Description                                                                                                                                               | Action to take                                                                                                                                                                                                                                                   |
| -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Authorised** | The payment was successful.                                                                                                                               | Inform the shopper that the payment has been successful. If you are using [manual capture](/online-payments/capture#manual-capture), you also need to [capture](/online-payments/capture) the payment.                                                           |
| **Cancelled**  | The shopper cancelled the payment.                                                                                                                        | Ask the shopper whether they want to continue with the order, or ask them to select a different payment method.                                                                                                                                                  |
| **Error**      | There was an error when the payment was being processed. For more information, check the [`refusalReason` ](/development-resources/refusal-reasons)field. | Inform the shopper that there was an error processing their payment.                                                                                                                                                                                             |
| **Refused**    | The payment was refused. For more information, check the [`refusalReason` ](/development-resources/refusal-reasons)field.                                 | Redirect the shopper back to the payment page and ask them to try the payment again using a different card. For more information on how to do this, check [Amazon Pay's documentation](https://developer.amazon.com/docs/amazon-pay-checkout/introduction.html). |

Additional `resultCode` values are possible in case of the 3D Secure authentication flow. For more information, refer to [Result codes](/online-payments/payment-result-codes).

[]()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:

| eventCode         | success field | Description                                     | Action to take                                                                      |
| ----------------- | ------------- | ----------------------------------------------- | ----------------------------------------------------------------------------------- |
| **AUTHORISATION** | **false**     | The transaction failed.                         | Cancel the order and inform the shopper that the payment failed.                    |
| **AUTHORISATION** | **true**      | The shopper successfully completed the payment. | Inform the shopper that the payment has been successful and proceed with the order. |
| **OFFER\_CLOSED** | **true**      | The shopper did not complete the payment.       | Cancel the order and inform the shopper that the payment timed out.                 |

## Recurring payments

Make sure that you have your Amazon Pay integration set up for recurring payments. For details of how to do this, see [Amazon Pay's documentation](https://developer.amazon.com/it/docs/amazon-pay-recurring-checkout/get-set-up-for-integration.html).

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

1. [Create a shopper token](#create-a-token).
2. [Use the token to make future payments for the shopper](#make-payment-with-token).

### Create a token

To create a token, include in your [/payments](https://docs.adyen.com/api-explorer/Checkout/latest/post/payments) request:

* `storePaymentMethod`: **true**
* [shopperReference](https://docs.adyen.com/api-explorer/Checkout/latest/post/payments#request-shopperReference): Your unique identifier for the shopper.

When the payment has been settled, you receive a [recurring.token.created](https://docs.adyen.com/api-explorer/Tokenization-webhooks/latest/post/recurring.token.created) [webhook](/development-resources/webhooks) containing:

* `type`: **recurring.token.created**
* `shopperReference`: your unique identifier for the shopper.
* `eventId`: the `pspReference` of the initial payment.
* `storedPaymentMethodId`: the token that you need to make recurring payments for this shopper.

Make sure that your server is able to receive the [Recurring tokens life cycle events](/development-resources/webhooks/webhook-types/#other-webhooks) webhook. You can [set up this webhook in your Customer Area](/development-resources/webhooks/#set-up-webhooks-in-your-customer-area).

### Make a payment with a token

To make a payment with the token, include in your [/payments](https://docs.adyen.com/api-explorer/Checkout/latest/post/payments) request:

* `paymentMethod.storedPaymentMethodId`: The `storedPaymentMethodId` from the [recurring.token.created](https://docs.adyen.com/api-explorer/Tokenization-webhooks/latest/post/recurring.token.created) webhook.

  You can also get this value using the [/listRecurringDetails](https://docs.adyen.com/api-explorer/Recurring/latest/post/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](/online-payments/tokenization/).

#### curl

```bash
curl https://checkout-test.adyen.com/v72/payments \
-H 'x-api-key: ADYEN_API_KEY' \
-H 'content-type: application/json' \
-d '{
       "amount":{
          "value":1000,
          "currency":"EUR"
       },
       "paymentMethod":{
          "type":"amazonpay",
          "storedPaymentMethodId":"7219687191761347"
       },
       "reference":"YOUR_ORDER_NUMBER",
       "merchantAccount":"YOUR_MERCHANT_ACCOUNT",
       "shopperReference":"YOUR_UNIQUE_SHOPPER_ID_IOfW3k9G2PvXFu2j",
       "shopperInteraction":"ContAuth",
       "recurringProcessingModel": "Subscription"
}'
```

#### Java

```java
// Set ADYEN_API_KEY with the API key from the Customer Area.
// Change to Environment.LIVE and add the Live URL prefix when you are ready to accept live payments.
Client client = new Client("ADYEN_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);

DefaultPaymentMethodDetails paymentMethodDetails = new DefaultPaymentMethodDetails();
paymentMethodDetails.setRecurringDetailReference("7219687191761347");
paymentMethodDetails.setType("amazonpay");
paymentsRequest.setPaymentMethod(paymentMethodDetails);

paymentsRequest.setReference("YOUR_ORDER_NUMBER");
paymentsRequest.setReturnUrl("https://your-company.example.com/checkout?shopperOrder=12xy..");
paymentsRequest.setShopperInteraction("ContAuth");
paymentsRequest.setRecurringProcessingModel("Subscription");

PaymentsResponse paymentsResponse = checkout.payments(paymentsRequest);
```

#### PHP

```php
// Set your X-API-KEY with the API key from the Customer Area.
$client = new \Adyen\Client();
$client->setXApiKey("ADYEN_API_KEY");
$service = new \Adyen\Service\Checkout($client);

$params = array(
  "amount" => array(
    "currency" => "EUR",
    "value" => 1000
  ),
  "reference" => "YOUR_ORDER_NUMBER",
  "paymentMethod" => array(
    "type" => "amazonpay",
    "storedPaymentMethodId" => "7219687191761347"
  ),
  "returnUrl" => "https://your-company.example.com/checkout?shopperOrder=12xy..",
  "shopperReference" => "YOUR_UNIQUE_SHOPPER_ID_IOfW3k9G2PvXFu2j",
  "recurringProcessingModel" => "Subscription",
  "shopperInteraction" => "ContAuth",
  "merchantAccount" => "YOUR_MERCHANT_ACCOUNT"
);
$result = $service->payments($params);
```

#### C\#

```cs
// Set your X-API-KEY with the API key from the Customer Area.
var client = new Client ("ADYEN_API_KEY", Environment.Test);
var checkout = new Checkout(client);

var amount = new Adyen.Model.Checkout.Amount("EUR", 1000);
var details = new Adyen.Model.Checkout.DefaultPaymentMethodDetails{
  Type = "amazonpay",
  StoredPaymentMethodId = "7219687191761347"
};
var paymentsRequest = new Adyen.Model.Checkout.PaymentRequest
{
  Reference = "YOUR_ORDER_NUMBER",
  Amount = amount,
  ReturnUrl = @"https://your-company.example.com/checkout?shopperOrder=12xy..",
  MerchantAccount = "YOUR_MERCHANT_ACCOUNT",
  ShopperReference = "YOUR_UNIQUE_SHOPPER_ID_IOfW3k9G2PvXFu2j",
  RecurringProcessingModel = Adyen.Model.Checkout.PaymentRequest.RecurringProcessingModelEnum.Subscription,
  ShopperInteraction = Adyen.Model.Checkout.PaymentRequest.ShopperInteractionEnum.ContAuth,
  PaymentMethod = details
};

var paymentResponse = checkout.Payments(paymentsRequest);
```

#### NodeJS (JavaScript)

```js
// Adyen Node API Library v16.1.0
// Require the parts of the module you want to use
const { Client, CheckoutAPI } = require('@adyen/api-library');

// Initialize the client object
const client = new Client({apiKey: "YOUR_X_API_KEY", environment: "TEST"});

// Create the request object
const paymentRequest = {
  amount: {
    value: 1000,
    currency: "EUR"
  },
  paymentMethod: {
    type: "amazonpay",
    storedPaymentMethodId: "7219687191761347"
  },
  reference: "YOUR_ORDER_NUMBER",
  merchantAccount: "YOUR_MERCHANT_ACCOUNT",
  shopperReference: "YOUR_UNIQUE_SHOPPER_ID_IOfW3k9G2PvXFu2j",
  shopperInteraction: "ContAuth",
  recurringProcessingModel: "Subscription"
}

// Make the request
const checkoutAPI = new CheckoutAPI(client);
const response = checkoutAPI.PaymentsApi.payments(paymentRequest, { idempotencyKey: "UUID" });
```

#### Python

```py
# Adyen Python API Library v12.0.0
import Adyen

adyen = Adyen.Adyen()
adyen.client.xapikey = "YOUR_X_API_KEY"
adyen.client.platform = "test" # The environment to use library in.

json_request = {
  "amount": {
    "value": 1000,
    "currency": "EUR"
  },
  "paymentMethod": {
    "type": "amazonpay",
    "storedPaymentMethodId": "7219687191761347"
  },
  "reference": "YOUR_ORDER_NUMBER",
  "merchantAccount": "YOUR_MERCHANT_ACCOUNT",
  "shopperReference": "YOUR_UNIQUE_SHOPPER_ID_IOfW3k9G2PvXFu2j",
  "shopperInteraction": "ContAuth",
  "recurringProcessingModel": "Subscription"
}

result = adyen.checkout.payments_api.payments(request=json_request, idempotency_key="UUID")
```

#### Ruby

```rb
# Adyen Ruby API Library v9.1.0
require "adyen-ruby-api-library"

adyen = Adyen::Client.new
adyen.api_key = 'YOUR_X_API_KEY'
adyen.env = :test # Set to "live" for live environment

request_body = {
  :amount => {
    :value => 1000,
    :currency => 'EUR'
  },
  :paymentMethod => {
    :type => 'amazonpay',
    :storedPaymentMethodId => '7219687191761347'
  },
  :reference => 'YOUR_ORDER_NUMBER',
  :merchantAccount => 'YOUR_MERCHANT_ACCOUNT',
  :shopperReference => 'YOUR_UNIQUE_SHOPPER_ID_IOfW3k9G2PvXFu2j',
  :shopperInteraction => 'ContAuth',
  :recurringProcessingModel => 'Subscription'
}

result = adyen.checkout.payments_api.payments(request_body, headers: { 'Idempotency-Key' => 'UUID' })
```

## Test and go live

To test Amazon Pay, you must follow the [Amazon Pay testing guidelines](https://developer.amazon.com/docs/amazon-pay-checkout/test-your-integration.html).

You can check the status of an Amazon Pay test payment in your [Customer Area](https://ca-test.adyen.com/) > **Transactions** > **Payments**.

Before you can accept live Amazon Pay payments, you need to [submit a request for Amazon Pay](/payment-methods/add-payment-methods) in your [live Customer Area](https://ca-live.adyen.com/).

For more information, see [Amazon Pay's test environment setup](https://developer.amazon.com/docs/amazon-pay-checkout/test-your-integration.html).

## See also

* [Payment methods](/payment-methods)
* [Tokenization](/online-payments/tokenization)
* [Amazon Pay error codes](/development-resources/error-codes#amazon-pay-error-codes)