Gérez les évolutions des exigences de vérification

Pour que vos comptes connectés puissent accepter des paiements et effectuer des virements, vous devez répondre à ce que l’on appelle communément les exigences Know Your Client (KYC). Pour ce faire, vous devez collecter certaines informations concernant vos comptes connectés et les envoyer à Stripe pour vérification.

Stripe met régulièrement à jour les exigences KYC, souvent à la suite de changements apportés par les organismes de réglementation financière, les réseaux de cartes ou d’autres institutions financières.

Ces mises à jour peuvent vous obliger à prendre les mesures suivantes :

1. Modifiez votre processus d’inscription des utilisateurs pour tenir compte des nouvelles exigences.
2. Collectez des informations à jour auprès de vos comptes connectés concernés et gérez les réponses de vérification.
3. Traitez les exigences liées au risque en notifiant les comptes connectés des problèmes identifiés, pour leur montrer comment les résoudre via les interfaces Stripe.

Lorsque vos comptes connectés seront concernés par de futures mises à jour des exigences, nous vous en informerons.

Identifier les exigences à venir

Lorsque Stripe est responsable de la collecte des exigences (controller.requirement_collection est défini sur stripe), Stripe gère automatiquement les changements d’exigences à venir pour vos comptes connectés. Dans ce cas, la suite de ce document ne s’applique pas à votre plateforme.

Si la plateforme est responsable de la collecte des exigences (requirement_collection est défini sur application), vous devez gérer vous-même les changements liés aux exigences à venir. Stripe fait apparaître ces changements via le hachage future_requirements, et la manière dont vous les traitez dépend du type d’intégration de votre processus d’onboarding, comme expliqué ci-dessous.

Les exigences à venir apparaissent dans le hachage future_requirements des objets Account et Capability. Elles n’apparaissent pas dans le hachage requirements et n’affectent aucune fonctionnalité.

Lorsqu’une exigence à venir prend effet, elle passe du hachage future_requirements au hachage requirements et peut affecter les fonctionnalités du compte. Cela peut empêcher le compte de mener des transactions tant que vous ne répondez pas aux exigences. L’horodatage future_requirements.current_deadline représente le moment où les entrées dans future_requirements passeront à la valeur requirements.

Collecter les exigences futures

Si vous n’avez pas encore intégré Stripe, configurez votre intégration en utilisant le guide de conception d’une intégration avant de continuer.

La manière dont vous collecterez les exigences futures dépend du type d’intégration de votre processus d’onboarding. Lorsque les exigences actuelles ou à venir changent, Stripe met automatiquement à jour les flux d’onboarding hébergés et intégrés par Stripe, tandis que les flux établis par l’API vous obligent à les mettre à jour manuellement.

Si vous utilisez l’onboarding hébergé par Stripe ou intégré, vous pouvez collecter les informations requises en créant et en partageant des liens de rectification.

Intégrer les exigences futures

Si vous utilisez l’onboarding hébergé par Stripe ou intégré, les changements d’exigences ne vous obligent pas à mettre à jour votre flux d’onboarding. Passez à la section consacrée à l’écoute des mises à jour.

Onboarding basé sur les API

Si vous utilisez un flux d’onboarding personnalisé basé sur un API, vous devez le mettre à jour pour gérer toute modification des exigences. Vous pouvez également envisager de remplacer votre flux d’onboarding basé sur un API par des composants intégrés ou un onboarding hébergé par Stripe.

Prévisualisez les nouvelles exigences de vérification

Lorsque les exigences de vérification évoluent, vous devez collecter les informations mises à jour avant une certaine date limite. Le non-respect des nouvelles exigences pour un compte connecté peut entraîner la désactivation d’une ou plusieurs fonctionnalités de ce compte. Consultez le détail des informations que vous devez collecter en fonction de la région du compte, des fonctionnalités demandées et d’autres facteurs.

