Install the Android SDK

Install the Android SDK library and start using components in your project.

Before you start

Make sure you meet the system requirements:

Requirement	Minimum / notes
`minSdk`	24
`compileSdk`	36 (recommended)
Kotlin	2.x
Jetpack Compose	Required (SDK UI is Compose-based)
Java desugaring	Recommended for Java 8+ APIs
Android Studio	Latest stable version (Hedgehog or later recommended)
Java Development Kit (JDK)	17 or higher
Google Play Services	21.0.0 or higher (required for Google Pay)
Custom Tabs browser	Chrome or another Custom Tabs-compatible browser (required for Paze checkout)

The SDK pulls transitive dependencies (Compose, Retrofit, OkHttp, Gson, Koin, Google Pay, and others) via its POM. Some transitive dependencies are hosted on JitPack rather than Maven Central — your project must declare the JitPack repository so Gradle can download them when resolving the SDK.

Step 1: Install the Android SDK library

Add the latest PXP Android Components SDK from Maven Central in your Android app. Browse published versions, dependencies, and the POM on the artifact page.

Configure repositories

Add mavenCentral() and the JitPack repository in your project-level build.gradle, settings.gradle, or dependencyResolutionManagement block:

repositories {
    google()
    mavenCentral()
    maven { url = 'https://jitpack.io' }  // Required for some SDK transitive dependencies hosted on JitPack
}

Apply the Kotlin Compose plugin

The SDK UI is Compose-based. Apply the Kotlin Compose plugin in your root and app module build files.

Root build.gradle:

buildscript {
    dependencies {
        classpath "org.jetbrains.kotlin:compose-compiler-gradle-plugin:<kotlin-version>"
    }
}

plugins {
    id 'org.jetbrains.kotlin.plugin.compose' version '2.2.10' apply false
}

App module plugins:

plugins {
    id 'com.android.application'
    id 'org.jetbrains.kotlin.plugin.compose'
}

Add the SDK dependency

Configure your app module and add the Maven Central dependency:

android {
    compileSdk = 36

    defaultConfig {
        minSdk = 24
    }

    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_11
        targetCompatibility = JavaVersion.VERSION_11
        coreLibraryDesugaringEnabled = true
    }

    buildFeatures {
        compose = true
    }
}

dependencies {
    coreLibraryDesugaring "com.android.tools:desugar_jdk_libs:2.1.4"

    implementation "io.pxp:android-components-sdk:1.0.0"

    // Your app Compose dependencies (example)
    implementation platform("androidx.compose:compose-bom:2026.02.01")
    implementation "androidx.compose.ui:ui"
    implementation "androidx.compose.material3:material3"
    implementation "androidx.activity:activity-compose:1.8.2"
}

Sync Gradle. Android Studio downloads the AAR from Maven Central.

Check the latest published version

Open the Maven Central artifact page and select the Versions tab, or query metadata directly:

curl -s https://repo.maven.apache.org/maven2/io/pxp/android-components-sdk/maven-metadata.xml

Use the <release> value (or the version shown on Sonatype) in your implementation line.

Verify dependency resolution

./gradlew :app:dependencies --configuration debugCompileClasspath | grep io.pxp

Expected output includes io.pxp:android-components-sdk:<version>.

Step 2: Add the required permissions

The SDK automatically merges the required permissions from its manifest, including:

INTERNET: required for API communication
ACCESS_NETWORK_STATE: required for network state checking
SYSTEM_ALERT_WINDOW: required for the 3DS Challenge overlay

The SDK also merges:

