---
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/developers/sdks-and-tools/ios/capture-flow/user-journeys
locale: en
generated_by: markdown-export
---

- [/](/)
- [SDKs and Tools](/developers/sdks-and-tools/overview)
- [iOS SDK](/developers/sdks-and-tools/ios/requirements)
- Capture flow
- User Journeys

# User Journeys

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.

ProductsThe 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 1** — Implement `AcessoBioManagerDelegate``AcessoBioManagerDelegate` handles the SDK lifecycle callbacks. Implement the four mandatory methods:

| Method | When it's called |
| --- | --- |
| `onErrorAcessoBioManager(error)` | An error occurred during SDK operation |
| `onUserClosedCameraManually()` | The user manually closed the camera |
| `onSystemClosedCameraTimeoutSession()` | The 40-second session limit was reached |
| `onSystemChangedTypeCameraTimeoutFaceInference()` | No face detected for 13 seconds — switches to manual capture |

- Swift
- Objective-C

```
class ViewController: UIViewController, AcessoBioManagerDelegate {**  var unicoCheck: AcessoBioManager!  override func viewDidLoad() {    super.viewDidLoad()    unicoCheck = AcessoBioManager(viewController: self)  }  func onErrorAcessoBioManager(_ error: ErrorBio!) { }  func onUserClosedCameraManually() { }  func onSystemClosedCameraTimeoutSession() { }  func onSystemChangedTypeCameraTimeoutFaceInference() { }}
```

```
@implementation ViewController: UIViewController- (void)viewDidLoad {    [super viewDidLoad];    unicoCheck = [[AcessoBioManager alloc]initWithViewController:self];}- (void)onErrorAcessoBioManager:(ErrorBio *)error { }- (void)onSystemChangedTypeCameraTimeoutFaceInference { }- (void)onSystemClosedCameraTimeoutSession { }- (void)onUserClosedCameraManually { }@end
```

Mandatory delegate methodsAll four delegate methods above must be created in your project (even without any logic). Otherwise, the project will not compile successfully.
**Step 2** — Implement `AcessoBioSelfieDelegate`Override the methods to handle the journey capture result callbacks:MethodDescription`onSuccessSelfie(result)`Image captured successfully — returns `SelfieResult` for subsequent REST API calls`onSuccess(result)`Journey completed successfully — returns a `processId` used to query validation results`onErrorSelfie(errorBio)`Capture failed — returns an `ErrorBio` with error detailsSwiftObjective-C```
class ViewController: UIViewController, AcessoBioManagerDelegate,  SelfieCameraDelegate, AcessoBioSelfieDelegate {  func onSuccessSelfie(_ result: SelfieResult!) { }  func onSuccess(_ result: SuccessResult!) { }  func onErrorSelfie(_ errorBio: ErrorBio!) { }}
```

```
@interface ViewController: UIViewController <AcessoBioManagerDelegate,  SelfieCameraDelegate, AcessoBioSelfieDelegate>@end@implementation ViewController- (void)onSuccessSelfie:(SelfieResult *)result { }- (void)onSuccess:(SuccessResult *)result { }- (void)onErrorSelfie:(ErrorBio *)errorBio { }@end
```

**Step 3** — Call `prepareSelfieCamera` and `open`Call `prepareSelfieCamera` passing the SDK config. When the camera is ready, the `onCameraReady` event is triggered — open the camera through the `open()` method, passing the `webAppToken`:webAppTokenThe `webAppToken` is the `process.webAppToken` field returned by [Create Process](/developers/api-reference/post-processes) when creating the process on your backend.
`onCameraReady(cameraOpener)` — camera is ready; call `open(self, webAppToken:)`.
`onCameraFailed(message)` — camera preparation failed (`ErrorPrepare` is an extension of `ErrorBio`).
SwiftObjective-C```
@IBAction func openCamera(_ sender: Any) {  unicoCheck.build().prepareSelfieCamera(self, config: YourUnicoConfigClass())}func onCameraReady(_ cameraOpener: AcessoBioCameraOpenerDelegate!) {  cameraOpener.open(self, webAppToken: "your_web_app_token")}func onCameraFailed(_ message: ErrorPrepare!) { }
```

```
- (IBAction)openCamera:(UIButton *)sender {    [[unicoCheck build] prepareSelfieCamera:self config:[YourUnicoConfigClass new]];}- (void)onCameraReady:(id)cameraOpener {    [cameraOpener open:self webAppToken:@"your_web_app_token"];}- (void)onCameraFailed:(ErrorPrepare *)message { }
```

For the full result handling, see [Receiving the result](/developers/sdks-and-tools/ios/capture-flow/receiving-the-result).Last updated on Oct 8, 2026**