Accept payments via Revolut Pay - iOS

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 iOS application.

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

How it works​

From an implementation perspective, the Revolut Pay iOS SDK works with the following components:

1. Server-side: A server-side endpoint is required to securely communicate with the Merchant API to create orders.
2. Client-side: The SDK is configured in your app with your public API key. When the customer taps the Revolut Pay button, the SDK uses the token obtained from your server to initiate and process the payment. The SDK handles the entire payment flow, including presenting native sheets, handling biometric authentication, and redirecting to the Revolut app if necessary.
3. Endpoint for webhooks: Your server should listen for webhook events to reliably track the payment lifecycle and handle critical backend processes like updating order status, managing inventory, or initiating shipping. For more information, see: Use webhooks to keep track of the payment lifecycle.

Available versions​

The Revolut Pay iOS 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 Xcode project
3. Initialise the SDK
4. Add the Revolut Pay button
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 iOS app with a checkout screen where you'll display the Revolut Pay button.

Implement Revolut Pay on iOS​

This section walks you through the server- and client-side implementation step by step.

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 iOS application.

The role of this server-side endpoint is to act as a secure bridge between your app and the Merchant API. When a customer taps the Revolut Pay button in your app, your app will call 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 createOrder callback calls this endpoint to fetch the token the SDK needs to initialise and process the payment.

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 Xcode project​

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

2.1 Install the SDK​

CocoaPods​

We recommend using CocoaPods to integrate the SDK into your Xcode project.

2.2 Configure project capabilities​

To allow your app to open the Revolut Retail and Revolut Business apps, you must declare the revolut and revolut-business URL schemes in your Info.plist file.

<key>LSApplicationQueriesSchemes</key>
<array>
    <string>revolut</string>
    <string>revolut-business</string>
</array>

<key>LSApplicationQueriesSchemes</key>
<array>
    <string>revolut</string>
    <string>revolut-business</string>
</array>

2.3 Enable biometrics and passkeys support​

To offer users a seamless and secure login experience with Face ID, Touch ID, and passkeys, you must associate your app with our web service.

2.4 Add the URL handler​

When the user is redirected from the Revolut app back to yours, you must pass the incoming URL to the SDK.

Your implementation depends on your app's lifecycle management. Use the UISceneDelegate method for modern, scene-based apps (the default since iOS 13), which support features like multiple windows on iPad. Use the AppDelegate method for older apps or if you have explicitly opted out of the scene-based lifecycle.

func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
    if let url = URLContexts.first?.url {
        RevolutPayKit.handle(url: url)
    }
}

func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
    if let url = URLContexts.first?.url {
        RevolutPayKit.handle(url: url)
    }
}

3. Initialise the SDK​

First, import the RevolutPayments module. Then, on app launch, typically in your AppDelegate, configure the SDK with your public API key and the environment.

import RevolutPayments

// In your AppDelegate's didFinishLaunchingWithOptions method
RevolutPaymentsSDK.configure(with: .init(
    merchantPublicKey: "<yourPublicApiKey>",
    environment: .production // or .sandbox for testing
))

import RevolutPayments

// In your AppDelegate's didFinishLaunchingWithOptions method
RevolutPaymentsSDK.configure(with: .init(
    merchantPublicKey: "<yourPublicApiKey>",
    environment: .production // or .sandbox for testing
))

The RevolutPaymentsSDK.configure method accepts the following parameters:

4. Add the Revolut Pay button​

On your checkout screen, create and display the Revolut Pay button.

4.1 Create the button​

Instantiate RevolutPayKit and call the button method. This is where you connect your server-side endpoint and define what happens after the payment attempt.

let revolutPayKit = RevolutPayKit()

let button = revolutPayKit.button(
    style: .init(size: .large),
    returnURL: "myapp://revolut-pay", // Your app's custom URL scheme
    createOrder: { createOrderHandler in
        // 1. Call your server to create the order
        createOrderOnBackEnd { orderToken in
            // 2. Pass the token to the SDK
            createOrderHandler.set(orderToken: orderToken)
        }
    },
    completion: { result in
        switch result {
            case .success:
                // Handle successful payment
            case .failure(let error):
                // Handle payment error
            case .userAbandonedPayment:
                // Handle abandoned payment
        }
    }
)

let revolutPayKit = RevolutPayKit()

