---
title: Completing backchannel authentication transactions on Android
description: Learn how to use the Ping Identity SDK for Android to complete a backchannel authentication transaction from a backchannel transaction URI.
component: orchsdks
page_id: orchsdks:journey:use-cases/backchannel-auth/android-backchannel-auth
canonical_url: https://developer.pingidentity.com/orchsdks/journey/use-cases/backchannel-auth/android-backchannel-auth.html
llms_txt: https://developer.pingidentity.com/orchsdks/llms.txt
docs_for_agents: https://developer.pingidentity.com/build-with-ai/docs-for-agents.md
revdate: Fri, 17 Jul 2026 00:00:00 +0000
keywords: ["PingOne Advanced Identity Cloud", "PingAM", "Journeys", "Android", "Backchannel Authentication", "Transactional Authentication", "SDK"]
section_ids:
  android_backchannel_module: Step 1. Installing the Journey module
  step_2_configuring_the_journey_module: Step 2. Configuring the Journey module
  step_3_completing_a_journey_using_a_backchannel_transaction_uri: Step 3. Completing a journey using a backchannel transaction URI
---

# Completing backchannel authentication transactions on Android

[icon: circle-check, set=far]PingOne Advanced Identity Cloud [icon: circle-check, set=far]PingAM [icon: android, set=fab]Android

A federation service that starts a backchannel authentication transaction on behalf of your user receives a backchannel transaction URI from PingOne Advanced Identity Cloud or PingAM, and is responsible for forwarding that URI to your app, for example over a push notification, a deep link, or another transport of your choosing.

The backchannel URI carries the details of the transaction as query parameters, for example:

```none
https://openam-forgerock-sdks.forgeblocks.com/am/UI/Login?realm=%2Falpha&authIndexType=transaction&authIndexValue=1bb31b1d-6b5f-4d5f-9a2f-6a6a7f6a2b3e
```

Use the **Journey** module's `start(backchannelUri:configure:)` method to complete the transaction on receipt of the URI.

The method extracts the transaction details from the backchannel transaction URI and drives the associated journey to completion, just like the standard `start()` method described in [Starting an authentication journey on Android](../../usage/android/04-starting-an-authentication-journey.html).

## Step 1. Installing the Journey module

To install the **Journey** module into your Android project:

1. In the **Project** tree view of your Android Studio project, open the `build.gradle.kts` file.

2. In the `dependencies` section, add the `journey` module as a dependency:

   ```gradle
   dependencies {
       implementation("com.pingidentity.sdks:journey:2.1.0")
   }
   ```

## Step 2. Configuring the Journey module

Import `com.pingidentity.journey.Journey`, then call `Journey()`, providing the Advanced Identity Cloud or PingAM server you want to target:

Configuring the Journey module

```kotlin
import com.pingidentity.journey.Journey

val journey = Journey {
    serverUrl = "https://openam-forgerock-sdks.forgeblocks.com/am"
    realm = "alpha"
    cookie = "ch15fefc5407912"
}
```

For the full range of configuration options available, see [Configuring the Journey module on Android](../../usage/android/03-configuring-the-journey-module.html).

|   |                                                                                                                                                                                                                                                                                                            |
| - | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|   | The Orchestration SDK uses the `serverUrl` and `realm` you provide when configuring `Journey`, rather than the host or `realm` parameter encoded in the backchannel transaction URI.This means a malicious or malformed backchannel transaction URI cannot redirect the SDK to contact a different server. |

## Step 3. Completing a journey using a backchannel transaction URI

Pass the backchannel transaction URI to `start()` to start the journey the server configured for the transaction:

Starting a journey from a backchannel transaction URI on Android

```kotlin
// backchannelUri is the value your app received from the federation service.
var node = journey.start(backchannelUri = backchannelUri)
```

You can optionally apply parameters to `start()`:

Adding parameters when starting a journey from a backchannel transaction URI

```kotlin
var node = journey.start(backchannelUri = backchannelUri) {
    forceAuth = true
    noSession = true
}
```

The parameters you might use in the `start()` method includes the following:

* *forceAuth*

  Set this parameter to `true` to force traversal of an authentication journey, even if the user already has a valid session.

  Default is `false`.

* *noSession*

  Set this parameter to `true` to prevent the authentication journey from issuing a new session token upon successful completion.

  Default is `false`.

Handle the returned `node` in exactly the same way as any other journey, as described in [Navigating an authentication journey on Android](../../usage/android/05-navigating-an-authentication-journey.html). A transaction that has expired, was already completed, or wasn't found returns an `ErrorNode` carrying the server's message.

Starting a journey and handling the returned node on Android

```kotlin
// backchannelUri is the value your app received from the federation service.
val node = journey.start(backchannelUri = backchannelUri)

when (node) {
    is ContinueNode -> {
        // Provide input to any callbacks in the journey, such as a username and password
        node.callbacks.forEach { callback ->
            when (callback) {
                is NameCallback -> callback.name = "demo"
                is PasswordCallback -> callback.password = "5tr0ngP@S5w0rd!!"
                // Handle other callback types as they are introduced
            }
        }

        // Proceed to the next node with the provided input
        val nextNode = node.next()
    }
    is ErrorNode -> {
        // Handle server-side errors, such as an expired or already-completed transaction
        val errorMessage = node.message
    }
    is FailureNode -> {
        // Handle unexpected errors, such as network issues or a missing JourneyConfig
        val errorCause = node.cause
    }
    is SuccessNode -> {
        // Authentication successful, retrieve the session
        val session = node.session
    }
}
```