### Install Dependencies with Make

Source: https://developer.revolut.com/docs/guides/accept-payments/online-payments/card-payments/mobile/ios

Run the `make project` command to install all necessary dependencies and components for the example application.

```bash
make project  

```

--------------------------------

### Create Subscription Request (cURL)

Source: https://developer.revolut.com/docs/merchant/2024-09-01/create-subscription

Example of creating a subscription using cURL. Ensure to replace placeholders with your actual API key and relevant IDs. The `setup_order_redirect_url` is optional but recommended for a smooth setup process.

```bash
curl -L -X POST 'https://merchant.revolut.com/api/subscriptions' \
-H 'Content-Type: application/json' \
-H 'Accept: application/json' \
-H 'Authorization: Bearer <yourSecretApiKey>' \
--data-raw '{ \
  "plan_variation_id": "550e8400-e29b-41d4-a716-446655440000", \
  "customer_id": "650e8400-e29b-41d4-a716-446655440001", \
  "setup_order_redirect_url": "https://example.com/subscription/setup/complete", \
  "external_reference": "ext-ref-12345" \
}'
```

--------------------------------

### Subscription Created Response Body

Source: https://developer.revolut.com/docs/merchant/2024-09-01/create-subscription

Example response body when a subscription is successfully created with a setup order. The `state` is 'pending' and a `setup_order_id` is provided.

```json
{
  "id": "550e8400-e29b-41d4-a716-446655440000",
  "external_reference": "ext-ref-12345",
  "state": "pending",
  "customer_id": "650e8400-e29b-41d4-a716-446655440001",
  "plan_id": "750e8400-e29b-41d4-a716-446655440002",
  "plan_variation_id": "850e8400-e29b-41d4-a716-446655440003",
  "payment_method_type": "automatic",
  "created_at": "2025-06-05T21:00:00.036001Z",
  "updated_at": "2025-06-05T21:00:00.036001Z",
  "setup_order_id": "a50e8400-e29b-41d4-a716-446655440005",
  "current_cycle_id": "a31627fb-b037-4566-8d7b-f380c1f44653"
}
```

--------------------------------

### Direct Initialisation Example

Source: https://developer.revolut.com/docs/sdks/merchant-web-sdk/initialisation/direct

Demonstrates how to initialise the SDK using direct initialisation with a public token, environment mode, and locale.

```javascript
import RevolutCheckout from '@revolut/checkout'

const { destroy } = await RevolutCheckout.embeddedCheckout({
  publicToken: 'pk_',
  mode: 'prod',
  locale: 'auto'
})
```

--------------------------------

### Retrieve Subscription Cycle (Node.js)

Source: https://developer.revolut.com/docs/merchant/2024-09-01/retrieve-subscription-cycle

This Node.js example uses the `axios` library to fetch subscription cycle details. Ensure you have `axios` installed (`npm install axios`).

```javascript
const axios = require('axios');

const subscriptionId = '{subscription_id}';
const cycleId = '{cycle_id}';
const apiKey = '<yourSecretApiKey>';

axios.get(`https://merchant.revolut.com/api/subscriptions/${subscriptionId}/cycles/${cycleId}`, {
  headers: {
    'Accept': 'application/json',
    'Authorization': `Bearer ${apiKey}`
  }
})
  .then(response => {
    console.log(response.data);
  })
  .catch(error => {
    console.error('Error fetching subscription cycle:', error);
  });
```

--------------------------------

### Navigate to Example App Directory

Source: https://developer.revolut.com/docs/guides/accept-payments/online-payments/card-payments/mobile/ios

Change the current directory to the ExampleApp folder within the cloned repository. Replace `<SDK version>` with the specific version you are using.

```bash
cd Releases/<SDK version>/RevolutMerchantCardForm/ExampleApp  

```

--------------------------------

### Retrieve Payment Details - Node.js Example

Source: https://developer.revolut.com/docs/merchant/2025-10-16/retrieve-payment-details

This Node.js example shows how to fetch payment details using the Revolut API. It makes a GET request with the necessary Authorization header.

```javascript
const https = require('https');

