Accept payments via Revolut Pay - Android

Add the Revolut Pay button to your app, confirm payment results in your UI, and fulfil orders on authoritative webhooks.

Revolut Pay allows your customers to pay with their card or their Revolut Retail or Revolut Business account, delivering a streamlined checkout experience through your Android application.

In this tutorial, we'll guide you through integrating Revolut Pay, powered by the Revolut Pay SDK for Android. The SDK handles the entire payment flow, including presenting native payment sheets, handling customer authentication, and redirecting to the Revolut app when needed, reducing friction and improving conversion rates.

How it works​

From an implementation perspective, integrating Revolut Pay into your Android app with the Revolut Pay SDK involves the following components:

1. Server-side: An endpoint on your server to securely create an order with the Revolut Merchant API.
2. Client-side: Your Android app uses the Revolut Pay SDK to display the Revolut Pay button, collect payment details, and handle the user flow.
3. Endpoint for webhooks: Optionally, you can set up an endpoint to receive webhook events from the Merchant API to track the payment lifecycle. For more information, see: Use webhooks to keep track of the payment lifecycle.

By default, the SDK prioritises the Retail sign-in flow. If Revolut Pay for Business is enabled for your merchant account, you can prioritise the Business flow with the preferredMode parameter.

Available versions​

The Revolut Pay Android SDK is available in two variants:

The payment flow for each variant:

Implementation overview​

The high-level implementation steps are the following:

1. Set up an endpoint for creating orders
2. Configure your Android project
3. Initialise the SDK
4. Implement the payment flow
5. Handle payment result

Before you begin​

Before you start this tutorial, make sure you have the following:

• An active Merchant account with Revolut Business. If you don't have one yet, apply for a Merchant account.
• Your API keys - both your public key (for initialising the SDK) and secret key (for creating orders on your backend). See Generate API keys.
• A backend server to securely create orders using the Merchant API. Your secret API key must never be exposed in your app.
• An Android app with a checkout screen where you'll display the Revolut Pay button.
• (Revolut Pay Native only) Your app's SHA-256 certificate fingerprint shared with Revolut - required before Revolut Pay Native can verify your app's identity.

Implement Revolut Pay on Android​

1. Set up an endpoint for creating orders​

Before implementing the client-side SDK, you must first create a dedicated endpoint on your server. This is a critical security step, as your secret API key must never be exposed in your Android application.

The role of this server-side endpoint is to act as a secure bridge between your app and the Merchant API. When the customer taps the Revolut Pay button in your app, your app calls this endpoint. Your endpoint is then responsible for:

1. Receiving the checkout details (e.g., amount, currency) from the app request.
2. Securely calling the Merchant API: Create an order endpoint with the received details.
3. Receiving the order details, including the public token, back from the Merchant API.
4. Passing this token back to your app in the response.

Later, the button's click listener calls this endpoint to fetch the token the SDK needs to initialise and process the payment (see Step 4.2).

POST /api/orders HTTP/1.1
Host: merchant.revolut.com
Authorization: Bearer sk_abcdef12347890_...
Content-Type: application/json
Revolut-Api-Version: 2026-08-17

{
  "amount": 1000,
  "currency": "GBP"
}

POST /api/orders HTTP/1.1
Host: merchant.revolut.com
Authorization: Bearer sk_abcdef12347890_...
Content-Type: application/json
Revolut-Api-Version: 2026-08-17

{
  "amount": 1000,
  "currency": "GBP"
}

2. Configure your Android project​

This section covers the one-time setup tasks required to prepare your Android project for the SDK.

2.1 Install the SDK​

allprojects {
    repositories {
        mavenCentral()
    }
}

allprojects {
    repositories {
        mavenCentral()
    }
}

implementation 'com.revolut.payments:revolutpay:3.4.0'

implementation 'com.revolut.payments:revolutpay:3.4.0'

2.2 Set up your SHA-256 certificate fingerprint​

To enable the native Revolut Pay SDK to verify your app's identity and deliver a secure, seamless payment experience, you must share your app's SHA-256 certificate fingerprint with Revolut.

2.3 Configure the App Manifest​

You need to declare necessary permissions and set up a deep link for redirection in your AndroidManifest.xml.

<uses-permission android:name="android.permission.INTERNET" />

<uses-permission android:name="android.permission.INTERNET" />

