---
title: "giropay Redirect Component v4.x.x integration"
description: "Add giropay to an existing Components integration."
url: "https://docs.adyen.com/payment-methods/giropay/android-component/earlier-versions"
source_url: "https://docs.adyen.com/payment-methods/giropay/android-component/earlier-versions.md"
canonical: "https://docs.adyen.com/payment-methods/giropay/android-component/earlier-versions"
last_modified: "2019-09-06T17:19:00+02:00"
language: "en"
---

# giropay Redirect Component v4.x.x integration

Add giropay to an existing Components integration.

You do not need to collect any information from your shopper in your payments form. If you have an existing Android Components integration, you can use our Redirect Component to redirect the shopper to their bank's website or app where they can complete the payment.

When making a giropay payment, you need to:

* [Include giropay in the list of available payment methods](#show-giropay-in-your-payment-form).
* [Handle the redirect](#handle-the-redirect).

## Requirements

| Requirement          | Description                                                                                                                                                                       |
| -------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Integration type** | Make sure that you have built an Advanced flow [Android Components integration](/online-payments/build-your-integration/advanced-flow/?platform=Android\&integration=Components). |
| **Setup steps**      | Before you begin, [add in your Customer Area](/payment-methods/add-payment-methods).                                                                                              |

## Show giropay in your payment form

Include giropay in the list of available payment methods. You do not need to collect any information from the shopper in your payment form.

1. Specify in your [/paymentMethods](https://docs.adyen.com/api-explorer/Checkout/latest/post/paymentMethods) request:

   * [countryCode](https://docs.adyen.com/api-explorer/Checkout/latest/post/paymentMethods#request-countryCode): **DE**
   * [amount.currency](https://docs.adyen.com/api-explorer/Checkout/latest/post/paymentMethods#request-amount-currency): **EUR**
   * [channel](https://docs.adyen.com/api-explorer/Checkout/latest/post/paymentMethods#request-channel): Specify **Android**.

The response contains `paymentMethod.type`: **giropay**.

We provide logos for giropay and the issuing banks 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).

## Make a payment

When the shopper proceeds to pay, you need to:

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

   * `paymentMethod.type`: Set this to **giropay**.
   * `returnURL`: URL to where the shopper should be redirected back to after they complete the payment. This URL can have a maximum of 1024 characters. Get this URL from the Component in the `RedirectComponent.getReturnUrl(context)`.

   #### 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": "giropay"
        },
        "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);

   GiropayDetails giropayDetails = new GiropayDetails()
     .type(GiropayDetails.TypeEnum.GIROPAY);

   PaymentRequest paymentRequest = new PaymentRequest()
     .reference("YOUR_ORDER_NUMBER")
     .amount(amount)
     .merchantAccount("ADYEN_MERCHANT_ACCOUNT")
     .paymentMethod(new CheckoutPaymentMethod(giropayDetails))
     .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("giropay");

   $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
   };

   GiropayDetails giropayDetails = new GiropayDetails
   {
     Type = GiropayDetails.TypeEnum.Giropay
   };

   PaymentRequest paymentRequest = new PaymentRequest
   {
     Reference = "YOUR_ORDER_NUMBER",
     Amount = amount,
     MerchantAccount = "ADYEN_MERCHANT_ACCOUNT",
     PaymentMethod = new CheckoutPaymentMethod(giropayDetails),
     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: "giropay"
     },
     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,
   }

   giropayDetails := checkout.GiropayDetails{
     Type: common.PtrString("giropay"),
   }

   paymentRequest := checkout.PaymentRequest{
     Reference: "YOUR_ORDER_NUMBER",
     Amount: amount,
     MerchantAccount: "ADYEN_MERCHANT_ACCOUNT",
     PaymentMethod: checkout.GiropayDetailsAsCheckoutPaymentMethod(&giropayDetails),
     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": "giropay"
     },
     "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 => 'giropay'
     },
     :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 giropayDetails: Types.checkout.GiropayDetails = {
     type: Types.checkout.GiropayDetails.TypeEnum.Giropay
   };

   const paymentRequest: Types.checkout.PaymentRequest = {
     reference: "YOUR_ORDER_NUMBER",
     amount: amount,
     merchantAccount: "ADYEN_MERCHANT_ACCOUNT",
     paymentMethod: giropayDetails,
     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" });
   ```

   In the [/payments](https://docs.adyen.com/api-explorer/Checkout/latest/post/payments) response, check the `action` object for the information that you must use to redirect the shopper.

   **/payments response**

   ```json
   {
     "resultCode":"RedirectShopper",
     "action":{
       "paymentMethodType":"giropay",
       "method":"GET",
       "url":"https://checkoutshopper-test.adyen.com/checkoutshopper/checkoutPaymentRedirect?redirectData=...",
       "type":"redirect"
     }
   }
   ```

2. Pass the `action` object to your client app. You need this to initialize the Redirect Component.

## Handle the redirect

1. Use the [Redirect Component](/online-payments/build-your-integration/sessions-flow/?platform=Android\&integration=Components#handle-a-redirect) to redirect the shopper to giropay's website where they can select their bank and provide their account details. When the shopper returns back to your app, the Redirect Component provides the `actionComponentData` object.

2. After the shopper returns to your app, make a POST [/payments/details](https://docs.adyen.com/api-explorer/Checkout/latest/post/payments/details) request from your server, providing:

   * `details`: The `actionComponentData.details` object from the Redirect Component.

**/payments/details request**

```bash
curl https://checkout-test.adyen.com/v72/payments/details \
-H 'x-api-key: ADYEN_API_KEY' \
-H 'content-type: application/json' \
-d '{
     "details": {
       "redirectResult": "eyJ0cmFuc1N0YXR1cyI6IlkifQ=="
   }
}'
```

You receive a response containing:

* `resultCode`: Use this to present the payment result to your shopper.
* `pspReference`: Our unique identifier for the transaction.

**/payments/details response**

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

## Present the payment result

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

The `resultCode` values you can receive for giropay are:

| resultCode                  | Description                                                                                                                                                      | Action to take                                                                                                                                                                                                                         |
| --------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Authorised**              | The payment was successful.                                                                                                                                      | Inform the shopper that the payment has been successful. You will receive the funds in 2-3 days.                                                                                                                                       |
| **Cancelled**               | The shopper cancelled the payment while on their bank's website.                                                                                                 | Ask the shopper whether they want to continue with the order, or ask them to select a different payment method.                                                                                                                        |
| **Pending** or **Received** | The shopper has completed the payment but the final result is not yet known. It may take minutes or hours for the Open Banking payments network to confirm this. | Inform the shopper that you have received their order, and are waiting for the payment to be completed. You will receive the final result of the payment in an [AUTHORISATION webhook](/development-resources/webhooks/webhook-types). |
| **Refused**                 | The payment was refused by the shopper's bank.                                                                                                                   | Ask the shopper to try the payment again using a different payment method. For a description of the refusal reason, check the **Payment Details** page in your [Customer Area](https://ca-test.adyen.com/).                            |

If the shopper failed to return to your website or app, wait for the [AUTHORISATION webhook](/development-resources/webhooks/webhook-types) to receive the outcome of the payment:

| 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. |

## Recurring payments

We support recurring transactions for giropay through [SEPA Direct Debit](/payment-methods/sepa-direct-debit). 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

#### Store SEPA details

When [creating a token](/online-payments/tokenization/create-tokens) for SEPA Direct Debit, use the standard tokenization parameters in your payment request. You do not need to include any additional parameters for SEPA Direct Debit.

**Create a SEPA token for subscription payments**

#### 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"
   },
   "countryCode": "NL",
   "paymentMethod":{
      "type":"sepadirectdebit",
      "sepa.ownerName":"A. Klaassen",
      "sepa.ibanNumber":"NL98ABNA0410108103"
   },
   "reference":"YOUR_ORDER_NUMBER",
   "merchantAccount":"ADYEN_MERCHANT_ACCOUNT",
   "shopperReference":"YOUR_SHOPPER_REFERENCE",
   "shopperInteraction":"Ecommerce",
   "recurringProcessingModel": "Subscription"
}'
```

#### Java

```java
// Adyen Java API Library v41.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, also 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);

SepaDirectDebitDetails sepaDirectDebitDetails = new SepaDirectDebitDetails()
  .type(SepaDirectDebitDetails.TypeEnum.SEPADIRECTDEBIT);

PaymentRequest paymentRequest = new PaymentRequest()
  .reference("YOUR_ORDER_NUMBER")
  .amount(amount)
  .merchantAccount("ADYEN_MERCHANT_ACCOUNT")
  .countryCode("NL")
  .recurringProcessingModel(PaymentRequest.RecurringProcessingModelEnum.SUBSCRIPTION)
  .paymentMethod(new CheckoutPaymentMethod(sepaDirectDebitDetails))
  .shopperInteraction(PaymentRequest.ShopperInteractionEnum.ECOMMERCE)
  .shopperReference("YOUR_SHOPPER_REFERENCE");

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

#### PHP

```php
<?php
// Adyen PHP API Library v29.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, also 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("sepadirectdebit");

$paymentRequest = new PaymentRequest();
$paymentRequest
  ->setReference("YOUR_ORDER_NUMBER")
  ->setAmount($amount)
  ->setMerchantAccount("ADYEN_MERCHANT_ACCOUNT")
  ->setCountryCode("NL")
  ->setRecurringProcessingModel("Subscription")
  ->setPaymentMethod($checkoutPaymentMethod)
  ->setShopperInteraction("Ecommerce")
  ->setShopperReference("YOUR_SHOPPER_REFERENCE");

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

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

#### C\#

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

// For the LIVE environment, also 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
};

