---
title: "Bancontact mobile Redirect Component"
description: "Add Bancontact mobile to an existing Components integration."
url: "https://docs.adyen.com/payment-methods/bancontact/bancontact-mobile/android-component"
source_url: "https://docs.adyen.com/payment-methods/bancontact/bancontact-mobile/android-component.md"
canonical: "https://docs.adyen.com/payment-methods/bancontact/bancontact-mobile/android-component"
last_modified: "2026-05-26T13:48:55+02:00"
language: "en"
---

# Bancontact mobile Redirect Component

Add Bancontact mobile to an existing Components integration.

[View source](/payment-methods/bancontact/bancontact-mobile/android-component.md)

**If you are using Android Components v5.0.0 or later:**

This payment method requires no additional configuration.

Follow the [Components integration guide](/online-payments/build-your-integration/sessions-flow?platform=Android\&integration=Components) and use the following module and Component names:

* To [import the module](/online-payments/build-your-integration/sessions-flow/?platform=Android\&integration=Components#import): **instant**
* To [launch and show the Component](/online-payments/build-your-integration/sessions-flow?platform=Android\&integration=Components#launch-and-show): **InstantPaymentComponent**

Use our [Redirect Component](/online-payments/build-your-integration/sessions-flow/?platform=Android\&integration=Components#handle-a-redirect) to handle the redirect to the Bancontact app. When adding Bancontact to your existing Components integration, you also need to:

1. [Show Bancontact in your payment form](#show-in-payment-form).
2. [Handle the redirect result](#handle-the-redirect) when the shopper returns to your app.

## Requirements

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

- To receive the `bcmcmobile.urlIntent` parameter in the payment response:

  1. In your [Customer Area](https://ca-test.adyen.com/), go to **Developers** > **Additional data**.
  2. Under **3D Secure** select the checkbox for **3DS2 Additional Fields**. |

## Show Bancontact in your payment form

Include Bancontact 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/#/PaymentSetupAndVerificationService/latest/paymentMethods): **BE**.
   * [amount.currency](https://docs.adyen.com/api-explorer/Checkout/latest/post/paymentMethods#request-amount): **EUR**.

The response contains `paymentMethod.type`: **bcmc\_mobile**.

We provide a Bancontact logo 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).

### Optional configuration

When you create the Bancontact configuration object, you can optionally add configuration parameters.

**Bancontact mobile configuration**

```kotlin
val bcmcConfiguration = BcmcConfiguration.Builder(context, "YOUR_CLIENT_KEY")
    // Makes the cardholder name required.
    .setHolderNameRequired(true)
    // When you are ready to accept live payments, change the value to one of our live environments.
    .setEnvironment(Environment.TEST)
    .build()
```

## Make a payment

1. When the shopper selects the button to pay, make a [/payments](https://docs.adyen.com/api-explorer/Checkout/latest/post/payments) request, specifying:

   * `paymentMethod.type`: **bcmc\_mobile**
   * `returnURL`: The URL to where the shopper should be redirected back to after they complete the payment. 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 '{
     "merchantAccount":"ADYEN_MERCHANT_ACCOUNT",
     "reference":"YOUR_ORDER_NUMBER",
     "amount":{
       "currency":"EUR",
       "value":1000
     },
     "paymentMethod":{
       "type":"bcmc_mobile"
     },
     "returnUrl":"adyencheckout://your.package.name"
   }'
   ```

   #### 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);

   StoredPaymentMethodDetails storedPaymentMethodDetails = new StoredPaymentMethodDetails()
     .type(StoredPaymentMethodDetails.TypeEnum.BCMC_MOBILE);

   PaymentRequest paymentRequest = new PaymentRequest()
     .reference("YOUR_ORDER_NUMBER")
     .amount(amount)
     .merchantAccount("ADYEN_MERCHANT_ACCOUNT")
     .paymentMethod(new CheckoutPaymentMethod(storedPaymentMethodDetails))
     .returnUrl("adyencheckout://your.package.name");

   // 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("bcmc_mobile");

   $paymentRequest = new PaymentRequest();
   $paymentRequest
     ->setReference("YOUR_ORDER_NUMBER")
     ->setAmount($amount)
     ->setMerchantAccount("ADYEN_MERCHANT_ACCOUNT")
     ->setPaymentMethod($checkoutPaymentMethod)
     ->setReturnUrl("adyencheckout://your.package.name");

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

   StoredPaymentMethodDetails storedPaymentMethodDetails = new StoredPaymentMethodDetails
   {
     Type = StoredPaymentMethodDetails.TypeEnum.BcmcMobile
   };

   PaymentRequest paymentRequest = new PaymentRequest
   {
     Reference = "YOUR_ORDER_NUMBER",
     Amount = amount,
     MerchantAccount = "ADYEN_MERCHANT_ACCOUNT",
     PaymentMethod = new CheckoutPaymentMethod(storedPaymentMethodDetails),
     ReturnUrl = "adyencheckout://your.package.name"
   };

   // 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 = {
     merchantAccount: "ADYEN_MERCHANT_ACCOUNT",
     reference: "YOUR_ORDER_NUMBER",
     amount: {
       currency: "EUR",
       value: 1000
     },
     paymentMethod: {
       type: "bcmc_mobile"
     },
     returnUrl: "adyencheckout://your.package.name"
   }

   // 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,
   }

   storedPaymentMethodDetails := checkout.StoredPaymentMethodDetails{
     Type: common.PtrString("bcmc_mobile"),
   }

   paymentRequest := checkout.PaymentRequest{
     Reference: "YOUR_ORDER_NUMBER",
     Amount: amount,
     MerchantAccount: "ADYEN_MERCHANT_ACCOUNT",
     PaymentMethod: checkout.StoredPaymentMethodDetailsAsCheckoutPaymentMethod(&storedPaymentMethodDetails),
     ReturnUrl: "adyencheckout://your.package.name",
   }

   // 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 = {
     "merchantAccount": "ADYEN_MERCHANT_ACCOUNT",
     "reference": "YOUR_ORDER_NUMBER",
     "amount": {
       "currency": "EUR",
       "value": 1000
     },
     "paymentMethod": {
       "type": "bcmc_mobile"
     },
     "returnUrl": "adyencheckout://your.package.name"
   }

   # 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 = {
     :merchantAccount => 'ADYEN_MERCHANT_ACCOUNT',
     :reference => 'YOUR_ORDER_NUMBER',
     :amount => {
       :currency => 'EUR',
       :value => 1000
     },
     :paymentMethod => {
       :type => 'bcmc_mobile'
     },
     :returnUrl => 'adyencheckout://your.package.name'
   }

   # 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 storedPaymentMethodDetails: Types.checkout.StoredPaymentMethodDetails = {
     type: Types.checkout.StoredPaymentMethodDetails.TypeEnum.BcmcMobile
   };

   const paymentRequest: Types.checkout.PaymentRequest = {
     reference: "YOUR_ORDER_NUMBER",
     amount: amount,
     merchantAccount: "ADYEN_MERCHANT_ACCOUNT",
     paymentMethod: storedPaymentMethodDetails,
     returnUrl: "adyencheckout://your.package.name"
   };

   // 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 contains:

   * `action`: Object containing information about the redirect.

     **/payments response**

     ```json
     {
         "resultCode": "Pending",
         "action": {
             "paymentData": "Ab02b4c0!BQABAgCpM2q6...==",
             "paymentMethodType": "bcmc_mobile",
             "url": "https://checkoutshopper-test.adyen.com/checkoutshopper/checkoutPaymentRedirect?redirectData=...",
             "qrCodeData": "BEP://1bcmc-test.adyen.com/pal/bep$RYB4BPBNXDTVG3PLKTXV5OVE",
             "type": "qrCode"
         },
         "additionalData": {
             "bcmcmobile.urlIntent": "BEPGenApp://DoTx?TransId=1bcmc-test.adyen.com/pal/bep$P5..."
     }
     ```

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

## Handle the redirect

Use the `QRCodeComponent` to redirect the shopper to the Bancontact app:

### Step 1: Initialize the QR Code Component

1. Before initializing the Component, make sure that you have added the following to your `build.gradle` file:

   **Initialize component**

   ```groovy
   implementation "com.adyen.checkout:qr-code:<latest-version>"
   ```

   Check the [latest version on GitHub](https://github.com/Adyen/adyen-android).

2. Create a configuration object for the Component, passing your [client key](/development-resources/client-side-authentication/#get-your-client-key):

   **Create configuration object**

   ```kotlin
   val qrCodeConfiguration = QRCodeConfiguration.Builder(context, "YOUR_CLIENT_KEY")
      .setEnvironment(Environment.TEST)
      .build()
   ```

3. To initialize an instance of the Component, call `PROVIDER.get` from the Component and pass in the context (for example, `this@YourActivity`), application class, and the configuration object created in the previous step:

   **Initialize instance of component**

   ```kotlin
   val qrCodeComponent = QRCodeComponent.PROVIDER.get(this@YourActivity, application, qrCodeConfiguration)
   ```

4. From your instance, call `handleAction` and pass:

   * the context (for example, `this@YourActivity`)
   * the `action` object from the deserialized `/payments` response.

   **Call handleAction**

   ```kotlin
   qrCodeComponent.handleAction(this@YourActivity, action)
   ```

### Step 2: Handle the redirect

1. Add an `IntentFilter` to the `Activity` that will handle the `returnUrl` specified in your [`/payments` request](/online-payments/build-your-integration/advanced-flow/?platform=Android\&integration=Components#make-a-payment).

   **Intent filter**

   ```xml
   <activity
       android:name=".YourActivity">
         <intent-filter>
            <action android:name="android.intent.action.VIEW"/>
            <category android:name="android.intent.category.DEFAULT"/>
            <category android:name="android.intent.category.BROWSABLE"/>
            <data android:host="${applicationId}" android:scheme="adyencheckout"/>
         </intent-filter>
    </activity>
   ```

   The `${applicationId}` will be replaced with `your.package.name` at build time.

2. Get the result of the redirect from the `Activity`. Pass the `intent` back to the Component. Depending on your activity's [launchMode](https://developer.android.com/guide/topics/manifest/activity-element#lmode), you can get this intent in either `onCreate` or `onNewIntent`.

   **Get result of redirect**

   ```kotlin
   private fun handleIntent(intent: Intent?) {
       val data = intent?.data
       if (data != null && data.toString().startsWith(RedirectUtil.REDIRECT_RESULT_SCHEME)) {
         qrCodeComponent.handleIntent(intent)
       }
   }
   ```

3. The Component notifies the `observer` with the `actionComponentData` object from the data in `intent.data`. Pass this to your server.

   **Notification**

   ```kotlin
   qrCodeComponent.observe(this) { actionComponentData ->
       // Send a /payments/details/ call containing the `actionComponentData`
       sendPaymentDetails(actionComponentData)
   }
   ```

### Step 3: Check the payment result

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 from the `QRCodeComponent`

  **/payments/details request**

  #### curl

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

  #### 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)
  PaymentCompletionDetails paymentCompletionDetails = new PaymentCompletionDetails()
    .redirectResult("eyJ0cmFuc1N0YXR1cyI6IlkifQ==");

  PaymentDetailsRequest paymentDetailsRequest = new PaymentDetailsRequest()
    .details(paymentCompletionDetails);

  // Send the request
  PaymentsApi service = new PaymentsApi(client);
  PaymentDetailsResponse response = service.paymentsDetails(paymentDetailsRequest, new RequestOptions().idempotencyKey("UUID"));
  ```

  #### PHP

  ```php
  // Adyen PHP API Library v19.0.0
  use Adyen\Client;
  use Adyen\Environment;
  use Adyen\Model\Checkout\PaymentCompletionDetails;
  use Adyen\Model\Checkout\PaymentDetailsRequest;
  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)
  $paymentCompletionDetails = new PaymentCompletionDetails();
  $paymentCompletionDetails
    ->setRedirectResult("eyJ0cmFuc1N0YXR1cyI6IlkifQ==");

  $paymentDetailsRequest = new PaymentDetailsRequest();
  $paymentDetailsRequest
    ->setDetails($paymentCompletionDetails);

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

  // Send the request
  $service = new PaymentsApi($client);
  $response = $service->paymentsDetails($paymentDetailsRequest, $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)
  PaymentCompletionDetails paymentCompletionDetails = new PaymentCompletionDetails
  {
    RedirectResult = "eyJ0cmFuc1N0YXR1cyI6IlkifQ=="
  };

  PaymentDetailsRequest paymentDetailsRequest = new PaymentDetailsRequest
  {
    Details = paymentCompletionDetails
  };

  // Send the request
  var service = new PaymentsService(client);
  var response = service.PaymentsDetails(paymentDetailsRequest, 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 paymentDetailsRequest = {
    details: {
      redirectResult: "eyJ0cmFuc1N0YXR1cyI6IlkifQ=="
    }
  }

  // Send the request
  const checkoutAPI = new CheckoutAPI(client);
  const response = checkoutAPI.PaymentsApi.paymentsDetails(paymentDetailsRequest, { 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)
  paymentCompletionDetails := checkout.PaymentCompletionDetails{
    RedirectResult: common.PtrString("eyJ0cmFuc1N0YXR1cyI6IlkifQ=="),
  }

  paymentDetailsRequest := checkout.PaymentDetailsRequest{
    Details: paymentCompletionDetails,
  }

  // Send the request
  service := client.Checkout()
  req := service.PaymentsApi.PaymentsDetailsInput().IdempotencyKey("UUID").PaymentDetailsRequest(paymentDetailsRequest)
  res, httpRes, err := service.PaymentsApi.PaymentsDetails(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 = {
    "details": {
      "redirectResult": "eyJ0cmFuc1N0YXR1cyI6IlkifQ=="
    }
  }

  # Send the request
  result = adyen.checkout.payments_api.payments_details(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 = {
    :details => {
      :redirectResult => 'eyJ0cmFuc1N0YXR1cyI6IlkifQ=='
    }
  }

  # Send the request
  result = adyen.checkout.payments_api.payments_details(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 paymentCompletionDetails: Types.checkout.PaymentCompletionDetails = {
    redirectResult: "eyJ0cmFuc1N0YXR1cyI6IlkifQ=="
  };

  const paymentDetailsRequest: Types.checkout.PaymentDetailsRequest = {
    details: paymentCompletionDetails
  };

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

  You receive a response containing:

* `resultCode`: Use this to [present the payment result](#present-the-payment-result) to your shopper.

* `pspReference`: Our unique identifier for the transaction.

  **/payments/details response**

  ```json
  {
        "resultCode": "Authorised",
        "pspReference": "88154795347618C"
  }
  ```

## Present the payment result

Use the  [resultCode](https://docs.adyen.com/api-explorer/Checkout/latest/post/payments/details#responses-200-resultCode) from the [/payments/details](https://docs.adyen.com/api-explorer/Checkout/latest/post/payments/details) response to present the payment result to your shopper. You will also receive the outcome of the payment asynchronously in a [webhook](/development-resources/webhooks).

For Bancontact payments, you can receive the following `resultCode` values:

| resultCode                  | Description                                                                                                                                               | Action to take                                                                                                                                                                                                                  |
| --------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Authorised**              | The payment was successful.                                                                                                                               | Inform the shopper that the payment was successful.                                                                                                                                                                             |
| **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.                                                                                                                                                            |
| **Pending** or **Received** | The payment order was successfully received.                                                                                                              | Inform the shopper that you have received their order, and are waiting for the payment to clear. You will receive the final result of the payment in an [AUTHORISATION webhook](/development-resources/webhooks/webhook-types). |
| **Refused**                 | The payment was refused. For more information, check the [`refusalReason` ](/development-resources/refusal-reasons)field.                                 | Ask the shopper to try the payment again using a different payment method.                                                                                                                                                      |

## Recurring payments

Bancontact supports [tokenization](/online-payments/tokenization/) for recurring payments.

We strongly recommend that you ask explicit permission from the shopper if you intend to make future recurring payments.

You can use recurring transactions through the Bancontact Wallet Initiated Program (WIP).

### Bancontact Wallet Initiated Program

The Bancontact Wallet Initiated Program (WIP) is a service that streamlines checkout and supports subscription-based billing. It offers the following:

* **Bancontact One-Click Pay** to speed up checkout and boost conversion rates
* **Bancontact Recurring** to support merchant-initiated recurring or subscription payments

You have to sign up to be able to use this service and not all companies are eligible to use Bancontact WIP. To enable Bancontact WIP, contact our [Support Team](https://ca-test.adyen.com/ca/ca/contactUs/support.shtml?form=other).

When you enable Bancontact WIP, transaction amount limits apply to ensure controlled and secure payments.

Shoppers go through Strong Customer Authentication (SCA) one time when they complete their first transaction and give their consent. Subsequent transactions do not require SCA, which reduces friction and improves the checkout flow. Because the first transaction goes through SCA, there is no liability shift. The issuer remains liable.

### Make a recurring payment

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

To test recurring payments, contact our [Support Team](https://ca-test.adyen.com/ca/ca/contactUs/support.shtml?form=other) to configure your test environment.

### Create a token

To create a token, include in your [/sessions](https://docs.adyen.com/api-explorer/#/CheckoutService/latest/post/sessions) or [/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 (minimum length three characters).

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`: This is 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 by using the [/listRecurringDetails](https://docs.adyen.com/api-explorer/#/Recurring/latest/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/).

The following example shows a recurring **Subscription** payment using WIP.

#### 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":"bcmc",
          "storedPaymentMethodId":"7219687191761347"
       },
       "reference":"YOUR_ORDER_NUMBER",
       "merchantAccount":"YOUR_MERCHANT_ACCOUNT",
       "shopperReference":"YOUR_UNIQUE_SHOPPER_ID_IOfW3k9G2PvXFu2j",
       "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);

CardDetails cardDetails = new CardDetails()
  .storedPaymentMethodId("7219687191761347")
  .type(CardDetails.TypeEnum.BCMC);

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

// 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("bcmc");

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

CardDetails cardDetails = new CardDetails
{
  StoredPaymentMethodId = "7219687191761347",
  Type = CardDetails.TypeEnum.Bcmc
};

PaymentRequest paymentRequest = new PaymentRequest
{
  Reference = "YOUR_ORDER_NUMBER",
  Amount = amount,
  MerchantAccount = "YOUR_MERCHANT_ACCOUNT",
  RecurringProcessingModel = PaymentRequest.RecurringProcessingModelEnum.Subscription,
  PaymentMethod = new CheckoutPaymentMethod(cardDetails),
  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: "bcmc",
    storedPaymentMethodId: "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,
}

cardDetails := checkout.CardDetails{
  StoredPaymentMethodId: common.PtrString("7219687191761347"),
  Type: common.PtrString("bcmc"),
}

paymentRequest := checkout.PaymentRequest{
  Reference: "YOUR_ORDER_NUMBER",
  Amount: amount,
  MerchantAccount: "YOUR_MERCHANT_ACCOUNT",
  RecurringProcessingModel: common.PtrString("Subscription"),
  PaymentMethod: checkout.CardDetailsAsCheckoutPaymentMethod(&cardDetails),
  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": "bcmc",
    "storedPaymentMethodId": "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 => 'bcmc',
    :storedPaymentMethodId => '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 cardDetails: Types.checkout.CardDetails = {
  storedPaymentMethodId: "7219687191761347",
  type: Types.checkout.CardDetails.TypeEnum.Bcmc
};

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

## Test and go live

Bancontact mobile does not have a test platform.

We recommend that you do a penny test in the live environment, where you make a payment with a value of **EUR .01**.

## See also

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