<activity
    android:name=".MainActivity"
    android:launchMode="singleTop">
    <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="payment-return"
            android:scheme="myapp" />
    </intent-filter>
</activity>

<activity
    android:name=".MainActivity"
    android:launchMode="singleTop">
    <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="payment-return"
            android:scheme="myapp" />
    </intent-filter>
</activity>

3. Initialise the SDK​

In your application's entry point (e.g., the onCreate method of your Application class), initialise the Revolut Pay SDK with your public API key.

import com.revolut.payments.RevolutPaymentsSDK

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        RevolutPaymentsSDK.configure(
            RevolutPaymentsSDK.Configuration(
                merchantPublicKey = "<yourPublicApiKey>",
                environment = RevolutPaymentsSDK.Environment.SANDBOX // Or .PRODUCTION
            )
        )
    }
}

import com.revolut.payments.RevolutPaymentsSDK

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        RevolutPaymentsSDK.configure(
            RevolutPaymentsSDK.Configuration(
                merchantPublicKey = "<yourPublicApiKey>",
                environment = RevolutPaymentsSDK.Environment.SANDBOX // Or .PRODUCTION
            )
        )
    }
}

The Configuration object accepts the following parameters:

The deep link URI will be provided later when creating payment orders.

4. Implement the payment flow​

Now, you will add the Revolut Pay button to your UI and connect it to your backend to handle payments.

4.1 Add the Revolut Pay button​

You can add the Revolut Pay button to your checkout screen either programmatically or via XML layout.

import com.revolut.payments.RevolutPaymentsSDK
import com.revolut.revolutpay.api.revolutPay
import com.revolut.revolutpay.api.button.ButtonParams
import com.revolut.revolutpay.api.button.Radius
import com.revolut.revolutpay.api.button.Size
import com.revolut.revolutpay.api.button.Variant
import com.revolut.revolutpay.api.button.VariantModes
import com.revolut.revolutpay.api.button.BoxText

// ...

val buttonParams = ButtonParams(
    buttonSize = Size.LARGE,
    radius = Radius.MEDIUM,
    variants = VariantModes(lightMode = Variant.DARK, darkMode = Variant.LIGHT),
    boxText = BoxText.NONE
)

val revolutPayButton = RevolutPaymentsSDK.revolutPay.provideButton(
    context = this,
    params = buttonParams
)

// Add the button to your view hierarchy
your_layout.addView(revolutPayButton)

import com.revolut.payments.RevolutPaymentsSDK
import com.revolut.revolutpay.api.revolutPay
import com.revolut.revolutpay.api.button.ButtonParams
import com.revolut.revolutpay.api.button.Radius
import com.revolut.revolutpay.api.button.Size
import com.revolut.revolutpay.api.button.Variant
import com.revolut.revolutpay.api.button.VariantModes
import com.revolut.revolutpay.api.button.BoxText

// ...

val buttonParams = ButtonParams(
    buttonSize = Size.LARGE,
    radius = Radius.MEDIUM,
    variants = VariantModes(lightMode = Variant.DARK, darkMode = Variant.LIGHT),
    boxText = BoxText.NONE
)

val revolutPayButton = RevolutPaymentsSDK.revolutPay.provideButton(
    context = this,
    params = buttonParams
)

// Add the button to your view hierarchy
your_layout.addView(revolutPayButton)

The ButtonParams object accepts the following parameters:

4.2 Set up payment controller and button interaction​

Now, let's wire everything up. You'll create a payment controller to manage the payment process and then configure your Revolut Pay button to use this controller when tapped.

Create the payment controller​

First, create an instance of the paymentController. This component is responsible for launching the payment flow and returning the final result (success, failure, or user cancellation) to your app.

import com.revolut.payments.RevolutPaymentsSDK
import com.revolut.revolutpay.api.PaymentResult
import com.revolut.revolutpay.api.order.OrderParams
import com.revolut.revolutpay.api.revolutPay
import androidx.core.net.toUri

// Create payment controller in your Activity or Fragment
private val paymentController = RevolutPaymentsSDK.revolutPay.createController(this) { paymentResult ->
    when (paymentResult) {
        is PaymentResult.Success -> {
            // Payment successful - update your UI
            showSuccessMessage()
        }
        is PaymentResult.UserAbandonedPayment -> {
            // User cancelled the payment
            showCancelledMessage()
        }
        is PaymentResult.Failure -> {
            // Payment failed - show error and log details
            showErrorMessage()
            Log.e("RevolutPay", "Payment failed", paymentResult.exception)
        }
    }
}

