Bancontact mobile Redirect Component

Use our Redirect Component 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.
2. Handle the redirect result when the shopper returns to your app.

Before you begin

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

Before starting your Bancontact integration:

1. Make sure that you have set up your back end implementation for making API requests.
2. Add Bancontact in your test Customer Area.

Show Bancontact in your payment form

Include Bancontact in the list of available payment methods. You don't need to collect any information from the shopper in your payment form.

1. Specify in your /paymentMethods request:

   • countryCode: BE.
   • amount.currency: EUR.

The response contains paymentMethod.type: bcmc_mobile.

Optional configuration

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

val bcmcConfiguration = BcmcConfiguration.Builder(context, "YOUR_CLIENT_KEY")
    // Makes the cardholder name required.
    .setHolderNameRequired(true)
    // When you're 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 proceeds to pay, make a /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 Ruby Java PHP Python C# NodeJS

   curl Ruby Java PHP Python C# NodeJS

   curl https://checkout-test.adyen.com/v68/payments \
   -H "x-API-key: YOUR_X-API-KEY" \
   -H "content-type: application/json" \
   -d '{
     "merchantAccount":"YOUR_MERCHANT_ACCOUNT",
     "reference":"YOUR_ORDER_NUMBER",
     "amount":{
       "currency":"EUR",
       "value":1000
     },
     "paymentMethod":{
       "type":"bcmc_mobile"
     },
     "returnUrl":"adyencheckout://your.package.name"
   }'

   # Set your X-API-KEY with the API key from the Customer Area.
   adyen = Adyen::Client.new
   adyen.api_key = "YOUR_X-API-KEY"
    
   response = adyen.checkout.payments({
     :amount => {
       :currency => "EUR",
       :value => 1000
     },
     :reference => "YOUR_ORDER_NUMBER",
     :paymentMethod => {
       :type => "bcmc_mobile"
     },
     :returnUrl => "https://your-company.com/checkout?shopperOrder=12xy..",
     :merchantAccount => "YOUR_MERCHANT_ACCOUNT"
   })

   // Set YOUR_X-API-KEY with the API key from the Customer Area.
   // Change to Environment.LIVE and add the Live URL prefix when you're ready to accept live payments.
   Client client = new Client("YOUR_X-API-KEY", Environment.TEST);
   Checkout checkout = new Checkout(client);
   
   PaymentsRequest paymentsRequest = new PaymentsRequest();
   
   String merchantAccount = "YOUR_MERCHANT_ACCOUNT";
   paymentsRequest.setMerchantAccount(merchantAccount);
   
   Amount amount = new Amount();
   amount.setCurrency("EUR");
   amount.setValue(15000L);
   paymentsRequest.setAmount(amount);
   
   DefaultPaymentMethodDetails paymentMethodDetails = new DefaultPaymentMethodDetails();
   paymentMethodDetails.setType("bcmc_mobile");
   paymentsRequest.setPaymentMethod(paymentMethodDetails);
   
   paymentsRequest.setReference("YOUR_ORDER_NUMBER");
   paymentsRequest.setReturnUrl("https://your-company.com/checkout?shopperOrder=12xy..");
   
   PaymentsResponse paymentsResponse = checkout.payments(paymentsRequest);

   // Set your X-API-KEY with the API key from the Customer Area.
   $client = new \Adyen\Client();
   $client->setXApiKey("YOUR_X-API-KEY");
   $service = new \Adyen\Service\Checkout($client);
   
   $params = array(
     "amount" => array(
       "currency" => "EUR",
       "value" => 1000
     ),
     "reference" => "YOUR_ORDER_NUMBER",
     "paymentMethod" => array(
       "type" => "bcmc_mobile"
     ),
     "returnUrl" => "https://your-company.com/checkout?shopperOrder=12xy..",
     "merchantAccount" => "YOUR_MERCHANT_ACCOUNT"
   );
   $result = $service->payments($params);

   #Set your X-API-KEY with the API key from the Customer Area.
   adyen = Adyen.Adyen()
   adyen.client.xapikey = 'YOUR_X-API-KEY'
   
   result = adyen.checkout.payments({
      'amount': {
         'value': 1000,
         'currency': 'EUR'
      },
      'reference': 'YOUR_ORDER_NUMBER',
      'paymentMethod': {
         'type': 'bcmc_mobile'
      },
      'returnUrl': 'https://your-company.com/checkout?shopperOrder=12xy..',
      'merchantAccount': 'YOUR_MERCHANT_ACCOUNT'
   })

   // Set your X-API-KEY with the API key from the Customer Area.
   var client = new Client ("YOUR_X-API-KEY", Environment.Test);
   var checkout = new Checkout(client);
   
   var amount = new Model.Checkout.Amount("EUR", 1000);
   var details = new Model.Checkout.DefaultPaymentMethodDetails{
     Type = "bcmc_mobile"
   };
   var paymentRequest = new Adyen.Model.Checkout.PaymentRequest
   {
     Reference = "YOUR_ORDER_NUMBER",
     Amount = amount,
     ReturnUrl = @"https://your-company.com/checkout?shopperOrder=12xy..",
     MerchantAccount = "YOUR_MERCHANT_ACCOUNT",
     PaymentMethod = details
   };
   
   var paymentResponse = checkout.Payments(paymentsRequest);

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

   https://docs.adyen.com/pt/pt/payment-methods/bancontact/bancontact-mobile/android-component#bancontact-payments

   The /payments response contains:

   • action: Object containing information about the redirect.

     /payments response

     {
         "resultCode": "Pending",
         "action": {
             "paymentData": "Ab02b4c0!BQABAgCpM2q6...==",
             "paymentMethodType": "bcmc_mobile",
             "url": "BEPGenApp://DoTx?TransId=1bcmc-test.adyen.com/pal/bep$P5FOT6N55HYZNXVPFDGIHEJC",
             "qrCodeData": "BEP://1bcmc-test.adyen.com/pal/bep$RYB4BPBNXDTVG3PLKTXV5OVE",
             "type": "qrCode"
         }
     }

     https://docs.adyen.com/pt/pt/payment-methods/bancontact/bancontact-mobile/android-component#-payments-response

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've added the following to your build.gradle file:

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

   Check the latest version on GitHub.