const options = {
  hostname: 'api.revolut.com',
  port: 443,
  path: '/api/payments/{payment_id}',
  method: 'GET',
  headers: {
    'Authorization': 'Bearer <yourSecretApiKey>'
  }
};

const req = https.request(options, (res) => {
  console.log('statusCode:', res.statusCode);
  console.log('headers:', res.headers);

  res.on('data', (d) => {
    process.stdout.write(d);
  });
});

req.on('error', (e) => {
  console.error(e);
});
req.end();
```

--------------------------------

### Initialize Upsell Module and Mount Banner (`sign_up` variant with all parameters)

Source: https://developer.revolut.com/docs/guides/accept-payments/tutorials/promotional-banner

Initializes the upsell module and mounts the promotional banner with the `sign_up` variant, including customer details and custom styling.

```javascript
import RevolutCheckout from '@revolut/checkout'

const { promotionalBanner } = await RevolutCheckout.upsell({
  locale: 'en',
  mode: 'sandbox',
  publicToken: '<yourPublicApiKey>'
})

const bannerOptions = {
  variant: `sign_up`
  transactionId: '<uniqueTransactionId>',
  currency: 'GBP',
  amount: 500,
  customer: {
    name: 'Example Customer',
    email: 'example.customere@example.com',
    phone: '+441234567890'
  },
  style: {
    border: '1px solid black',
    borderRadius: '0',
    backgroundColor: 'white',
    primaryColor: '#007681'
  }
}

promotionalBanner.mount(document.getElementById('promotional-banner'), bannerOptions)
```

--------------------------------

### Unfreeze Card (Go)

Source: https://developer.revolut.com/docs/business/unfreeze-card

Unfreeze a card using Go. This example shows the necessary HTTP request setup, including the authorization header and endpoint.

```go
package main

import (
    "fmt"
    "net/http"
)

func main() {
    accessToken := "<your_access_token>"
    cardID := "{card_id}"

    url := fmt.Sprintf("https://sandbox-business.revolut.com/cards/%s/unfreeze", cardID)

    req, err := http.NewRequest("POST", url, nil)
    if err != nil {
        fmt.Printf("Error creating request: %v\n", err)
        return
    }

    req.Header.Set("Authorization", "Bearer "+accessToken)

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Printf("Error sending request: %v\n", err)
        return
    }
    defer resp.Body.Close()

    if resp.StatusCode == http.StatusNoContent {
        fmt.Println("Card successfully unfrozen.")
    } else {
        fmt.Printf("Error: %d - %s\n", resp.StatusCode, resp.Status)
    }
}
```

--------------------------------

### Initialize Upsell Module and Mount Banner (Minimal Parameters)

Source: https://developer.revolut.com/docs/guides/accept-payments/tutorials/promotional-banner

Initializes the upsell module with a public token and mounts the promotional banner. Defaults to the `sign_up` variant.

```javascript
import RevolutCheckout from '@revolut/checkout'

const { promotionalBanner } = await RevolutCheckout.upsell({
  publicToken: '<yourPublicApiKey>'
})

const bannerOptions = {
  transactionId: '<uniqueTransactionId>',
  currency: 'GBP'
}

promotionalBanner.mount(document.getElementById('promotional-banner'), bannerOptions)
```

--------------------------------

### Python Example for Creating a Payment Intent

Source: https://developer.revolut.com/docs/merchant/create-payment-intent

This Python code snippet demonstrates how to create a payment intent using the Revolut API. Ensure you have the `requests` library installed.

```python
import requests

url = "https://api.revolut.com/api/orders/{order_id}/payment-intents"
headers = {
    "Authorization": "Bearer <yourSecretApiKey>",
    "Content-Type": "application/json",
    "Revolut-Api-Version": "2023-01-01"
}
data = {
    "amount": 2500,
    "terminal_id": "0e53f673-7705-473a-a263-89a3e7647c3d"
}