import com.revolut.payments.RevolutPaymentsSDK
import com.revolut.revolutpay.api.PaymentResult
import com.revolut.revolutpay.api.order.OrderParams
import com.revolut.revolutpay.api.revolutPay
import androidx.core.net.toUri

// Create payment controller in your Activity or Fragment
private val paymentController = RevolutPaymentsSDK.revolutPay.createController(this) { paymentResult ->
    when (paymentResult) {
        is PaymentResult.Success -> {
            // Payment successful - update your UI
            showSuccessMessage()
        }
        is PaymentResult.UserAbandonedPayment -> {
            // User cancelled the payment
            showCancelledMessage()
        }
        is PaymentResult.Failure -> {
            // Payment failed - show error and log details
            showErrorMessage()
            Log.e("RevolutPay", "Payment failed", paymentResult.exception)
        }
    }
}

Configure the Revolut Pay button​

With the controller ready, you can configure the button's behaviour, also within onCreate() or onViewCreated(). This involves two main actions:

1. Binding the payment state: This links the button's appearance (e.g., showing a loading spinner) to the controller's current state automatically.
2. Setting a click listener: This defines the action to take when the user taps the button—fetching the order token from your backend and starting the payment.

// In your Activity/Fragment's onCreate() or onViewCreated()

// 1. Bind the button's loading state to payment controller's state
revolutPayButton.bindPaymentState(paymentController, this)

// 2. Set the button's click listener to start the payment
revolutPayButton.setOnClickListener {
    // Show a loading indicator on the button
    revolutPayButton.showBlockingLoading(true)

    viewLifecycleOwner.lifecycleScope.launch {
        try {
            // Call your backend to get the order token
            val orderToken = fetchOrderTokenFromBackend()

            // Start the payment with the token (and other order details)
            paymentController.pay(
                OrderParams(
                    orderToken = orderToken,
                    returnUri = "myapp://payment-return".toUri(), // Must match your deep link from step 2.3
                    requestShipping = false, // Set to true for Fast checkout - see Additional features
                    savePaymentMethodForMerchant = false, // Set to true for MIT - see Additional features
                    customer = null // Optional customer details to pre-fill the checkout
                )
            )
        } catch (e: Exception) {
            // Handle any errors during the token fetch
            revolutPayButton.showBlockingLoading(false)
            showErrorMessage()
        }
    }
}

// In your Activity/Fragment's onCreate() or onViewCreated()

// 1. Bind the button's loading state to payment controller's state
revolutPayButton.bindPaymentState(paymentController, this)

// 2. Set the button's click listener to start the payment
revolutPayButton.setOnClickListener {
    // Show a loading indicator on the button
    revolutPayButton.showBlockingLoading(true)

    viewLifecycleOwner.lifecycleScope.launch {
        try {
            // Call your backend to get the order token
            val orderToken = fetchOrderTokenFromBackend()

            // Start the payment with the token (and other order details)
            paymentController.pay(
                OrderParams(
                    orderToken = orderToken,
                    returnUri = "myapp://payment-return".toUri(), // Must match your deep link from step 2.3
                    requestShipping = false, // Set to true for Fast checkout - see Additional features
                    savePaymentMethodForMerchant = false, // Set to true for MIT - see Additional features
                    customer = null // Optional customer details to pre-fill the checkout
                )
            )
        } catch (e: Exception) {
            // Handle any errors during the token fetch
            revolutPayButton.showBlockingLoading(false)
            showErrorMessage()
        }
    }
}

The OrderParams object accepts the following parameters:

Implement fetchOrderTokenFromBackend()​

In the code above, fetchOrderTokenFromBackend() is a placeholder for a function you must create. This function's job is to make a network request to the server endpoint you built in Step 1. It sends the order details (like amount and currency) to your server and gets the unique order token in return.

Because this is a network operation it must be performed off the main UI thread. The example uses lifecycleScope.launch (a Kotlin Coroutine) to handle this, which is the recommended approach.

4.3 Handle deep link redirect​

After the customer authorises the payment in the Revolut retail app, they are redirected back to your app using the deep link you configured in Step 2.3.

You need to catch this redirect in the Activity you configured with the <intent-filter>. To do this, override the onNewIntent() method and pass the incoming URI to the Revolut Pay SDK for processing.