Custom Tabs <queries> intent filters for PayPal and Paze web checkout
Google Pay <meta-data> configuration
Deeplink activities for Paze (PazeSdkRedirectActivity for pxpcheckout://callback and pxpcheckout://paze)

For Paze, the SDK merges redirect handling for the default schemes. Your host Activity must still implement onNewIntent and call deliverPazeCheckoutResult. See Paze implementation.

No manual manifest configuration is required. These entries are merged automatically when you add the SDK dependency.

Step 3: Get your API credentials

In order to initialise the SDK, you'll need to send authenticated requests to the PXP API.

To get your credentials:

In the Unity Portal, go to Merchant setup > Merchant groups.
Select a merchant group.
Click the Inbound calls tab.
Copy the Client ID in the top-right corner.
Click New token.
Choose a number of days before token expiry. For example, 30.
Click Save to confirm. Your token is now created.
Copy the token ID and token value. Make sure to keep these confidential to protect the integrity of your authentication process.

As best practice, we recommend regularly generating and implementing new tokens.

Step 4: Get the session data

Now that you have your credentials, you're ready to send an API request to the sessions endpoint. This allows you to retrieve the transaction session data from the back-end, so you can supply it when you initialise the SDK.

For Paze, configure Paze in the Unity Portal first, use USD in amounts.currencyCode, and confirm the session response includes allowedFundingTypes.wallets.paze.clientId and merchantCategoryCode. Paze-specific session and SDK setup is documented in Paze onboarding and Paze implementation.

Our platform uses HMAC (Hash-based Message Authentication Code) with SHA256 for authentication to ensure secure communication and data integrity. This method involves creating a signature by hashing your request data with a secret key, which must then be included in the HTTP headers of your API request.

To create the HMAC signature, you need to prepare a string that includes four parts:

A timestamp, in Unix format. For example, 1754701373.
A unique request ID, in GUID format. For example, ce244054-b372-42c2-9102-f0d976db69f6.
The request path, which is api/v1/sessions.

The request body. For example:

{
   "merchant": "MERCHANT-1",
   "site": "SITE-1",
   "sessionTimeout": 120,
   "merchantTransactionId": "0ce72cfd-014d-4256-a006-a56601b2ffc4",
   "transactionMethod": {
     "intent": {
       "card": "Authorisation",
       "paypal": "Purchase",
       "googlepay": "Authorisation"
     }
   },
   "amounts": {
     "currencyCode": "EUR",
     "transactionValue": 20
   },
   "authorisation": true,
   "addressVerification": {
     "countryCode": "GB",
     "houseNumberOrName": "10 Downing Street",
     "postalCode": "SW1A 2AA"
   },
   "identityVerification": {
     "nameVerification": true
   },
   "threeDSecureData": {
     "threeDSecureVersion": "2.2",
     "electronicCommerceIndicator": "05",
     "cardHolderAuthenticationVerificationValue": "CAVV1234567890",
     "directoryServerTransactionId": "550e8400-e29b-41d4-a716-446655440000",
     "threeDSecureTransactionStatus": "Y"
   }
}

Put these four parts together following this format: "{timestamp}{requestId}{requestPath}{requestBody}". The result should look something like this:

1754701373ce244054-b372-42c2-9102-f0d976db69f6api/v1/sessions{
  "merchant": "MERCHANT-1",
  "site": "SITE-1",
  "sessionTimeout": 120,
  "merchantTransactionId": "0ce72cfd-014d-4256-a006-a56601b2ffc4",
  "transactionMethod": {
    "intent": {
      "card": "Authorisation",
      "paypal": "Purchase",
      "googlepay": "Authorisation"
    }
  },
  "amounts": {
    "currencyCode": "EUR",
    "transactionValue": 20
  },
  "authorisation": true,
  "addressVerification": {
    "countryCode": "GB",
    "houseNumberOrName": "10 Downing Street",
    "postalCode": "SW1A 2AA"
  },
  "identityVerification": {
    "nameVerification": true
  },
  "threeDSecureData": {
    "threeDSecureVersion": "2.2",
    "electronicCommerceIndicator": "05",
    "cardHolderAuthenticationVerificationValue": "CAVV1234567890",
    "directoryServerTransactionId": "550e8400-e29b-41d4-a716-446655440000",
    "threeDSecureTransactionStatus": "Y"
  }
}

Use your token ID to encrypt this data structure by SHA256. You can find your token ID in the Unity Portal. Here's an example of an hmacSignature after you've encrypted the data:

1DE2DFC390D7CD746A972140F26846AFA81CF85F5A0BAABA95DBC95301795EA6

You can now put together your Authorization header. It follows this format: PXP-UST1 {tokenId}:{timestamp}:{hmacSignature}. For example:

"PXP-UST1 9aac6071-38d0-4545-9d2f-15b936af6d7f:1754701373:1DE2DFC390D7CD746A972140F26846AFA81CF85F5A0BAABA95DBC95301795EA6"

Lastly, send your request to the Sessions API. You'll need to add a request ID of your choice and include your client ID, which you can find in the Unity Portal.

Here's a full example of what your request might look like:

curl -i -X POST \
  'https://api-services.pxp.io/api/v1/sessions' \
  -H 'Authorization: "PXP-UST1 9aac6071-38d0-4545-9d2f-15b936af6d7f:1754701373:1DE2DFC390D7CD746A972140F26846AFA81CF85F5A0BAABA95DBC95301795EA6"' \
  -H 'X-Request-Id: "550e8400-e29b-41d4-a716-446655440000"' \
  -H 'X-Client-Id: "f47ac10b-58cc-4372-a567-0e02b2c3d479"' \
  -H 'Content-Type: application/json' \
  -d '{
  "merchant": "MERCHANT-1",
  "site": "SITE-1",
  "sessionTimeout": 120,
  "merchantTransactionId": "0ce72cfd-014d-4256-a006-a56601b2ffc4",
  "transactionMethod": {
    "intent": {
      "card": "Authorisation",
      "paypal": "Purchase",
      "googlepay": "Authorisation"
    }
  },
  "amounts": {
    "currencyCode": "EUR",
    "transactionValue": 20
  },
  "authorisation": true,
  "addressVerification": {
    "countryCode": "GB",
    "houseNumberOrName": "10 Downing Street",
    "postalCode": "SW1A 2AA"
  },
  "identityVerification": {
    "nameVerification": true
  },
  "threeDSecureData": {
    "threeDSecureVersion": "2.2",
    "electronicCommerceIndicator": "05",
    "cardHolderAuthenticationVerificationValue": "CAVV1234567890",
    "directoryServerTransactionId": "550e8400-e29b-41d4-a716-446655440000",
    "threeDSecureTransactionStatus": "Y"
  }
}'