let button = revolutPayKit.button(
    style: .init(size: .large),
    returnURL: "myapp://revolut-pay", // Your app's custom URL scheme
    createOrder: { createOrderHandler in
        // 1. Call your server to create the order
        createOrderOnBackEnd { orderToken in
            // 2. Pass the token to the SDK
            createOrderHandler.set(orderToken: orderToken)
        }
    },
    completion: { result in
        switch result {
            case .success:
                // Handle successful payment
            case .failure(let error):
                // Handle payment error
            case .userAbandonedPayment:
                // Handle abandoned payment
        }
    }
)

The button method accepts the following core parameters:

4.2 Display the button​

Add the created button to your view hierarchy.

view.addSubview(button)
button.translatesAutoresizingMaskIntoConstraints = false
NSLayoutConstraint.activate([
    button.bottomAnchor.constraint(equalTo: view.bottomAnchor),
    button.leadingAnchor.constraint(greaterThanOrEqualTo: view.leadingAnchor),
    button.trailingAnchor.constraint(lessThanOrEqualTo: view.trailingAnchor),
    button.centerXAnchor.constraint(equalTo: view.centerXAnchor)
])

view.addSubview(button)
button.translatesAutoresizingMaskIntoConstraints = false
NSLayoutConstraint.activate([
    button.bottomAnchor.constraint(equalTo: view.bottomAnchor),
    button.leadingAnchor.constraint(greaterThanOrEqualTo: view.leadingAnchor),
    button.trailingAnchor.constraint(lessThanOrEqualTo: view.trailingAnchor),
    button.centerXAnchor.constraint(equalTo: view.centerXAnchor)
])

Additional features​

The Revolut Pay SDK also offers a range of optional features you can enable when creating the button.

let promotionalBanner = revolutPayKit.promotionalBanner(
    transactionId: "transaction-id", // Unique ID of the payment corresponding to the promotional offer
    amount: 10_00,
    currency: .EUR,
    customer: .init()
)

let promotionalBanner = revolutPayKit.promotionalBanner(
    transactionId: "transaction-id", // Unique ID of the payment corresponding to the promotional offer
    amount: 10_00,
    currency: .EUR,
    customer: .init()
)

view.addSubview(promotionalBanner)

promotionalBanner.translatesAutoresizingMaskIntoConstraints = false

NSLayoutConstraint.activate([
    promotionalBanner.topAnchor.constraint(
        equalTo: view.safeAreaLayoutGuide.topAnchor,
        constant: 16
    ),
    promotionalBanner.trailingAnchor.constraint(
        equalTo: view.safeAreaLayoutGuide.trailingAnchor,
        constant: -16
    ),
    promotionalBanner.leadingAnchor.constraint(
        equalTo: view.safeAreaLayoutGuide.leadingAnchor,
        constant: 16
    )
])

view.addSubview(promotionalBanner)

promotionalBanner.translatesAutoresizingMaskIntoConstraints = false

NSLayoutConstraint.activate([
    promotionalBanner.topAnchor.constraint(
        equalTo: view.safeAreaLayoutGuide.topAnchor,
        constant: 16
    ),
    promotionalBanner.trailingAnchor.constraint(
        equalTo: view.safeAreaLayoutGuide.trailingAnchor,
        constant: -16
    ),
    promotionalBanner.leadingAnchor.constraint(
        equalTo: view.safeAreaLayoutGuide.leadingAnchor,
        constant: 16
    )
])

let button = revolutPayKit.button(
    style: .init(size: .large),
    returnURL: "myapp://revolut-pay",
    savePaymentMethodForMerchant: true,
    createOrder: { createOrderHandler in
        createOrderOnBackEnd { orderToken in
            createOrderHandler.set(orderToken: orderToken)
        }
    },
    completion: { result in
        // Handle the payment result
    }
)

let button = revolutPayKit.button(
    style: .init(size: .large),
    returnURL: "myapp://revolut-pay",
    savePaymentMethodForMerchant: true,
    createOrder: { createOrderHandler in
        createOrderOnBackEnd { orderToken in
            createOrderHandler.set(orderToken: orderToken)
        }
    },
    completion: { result in
        // Handle the payment result
    }
)

let button = revolutPayKit.button(
    style: .init(size: .large),
    returnURL: "myapp://revolut-pay",
    shouldRequestShipping: true,
    createOrder: { createOrderHandler in
        createOrderOnBackEnd { orderToken in
            createOrderHandler.set(orderToken: orderToken)
        }
    },
    completion: { result in
        // Handle the payment result
    }
)

let button = revolutPayKit.button(
    style: .init(size: .large),
    returnURL: "myapp://revolut-pay",
    shouldRequestShipping: true,
    createOrder: { createOrderHandler in
        createOrderOnBackEnd { orderToken in
            createOrderHandler.set(orderToken: orderToken)
        }
    },
    completion: { result in
        // Handle the payment result
    }
)