Vous pouvez trouver en avance des informations sur les modifications à venir concernant les exigences en examinant le hachage future_requirements de l’objet Account. Pour éviter toute interruption des fonctionnalités de vos comptes connectés, collectez les informations relatives aux exigences futures avant la date future_requirements.current_deadline, date à laquelle elles passent au hachage requirements.

Vous trouverez également les comptes ayant des exigences en attente sur la page Comptes connectés de votre Dashboard, où vous pouvez les filtrer par problème et état de compte.

Si vos comptes connectés n’ont pas encore mis à jour les exigences dans future_requirements ou si vous souhaitez tester différentes configurations, vous pouvez utiliser le formulaire sur la page d’information des vérifications requises. Vous pouvez également créer des comptes de test.

{
  "id": 
"{{CONNECTED_ACCOUNT_ID}}",
  "object": "account",
  "future_requirements": {
    "current_deadline": 1656608400,
    "currently_due": [
      "company.tax_id"
    ],
    "disabled_reason": null,
    "errors": [],
    "eventually_due": [
      "company.tax_id"
    ],
    "past_due": [],
    "pending_verification": []
  },
  ...
}

Ajoutez des champs obligatoires à votre flux d’inscription

Lorsque vous avez identifié les informations à jour que vous devez collecter, déterminez s’il convient de les ajouter à votre flux d’inscription. Par exemple, si la mise à jour est une nouvelle exigence qui s’applique toujours à une fonctionnalité et que votre flux d’inscription demande cette fonctionnalité, votre flux doit collecter cette information.

Sinon, si la mise à jour modifie une exigence parce qu’un compte a atteint un seuil, tenez compte de la fréquence à laquelle vos comptes atteignent ce seuil. Si cette fréquence n’est pas élevée, votre flux d’inscription n’a pas besoin d’exiger que chaque nouveau compte connecté fournisse cette information.

Pour vous préparer aux exigences qui s’appliquent lorsqu’un compte atteint un seuil, examinez le tableau future_requirements.eventually_due.

Mettez à jour votre formulaire d’onboarding pour collecter les nouveaux champs, puis envoyez-les à l’aide de l’API Accounts ou Persons.

Testez votre flux d’inscription mis à jour

Pour simuler des exigences de vérification futures, créez un compte de test à l’aide de l’API Accounts et définissez son paramètre email sur enforce_future_requirements. Cela renseigne le hachage requirements du compte avec toutes les futures exigences de vérification connues.

curl https://api.stripe.com/v1/accounts \
  -u "
sk_test_VePHdqKTYQjKNInc7u56JBrQ
:" \
  -d "controller[stripe_dashboard][type]=none" \
  -d "controller[fees][payer]=application" \
  -d "controller[losses][payments]=application" \
  -d "controller[requirement_collection]=application" \
  -d country=US \
  -d business_type=individual \
  -d "capabilities[card_payments][requested]=true" \
  -d "capabilities[transfers][requested]=true" \
  --data-urlencode "email=jenny.rosen+enforce_future_requirements@example.com"

Pour vérifier que votre flux d’inscription mis à jour répond aux exigences du compte, inscrivez le compte de test et vérifiez son hachage requirements. Si votre flux couvre toutes les exigences, la liste currently_due est vide. Consultez le guide de test pour trouver des outils additionnels vous permettant de simuler des états de compte spécifiques.

Vérifier les exigences futures soumises

Après avoir soumis les informations requises, vérifiez si l’exigence figure toujours dans le hachage future_requirements.entries. Si elle n’y figure pas, l’exigence a été satisfaite.

Si l’exigence est toujours présente dans future_requirements, vérifiez dans le tableau future_requirements.errors qu’une entrée présente une propriété requirement correspondant au nom de l’exigence. Cette erreur peut contenir des informations sur la raison pour laquelle l’exigence n’est pas satisfaite.

Si l’exigence ne comporte aucune erreur correspondante, examinez le tableau future_requirements.pending_verification. Si elle inclut l’exigence, Stripe traite toujours les informations. Vérifiez le tableau de nouveau ultérieurement.