SepaDirectDebitDetails sepaDirectDebitDetails = new SepaDirectDebitDetails
{
  Type = SepaDirectDebitDetails.TypeEnum.Sepadirectdebit
};

PaymentRequest paymentRequest = new PaymentRequest
{
  Reference = "YOUR_ORDER_NUMBER",
  Amount = amount,
  MerchantAccount = "ADYEN_MERCHANT_ACCOUNT",
  CountryCode = "NL",
  RecurringProcessingModel = PaymentRequest.RecurringProcessingModelEnum.Subscription,
  PaymentMethod = new CheckoutPaymentMethod(sepaDirectDebitDetails),
  ShopperInteraction = PaymentRequest.ShopperInteractionEnum.Ecommerce,
  ShopperReference = "YOUR_SHOPPER_REFERENCE"
};

// 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 v30.1.0
const { Client, CheckoutAPI } = require('@adyen/api-library');

// For the LIVE environment, also include your liveEndpointUrlPrefix.
const config = new Config({
  apiKey: "ADYEN_API_KEY",
  environment: EnvironmentEnum.TEST
});

const client = new Client(config);

// Create the request object(s)
const paymentRequest = {
  amount: {
    value: 1000,
    currency: "EUR"
  },
  countryCode: "NL",
  paymentMethod: {
    type: "sepadirectdebit",
    "sepa.ownerName": "A. Klaassen",
    "sepa.ibanNumber": "NL98ABNA0410108103"
  },
  reference: "YOUR_ORDER_NUMBER",
  merchantAccount: "ADYEN_MERCHANT_ACCOUNT",
  shopperReference: "YOUR_SHOPPER_REFERENCE",
  shopperInteraction: "Ecommerce",
  recurringProcessingModel: "Subscription"
}

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