response = requests.post(url, headers=headers, json=data)

print(response.json())
```

--------------------------------

### Go Example for Creating a Payment Intent

Source: https://developer.revolut.com/docs/merchant/create-payment-intent

This Go code shows how to create a payment intent. It includes setting up the HTTP request with necessary headers and the JSON body.

```go
package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
)

func main() {
	url := "https://api.revolut.com/api/orders/{order_id}/payment-intents"
	headers := map[string]string{
		"Authorization": "Bearer <yourSecretApiKey>",
		"Content-Type": "application/json",
		"Revolut-Api-Version": "2023-01-01"
	}
	data := map[string]interface{}{
		"amount": 2500,
		"terminal_id": "0e53f673-7705-473a-a263-89a3e7647c3d"
	}

	jsonData, err := json.Marshal(data)
	if err != nil {
		fmt.Println("Error marshalling JSON:", err)
		return
	}

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
	if err != nil {
		fmt.Println("Error creating request:", err)
		return
	}

	for key, value := range headers {
		req.Header.Set(key, value)
	}

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Println("Error sending request:", err)
		return
	}

	defer resp.Body.Close()

	var result map[string]interface{}
	err = json.NewDecoder(resp.Body).Decode(&result)
	if err != nil {
		fmt.Println("Error decoding response:", err)
		return
	}

	fmt.Println(result)
}
```

--------------------------------

### Delete Account Access Consent (Python)

Source: https://developer.revolut.com/docs/open-banking/delete-account-access-consents-consent-id

Example of deleting an account access consent using Python. Ensure you have the 'requests' library installed. Replace '{ConsentId}' and '<yourSecretApiKey>' with your specific values.

```python
import requests

consent_id = "{ConsentId}"
access_token = "<yourSecretApiKey>"

url = f"https://oba-auth.revolut.com/account-access-consents/{consent_id}"
headers = {
    "Authorization": f"Bearer {access_token}"
}

response = requests.delete(url, headers=headers)

if response.status_code == 204:
    print("Account access consent deleted successfully.")
else:
    print(f"Error deleting consent: {response.status_code} - {response.text}")
```

--------------------------------

### Initialize Pay by Bank Widget (Additional Parameters)

Source: https://developer.revolut.com/docs/guides/accept-payments/online-payments/pay-by-bank/web

This example demonstrates initializing the Pay by Bank widget with additional parameters, including `instantOnly` to restrict payments to instant methods. It also includes an `onCancel` handler for when the customer cancels the payment.

```javascript
const { payByBank } = await RevolutCheckout.payments({
  locale: 'en', // Optional, defaults to 'auto'
  publicToken: '<yourPublicApiKey>', // Merchant public API key 
})

const payByBankButton = document.getElementById('pay-by-bank')

payByBankButton.addEventListener('click', async () => {
  const payByBankInstance = payByBank({
    createOrder: async () => {
      // Call your backend here to create an order and return order.token
      // For more information, see: https://developer.revolut.com/docs/merchant/create-order
      const order = await yourServerSideCall()
      return { publicId: order.token }
    },
    instantOnly: true,
    onSuccess() {
      // Do something to handle successful payments
      window.alert('Successful payment!')
    },
    onError(error) {
      // Do something to handle payment errors
      window.alert(`Something went wrong. ${error}`)
    },
    onCancel() {
      // Do something to handle cancelled payments
      window.alert('The payment was cancelled.')
    }
  })

  payByBankInstance.show()
})
```

--------------------------------

### Retrieve Payment Details - C# Example

Source: https://developer.revolut.com/docs/merchant/2025-10-16/retrieve-payment-details

This C# code snippet shows how to make an HTTP GET request to retrieve payment details from the Revolut API. It includes setting the Authorization header.

```csharp
using System;
using System.Net.Http;
using System.Threading.Tasks;