Lorsque Stripe reçoit des informations mises à jour, nous avons besoin de temps pour vérifier qu’elles répondent aux exigences associées. Tant que la vérification n’est pas terminée, partez du principe que toute fonctionnalité associée reste désactivée. Pour détecter les mises à jour de vérification, écoutez les événements account.updated et inspectez-les à la recherche d’erreurs de vérification. Le hachage requirements d’une fonctionnalité désactivée contient une valeur disabled_reason que vous pouvez utiliser pour déterminer l’action que vous devez effectuer.

Si la validation d’une soumission échoue, des erreurs s’affichent dans future_requirements.errors :

{
  "future_requirements": {
    "currently_due": ["company.tax_id"],
    "errors": [
      {
        "code": "invalid_tax_id_format",
        "requirement": "company.tax_id",
        "reason": "Tax IDs must be a unique set of 9 numbers without dashes or other special characters."
      }
    ]
  }
}

Assurez-vous que votre intégration analyse le tableau des erreurs, affiche les messages d’erreur pertinents à vos comptes connectés et leur permet de corriger et de soumettre à nouveau les informations. Consultez le guide de test pour trouver un ensemble complet d’outils de test.

Écouter les mises à jour du compte

Détectez les changements d’état compte en écoutant l’événement account.updated. Lorsque les exigences actives ou futures changent, l’événement inclut l’objet de mise à jour du compte. Pour surveiller les exigences futures, assurez-vous que votre gestionnaire de webhook analyse correctement future_requirements à partir de la charge utile :

{
  "type": "account.updated",
  "data": {
    "object": {
      "id": 
"{{CONNECTED_ACCOUNT_ID}}",
      "future_requirements": {
        "currently_due": ["company.tax_id"],
        "past_due": ["company.tax_id"]
      }
    }
  }
}

Une fois qu’un compte a suivi votre flux d’onboarding, inspectez les tableaux currently_due et pending_verification dans le hachage future_requirements du compte. Lorsque les deux sont vides, et que future_requirements.disabled_reason est nul, le compte est conforme à toutes les exigences futures applicables.

Considérations relatives à la version API

Dans la version de l’API 2023-10-16 et les versions ultérieures, le tableau requirements.errors de l’objet Account spécifie tout type d’erreurs de vérification dans l’attribut code. Si vous utilisez une version antérieure de l’API, nous vous recommandons fortement de mettre à niveau vers la dernière version de l’API et d’utiliser requirements.errors.

Si vous ne pouvez pas effectuer la mise à jour vers la version 2023-10-16, les versions antérieures du tableau requirements.errors incluent un champ detailed_code pour conserver les erreurs de vérification non compatibles avec l’attribut code. L’attribut detailed_code n’apparaît pas dans la documentation de l’API.

Si vous utilisez des liens de compte ou de rectification pour collecter les nouvelles informations exigées, utilisez la version de l’API datée du 07/09/2021 ou une version ultérieure.

Si vous recevez des événements account.updated. Définissez la version de l’API des webhooks sur 2021-09-07 ou une version ultérieure.

Liste de préparation

Utilisez cette liste de contrôle pour vous assurer que votre intégration est prête pour les changements d’exigences à venir :

• Récupérez les comptes et confirmez que vous pouvez lire future_requirements
• Identifiez les nouvelles chaînes d’exigences et comprenez quelles informations collecter
• Mettez à jour les formulaires d’onboarding pour collecter les nouveaux champs obligatoires (onboarding basé sur un API uniquement)
• Soumettez des données de test et vérifiez que les exigences sont clairement définies dans future_requirements
• Gérez les erreurs en testant les soumissions non valides et en vérifiant la gestion des erreurs
• Traitez les webhooks pour les événements account.updated avec les modifications future_requirements
• Testez plusieurs comptes pour assurer la cohérence entre les différents types d’entreprises