Vérifier les pièces d'identité de vos utilisateurs

Installer le SDK Client-side

Le SDK Stripe Android est disponible en open source et fait l’objet d’une documentation complète.

Pour installer le SDK, ajoutez identity au bloc dependencies de votre fichier app/build.gradle :

plugins {
    id("com.android.application")
}

android { ... }

dependencies {
  // ...

  // Stripe Identity Android SDK
  implementation("com.stripe:identity:21.26.1")
}

Utiliser TFLite dans Google Play pour réduire la taille binaire Client-side

Le SDK Identity Android utilise un environnement d’exécution TFLite portable pour exécuter des modèles d’IA. Si votre application est publiée via Google Play, vous pouvez utiliser l’environnement d’exécution de Google Play pour réduire la taille du SDK d’environ 1,2 Mo.

dependencies {
  // ...

  // Stripe Identity Android SDK
  implementation('com.stripe:identity:21.26.1') {
    exclude group: 'com.stripe', module: 'ml-core-default' // exclude the default TFLite runtime
  }
  implementation('com.stripe:ml-core-googleplay:21.26.1') // include the Google Play TFLite runtime
}

Configurer le thème du matériel Client-side

Le SDK Android de Stripe Identity nécessite que l’activité d’hébergement utilise le thème du matériel. Pour activer le thème du matériel :

1. Ouvrez le fichier app/src/main/AndroidManifest.xml de votre projet.
2. Assurez-vous que le thème android:theme appliqué à application soit un enfant de l’un des thèmes de matériel (par exemple, Theme.MaterialComponents.DayNight).

Pour en savoir plus sur le thème de matériel, cliquez ici.

Installer Stripe sur votre serveur Server-side

Pour commencer, créez un compte Stripe.

Installez ensuite les bibliothèques permettant d’accéder à l’API Stripe depuis votre application :

# Available as a gem
sudo gem install stripe

# If you use bundler, you can add this line to your Gemfile
gem 'stripe'

Créer une VerificationSession

Une VerificationSession est une représentation programmatique de la vérification. Elle contient des détails concernant le type de vérification, comme les contrôles à effectuer. Vous pouvez développer le champ des résultats vérifiés pour afficher les données qui ont été contrôlées.

Vous avez besoin d’un endpoint côté serveur pour créer la VerificationSession. La création de la VerificationSession côté serveur éliminera tout risque de remplacement des options de vérification par des utilisateurs malintentionnés et vous évitera ainsi des frais de traitement sur votre compte. Ajoutez une authentification à cet endpoint en incluant une référence utilisateur dans les métadonnées de la session ou en enregistrant l’ID de session dans votre base de données.

Pour des raisons de sécurité, ne créez pas d’objet VerificationSession directement accessible depuis le client mobile. Le SDK recevra en fait de la part de votre serveur une clé éphémère d’accès, à savoir une clé API temporaire lui octroyant un droit d’accès restreint à l’objet VerificationSession. Cette clé éphémère lui ouvrira en quelque sorte une session, durant laquelle le SDK sera autorisé à récupérer et mettre à jour l’objet VerificationSession.

Une fois votre VerificationSession et votre clé éphémère créées, envoyez l’ID de la VerificationSession et la clé secrète éphémère au client pour afficher la feuille de chargement de documents.

// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
const stripe = require('stripe')(
'sk_test_BQokikJOvBiI2HlWgH4olfQ2');

// In the route handler for /create-verification-session:
// Authenticate your user.

// Create the session.
const verificationSession = await stripe.identity.verificationSessions.create({
  type: 'document',
  provided_details: {
    email: 'user@example.com',
  },
  metadata: {
    user_id: '{{USER_ID}}',
  },
});

// Create an ephemeral key for the VerificationSession
const ephemeralKey = await stripe.ephemeralKeys.create(
  {verification_session: verificationSession.id},
  {apiVersion: '2025-08-27.basil'}
);

// Return only the ID and ephemeral key secret to the frontend.
const verificationSessionId = verificationSession.id;
const ephemeralKeySecret = ephemeralKey.secret;

Testez votre endpoint en démarrant votre serveur Web (par exemple, localhost:4242) et en envoyant une requête POST avec curl pour créer une VerificationSession :

curl -X POST -is "http://localhost:4242/create-verification-session" -d ""

La réponse doit ressembler à ceci sur votre terminal :

HTTP/1.1 200 OK
Content-Type: application/json

{ id: "vs_QdfQQ6xfGNJR7ogV6", ephemeral_key_secret: "ek_YWNjdF8xRm..." }

Paramétrez un bouton afin qu’il feuille de chargement de document. En touchant le bouton, vos utilisateurs pourront capturer et charger une photo de leur passeport, de leur permis de conduire ou de leur carte d’identité.

Avant de démarrer, votre page de vérification doit :

• Expliquer à l’utilisateur pourquoi son identité doit être vérifiée.
• Inclure un bouton de vérification d’identité pour afficher l’interface utilisateur de Stripe.

Ajouter un bouton

Commencez par créer une Activity avec un bouton cliquable qui dispose d’un indicateur de chargement. Assurez-vous que MyHostingActivity hérite de AppCompatActivity et utilise un thème, héritant de Theme.MaterialComponents