public class PaymentRetriever
{
    public static async Task RetrievePaymentAsync(string paymentId, string apiKey)
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", apiKey);
            var response = await client.GetAsync($"https://api.revolut.com/api/payments/{paymentId}");
            var responseBody = await response.Content.ReadAsStringAsync();
            Console.WriteLine(responseBody);
        }
    }
}
```

--------------------------------

### Initialize Revolut Checkout SDK (Async/Await)

Source: https://developer.revolut.com/docs/guides/accept-payments/online-payments/revolut-checkout/web

Initialize the Revolut Checkout SDK using async/await with your public API key and environment mode. This sets up the widget foundation. The `destroy` function can be called later to remove the widget.

```javascript
import RevolutCheckout from '@revolut/checkout'

const { destroy } = await RevolutCheckout.embeddedCheckout({
  publicToken: '<yourPublicApiKey>',
  mode: 'prod', // 'prod' for production, 'sandbox' for testing
  locale: 'en' // Optional, defaults to 'auto'

  // Configuration will be added in the next steps
})

// Call destroy() later if you need to remove the widget from the page
```

--------------------------------

### RevolutCheckout Initialisation

Source: https://developer.revolut.com/docs/sdks/merchant-web-sdk/initialisation/token-based

Initialise the SDK with an order token and an optional environment mode. The `token` is obtained from the 'Create an order' response, and the `mode` can be 'prod' for production or 'sandbox' for testing.

```APIDOC
## RevolutCheckout

### Description
Initialises the Revolut Checkout SDK with a provided order token, enabling access to payment methods like card fields and pop-ups. It returns a `RevolutCheckoutInstance` which can be used to interact with the payment functionalities.

### Method Signature
```typescript
function RevolutCheckout(
  token: string,
  mode?: 'prod' | 'sandbox'
): Promise<RevolutCheckoutInstance>
```

### Parameters
#### Path Parameters
- **token** (string) - Required - Order `token` from the Create an order response.
- **mode** (string) - Optional - API environment. Can be `'prod'` or `'sandbox'`. Defaults to `'prod'`.

### Returns
Returns a `Promise<RevolutCheckoutInstance>` which contains methods to create card fields, initiate pop-up payments, set locales, and destroy the instance.

### Example
```javascript
import RevolutCheckout from '@revolut/checkout';

async function initializeCheckout() {
  try {
    const instance = await RevolutCheckout('your_order_token', 'sandbox');
    console.log('RevolutCheckout instance created:', instance);
    // You can now use instance.createCardField(), instance.payWithPopup(), etc.
  } catch (error) {
    console.error('Error initialising RevolutCheckout:', error);
  }
}

initializeCheckout();
```
```

--------------------------------

### Initialize SDK with Token

Source: https://developer.revolut.com/docs/sdks/merchant-web-sdk/initialisation/token-based

Example of how to import and initialize the Revolut Checkout SDK using a provided order token and specifying the production environment. This is the primary method for token-based initialization.

```javascript
import RevolutCheckout from '@revolut/checkout'

const instance = await RevolutCheckout('order_token_here', 'prod')
```

--------------------------------

### Retrieve a Payout Link (Node.js)

Source: https://developer.revolut.com/docs/business/get-payout-link

This Node.js example uses the `axios` library to make a GET request to retrieve payout link information. Remember to replace placeholders with your actual payout link ID and access token.

```javascript
const axios = require('axios');

const payoutLinkId = '{payout_link_id}';
const token = '<TOKEN>';