#### Go

```go
// Adyen Go API Library v21.1.0
import (
  "context"
  "github.com/adyen/adyen-go-api-library/v21/src/common"
  "github.com/adyen/adyen-go-api-library/v21/src/adyen"
  "github.com/adyen/adyen-go-api-library/v21/src/checkout"
)
// For the LIVE environment, also 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,
}

sepaDirectDebitDetails := checkout.SepaDirectDebitDetails{
  Type: common.PtrString("sepadirectdebit"),
}

paymentRequest := checkout.PaymentRequest{
  Reference: "YOUR_ORDER_NUMBER",
  Amount: amount,
  MerchantAccount: "ADYEN_MERCHANT_ACCOUNT",
  CountryCode: common.PtrString("NL"),
  RecurringProcessingModel: common.PtrString("Subscription"),
  PaymentMethod: checkout.SepaDirectDebitDetailsAsCheckoutPaymentMethod(&sepaDirectDebitDetails),
  ShopperInteraction: common.PtrString("Ecommerce"),
  ShopperReference: common.PtrString("YOUR_SHOPPER_REFERENCE"),
}

// 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 v14.0.0
import Adyen

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

# Create the request object(s)
json_request = {
  "amount": {
    "value": 1000,
    "currency": "EUR"
  },
  "countryCode": "NL",
  "paymentMethod": {
    "type": "sepadirectdebit",
    "sepa.ownerName": "A. Klaassen",
    "sepa.ibanNumber": "NL98ABNA0410108103"
  },
  "reference": "YOUR_ORDER_NUMBER",
  "merchantAccount": "ADYEN_MERCHANT_ACCOUNT",
  "shopperReference": "YOUR_SHOPPER_REFERENCE",
  "shopperInteraction": "Ecommerce",
  "recurringProcessingModel": "Subscription"
}

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

#### Ruby

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

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

# Create the request object(s)
request_body = {
  :amount => {
    :value => 1000,
    :currency => 'EUR'
  },
  :countryCode => 'NL',
  :paymentMethod => {
    :type => 'sepadirectdebit',
    :sepa.ownerName => 'A. Klaassen',
    :sepa.ibanNumber => 'NL98ABNA0410108103'
  },
  :reference => 'YOUR_ORDER_NUMBER',
  :merchantAccount => 'ADYEN_MERCHANT_ACCOUNT',
  :shopperReference => 'YOUR_SHOPPER_REFERENCE',
  :shopperInteraction => 'Ecommerce',
  :recurringProcessingModel => 'Subscription'
}

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

#### NodeJS (TypeScript)

```ts
// Adyen Node API Library v29.0.0
import { Client, CheckoutAPI, Types } from "@adyen/api-library";

// For the LIVE environment, also include your liveEndpointUrlPrefix.
const config = new Config({
  apiKey: "ADYEN_API_KEY",
  environment: EnvironmentEnum.TEST
});

const client = new Client(config);

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