import com.revolut.payments.RevolutPaymentsSDK
import com.revolut.revolutpay.api.revolutPay

override fun onNewIntent(intent: Intent?) {
    super.onNewIntent(intent)
    intent?.data?.let { uri ->
        // Pass the deep link URI to the Revolut Pay SDK for processing
        RevolutPaymentsSDK.revolutPay.handle(uri)
    }
}

import com.revolut.payments.RevolutPaymentsSDK
import com.revolut.revolutpay.api.revolutPay

override fun onNewIntent(intent: Intent?) {
    super.onNewIntent(intent)
    intent?.data?.let { uri ->
        // Pass the deep link URI to the Revolut Pay SDK for processing
        RevolutPaymentsSDK.revolutPay.handle(uri)
    }
}

The SDK processes this URI internally. You don't need to parse it yourself. The final PaymentResult is automatically delivered to the paymentController callback you configured in Step 4.2.

Additional features​

The Revolut Pay SDK also offers a range of optional features you can enable when starting the payment, as well as a promotional banner for your order confirmation screen.

// In your order confirmation Activity (e.g., OrderConfirmationActivity.kt)

import com.revolut.revolutpay.api.promobanner.Currency
import com.revolut.revolutpay.api.promobanner.Customer
import com.revolut.revolutpay.api.promobanner.DateOfBirth
import com.revolut.revolutpay.api.promobanner.PromoBannerParams
import com.revolut.revolutpay.api.promobanner.CountryCode
import com.revolut.payments.RevolutPaymentsSDK
import com.revolut.revolutpay.api.revolutPay

class OrderConfirmationActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_order_confirmation)

        // 1. Get the order token you passed to this activity after a successful payment.
        // This is the `token` from the order object you received from your server in Step 1.
        val orderIdFromServer = intent.getStringExtra("ORDER_ID") ?: ""

        // 2. Define the parameters for the banner.
        val bannerParams = PromoBannerParams(
            transactionId = orderIdFromServer,
            paymentAmount = 1000, // Amount in the smallest currency unit (e.g., cents)
            currency = Currency.EUR,
            customer = Customer(
                name = "Example Customer",
                email = "example.customer@email.com",
                phone = "+441234567890",
                dateOfBirth = DateOfBirth(_day = 1, _month = 2, _year = 2000),
                country = CountryCode.GB,
            )
        )

        // 3. Create the banner widget.
        val promotionalBanner = RevolutPaymentsSDK.revolutPay.providePromotionalBannerWidget(
            context = this,
            params = bannerParams
        )

        // 4. Add the banner to your layout.
        // Assuming you have a LinearLayout with id 'banner_container' in your XML file.
        val bannerContainer = findViewById<LinearLayout>(R.id.banner_container)
        bannerContainer.addView(promotionalBanner)
    }
}

// In your order confirmation Activity (e.g., OrderConfirmationActivity.kt)

import com.revolut.revolutpay.api.promobanner.Currency
import com.revolut.revolutpay.api.promobanner.Customer
import com.revolut.revolutpay.api.promobanner.DateOfBirth
import com.revolut.revolutpay.api.promobanner.PromoBannerParams
import com.revolut.revolutpay.api.promobanner.CountryCode
import com.revolut.payments.RevolutPaymentsSDK
import com.revolut.revolutpay.api.revolutPay

class OrderConfirmationActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_order_confirmation)

        // 1. Get the order token you passed to this activity after a successful payment.
        // This is the `token` from the order object you received from your server in Step 1.
        val orderIdFromServer = intent.getStringExtra("ORDER_ID") ?: ""

        // 2. Define the parameters for the banner.
        val bannerParams = PromoBannerParams(
            transactionId = orderIdFromServer,
            paymentAmount = 1000, // Amount in the smallest currency unit (e.g., cents)
            currency = Currency.EUR,
            customer = Customer(
                name = "Example Customer",
                email = "example.customer@email.com",
                phone = "+441234567890",
                dateOfBirth = DateOfBirth(_day = 1, _month = 2, _year = 2000),
                country = CountryCode.GB,
            )
        )

        // 3. Create the banner widget.
        val promotionalBanner = RevolutPaymentsSDK.revolutPay.providePromotionalBannerWidget(
            context = this,
            params = bannerParams
        )

        // 4. Add the banner to your layout.
        // Assuming you have a LinearLayout with id 'banner_container' in your XML file.
        val bannerContainer = findViewById<LinearLayout>(R.id.banner_container)
        bannerContainer.addView(promotionalBanner)
    }
}