Body parameters

Parameter	Description
`merchant` string (≤ 20 characters) required	Your unique merchant identifier, as assigned by PXP. You can find it in the Unity Portal, by going to Merchant setup > Merchants and checking the Merchant ID column or by clicking on a merchant and checking the General information section.
`site` string (≤ 20 characters) required	Your unique site identifier, as assigned by PXP. You can find it in the Unity Portal, by going to Merchant setup > Sites and checking the Site ID column or by clicking on a site and checking the General information section.
`merchantTransactionId` string (≤ 50 characters) required	A unique identifier of your choice that represents this transaction.
`sessionTimeout` number required	The duration of the session, in minutes.
`transactionMethod` object required	Details about the transaction method, including the intent for each payment type.
`transactionMethod.intent` object required	The transaction intent for each payment method.
`transactionMethod.intent.card` string	The intent for card transactions. Possible values: `Authorisation` `Purchase` `Verification` `EstimatedAuthorisation` `Payout`
`transactionMethod.intent.paypal` string	The intent for PayPal transactions. Possible values: `Authorisation` `Purchase`
`transactionMethod.intent.googlepay` string	The intent for Google Pay transactions. Possible values: `Authorisation` `Purchase`
`amounts` object required	Details about the transaction amount.
`amounts.currencyCode` string (3 characters) required	The currency code associated with the transaction, in ISO 4217 format. See Supported payment currencies.
`amounts.transactionValue` number required	The transaction amount. The numbers after the decimal will be zero padded if they are less than the expected `currencyCode` exponent. For example, GBP 1.1 = GBP 1.10, EUR 1 = EUR 1.00, or BHD 1.3 = 1.300. The transaction will be rejected if numbers after the decimal are greater than the expected `currencyCode` exponent (e.g., GBP 1.234), or if a decimal is supplied when the `currencyCode` of the exponent does not require it (e.g., JPY 1.0).
`authorisation` boolean	Whether or not to proceed with authorisation.
`addressVerification` object	Details about the cardholder's address. These help in the validation and fraud prevention process by matching the provided address with the cardholder's address on file.
`addressVerification.countryCode` string (≤ 2 characters)	The country associated with the cardholder's address, in ISO 3166-1 alpha-2 format.
`addressVerification.houseNumberOrName` string (≤ 100 characters)	The house number or name associated with the cardholder's address.
`addressVerification.postalCode` string (≤ 10 characters)	The postal code of the cardholder's address.
`identityVerification` object	Details about the cardholder's identity. These help in ensuring that the information provided matches the cardholder's details on file.
`identityVerification.nameVerification` boolean	Whether the cardholder's name matches the name associated with the registered address on file.
`threeDSecureData` object	Details about the 3D Secure authentication data from an external authentication process.
`threeDSecureData.threeDSecureVersion` string (≤ 10 characters)	The 3DS protocol version.
`threeDSecureData.electronicCommerceIndicator` string (≤ 2 characters)	The ECI value indicating the authentication result.
`threeDSecureData.cardHolderAuthenticationVerificationValue` string (≤ 50 characters)	The CAVV value from 3DS authentication.
`threeDSecureData.directoryServerTransactionId` string (≤ 50 characters)	The Directory Server transaction identifier.
`threeDSecureData.threeDSecureTransactionStatus` string (≤ 1 character)	The 3DS transaction status.