axios.get(`https://b2b.revolut.com/api/1.0/payout-links/${payoutLinkId}`, {
  headers: {
    'Authorization': `Bearer ${token}`,
    'Accept': 'application/json'
  }
})
.then(response => {
  console.log(response.data);
})
.catch(error => {
  console.error(error);
});
```

--------------------------------

### Retrieve Counterparty cURL Example

Source: https://developer.revolut.com/docs/business/get-counterparty

Use this cURL command to make a GET request to retrieve a specific counterparty's details. Ensure you replace `{counterparty_id}` with the actual counterparty ID and provide a valid access token.

```curl
curl -L -g -X GET 'https://b2b.revolut.com/api/1.0/counterparty/{counterparty_id}' \
-H 'Accept: application/json' \
-H 'Authorization: Bearer <TOKEN>'
```

--------------------------------

### Go Example for Creating Subscription Usage

Source: https://developer.revolut.com/docs/merchant/2024-09-01/create-subscription-usage

This Go program shows how to send a POST request to the Revolut API to report subscription usage. It constructs the request body and headers.

```go
package main

import (
	"bytes"
	"fmt"
	"net/http"
)

func main() {

	url := "https://api.revolut.com/1.0/subscription-usages"

	payload := []byte(`{
  "subscription_id": "550e8400-e29b-41d4-a716-446655440000",
  "subscription_item_code": "active_seats",
  "usage_date": "2026-03-15T09:30:00Z",
  "quantity": 12,
  "metadata": {
    "department": "engineering",
    "update_type": "onboarding"
  }
}`) 

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(payload))
	if err != nil {
		panic(err)
	}

	req.Header.Set("Authorization", "Bearer <yourSecretApiKey>")
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Revolut-Api-Version", "2024-09-01")

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		panic(err)
	}

	defer resp.Body.Close()

	fmt.Println("response Status:", resp.Status)
}
```

--------------------------------

### Initialize Revolut Pay Button and Handle Events

Source: https://developer.revolut.com/docs/sdks/merchant-web-sdk/payment-methods/revolut-pay

A minimal example demonstrating how to mount the Revolut Pay button and set up event listeners for payment outcomes. Requires a public API key and server-side order creation.

```html
<!-- Add a container for the button in your HTML -->
<div id="revolut-pay-container"></div>
```

```javascript
import RevolutCheckout from '@revolut/checkout'

async function initializeRevolutPay() {
  const { revolutPay } = await RevolutCheckout.payments({
    publicToken: '<YOUR_PUBLIC_API_KEY>',
    locale: 'en',
  })

  const paymentOptions = {
    currency: 'GBP',
    totalAmount: 2000, // £20.00
    createOrder: async () => {
      // Replace with your server-side call to create an order in the Merchant API
      const response = await fetch('/api/create-revolut-order');
      const order = await response.json()
      return { publicId: order.token }
    },
  }

  revolutPay.mount('#revolut-pay-container', paymentOptions)

  revolutPay.on('payment', (event) => {
    switch (event.type) {
      case 'success':
        console.log('Payment successful! Order ID:', event.orderId);
        // e.g., redirect to a success page
        break
      case 'error':
        console.error('Payment failed:', event.error);
        // e.g., show an error message to the user
        break
      case 'cancel':
        console.log('Payment cancelled by user at state:', event.dropOffState);
        // e.g., re-enable the checkout button
        break
    }
  })
}

initializeRevolutPay()
```

--------------------------------

### Retrieve Payment Details - Python Example

Source: https://developer.revolut.com/docs/merchant/2025-10-16/retrieve-payment-details

This Python code snippet demonstrates how to retrieve payment details using the Revolut API. Ensure you have the `requests` library installed and replace placeholders with your actual payment ID and API key.

```python
import requests

url = "https://api.revolut.com/api/payments/{payment_id}"
headers = {
    "Authorization": "Bearer <yourSecretApiKey>"
}

response = requests.get(url, headers=headers)

if response.status_code == 200:
    print(response.json())
else:
    print(f"Error: {response.status_code}")
```

--------------------------------

### Initialize Revolut Pay SDK (Async/Await)

Source: https://developer.revolut.com/docs/guides/accept-payments/online-payments/revolut-pay/web

Import RevolutCheckout and initialize the Revolut Pay SDK using your public API key. The 'locale' parameter is optional and defaults to 'auto'. This setup is required before configuring the payment button.

```javascript
import RevolutCheckout from '@revolut/checkout'