let button = revolutPayKit.button(
    style: .init(size: .large),
    returnURL: "myapp://revolut-pay",
    preferredMode: .business, // .retail (default), .retailOnly, .business, or .businessOnly
    createOrder: { createOrderHandler in
        createOrderOnBackEnd { orderToken in
            createOrderHandler.set(orderToken: orderToken)
        }
    },
    completion: { result in
        // Handle the payment result
    }
)

let button = revolutPayKit.button(
    style: .init(size: .large),
    returnURL: "myapp://revolut-pay",
    preferredMode: .business, // .retail (default), .retailOnly, .business, or .businessOnly
    createOrder: { createOrderHandler in
        createOrderOnBackEnd { orderToken in
            createOrderHandler.set(orderToken: orderToken)
        }
    },
    completion: { result in
        // Handle the payment result
    }
)

let button = revolutPayKit.button(
    style: .init(size: .large, variants: .init(lightMode: .dark, darkMode: .light), radius: .small),
    returnURL: "myapp://revolut-pay",
    customer: .init(name: "John Smith", email: "john.smith@example.com"),
    createOrder: { createOrderHandler in
        createOrderOnBackEnd { orderToken in
            createOrderHandler.set(orderToken: orderToken)
        }
    },
    completion: { result in
        // Handle the payment result
    }
)

let button = revolutPayKit.button(
    style: .init(size: .large, variants: .init(lightMode: .dark, darkMode: .light), radius: .small),
    returnURL: "myapp://revolut-pay",
    customer: .init(name: "John Smith", email: "john.smith@example.com"),
    createOrder: { createOrderHandler in
        createOrderOnBackEnd { orderToken in
            createOrderHandler.set(orderToken: orderToken)
        }
    },
    completion: { result in
        // Handle the payment result
    }
)

5. Handle payment result​

Revolut Pay reports the payment result to your app through the completion block of the button method. 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 completion block passed to the button method 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:

completion: { result in
    switch result {
    case .success:
        // Present the payment confirmation UI
    case .failure(let error):
        // Show an error message and let the customer retry
    case .userAbandonedPayment:
        // Return the customer to your checkout screen
    }
}

completion: { result in
    switch result {
    case .success:
        // Present the payment confirmation UI
    case .failure(let error):
        // Show an error message and let the customer retry
    case .userAbandonedPayment:
        // Return the customer to your checkout screen
    }
}

Set up webhooks​

Your backend must rely on webhooks as the authoritative source of payment status. The completion handler 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. Navigate to the ExampleApp directory within the latest release.
3. Run make project to install dependencies.
4. Open RevolutPayApp.xcworkspace in Xcode and run the project.

Implementation checklist​

Before going live, use this checklist to test your integration in both the .sandbox and .production environments.

Project setup​

• SDK is installed via CocoaPods.

• Info.plist contains the revolut and revolut-business URL schemes.

• Associated Domain webcredentials:revolut.com is configured for passkeys.

  Double-check your Associated Domain, if you used an SDK version before 3.9.

• The SDK is initialised with the correct public API key and environment.

• The Privacy Manifest is correctly merged into the app's resources.

Payment flow​

• The Revolut Pay button appears correctly on the checkout screen.
• Tapping the button successfully calls your server to create an order and receives a token.
• Test case 1 (Revolut app installed): The payment flow completes via the native in-app experience (Revolut Pay Native) or via redirect to the Revolut app and back (Revolut Pay Lite).
• Test case 2 (Revolut app not installed): The payment flow completes successfully within the in-app flow (Revolut Pay Native) or in-app WebView (Revolut Pay Lite fallback).
• Test case 3 (Biometrics): Passkey/Face ID/Touch ID login works as expected (requires a real device).
• A successful payment shows a success message in the UI.
• A failed payment shows an appropriate error message in the UI.
• The user cancelling the payment flow is handled gracefully.

Backend verification​

• Your server correctly receives and processes webhook events for different payment states (e.g., ORDER_COMPLETED, ORDER_AUTHORISED for success; ORDER_PAYMENT_FAILED, ORDER_CANCELLED for failure or cancellation).
• Order fulfilment logic is only triggered after receiving a successful webhook, not from the client-side callback.

Prepare for App Store submission​

To comply with Apple's App Store requirements, you must include our privacy manifest in your app. This file, named PrivacyInfo.xcprivacy, details the data collection practices of the Revolut Pay SDK.

These steps are required to prepare your iOS application for Apple's review policies and ensure that your Revolut Pay integration adheres to their privacy standards.

What's next​