---
title: Stille Revalidierung
description: Nutzt die Intelligente-Revalidierung-Engine, die den Verhaltenskontext des Nutzers im Netzwerkeffekt von Unico analysiert, um ein Vertrauenssignal für die aktuelle Transaktion zu liefern — mit anderen Worten, die Vertrauensstufe, dass es sich um den erwarteten Nutzer handelt.
canonical: https://developer.unico.io/de/dual-api/developers/sdks-and-tools/android/smart-revalidation/silent-revalidation
locale: de
generated_by: markdown-export
---

## PrepareInfo-Attribute

| Attribut | Typ | Erforderlich | Beschreibung |
|---|---|:-:|---|
| `externalUserId` | `String` | ✅ | Benutzerkennung in Ihrem System. Wird vor der Übertragung automatisch mit SHA-256 gehasht und niemals im Klartext gesendet. |

## Eine Stille Revalidierung starten

****Schritt 1** — `initializeSDK` implementieren**

Erstellen Sie eine neue `UnicoSDK`-Klasse/-Objekt mit einer statischen `initializeSDK`-Methode, die die `UnicoSDK`-Instanz zurückgibt und dabei den `context` sowie ein `UnicoSDKConfig` mit Ihrem `sdkKey`, `bundleId` und `environment` empfängt. Bewahren Sie die zurückgegebene Instanz auf — sie wird später benötigt, um `startSilentValidation` aus Java aufzurufen.

  :::warning[Beim App-Start aufrufen]
  `UnicoSDK.initializeSDK` muss so früh wie möglich beim App-Start aufgerufen werden (z. B. in `Application.onCreate`). Ein späterer Aufruf verringert die Verarbeitungszeit im Hintergrund und erhöht die Wahrscheinlichkeit unentschlossener Ergebnisse der Authentifizierung.
  :::

  ### Kotlin

    ```kotlin
    UnicoSDK.initializeSDK(
        context,
        UnicoSDKConfig(
            sdkKey = "your_sdk_key",
            bundleId = "your_bundle_id",
            environment = Environment.UAT
        )
    )
    ```

### Java

    ```java
    UnicoSDK sdk = UnicoSDK.initializeSDK(
        context,
        new UnicoSDKConfig("your_sdk_key", "your_bundle_id", Environment.UAT)
    );
    ```

****Schritt 2** — `startSilentValidation` implementieren**

Verknüpfen Sie nach `initializeSDK` die bereits laufende Erfassung mit dem identifizierten Nutzer, indem Sie `startSilentValidation` mit einer `PrepareInfo` aufrufen, die die `externalUserId` enthält.

  ### Kotlin

    ```kotlin
    val prepareInfo = PrepareInfo(
        externalUserId = "external_user_id"
    )

    UnicoSDK.startSilentValidation(prepareInfo)
        .onSuccess { result -> /* ... */ }
        .onFailure { error -> /* ... */ }
    ```

### Java

:::info[Java benötigt eine Kotlin-Bridge]
    `startSilentValidation` ist eine Kotlin-Suspend-Funktion und kann nicht direkt aus Java aufgerufen werden. Fügen Sie Ihrem Projekt eine kleine Kotlin-Bridge hinzu, die die Coroutine startet und ein einfaches Callback-Interface bereitstellt.
    :::

    ```kotlin
    interface SilentAuthCallback {
        fun onSuccess(success: Boolean)
        fun onFailure(message: String?)
    }

    object SilentAuthBridge {

        @JvmStatic
        fun startSilentValidation(
            owner: LifecycleOwner,
            sdk: UnicoSDK,
            externalUserId: String,
            callback: SilentAuthCallback
        ) {
            owner.lifecycleScope.launch {
                val result = sdk.startSilentValidation(PrepareInfo(externalUserId, null))
                result.onSuccess { callback.onSuccess(it.success) }
                    .onFailure { callback.onFailure(it.message) }
            }
        }
    }
    ```

    ```java
    SilentAuthBridge.startSilentValidation(this, sdk, externalUserId, new SilentAuthCallback() {
        @Override
        public void onSuccess(boolean success) {
            /* ... */
        }

        @Override
        public void onFailure(String message) {
            /* ... */
        }
    });
    ```

  Wenn die Validierung am Anfang des Flows stattfindet, zum Beispiel beim Login, warten Sie auf den `onSuccess`-Callback, bevor Sie mit Schritt 3 fortfahren.

****Schritt 3** — Prozess erstellen und authentifizieren**

Erstellen Sie bei laufender Validierung den Verifizierungsprozess, um die Authentifizierung abzuschließen. Siehe [API-Referenz ▸ API ▸ Prozess erstellen](/dual-api/developers/api-reference/api/post-processes).

  Fügen Sie im Request-Body dieselbe `externalUserId` ein, die in Schritt 2 in der `PrepareInfo` gesendet wurde — dadurch kann das Backend die Prozesserstellung mit der bereits laufenden Validierung korrelieren.

  ```bash
  curl -X POST https://api.id.unico.app/processes/v1 \
    -H "Authorization: Bearer $TOKEN" \
    -H "APIKEY: $API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "subject": {
        "duiType": 1,
        "code": "12345678909",
        "name": "Luke Skywalker",
        "gender": "M",
        "birthDate": "2000-05-20",
        "email": "luke@example.com",
        "phone": "5519725570707"
      },
      "useCase": "Onboarding",
      "externalUserId": "external_user_id",
      "imageBase64": "/9j/4AAQSkZJR..."
    }'
  ```

  Die Antwort enthält das Feld `silentAuth.result` mit dem Ergebnis der Authentifizierung:

  ```json
  {
      "id": "80371b2a-3ac7-432e-866d-57fe37896ac6",
      "status": 3,
      "silentAuth": {
          "result": "yes"
      }
  }
  ```

  | Feld | Typ | Beschreibung |
  |---|---|---|
  | `silentAuth.result` | string | `yes` oder `no` — siehe mögliche Werte unten. |

  <details>
  **`silentAuth.result` — mögliche Werte**

  | Wert | Bedeutung |
  |---|---|
  | `yes` | Authentifizierung genehmigt, Nutzer mit ausreichender Sicherheit erkannt, keine zusätzliche Erfassung erforderlich. |
  | `no` | Unzureichende Daten für eine stille Genehmigung. Es wird empfohlen, über Biometrie (Selfie) oder eine andere alternative Methode zu authentifizieren. |

</details>