---
title: User Journeys
description: Multi-step capture sessions orchestrated by the SDK based on the configured flow, such as selfie, document capture, and signature in a single session.
canonical: https://developer.unico.io/dual-api/developers/sdks-and-tools/android/capture-flow/capture-types/user-journeys
locale: en
generated_by: markdown-export
---

User Journeys are multi-step capture sessions orchestrated by the SDK in conjunction with the configured flow. For example, a flow with Liveness + Risk Score + Document Capture + Electronic Signature executes selfie, document capture, and signature in a single session.

:::secondary[Products]
The available journeys depend on the flow configured for your integration. Refer to [Products](/products) for the full mapping of product → flow → capability.
:::

## How it works

The SDK:

1. Reads the flow configuration provided during initialization.
2. Orchestrates the sequence of captures required for the flow (selfie, document, signature).
3. Returns a `processId` via `onSuccess` when the journey completes. For the selfie step, image data (`base64` / `encrypted`) is also returned via `onSuccessSelfie`. Document and signature captures are processed internally by the SDK — no per-step artifact is exposed to the client.

The orchestration is handled entirely by the SDK — you do not need to implement the step sequence in your app.

## Starting a User Journey

****Step 2** — Implement `iAcessoBioSelfie`**

`iAcessoBioSelfie` handles the journey capture result callbacks:

  | Method | Description |
  |---|---|
  | `onSuccessSelfie(result)` | Image captured successfully — returns `ResultCamera` for subsequent REST API calls |
  | `onSuccess(result)` | Journey completed successfully — returns `SuccessResult` with a `processId` used to query validation results |
  | `onErrorSelfie(errorBio)` | Capture failed — returns an `ErrorBio` with error details |

  ### Kotlin

    ```kotlin
    val cameraListener: iAcessoBioSelfie = object : iAcessoBioSelfie {
      override fun onSuccessSelfie(result: ResultCamera?) { }
      override fun onSuccess(result: SuccessResult) { }
      override fun onErrorSelfie(errorBio: ErrorBio?) { }
    }
    ```

### Java

    ```java
    iAcessoBioSelfie cameraListener = new iAcessoBioSelfie() {
      @Override
      public void onSuccessSelfie(ResultCamera result) { }

      @Override
      public void onSuccess(SuccessResult result) { }

      @Override
      public void onErrorSelfie(ErrorBio errorBio) { }
    };
    ```

****Step 3** — Call `prepareCamera`**

With `unicoCheckCamera` initialized and both listeners implemented, call `prepareCamera` passing the SDK config, a `CameraListener`, and your `webAppToken`:

  :::note[webAppToken]
  The `webAppToken` is the `process.webAppToken` field returned by `POST /client/v1/process` when creating the process on your backend. See [Create Process](/dual-api/developers/api-reference/web-sdk/post-process).
  :::

  - `onCameraReady` — camera is ready; call `open` passing the `cameraListener` and your `webAppToken`.
  - `onCameraFailed` — camera preparation failed; handle the error message.

  ### Kotlin

    ```kotlin
    unicoCheckCamera.prepareCamera(unicoConfig, object : CameraListener {
      override fun onCameraReady(cameraOpener: UnicoCheckCameraOpener.Camera?) {
        cameraOpener?.open(cameraListener, "your_web_app_token")
      }

      override fun onCameraFailed(message: String?) {
        Log.e(TAG, message)
      }
    })
    ```

### Java

    ```java
    unicoCheckCamera.prepareCamera(unicoConfig, new CameraListener() {
      @Override
      public void onCameraReady(UnicoCheckCameraOpener.Camera cameraOpener) {
        cameraOpener.open(cameraListener, "your_web_app_token");
      }

      @Override
      public void onCameraFailed(String message) {
        Log.e(TAG, message);
      }
    });
    ```

For the full result handling, see [Receiving the result](/developers/sdks-and-tools/android/capture-flow/receiving-the-result).