const sepaDirectDebitDetails: Types.checkout.SepaDirectDebitDetails = {
  storedPaymentMethodId: "M5N7TQ4TG5PFWR50",
  type: Types.checkout.SepaDirectDebitDetails.TypeEnum.Sepadirectdebit
};

const paymentRequest: Types.checkout.PaymentRequest = {
  reference: "YOUR_ORDER_NUMBER",
  amount: amount,
  merchantAccount: "ADYEN_MERCHANT_ACCOUNT",
  countryCode: "US",
  recurringProcessingModel: Types.checkout.PaymentRequest.RecurringProcessingModelEnum.Subscription,
  paymentMethod: sepaDirectDebitDetails,
  shopperInteraction: Types.checkout.PaymentRequest.ShopperInteractionEnum.Ecommerce,
  shopperReference: "YOUR_SHOPPER_REFERENCE"
};

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

When a token is created, you receive a [recurring.token.created](https://docs.adyen.com/api-explorer/Tokenization-webhooks/latest/post/recurring.token.created) webhook. The webhook contains the `storedPaymentMethodId` that you can use to make subsequent payments using the stored payment details.

### Make a payment with a token

Only use tokenised payments in scenarios where the shopper is not present, that is, `UnscheduledCardOnFile` and `Subscription` payments.

#### Make a subscription payment

[Make a subscription payment](/online-payments/tokenization/make-token-payments#make-a-subscription-or-unscheduled-card-on-file-payment) using the standard tokenization parameters. You do not need to include any additional parameters for SEPA Direct Debit.

**Make a subscription payment with a SEPA token**

#### curl

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

#### Java

```java
// Adyen Java API Library v39.3.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, also 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);

SepaDirectDebitDetails sepaDirectDebitDetails = new SepaDirectDebitDetails()
  .storedPaymentMethodId("7219687191761347")
  .type(SepaDirectDebitDetails.TypeEnum.SEPADIRECTDEBIT);

PaymentRequest paymentRequest = new PaymentRequest()
  .reference("YOUR_ORDER_NUMBER")
  .amount(amount)
  .merchantAccount("YOUR_MERCHANT_ACCOUNT")
  .recurringProcessingModel(PaymentRequest.RecurringProcessingModelEnum.SUBSCRIPTION)
  .paymentMethod(new CheckoutPaymentMethod(sepaDirectDebitDetails))
  .shopperInteraction(PaymentRequest.ShopperInteractionEnum.CONTAUTH)
  .shopperReference("YOUR_SHOPPER_REFERENCE");

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

#### PHP

```php
<?php
// Adyen PHP API Library v28.2.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, also include your liveEndpointUrlPrefix.
$client->setEnvironment(Environment::TEST);


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

$checkoutPaymentMethod = new CheckoutPaymentMethod();
$checkoutPaymentMethod
  ->setStoredPaymentMethodId("7219687191761347")
  ->setType("sepadirectdebit");

$paymentRequest = new PaymentRequest();
$paymentRequest
  ->setReference("YOUR_ORDER_NUMBER")
  ->setAmount($amount)
  ->setMerchantAccount("YOUR_MERCHANT_ACCOUNT")
  ->setRecurringProcessingModel("Subscription")
  ->setPaymentMethod($checkoutPaymentMethod)
  ->setShopperInteraction("ContAuth")
  ->setShopperReference("YOUR_SHOPPER_REFERENCE");

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

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

#### C\#

```cs
// Adyen .net API Library v32.1.1
using Adyen;
using Environment = Adyen.Model.Environment;
using Adyen.Model;
using Adyen.Model.Checkout;
using Adyen.Service.Checkout;

// For the LIVE environment, also 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
};

SepaDirectDebitDetails sepaDirectDebitDetails = new SepaDirectDebitDetails
{
  StoredPaymentMethodId = "7219687191761347",
  Type = SepaDirectDebitDetails.TypeEnum.Sepadirectdebit
};

PaymentRequest paymentRequest = new PaymentRequest
{
  Reference = "YOUR_ORDER_NUMBER",
  Amount = amount,
  MerchantAccount = "YOUR_MERCHANT_ACCOUNT",
  RecurringProcessingModel = PaymentRequest.RecurringProcessingModelEnum.Subscription,
  PaymentMethod = new CheckoutPaymentMethod(sepaDirectDebitDetails),
  ShopperInteraction = PaymentRequest.ShopperInteractionEnum.ContAuth,
  ShopperReference = "YOUR_SHOPPER_REFERENCE"
};

// 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 v29.0.0
const { Client, CheckoutAPI } = require('@adyen/api-library');

// For the LIVE environment, also include your liveEndpointUrlPrefix.
const config = new Config({
  apiKey: "ADYEN_API_KEY",
  environment: EnvironmentEnum.TEST
});

const client = new Client(config);

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

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

#### Go

```go
// Adyen Go API Library v21.0.0
import (
  "context"
  "github.com/adyen/adyen-go-api-library/v21/src/common"
  "github.com/adyen/adyen-go-api-library/v21/src/adyen"
  "github.com/adyen/adyen-go-api-library/v21/src/checkout"
)
// For the LIVE environment, also 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,
}

sepaDirectDebitDetails := checkout.SepaDirectDebitDetails{
  StoredPaymentMethodId: common.PtrString("7219687191761347"),
  Type: common.PtrString("sepadirectdebit"),
}

paymentRequest := checkout.PaymentRequest{
  Reference: "YOUR_ORDER_NUMBER",
  Amount: amount,
  MerchantAccount: "YOUR_MERCHANT_ACCOUNT",
  RecurringProcessingModel: common.PtrString("Subscription"),
  PaymentMethod: checkout.SepaDirectDebitDetailsAsCheckoutPaymentMethod(&sepaDirectDebitDetails),
  ShopperInteraction: common.PtrString("ContAuth"),
  ShopperReference: common.PtrString("YOUR_SHOPPER_REFERENCE"),
}

// 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 v13.6.0
import Adyen

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

# Create the request object(s)
json_request = {
  "amount": {
    "value": 1000,
    "currency": "EUR"
  },
  "paymentMethod": {
    "type": "sepadirectdebit",
    "storedPaymentMethodId": "7219687191761347"
  },
  "merchantAccount": "YOUR_MERCHANT_ACCOUNT",
  "reference": "YOUR_ORDER_NUMBER",
  "shopperReference": "YOUR_SHOPPER_REFERENCE",
  "shopperInteraction": "ContAuth",
  "recurringProcessingModel": "Subscription"
}

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

#### Ruby

```rb
# Adyen Ruby API Library v10.4.0
require "adyen-ruby-api-library"

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

# Create the request object(s)
request_body = {
  :amount => {
    :value => 1000,
    :currency => 'EUR'
  },
  :paymentMethod => {
    :type => 'sepadirectdebit',
    :storedPaymentMethodId => '7219687191761347'
  },
  :merchantAccount => 'YOUR_MERCHANT_ACCOUNT',
  :reference => 'YOUR_ORDER_NUMBER',
  :shopperReference => 'YOUR_SHOPPER_REFERENCE',
  :shopperInteraction => 'ContAuth',
  :recurringProcessingModel => 'Subscription'
}

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

#### NodeJS (TypeScript)

```ts
// Adyen Node API Library v29.0.0
import { Client, CheckoutAPI, Types } from "@adyen/api-library";

// For the LIVE environment, also include your liveEndpointUrlPrefix.
const config = new Config({
  apiKey: "ADYEN_API_KEY",
  environment: EnvironmentEnum.TEST
});

const client = new Client(config);

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

const sepaDirectDebitDetails: Types.checkout.SepaDirectDebitDetails = {
  storedPaymentMethodId: "7219687191761347",
  type: Types.checkout.SepaDirectDebitDetails.TypeEnum.Sepadirectdebit
};

const paymentRequest: Types.checkout.PaymentRequest = {
  reference: "YOUR_ORDER_NUMBER",
  amount: amount,
  merchantAccount: "YOUR_MERCHANT_ACCOUNT",
  recurringProcessingModel: Types.checkout.PaymentRequest.RecurringProcessingModelEnum.Subscription,
  paymentMethod: sepaDirectDebitDetails,
  shopperInteraction: Types.checkout.PaymentRequest.ShopperInteractionEnum.ContAuth,
  shopperReference: "YOUR_SHOPPER_REFERENCE"
};

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

#### Make an unscheduled card-on-file payment

[Make an unscheduled card-on-file](/online-payments/tokenization/make-token-payments#make-a-subscription-or-unscheduled-card-on-file-payment) using the standard tokenization parameters. You do not need to include any additional parameters for SEPA Direct Debit.

**Make an unscheduled card-on-file payment with a SEPA token**

#### curl

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

#### Java

```java
// Adyen Java API Library v39.3.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, also 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);

SepaDirectDebitDetails sepaDirectDebitDetails = new SepaDirectDebitDetails()
  .storedPaymentMethodId("7219687191761347")
  .type(SepaDirectDebitDetails.TypeEnum.SEPADIRECTDEBIT);

PaymentRequest paymentRequest = new PaymentRequest()
  .reference("YOUR_ORDER_NUMBER")
  .amount(amount)
  .merchantAccount("YOUR_MERCHANT_ACCOUNT")
  .recurringProcessingModel(PaymentRequest.RecurringProcessingModelEnum.UNSCHEDULEDCARDONFILE)
  .paymentMethod(new CheckoutPaymentMethod(sepaDirectDebitDetails))
  .shopperInteraction(PaymentRequest.ShopperInteractionEnum.CONTAUTH)
  .shopperReference("YOUR_SHOPPER_REFERENCE");

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

#### PHP

```php
<?php
// Adyen PHP API Library v28.2.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, also include your liveEndpointUrlPrefix.
$client->setEnvironment(Environment::TEST);


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

$checkoutPaymentMethod = new CheckoutPaymentMethod();
$checkoutPaymentMethod
  ->setStoredPaymentMethodId("7219687191761347")
  ->setType("sepadirectdebit");

$paymentRequest = new PaymentRequest();
$paymentRequest
  ->setReference("YOUR_ORDER_NUMBER")
  ->setAmount($amount)
  ->setMerchantAccount("YOUR_MERCHANT_ACCOUNT")
  ->setRecurringProcessingModel("UnscheduledCardOnFile")
  ->setPaymentMethod($checkoutPaymentMethod)
  ->setShopperInteraction("ContAuth")
  ->setShopperReference("YOUR_SHOPPER_REFERENCE");

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

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

#### C\#

```cs
// Adyen .net API Library v32.1.1
using Adyen;
using Environment = Adyen.Model.Environment;
using Adyen.Model;
using Adyen.Model.Checkout;
using Adyen.Service.Checkout;

// For the LIVE environment, also 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
};

SepaDirectDebitDetails sepaDirectDebitDetails = new SepaDirectDebitDetails
{
  StoredPaymentMethodId = "7219687191761347",
  Type = SepaDirectDebitDetails.TypeEnum.Sepadirectdebit
};

PaymentRequest paymentRequest = new PaymentRequest
{
  Reference = "YOUR_ORDER_NUMBER",
  Amount = amount,
  MerchantAccount = "YOUR_MERCHANT_ACCOUNT",
  RecurringProcessingModel = PaymentRequest.RecurringProcessingModelEnum.UnscheduledCardOnFile,
  PaymentMethod = new CheckoutPaymentMethod(sepaDirectDebitDetails),
  ShopperInteraction = PaymentRequest.ShopperInteractionEnum.ContAuth,
  ShopperReference = "YOUR_SHOPPER_REFERENCE"
};

// 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 v29.0.0
const { Client, CheckoutAPI } = require('@adyen/api-library');

// For the LIVE environment, also include your liveEndpointUrlPrefix.
const config = new Config({
  apiKey: "ADYEN_API_KEY",
  environment: EnvironmentEnum.TEST
});

const client = new Client(config);

// Create the request object(s)
const paymentRequest = {
  amount: {
    value: 1000,
    currency: "EUR"
  },
  paymentMethod: {
    type: "sepadirectdebit",
    storedPaymentMethodId: "7219687191761347"
  },
  merchantAccount: "YOUR_MERCHANT_ACCOUNT",
  reference: "YOUR_ORDER_NUMBER",
  shopperReference: "YOUR_SHOPPER_REFERENCE",
  shopperInteraction: "ContAuth",
  recurringProcessingModel: "UnscheduledCardOnFile"
}

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

#### Go

```go
// Adyen Go API Library v21.0.0
import (
  "context"
  "github.com/adyen/adyen-go-api-library/v21/src/common"
  "github.com/adyen/adyen-go-api-library/v21/src/adyen"
  "github.com/adyen/adyen-go-api-library/v21/src/checkout"
)
// For the LIVE environment, also 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,
}

sepaDirectDebitDetails := checkout.SepaDirectDebitDetails{
  StoredPaymentMethodId: common.PtrString("7219687191761347"),
  Type: common.PtrString("sepadirectdebit"),
}

paymentRequest := checkout.PaymentRequest{
  Reference: "YOUR_ORDER_NUMBER",
  Amount: amount,
  MerchantAccount: "YOUR_MERCHANT_ACCOUNT",
  RecurringProcessingModel: common.PtrString("UnscheduledCardOnFile"),
  PaymentMethod: checkout.SepaDirectDebitDetailsAsCheckoutPaymentMethod(&sepaDirectDebitDetails),
  ShopperInteraction: common.PtrString("ContAuth"),
  ShopperReference: common.PtrString("YOUR_SHOPPER_REFERENCE"),
}

// 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 v13.6.0
import Adyen

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

# Create the request object(s)
json_request = {
  "amount": {
    "value": 1000,
    "currency": "EUR"
  },
  "paymentMethod": {
    "type": "sepadirectdebit",
    "storedPaymentMethodId": "7219687191761347"
  },
  "merchantAccount": "YOUR_MERCHANT_ACCOUNT",
  "reference": "YOUR_ORDER_NUMBER",
  "shopperReference": "YOUR_SHOPPER_REFERENCE",
  "shopperInteraction": "ContAuth",
  "recurringProcessingModel": "UnscheduledCardOnFile"
}

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

#### Ruby

```rb
# Adyen Ruby API Library v10.4.0
require "adyen-ruby-api-library"

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

# Create the request object(s)
request_body = {
  :amount => {
    :value => 1000,
    :currency => 'EUR'
  },
  :paymentMethod => {
    :type => 'sepadirectdebit',
    :storedPaymentMethodId => '7219687191761347'
  },
  :merchantAccount => 'YOUR_MERCHANT_ACCOUNT',
  :reference => 'YOUR_ORDER_NUMBER',
  :shopperReference => 'YOUR_SHOPPER_REFERENCE',
  :shopperInteraction => 'ContAuth',
  :recurringProcessingModel => 'UnscheduledCardOnFile'
}

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

#### NodeJS (TypeScript)

```ts
// Adyen Node API Library v29.0.0
import { Client, CheckoutAPI, Types } from "@adyen/api-library";

// For the LIVE environment, also include your liveEndpointUrlPrefix.
const config = new Config({
  apiKey: "ADYEN_API_KEY",
  environment: EnvironmentEnum.TEST
});

const client = new Client(config);

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

const sepaDirectDebitDetails: Types.checkout.SepaDirectDebitDetails = {
  storedPaymentMethodId: "7219687191761347",
  type: Types.checkout.SepaDirectDebitDetails.TypeEnum.Sepadirectdebit
};

const paymentRequest: Types.checkout.PaymentRequest = {
  reference: "YOUR_ORDER_NUMBER",
  amount: amount,
  merchantAccount: "YOUR_MERCHANT_ACCOUNT",
  recurringProcessingModel: Types.checkout.PaymentRequest.RecurringProcessingModelEnum.UnscheduledCardOnFile,
  paymentMethod: sepaDirectDebitDetails,
  shopperInteraction: Types.checkout.PaymentRequest.ShopperInteractionEnum.ContAuth,
  shopperReference: "YOUR_SHOPPER_REFERENCE"
};

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

#### 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":"sepadirectdebit",
          "recurringDetailReference":"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);

SepaDirectDebitDetails paymentMethodDetails = new SepaDirectDebitDetails();
paymentMethodDetails.setStoredPaymentMethodId("7219687191761347");
paymentMethodDetails.setType("sepadirectdebit");
paymentsRequest.setPaymentMethod(paymentMethodDetails);

paymentsRequest.setReference("YOUR_ORDER_NUMBER");
paymentsRequest.setReturnUrl("https://your-company.com/checkout?shopperOrder=12xy..");
paymentsRequest.setShopperInteraction(PaymentsRequest.ShopperInteractionEnum.CONTAUTH);
paymentsRequest.setRecurringProcessingModel(PaymentsRequest.RecurringProcessingModelEnum.SUBSCRIPTION);

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

#### PHP

```php
<?php
// Adyen PHP API Library v28.2.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, also include your liveEndpointUrlPrefix.
$client->setEnvironment(Environment::TEST);


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

$checkoutPaymentMethod = new CheckoutPaymentMethod();
$checkoutPaymentMethod
  ->setRecurringDetailReference("7219687191761347")
  ->setType("sepadirectdebit");

$paymentRequest = new PaymentRequest();
$paymentRequest
  ->setReference("YOUR_ORDER_NUMBER")
  ->setAmount($amount)
  ->setMerchantAccount("YOUR_MERCHANT_ACCOUNT")
  ->setRecurringProcessingModel("Subscription")
  ->setPaymentMethod($checkoutPaymentMethod)
  ->setShopperInteraction("ContAuth")
  ->setShopperReference("YOUR_UNIQUE_SHOPPER_ID_IOfW3k9G2PvXFu2j");

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

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

#### C\#

```cs
// Adyen .net API Library v32.1.1
using Adyen;
using Environment = Adyen.Model.Environment;
using Adyen.Model;
using Adyen.Model.Checkout;
using Adyen.Service.Checkout;

// For the LIVE environment, also 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
};

