# Vérifier les pièces d'identité de vos utilisateurs
Créez des sessions et collectez leurs pièces d'identité.
Ce guide explique comment utiliser Stripe Identity pour collecter et vérifier de manière sécurisée les pièces d’identité de vos utilisateurs.
Affichage d’un modal de chargement de documents sur votre site Web. Voici ce que vous devez effectuer :
1. Ajouter un bouton de vérification à votre page Web qui affiche un modal de chargement de documents.
1. Afficher une page de confirmation à la soumission d’une pièce d’identité.
1. Gérez les résultats de la vérification.
## Before you begin
1. [Activez votre compte](https://dashboard.stripe.com/account/onboarding).
1. Remplissez votre [formulaire d’inscription à Stripe Identity](https://dashboard.stripe.com/identity/application).
1. (Facultatif) Personnalisez les paramètres de votre marque sur la [page Paramètres de marque](https://dashboard.stripe.com/settings/branding).
## Configurer Stripe [Côté serveur]
Pour commencer, [créez un compte](https://dashboard.stripe.com/register) Stripe.
Installez ensuite les bibliothèques permettant d’accéder à l’API Stripe depuis votre application :
#### Ruby
```bash
# Available as a gem
sudo gem install stripe
```
```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```
## Ajouter un bouton sur votre site Web [Côté client]
Ajoutez un bouton à votre site Web permettant de lancer la vérification.
#### HTML + JS
### Ajouter un bouton
Commencez par ajouter un bouton de vérification à votre page :
```html
Verify your identity
```
### Ajouter la bibliothèque Stripe.js à votre page
Ajoutez [Stripe.js](https://docs.stripe.com/payments/elements.md) à votre page en incluant une balise de script dans votre document HTML :
```html
Verify your identity
```
> Chargez toujours **Stripe.js** directement depuis `https://js.stripe.com`. Vous ne pouvez pas l’inclure dans un lot ni en héberger une copie sur votre propre serveur.
### Initialiser Stripe.js
Initialisez Stripe.js avec votre [clé API](https://docs.stripe.com/keys.md) publique en transmettant le JavaScript suivant à votre page :
```html
Verify your identity
```
#### React
### Ajouter un bouton
Commencez par ajouter un bouton de vérification à votre page :
```jsx
import React from 'react';
class VerifyButton extends React.Component {
render() {
return (
);
}
}
const App = () => {
return (
);
};
export default App;
```
### Installer Stripe.js
Installez le [module ES Stripe.js](https://www.npmjs.com/package/@stripe/stripe-js) :
```bash
npm install @stripe/stripe-js
```
> Si vous utilisez Node.js sur le serveur, vous devez installer les packages [Stripe](https://www.npmjs.com/package/stripe) et [@stripe/stripe-js](https://www.npmjs.com/package/@stripe/stripe-js). `stripe` est utilisé côté serveur pour envoyer des requêtes à l’API Stripe, tandis que `@stripe/stripe-js` fournit des méthodes pour l’inclusion de [Stripe.js](https://docs.stripe.com/js.md) dans votre code côté client.
### Initialiser Stripe.js
Appelez `loadStripe` avec votre [clé API](https://docs.stripe.com/keys.md) publique. La promesse qui est renvoyée résout l’objet Stripe dès que Stripe.js est chargé.
```jsx
import React from 'react';import {loadStripe} from '@stripe/stripe-js';
class VerifyButton extends React.Component {constructor(props) {
super(props);
this.state = {};
}
async componentDidMount() {
this.setState({ stripe: await this.props.stripePromise });
}
render() {const { stripe } = this.state;
return (
);
}
}
// Make sure to call `loadStripe` outside of a component’s render to avoid
// recreating the `Stripe` object on every render.
const stripePromise = loadStripe('<>');
const App = () => {
return (
);
};
export default App;
```
## Afficher la boîte de dialogue de chargement de documents [Côté client] [Côté serveur]
Paramétrez le nouveau bouton afin qu’il affiche la boîte de dialogue de chargement de documents. Lorsqu’ils cliqueront sur le bouton, vos utilisateurs pourront capturer et charger une photo de leur passeport, de leur permis de conduire ou de leur carte d’identité.
Le modal réduit les efforts de développement et de maintenance et vous permet de collecter des pièces d’identité dans le cadre de vos flux existants. Il réduit par ailleurs la quantité d’informations privées à gérer sur votre site. Et il vous permet en outre de prendre en charge les utilisateurs sur plusieurs plateformes et dans plusieurs langues, ainsi que de personnaliser le style de la page aux couleurs de votre marque.
### Créer une VerificationSession
Une [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md) est une représentation programmatique de la vérification. Elle contient des détails concernant le type de vérification, comme les [contrôles](https://docs.stripe.com/identity/verification-checks.md) à effectuer. Vous pouvez [développer](https://docs.stripe.com/api/expanding_objects.md) le champ des [résultats vérifiés](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-verified_outputs) pour afficher les données qui ont été contrôlées.
Une fois votre `VerificationSession` créée, envoyez la [clé secrète du client](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-client_secret) au front-end pour afficher la fenêtre modale de chargement de documents.
Vous pouvez utiliser les flux de vérification pour une configuration réutilisable qui est transmise au paramètre [verification_flow](https://docs.stripe.com/api/identity/verification_sessions/create.md#create_identity_verification_session-verification_flow). Pour en savoir plus, consultez le [guide des flux de vérification](https://docs.stripe.com/identity/verification-flows.md).
Vous avez besoin d’un endpoint côté serveur pour [créer la VerificationSession](https://docs.stripe.com/api/identity/verification_sessions/create.md). 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.
#### Node.js
```javascript
// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<>');
// 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}}',
},
});
// Return only the client secret to the frontend.
const clientSecret = verificationSession.client_secret;
```
> La clé secrète du client permet à votre front-end de collecter des informations de vérification sensibles. Elle est à usage unique et expire après 24 heures. Ne la stockez pas, ne l’enregistrez pas, ne l’intégrez pas dans des URL et ne la dévoilez à personne d’autre que votre client. Veillez à ce que le protocole TLS soit activé sur toutes les pages contenant la clé secrète du client. N’envoyez cette dernière qu’à votre front-end pour éviter d’exposer la configuration ou les résultats de la vérification.
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 :
```bash
curl -X POST -is "http://localhost:4242/create-verification-session" -d ""
```
La réponse doit ressembler à ceci sur votre terminal :
```bash
HTTP/1.1 200 OK
Content-Type: application/json
{ id: "vs_QdfQQ6xfGNJR7ogV6", client_secret: "vs_QdfQQ6xfGNJR7ogV6_secret_live_..." }
```
### Ajouter un gestionnaire d’événements au bouton de vérification
Maintenant que vous disposez d’un bouton et d’un endpoint pour créer une VerificationSession, modifiez le bouton afin qu’il affiche la fenêtre modale de chargement de documents lorsque l’utilisateur cliquera dessus. Ajoutez un appel à [verifyIdentity](https://docs.stripe.com/js/identity/modal) à l’aide de la clé secrète du client :
#### HTML + JS
```html
Verify your identity
```
#### React
```jsx
import React from 'react';
import {loadStripe} from '@stripe/stripe-js';
class VerifyButton extends React.Component {
constructor(props) {
super(props);
this.state = {};this.handleClick = this.handleClick.bind(this);
}
async componentDidMount() {
this.setState({ stripe: await this.props.stripePromise });
}
async handleClick(event) {
// Block native event handling.
event.preventDefault();
const { stripe } = this.state;
if (!stripe) {
// Stripe.js hasn't loaded yet. Make sure to disable
// the button until Stripe.js has loaded.
return;
}
// Call your backend to create the VerificationSession.
const response = await fetch('/create-verification-session', { method: 'POST' });
const session = await response.json();
// Show the verification modal.
const { error } = await stripe.verifyIdentity(session.client_secret);
if (error) {
console.log('[error]', error);
} else {
console.log('Verification submitted!');
}
}
render() {
const { stripe } = this.state;
return (
);
}
}
// Make sure to call `loadStripe` outside of a component’s render to avoid
// recreating the `Stripe` object on every render.
const stripePromise = loadStripe('<>');
const App = () => {
return (
);
};
export default App;
```
### Codes d’erreur des événements
| Code d’erreur | Description |
| ----------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `consent_declined` | L’utilisateur a refusé la vérification par Stripe. Consultez votre conseiller juridique pour savoir si vous avez l’obligation de proposer une méthode de vérification non biométrique, par exemple une vérification manuelle. |
| `device_unsupported` | La vérification nécessite un appareil photo, mais l’appareil de l’utilisateur n’en possède pas. |
| `under_supported_age` | Stripe ne vérifie pas les utilisateurs mineurs. |
| `phone_otp_declined` | L’utilisateur ne peut pas vérifier le numéro de téléphone fourni. |
| `email_verification_declined` | L’utilisateur ne peut pas vérifier l’adresse e-mail fournie. |
### Tester la boîte de dialogue de chargement
Vérifiez que votre bouton de vérification affiche la boîte de dialogue de chargement de documents :
- Cliquez sur le bouton de vérification et assurez-vous qu’il affiche la boîte de dialogue de chargement de documents Stripe.
- Vérifiez qu’aucun message d’erreur ne s’affiche.
Si votre intégration ne fonctionne pas :
1. Ouvrez l’onglet Réseau dans les outils de développement de votre navigateur.
1. Cliquez sur le bouton de vérification pour voir s’il effectue bien une requête XHR auprès de votre endpoint côté serveur (`POST /create-verification-session`).
1. Vérifiez que la requête renvoie bien un état 200.
1. Utilisez `console.log(session)` dans l’écouteur du clic sur le bouton pour vous assurer qu’il renvoie les données appropriées.
## Afficher une page de confirmation [Côté client]
Afin de fournir une expérience conviviale, affichez une page de confirmation une fois la pièce d’identité soumise. Hébergez la page sur votre site pour informer l’utilisateur que la vérification est en cours.
#### HTML + JS
Créez une page de confirmation minimale :
```html
Your document was submitted
Thanks for submitting your identity document.
We are processing your verification.
```
Ensuite, mettez à jour le gestionnaire de boutons pour qu’il redirige vers cette page :
```html
Verify your identity
```
#### React
Mettez à jour le gestionnaire de boutons pour qu’il affiche un message de confirmation :
```jsx
import React from 'react';
import {loadStripe} from '@stripe/stripe-js';
class VerifyButton extends React.Component {
constructor(props) {
super(props);this.state = { submitted: false };
this.handleClick = this.handleClick.bind(this);
}
async componentDidMount() {
this.setState({ stripe: await this.props.stripePromise });
}
async handleClick(event) {
// Block native event handling.
event.preventDefault();
const { stripe } = this.state;
if (!stripe) {
// Stripe.js hasn't loaded yet. Make sure to disable
// the button until Stripe.js has loaded.
return;
}
// Call your backend to create the VerificationSession.
const response = await fetch('/create-verification-session', { method: 'POST' });
const session = await response.json();
// Show the verification modal.
const { error } = await stripe.verifyIdentity(session.client_secret);
if (error) {
console.log('[error]', error.message);
} else {
console.log('Verification submitted!');this.setState({ submitted: true });
}
}
render() {const { stripe, submitted } = this.state;
if (submitted) {
return (
<>
Thanks for submitting your identity document
We are processing your verification.
);
}
return (
);
}
}
// Make sure to call `loadStripe` outside of a component’s render to avoid
// recreating the `Stripe` object on every render.
const stripePromise = loadStripe('<>');
const App = () => {
return (
);
};
export default App;
```
### Tester la page de confirmation
Vérifiez que votre page de confirmation fonctionne :
- Cliquez sur votre bouton de vérification.
- Soumettez la session en sélectionnant un cas de test prédéfini.
- Confirmez que la nouvelle page de confirmation s’affiche.
- Testez les cas d’échec (comme les refus de consentement ou d’autorisation d’accès à l’appareil photo) sur l’ensemble du flux et assurez-vous que votre application les traite sans problème.
Ensuite, recherchez la vérification dans le Dashboard Stripe. Les sessions de vérification apparaissent dans la [liste des VerificationSessions](https://dashboard.stripe.com/identity) du Dashboard. Cliquez sur une session pour accéder à la page d’informations correspondante. La section du récapitulatif contient les résultats de la vérification, dont vous pouvez vous servir dans votre application.
## Gérer les événements de vérification
[Document checks](https://docs.stripe.com/identity/verification-checks.md#document-availability) 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 :
| Nom de l’événement | Description | Étapes suivantes |
| ---------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [identity.verification_session.verified](https://docs.stripe.com/api/events/types.md#event_types-identity.verification_session.verified) | Le traitement de tous les [contrôles de vérification](https://docs.stripe.com/identity/verification-checks.md) est terminé. La vérification a été effectuée avec succès. | Déclenchez les actions pertinentes dans votre application. |
| [identity.verification_session.requires_input](https://docs.stripe.com/api/events/types.md#event_types-identity.verification_session.requires_input) | Le traitement de tous les [contrôles de vérification](https://docs.stripe.com/identity/verification-checks.md) est terminé, et au moins un des contrôles a échoué. | Déclenchez les actions appropriées dans votre application et autorisez le cas échéant l’utilisateur à effectuer une nouvelle tentative de vérification. |
Utilisez un [gestionnaire de webhook](https://docs.stripe.com/identity/handle-verification-outcomes.md) 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](https://dashboard.stripe.com/events?type=identity.%2A).
## 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é](https://docs.stripe.com/identity/handle-verification-outcomes.md)
### 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](https://dashboard.stripe.com/test/identity/verification-sessions)
## See also
- [Gérer les résultats de la vérification](https://docs.stripe.com/identity/handle-verification-outcomes.md)
- [En savoir plus sur les VerificationSessions](https://docs.stripe.com/identity/verification-sessions.md)
- [En savoir plus sur Stripe.js](https://docs.stripe.com/payments/elements.md)
Renvoi de vos utilisateurs vers Stripe pour qu’ils chargent leurs pièces d’identité. Voici ce que vous devez effectuer :
1. Ajouter un bouton de vérification à votre page Web qui redirige vers Stripe Identity.
1. Afficher une page de confirmation à la soumission d’une pièce d’identité.
1. Gérez les résultats de la vérification.
## Before you begin
1. [Activez votre compte](https://dashboard.stripe.com/account/onboarding).
1. Remplissez votre [formulaire d’inscription à Stripe Identity](https://dashboard.stripe.com/identity/application).
1. (Facultatif) Personnalisez les paramètres de votre marque sur la [page Paramètres de marque](https://dashboard.stripe.com/settings/branding).
## Configurer Stripe [Côté serveur]
Pour commencer, [créez un compte](https://dashboard.stripe.com/register) Stripe.
Installez ensuite les bibliothèques permettant d’accéder à l’API Stripe depuis votre application :
#### Ruby
```bash
# Available as a gem
sudo gem install stripe
```
```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```
## Ajouter un bouton sur votre site Web [Côté client]
Ajoutez un bouton à votre site Web permettant de lancer la vérification.
#### HTML + JS
### Ajouter un bouton
Commencez par ajouter un bouton de vérification à votre page :
```html
Verify your identity
```
#### React
### Ajouter un bouton
Commencez par ajouter un bouton de vérification à votre page :
```jsx
import React from 'react';
class VerifyButton extends React.Component {
render() {
return (
);
}
}
const App = () => {
return (
);
};
export default App;
```
## Rediriger vers Stripe Identity [Côté client] [Côté serveur]
Paramétrez le bouton afin qu’il redirige vers Stripe Identity. Lorsque l’utilisateur cliquera sur le bouton, votre front-end devra le rediriger vers une page hébergée par Stripe où il pourra capturer et charger une photo de son passeport, de son permis de conduire ou de sa carte d’identité.
Le mécanisme de redirection vers Stripe Identity réduit les efforts de développement et de maintenance, tout en offrant davantage de sécurité. Il réduit par ailleurs la quantité d’informations privées à gérer sur votre site. Et il vous permet en outre de prendre en charge les utilisateurs sur plusieurs plateformes et dans plusieurs langues, ainsi que de personnaliser le style de la page aux couleurs de votre marque.
### Créer une VerificationSession
Une [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md) est une représentation programmatique de la vérification. Elle contient des détails concernant le type de vérification, comme les [contrôles](https://docs.stripe.com/identity/verification-checks.md) à effectuer. Vous pouvez [développer](https://docs.stripe.com/api/expanding_objects.md) le champ des [résultats vérifiés](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-verified_outputs) pour afficher les données qui ont été contrôlées.
Une fois votre `VerificationSession` créée, envoyez l’[URL de session](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-url) au front-end pour assurer la redirection vers Stripe Identity.
Vous pouvez utiliser les flux de vérification pour une configuration réutilisable qui est transmise au paramètre [verification_flow](https://docs.stripe.com/api/identity/verification_sessions/create.md#create_identity_verification_session-verification_flow). Pour en savoir plus, consultez le [guide des flux de vérification](https://docs.stripe.com/identity/verification-flows.md).
Vous avez besoin d’un endpoint côté serveur pour [créer la VerificationSession](https://docs.stripe.com/api/identity/verification_sessions/create.md). 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.
#### Node.js
```javascript
// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<>');
// 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}}',
},
});
// Return only the session URL to the frontend.
const url = verificationSession.url;
```
> L’URL de session est à usage unique et expire après 48 heures. Ne la stockez pas, ne l’enregistrez pas, ne l’intégrez pas dans des URL et ne la dévoilez à personne d’autre que votre client. N’envoyez l’URL de session qu’à votre front-end pour éviter d’exposer la configuration ou les résultats de la vérification.
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 :
```bash
curl -X POST -is "http://localhost:4242/create-verification-session" -d ""
```
La réponse doit ressembler à ceci sur votre terminal :
```bash
HTTP/1.1 200 OK
Content-Type: application/json
{ id: "vs_QdfQQ6xfGNJR7ogV6", url: "https://verify.stripe.com/start/QdfQQ6xfxNJR7ogV6Z6Wp..." }
```
### Ajouter un gestionnaire d’événements au bouton de vérification
Maintenant que vous disposez d’un bouton et d’un endpoint pour créer une VerificationSession, modifiez le bouton afin qu’il redirige vers l’URL de la session lorsque l’utilisateur cliquera dessus :
#### HTML + JS
```html
Verify your identity
```
#### React
```jsx
import React from 'react';
import {loadStripe} from '@stripe/stripe-js';
class VerifyButton extends React.Component {async handleClick(event) {
// Block native event handling.
event.preventDefault();
// Call your backend to create the VerificationSession.
const response = await fetch('/create-verification-session', { method: 'POST' });
const session = await response.json();
// When the user clicks on the button, redirect to the session URL.
window.location.href = session.url;
}
render() {
return (
);
}
}
// Make sure to call `loadStripe` outside of a component’s render to avoid
// recreating the `Stripe` object on every render.
const stripePromise = loadStripe('<>');
const App = () => {
return (
);
};
export default App;
```
### Test de la redirection
Vérifiez que bouton de vérification redirige vers Stripe Identity :
- Cliquez sur le bouton de vérification.
- Assurez-vous que votre navigateur redirige vers Stripe Identity.
Si votre intégration ne fonctionne pas :
1. Ouvrez l’onglet Réseau dans les outils de développement de votre navigateur.
1. Cliquez sur le bouton de vérification pour voir s’il effectue bien une requête XHR auprès de votre endpoint côté serveur (`POST /create-verification-session`).
1. Vérifiez que la requête renvoie bien un état 200.
1. Utilisez `console.log(session)` dans l’écouteur du clic sur le bouton pour vous assurer qu’il renvoie les données appropriées.
## Gérer les événements de vérification
[Document checks](https://docs.stripe.com/identity/verification-checks.md#document-availability) 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 :
| Nom de l’événement | Description | Étapes suivantes |
| ---------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [identity.verification_session.verified](https://docs.stripe.com/api/events/types.md#event_types-identity.verification_session.verified) | Le traitement de tous les [contrôles de vérification](https://docs.stripe.com/identity/verification-checks.md) est terminé. La vérification a été effectuée avec succès. | Déclenchez les actions pertinentes dans votre application. |
| [identity.verification_session.requires_input](https://docs.stripe.com/api/events/types.md#event_types-identity.verification_session.requires_input) | Le traitement de tous les [contrôles de vérification](https://docs.stripe.com/identity/verification-checks.md) est terminé, et au moins un des contrôles a échoué. | Déclenchez les actions appropriées dans votre application et autorisez le cas échéant l’utilisateur à effectuer une nouvelle tentative de vérification. |
Utilisez un [gestionnaire de webhook](https://docs.stripe.com/identity/handle-verification-outcomes.md) 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](https://dashboard.stripe.com/events?type=identity.%2A).
## 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é](https://docs.stripe.com/identity/handle-verification-outcomes.md)
### 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](https://dashboard.stripe.com/test/identity/verification-sessions)
## Optional: Afficher une page de confirmation [Côté client]
Afin de fournir une expérience conviviale, Identity peut rediriger les utilisateurs vers une page de votre site Web une fois leur pièce d’identité soumise.
Créez une page de confirmation minimale :
```html
Your document was submitted
Thanks for submitting your identity document.
We are processing your verification.
```
Ensuite, mettez à jour l’appel de création de la VerificationSession avec une URL pour cette page dans le paramètre `return_url` :
#### Node.js
```javascript
const verificationSession = await stripe.identity.verificationSessions.create({
type: 'document',return_url: 'https://{{ YOUR_DOMAIN }}/submitted.html',
metadata: { user_id: '{{USER_ID}}' },
});
```
### Tester la page de confirmation
Vérifiez que votre page de confirmation fonctionne :
- Cliquez sur votre bouton de vérification.
- Soumettez la session en sélectionnant un cas de test prédéfini.
- Confirmez que la nouvelle page de confirmation s’affiche.
- Testez les cas d’échec (comme les refus de consentement ou d’autorisation d’accès à l’appareil photo) sur l’ensemble du flux et assurez-vous que votre application les traite sans problème.
Ensuite, recherchez la vérification dans le Dashboard Stripe. Les sessions de vérification apparaissent dans la [liste des VerificationSessions](https://dashboard.stripe.com/identity) du Dashboard. Cliquez sur une session pour accéder à la page d’informations correspondante. La section du récapitulatif contient les résultats de la vérification, dont vous pouvez vous servir dans votre application.
## See also
- [Gérer les résultats de la vérification](https://docs.stripe.com/identity/handle-verification-outcomes.md)
- [En savoir plus sur les VerificationSessions](https://docs.stripe.com/identity/verification-sessions.md)
- [En savoir plus sur Stripe.js](https://docs.stripe.com/payments/elements.md)
> Pour accéder au SDK Identity iOS, rendez-vous sur la page [Paramètres d’identité](https://dashboard.stripe.com/settings/identity) et cliquez sur **Activer**.
Pour vérifier l’identité de vos utilisateurs sur iOS, affichez une feuille de vérification dans votre application. Ce guide comprend les étapes suivantes :
1. Configurez Stripe.
1. Ajouter un endpoint de serveur.
1. Afficher la feuille de vérification.
1. Gérer les événements de vérification.
## Before you begin
1. [Activez votre compte](https://dashboard.stripe.com/account/onboarding).
1. Remplissez votre [formulaire d’inscription à Stripe Identity](https://dashboard.stripe.com/identity/application).
Les étapes de ce guide sont intégralement implémentées dans notre [application test](https://github.com/stripe/stripe-ios/tree/master/Example/IdentityVerification%20Example) et notre [exemple de serveur back-end](https://codesandbox.io/p/devbox/compassionate-violet-gshhgf).
## Configurer [Côté serveur] [Côté client]
> Si vous avez l’intention d’utiliser ce SDK avec le service Identity de Stripe, ne modifiez pas le SDK Stripe Identity. En l’absence d’autorisation écrite de Stripe, l’utilisation d’une version modifiée de ce SDK pour le service Stripe Identity constitue une violation de votre contrat avec Stripe et peut entraîner la suspension ou la clôture de votre compte Stripe.
### Installer le SDK (Client-side)
Le [SDK iOS de Stripe](https://github.com/stripe/stripe-ios) est disponible en open source et [fait l’objet d’une documentation complète](https://stripe.dev/stripe-ios/index.html). Il est également compatible avec les applications prenant en charge iOS 13.0 et les versions ultérieures.
#### Swift Package Manager
Pour installer le SDK, veuillez suivre les étapes ci-dessous :
1. Dans Xcode, sélectionnez **File** > **Add Package Dependencies…** puis saisissez `https://github.com/stripe/stripe-ios-spm` en tant qu’URL du référentiel.
1. Sélectionnez le dernier numéro de version, visible sur notre [page des versions](https://github.com/stripe/stripe-ios/releases).
1. Ajoutez le produit **StripeIdentity** à la [cible de votre application](https://developer.apple.com/documentation/swift_packages/adding_package_dependencies_to_your_app).
#### CocoaPods
1. Si vous ne l’avez pas encore fait, installez la version la plus récente de [CocoaPods](https://guides.cocoapods.org/using/getting-started.html).
1. Si vous n’avez pas de fichier [Podfile](https://guides.cocoapods.org/syntax/podfile.html), exécutez la commande suivante pour en créer un :
```bash
pod init
```
1. Ajoutez cette ligne à votre `Podfile` :
```podfile
pod 'StripeIdentity'
```
1. Exécutez la commande suivante :
```bash
pod install
```
1. À partir de maintenant, n’oubliez pas d’utiliser le fichier .xcworkspace au lieu du fichier .xcodeproj pour ouvrir votre projet dans Xcode.
1. Pour mettre à jour ultérieurement le SDK vers la version la plus récente, il vous suffit d’exécuter :
```bash
pod update StripeIdentity
```
#### Carthage
1. Si vous ne l’avez pas encore fait, installez la version la plus récente de [Carthage](https://github.com/Carthage/Carthage#installing-carthage).
1. Ajoutez cette ligne à votre `Cartfile` :
```cartfile
github "stripe/stripe-ios"
```
1. Suivez les [instructions d’installation de Carthage](https://github.com/Carthage/Carthage#if-youre-building-for-ios-tvos-or-watchos). Veillez à intégrer tous les cadres requis listés [ici](https://github.com/stripe/stripe-ios/tree/master/StripeIdentity#manual-linking).
1. Pour mettre à jour ultérieurement le SDK vers la version la plus récente, exécutez la commande suivante :
```bash
carthage update stripe-ios --platform ios
```
#### Cadre manuel
1. Accédez à notre [page des versions GitHub](https://github.com/stripe/stripe-ios/releases/latest), puis téléchargez et décompressez **Stripe.xcframework.zip**.
1. Faites glisser **StripeIdentity.xcframework** vers la section **Embedded Binaries (Fichiers binaires incorporés)** des paramètres **General (Général)** de votre projet Xcode. Veillez à sélectionner **Copy items if needed (Copier les éléments si nécessaire)**.
1. Répétez l’étape 2 pour tous les cadres requis listés [ici](https://github.com/stripe/stripe-ios/tree/master/StripeIdentity#manual-linking).
1. À l’avenir, pour mettre à jour vers la version la plus récente de notre SDK, répétez les étapes 1 à 3.
> Pour obtenir de plus amples informations sur la version la plus récente du SDK et ses versions antérieures, consultez la page des [versions](https://github.com/stripe/stripe-ios/releases) sur GitHub. Pour recevoir une notification lors de la publication d’une nouvelle version, [surveillez les versions](https://help.github.com/en/articles/watching-and-unwatching-releases-for-a-repository#watching-releases-for-a-repository) à partir du référentiel.
### Configurer l’autorisation d’accès à l’appareil photo (Client-side)
Le SDK iOS de Stripe Identity doit pouvoir accéder à l’appareil photo de l’appareil pour capturer des pièces d’identité. Pour permettre à votre application de demander des autorisations d’accès à l’appareil photo :
1. Ouvrez le fichier **Info.plist** de votre projet dans Xcode.
1. Ajoutez la clé `NSCameraUsageDescription`.
1. Ajoutez une valeur de chaîne qui explique à vos utilisateurs pourquoi votre application nécessite des autorisations de caméra, par exemple :
> Cette application utilise l’appareil photo pour prendre une photo de vos documents d’identité.
Consultez la [documentation d’Apple](https://developer.apple.com/documentation/avfoundation/cameras_and_media_capture/requesting_authorization_for_media_capture_on_ios) pour en savoir plus sur la demande d’accès à l’appareil photo.
### Installer Stripe sur votre serveur (Server-side)
Pour commencer, [créez un compte](https://dashboard.stripe.com/register) Stripe.
Installez ensuite les bibliothèques permettant d’accéder à l’API Stripe depuis votre application :
#### Ruby
```bash
# Available as a gem
sudo gem install stripe
```
```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```
## Ajouter un endpoint de serveur [Côté serveur]
### Créer une VerificationSession
Une [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md) est une représentation programmatique de la vérification. Elle contient des détails concernant le type de vérification, comme les [contrôles](https://docs.stripe.com/identity/verification-checks.md) à effectuer. Vous pouvez [développer](https://docs.stripe.com/api/expanding_objects.md) le champ des [résultats vérifiés](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-verified_outputs) pour afficher les données qui ont été contrôlées.
Vous pouvez utiliser les flux de vérification pour une configuration réutilisable qui est transmise au paramètre [verification_flow](https://docs.stripe.com/api/identity/verification_sessions/create.md#create_identity_verification_session-verification_flow). Pour en savoir plus, consultez le [guide des flux de vérification](https://docs.stripe.com/identity/verification-flows.md).
Vous avez besoin d’un endpoint côté serveur pour [créer la VerificationSession](https://docs.stripe.com/api/identity/verification_sessions/create.md). 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. À la place, votre serveur fournit au SDK une clé éphémère, c’est-à-dire une clé API à durée de vie limitée avec un accès restreint à [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md). Vous pouvez considérer une clé éphémère comme une session qui autorise le SDK à récupérer et à mettre à jour un objet `VerificationSession` spécifique pendant la durée de la session.
Une fois votre `VerificationSession` et votre clé éphémère créées, envoyez l’[ID](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-id) de la `VerificationSession` et la clé secrète éphémère au client pour afficher la feuille de chargement de documents.
> Vous trouverez une implémentation en cours d’exécution de cet endpoint [disponible ici](https://codesandbox.io/p/devbox/compassionate-violet-gshhgf) pour des tests rapides.
#### Node.js
```javascript
// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<>');
// 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: '2026-03-25.dahlia'}
);
// Return only the ID and ephemeral key secret to the frontend.
const verificationSessionId = verificationSession.id;
const ephemeralKeySecret = ephemeralKey.secret;
```
> La clé secrète éphémère est liée à la session `VerificationSession` et permet à votre application de collecter des données de vérification sensibles, telles que des fichiers contenant des pièces d’identité et images de selfie. Elle est à usage unique et expire au bout d’une heure. Ne la stockez pas, ne l’enregistrez pas, ne l’intégrez pas dans des URL et ne la dévoilez à personne d’autre que votre utilisateur. Veillez à ce que le protocole TLS soit activé sur tout endpoint renvoyant la clé secrète éphémère. Envoyez celle-ci uniquement à votre application pour éviter de dévoiler la configuration ou les résultats de la vérification.
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 :
```bash
curl -X POST -is "http://localhost:4242/create-verification-session" -d ""
```
La réponse doit ressembler à ceci sur votre terminal :
```bash
HTTP/1.1 200 OK
Content-Type: application/json
{ id: "vs_QdfQQ6xfGNJR7ogV6", ephemeral_key_secret: "ek_YWNjdF8xRm..." }
```
## Afficher la feuille de vérification [Côté client]
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 un contrôleur d’affichage avec un bouton cliquable qui dispose d’un indicateur de chargement :
```swift
import UIKit
class VerifyViewController: UIViewController {
@IBOutlet weak var verifyButton: UIButton!
@IBOutlet weak var activityIndicator: UIActivityIndicatorView!
}
```
### Importer le SDK StripeIdentity
Importez `StripeIdentity` sur votre contrôleur d’affichage :
```swift
import UIKitimport StripeIdentity
class VerifyViewController: UIViewController {
@IBOutlet weak var verifyButton: UIButton!
@IBOutlet weak var activityIndicator: UIActivityIndicatorView!
}
```
### 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 `VerificationResult` afin de savoir si l’utilisateur a exécuté le flux de vérification.
```swift
import UIKit
import StripeIdentity
class VerifyViewController: UIViewController {
@IBOutlet weak var verifyButton: UIButton!
@IBOutlet weak var activityIndicator: UIActivityIndicatorView!
override func viewDidLoad() {
super.viewDidLoad()
verifyButton.addTarget(self, action: #selector(didTapVerifyButton), for: .touchUpInside)
}
@objc
func didTapVerifyButton() {
// Disable the button while the request is made
verifyButton.isEnabled = false
activityIndicator.startAnimating()
// Make request to your verification endpoint
var urlRequest = URLRequest(url: URL(string: "https://{{YOUR_SERVER_BASE_URL}}/create-verification-session")!)
urlRequest.httpMethod = "POST"
let task = URLSession.shared.dataTask(with: urlRequest) { [weak self] data, response, error in
DispatchQueue.main.async { [weak self] in
// Re-enable button
self?.verifyButton.isEnabled = true
self?.activityIndicator.stopAnimating()
guard error == nil,
let data = data,
let responseJson = try? JSONDecoder().decode([String: String].self, from: data),
let verificationSessionId = responseJson["id"],
let ephemeralKeySecret = responseJson["ephemeral_key_secret"] else {
// Handle error
print(error as Any)
return
}
self?.presentVerificationSheet(verificationSessionId: verificationSessionId, ephemeralKeySecret: ephemeralKeySecret)
}
}
task.resume()
}
func presentVerificationSheet(verificationSessionId: String, ephemeralKeySecret: String) {
// Configure a square brand logo. Recommended image size is 32 x 32 points.
let configuration = IdentityVerificationSheet.Configuration(
brandLogo: UIImage(named: "{{YOUR_BRAND_LOGO}}")!
)
// Instantiate and present the sheet
let verificationSheet = IdentityVerificationSheet(
verificationSessionId: verificationSessionId,
ephemeralKeySecret: ephemeralKeySecret,
configuration: configuration
)
verificationSheet.present(from: self, completion: { result in
switch result {
case .flowCompleted:
// The user has completed uploading their documents.
// Let them know that the verification is processing.
print("Verification Completed!")
case .flowCanceled:
// The user did not complete uploading their documents.
// You should allow them to try again.
print("Verification Canceled!")
case .flowFailed(let error):
// If the flow fails, you should display the localized error
// message to your user using error.localizedDescription
print("Verification Failed!")
print(error.localizedDescription)
}
})
}
}
```
### 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.
1. 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.
## Gérer les événements de vérification
[Document checks](https://docs.stripe.com/identity/verification-checks.md#document-availability) 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 :
| Nom de l’événement | Description | Étapes suivantes |
| ---------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [identity.verification_session.verified](https://docs.stripe.com/api/events/types.md#event_types-identity.verification_session.verified) | Le traitement de tous les [contrôles de vérification](https://docs.stripe.com/identity/verification-checks.md) est terminé. La vérification a été effectuée avec succès. | Déclenchez les actions pertinentes dans votre application. |
| [identity.verification_session.requires_input](https://docs.stripe.com/api/events/types.md#event_types-identity.verification_session.requires_input) | Le traitement de tous les [contrôles de vérification](https://docs.stripe.com/identity/verification-checks.md) est terminé, et au moins un des contrôles a échoué. | Déclenchez les actions appropriées dans votre application et autorisez le cas échéant l’utilisateur à effectuer une nouvelle tentative de vérification. |
Utilisez un [gestionnaire de webhook](https://docs.stripe.com/identity/handle-verification-outcomes.md) 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](https://dashboard.stripe.com/events?type=identity.%2A).
## 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é](https://docs.stripe.com/identity/handle-verification-outcomes.md)
### 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](https://dashboard.stripe.com/test/identity/verification-sessions)
> Pour accéder au SDK Identity iOS, rendez-vous sur la page [Paramètres d’identité](https://dashboard.stripe.com/settings/identity) et cliquez sur **Activer**.
Ce guide explique comment migrer une intégration Stripe Identity depuis le SDK de [redirection Web](https://docs.stripe.com/identity/verify-identity-documents.md?platform=web&type=redirect) vers le SDK iOS natif pour votre application mobile. Ce guide comprend les étapes suivantes :
1. Configurez Stripe.
1. Mettez à jour votre endpoint de serveur.
1. Afficher la feuille de vérification.
1. Gérer les événements de vérification.
## Before you begin
1. [Activez votre compte](https://dashboard.stripe.com/account/onboarding).
1. Remplissez votre [formulaire d’inscription à Stripe Identity](https://dashboard.stripe.com/identity/application).
Les étapes de ce guide sont intégralement implémentées dans notre [application test](https://github.com/stripe/stripe-ios/tree/master/Example/IdentityVerification%20Example) et notre [exemple de serveur back-end](https://codesandbox.io/p/devbox/compassionate-violet-gshhgf).
## Configurer [Côté serveur] [Côté client]
> Si vous avez l’intention d’utiliser ce SDK avec le service Identity de Stripe, ne modifiez pas le SDK Stripe Identity. En l’absence d’autorisation écrite de Stripe, l’utilisation d’une version modifiée de ce SDK pour le service Stripe Identity constitue une violation de votre contrat avec Stripe et peut entraîner la suspension ou la clôture de votre compte Stripe.
### Installer le SDK (Client-side)
Le [SDK iOS de Stripe](https://github.com/stripe/stripe-ios) est disponible en open source et [fait l’objet d’une documentation complète](https://stripe.dev/stripe-ios/index.html). Il est également compatible avec les applications prenant en charge iOS 13.0 et les versions ultérieures.
#### Swift Package Manager
Pour installer le SDK, veuillez suivre les étapes ci-dessous :
1. Dans Xcode, sélectionnez **File** > **Add Package Dependencies…** puis saisissez `https://github.com/stripe/stripe-ios-spm` en tant qu’URL du référentiel.
1. Sélectionnez le dernier numéro de version, visible sur notre [page des versions](https://github.com/stripe/stripe-ios/releases).
1. Ajoutez le produit **StripeIdentity** à la [cible de votre application](https://developer.apple.com/documentation/swift_packages/adding_package_dependencies_to_your_app).
#### CocoaPods
1. Si vous ne l’avez pas encore fait, installez la version la plus récente de [CocoaPods](https://guides.cocoapods.org/using/getting-started.html).
1. Si vous n’avez pas de fichier [Podfile](https://guides.cocoapods.org/syntax/podfile.html), exécutez la commande suivante pour en créer un :
```bash
pod init
```
1. Ajoutez cette ligne à votre `Podfile` :
```podfile
pod 'StripeIdentity'
```
1. Exécutez la commande suivante :
```bash
pod install
```
1. À partir de maintenant, n’oubliez pas d’utiliser le fichier .xcworkspace au lieu du fichier .xcodeproj pour ouvrir votre projet dans Xcode.
1. Pour mettre à jour ultérieurement le SDK vers la version la plus récente, il vous suffit d’exécuter :
```bash
pod update StripeIdentity
```
#### Carthage
1. Si vous ne l’avez pas encore fait, installez la version la plus récente de [Carthage](https://github.com/Carthage/Carthage#installing-carthage).
1. Ajoutez cette ligne à votre `Cartfile` :
```cartfile
github "stripe/stripe-ios"
```
1. Suivez les [instructions d’installation de Carthage](https://github.com/Carthage/Carthage#if-youre-building-for-ios-tvos-or-watchos). Veillez à intégrer tous les cadres requis listés [ici](https://github.com/stripe/stripe-ios/tree/master/StripeIdentity#manual-linking).
1. Pour mettre à jour ultérieurement le SDK vers la version la plus récente, exécutez la commande suivante :
```bash
carthage update stripe-ios --platform ios
```
#### Cadre manuel
1. Accédez à notre [page des versions GitHub](https://github.com/stripe/stripe-ios/releases/latest), puis téléchargez et décompressez **Stripe.xcframework.zip**.
1. Faites glisser **StripeIdentity.xcframework** vers la section **Embedded Binaries (Fichiers binaires incorporés)** des paramètres **General (Général)** de votre projet Xcode. Veillez à sélectionner **Copy items if needed (Copier les éléments si nécessaire)**.
1. Répétez l’étape 2 pour tous les cadres requis listés [ici](https://github.com/stripe/stripe-ios/tree/master/StripeIdentity#manual-linking).
1. À l’avenir, pour mettre à jour vers la version la plus récente de notre SDK, répétez les étapes 1 à 3.
> Pour obtenir de plus amples informations sur la version la plus récente du SDK et ses versions antérieures, consultez la page des [versions](https://github.com/stripe/stripe-ios/releases) sur GitHub. Pour recevoir une notification lors de la publication d’une nouvelle version, [surveillez les versions](https://help.github.com/en/articles/watching-and-unwatching-releases-for-a-repository#watching-releases-for-a-repository) à partir du référentiel.
### Configurer l’autorisation d’accès à l’appareil photo (Client-side)
Le SDK iOS de Stripe Identity doit pouvoir accéder à l’appareil photo de l’appareil pour capturer des pièces d’identité. Pour permettre à votre application de demander des autorisations d’accès à l’appareil photo :
1. Ouvrez le fichier **Info.plist** de votre projet dans Xcode.
1. Ajoutez la clé `NSCameraUsageDescription`.
1. Ajoutez une valeur de chaîne qui explique à vos utilisateurs pourquoi votre application nécessite des autorisations de caméra, par exemple :
> Cette application utilise l’appareil photo pour prendre une photo de vos documents d’identité.
Consultez la [documentation d’Apple](https://developer.apple.com/documentation/avfoundation/cameras_and_media_capture/requesting_authorization_for_media_capture_on_ios) pour en savoir plus sur la demande d’accès à l’appareil photo.
### Installer Stripe sur votre serveur (Server-side)
Pour commencer, [créez un compte](https://dashboard.stripe.com/register) Stripe.
Installez ensuite les bibliothèques permettant d’accéder à l’API Stripe depuis votre application :
#### Ruby
```bash
# Available as a gem
sudo gem install stripe
```
```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```
## Mettre à jour l'endpoint du serveur [Côté serveur]
### Intégration Web existante
Si vous disposiez d’une intégration [modale](https://docs.stripe.com/identity/verify-identity-documents.md?platform=web&type=modal), une [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md) a été créée et une `VerificationSession` [client_secret](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-client_secret) a été transmise à l’objet d’API Stripe.
#### Node.js
```javascript
// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<>');
// 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}}',
},
});
// Return only the client secret to the frontend.
const clientSecret = verificationSession.client_secret;
```
Si vous disposiez d’une intégration de [redirection](https://docs.stripe.com/identity/verify-identity-documents.md?platform=web&type=redirect), une [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md) a été créée et l’[url](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-url) `VerificationSession` a été envoyée à l’application mobile cliente et ouverte dans un navigateur intégré à l’application.
#### Node.js
```javascript
// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<>');
// 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}}',
},
});
// Return only the session URL to the frontend.
const url = verificationSession.url;
```
### Migrer vers l’intégration SDK
Pour utiliser le SDK natif, créez la même [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md) et une clé secrète éphémère.
#### Node.js
```javascript
// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<>');
// 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: '2026-03-25.dahlia'}
);
// Return only the ID and ephemeral key secret to the frontend.
const verificationSessionId = verificationSession.id;
const ephemeralKeySecret = ephemeralKey.secret;
```
Une fois votre `VerificationSession` et votre clé éphémère créées, envoyez l’[ID](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-id) de la `VerificationSession` et la `ephemeral key secret` à l’application mobile du client.
> Vous trouverez une implémentation en cours d’exécution de cet endpoint [disponible ici](https://codesandbox.io/p/devbox/compassionate-violet-gshhgf) pour des tests rapides.
> La clé secrète éphémère permet à votre application de collecter des informations de vérification sensibles. Elle est à usage unique et expire après 1 heure. Ne la stockez pas, ne l’enregistrez pas, ne l’intégrez pas dans des URL et ne la dévoilez à personne d’autre que votre utilisateur. Veillez à ce que le protocole TLS soit activé sur tout endpoint renvoyant la clé secrète éphémère. N’envoyez cette dernière qu’à votre application pour éviter d’exposer la configuration ou les résultats de la vérification.
## Afficher la feuille de vérification [Côté client]
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 un contrôleur d’affichage avec un bouton cliquable qui dispose d’un indicateur de chargement :
```swift
import UIKit
class VerifyViewController: UIViewController {
@IBOutlet weak var verifyButton: UIButton!
@IBOutlet weak var activityIndicator: UIActivityIndicatorView!
}
```
### Importer le SDK StripeIdentity
Importez `StripeIdentity` sur votre contrôleur d’affichage :
```swift
import UIKitimport StripeIdentity
class VerifyViewController: UIViewController {
@IBOutlet weak var verifyButton: UIButton!
@IBOutlet weak var activityIndicator: UIActivityIndicatorView!
}
```
### 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 `VerificationResult` afin de savoir si l’utilisateur a exécuté le flux de vérification.
```swift
import UIKit
import StripeIdentity
class VerifyViewController: UIViewController {
@IBOutlet weak var verifyButton: UIButton!
@IBOutlet weak var activityIndicator: UIActivityIndicatorView!
override func viewDidLoad() {
super.viewDidLoad()
verifyButton.addTarget(self, action: #selector(didTapVerifyButton), for: .touchUpInside)
}
@objc
func didTapVerifyButton() {
// Disable the button while the request is made
verifyButton.isEnabled = false
activityIndicator.startAnimating()
// Make request to your verification endpoint
var urlRequest = URLRequest(url: URL(string: "https://{{YOUR_SERVER_BASE_URL}}/create-verification-session")!)
urlRequest.httpMethod = "POST"
let task = URLSession.shared.dataTask(with: urlRequest) { [weak self] data, response, error in
DispatchQueue.main.async { [weak self] in
// Re-enable button
self?.verifyButton.isEnabled = true
self?.activityIndicator.stopAnimating()
guard error == nil,
let data = data,
let responseJson = try? JSONDecoder().decode([String: String].self, from: data),
let verificationSessionId = responseJson["id"],
let ephemeralKeySecret = responseJson["ephemeral_key_secret"] else {
// Handle error
print(error as Any)
return
}
self?.presentVerificationSheet(verificationSessionId: verificationSessionId, ephemeralKeySecret: ephemeralKeySecret)
}
}
task.resume()
}
func presentVerificationSheet(verificationSessionId: String, ephemeralKeySecret: String) {
// Configure a square brand logo. Recommended image size is 32 x 32 points.
let configuration = IdentityVerificationSheet.Configuration(
brandLogo: UIImage(named: "{{YOUR_BRAND_LOGO}}")!
)
// Instantiate and present the sheet
let verificationSheet = IdentityVerificationSheet(
verificationSessionId: verificationSessionId,
ephemeralKeySecret: ephemeralKeySecret,
configuration: configuration
)
verificationSheet.present(from: self, completion: { result in
switch result {
case .flowCompleted:
// The user has completed uploading their documents.
// Let them know that the verification is processing.
print("Verification Completed!")
case .flowCanceled:
// The user did not complete uploading their documents.
// You should allow them to try again.
print("Verification Canceled!")
case .flowFailed(let error):
// If the flow fails, you should display the localized error
// message to your user using error.localizedDescription
print("Verification Failed!")
print(error.localizedDescription)
}
})
}
}
```
### 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.
1. 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.
## Gérer les événements de vérification
[Document checks](https://docs.stripe.com/identity/verification-checks.md#document-availability) 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 :
| Nom de l’événement | Description | Étapes suivantes |
| ---------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [identity.verification_session.verified](https://docs.stripe.com/api/events/types.md#event_types-identity.verification_session.verified) | Le traitement de tous les [contrôles de vérification](https://docs.stripe.com/identity/verification-checks.md) est terminé. La vérification a été effectuée avec succès. | Déclenchez les actions pertinentes dans votre application. |
| [identity.verification_session.requires_input](https://docs.stripe.com/api/events/types.md#event_types-identity.verification_session.requires_input) | Le traitement de tous les [contrôles de vérification](https://docs.stripe.com/identity/verification-checks.md) est terminé, et au moins un des contrôles a échoué. | Déclenchez les actions appropriées dans votre application et autorisez le cas échéant l’utilisateur à effectuer une nouvelle tentative de vérification. |
Utilisez un [gestionnaire de webhook](https://docs.stripe.com/identity/handle-verification-outcomes.md) 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](https://dashboard.stripe.com/events?type=identity.%2A).
## 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é](https://docs.stripe.com/identity/handle-verification-outcomes.md)
### 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](https://dashboard.stripe.com/test/identity/verification-sessions)
> Pour accéder au SDK Identity Android, rendez-vous sur la page [Paramètres d’identité](https://dashboard.stripe.com/settings/identity) et cliquez sur **Activer**.
Pour vérifier l’identité de vos utilisateurs sur Android, affichez une feuille de vérification dans votre application. Ce guide comprend les étapes suivantes :
1. Configurez Stripe.
1. Ajouter un endpoint de serveur.
1. Afficher la feuille de vérification.
1. Gérer les événements de vérification.
## Before you begin
1. [Activez votre compte](https://dashboard.stripe.com/account/onboarding).
1. Remplissez votre [formulaire d’inscription à Stripe Identity](https://dashboard.stripe.com/identity/application).
Les étapes de ce guide sont entièrement implémentées dans notre [application test](https://github.com/stripe/stripe-android/tree/master/identity-example) et notre [exemple de serveur back-end](https://codesandbox.io/p/devbox/compassionate-violet-gshhgf).
## Configurer [Côté serveur] [Côté client]
> Si vous avez l’intention d’utiliser ce SDK avec le service Identity de Stripe, ne modifiez pas le SDK Stripe Identity. En l’absence d’autorisation écrite de Stripe, l’utilisation d’une version modifiée de ce SDK pour le service Stripe Identity constitue une violation de votre contrat avec Stripe et peut entraîner la suspension ou la clôture de votre compte Stripe.
### Installer le SDK (Client-side)
Le [SDK Stripe Android](https://github.com/stripe/stripe-android) est disponible en open source et [fait l’objet d’une documentation complète](https://stripe.dev/stripe-android/).
Pour installer le SDK, ajoutez `identity` au bloc `dependencies` de votre fichier [app/build.gradle](https://developer.android.com/studio/build/dependencies) :
#### Kotlin
```kotlin
plugins {
id("com.android.application")
}
android { ... }
dependencies {
// ...
// Stripe Identity Android SDK
implementation("com.stripe:identity:23.2.0")
}
```
> Pour obtenir de plus amples informations sur la version la plus récente du SDK et ses versions antérieures, consultez la page des [versions](https://github.com/stripe/stripe-android/releases) sur GitHub. Pour savoir quand une nouvelle version est disponible, [surveillez les versions du référentiel](https://docs.github.com/en/github/managing-subscriptions-and-notifications-on-github/configuring-notifications#configuring-your-watch-settings-for-an-individual-repository).
### 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.
#### Groovy
```groovy
dependencies {
// ...
// Stripe Identity Android SDK
implementation('com.stripe:identity:23.2.0') {
exclude group: 'com.stripe', module: 'ml-core-default' // exclude the default TFLite runtime
}
implementation('com.stripe:ml-core-googleplay:23.2.0') // include the Google Play TFLite runtime
}
```
### Configurer le thème du matériel (Client-side)
Le SDK Android Stripe Identity exige que l’activité hôte utilise un [thème Matériel](https://material.io/develop/android/theming/dark).Pour activer le thème matériel :
1. Ouvrez le fichier `app/src/main/AndroidManifest.xml` de votre projet.
1. Assurez-vous que le `android:theme` appliqué à l’`application` est un enfant de l’un des thèmes matériels (par exemple,`Theme.MaterialComponents.DayNight`).
### Installer Stripe sur votre serveur (Server-side)
Pour commencer, [créez un compte](https://dashboard.stripe.com/register) Stripe.
Installez ensuite les bibliothèques permettant d’accéder à l’API Stripe depuis votre application :
#### Ruby
```bash
# Available as a gem
sudo gem install stripe
```
```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```
## Ajouter un endpoint de serveur [Côté serveur]
### Créer une VerificationSession
Une [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md) est une représentation programmatique de la vérification. Elle contient des détails concernant le type de vérification, comme les [contrôles](https://docs.stripe.com/identity/verification-checks.md) à effectuer. Vous pouvez [développer](https://docs.stripe.com/api/expanding_objects.md) le champ des [résultats vérifiés](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-verified_outputs) pour afficher les données qui ont été contrôlées.
Vous pouvez utiliser les flux de vérification pour une configuration réutilisable qui est transmise au paramètre [verification_flow](https://docs.stripe.com/api/identity/verification_sessions/create.md#create_identity_verification_session-verification_flow). Pour en savoir plus, consultez le [guide des flux de vérification](https://docs.stripe.com/identity/verification-flows.md).
Vous avez besoin d’un endpoint côté serveur pour [créer la VerificationSession](https://docs.stripe.com/api/identity/verification_sessions/create.md). 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. À la place, votre serveur fournit au SDK une clé éphémère, c’est-à-dire une clé API à durée de vie limitée avec un accès restreint à [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md). Vous pouvez considérer une clé éphémère comme une session qui autorise le SDK à récupérer et à mettre à jour un objet `VerificationSession` spécifique pendant la durée de la session.
Une fois votre `VerificationSession` et votre clé éphémère créées, envoyez l’[ID](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-id) de la `VerificationSession` et la clé secrète éphémère au client pour afficher la feuille de chargement de documents.
> Vous trouverez une implémentation en cours d’exécution de cet endpoint [disponible ici](https://codesandbox.io/p/devbox/compassionate-violet-gshhgf) pour des tests rapides.
#### Node.js
```javascript
// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<>');
// 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: '2026-03-25.dahlia'}
);
// Return only the ID and ephemeral key secret to the frontend.
const verificationSessionId = verificationSession.id;
const ephemeralKeySecret = ephemeralKey.secret;
```
> La clé secrète éphémère est liée à la session `VerificationSession` et permet à votre application de collecter des données de vérification sensibles, telles que des fichiers contenant des pièces d’identité et images de selfie. Elle est à usage unique et expire au bout d’une heure. Ne la stockez pas, ne l’enregistrez pas, ne l’intégrez pas dans des URL et ne la dévoilez à personne d’autre que votre utilisateur. Veillez à ce que le protocole TLS soit activé sur tout endpoint renvoyant la clé secrète éphémère. Envoyez celle-ci uniquement à votre application pour éviter de dévoiler la configuration ou les résultats de la vérification.
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 :
```bash
curl -X POST -is "http://localhost:4242/create-verification-session" -d ""
```
La réponse doit ressembler à ceci sur votre terminal :
```bash
HTTP/1.1 200 OK
Content-Type: application/json
{ id: "vs_QdfQQ6xfGNJR7ogV6", ephemeral_key_secret: "ek_YWNjdF8xRm..." }
```
## Afficher la feuille de vérification [Côté client]
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`
#### Kotlin
```kotlin
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](https://developer.android.com/reference/androidx/activity/result/ActivityResultLauncher) au niveau de ce `AppCompatActivity` ou `Fragment`).
#### Kotlin
```kotlin
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.
#### Kotlin
```kotlin
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.
1. 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.
## Gérer les événements de vérification
[Document checks](https://docs.stripe.com/identity/verification-checks.md#document-availability) 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 :
| Nom de l’événement | Description | Étapes suivantes |
| ---------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [identity.verification_session.verified](https://docs.stripe.com/api/events/types.md#event_types-identity.verification_session.verified) | Le traitement de tous les [contrôles de vérification](https://docs.stripe.com/identity/verification-checks.md) est terminé. La vérification a été effectuée avec succès. | Déclenchez les actions pertinentes dans votre application. |
| [identity.verification_session.requires_input](https://docs.stripe.com/api/events/types.md#event_types-identity.verification_session.requires_input) | Le traitement de tous les [contrôles de vérification](https://docs.stripe.com/identity/verification-checks.md) est terminé, et au moins un des contrôles a échoué. | Déclenchez les actions appropriées dans votre application et autorisez le cas échéant l’utilisateur à effectuer une nouvelle tentative de vérification. |
Utilisez un [gestionnaire de webhook](https://docs.stripe.com/identity/handle-verification-outcomes.md) 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](https://dashboard.stripe.com/events?type=identity.%2A).
## 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é](https://docs.stripe.com/identity/handle-verification-outcomes.md)
### 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](https://dashboard.stripe.com/test/identity/verification-sessions)
> Pour accéder au SDK Identity Android, rendez-vous sur la page [Paramètres d’identité](https://dashboard.stripe.com/settings/identity) et cliquez sur **Activer**.
Ce guide explique comment migrer une intégration Stripe Identity depuis le SDK de [redirection Web](https://docs.stripe.com/identity/verify-identity-documents.md?platform=web&type=redirect) vers le SDK Android natif pour votre application mobile. Ce guide comprend les étapes suivantes :
1. Configurez Stripe.
1. Mettez à jour votre endpoint de serveur.
1. Afficher la feuille de vérification.
1. Gérer les événements de vérification.
## Before you begin
1. [Activez votre compte](https://dashboard.stripe.com/account/onboarding).
1. Remplissez votre [formulaire d’inscription à Stripe Identity](https://dashboard.stripe.com/identity/application).
Les étapes de ce guide sont entièrement implémentées dans notre [application test](https://github.com/stripe/stripe-android/tree/master/identity-example) et notre [exemple de serveur back-end](https://codesandbox.io/p/devbox/compassionate-violet-gshhgf).
## Configurer [Côté serveur] [Côté client]
> Si vous avez l’intention d’utiliser ce SDK avec le service Identity de Stripe, ne modifiez pas le SDK Stripe Identity. En l’absence d’autorisation écrite de Stripe, l’utilisation d’une version modifiée de ce SDK pour le service Stripe Identity constitue une violation de votre contrat avec Stripe et peut entraîner la suspension ou la clôture de votre compte Stripe.
### Installer le SDK (Client-side)
Le [SDK Stripe Android](https://github.com/stripe/stripe-android) est disponible en open source et [fait l’objet d’une documentation complète](https://stripe.dev/stripe-android/).
Pour installer le SDK, ajoutez `identity` au bloc `dependencies` de votre fichier [app/build.gradle](https://developer.android.com/studio/build/dependencies) :
#### Kotlin
```kotlin
plugins {
id("com.android.application")
}
android { ... }
dependencies {
// ...
// Stripe Identity Android SDK
implementation("com.stripe:identity:23.2.0")
}
```
> Pour obtenir de plus amples informations sur la version la plus récente du SDK et ses versions antérieures, consultez la page des [versions](https://github.com/stripe/stripe-android/releases) sur GitHub. Pour savoir quand une nouvelle version est disponible, [surveillez les versions du référentiel](https://docs.github.com/en/github/managing-subscriptions-and-notifications-on-github/configuring-notifications#configuring-your-watch-settings-for-an-individual-repository).
### 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.
#### Groovy
```groovy
dependencies {
// ...
// Stripe Identity Android SDK
implementation('com.stripe:identity:23.2.0') {
exclude group: 'com.stripe', module: 'ml-core-default' // exclude the default TFLite runtime
}
implementation('com.stripe:ml-core-googleplay:23.2.0') // include the Google Play TFLite runtime
}
```
### Configurer le thème du matériel (Client-side)
Le SDK Android Stripe Identity exige que l’activité hôte utilise un [thème Matériel](https://material.io/develop/android/theming/dark).Pour activer le thème matériel :
1. Ouvrez le fichier `app/src/main/AndroidManifest.xml` de votre projet.
1. Assurez-vous que le `android:theme` appliqué à l’`application` est un enfant de l’un des thèmes matériels (par exemple,`Theme.MaterialComponents.DayNight`).
### Installer Stripe sur votre serveur (Server-side)
Pour commencer, [créez un compte](https://dashboard.stripe.com/register) Stripe.
Installez ensuite les bibliothèques permettant d’accéder à l’API Stripe depuis votre application :
#### Ruby
```bash
# Available as a gem
sudo gem install stripe
```
```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```
## Mettre à jour l'endpoint du serveur [Côté serveur]
### Intégration Web existante
Si vous disposiez d’une intégration [modale](https://docs.stripe.com/identity/verify-identity-documents.md?platform=web&type=modal), une [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md) a été créée et une `VerificationSession` [client_secret](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-client_secret) a été transmise à l’objet d’API Stripe.
#### Node.js
```javascript
// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<>');
// 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}}',
},
});
// Return only the client secret to the frontend.
const clientSecret = verificationSession.client_secret;
```
Si vous disposiez d’une intégration de [redirection](https://docs.stripe.com/identity/verify-identity-documents.md?platform=web&type=redirect), une [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md) a été créée et l’[url](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-url) `VerificationSession` a été envoyée à l’application mobile cliente et ouverte dans un navigateur intégré à l’application.
#### Node.js
```javascript
// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<>');
// 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}}',
},
});
// Return only the session URL to the frontend.
const url = verificationSession.url;
```
### Migrer vers l’intégration SDK
Pour utiliser le SDK natif, créez la même [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md) et une clé secrète éphémère.
#### Node.js
```javascript
// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<>');
// 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: '2026-03-25.dahlia'}
);
// Return only the ID and ephemeral key secret to the frontend.
const verificationSessionId = verificationSession.id;
const ephemeralKeySecret = ephemeralKey.secret;
```
Une fois votre `VerificationSession` et votre clé éphémère créées, envoyez l’[ID](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-id) de la `VerificationSession` et la `ephemeral key secret` à l’application mobile du client.
> Vous trouverez une implémentation en cours d’exécution de cet endpoint [disponible ici](https://codesandbox.io/p/devbox/compassionate-violet-gshhgf) pour des tests rapides.
> La clé secrète éphémère permet à votre application de collecter des informations de vérification sensibles. Elle est à usage unique et expire après 1 heure. Ne la stockez pas, ne l’enregistrez pas, ne l’intégrez pas dans des URL et ne la dévoilez à personne d’autre que votre utilisateur. Veillez à ce que le protocole TLS soit activé sur tout endpoint renvoyant la clé secrète éphémère. N’envoyez cette dernière qu’à votre application pour éviter d’exposer la configuration ou les résultats de la vérification.
## Afficher la feuille de vérification [Côté client]
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`
#### Kotlin
```kotlin
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](https://developer.android.com/reference/androidx/activity/result/ActivityResultLauncher) au niveau de ce `AppCompatActivity` ou `Fragment`).
#### Kotlin
```kotlin
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.
#### Kotlin
```kotlin
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.
1. 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.
## Gérer les événements de vérification
[Document checks](https://docs.stripe.com/identity/verification-checks.md#document-availability) 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 :
| Nom de l’événement | Description | Étapes suivantes |
| ---------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [identity.verification_session.verified](https://docs.stripe.com/api/events/types.md#event_types-identity.verification_session.verified) | Le traitement de tous les [contrôles de vérification](https://docs.stripe.com/identity/verification-checks.md) est terminé. La vérification a été effectuée avec succès. | Déclenchez les actions pertinentes dans votre application. |
| [identity.verification_session.requires_input](https://docs.stripe.com/api/events/types.md#event_types-identity.verification_session.requires_input) | Le traitement de tous les [contrôles de vérification](https://docs.stripe.com/identity/verification-checks.md) est terminé, et au moins un des contrôles a échoué. | Déclenchez les actions appropriées dans votre application et autorisez le cas échéant l’utilisateur à effectuer une nouvelle tentative de vérification. |
Utilisez un [gestionnaire de webhook](https://docs.stripe.com/identity/handle-verification-outcomes.md) 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](https://dashboard.stripe.com/events?type=identity.%2A).
## 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é](https://docs.stripe.com/identity/handle-verification-outcomes.md)
### 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](https://dashboard.stripe.com/test/identity/verification-sessions)
> Pour accéder au SDK Identity React Native, rendez-vous sur la page [Paramètres d’identité](https://dashboard.stripe.com/settings/identity) et cliquez sur **Activer**.
Pour vérifier l’identité de vos utilisateurs sur React Native, affichez une feuille de vérification dans votre application. Ce guide comprend les étapes suivantes :
1. Configurez Stripe.
1. Ajouter un endpoint de serveur.
1. Afficher la feuille de vérification.
1. Gérer les événements de vérification.
## Before you begin
1. [Activez votre compte](https://dashboard.stripe.com/account/onboarding).
1. Remplissez votre [formulaire d’inscription à Stripe Identity](https://dashboard.stripe.com/identity/application).
Les étapes de ce guide sont entièrement implémentées dans notre [application test](https://github.com/stripe/stripe-identity-react-native/tree/main/example) et notre [exemple de serveur back-end](https://codesandbox.io/p/devbox/compassionate-violet-gshhgf).
## Configurer [Côté serveur] [Côté client]
### Installer le SDK (Client-side)
Le [SDK React Native](https://github.com/stripe/stripe-identity-react-native) est open source, [possède une documentation complète](https://stripe.dev/stripe-identity-react-native) et est compatible avec les apps prenant en charge iOS 13.0 ou Android 5.0 (API level 21) et versions ultérieures. En interne, il utilise les SDK natifs [iOS](https://github.com/stripe/stripe-ios/tree/master/StripeIdentity) et [Android](https://github.com/stripe/stripe-android/tree/master/identity).
Pour installer le SDK, exécutez :
#### Yarn
```bash
yarn add @stripe/stripe-identity-react-native
```
> Pour plus de détails sur la version la plus récente du SDK et ses versions antérieures, consultez la page [Releases](https://github.com/stripe/stripe-identity-react-native/releases) sur GitHub. Pour recevoir une notification lors de la diffusion d’une nouvelle version, [suivez les versions du référentiel](https://help.github.com/en/articles/watching-and-unwatching-releases-for-a-repository#watching-releases-for-a-repository).
Pour iOS, exécutez `pod install` dans le répertoire `ios` pour vous assurer d’installer également les dépendances natives. Android ne nécessite aucune action supplémentaire.
### Configurer l’autorisation d’accès à l’appareil photo pour iOS (Client-side)
Le SDK iOS de Stripe Identity doit pouvoir accéder à l’appareil photo de l’appareil pour capturer des pièces d’identité. Pour permettre à votre application de demander des autorisations d’accès à l’appareil photo :
1. Ouvrez le fichier **Info.plist** de votre projet dans Xcode.
1. Ajoutez la clé `NSCameraUsageDescription`.
1. Ajoutez une valeur de chaîne qui explique à vos utilisateurs pourquoi votre application nécessite des autorisations de caméra, par exemple :
> Cette application utilise l’appareil photo pour prendre une photo de vos documents d’identité.
Consultez la [documentation d’Apple](https://developer.apple.com/documentation/avfoundation/cameras_and_media_capture/requesting_authorization_for_media_capture_on_ios) pour en savoir plus sur la demande d’accès à l’appareil photo.
### Configurer le thème du matériel pour Android (Client-side)
Le SDK Android Stripe Identity exige que l’activité hôte utilise un [thème Matériel](https://material.io/develop/android/theming/dark).Pour activer le thème matériel :
1. Ouvrez le fichier `app/src/main/AndroidManifest.xml` de votre projet.
1. Assurez-vous que le `android:theme` appliqué à l’`application` est un enfant de l’un des thèmes matériels (par exemple,`Theme.MaterialComponents.DayNight`).
### Installer Stripe sur votre serveur (Server-side)
Pour commencer, [créez un compte](https://dashboard.stripe.com/register) Stripe.
Installez ensuite les bibliothèques permettant d’accéder à l’API Stripe depuis votre application :
#### Ruby
```bash
# Available as a gem
sudo gem install stripe
```
```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```
## Ajouter un endpoint de serveur [Côté serveur]
### Créer une VerificationSession
Une [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md) est une représentation programmatique de la vérification. Elle contient des détails concernant le type de vérification, comme les [contrôles](https://docs.stripe.com/identity/verification-checks.md) à effectuer. Vous pouvez [développer](https://docs.stripe.com/api/expanding_objects.md) le champ des [résultats vérifiés](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-verified_outputs) pour afficher les données qui ont été contrôlées.
Vous pouvez utiliser les flux de vérification pour une configuration réutilisable qui est transmise au paramètre [verification_flow](https://docs.stripe.com/api/identity/verification_sessions/create.md#create_identity_verification_session-verification_flow). Pour en savoir plus, consultez le [guide des flux de vérification](https://docs.stripe.com/identity/verification-flows.md).
Vous avez besoin d’un endpoint côté serveur pour [créer la VerificationSession](https://docs.stripe.com/api/identity/verification_sessions/create.md). 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. À la place, votre serveur fournit au SDK une clé éphémère, c’est-à-dire une clé API à durée de vie limitée avec un accès restreint à [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md). Vous pouvez considérer une clé éphémère comme une session qui autorise le SDK à récupérer et à mettre à jour un objet `VerificationSession` spécifique pendant la durée de la session.
Une fois votre `VerificationSession` et votre clé éphémère créées, envoyez l’[ID](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-id) de la `VerificationSession` et la clé secrète éphémère au client pour afficher la feuille de chargement de documents.
> Vous trouverez une implémentation en cours d’exécution de cet endpoint [disponible ici](https://codesandbox.io/p/devbox/compassionate-violet-gshhgf) pour des tests rapides.
#### Node.js
```javascript
// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<>');
// 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: '2026-03-25.dahlia'}
);
// Return only the ID and ephemeral key secret to the frontend.
const verificationSessionId = verificationSession.id;
const ephemeralKeySecret = ephemeralKey.secret;
```
> La clé secrète éphémère est liée à la session `VerificationSession` et permet à votre application de collecter des données de vérification sensibles, telles que des fichiers contenant des pièces d’identité et images de selfie. Elle est à usage unique et expire au bout d’une heure. Ne la stockez pas, ne l’enregistrez pas, ne l’intégrez pas dans des URL et ne la dévoilez à personne d’autre que votre utilisateur. Veillez à ce que le protocole TLS soit activé sur tout endpoint renvoyant la clé secrète éphémère. Envoyez celle-ci uniquement à votre application pour éviter de dévoiler la configuration ou les résultats de la vérification.
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 :
```bash
curl -X POST -is "http://localhost:4242/create-verification-session" -d ""
```
La réponse doit ressembler à ceci sur votre terminal :
```bash
HTTP/1.1 200 OK
Content-Type: application/json
{ id: "vs_QdfQQ6xfGNJR7ogV6", ephemeral_key_secret: "ek_YWNjdF8xRm..." }
```
## Afficher la feuille de vérification [Côté client]
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 un composant Button :
```javascript
import React from 'react';
import {
View,
Button,
} from 'react-native';
function VerifyScreen() {
return (
);
}
```
### Importer le SDK Stripe Identity
Importer le hook `useStripeIdentity` :
```javascript
import React from 'react';
import {
View,
Button,
} from 'react-native';import { useStripeIdentity } from "@stripe/stripe-identity-react-native";
function VerifyScreen() {
return (
);
}
```
### Ajouter un gestionnaire d’événements 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 le hook `useStripeIdentity` en transmettant `fetchOptions` avec le logo de votre marque et affichez-le à l’utilisateur.
- Gérez le `status` afin de savoir si l’utilisateur a exécuté le flux de vérification.
```javascript
import React from 'react';
import {
View,
Button,Text,
Image
} from 'react-native';
import { useStripeIdentity } from "@stripe/stripe-identity-react-native";
// A square logo for your brand
import logo from './assets/{{YOUR_BRAND_LOGO}}.png';
function VerifyScreen() {const fetchVerificationSessionParams = async () => {
try {
const data = await fetch(`${YOUR_SERVER_BASE_URL}/create-verification-session`, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
});
const json = await data.json();
return json;
} catch (e) {
return {};
}
};
const fetchOptions = async () => {
const response = await fetchVerificationSessionParams();
return {
sessionId: response.id,
ephemeralKeySecret: response.ephemeral_key_secret,
brandLogo: Image.resolveAssetSource(logo),
};
};
const { status, present, loading } = useStripeIdentity(fetchOptions);
const handlePress = React.useCallback(() => {
present();
}, [present]);
return (
Status: {status}
);
}
```
### 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.
1. 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.
## Gérer les événements de vérification
[Document checks](https://docs.stripe.com/identity/verification-checks.md#document-availability) 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 :
| Nom de l’événement | Description | Étapes suivantes |
| ---------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [identity.verification_session.verified](https://docs.stripe.com/api/events/types.md#event_types-identity.verification_session.verified) | Le traitement de tous les [contrôles de vérification](https://docs.stripe.com/identity/verification-checks.md) est terminé. La vérification a été effectuée avec succès. | Déclenchez les actions pertinentes dans votre application. |
| [identity.verification_session.requires_input](https://docs.stripe.com/api/events/types.md#event_types-identity.verification_session.requires_input) | Le traitement de tous les [contrôles de vérification](https://docs.stripe.com/identity/verification-checks.md) est terminé, et au moins un des contrôles a échoué. | Déclenchez les actions appropriées dans votre application et autorisez le cas échéant l’utilisateur à effectuer une nouvelle tentative de vérification. |
Utilisez un [gestionnaire de webhook](https://docs.stripe.com/identity/handle-verification-outcomes.md) 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](https://dashboard.stripe.com/events?type=identity.%2A).
## 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é](https://docs.stripe.com/identity/handle-verification-outcomes.md)
### 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](https://dashboard.stripe.com/test/identity/verification-sessions)
> Pour accéder au SDK Identity React Native, rendez-vous sur la page [Paramètres d’identité](https://dashboard.stripe.com/settings/identity) et cliquez sur **Activer**.
Ce guide explique comment migrer une intégration Stripe Identity depuis le SDK de [redirection Web](https://docs.stripe.com/identity/verify-identity-documents.md?platform=web&type=redirect) vers le SDK React Native natif pour votre application mobile. Ce guide comprend les étapes suivantes :
1. Configurez Stripe.
1. Mettez à jour votre endpoint de serveur.
1. Afficher la feuille de vérification.
1. Gérer les événements de vérification.
## Before you begin
1. [Activez votre compte](https://dashboard.stripe.com/account/onboarding).
1. Remplissez votre [formulaire d’inscription à Stripe Identity](https://dashboard.stripe.com/identity/application).
Les étapes de ce guide sont entièrement implémentées dans notre [application test](https://github.com/stripe/stripe-identity-react-native/tree/main/example) et notre [exemple de serveur back-end](https://codesandbox.io/p/devbox/compassionate-violet-gshhgf).
## Configurer [Côté serveur] [Côté client]
### Installer le SDK (Client-side)
Le [SDK React Native](https://github.com/stripe/stripe-identity-react-native) est open source, [possède une documentation complète](https://stripe.dev/stripe-identity-react-native) et est compatible avec les apps prenant en charge iOS 13.0 ou Android 5.0 (API level 21) et versions ultérieures. En interne, il utilise les SDK natifs [iOS](https://github.com/stripe/stripe-ios/tree/master/StripeIdentity) et [Android](https://github.com/stripe/stripe-android/tree/master/identity).
Pour installer le SDK, exécutez :
#### Yarn
```bash
yarn add @stripe/stripe-identity-react-native
```
> Pour plus de détails sur la version la plus récente du SDK et ses versions antérieures, consultez la page [Releases](https://github.com/stripe/stripe-identity-react-native/releases) sur GitHub. Pour recevoir une notification lors de la diffusion d’une nouvelle version, [suivez les versions du référentiel](https://help.github.com/en/articles/watching-and-unwatching-releases-for-a-repository#watching-releases-for-a-repository).
Pour iOS, exécutez `pod install` dans le répertoire `ios` pour vous assurer d’installer également les dépendances natives. Android ne nécessite aucune action supplémentaire.
### Configurer l’autorisation d’accès à l’appareil photo pour iOS (Client-side)
Le SDK iOS de Stripe Identity doit pouvoir accéder à l’appareil photo de l’appareil pour capturer des pièces d’identité. Pour permettre à votre application de demander des autorisations d’accès à l’appareil photo :
1. Ouvrez le fichier **Info.plist** de votre projet dans Xcode.
1. Ajoutez la clé `NSCameraUsageDescription`.
1. Ajoutez une valeur de chaîne qui explique à vos utilisateurs pourquoi votre application nécessite des autorisations de caméra, par exemple :
> Cette application utilise l’appareil photo pour prendre une photo de vos documents d’identité.
Consultez la [documentation d’Apple](https://developer.apple.com/documentation/avfoundation/cameras_and_media_capture/requesting_authorization_for_media_capture_on_ios) pour en savoir plus sur la demande d’accès à l’appareil photo.
### Configurer le thème du matériel pour Android (Client-side)
Le SDK Android Stripe Identity exige que l’activité hôte utilise un [thème Matériel](https://material.io/develop/android/theming/dark).Pour activer le thème matériel :
1. Ouvrez le fichier `app/src/main/AndroidManifest.xml` de votre projet.
1. Assurez-vous que le `android:theme` appliqué à l’`application` est un enfant de l’un des thèmes matériels (par exemple,`Theme.MaterialComponents.DayNight`).
### Installer Stripe sur votre serveur (Server-side)
Pour commencer, [créez un compte](https://dashboard.stripe.com/register) Stripe.
Installez ensuite les bibliothèques permettant d’accéder à l’API Stripe depuis votre application :
#### Ruby
```bash
# Available as a gem
sudo gem install stripe
```
```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```
## Mettre à jour l'endpoint du serveur [Côté serveur]
### Intégration Web existante
Si vous disposiez d’une intégration [modale](https://docs.stripe.com/identity/verify-identity-documents.md?platform=web&type=modal), une [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md) a été créée et une `VerificationSession` [client_secret](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-client_secret) a été transmise à l’objet d’API Stripe.
#### Node.js
```javascript
// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<>');
// 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}}',
},
});
// Return only the client secret to the frontend.
const clientSecret = verificationSession.client_secret;
```
Si vous disposiez d’une intégration de [redirection](https://docs.stripe.com/identity/verify-identity-documents.md?platform=web&type=redirect), une [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md) a été créée et l’[url](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-url) `VerificationSession` a été envoyée à l’application mobile cliente et ouverte dans un navigateur intégré à l’application.
#### Node.js
```javascript
// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<>');
// 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}}',
},
});
// Return only the session URL to the frontend.
const url = verificationSession.url;
```
### Migrer vers l’intégration SDK
Pour utiliser le SDK natif, créez la même [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md) et une clé secrète éphémère.
#### Node.js
```javascript
// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<>');
// 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: '2026-03-25.dahlia'}
);
// Return only the ID and ephemeral key secret to the frontend.
const verificationSessionId = verificationSession.id;
const ephemeralKeySecret = ephemeralKey.secret;
```
Une fois votre `VerificationSession` et votre clé éphémère créées, envoyez l’[ID](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-id) de la `VerificationSession` et la `ephemeral key secret` à l’application mobile du client.
> Vous trouverez une implémentation en cours d’exécution de cet endpoint [disponible ici](https://codesandbox.io/p/devbox/compassionate-violet-gshhgf) pour des tests rapides.
> La clé secrète éphémère permet à votre application de collecter des informations de vérification sensibles. Elle est à usage unique et expire après 1 heure. Ne la stockez pas, ne l’enregistrez pas, ne l’intégrez pas dans des URL et ne la dévoilez à personne d’autre que votre utilisateur. Veillez à ce que le protocole TLS soit activé sur tout endpoint renvoyant la clé secrète éphémère. N’envoyez cette dernière qu’à votre application pour éviter d’exposer la configuration ou les résultats de la vérification.
## Afficher la feuille de vérification [Côté client]
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 un composant Button :
```javascript
import React from 'react';
import {
View,
Button,
} from 'react-native';
function VerifyScreen() {
return (
);
}
```
### Importer le SDK Stripe Identity
Importer le hook `useStripeIdentity` :
```javascript
import React from 'react';
import {
View,
Button,
} from 'react-native';import { useStripeIdentity } from "@stripe/stripe-identity-react-native";
function VerifyScreen() {
return (
);
}
```
### Ajouter un gestionnaire d’événements 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 le hook `useStripeIdentity` en transmettant `fetchOptions` avec le logo de votre marque et affichez-le à l’utilisateur.
- Gérez le `status` afin de savoir si l’utilisateur a exécuté le flux de vérification.
```javascript
import React from 'react';
import {
View,
Button,Text,
Image
} from 'react-native';
import { useStripeIdentity } from "@stripe/stripe-identity-react-native";
// A square logo for your brand
import logo from './assets/{{YOUR_BRAND_LOGO}}.png';
function VerifyScreen() {const fetchVerificationSessionParams = async () => {
try {
const data = await fetch(`${YOUR_SERVER_BASE_URL}/create-verification-session`, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
});
const json = await data.json();
return json;
} catch (e) {
return {};
}
};
const fetchOptions = async () => {
const response = await fetchVerificationSessionParams();
return {
sessionId: response.id,
ephemeralKeySecret: response.ephemeral_key_secret,
brandLogo: Image.resolveAssetSource(logo),
};
};
const { status, present, loading } = useStripeIdentity(fetchOptions);
const handlePress = React.useCallback(() => {
present();
}, [present]);
return (
Status: {status}
);
}
```
### 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.
1. 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.
## Gérer les événements de vérification
[Document checks](https://docs.stripe.com/identity/verification-checks.md#document-availability) 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 :
| Nom de l’événement | Description | Étapes suivantes |
| ---------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [identity.verification_session.verified](https://docs.stripe.com/api/events/types.md#event_types-identity.verification_session.verified) | Le traitement de tous les [contrôles de vérification](https://docs.stripe.com/identity/verification-checks.md) est terminé. La vérification a été effectuée avec succès. | Déclenchez les actions pertinentes dans votre application. |
| [identity.verification_session.requires_input](https://docs.stripe.com/api/events/types.md#event_types-identity.verification_session.requires_input) | Le traitement de tous les [contrôles de vérification](https://docs.stripe.com/identity/verification-checks.md) est terminé, et au moins un des contrôles a échoué. | Déclenchez les actions appropriées dans votre application et autorisez le cas échéant l’utilisateur à effectuer une nouvelle tentative de vérification. |
Utilisez un [gestionnaire de webhook](https://docs.stripe.com/identity/handle-verification-outcomes.md) 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](https://dashboard.stripe.com/events?type=identity.%2A).
## 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é](https://docs.stripe.com/identity/handle-verification-outcomes.md)
### 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](https://dashboard.stripe.com/test/identity/verification-sessions)
Le Dashboard est le moyen le plus souvent utilisé pour créer des vérifications ponctuelles, mais vous pouvez également automatiser ce processus en vous intégrant à l’API. Voici ce que vous devez effectuer :
1. Créer une VerificationSession avec le Dashboard.
1. Partagez le lien de vérification avec votre utilisateur.
1. Visualiser les résultats de vérification dans le Dashboard.
## Before you begin
1. [Activez votre compte](https://dashboard.stripe.com/account/onboarding).
1. Remplissez votre [formulaire d’inscription à Stripe Identity](https://dashboard.stripe.com/identity/application).
1. (Facultatif) Personnalisez les paramètres de votre marque sur la [page Paramètres de marque](https://dashboard.stripe.com/settings/branding).
## Créer une VerificationSession [Dashboard]
Une [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md) est une représentation programmatique de la vérification. Elle contient des détails concernant le type de vérification, comme les [contrôles](https://docs.stripe.com/identity/verification-checks.md) à effectuer et expose les [résultats vérifiés](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-verified_outputs).
Pour créer une VerificationSession dans le Dashboard Stripe :
1. Rendez-vous sur la page [Créer une page de session](https://dashboard.stripe.com/identity/verification-sessions/create).
1. Sélectionnez **Vérification à l’aide d’un document**.
1. Cliquez sur **Créer**.
## Partager le lien de vérification avec votre utilisateur. [Dashboard]
1. Cliquez sur **Copier le lien de vérification**.
1. Partagez l’URL copiée avec votre utilisateur.
Les liens de vérification expirent 48 heures après création et sont à usage unique. Partagez le lien uniquement avec l’utilisateur que vous voulez vérifier. Nous vous déconseillons l’envoi de liens de vérification par e-mail ou par SMS.
## Visualiser les résultats de vérification [Dashboard]
Les [vérifications de documents](https://docs.stripe.com/identity/verification-checks.md#document-availability) sont généralement terminées lorsque l’utilisateur est redirigé vers votre site, et vous pouvez récupérer le résultat de l’API immédiatement. Dans certains cas rares, la vérification du document n’est pas encore prête et doit se poursuivre de manière asynchrone. Dans ce cas, vous recevez des notifications des webhooks lorsque le résultat de la vérification est prêt. Une fois le traitement terminé, le statut de la VerificationSession passe de `processing` à `verified`.
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](https://dashboard.stripe.com/test/identity/verification-sessions)
## Before you begin
1. [Activez votre compte](https://dashboard.stripe.com/account/onboarding).
1. Remplissez votre [formulaire d’inscription à Stripe Identity](https://dashboard.stripe.com/identity/application).
1. (Facultatif) Personnalisez les paramètres de votre marque sur la [page Paramètres de marque](https://dashboard.stripe.com/settings/branding).
## Créer un flux de vérification [Dashboard]
Un [flux](https://docs.stripe.com/identity/verification-flows.md) représente une configuration réutilisable pour les vérifications que vous demanderez à votre utilisateur.
Pour créer un flux dans le Dashboard :
1. Accédez à la page [Flux de vérification](https://dashboard.stripe.com/identity/verification-flows?create=true) de votre Dashboard.
1. Remplissez le formulaire avec la configuration souhaitée et cliquez sur **Enregistrer**. Vous pourrez personnaliser le flux ultérieurement.
## Partager le lien statique avec votre utilisateur [Dashboard]
1. Sur la page des détails du flux, cliquez sur l’URL pour la copier dans votre presse-papiers.
1. Partagez l’URL copiée avec votre utilisateur.
Cette URL n’expire jamais et peut être utilisée pour vérifier autant d’utilisateurs que nécessaire, tant que le flux reste activé. Pour désactiver un flux, accédez à la page des détails de ce flux. Partagez le lien uniquement avec les utilisateurs que vous souhaitez vérifier.
## Visualiser les résultats de vérification [Dashboard]
When your user completes verification, a verification session is created to hold the results and you can see it in your Dashboard. [Document checks](https://docs.stripe.com/identity/verification-checks.md#document-availability) are asynchronous, which means that verification results aren’t immediately available. An identity document check typically takes 1 to 3 minutes to complete. After the processing completes, the verification session’s status changes from `processing` to `verified`.
Utilisez le Dashboard pour consulter toutes vos vérifications, inspecter les données collectées et comprendre les échecs de vérification.
## See also
- [Flux de vérification](https://docs.stripe.com/identity/verification-flows.md)