2. Create a configuration object for the Component, passing your client key:

   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:

    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.

   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.

   <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, you can get this intent in either onCreate or onNewIntent.

   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.

   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 request from your server, providing:

• details: The actionComponentData.details object from the from the QRCodeComponent

  /payments/details request

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

  https://docs.adyen.com/pt/pt/payment-methods/bancontact/bancontact-mobile/android-component#-payments-details-request

  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

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

  https://docs.adyen.com/pt/pt/payment-methods/bancontact/bancontact-mobile/android-component#-payments-details-response

Present the payment result

Use the resultCode from the /payments/details response to present the payment result to your shopper. You will also receive the outcome of the payment asynchronously in a notification webhook.

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

Recurring payments

We support recurring transactions for Bancontact through SEPA Direct Debit. To make recurring payments, you need to:

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

Create a token

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

• storePaymentMethod: true
• shopperReference: Your unique identifier for the shopper (minimum length three characters).

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

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

Make a payment with a token

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

• paymentMethod.storedPaymentMethodId: The pspReference from the RECURRING_CONTRACT. You can also get this value by using the /listRecurringDetails endpoint.
• shopperReference: The unique shopper identifier that you specified when creating the token.
• shopperInteraction: ContAuth.
• recurringProcessingModel: Subscription or UnscheduledCardOnFile.

For more information about the shopperInteraction and recurringProcessingModel fields, refer to Recurring transaction types.

curl https://checkout-test.adyen.com/v68/payments \
-H "x-API-key: YOUR_X-API-KEY" \
-H "content-type: application/json" \
-d '{
       "amount":{
          "value":1000,
          "currency":"EUR"
       },
       "paymentMethod":{
          "type":"sepadirectdebit",
          "storedPaymentMethodId":"7219687191761347"
       },
       "reference":"YOUR_ORDER_NUMBER",
       "merchantAccount":"YOUR_MERCHANT_ACCOUNT",
       "shopperReference":"YOUR_UNIQUE_SHOPPER_ID_IOfW3k9G2PvXFu2j",
       "shopperInteraction":"ContAuth",
       "recurringProcessingModel": "Subscription"
}'