SepaDirectDebitDetails sepaDirectDebitDetails = new SepaDirectDebitDetails
{
  RecurringDetailReference = "7219687191761347",
  Type = SepaDirectDebitDetails.TypeEnum.Sepadirectdebit
};

PaymentRequest paymentRequest = new PaymentRequest
{
  Reference = "YOUR_ORDER_NUMBER",
  Amount = amount,
  MerchantAccount = "YOUR_MERCHANT_ACCOUNT",
  RecurringProcessingModel = PaymentRequest.RecurringProcessingModelEnum.Subscription,
  PaymentMethod = new CheckoutPaymentMethod(sepaDirectDebitDetails),
  ShopperInteraction = PaymentRequest.ShopperInteractionEnum.ContAuth,
  ShopperReference = "YOUR_UNIQUE_SHOPPER_ID_IOfW3k9G2PvXFu2j"
};

// 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 v29.0.0
const { Client, CheckoutAPI } = require('@adyen/api-library');

// For the LIVE environment, also include your liveEndpointUrlPrefix.
const config = new Config({
  apiKey: "ADYEN_API_KEY",
  environment: EnvironmentEnum.TEST
});

const client = new Client(config);

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

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

#### Go

```go
// Adyen Go API Library v21.0.0
import (
  "context"
  "github.com/adyen/adyen-go-api-library/v21/src/common"
  "github.com/adyen/adyen-go-api-library/v21/src/adyen"
  "github.com/adyen/adyen-go-api-library/v21/src/checkout"
)
// For the LIVE environment, also 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,
}

sepaDirectDebitDetails := checkout.SepaDirectDebitDetails{
  RecurringDetailReference: common.PtrString("7219687191761347"),
  Type: common.PtrString("sepadirectdebit"),
}

paymentRequest := checkout.PaymentRequest{
  Reference: "YOUR_ORDER_NUMBER",
  Amount: amount,
  MerchantAccount: "YOUR_MERCHANT_ACCOUNT",
  RecurringProcessingModel: common.PtrString("Subscription"),
  PaymentMethod: checkout.SepaDirectDebitDetailsAsCheckoutPaymentMethod(&sepaDirectDebitDetails),
  ShopperInteraction: common.PtrString("ContAuth"),
  ShopperReference: common.PtrString("YOUR_UNIQUE_SHOPPER_ID_IOfW3k9G2PvXFu2j"),
}

// 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 v13.6.0
import Adyen

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

# Create the request object(s)
json_request = {
  "amount": {
    "value": 1000,
    "currency": "EUR"
  },
  "paymentMethod": {
    "type": "sepadirectdebit",
    "recurringDetailReference": "7219687191761347"
  },
  "reference": "YOUR_ORDER_NUMBER",
  "merchantAccount": "YOUR_MERCHANT_ACCOUNT",
  "shopperReference": "YOUR_UNIQUE_SHOPPER_ID_IOfW3k9G2PvXFu2j",
  "shopperInteraction": "ContAuth",
  "recurringProcessingModel": "Subscription"
}

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

#### Ruby

```rb
# Adyen Ruby API Library v10.4.0
require "adyen-ruby-api-library"

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

