---
title: "BLIK Android Component"
description: "Add BLIK to an existing Android Components integration."
url: "https://docs.adyen.com/payment-methods/blik/android-component"
source_url: "https://docs.adyen.com/payment-methods/blik/android-component.md"
canonical: "https://docs.adyen.com/payment-methods/blik/android-component"
last_modified: "2026-06-01T15:33:15+02:00"
language: "en"
---

# BLIK Android Component

Add BLIK to an existing Android Components integration.

[View source](/payment-methods/blik/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): **blik**
* To [launch and show the Component](/online-payments/build-your-integration/sessions-flow?platform=Android\&integration=Components#launch-and-show): **BlikComponent**

This page explains how to add BLIK to your existing Android Components integration.

## Requirements

| Requirement          | Description                                                                                                                                                                                                               |
| -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Integration type** | Make sure that you have built your [Components integration](/online-payments//). BLIK for Android requires at least v3.8.0 of Components. For more information, refer to [Release notes](/online-payments/release-notes). |
| **Setup steps**      | Before you begin, [add BLIK in your test Customer Area](/payment-methods/add-payment-methods).                                                                                                                            |

## Set up the BLIK Component

1. Import the BLIK Component to your `build.gradle` file:

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

   For the latest version, refer to our [GitHub](https://github.com/Adyen/adyen-android).

2. Build a client-side configuration of the BLIK Component:
   ```kotlin
   val blikConfiguration =
     BlikConfiguration.Builder(context, "YOUR_CLIENT_KEY")
     // When you are ready to accept live payments, change the value to one of our live environments.
     .setEnvironment(Environment.TEST)
     .build()
   ```

3. Add the Component view to your layout:

   ```ml
   <com.adyen.checkout.blik.BlikView
     android:id="@+id/YOUR_COMPONENT_VIEW_ID"
     .../>
   ```

   You will attach the initialized component to this view when [collecting payment details](#collect-payment-details).

## Collect payment details

Use the client-side Component to collect the phone number from your shopper.

1. Deserialize [the `/paymentMethods` response](/online-payments/build-your-integration/advanced-flow/?platform=Android\&integration=Components#get-available-payment-methods) with the `SERIALIZER` object:
   ```kotlin
   val paymentMethodsApiResponse = PaymentMethodsApiResponse.SERIALIZER.deserialize(paymentMethodsResponse)
   ```

2. From the result, get the object containing `paymentMethods.type`: **blik**.

3. Initialize an instance of the Component. Call `PROVIDER.get` from the BLIK Component and pass the following:

   * The context (for example, `this@YourActivity`)
   * The `PaymentMethod` object (for example, `paymentMethod`)
   * The `BlikConfiguration` object:
     ```kotlin
     val blikComponent = BlikComponent.PROVIDER.get(this@YourActivity, paymentMethod, blikConfiguration)
     ```

4. Attach the Component to the view to start getting your shopper's payment details. You need to call `attach` from the payment method's Component view and pass in:

   * the `BlikComponent`
   * the context (for example, `this@YourActivity`): `BlikView.attach(blikComponent, this@YourActivity)`\
     You start receiving updates when the shopper enters their phone number.

5. Check if `isValid` is **true**, and when the shopper proceeds to pay, pass the `paymentComponentState.data.paymentMethod` to your server:
   ```kotlin
   blikComponent.observe(this@MainActivity) { state ->
     if (state?.isValid == true) {
         //serialize data
         val paymentComponentData = PaymentComponentData.SERIALIZER.serialize(state.data)
         // When the shopper pays, pass the serialized `state.data` to your server to send a /payments request
     }
   }
   ```

## Handle the await action

### Step 1: Deserialize the action object

In your client-side app, deserialize the `action` object from the [`/payments` response](/online-payments/build-your-integration/advanced-flow/?platform=Android\&integration=Components#make-a-payment):

```kotlin
val action = Action.SERIALIZER.deserialize(paymentResponse.action)
```

### Step 2: Initialize the 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:await:<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 awaitConfiguration = AwaitConfiguration.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 awaitComponent = AwaitComponent.PROVIDER.get(this@YourActivity, application, awaitConfiguration)
   ```

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
   awaitComponent.handleAction(this@YourActivity, action)
   ```

### Step 3: Check the payment result

The Component notifies the `observer` with the `actionComponentData` object from the data in `intent.data`. Pass this to your server to make a [`/payments/details` request](/online-payments/build-your-integration/advanced-flow/?platform=Android\&integration=Drop-in#send-additional-payment-details).

**Check payment result**

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

## Test and go live

To test a BLIK with code payment:

* Use BLIK code 777213.
* Make sure your implementation satisfies BLIK’s guidelines.
* Test your integration end-to-end.

### Going live

Before you can accept live BLIK payments, you need to add BLIK in your live Customer Area.

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