<style name="RevolutPay_RevolutPayBanner">
    <item name="revolutPay_ColorAccent">#0666EB</item>
    <item name="revolutPay_ColorBackground">#F7F7F7</item>
    <item name="revolutPay_BannerCornerRadius">12dp</item>
    <item name="revolutPay_ComponentCornerRadius">12dp</item>
    <item name="revolutPay_StrokeWidth">0dp</item>
    <item name="revolutPay_StrokeColor">#BBC4CD</item>
</style>

<style name="RevolutPay_RevolutPayBanner">
    <item name="revolutPay_ColorAccent">#0666EB</item>
    <item name="revolutPay_ColorBackground">#F7F7F7</item>
    <item name="revolutPay_BannerCornerRadius">12dp</item>
    <item name="revolutPay_ComponentCornerRadius">12dp</item>
    <item name="revolutPay_StrokeWidth">0dp</item>
    <item name="revolutPay_StrokeColor">#BBC4CD</item>
</style>

val promotionalBanner = RevolutPaymentsSDK.revolutPay.providePromotionalBannerWidget(
    context = this,
    params = bannerParams,
    themeId = R.style.RevolutPay_RevolutPayBanner
)

val promotionalBanner = RevolutPaymentsSDK.revolutPay.providePromotionalBannerWidget(
    context = this,
    params = bannerParams,
    themeId = R.style.RevolutPay_RevolutPayBanner
)

paymentController.pay(
    OrderParams(
        orderToken = orderToken,
        returnUri = "myapp://payment-return".toUri(),
        savePaymentMethodForMerchant = true,
        requestShipping = false,
        customer = null
    )
)

paymentController.pay(
    OrderParams(
        orderToken = orderToken,
        returnUri = "myapp://payment-return".toUri(),
        savePaymentMethodForMerchant = true,
        requestShipping = false,
        customer = null
    )
)

paymentController.pay(
    OrderParams(
        orderToken = orderToken,
        returnUri = "myapp://payment-return".toUri(),
        requestShipping = true,
        savePaymentMethodForMerchant = false,
        customer = null
    )
)

paymentController.pay(
    OrderParams(
        orderToken = orderToken,
        returnUri = "myapp://payment-return".toUri(),
        requestShipping = true,
        savePaymentMethodForMerchant = false,
        customer = null
    )
)

// Don't forget the additional import:
// import com.revolut.revolutpay.api.order.PreferredMode

paymentController.pay(
    OrderParams(
        orderToken = orderToken,
        returnUri = "myapp://payment-return".toUri(),
        requestShipping = false,
        savePaymentMethodForMerchant = false,
        customer = null,
        preferredMode = PreferredMode.BUSINESS // RETAIL (default), RETAIL_ONLY, BUSINESS, or BUSINESS_ONLY
    )
)

// Don't forget the additional import:
// import com.revolut.revolutpay.api.order.PreferredMode

paymentController.pay(
    OrderParams(
        orderToken = orderToken,
        returnUri = "myapp://payment-return".toUri(),
        requestShipping = false,
        savePaymentMethodForMerchant = false,
        customer = null,
        preferredMode = PreferredMode.BUSINESS // RETAIL (default), RETAIL_ONLY, BUSINESS, or BUSINESS_ONLY
    )
)

// Don't forget the additional import:
// import com.revolut.revolutpay.api.order.Customer

paymentController.pay(
    OrderParams(
        orderToken = orderToken,
        returnUri = "myapp://payment-return".toUri(),
        requestShipping = false,
        savePaymentMethodForMerchant = false,
        customer = Customer(
            name = "John Smith",
            email = "john.smith@example.com",
            phone = null,
            dateOfBirth = null,
            country = null
        )
    )
)

// Don't forget the additional import:
// import com.revolut.revolutpay.api.order.Customer

paymentController.pay(
    OrderParams(
        orderToken = orderToken,
        returnUri = "myapp://payment-return".toUri(),
        requestShipping = false,
        savePaymentMethodForMerchant = false,
        customer = Customer(
            name = "John Smith",
            email = "john.smith@example.com",
            phone = null,
            dateOfBirth = null,
            country = null
        )
    )
)

5. Handle payment result​

After the customer completes or cancels the payment, the SDK delivers a PaymentResult to the callback you configured in step 4.2. This confirms the result at the UX-level only.