# Create the request object(s)
request_body = {
  :amount => {
    :value => 1000,
    :currency => 'EUR'
  },
  :paymentMethod => {
    :type => 'sepadirectdebit',
    :recurringDetailReference => '7219687191761347'
  },
  :reference => 'YOUR_ORDER_NUMBER',
  :merchantAccount => 'YOUR_MERCHANT_ACCOUNT',
  :shopperReference => 'YOUR_UNIQUE_SHOPPER_ID_IOfW3k9G2PvXFu2j',
  :shopperInteraction => 'ContAuth',
  :recurringProcessingModel => 'Subscription'
}

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

#### NodeJS (TypeScript)

```ts
// Adyen Node API Library v29.0.0
import { Client, CheckoutAPI, Types } from "@adyen/api-library";

// For the LIVE environment, also include your liveEndpointUrlPrefix.
const config = new Config({
  apiKey: "ADYEN_API_KEY",
  environment: EnvironmentEnum.TEST
});

const client = new Client(config);

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

const sepaDirectDebitDetails: Types.checkout.SepaDirectDebitDetails = {
  recurringDetailReference: "7219687191761347",
  type: Types.checkout.SepaDirectDebitDetails.TypeEnum.Sepadirectdebit
};

const paymentRequest: Types.checkout.PaymentRequest = {
  reference: "YOUR_ORDER_NUMBER",
  amount: amount,
  merchantAccount: "YOUR_MERCHANT_ACCOUNT",
  recurringProcessingModel: Types.checkout.PaymentRequest.RecurringProcessingModelEnum.Subscription,
  paymentMethod: sepaDirectDebitDetails,
  shopperInteraction: Types.checkout.PaymentRequest.ShopperInteractionEnum.ContAuth,
  shopperReference: "YOUR_UNIQUE_SHOPPER_ID_IOfW3k9G2PvXFu2j"
};

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

If the payment was successfully received the response will contain a **Received** `resultCode` and a `pspReference`, which is our unique identifier for this transaction. You can track whether the payment was successful using webhooks.

## Test and go live

On the bank selection screen, select **giropay Testbank**. You can use the following details to make test payments:

IBAN: DE48499999601234567890\
VR-NetKey: Any value allowed\
PIN: 1234\
TAN (for Photo and Flicker devices): 123456

You can check the status of a giropay test payment in your [Customer Area](https://ca-test.adyen.com/) > **Payments** > **Payment list**.

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

## See also

* [Android Components integration guide](/online-payments/build-your-integration/sessions-flow?platform=Android\&integration=Components)
* [Webhooks](/development-resources/webhooks)
* [Tokenization for recurring payments](/online-payments/tokenization)
* [API Explorer](https://docs.adyen.com/api-explorer/Checkout/latest/overview)