If your request is successful, you'll receive a 200 response containing the session data.

{
  "sessionId": "c5f0799b-0839-43ce-abc5-5b462a98f250",
  "hmacKey": "904bc42395d4af634e2fd48ee8c2c7f52955a1da97a3aa3d82957ff12980a7bb",
  "encryptionKey": "20d175a669ad3f8c195c9c283fc86155",
  "data": "eyJzZXNzaW9uSWQiOiJjNWYwNzk5Yi0wODM5LTQzY2UtYWJjNS01YjQ2MmE5OGYyNTAifQ==",
  "sessionExpiry": "2025-05-19T13:39:20.3843454Z",
  "allowedFundingTypes": {
    "cards": [
      "Visa",
      "Diners",
      "Mastercard",
      "AmericanExpress"
    ],
    "cardSchemes": [
      "Visa",
      "Mastercard"
    ],
    "wallets": {
      "paypal": {
        "allowedFundingOptions": [
          "venmo", 
          "paylater", 
          "paypal"
        ],
        "merchantId": "paypal-merchant-123"
      },
      "googlePay": {
        "merchantId": "googlepay-merchant-id",
        "merchantName": "Your Store Name"
      },
      "paze": {
        "clientId": "your-paze-client-id",
        "profileId": "optional-profile-id",
        "merchantCategoryCode": "5812"
      },
      "applepay": {}
    }
  },
  "restrictions": {
    "card": {
      "ownerTypes": ["Consumer"],
      "fundingSources": ["Credit", "Debit"]
    }
  }
}

Response parameters

Parameter	Description
`sessionId` string (UUID)	The unique identifier for the newly-created session. Required for SDK initialisation.
`hmacKey` string	The HMAC key generated for securing session communications. Required for SDK initialisation.
`encryptionKey` string	A key used for encrypting sensitive session data during communication. Required for SDK initialisation.
`data` string	Base64-encoded session data payload. Required for SDK initialisation. Pass this directly to `SessionConfig`.
`sessionExpiry` string	The timestamp indicating when the session will expire, in ISO 8601 format. This is returned by the API for informational purposes but isn't used by the Android SDK's `SessionConfig`.
`allowedFundingTypes` object	Details about the funding types allowed for this session.
`allowedFundingTypes.cards` array of strings or null	The list of supported card brands (e.g., `["Visa", "Mastercard", "AmericanExpress"]`). Map this to `SessionConfig.allowedFundingTypes.cards`.
`allowedFundingTypes.cardSchemes` array of strings or null	An alternative list of supported card schemes. The SDK supports both `cards` and `cardSchemes` fields.
`allowedFundingTypes.wallets` object or null	Object containing wallet configurations. Map this to `SessionConfig.allowedFundingTypes.wallets`.
`allowedFundingTypes.wallets.paypal` object or null	PayPal wallet configuration. Maps to `WalletsConfig.paypal`.
`allowedFundingTypes.wallets.paypal.allowedFundingOptions` array of strings	An array of funding options (e.g., `["paypal", "paylater", "venmo"]`).
`allowedFundingTypes.wallets.paypal.merchantId` string	The PayPal merchant identifier.
`allowedFundingTypes.wallets.googlePay` object or null	Google Pay wallet configuration. Maps to `WalletsConfig.googlePay`. `gatewayMerchantId` may appear in API responses but isn't mapped by `GooglePayWalletConfig`.
`allowedFundingTypes.wallets.googlePay.merchantId` string	The Google Pay merchant identifier.
`allowedFundingTypes.wallets.googlePay.merchantName` string	The Google Pay merchant display name.
`allowedFundingTypes.wallets.paze` object or null	Paze wallet configuration. Maps to `WalletsConfig.paze`. Required for the Paze button component.
`allowedFundingTypes.wallets.paze.clientId` string	The Paze client ID from Paze Account Settings in the Unity Portal. Missing values cause presentment error `SDK1202`.
`allowedFundingTypes.wallets.paze.profileId` string	Optional Paze profile ID, when provided by Paze.
`allowedFundingTypes.wallets.paze.merchantCategoryCode` string	Merchant category code (MCC). Required when the SDK calls Paze complete; missing values cause `SDK1202A`.
`allowedFundingTypes.wallets.applepay` object or null	Apple Pay configuration (empty object for Android).
`restrictions` object or null	Optional card restrictions for frontend validation returned from the session. Map this to `SessionConfig.restrictions`.
`restrictions.card` object or null	Card-specific restrictions.
`restrictions.card.ownerTypes` array of strings	An array of allowed owner types (e.g., `["Corporate", "Consumer"]`).
`restrictions.card.fundingSources` array of strings	An array of allowed funding sources (e.g., `["Prepaid", "Credit", "Debit"]`).

