---
title: Revalidation silencieuse
description: Utilise le moteur de Revalidation intelligente, qui analyse le contexte comportemental de l'utilisateur au sein de l'effet de réseau d'Unico, pour fournir un signal de confiance pour la transaction en cours — autrement dit, le niveau de confiance qu'il s'agit bien de l'utilisateur attendu.
canonical: https://developer.unico.io/fr/dual-api/developers/sdks-and-tools/android/smart-revalidation/silent-revalidation
locale: fr
generated_by: markdown-export
---

## Attributs de PrepareInfo

| Attribut | Type | Requis | Description |
|---|---|:-:|---|
| `externalUserId` | `String` | ✅ | Identifiant de l'utilisateur dans votre système. Haché automatiquement avec SHA-256 avant la transmission, jamais envoyé en texte clair. |

## Démarrer une Revalidation silencieuse

****Étape 1** — Implémenter `initializeSDK`**

Créez une nouvelle classe/un nouvel objet `UnicoSDK`, avec une méthode statique `initializeSDK` qui retourne l'instance `UnicoSDK`, recevant le `context` et un `UnicoSDKConfig` avec votre `sdkKey`, `bundleId` et `environment`. Conservez l'instance retournée — elle sera nécessaire plus tard pour appeler `startSilentValidation` depuis Java.

  :::warning[Appelez-le au lancement de l'application]
  `UnicoSDK.initializeSDK` doit être appelé le plus tôt possible au lancement de l'application (par exemple, `Application.onCreate`). L'appeler plus tard réduit le temps de traitement en arrière-plan et augmente le risque de réponses d'authentification non concluantes.
  :::

  ### 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)
    );
    ```

****Étape 2** — Implémenter `startSilentValidation`**

Après `initializeSDK`, associez la collecte déjà en cours à l'utilisateur identifié en appelant `startSilentValidation` avec un `PrepareInfo` contenant l'`externalUserId`.

  ### Kotlin

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

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

### Java

:::info[Java nécessite un pont Kotlin]
    `startSilentValidation` est une fonction suspendue (suspend) Kotlin et ne peut pas être appelée directement depuis Java. Ajoutez un petit pont Kotlin à votre projet qui lance la coroutine et expose une interface de callback simple.
    :::

    ```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) {
            /* ... */
        }
    });
    ```

  Si la validation a lieu au début du flux, par exemple lors de la connexion, attendez le callback `onSuccess` avant de passer à l'étape 3.

****Étape 3** — Créer le processus et authentifier**

Avec la validation en cours, créez le processus de vérification pour terminer l'authentification. Voir [Référence API ▸ API ▸ Créer un processus](/dual-api/developers/api-reference/api/post-processes).

  Incluez le même `externalUserId` envoyé dans le `PrepareInfo` de l'étape 2 dans le corps de la requête — c'est ce qui permet au backend de corréler la création du processus avec la validation déjà en cours.

  ```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..."
    }'
  ```

  La réponse inclut le champ `silentAuth.result` avec le résultat de l'authentification :

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

  | Champ | Type | Description |
  |---|---|---|
  | `silentAuth.result` | string | `yes` ou `no` — voir les valeurs possibles ci-dessous. |

  <details>
  **`silentAuth.result` — valeurs possibles**

  | Valeur | Signification |
  |---|---|
  | `yes` | Authentification approuvée, utilisateur reconnu avec une confiance suffisante, aucune capture supplémentaire nécessaire. |
  | `no` | Données insuffisantes pour approuver silencieusement. Il est recommandé de procéder à une authentification par biométrie (selfie) ou une autre méthode alternative. |

</details>