class MyHostingActivity : AppCompatActivity() {
  // binding has a button and a loading indicator
  private val binding by lazy {
    MyHostingActivityBinding.inflate(layoutInflater)
  }
}

Importer le SDK Stripe Identity

Importez le SDK Identity dans votre activité, initialisez-le dans la méthode onCreate (cela a pour effet d’enregistrer un ActivityResultLauncher au niveau de ce AppCompatActivity ou Fragment).

import com.stripe.android.identity.IdentityVerificationSheet

class MyHostingActivity : AppCompatActivity() {
  // binding has a button and a loading indicator
  private val binding by lazy {
    MyHostingActivityBinding.inflate(layoutInflater)
  }

  lateinit var identityVerificationSheet: IdentityVerificationSheet

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(binding.root)
    identityVerificationSheet =
      IdentityVerificationSheet.create(
          this,
          IdentityVerificationSheet.Configuration(
              // Pass your square brand logo by creating it from local resource or
              // Uri.parse("https://path/to/your/brandlogo.jpg")
              brandLogo = logoUri
          )
      ) { verificationResult->
          when (verificationResult) {
            is Completed -> {
                // The user has completed uploading their documents.
                // Let them know that the verification is processing.
                ...
                Log.d(TAG, "Verification Completed!")
            }
            is Canceled -> {
                // The user did not complete uploading their documents.
                // You should allow them to try again.
                ...
                Log.d(TAG, "Verification Canceled!")
            }
            is Failed -> {
                // If the flow fails, you should display the localized error
                // message to your user using throwable.getLocalizedMessage()
                ...
                Log.d(TAG, "Verification Failed!")
            }
         }
      }
  }
}

Ajouter une action au bouton de vérification

Maintenant que vous avez un bouton et un endpoint pour créer une VerificationSession, modifiez le bouton afin que son activation déclenche l’affichage de la feuille de chargement de documents.

Ajoutez un appel pour :

• Récupérez l’ID VerificationSession et la clé secrète éphémère depuis votre endpoint.
• Instanciez une IdentityVerificationSheet avec le logo de votre marque et affichez-la à l’utilisateur.
• Gérez le VerificationFlowResult afin de savoir si l’utilisateur a exécuté le flux de vérification.

import com.stripe.android.identity.*

class MyHostingActivity : AppCompatActivity() {
  // binding has a button and a loading indicator
  private val binding by lazy {
    MyHostingActivityBinding.inflate(layoutInflater)
  }
  lateinit var identityVerificationSheet: IdentityVerificationSheet

  override fun onCreate(savedInstanceState: Bundle?) {
    ...
    binding.button.setOnClickListener(::onButtonClick)
  }

  fun onButtonClick() {
    // show loading UI
    // Request the session ID with Fuel or other network libraries
    Fuel.post("https://{{YOUR_SERVER_BASE_URL}}/create-verification-session")
      .responseString { _, _, result ->
          when (result) {
              is Result.Failure -> {
                  // show error UI
              }
              is Result.Success -> {
                  val responseJson = JSONObject(result.value)
                  try {
                      // start verification session
                      identityVerificationSheet.present(
                          verificationSessionId =
                            responseJson.getString("id"),
                          ephemeralKeySecret =
                            responseJson.getString("ephemeral_key_secret")
                      )
                  } catch (t: Throwable) {
                      // show error UI
                  }
              }
          }
      }
  }
}

Tester la feuille de vérification

Vérifiez que le bouton de vérification affiche la feuille de chargement de documents :

• Touchez le bouton Vérifier l’identité.
• Vérifiez qu’aucun message d’erreur ne s’affiche.

Si votre intégration ne fonctionne pas :

1. Fixez un point d’arrêt à l’endroit où vous récupérez l’ID VerificationSession et la clé secrète éphémère.
2. Vérifiez qu’il n’existe aucune erreur réseau et que l’endpoint renvoie un ID VerificationSession et une clé secrète éphémère.

Document checks are typically completed as soon as the user redirects back to your site and you can retrieve the result from the API immediately. In some rare cases, the document verification isn’t ready yet and must continue asynchronously. In these cases, you’re notified through webhooks when the verification result is ready. After the processing completes, the VerificationSession status changes from processing to verified.

Stripe envoie les événements suivants lorsque l’état de la session change :

Utilisez un gestionnaire de webhook pour recevoir ces événements et automatiser des actions telles que l’envoi d’un e-mail de confirmation, la mise à jour des résultats de la vérification dans votre base de données ou l’exécution d’une étape d’inscription. Vous pouvez également consulter les événements de vérification dans votre Dashboard.

Recevoir des événements et exécuter des actions métier

Avec code

Créez un gestionnaire de webhook pour écouter les événements et créer des flux de vérification asynchrones personnalisés. Testez et déboguez votre intégration de webhook en local avec la CLI Stripe.

Créer un webhook personnalisé

Sans code

Utilisez le Dashboard pour consulter toutes vos vérifications, inspecter les données collectées et comprendre les échecs de vérification.

Afficher vos vérifications de test dans le Dashboard