const { revolutPay } = await RevolutCheckout.payments({
  locale: 'en', // Optional, defaults to 'auto'
  publicToken: '<yourPublicApiKey>', // Merchant public API key
})

// Configuration code will go here
```

--------------------------------

### Install CocoaPods Dependencies

Source: https://developer.revolut.com/docs/guides/accept-payments/online-payments/apple-pay-google-pay/mobile/ios

After updating your Podfile, run this command to install the SDK and its dependencies.

```bash
pod install
```

--------------------------------

### Usage Examples

Source: https://developer.revolut.com/docs/sdks/merchant-web-sdk/promotional-widgets/card-gateway-banner

Examples demonstrating how to use the Card Gateway Banner in different scenarios.

```APIDOC
## Usage Examples

### Card field with promotional banner

#### HTML structure
```html
<div id="card-field-container"></div>
```

#### JavaScript structure
```javascript
const cardFieldElement = document.getElementById('card-field-container');
const bannerOptions = {
  text: 'Special Offer!',
  backgroundColor: '#e0f7fa',
  textColor: '#00796b'
};

const cardFieldBanner = new CardGatewayBanner(cardFieldElement, bannerOptions);
```

### Card pop-up with promotional banner

*(Specific code for card pop-up integration would be detailed here if available in the source)*
```

--------------------------------

### Configure and Initialize Promotional Banner

Source: https://developer.revolut.com/docs/guides/accept-payments/online-payments/revolut-pay/mobile/ios

Configure the promotional banner by calling the `revolutPayKit.promotionalBanner` method with transaction details. This prepares the banner for display.

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

--------------------------------

### Fiat Object Example

Source: https://developer.revolut.com/docs/crypto-ramp/retrieve-all-orders

Example of the fiat object structure, showing amount and currency.

```json
{
  "amount": 100,
  "currency": "USD"
}
```

--------------------------------

### Initialize Upsell Module and Mount Banner (`icon` variant)

Source: https://developer.revolut.com/docs/guides/accept-payments/tutorials/promotional-banner

Initializes the upsell module and mounts the promotional banner with the `icon` variant, including custom styling.

```javascript
import RevolutCheckout from '@revolut/checkout'

const { promotionalBanner } = await RevolutCheckout.upsell({
  locale: 'en',
  mode: 'sandbox',
  publicToken: '<yourPublicApiKey>'
})

const bannerOptions = {
  variant: `icon`
  currency: 'GBP',
  amount: 500,
  style: {
    size: 'small',
    color: 'blue',
    outline: true
  }
}

promotionalBanner.mount(document.getElementById('promotional-banner'), bannerOptions)
```

--------------------------------

### JWT Header Example

Source: https://developer.revolut.com/docs/guides/manage-accounts/get-started/make-your-first-api-request

This is an example of the JWT header structure. It specifies the algorithm and token type.

```json
{
  "alg": "RS256",
  "typ": "JWT"
}

```

--------------------------------

### Initialize Pay by Bank Widget (Minimal Parameters)

Source: https://developer.revolut.com/docs/guides/accept-payments/online-payments/pay-by-bank/web

This example shows how to initialize the Pay by Bank widget with the essential parameters. It includes a click event listener that calls your backend to create an order and displays alerts for payment success or errors.

```javascript
const { payByBank } = await RevolutCheckout.payments({
  locale: 'en', // Optional, defaults to 'auto'
  publicToken: '<yourPublicApiKey>', // Merchant public API key 
})

const payByBankButton = document.getElementById('pay-by-bank')