The authoritative payment status for your business logic - fulfilment, shipping, inventory - always arrives on your backend via webhooks, which you set up at the end of this step.

Confirm payment result in UI​

The callback you registered when creating the payment controller provides a PaymentResult that tells you whether the payment succeeded, failed, or was abandoned by the customer. Handle each case to show an appropriate message to the user:

when (paymentResult) {
    is PaymentResult.Success -> {
        // Present the payment confirmation UI
    }
    is PaymentResult.UserAbandonedPayment -> {
        // Return the customer to your checkout screen
    }
    is PaymentResult.Failure -> {
        // Show an error message and let the customer retry
    }
}

when (paymentResult) {
    is PaymentResult.Success -> {
        // Present the payment confirmation UI
    }
    is PaymentResult.UserAbandonedPayment -> {
        // Return the customer to your checkout screen
    }
    is PaymentResult.Failure -> {
        // Show an error message and let the customer retry
    }
}

Set up webhooks​

Your backend must rely on webhooks as the authoritative source of payment status. The client-side callback confirms the result at the UX level only - webhooks are guaranteed, server-to-server notifications that drive your critical backend logic.

POST /api/webhooks HTTP/1.1
Host: merchant.revolut.com
Authorization: Bearer sk_abcdef12347890_...
Content-Type: application/json
Revolut-Api-Version: 2026-08-17

{
  "url": "https://example.com/webhooks",
  "events": [
    "ORDER_COMPLETED",
    "ORDER_AUTHORISED",
    "ORDER_PAYMENT_DECLINED",
    "ORDER_PAYMENT_FAILED",
    "ORDER_CANCELLED",
    "ORDER_FAILED"
  ]
}

POST /api/webhooks HTTP/1.1
Host: merchant.revolut.com
Authorization: Bearer sk_abcdef12347890_...
Content-Type: application/json
Revolut-Api-Version: 2026-08-17

{
  "url": "https://example.com/webhooks",
  "events": [
    "ORDER_COMPLETED",
    "ORDER_AUTHORISED",
    "ORDER_PAYMENT_DECLINED",
    "ORDER_PAYMENT_FAILED",
    "ORDER_CANCELLED",
    "ORDER_FAILED"
  ]
}

Payment outcomes​

Handle the following scenarios in your webhook handler:

Example​

For a complete, working implementation, refer to the example app included in our public SDK repository:

To run the example app:

1. Clone the repository.
2. Open the project in Android Studio, or your preferred IDE.
3. Run the example app.

Implementation checklist​

Before going live, use this checklist to test your integration in both the SANDBOX and MAIN (production) environments.

Project setup​

• mavenCentral() is in build.gradle.
• SDK dependency is added (Revolut Pay Native or Revolut Pay Lite, depending on your chosen variant).
• (Revolut Pay Native only) SHA-256 certificate fingerprint has been obtained and shared with Revolut.
• AndroidManifest.xml: INTERNET permission is present.
• AndroidManifest.xml: Deep link <intent-filter> is configured with a unique scheme and host.
• The deep link activity has launchMode="singleTop".
• SDK is initialised with the correct public API key and environment in your Application class.

Payment flow​

• The Revolut Pay button appears correctly on the checkout screen.
• Payment controller is created and configured with result handling.
• Tapping the button successfully calls your server to create an order and receives a token.
• (Revolut Pay Native) Test case 1: The payment flow completes when the Revolut app is installed (fully native in-app path, no redirection).
• (Revolut Pay Native) Test case 2: The payment flow completes via in-app WebView (guest checkout) when the Revolut app is not installed. This path behaves similarly to Revolut Pay Lite.
• (Revolut Pay Lite) Test case 1: The payment flow correctly redirects to the Revolut retail app and back when it is installed.
• (Revolut Pay Lite) Test case 2: The payment flow completes via in-app WebView when the Revolut app is not installed.
• A successful payment shows a success message in the UI via the PaymentResult.Success callback.
• A failed payment shows an appropriate error message in the UI via the PaymentResult.Failure callback.
• The user cancelling the payment flow is handled gracefully via the PaymentResult.UserAbandonedPayment callback.
• Deep link handling is correctly implemented in your main activity's onNewIntent method.

Backend verification​

• Webhook endpoint is created and subscribed to events.
• Order fulfilment is triggered only by a ORDER_COMPLETED webhook.

What's next​