Step 5: Initialise the SDK

To initialise the SDK, you need to pass the session data from Step 4 back to your Android application.

You'll also need to provide your client ID, details about the environment, your owner ID and type, the transaction data, and optionally provide shopper and shipping address data dynamically.

Configure ProGuard/R8

The SDK release AAR is minified at publish time and ships consumer ProGuard rules as proguard.txt inside the AAR. Gradle merges them automatically.

Enable minify in your app release build:

android {
    buildTypes {
        release {
            minifyEnabled true
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
}

Initialise the SDK in your application

Here's a complete example showing how to initialise the SDK and create your first component:

import com.pxp.PxpCheckout
import com.pxp.checkout.components.cardnumber.CardNumberComponent
import com.pxp.checkout.components.cardnumber.CardNumberComponentConfig
import com.pxp.checkout.models.*
import com.pxp.checkout.services.models.transaction.Shopper
import com.pxp.checkout.factory.ComponentType
import androidx.compose.foundation.layout.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.unit.dp
import java.time.Instant
import java.util.*

@Composable
fun PaymentScreen(session: SessionConfig) {
    val context = LocalContext.current
    var cardNumberComponent by remember { mutableStateOf<CardNumberComponent?>(null) }

    LaunchedEffect(session) {
        // Initialise the SDK
        val checkout = PxpCheckout.builder()
            .withConfig(
                PxpSdkConfig(
                    environment = Environment.TEST,
                    session = session,
                    clientId = "your-client-id-from-unity-portal",
                    ownerId = "your-merchant-group-id",
                    ownerType = "MerchantGroup",
                    transactionData = TransactionData(
                        amount = 25.00,
                        currency = "USD",
                        entryType = EntryType.Ecom,
                        intent = TransactionIntentData(
                            card = IntentType.Authorisation,
                            paypal = IntentType.Purchase
                        ),
                        merchant = "your-merchant-id",
                        merchantTransactionId = UUID.randomUUID().toString(),
                        merchantTransactionDate = { Instant.now().toString() }
                    ),
                    kountDisabled = false, // OPTIONAL: Set to true to disable Kount fraud detection
                    // OPTIONAL: Provide shopper data dynamically
                    onGetShopper = {
                        Shopper(
                            id = "shopper-123",
                            email = "customer@example.com",
                            firstName = "John",
                            lastName = "Doe",
                            phoneNumber = "+1-555-0123"
                        )
                    },
                    // OPTIONAL: Provide shipping address dynamically
                    onGetShippingAddress = {
                        ShippingAddress(
                            addressLine1 = "123 Main Street",
                            addressLine2 = "Apt 4B",
                            city = "New York",
                            state = "NY",
                            postalCode = "10001",
                            countryCode = "US"
                        )
                    }
                )
            )
            .withContext(context.applicationContext)
            .build()

        // Create components after SDK is initialised
        cardNumberComponent = checkout.createComponent(
            type = ComponentType.CARD_NUMBER,
            config = CardNumberComponentConfig(isRequired = true)
        )
    }

    Column(
        modifier = Modifier
            .fillMaxWidth()
            .padding(16.dp)
    ) {
        // Render the card number component with required Modifier parameter
        cardNumberComponent?.Content(Modifier.fillMaxWidth())
    }
}

// Fetch session from your backend
suspend fun fetchSessionFromBackend(): SessionConfig {
    // Make API call to your backend to get session data
    // Your backend should call the PXP Sessions API
    // See Step 4 for details on the Sessions API
    
    return SessionConfig(
        sessionId = "session-id-from-backend",
        hmacKey = "hmac-key-from-backend",
        data = "session-data-from-backend",
        encryptionKey = "encryption-key-from-backend",
        locale = "en-US",
        allowedFundingTypes = AllowedFundingTypes(
            cards = listOf("Visa", "Mastercard", "AmericanExpress"),
            cardSchemes = listOf("Visa", "Mastercard"),
            wallets = WalletsConfig(
                paypal = PayPalWalletConfig(
                    allowedFundingOptions = listOf("paypal", "paylater", "venmo"),
                    merchantId = "paypal-merchant-123"
                ),
                googlePay = GooglePayWalletConfig(
                    merchantId = "googlepay-merchant-id",
                    merchantName = "Your Store Name"
                )
            )
        ),
        restrictions = Restrictions(
            card = RestrictionsCard(
                ownerTypes = listOf(RestrictionOwnerType.CONSUMER),
                fundingSources = listOf(RestrictionFundingSource.CREDIT, RestrictionFundingSource.DEBIT)
            )
        )
    )
}

Configuration parameters

Parameter	Description
`environment` Environment required	The environment type enum. Possible values: `Environment.TEST` `Environment.LIVE`
`session` SessionConfig required	Details about the checkout session. This is a `SessionConfig` object containing `sessionId`, `hmacKey`, `data`, `encryptionKey`, `locale`, and optional `allowedFundingTypes` and `restrictions`. Get this from your backend by calling the Sessions API (see Step 4). `sessionExpiry` is returned by the API but is not a field on the Android `SessionConfig` model.
`clientId` String required	Your client ID from the Unity Portal. Required for 3DS authentication. Get this from Merchant setup > Merchant groups > Inbound calls in the Unity Portal.
`clientName` String?	Optional merchant display name forwarded to Paze as `name` (max 50 characters). Required for Paze presentment.
`siteName` String?	Optional site or brand name forwarded to Paze as `brandName` (max 50 characters). Required for Paze presentment.
`ownerId` string required	The identifier of the owner related to the `ownerType`. Get this from the Unity Portal.
`ownerType` string required	The type of owner. Always set this to `"MerchantGroup"`.
`transactionData` TransactionData required	Details about the transaction.
`transactionData.amount` Double required	The transaction amount as a Double (e.g., `25.00`).
`transactionData.currency` String (3 characters) required	The currency code associated with the transaction, in ISO 4217 format (e.g., "USD", "GBP", "EUR").
`transactionData.merchant` String required	Your unique merchant identifier, as assigned by PXP. Get this from the Unity Portal.
`transactionData.merchantTransactionId` String required	A unique identifier for this transaction. Use `UUID.randomUUID().toString()`.
`transactionData.merchantTransactionDate` () -> String required	A callback function that returns the transaction date as an ISO 8601 formatted string.
`transactionData.entryType` EntryType	The entry type for the transaction. Possible values: `EntryType.Ecom`: E-commerce transactions `EntryType.Moto`: Mail order/telephone order
`transactionData.intent` TransactionIntentData	The transaction intents for each payment method.
`transactionData.intent.card` IntentType	The intent for card transactions. Possible values: `IntentType.Authorisation` `IntentType.EstimatedAuthorisation` `IntentType.Purchase` `IntentType.Payout` `IntentType.Verification` Learn more about card intents.
`transactionData.intent.paypal` IntentType	The intent for PayPal transactions. Possible values: `IntentType.Authorisation` `IntentType.Purchase` Learn more about PayPal intents.
`kountDisabled` Boolean	Whether to disable the Kount fraud detection service. Defaults to `false` (fraud detection enabled).
`locale` String	Optional locale for UI localisation (e.g., `"en-US"`, `"es-ES"`). Defaults to device locale if not provided.
`localisation` Localisation	Optional custom localisation provider to override default component text. Implement the `Localisation` interface to provide custom strings.
`analyticsEvent` (BaseAnalyticsEvent) -> Unit	Optional callback function to receive analytics events from the SDK. Use this to forward events to your analytics platform.
`merchantId` String	Optional merchant identifier override. Typically not needed as the SDK uses `transactionData.merchant`.
`onGetShopper` () -> Shopper?	Optional callback function to provide shopper data dynamically. Returns a `Shopper` object with shopper information including ID, email, name, and contact details.
`onGetShippingAddress` () -> ShippingAddress?	Optional callback function to provide shipping address data dynamically. Returns a `ShippingAddress` object with current shipping address information.
`restrictions` Restrictions	Optional card restrictions for frontend validation. Restricts what card types are accepted in the new card component. If restrictions are specified in both the session (via Sessions API) and the SDK config, they're merged using a union approach: session restrictions come first, followed by SDK-only values. If a restriction axis is empty after merging, it becomes `null`.
`restrictions.card` RestrictionsCard?	Card-specific restrictions.
`restrictions.card.ownerTypes` List<RestrictionOwnerType>?	The allowed card owner types. Possible values: `RestrictionOwnerType.CORPORATE` `RestrictionOwnerType.CONSUMER`
`restrictions.card.fundingSources` List<RestrictionFundingSource>?	The allowed funding sources. Possible values: `RestrictionFundingSource.PREPAID` `RestrictionFundingSource.CREDIT` `RestrictionFundingSource.DEBIT`
`paypalConfig` PaypalConfig	Optional PayPal configuration for payout operations. Contains wallet configurations for PayPal and Venmo payouts. See the PayPal payouts documentation for details.

Integrate a payment component

After installation and SDK initialisation, follow the guide for the component you are integrating:

Component	Start here
Paze	Paze onboarding → Implementation
Card	Card implementation
Google Pay	Google Pay implementation
PayPal	PayPal implementation
PayPal Payouts	PayPal payouts

Paze checkout requires USD transaction data, EntryType.Ecom, a card intent on TransactionData, and an Activity Context when you build PxpCheckout. See Paze platform requirements.

Troubleshooting installation

Issue	Cause	Fix
Could not find `io.pxp:android-components-sdk:<version>`	Version not on Maven Central yet	Confirm the version string; wait for Central sync or contact PXP support
Transitive dependency resolution fails (artifact hosted on JitPack)	Missing JitPack repository	Add `maven { url = 'https://jitpack.io' }` to your `repositories` block
Unresolved SDK symbols at compile time	SDK version mismatch or stale cache	Confirm the Maven Central version matches this guide; run Gradle sync or a clean build
Duplicate classes / version conflicts	Compose or OkHttp version clash	Align with SDK POM versions or use Compose BOM `2026.02.01`
`minSdk` error	App `minSdk` < 24	Set `minSdk = 24` or higher
R8 / missing class at runtime	App release minify misconfiguration	Use the published release AAR; consumer rules are bundled as `proguard.txt`
App crashes after ProGuard obfuscation	ProGuard rules aren't properly configured	Use the published release AAR; consumer rules merge automatically from the SDK AAR
"Class not found" errors for SDK classes	The SDK dependency isn't properly synced or included	Verify the Maven Central dependency is in your app module; sync Gradle; clean and rebuild
Compose compiler version mismatch	Kotlin version doesn't match Compose compiler requirements	Use Kotlin 2.x with the Kotlin Compose Compiler Gradle plugin (see Step 1)
Google Pay not working	Missing Google Play Services or device configuration	Ensure Google Play Services 21.0.0+ is installed; use a device with a Google account and at least one payment method configured for testing

Next steps

You have installed and initialised the SDK. Continue with a component guide from Integrate a payment component above.

For Paze specifically:

Paze onboarding — configure Paze in the Unity Portal
Paze implementation — integrate the button, redirects, and callbacks
Paze configuration — component properties and styling

That's it for SDK installation. Choose a component guide above to complete your integration.