# Set your X-API-KEY with the API key from the Customer Area.
adyen = Adyen::Client.new
adyen.api_key = "YOUR_X-API-KEY"
 
response = adyen.checkout.payments({
  :amount => {
    :currency => "EUR",
    :value => 1000
  },
  :reference => "YOUR_ORDER_NUMBER",
  :paymentMethod => {
    :type => "sepadirectdebit",
    :storedPaymentMethodId => "7219687191761347"
  },
  :returnUrl => "https://your-company.com/checkout?shopperOrder=12xy..",
  :shopperReference => "YOUR_UNIQUE_SHOPPER_ID_IOfW3k9G2PvXFu2j",
  :merchantAccount => "YOUR_MERCHANT_ACCOUNT",
  :shopperInteraction => "ContAuth",
  :recurringProcessingModel => "Subscription"
})

// Set YOUR_X-API-KEY with the API key from the Customer Area.
// Change to Environment.LIVE and add the Live URL prefix when you're ready to accept live payments.
Client client = new Client("YOUR_X-API-KEY", Environment.TEST);
Checkout checkout = new Checkout(client);

PaymentsRequest paymentsRequest = new PaymentsRequest();

String merchantAccount = "YOUR_MERCHANT_ACCOUNT";
paymentsRequest.setMerchantAccount(merchantAccount);

Amount amount = new Amount();
amount.setCurrency("EUR");
amount.setValue(15000L);
paymentsRequest.setAmount(amount);

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

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

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

#Set your X-API-KEY with the API key from the Customer Area.
adyen = Adyen.Adyen()
adyen.client.xapikey = 'YOUR_X-API-KEY'

result = adyen.checkout.payments({
   'amount': {
      'value': 1000,
      'currency': 'EUR'
   },
   'reference': 'YOUR_ORDER_NUMBER',
   'paymentMethod': {
      'type': 'sepadirectdebit',
      'storedPaymentMethodId': '7219687191761347'
   },
   'returnUrl': 'https://your-company.com/checkout?shopperOrder=12xy..',
   'shopperReference': 'YOUR_UNIQUE_SHOPPER_ID_IOfW3k9G2PvXFu2j'
   'merchantAccount': 'YOUR_MERCHANT_ACCOUNT',
   'shopperInteraction':'ContAuth',
   'recurringProcessingModel': 'Subscription'
})

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

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

var paymentResponse = checkout.Payments(paymentsRequest);

// Set your X-API-KEY with the API key from the Customer Area.
const {Client, Config, CheckoutAPI} = require('@adyen/api-library');
const config = new Config();
// Set your X-API-KEY with the API key from the Customer Area.
config.apiKey = '[API_KEY]';
config.merchantAccount = '[YOUR_MERCHANT_ACCOUNT]';
const client = new Client({ config });
client.setEnvironment("TEST");
const checkout = new CheckoutAPI(client);
checkout.payments({
    amount: { currency: "EUR", value: 1000 },
    paymentMethod: {
        type: 'sepadirectdebit',
        storedPaymentMethodId: "7219687191761347"
    },
    reference: "YOUR_ORDER_NUMBER",
    merchantAccount: config.merchantAccount,
    shopperReference: "YOUR_UNIQUE_SHOPPER_ID_IOfW3k9G2PvXFu2j",
    returnUrl: "https://your-company.com/checkout?shopperOrder=12xy..",
    shopperInteraction: "ContAuth",
    recurringProcessingModel: "Subscription"
}).then(res => res);

Test and go live

Bancontact currently has no test platform.
You can specify the last three digits of a payment amount as follows to simulate authorised or declined payments.

Any other scenarios must be tested in the live environment using real payment details and small amounts.
Before you can accept live payments, you need to submit a request for Bancontact in your live Customer Area.

See also