payByBankButton.addEventListener('click', async () => {
  const payByBankInstance = payByBank({
    createOrder: async () => {
      // Call your backend here to create an order and return order.token
      // For more information, see: https://developer.revolut.com/docs/merchant/create-order
      const order = await yourServerSideCall()
      return { publicId: order.token }
    },
    onSuccess() {
      // Do something to handle successful payments
      window.alert('Successful payment!')
    },
    onError(error) {
      // Do something to handle payment errors
      window.alert(`Something went wrong. ${error}`)
    }
  })

  payByBankInstance.show()
})
```

--------------------------------

### Crypto Object Example

Source: https://developer.revolut.com/docs/crypto-ramp/retrieve-all-orders

Example of the crypto object structure, showing amount and currency ID.

```json
{
  "amount": 100,
  "currencyId": "USDT-ETH"
}
```

--------------------------------

### Initialize CocoaPods

Source: https://developer.revolut.com/docs/guides/accept-payments/online-payments/apple-pay-google-pay/mobile/ios

Run this command in your project directory to initialize CocoaPods if a Podfile does not exist.

```bash
pod init
```

--------------------------------

### Install Pod Dependencies

Source: https://developer.revolut.com/docs/guides/accept-payments/online-payments/card-payments/mobile/ios

Install all the dependencies listed in your Podfile, including the Revolut SDK, into your Xcode project.

```bash
pod install
```

--------------------------------

### Upsell Module Initialisation

Source: https://developer.revolut.com/docs/sdks/merchant-web-sdk/initialisation/upsell-module

Initialise the SDK with your public API key to access promotional and upsell widgets. This method creates a `RevolutUpsellModuleInstance` with promotional widgets.

```APIDOC
## RevolutCheckout.upsell

### Description
Initialises the Upsell module to display promotional and upsell widgets.

### Method
```javascript
RevolutCheckout.upsell(options: {
  publicToken: string
  mode?: 'prod' | 'sandbox'
  locale?: Locale | 'auto'
}): Promise<RevolutUpsellModuleInstance>
```

### Parameters
#### Options
- **`publicToken`** (string) - Required - Your Merchant API public key.
- **`mode`** ('prod' | 'sandbox') - Optional - API environment. Defaults to `'prod'`.
- **`locale`** (Locale | 'auto') - Optional - Widget language. Defaults to `'auto'`.

### Returns
Returns a `Promise<RevolutUpsellModuleInstance>` which contains methods to manage different upsell banners and their configurations.

#### RevolutUpsellModuleInstance Methods
- **`promotionalBanner`**: Instance for displaying promotional banners.
- **`cardGatewayBanner`**: Instance for displaying card gateway banners.
- **`enrollmentConfirmationBanner`**: Instance for displaying enrollment confirmation banners.
- **`setDefaultLocale`**: Function to dynamically change the widget language.
- **`destroy`**: Function to manually destroy the instance.

### Example
```javascript
import RevolutCheckout from '@revolut/checkout'

const upsellInstance = await RevolutCheckout.upsell({
  publicToken: 'pk_...',
  mode: 'prod',
  locale: 'auto'
})
```
```

--------------------------------

### JWT Payload Example

Source: https://developer.revolut.com/docs/guides/manage-accounts/get-started/make-your-first-api-request

This is an example of the JWT payload structure. Ensure the 'exp' value is a number, not a string.

```json
{
  "iss": "example.com",
  "sub": "zfTKV9Eie_XLHl03f2Y7vJYDe5Klr6Y54v8fsp4Gvgp",
  "aud": "https://revolut.com",
  "exp": 1706136791
}

```

--------------------------------

### Complete Magento 2 Installation Steps

Source: https://developer.revolut.com/docs/guides/accept-payments/plugins/magento/installation

Run these commands after enabling the module to finalize the installation, including upgrades, dependency injection compilation, and static content deployment.

```bash
$ php bin/magento setup:upgrade
$ php bin/magento setup:di:compile
$ php bin/magento setup:static-content:deploy
```

--------------------------------

### SSA Header Example

Source: https://developer.revolut.com/docs/guides/build-banking-apps/register-your-application-using-dcr/get-the-software-statement

This is an example of the SSA header. It must use 'none' as the algorithm for self-signed statements.

```json
{
  "alg": "none"
}
```