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

# Scalapay Android Component

Add Scalapay to an existing Components integration.

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

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

Choose the [server-side flow](/online-payments/build-your-integration) that your integration uses:

### Tab: Sessions flow

## Requirements

| Requirement          | Description                                                                                                                                                                                    |
| -------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Integration type** | Make sure that you have built a Sessions flow [Android Components integration](/online-payments/build-your-integration/sessions-flow?platform=Android). The minimum required version is 5.0.0. |
| **Setup steps**      | Before you begin, [add Scalapay in your Customer Area](/payment-methods/add-payment-methods).                                                                                                  |

Activating Scalapay defaults the pricing to our standard pricing. Adyen offers Enterprise pricing for merchants with sufficient volume. Before activating Scalapay, contact your account manager to verify if you are eligible.

## Create a payment session

This step corresponds to [Create a payment session](/online-payments/build-your-integration/sessions-flow/?platform=Android\&integration=Components\&version=5.3.0#create-the-checkout-session) in the Components integration guide.

You do not need to include any additional parameters for Scalapay in the API request.

## Set up Components

This section corresponds to [Set up Components](/online-payments/build-your-integration/sessions-flow/?platform=Android\&integration=Components#set-up) in the Components integration guide.

### Import the library

This step corresponds to the [Import the library step](/online-payments/build-your-integration/sessions-flow/?platform=Android\&integration=Components#import) of the Components integration guide.

During this step of integrating, use the following code snippets:

#### With Jetpack Compose

**Import the library with Compose**

```java
implementation "com.adyen.checkout:instant:YOUR_VERSION"
implementation "com.adyen.checkout:components-compose:YOUR_VERSION"
```

#### Without Jetpack Compose

**Import the library without Compose**

```java
implementation "com.adyen.checkout:instant:YOUR_VERSION"
```

### Configure the Component

This step corresponds to [Configure components](/online-payments/build-your-integration/sessions-flow/?platform=Android\&integration=Components#import) of the Components integration guide.

No specific configuration is required for Scalapay.

### Create the checkout session

This step corresponds to the [create a payment session step](/online-payments/build-your-integration/sessions-flow/?platform=Android\&integration=Components\&version=5.3.0#create-the-checkout-session) in the main integration guide.

### Launch and show the Component

This corresponds to the [Launch and show the Component step](/online-payments/build-your-integration/sessions-flow/?platform=Android\&integration=Components#launch-and-show) in the main integration guide.

During this step of integrating, use the following code snippets:

#### With Jetpack Compose

**Launch the Component with Compose**

```java
Component
import com.adyen.checkout.components.compose.get

// Get the payment method.
val paymentMethod = checkoutSession.getPaymentMethod(PaymentMethodTypes.SCALAPAY)

@Composable
private fun ComposableInstantComponent() {
   // Keep a reference to this Component in case you need to access it later.
   val instantPaymentComponent = InstantPaymentComponent.PROVIDER.get(
       checkoutSession = checkoutSession,
       paymentMethod = paymentMethod,
       configuration = configuration,
       componentCallback = callback,
       // This key is required to ensure a new Component gets created for each different screen or payment session.
       // Generate a new value for this key every time you need to reset the Component.
       key = "YOUR_UNIQUE_KEY_FOR_THIS_COMPONENT",
   )

   // This is your composable, a wrapper around our xml view.
   AdyenComponent(
      component = instantPaymentComponent,
      modifier = YOUR_MODIFIER,
   )
```

#### Without Jetpack Compose

**Launch the Component without Compose**

```java
<com.adyen.checkout.ui.core.AdyenComponentView
    android:id="@+id/YOUR_COMPONENT_VIEW_ID"
    .../>

// Get the payment method.
val paymentMethod = checkoutSession.getPaymentMethod(PaymentMethodTypes.SCALAPAY)

val instantPaymentComponent = InstantPaymentComponent.PROVIDER.get(
    activity, // Your activity or fragment.
    checkoutSession,
    paymentMethod,
    cardConfiguration,
    componentCallback,
)

binding.componentView.attach(instantPaymentComponent, viewLifecycleOwner)
```

### Tab: Advanced flow

## 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). The minimum required version is 5.0.0. |
| **Setup steps**      | Before you begin, [add Scalapay in your Customer Area](/payment-methods/add-payment-methods).                                                                                                   |

Activating Scalapay defaults the pricing to our standard pricing. Adyen offers Enterprise pricing for merchants with sufficient volume. Before activating Scalapay, contact your account manager to verify if you are eligible.

## Configure the Component

This corresponds to the [Configure components step](/online-payments/build-your-integration/advanced-flow?platform=Android\&integration=Components\&version=5.2.0#configure) in the main integration guide.

You do not need to add specific configuration for Scalapay.

### Import the library

This step corresponds to the [Import the library step](/online-payments/build-your-integration/sessions-flow/?platform=Android\&integration=Components#import) of the Components integration guide.

During this step of integrating, use the following code snippets:

#### With Jetpack Compose

**Import the library with Compose**

```java
implementation "com.adyen.checkout:instant:YOUR_VERSION"
implementation "com.adyen.checkout:components-compose:YOUR_VERSION"
```

#### Without Jetpack Compose

**Import the library without Compose**

```java
implementation "com.adyen.checkout:instant:YOUR_VERSION"
```

## Launch and show the Component

Follow the steps in the [Android Components Advanced flow integration guide](/online-payments/build-your-integration/advanced-flow/?tab=compose-launch_1#launch-and-show) to launch and show the Component for Scalapay.

During this step of integrating, use the following code snippets:

#### With Jetpack Compose

**Create the Component with Compose**

```java
import com.adyen.checkout.components.compose.get

   // Create the payment method object from the /paymentMethods response.
   val paymentMethod = paymentMethodsApiResponse?.paymentMethods.orEmpty().firstOrNull {
  it.type == PaymentMethodTypes.SCALAPAY
   }

@Composable
private fun ComposableCardComponent() {
    // Keep a reference to this Component in case you need to access it later.
    val cardComponent = InstantComponent.PROVIDER.get(
        paymentMethod = paymentMethod,
        configuration = configuration,
        componentCallback = callback,
        // This key is required to ensure a new Component gets created for each different screen or payment session.
        // Generate a new value for this key every time you need to reset the Component.
        key = "UNIQUE_KEY_PER_COMPONENT",
    )

    // This is your composable, a wrapper around our xml view.
    AdyenComponent(
        component = instantComponent,
        modifier = YOUR_MODIFIER,
    )
}
```

#### Without Jetpack Compose

**Create the Component without Compose**

```java
// Create the payment method object from the /paymentMethods response.
val paymentMethod = paymentMethodsApiResponse?.paymentMethods.orEmpty().firstOrNull {
    it.type == PaymentMethodTypes.SCALAPAY
}

val cardComponent = InstantComponent.PROVIDER.get(
    activity, // Your activity or fragment.
    paymentMethod,
    cardConfiguration,
    componentCallback,
)
```

## Make a payment

Make a payment request with the payment information for the shopper, as described in the [Android Components Advanced flow integration guide](/online-payments/build-your-integration/advanced-flow/?platform=Android\&integration=Components\&version=5.2.0#make-a-payment).

**Sample /payments request**

#### curl

```bash
curl https://checkout-test.adyen.com/v72/payments \
-H 'x-api-key: ADYEN_API_KEY' \
-H 'content-type: application/json' \
-d '{
  "merchantAccount":"YOUR_MERCHANT_ACCOUNT",
  "reference":"YOUR_ORDER_NUMBER",
  "countryCode":"IT",
  "paymentMethod": {
    "type":"scalapay_3x"
  },
  "amount":{
    "currency":"EUR",
    "value":1000
  },
  "shopperName": {
     "firstName":"Simone",
     "lastName":"Hopper"
  },
  "returnUrl":"adyencheckout://your.package.name"
}'
```

#### Java

```java
// Adyen Java API Library v28.2.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);

Name name = new Name()
  .firstName("Simone")
  .lastName("Hopper");

PaymentDetails paymentDetails = new PaymentDetails()
  .type(PaymentDetails.TypeEnum.SCALAPAY_3X);

PaymentRequest paymentRequest = new PaymentRequest()
  .reference("YOUR_ORDER_NUMBER")
    .countryCode("IT")
  .amount(amount)
  .shopperName(name)
  .merchantAccount("YOUR_MERCHANT_ACCOUNT")
  .paymentMethod(new CheckoutPaymentMethod(paymentDetails))
  .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 v20.1.0
use Adyen\Client;
use Adyen\Environment;
use Adyen\Model\Checkout\Amount;
use Adyen\Model\Checkout\Name;
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);

$name = new Name();
$name
  ->setFirstName("Simone")
  ->setLastName("Hopper");

$checkoutPaymentMethod = new CheckoutPaymentMethod();
$checkoutPaymentMethod
  ->setType("scalapay_3x");

$paymentRequest = new PaymentRequest();
$paymentRequest
  ->setReference("YOUR_ORDER_NUMBER")
  ->setCountryCode("IT")
  ->setAmount($amount)
  ->setShopperName($name)
  ->setMerchantAccount("YOUR_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 v19.1.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
};

Name name = new Name
{
  FirstName = "Simone",
  LastName = "Hopper"
};

PaymentDetails paymentDetails = new PaymentDetails
{
  Type = PaymentDetails.TypeEnum.Scalapay3x
};

PaymentRequest paymentRequest = new PaymentRequest
{
  Reference = "YOUR_ORDER_NUMBER",
  countryCode = "IT",
  Amount = amount,
  ShopperName = name,
  MerchantAccount = "YOUR_MERCHANT_ACCOUNT",
  PaymentMethod = new CheckoutPaymentMethod(paymentDetails),
  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 v19.2.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: "YOUR_MERCHANT_ACCOUNT",
  reference: "YOUR_ORDER_NUMBER",
  countryCode: "IT",
  paymentMethod: {
    type: "scalapay_3x"
  },
  amount: {
    currency: "EUR",
    value: 1000
  },
  shopperName: {
    firstName: "Simone",
    lastName: "Hopper"
  },
  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 v12.1.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,
}

name := checkout.Name{
  FirstName: "Simone",
  LastName: "Hopper",
}

paymentDetails := checkout.PaymentDetails{
  Type: common.PtrString("scalapay_3x"),
}

paymentRequest := checkout.PaymentRequest{
  countryCode: "IT",
  Reference: "YOUR_ORDER_NUMBER",
  Amount: amount,
  ShopperName: &name,
  MerchantAccount: "YOUR_MERCHANT_ACCOUNT",
  PaymentMethod: checkout.PaymentDetailsAsCheckoutPaymentMethod(&paymentDetails),
  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.7.0
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": "YOUR_MERCHANT_ACCOUNT",
  "reference": "YOUR_ORDER_NUMBER",
  "countryCode": "IT",
  "paymentMethod": {
    "type": "scalapay_3x"
  },
  "amount": {
    "currency": "EUR",
    "value": 1000
  },
  "shopperName": {
    "firstName": "Simone",
    "lastName": "Hopper"
  },
  "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.7.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 => 'YOUR_MERCHANT_ACCOUNT',
  :reference => 'YOUR_ORDER_NUMBER',
  :countryCode => 'IT',
  :paymentMethod => {
    :type => 'scalapay_3x'
  },
  :amount => {
    :currency => 'EUR',
    :value => 1000
  },
  :shopperName => {
    :firstName => 'Simone',
    :lastName => 'Hopper'
  },
  :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 v19.2.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 name: Types.checkout.Name = {
  firstName: "Simone",
  lastName: "Hopper"
};

const paymentDetails: Types.checkout.PaymentDetails = {
  type: Types.checkout.PaymentDetails.TypeEnum.Scalapay3x
};

const paymentRequest: Types.checkout.PaymentRequest = {
  reference: "YOUR_ORDER_NUMBER",
  countryCode: "IT",
  amount: amount,
  shopperName: name,
  merchantAccount: "YOUR_MERCHANT_ACCOUNT",
  paymentMethod: paymentDetails,
  returnUrl: "adyencheckout://your.package.name"
};

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

## Test and go live

Use the test cards for the test scenarios that are specified on the [Scalapay website](https://developers.scalapay.com/docs/test-the-order-flow).

Check the status of Scalapay test payments in your [Customer Area](https://ca-test.adyen.com/) > **Transactions** > **Payments**.

Before you can accept live Scalapay payments, [submit a request for Scalapay](/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/#/CheckoutService/latest/overview)
