> ## Documentation Index
> Fetch the complete documentation index at: https://terminal-docs.xendit.co/llms.txt
> Use this file to discover all available pages before exploring further.
# Android SDK (Kotlin)
> Integrate Xendit's Payment Terminal H2H into your Android applications with our comprehensive Kotlin SDK
# Terminal H2H SDK for Android (Kotlin)
The Xendit's Payment Terminal H2H Android SDK enables you to integrate secure payment processing into your Android applications. Connect to physical payment terminals and process transactions seamlessly using our Kotlin-based SDK.
This SDK works alongside the Terminal API to provide complete in-person payment functionality. You'll use the Terminal API to create payment sessions and this SDK to interact with physical payment devices.
## Version information
What's new:
* **Activity Lifecycle Management**: Introduced `TerminalActivityLifecycleObserver` interface for reusable activity lifecycle tracking, intent queuing, and dispatch logic
* **Enhanced Provider App Launching**: Refactored Atom and SHC provider app launchers with improved background app launch handling
* **Launch Failure Notifications**: Added notification mechanism to prompt users when provider app launch fails while app is in background
* **Callback Interface**: New `TerminalAppLauncherCallback` interface for custom handling of provider app launch failures
* **Improved Maintainability**: Centralized lifecycle and launcher logic for better extensibility across different application contexts
What's new:
* **Core Stability**: Fixed activity tracking bug in TerminalApplication where paused activities were not properly removed from internal tracking list
What's new:
* Fixed casting issue on C2C request payload to improve compatibility and prevent runtime errors.
What's new:
* Added Cashup provider support for Indonesian terminals
What's new:
* Renamed class name `TerminalGateway` to `TerminalH2H` for better consistency
**Breaking Change**: Class name changed from `TerminalGateway` to `TerminalH2H`. Update your imports and references accordingly.
What's new:
* Fixed NTT payment method value maping to ensure correct provider selection
* Updated BRI payment flow to validate transaction data before executing terminal actions
* Added timeout configuration for card and QR transactions to auto-cancel and retry stalled requests
* Added support to handle retry requests via `/v1/terminal/sessions/{id}/retry` endpoint
What's new:
* Added support for multiple concurrent device connections, enabling simultaneous transactions across different terminals
* \[BRI] Fixed status value handling in void and cancel API responses for improved transaction status accuracy
What's new:
* Introduced command ID handling for settlement operations
* Enhanced retry logic with configurable attempt counts
* Improved error handling and logging throughout the gateway service
Bug fixes and improvements:
* Fix data mapping for terminal responses
* \[BRI] Enhanced status verification after transaction timeout for improved reliability
XenTerminal is the companion SDK to In-Person Payment Sessions API. This version provides core functionality for connecting to payment terminals and processing transactions.
The SDK follows semantic versioning. Breaking changes will bump the major version number.
## Installation
Follow these steps to add the Terminal H2H Android SDK to your project.
Add `mavenCentral()` to your Gradle configuration so Gradle can resolve the SDK artifacts.
Add Maven Central to your Gradle settings file:
```kotlin settings.gradle(.kts) theme={null}
dependencyResolutionManagement {
repositories {
// ... other repositories
mavenCentral()
}
}
```
```groovy settings.gradle theme={null}
dependencyResolutionManagement {
repositories {
// ... other repositories
mavenCentral()
}
}
```
Add Maven Central to your root build.gradle file:
```kotlin build.gradle.kts (root) theme={null}
allprojects {
repositories {
// ... other repositories
mavenCentral()
}
}
```
```groovy build.gradle (root) theme={null}
allprojects {
repositories {
// ... other repositories
mavenCentral()
}
}
```
Verify `mavenCentral()` is available in the repository list used by your app module.
Add the required dependencies to your `build.gradle.kts` or `build.gradle` file:
```kotlin build.gradle.kts theme={null}
dependencies {
// Terminal H2H SDK
implementation("co.xendit.terminal:h2h-android:")
// Core Terminal SDK (required)
implementation("co.xendit.terminal:core-android:")
// Optional: Provider-specific dependencies for helper methods
// Indonesia - BRI terminals
implementation("co.xendit.terminal:id-bri-android:")
// Thailand - NTT terminals
implementation("co.xendit.terminal:th-ntt-android:")
}
```
```groovy build.gradle theme={null}
dependencies {
// Terminal H2H SDK
implementation 'co.xendit.terminal:h2h-android:'
// Core Terminal SDK (required)
implementation 'co.xendit.terminal:core-android:'
// Optional: Provider-specific dependencies for helper methods
// Indonesia - BRI terminals
implementation 'co.xendit.terminal:id-bri-android:'
// Thailand - NTT terminals
implementation 'co.xendit.terminal:th-ntt-android:'
}
```
Provider-specific dependencies are optional and enable convenient helper methods for creating `TerminalDevice` instances. Include only the dependencies for providers you plan to use.
Sync your project to download the dependencies.
## Getting Started
Before you begin, ensure you have the following:
* **Client key**: Request an In-Person Payment `CLIENT_KEY` from the Xendit team
* **Terminal device information**: Obtain the Terminal ID and IP address for each device
* **Android project**: Set up with minimum SDK version 21 (Android 5.0)
Keep your client key secure and never commit it to version control. Use environment variables or secure storage for production applications.
### Step 1: Initialize the SDK
Initialize the Terminal H2H SDK in your Application class:
```kotlin MyApp.kt theme={null}
class MyApp : Application() {
override fun onCreate() {
super.onCreate()
TerminalApp.initialize(
context = this,
clientKey = TEST_CLIENT_KEY,
mode = TerminalMode.INTEGRATION
)
}
}
```
Use `TerminalMode.INTEGRATION` for development and testing. Switch to `TerminalMode.LIVE` for production with a live client key.
### Step 2: Add Terminal Providers
Add the specific terminal providers you need for your integration:
For Share Commerce (SHC), Cashup, and Atom terminals, you do not need to add a Terminal H2H provider. Those devices run terminal logic through the Gateway app installed on the hardware. If the app is missing, install it from the Gateway download page or contact [inpersonpayments@xendit.co](mailto:inpersonpayments@xendit.co) for assistance.
```kotlin theme={null}
// Add BRI provider for Indonesian terminals
TerminalH2H.addProvider(TerminalBRI)
```
**Required dependency:**
```kotlin theme={null}
implementation("co.xendit.terminal:id-bri-android:")
```
BRI provider supports timeout configuration for card and QR transactions, and provides enhanced transaction retry capabilities.
```kotlin theme={null}
// Add NTT provider for Thai terminals
TerminalH2H.addProvider(TerminalNTT)
```
**Required dependency:**
```kotlin theme={null}
implementation("co.xendit.terminal:th-ntt-android:")
```
NTT provider supports multi-function terminals with card payments and QR code transactions.
```kotlin theme={null}
// Add Cashup provider for Indonesian terminals
TerminalH2H.addProvider(TerminalCashup)
```
**Required dependency:**
```kotlin theme={null}
implementation("co.xendit.terminal:id-cashup-android:")
```
Cashup terminals run terminal logic through the Gateway app on the device. Ensure the Gateway app is installed and your terminal is registered before processing payments.
Only add the Cashup provider if you plan to install your app directly in the terminal device.
```kotlin theme={null}
// Add multiple providers for supporting different terminal types
TerminalH2H.addProvider(TerminalBRI)
TerminalH2H.addProvider(TerminalNTT)
```
**Required dependencies:**
```kotlin theme={null}
implementation("co.xendit.terminal:id-bri-android:")
implementation("co.xendit.terminal:th-ntt-android:")
```
Only add providers for terminal types you actually plan to use. Each provider adds to your app's size and initialization time.
After adding providers, they will be available for use when registering terminal devices in the next step.
### Step 3: Register Terminal Devices
Create `TerminalDevice` entries for each terminal and register them with the gateway:
```kotlin theme={null}
val devices = listOf(
TerminalDevice(id = "BRI12345", ipAddress = "192.168.1.10", active = true),
TerminalDevice(id = "BRI67890", ipAddress = "192.168.1.11", active = true)
)
TerminalH2H.registerDevices(
devices = devices,
restart = true // restart to apply the refreshed device list immediately
)
```
For steps to locate each terminal's Terminal ID and IP address, review the [Finding Terminal Information guide](#finding-terminal-information).
Set active = true for terminals that should be available immediately. You can keep an entry with active = false to stage devices without establishing a connection.
After successful registration, your terminal devices will be available for payment processing.
### Step 4: Calling Terminal API
With Terminal H2H SDK configured, you can now process payments using the Terminal API. The SDK handles communication with physical terminals through the local gateway service.
```bash theme={null}
# Example: Create a payment session
curl -X POST 'https://terminal-dev.xendit.co/v1/terminal/sessions' \
-u 'API_KEY:' \
-H 'Content-Type: application/json' \
-H 'Idempotency-key: unique-session-123' \
-d '{
"terminal_id": "TERMINAL_ID",
"amount": 10000,
"currency": "IDR",
"external_id": "payment-123",
"payment_method": "card"
}'
```
For complete API documentation including request/response formats, error handling, and advanced features, see the [Terminal API (H2H)](/api-reference/terminal-api/introduction) documentation.
The Terminal H2H SDK automatically manages the connection to your registered terminal devices and handles communication protocols for different providers.
You're now ready to process payments using the Terminal H2H SDK integrated with Terminal API.
## Configuring App for Terminal Device
When running your application on a Terminal device, additional configuration is required to enable the terminal to communicate with the Cashup payment system. Follow these steps:
Add the Cashup result activity to your `AndroidManifest.xml` file:
```xml AndroidManifest.xml theme={null}
```
The `android:exported="true"` attribute is required to allow the Cashup system to return results to your application.
Choose one of the following approaches to configure your Application class:
Make your `Application` class extend `TerminalApplication` and configure the Cashup provider launcher:
```kotlin Application.kt theme={null}
import android.app.Application
import co.xendit.terminal.core.application.TerminalApplication
import co.xendit.terminal.cashup.TerminalCashup
import co.xendit.terminal.cashup.launcher.CashupAppLauncher
class MyApplication : TerminalApplication() {
override fun onCreate() {
super.onCreate()
// Configure Cashup provider app launcher
TerminalCashup.providerAppLauncher = CashupAppLauncher(this)
}
}
```
Don't forget to register your custom `Application` class in the `AndroidManifest.xml`:
```xml AndroidManifest.xml theme={null}
```
Create a custom `Application` class and register the `TerminalAppLauncherCallback`:
```kotlin Application.kt theme={null}
import android.app.Application
import co.xendit.terminal.core.application.TerminalAppLauncherCallback
import co.xendit.terminal.cashup.TerminalCashup
import co.xendit.terminal.cashup.launcher.CashupAppLauncher
class MyApplication : Application() {
override fun onCreate() {
super.onCreate()
// Register the callback
TerminalAppLauncherCallback.register(this)
// Configure Cashup provider app launcher
TerminalCashup.providerAppLauncher = CashupAppLauncher(this)
}
}
```
Don't forget to register your custom `Application` class in the `AndroidManifest.xml`:
```xml AndroidManifest.xml theme={null}
```
Your app is now configured to run on Cashup Terminal devices and can communicate with the Cashup payment system.
Control whether the terminal prints a receipt after a transaction:
```kotlin theme={null}
import co.xendit.terminal.cashup.utils.setCashupPrintReceiptEnabled
// Enable receipt printing
TerminalH2H.setCashupPrintReceiptEnabled(true)
// Disable receipt printing
TerminalH2H.setCashupPrintReceiptEnabled(false)
```
This setting allows you to control the default receipt printing behavior for Cashup terminals.
When running your application on a Terminal device, additional configuration is required to enable the terminal to communicate with the SHC payment system. Follow these steps:
Add the SHC result activity to your `AndroidManifest.xml` file:
```xml AndroidManifest.xml theme={null}
```
The `android:exported="true"` attribute is required to allow the SHC system to return results to your application.
Choose one of the following approaches to configure your Application class:
Make your `Application` class extend `TerminalApplication` and configure the SHC provider launcher:
```kotlin Application.kt theme={null}
import android.app.Application
import co.xendit.terminal.core.application.TerminalApplication
import co.xendit.terminal.shc.TerminalSHC
import co.xendit.terminal.shc.launcher.SHCAppLauncher
class MyApplication : TerminalApplication() {
override fun onCreate() {
super.onCreate()
// Configure SHC provider app launcher
TerminalSHC.providerAppLauncher = SHCAppLauncher(this)
}
}
```
Don't forget to register your custom `Application` class in the `AndroidManifest.xml`:
```xml AndroidManifest.xml theme={null}
```
Create a custom `Application` class and register the `TerminalAppLauncherCallback`:
```kotlin Application.kt theme={null}
import android.app.Application
import co.xendit.terminal.core.application.TerminalAppLauncherCallback
import co.xendit.terminal.shc.TerminalSHC
import co.xendit.terminal.shc.launcher.SHCAppLauncher
class MyApplication : Application() {
override fun onCreate() {
super.onCreate()
// Register the callback
TerminalAppLauncherCallback.register(this)
// Configure SHC provider app launcher
TerminalSHC.providerAppLauncher = SHCAppLauncher(this)
}
}
```
Don't forget to register your custom `Application` class in the `AndroidManifest.xml`:
```xml AndroidManifest.xml theme={null}
```
Your app is now configured to run on SHC Terminal devices and can communicate with the SHC payment system.
## Configuration and Management
### Set Operation Timeout
Configure the timeout for terminal operations:
```kotlin theme={null}
// Set timeout to 5 minutes (default)
TerminalH2H.setOperationTimeout(minutes = 5)
// Set custom timeout for longer operations
TerminalH2H.setOperationTimeout(minutes = 10)
// Set provider-specific timeouts
TerminalH2H.setOperationTimeout(type = TimeoutType.CARD, minutes = 10)
TerminalH2H.setOperationTimeout(type = TimeoutType.QR, minutes = 10)
```
The default timeout is 5 minutes. Use the type-specific methods to override card vs QR timeouts when needed.
This timeout configuration is only available for the BRI provider. Other terminal providers use their own internal timeout settings.
### Restart Terminal Connection
Manage and restart terminal service connections:
Call the method without parameters to restart all connections and tasks:
```kotlin theme={null}
// This restarts all connections
TerminalH2H.restart()
```
Provide the terminal ID to restart a specific terminal connection:
```kotlin theme={null}
// This restarts the connection to a specific Terminal
TerminalH2H.restart(terminalID = TERMINAL_ID)
```
### Monitor Connection State
Observe terminal connection states in real-time:
Use the `observeConnection` method with a coroutine scope:
```kotlin theme={null}
TerminalH2H.observeConnection(
CoroutineScope(Dispatchers.IO),
terminalDevice
) { state ->
when (state) {
ConnectionState.CONNECTED -> {
// Terminal is ready for transactions
Log.i("Terminal", "Connected to ${terminalDevice.id}")
}
ConnectionState.DISCONNECTED -> {
// Terminal is offline
Log.w("Terminal", "Disconnected from ${terminalDevice.id}")
}
ConnectionState.CONNECTING_FAILED -> {
// Connection attempt failed
Log.e("Terminal", "Failed to connect to ${terminalDevice.id}")
}
ConnectionState.UNREACHABLE -> {
// Gateway cannot reach the device; SDK keeps retrying
Log.w("Terminal", "Device unreachable ${terminalDevice.id}")
}
// ... handle other states
}
}
```
Use the connection state Flow directly:
```kotlin theme={null}
val connectionStateFlow = terminalDevice.connectionState
connectionStateFlow.collect { state ->
// Handle connection state changes
when (state) {
ConnectionState.CONNECTED -> {
// Terminal is ready for transactions
Log.i("Terminal", "Connected to ${terminalDevice.id}")
}
ConnectionState.DISCONNECTED -> {
// Terminal is offline
Log.w("Terminal", "Disconnected from ${terminalDevice.id}")
}
ConnectionState.UNREACHABLE -> {
// Gateway temporarily marks the device unreachable
Log.w("Terminal", "Unreachable device ${terminalDevice.id}")
}
// ... handle other states
}
}
```
### Connection States
| State | Description |
| ------------------ | -------------------------------------------------------------------- |
| CONNECTED | Device successfully connected to terminal and ready for transactions |
| DISCONNECTED | Device disconnected from terminal or network unavailable |
| UNKNOWN | Initial state before any connection attempt |
| CONNECTING | Currently establishing connection to terminal |
| CONNECTING\_FAILED | Connection attempt failed due to network or authentication issues |
| UNREACHABLE | Gateway ping failed; SDK retries until the terminal responds |
| UNSUPPORTED | Terminal type or connection method not supported |
### Monitor Error States
Observe and handle errors across all terminal devices:
```kotlin theme={null}
// Global error monitoring
TerminalH2H.observeError(
CoroutineScope(Dispatchers.IO)
) { device, error ->
Log.e("TerminalH2H", "Error on ${device?.id}: ${error?.message}")
when (error.code) {
ErrorCode.TERMINAL_BUSY -> {
// Terminal is processing another transaction
// Wait and retry later
}
ErrorCode.FAILED_TO_CONNECT -> {
// Network connectivity issue
// Check network connection and terminal IP
}
ErrorCode.AUTHENTICATION_FAILED -> {
// Invalid credentials or terminal ID
// Verify client key and terminal configuration
}
// ... handle other error codes
}
}
// Device-specific error monitoring
val errorFlow = TerminalH2H.errorState(terminalDevice)
val deviceErrorFlow = terminalDevice.error
```
## Error Handling
### Error Data Structure
All errors returned by the Terminal H2H SDK follow this structure:
```kotlin theme={null}
data class TerminalError(
val code: ErrorCode,
val message: String
)
```
### Error Codes Reference
| Error Code | HTTP Status | Description |
| ----------------------- | ----------- | ------------------------------------------------------------------------------------------------------ |
| INVALID\_CREDENTIAL | 401 | Provided credentials are invalid or expired |
| INVALID\_REQUEST | 400 | Request format or parameters are invalid |
| INTERNAL\_SERVER\_ERROR | 500 | Server-side error occurred during processing |
| UNKNOWN\_ERROR | 0 | Unexpected error that doesn't fit other categories |
| KEY\_INVALID | -1 | API key is invalid or not authorized |
| SEND\_FAILED | -2 | Failed to send data to the terminal device |
| NOT\_CONNECTED | -3 | No active connection to any terminal device |
| FAILED\_TO\_CONNECT | -4 | Unable to establish connection to terminal |
| UNSUPPORTED | -5 | Operation or platform not supported |
| TERMINAL\_BUSY | -6 | Terminal is processing another transaction |
| ENCRYPTION\_FAILED | -7 | Encryption key invalid or encryption process failed |
| AUTHENTICATION\_FAILED | -21 | Terminal authentication failed - check TID and credentials |
| DECLINED\_BY\_READER | N/A | Card reader rejected the transaction; prompt the customer to retry |
| PAYMENT\_UNPAID | N/A | Payment is still pending on the terminal; confirm status before retrying |
| DUPLICATED | N/A | Duplicate command detected; generate a new order ID before retrying |
| CANCELLED | N/A | Action cancelled on the terminal or by the operator |
| TIMEOUT | N/A | Operation exceeded the configured timeout window |
| NO\_DATA\_FOUND | N/A | Terminal cannot find the referenced transaction data |
| TID\_NOT\_SET | N/A | Terminal ID is missing in the gateway configuration |
| TID\_NOT\_MATCH | N/A | Terminal ID does not match the registered device |
### Error Handling Best Practices
Implement comprehensive error handling for robust payment processing:
```kotlin theme={null}
fun handleTerminalError(error: TerminalError?) {
when (error?.code) {
ErrorCode.AUTHENTICATION_FAILED -> {
// Verify API key and terminal ID
Log.e("TerminalH2H", "Authentication failed: ${error.message}")
// Show user-friendly message and retry with correct credentials
}
ErrorCode.TERMINAL_BUSY -> {
// Terminal is processing another transaction
Log.w("TerminalH2H", "Terminal busy: ${error.message}")
// Wait and retry after a delay
retryAfterDelay(5000) // 5 seconds
}
ErrorCode.FAILED_TO_CONNECT, ErrorCode.NOT_CONNECTED -> {
// Network connectivity issues
Log.e("TerminalH2H", "Connection failed: ${error.message}")
// Check network connection and terminal IP address
checkNetworkConnectivity()
}
ErrorCode.KEY_INVALID, ErrorCode.INVALID_CREDENTIAL -> {
// Credential issues
Log.e("TerminalH2H", "Invalid credentials: ${error.message}")
// Rotate or refresh API credentials
refreshCredentials()
}
ErrorCode.ENCRYPTION_FAILED -> {
// Encryption key issues
Log.e("TerminalH2H", "Encryption failed: ${error.message}")
// Re-initialize SDK with correct encryption keys
reinitializeSDK()
}
ErrorCode.TIMEOUT -> {
// Operation exceeded configured timeout window
Log.w("TerminalH2H", "Operation timed out: ${error.message}")
// Retry using exponential backoff or restart the device connection
retryAfterDelay(5000)
}
ErrorCode.CANCELLED -> {
// Action cancelled on terminal or by operator
Log.i("TerminalH2H", "Command cancelled: ${error.message}")
// Surface a friendly message to the cashier and re-initiate if needed
}
ErrorCode.DECLINED_BY_READER -> {
// Card or reader rejected the transaction
Log.w("TerminalH2H", "Reader declined: ${error.message}")
// Prompt customer to retry or use a different payment method
}
else -> {
// Log and escalate unknown errors
Log.e("TerminalH2H", "Unknown error: ${error?.message}")
// Report to monitoring system
reportError(error)
}
}
}
```
Always implement retry logic for transient errors like `TERMINAL_BUSY` and `FAILED_TO_CONNECT`. Use exponential backoff to avoid overwhelming the terminal.
## Troubleshooting
For more recovery scenarios across H2H and C2C terminal flows, see the [SDK Troubleshooting Guide](/sdk/troubleshooting).
### Common Issues and Solutions
**Problem**: The EDC (Electronic Data Capture) machine becomes unresponsive or stops processing transactions.
**Solution**:
1. Restart the EDC machine by holding the power button and selecting "Restart"
2. Wait for the device to fully boot up and reconnect
3. Verify the terminal is back online using the connection monitoring features
Always ensure the EDC is properly restarted before attempting new transactions to avoid data corruption.
**Problem**: Unexpected behaviors or unauthorized access to terminal functions.
**Solution**:
1. Ensure all transactions are initiated only through the SDK
2. Contact the Xendit EDC team to enable POS-only mode for your Terminal IDs
3. Configure terminal settings to disable manual transaction entry
POS-only mode prevents manual transaction entry and ensures all operations go through your application.
**Problem**: EDC fails to send transaction results to the SDK after payment completion.
**Solution**:
1. Query the Payment Session using the Terminal API to retrieve the latest status
2. Check network connectivity between the EDC and your application
3. Verify the callback URL configuration in your payment session
4. Implement retry logic for failed status updates
```kotlin theme={null}
// Example: Query payment session status
val paymentSession = terminalApi.getPaymentSession(sessionId)
when (paymentSession.status) {
PaymentStatus.COMPLETED -> {
// Process successful payment
}
PaymentStatus.FAILED -> {
// Handle failed payment
}
PaymentStatus.PENDING -> {
// Payment still in progress
}
}
```
**Problem**: Transaction appears stuck or you don't receive a callback after the terminal prints a receipt, indicating the transaction may be incomplete.
This troubleshooting section applies only to BRI terminals.
**Solution**:
Call the Terminal API retry endpoint to request the app check the transaction status and redo the transaction if it's incomplete:
```kotlin theme={null}
// Retry transaction via Terminal API
val response = terminalApi.retrySession(sessionId)
// The app will check transaction status and redo if incomplete
```
The retry endpoint `/v1/terminal/sessions/{id}/retry` instructs the app to verify the current transaction status with the terminal and automatically redo the transaction if it's found to be incomplete.
Use this retry mechanism when you see a receipt printed but haven't received a callback, as it may indicate the transaction didn't complete successfully on the terminal side.
**Problem**: Unable to establish or maintain connection with terminal devices.
**Solutions**:
* **Check network connectivity**: Ensure both devices are on the same network
* **Verify IP addresses**: Confirm terminal IP addresses are correct and accessible
* **Firewall settings**: Check if firewall is blocking the connection ports
* **Terminal status**: Ensure the terminal is powered on and in ready state
* **SDK initialization**: Verify client key and terminal configuration
Use the connection monitoring features to diagnose specific connection issues.
## Finding Terminal Information
Open the BRI FMS app on the terminal device and locate the Terminal ID in the device information section.
Open the ECRLink app on the terminal and check the network settings for the IP address.
Look for the Terminal ID on the physical sticker attached to the device.
Open the NTT LinkPOS app on the terminal and navigate to network settings to find the IP address.
Open the Cashlez app and navigate to the User Account tab to locate the Terminal ID.
Open the Terminal Gateway app and check the device list for the terminal IP address.
Open the Xendit app on the device and review the terminal details screen to locate the Terminal ID.
Open the Terminal Gateway app and check the device list for the terminal IP address.
Open the payment app on the Atom terminal, then go to Settings → Device Info to view the Terminal ID.
Open the Terminal Gateway app and check the device list for the terminal IP address.
Screenshots and UI layouts may vary by firmware or app version. Refer to the latest vendor documentation if the interface differs from these instructions.