# Configurer un abonnement par prélèvement automatique ACH Comment créer un abonnement et débiter votre client avec un compte bancaire américain. Suivez ce guide pour configurer un *abonnement* (A Subscription represents the product details associated with the plan that your customer subscribes to. Allows you to charge the customer on a recurring basis) avec le [prélèvement automatique ACH](https://docs.stripe.com/payments/ach-direct-debit.md). # Intégration avancée > This is a Intégration avancée for when platform is web and payment-ui is elements. View the full page at https://docs.stripe.com/billing/subscriptions/ach-debit?platform=web&payment-ui=elements. > Contrairement à ce qui est indiqué dans ce guide, nous recommandons aux nouveaux utilisateurs d’utiliser le composant [Payment Element](https://docs.stripe.com/payments/payment-element.md) plutôt que Stripe Elements. Le composant Payment Element propose un chemin d’intégration avec peu de code et des optimisations de conversion intégrées. Pour connaître la procédure à suivre, consultez la documentation consacrée à la [création d’un abonnement](https://docs.stripe.com/billing/subscriptions/build-subscriptions.md?payment-ui=elements). ## Créer un produit et un tarif [Dashboard] Les [produits](https://docs.stripe.com/api/products.md) correspondent aux articles ou services que vous vendez. Les [tarifs](https://docs.stripe.com/api/prices.md) définissent le montant et la fréquence des paiements facturés pour un produit. Le tarif prend en compte la valeur du produit, la devise que vous acceptez et s’il s’agit d’un paiement ponctuel ou récurrent. Si vous n’avez que quelques produits et tarifs, créez-les et gérez-les dans le Dashboard. Ce guide prend comme exemple un service de banque d’images qui débite ses clients d’un montant de 15 USD pour un abonnement mensuel. Pour modéliser ceci : 1. Go to the [Products](https://dashboard.stripe.com/products?active=true) page and click **Create product**. 1. Saisissez un **Nom** pour le produit. Vous pouvez éventuellement ajouter une **Description** et télécharger une image du produit. 1. Select a **Product tax code**. Learn more about [product tax codes](https://docs.stripe.com/tax/tax-codes.md). 1. Sélectionnez **Récurrent**. Saisissez ensuite **** pour le prix et sélectionnez **** comme devise. 1. Choose whether to **Include tax in price**. You can either use the default value from your [tax settings](https://dashboard.stripe.com/test/settings/tax) or set the value manually. In this example, select **Auto**. 1. Pour **Période de facturation**, sélectionnez **Mensuel**. 1. Click **More pricing options**. Then select **Flat rate** as the pricing model for this example. Learn more about [flat rate](https://docs.stripe.com/products-prices/pricing-models.md#flat-rate) and other [pricing models](https://docs.stripe.com/products-prices/pricing-models.md). 1. Add an internal **Price description** and [Lookup key](https://docs.stripe.com/products-prices/manage-prices.md#lookup-keys) to organize, query, and update specific prices in the future. 1. Cliquez sur **Suivant**. Cliquez ensuite sur **Ajouter un produit**. Après avoir créé le produit et le tarif, enregistrez l’ID de tarif de manière à pouvoir l’utiliser dans les étapes ultérieures. La page des tarifs affiche l’ID dont le format est similaire à ce qui suit : `price_G0FvDp6vZvdwRZ`. ## Créer l'abonnement [Côté serveur] > Pour créer un *abonnement* (A Subscription represents the product details associated with the plan that your customer subscribes to. Allows you to charge the customer on a recurring basis) avec une période d’essai gratuite, consultez la documentation relative aux [périodes d’essai des abonnements](https://docs.stripe.com/billing/subscriptions/ach-debit.md#trial-periods). Créez un [abonnement](https://docs.stripe.com/api/subscriptions.md) avec le tarif et le client à l’état `incomplete` en fournissant le paramètre [payment_behavior](https://docs.stripe.com/api/subscriptions/create.md#create_subscription-payment_behavior) défini sur la valeur `default_incomplete`. #### curl ```bash curl https://api.stripe.com/v1/subscriptions \ -u <>: \ -d "customer"="{{CUSTOMER_ID}}" \ -d "items[0][price]"="price_F52b2UdntfQsfR" \ -d "payment_behavior"="default_incomplete" \ -d "payment_settings[payment_method_types][]"="us_bank_account" \ -d "expand[0]"="latest_invoice.payment_intent" ``` La réponse inclut la première [facture](https://docs.stripe.com/api/invoices.md) de l’*abonnement* (A Subscription represents the product details associated with the plan that your customer subscribes to. Allows you to charge the customer on a recurring basis). Celui-ci contient les paiements de la facture, qui inclut un PaymentIntent par défaut que Stripe a généré pour cette facture et la clé secrète de confirmation que vous pouvez envoyer au client afin qu’il finalise le processus de paiement en toute sécurité au lieu de lui transmettre la totalité de l’objet PaymentIntent. Renvoyez le `latest_invoice.confirmation_secret.client_secret` au front-end pour finaliser le paiement. ## Collecter les informations du moyen de paiement [Côté client] Lorsqu’un client clique pour payer avec ACH Direct Debit, nous vous recommandons d’utiliser Stripe.js pour soumettre le paiement à Stripe. [Stripe.js](https://docs.stripe.com/payments/elements.md) est notre bibliothèque JavaScript de base pour créer les tunnels de paiement : elle gère automatiquement les opérations complexes d’intégration et vous permettra de facilement étendre votre intégration à d’autres moyens de paiement par la suite. Intégrez le script Stripe.js à votre page de paiement en l’ajoutant entre les balises `head` de votre fichier HTML. ```html Checkout ``` Créez une instance de Stripe.js avec le code JavaScript suivant sur votre page de paiement. ```javascript // Set your publishable key. Remember to change this to your live publishable key in production! // See your keys here: https://dashboard.stripe.com/apikeys const stripe = Stripe('<>'); ``` Plutôt que d’envoyer la totalité de l’objet PaymentIntent au client, utilisez sa *clé secrète* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)) provenant de l’étape précédente. Il ne s’agit pas de vos clés API qui authentifient les requêtes de l’API de Stripe. Utilisez la clé secrète du client avec prudence, car elle peut servir à finaliser le paiement. Ne l’enregistrez pas, ne l’intégrez pas dans des URL et ne la dévoilez à personne d’autre que votre client. Utilisez [stripe.collectBankAccountForPayment](https://docs.stripe.com/js/payment_intents/collect_bank_account_for_payment) pour collecter les coordonnées bancaires avec [Financial Connections](https://docs.stripe.com/financial-connections.md), créer un objet *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) et l’associer au PaymentIntent. Pour créer un PaymentMethod par prélèvement automatique ACH, vous devez obligatoirement inclure le nom du titulaire du compte dans le paramètre `billing_details`. ```javascript // Use the form that already exists on the web page. const paymentMethodForm = document.getElementById('payment-method-form'); const confirmationForm = document.getElementById('confirmation-form'); paymentMethodForm.addEventListener('submit', (ev) => { ev.preventDefault(); const accountHolderNameField = document.getElementById('account-holder-name-field'); const emailField = document.getElementById('email-field'); // Calling this method will open the instant verification dialog. stripe.collectBankAccountForPayment({ clientSecret: clientSecret, params: { payment_method_type: 'us_bank_account', payment_method_data: { billing_details: { name: accountHolderNameField.value, email: emailField.value, }, }, }, expand: ['payment_method'], }) .then(({paymentIntent, error}) => { if (error) { console.error(error.message); // PaymentMethod collection failed for some reason. } else if (paymentIntent.status === 'requires_payment_method') { // Customer canceled the hosted verification modal. Present them with other // payment method type options. } else if (paymentIntent.status === 'requires_confirmation') { // We collected an account - possibly instantly verified, but possibly // manually-entered. Display payment method details and mandate text // to the customer and confirm the intent once they accept // the mandate. confirmationForm.show(); } }); }); ``` Le [flux d’authentification de Financial Connections](https://docs.stripe.com/financial-connections/fundamentals.md#authentication-flow) gère automatiquement la collecte et la vérification des informations de compte bancaire. Lorsque votre client termine le flux d’authentification, le *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) est automatiquement associé au PaymentIntent, et créée un compte [Financial Connections](https://docs.stripe.com/api/financial_connections/accounts.md). > Les comptes bancaires que vos clients associent par saisie manuelle ou par le biais de microversements ne fourniront pas d’accès à certaines données supplémentaires comme le solde, le propriétaire et les transactions. Afin de proposer une expérience utilisateur optimale quel que soit l’appareil utilisé, définissez le paramètre `minimum-scale` de la fenêtre d’affichage de votre page sur 1 à l’aide de la balise `meta`. ```html ``` ## Collecter et envoyer l'accusé de réception du mandat [Côté client] Avant de pouvoir initier le paiement, vous devez obtenir l’autorisation de votre client en affichant les conditions du mandat pour qu’il les accepte. Pour vous conformer aux règles de la Nacha, vous devez obtenir l’autorisation d’initier le paiement auprès de votre client. Pour ce faire, présentez-lui les conditions du mandat et demandez-lui de les accepter. Pour en savoir plus, consultez la page sur les [mandats](https://docs.stripe.com/payments/ach-direct-debit.md#mandates). Lorsque le client accepte les conditions du mandat, vous devez confirmer le PaymentIntent. Utilisez [stripe.confirmUsBankAccountPayment](https://docs.stripe.com/js/payment_intents/confirm_us_bank_account_payment) pour mener à bien le paiement une fois que le client a soumis le formulaire. ```javascript confirmationForm.addEventListener('submit', (ev) => { ev.preventDefault(); stripe.confirmUsBankAccountPayment(clientSecret) .then(({paymentIntent, error}) => { if (error) { console.error(error.message); // The payment failed for some reason. } else if (paymentIntent.status === "requires_payment_method") { // Confirmation failed. Attempt again with a different payment method. } else if (paymentIntent.status === "processing") { // Confirmation succeeded! The account will be debited. // Display a message to customer. } else if (paymentIntent.next_action?.type === "verify_with_microdeposits") { // The account needs to be verified through microdeposits. // Display a message to consumer with next steps (consumer waits for // microdeposits, then enters a statement descriptor code on a page sent to them through email). } }); }); ``` > [stripe.confirmUsBankAccountPayment](https://docs.stripe.com/js/payment_intents/confirm_us_bank_account_payment) peut prendre plusieurs secondes pour s’exécuter. Pendant ce temps, désactivez toute nouvelle soumission de votre formulaire et affichez un indicateur d’attente (par exemple un spinner). Si vous recevez une erreur, affichez-la au client, réactivez le formulaire et masquez l’indicateur d’attente. Si le client termine le processus de vérification instantanée, l’abonnement bascule automatiquement sur `active`. Sinon, consultez la section [Vérifier le compte bancaire à l’aide de microversements](https://docs.stripe.com/billing/subscriptions/ach-debit.md#verify-with-microdeposits) pour apprendre à gérer la vérification à l’aide de microversements pendant que l’abonnement reste `incomplete`. ## Vérifier le compte bancaire à l'aide de microversements [Côté client] > Les clients disposent de 10 jours pour vérifier les microversements, au lieu des 23 heures habituellement accordées dans le [cycle de vie d’un abonnement](https://docs.stripe.com/billing/subscriptions/overview.md#subscription-lifecycle). Toutefois, cette date d’expiration ne peut pas être postérieure à la [date de début du cycle de facturation](https://docs.stripe.com/billing/subscriptions/ach-debit.md#billing-cycle). Tous les clients ne peuvent pas vérifier instantanément le compte bancaire. Cette étape ne s’applique que si votre client a choisi de se désinscrire du flux de vérification instantanée dans l’étape précédente. Dans ce cas, Stripe envoie un microversement `descriptor_code` ou `amount` si un problème survient au cours de la vérification du compte bancaire. Ces microversements apparaissent sur le relevé en ligne du client sous 1 à 2 jours ouvrables. - **Code de libellé** : Stripe envoie un microversement unique de 0,01 USD sur le compte bancaire du client avec un `descriptor_code` unique à 6 chiffres qui commence par SM. Votre client utilise cette chaîne pour vérifier son compte bancaire. - **Montant** : Stripe envoie deux microversements distincts sur le compte bancaire du client avec un code de libellé indiquant `ACCTVERIFY`. Votre client utilise les montants de ces versements pour vérifier son compte bancaire. L’appel [stripe.confirmUsBankAccountPayment](https://docs.stripe.com/js/payment_intents/confirm_us_bank_account_payment) effectué à l’étape précédente renvoie un PaymentIntent avec l’état `requires_action`. Le champ `next_action` du PaymentIntent contient des informations utiles à la vérification. ```javascript next_action: { type: "verify_with_microdeposits", verify_with_microdeposits: { arrival_date: 1647586800, hosted_verification_url: "https://payments.stripe.com/…", microdeposit_type: "descriptor_code" } } ``` Si vous avez fourni une [adresse e-mail de facturation](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-billing_details-email), Stripe utilise cette dernière pour notifier votre client de la date d’arrivée prévue des versements. L’e-mail envoyé inclut un lien vers la page de vérification hébergée par Stripe, sur laquelle il peut confirmer les montants des versements et effectuer la vérification. > Les tentatives de vérification sont limitées à dix pour les microversements basés sur des libellés et à trois pour ceux basés sur des montants. Si vous atteignez cette limite, nous ne pouvons plus vérifier le compte bancaire. En outre, les vérifications à l’aide de microversements expirent au bout de 10 jours. Si vous ne vérifiez pas les microversements pendant ce laps de temps, le PaymentIntent réitère sa demande d’informations sur le moyen de paiement. En informant clairement vos clients sur le fonctionnement de ces microversements, vous évitez d’éventuels problèmes liés à la vérification. ### Facultatif : Envoi de notifications personnalisées par e-mail Si vous le souhaitez, vous pouvez envoyer des [notifications personnalisées par e-mail](https://docs.stripe.com/payments/ach-direct-debit.md#mandate-and-microdeposit-emails) à votre client. Après avoir configuré les e-mails personnalisés, vous devez préciser comment le client doit répondre à l’e-mail de vérification. Pour ce faire, choisissez *une* des options suivantes : - Utilisez la page de vérification hébergée par Stripe. Pour ce faire, utilisez l’URL `verify_with_microdeposits[hosted_verification_url]` de l’objet [next_action](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-next_action-verify_with_microdeposits-hosted_verification_url) pour diriger votre client vers la procédure de vérification. - Si vous préférez ne pas utiliser la page de vérification hébergée par Stripe, créez un formulaire sur votre site. Vos clients pourront ensuite utiliser ce formulaire pour vous transmettre les montants des microversements et vérifier le compte bancaire à l’aide de [Stripe.js](https://docs.stripe.com/js/payment_intents/verify_microdeposits_for_payment). - Configurez au moins le formulaire pour qu’il gère le paramètre `descriptor code`, qui comporte une chaîne à 6 chiffres à des fins de vérification. - Stripe recommande également de configurer votre formulaire pour gérer le paramètre `amounts`, car certaines banques utilisées par vos clients peuvent l’exiger. Les intégrations transmettent uniquement le code de libellé, `descriptor_code`, *ou* les montants, `amounts`. Pour savoir quel paramètre votre intégration utilise, vérifiez la valeur de `verify_with_microdeposits[microdeposit_type]` dans l’objet `next_action`. ```javascript stripe.verifyMicrodepositsForPayment(clientSecret, { // Provide either a descriptor_code OR amounts, not both descriptor_code: 'SMT86W', amounts: [32, 45], }); ``` ## Configurer le moyen de paiement par défaut [Serveur] Vous disposez à présent d’un *abonnement* (A Subscription represents the product details associated with the plan that your customer subscribes to. Allows you to charge the customer on a recurring basis) actif appartenant à un client avec un moyen de paiement défini, mais ce dernier ne sera pas automatiquement utilisé pour les futurs paiements. À l’avenir, si vous souhaitez débiter automatiquement ce moyen de paiement, utilisez un consommateur de *webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) pour écouter l’événement `invoice.payment_succeeded` pour votre nouvel abonnement et pour définir le moyen de paiement par défaut. #### Ruby ```ruby # Don't put any keys in code. See https://docs.stripe.com/keys-best-practices. # Find your keys at https://dashboard.stripe.com/apikeys. Stripe.api_key = '<>' if event.type == 'invoice.payment_succeeded' invoice = event.data.object if invoice['billing_reason'] == 'subscription_create' subscription_id = invoice['parent']['subscription_details']['subscription'] # This example assumes you're using the default PaymentIntent that Stripe generated for the invoice. invoice_payments = Stripe::InvoicePayment.list({invoice: invoice['id']}) payment_intent_id = invoice_payments.data[0].payment.payment_intent # Retrieve the payment intent used to pay the subscription payment_intent = Stripe::PaymentIntent.retrieve(payment_intent_id) # Set the default payment method Stripe::Subscription.update( subscription_id, default_payment_method: payment_intent.payment_method ) end end ``` ## Gérer l'état de l'abonnement [Côté client] Si le paiement initial aboutit, l’abonnement prend l’état `active` et aucune action supplémentaire n’est nécessaire. Si le paiement échoue, l’état passe à l’**état de l’abonnement** que vous avez configuré dans vos [paramètres de recouvrement automatique](https://docs.stripe.com/invoicing/automatic-collection.md). Prévenez votre client que le paiement a échoué et [débitez-le avec un autre moyen de paiement](https://docs.stripe.com/billing/subscriptions/overview.md#requires-payment-method). ## Tester votre intégration Découvrez comment tester des scénarios avec des vérifications instantanées à l’aide de [Financial Connections](https://docs.stripe.com/financial-connections/testing.md#web-how-to-use-test-accounts). ### Envoyer des e-mails de transaction dans un environnement de test Une fois que vous avez collecté les coordonnées bancaires et accepté un mandat, envoyez les courriels de confirmation du mandat et de vérification du microversement dans un *environnement de bac à sable* (A sandbox is an isolated test environment that allows you to test Stripe functionality in your account without affecting your live integration. Use sandboxes to safely experiment with new features and changes). Si votre domaine est **{domain}** et votre nom d’utilisateur est **{username}**, utilisez le format d’adresse e-mail suivant pour envoyer des e-mails de transaction de test : **{username}+test\_email@{domain}**. Par exemple, si votre domaine est **example.com** et que votre nom d’utilisateur est **info**, utilisez le format **info+test\_email@example.com** pour tester les paiements ACH Direct Debit. Ce format garantit que les e-mails sont acheminés correctement. Si vous n’incluez pas le suffixe **+test\_email**, nous n’enverrons pas l’e-mail. > Pour déclencher ces e-mails pendant le test, vous devez d’abord [activer votre compte Stripe](https://docs.stripe.com/get-started/account/activate.md). ### Numéros de comptes de test Stripe fournit plusieurs numéros de compte de test et les tokens correspondants que vous pouvez utiliser pour vous assurer que votre intégration pour les comptes bancaires saisis manuellement est prête à passer en mode production. | Numéro de compte | Token | Numéro de routage | Comportement | | ---------------- | -------------------------------------- | ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `000123456789` | `pm_usBankAccount_success` | `110000000` | Le paiement aboutit. | | `000111111113` | `pm_usBankAccount_accountClosed` | `110000000` | Le paiement échoue parce que le compte est clôturé. | | `000000004954` | `pm_usBankAccount_riskLevelHighest` | `110000000` | Le paiement est bloqué par Radar en raison d’un [risque élevé de fraude](https://docs.stripe.com/radar/risk-evaluation.md#high-risk). | | `000111111116` | `pm_usBankAccount_noAccount` | `110000000` | Le paiement échoue car aucun compte n’est trouvé. | | `000222222227` | `pm_usBankAccount_insufficientFunds` | `110000000` | Le paiement échoue en raison de fonds insuffisants. | | `000333333335` | `pm_usBankAccount_debitNotAuthorized` | `110000000` | Le paiement échoue parce que les débits ne sont pas autorisés. | | `000444444440` | `pm_usBankAccount_invalidCurrency` | `110000000` | Le paiement échoue en raison d’une devise non valide. | | `000666666661` | `pm_usBankAccount_failMicrodeposits` | `110000000` | Le paiement ne parvient pas à envoyer les microversements. | | `000555555559` | `pm_usBankAccount_dispute` | `110000000` | Le paiement déclenche un litige. | | `000000000009` | `pm_usBankAccount_processing` | `110000000` | Le traitement du paiement est indéfini. Utile pour tester { % si $checkoutSessions %}[Expiration de la session de paiement](https://docs.stripe.com/api/checkout/sessions/expire.md){ % else / %}[Annulation de PaymentIntent](https://docs.stripe.com/api/payment_intents/cancel.md){ % /if %}. | | `000777777771` | `pm_usBankAccount_weeklyLimitExceeded` | `110000000` | Le paiement échoue, car son montant entraîne un dépassement de la limite hebdomadaire de volume de paiement du compte. | | `000888888885` | | `110000000` | Le paiement échoue en raison d’un [numéro de compte tokenisé](https://docs.stripe.com/financial-connections/tokenized-account-numbers.md) désactivé. | Avant d’effectuer les transactions de test, vous devez vérifier tous les comptes de test pour lesquels le paiement aboutit ou échoue automatiquement. Pour ce faire, utilisez les codes de libellé ou les montants de microversements de test ci-dessous. ### Tester des codes de libellé et des montants de microversements Pour simuler différents scénarios, utilisez ces montants de microversements *ou* ces codes de libellé 0.01. | Valeurs de microversement | Valeurs de code de libellé 0.01 | Scénario | | ------------------------- | ------------------------------- | ----------------------------------------------------------------------- | | `32` et `45` | SM11AA | Simule la vérification du compte. | | `10` et `11` | SM33CC | Simule le dépassement du nombre de tentatives de vérification autorisé. | | `40` et `41` | SM44DD | Simule l’expiration du délai de validité d’un microversement. | ### Comportement de règlement des tests Les transactions de test sont réglées instantanément et ajoutées à votre solde de test disponible. Ce comportement diffère de celui du mode production, où les transactions peuvent prendre [plusieurs jours](https://docs.stripe.com/billing/subscriptions/ach-debit.md#timing) pour être réglées dans votre solde disponible. ## Optional: Configuration du cycle de facturation Lorsque vous créez un abonnement, le système définit automatiquement le cycle de facturation par défaut. Par exemple, si un client s’abonne à un plan mensuel le 7 septembre, il est ensuite facturé le 7 de chaque mois. Certaines entreprises préfèrent définir le cycle de facturation manuellement afin de pouvoir facturer leurs clients conjointement à chaque cycle. L’argument [billing cycle anchor](https://docs.stripe.com/api/subscriptions/create.md#create_subscription-billing_cycle_anchor) vous permet d’effectuer cette opération. ```curl curl https://api.stripe.com/v1/subscriptions \ -u "<>:" \ -d "customer={{CUSTOMER_ID}}" \ -d "items[0][price]={{PRICE_ID}}" \ -d billing_cycle_anchor=1611008505 ``` La définition manuelle du cycle de facturation facture automatiquement au client un montant au prorata pour la période écoulée entre la création de l’abonnement et la date de début du cycle de facturation. Si vous ne souhaitez pas que les clients soient facturés pour cette période, vous pouvez définir l’argument [proration_behavior](https://docs.stripe.com/api/subscriptions/create.md#create_subscription-proration_behavior) sur `none`. Vous pouvez également combiner la date de début du cycle de facturation avec des [périodes d’essai](https://docs.stripe.com/billing/subscriptions/ach-debit.md#trial-periods) pour permettre aux clients d’accéder gratuitement à votre produit et ensuite leur facturer un montant au prorata. ## Optional: Périodes d'essai avant abonnement Les essais gratuits permettent aux clients d’accéder à votre produit pendant une certaine période sans être facturés. Pour définir une période d’essai, transmettez un horodatage dans [trial_end](https://docs.stripe.com/api/subscriptions/create.md#create_subscription-trial_end). > Utiliser des essais gratuits ne produit pas les mêmes résultats que de régler le paramètre [proration_behavior](https://docs.stripe.com/api/subscriptions/create.md#create_subscription-proration_behavior) sur `none` car vous pouvez personnaliser la durée de la période gratuite. Lorsque vous lancez un abonnement comportant une période d’essai avec la valeur du paramètre [payment_behavior](https://docs.stripe.com/api/subscriptions/create.md#create_subscription-payment_behavior) définie sur `default_incomplete`, Stripe renvoie une valeur `pending_setup_intent` dans l’objet Subscription. Consultez la documentation pour en savoir plus sur l’objet [SetupIntent](https://docs.stripe.com/api/setup_intents.md). #### curl ```bash curl https://api.stripe.com/v1/subscriptions \ -u <>: \ -d "customer"="cus_4fdAW5ftNQow1a" \ -d "items[0][price]"="price_CBb6IXqvTLXp3f" \ -d "payment_behavior"="default_incomplete" \ -d "payment_settings[payment_method_types][]"="us_bank_account" \ -d "trial_end"=1610403705 \ -d "expand[0]"="pending_setup_intent" ``` Renvoyez le `client_secret` du `pending_setup_intent` de l’abonnement au front-end pour terminer la configuration. Cette étape est nécessaire pour réussir à initier un paiement pour le premier cycle de facturation. Suivez les instructions des sections [Collecter les informations du moyen de paiement](https://docs.stripe.com/billing/subscriptions/ach-debit.md#collect-payment-details), [Collecter et envoyer l’accusé de réception du mandat](https://docs.stripe.com/billing/subscriptions/ach-debit.md#collect-mandate-and-submit), and [Vérifier le compte bancaire à l’aide de microversements](https://docs.stripe.com/billing/subscriptions/ach-debit.md#verify-with-microdeposits), à deux différences près : - Utilisez `stripe.collectBankAccountForSetup` au lieu de `stripe.collectBankAccountForPayment`. - Utilisez `stripe.confirmUsBankAccountSetup` au lieu de `stripe.confirmUsBankAccountPayment`. Si votre client opte pour la vérification à l’aide de microversements, utilisez `stripe.verifyMicrodepositsForSetup` au lieu de `stripe.verifyMicrodepositsForPayment`. Après vérification, le SetupIntent passe immédiatement à l’état `succeeded`, et Stripe définit automatiquement le `default_payment_method` de l’abonnement sur le nouveau *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs). Vous pouvez également combiner une [date de début du cycle de facturation](https://docs.stripe.com/billing/subscriptions/ach-debit.md#billing-cycle) avec un essai gratuit. Supposons par exemple que nous sommes le 15 septembre et que vous voulez offrir à votre client un essai gratuit de sept jours, puis lancer le cycle de facturation normal le 1er octobre. Vous pouvez définir la fin de l’essai gratuit le 22 septembre et la date de début du cycle de facturation le 1er octobre. Ainsi, le client bénéficie d’un essai gratuit pendant sept jours et paye un montant au prorata pour la durée comprise entre la fin de l’essai et le 1er octobre. Le 1er octobre, vous facturez à ce client le montant normal de l’abonnement pour son premier cycle de facturation complet. ## Optional: Enregistrement des informations de moyen de paiement pour utilisation ultérieure Vous pouvez enregistrer les coordonnées du compte bancaire américain de votre client afin de les utiliser automatiquement avec vos *factures* (Invoices are statements of amounts owed by a customer. They track the status of payments from draft through paid or otherwise finalized. Subscriptions automatically generate invoices, or you can manually create a one-off invoice), abonnements ou planifications d’abonnement futures. Pour ce faire, utilisez un objet [SetupIntent](https://docs.stripe.com/api/setup_intents.md) pour représenter votre intention d’enregistrer le moyen de paiement d’un client en vue de paiements futurs. Suivez les instructions pour [enregistrer les informations de comptes bancaires américains pour de futurs paiements](https://docs.stripe.com/payments/ach-direct-debit/set-up-payment.md). Une fois que le `SetupIntent` atteint l’état `succeeded`, mettez à jour le `default_payment_method` de votre client. #### Ruby ```ruby # Don't put any keys in code. See https://docs.stripe.com/keys-best-practices. # Find your keys at https://dashboard.stripe.com/apikeys. Stripe.api_key = '<>' if event.type == 'setup_intent.succeeded' setup_intent = event.data.object customer_id = setup_intent['customer'] payment_method_id = setup_intent['payment_method'] # Set the default payment method Stripe::Customer.update( customer_id, { invoice_settings: { default_payment_method: payment_method_id } } ) end ``` # Page hébergée > This is a Page hébergée for when platform is web and payment-ui is stripe-hosted. View the full page at https://docs.stripe.com/billing/subscriptions/ach-debit?platform=web&payment-ui=stripe-hosted. Si votre intégration Stripe Checkout permet aux clients de créer des abonnements dans une [session Checkout](https://docs.stripe.com/api/checkout/sessions.md), vous pouvez ajouter un compte bancaire américain comme moyen de paiement. Une [session Checkout](https://docs.stripe.com/api/checkout/sessions.md) représente les détails de l’intention d’achat de votre client. Créez une session Checkout lorsqu’un client souhaite démarrer un abonnement. Après avoir redirigé un client vers une session Checkout, Stripe affiche un formulaire de paiement qui permet au client d’effectuer son achat. Une fois le paiement finalisé, Stripe redirige le client vers votre site. Une fois l’intégration terminée, vous pouvez l’étendre pour : - [Ajouter des tarifs multiples](https://docs.stripe.com/products-prices/how-products-and-prices-work.md#multiple-prices) - [Créer des tarifs variables](https://docs.stripe.com/products-prices/how-products-and-prices-work.md#variable-pricing) - [Traiter les clients existants](https://docs.stripe.com/payments/existing-customers.md?platform=web&ui=stripe-hosted) - [Gérer les périodes d’essai](https://docs.stripe.com/billing/subscriptions/trials.md) - [Collecter des taxes](https://docs.stripe.com/billing/taxes/collect-taxes.md?tax-calculation=tax-rates) - [Créer des bons de réduction](https://docs.stripe.com/billing/subscriptions/coupons.md) ## Configurer Stripe [Côté serveur] Pour commencer, vous devez créer un compte Stripe. [Inscrivez-vous maintenant](https://dashboard.stripe.com/register). Utilisez nos bibliothèques officielles pour 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' ``` ## Créer le modèle tarifaire [Dashboard] [CLI Stripe] Les [modèles de tarification récurrents](https://docs.stripe.com/products-prices/pricing-models.md) représentent les produits ou services que vous vendez, leur coût, la devise que vous acceptez pour les paiements et la période de service pour les abonnements. Pour élaborer le modèle de tarification, créez des [produits](https://docs.stripe.com/api/products.md) (ce que vous vendez) et des [prix](https://docs.stripe.com/api/prices.md) (combien et à quelle fréquence facturer vos produits). Cet exemple utilise une tarification forfaitaire avec deux options de niveau de service différentes : basique et premium. Pour chaque option de niveau de service, vous devez créer un produit et un prix récurrent. Pour ajouter des frais uniques, tels que des frais d’installation, créez un troisième produit avec un prix unique. Chaque produit est facturé à intervalles mensuels. Le prix du produit basique est de 5 USD. Le prix du produit premium est de 15 USD. Voir le[ guide des tarifs forfaitaires ](https://docs.stripe.com/subscriptions/pricing-models/flat-rate-pricing.md)pour un exemple à trois niveaux. #### Dashboard Accédez à la page [Ajouter un produit](https://dashboard.stripe.com/test/products/create) et créez deux produits. Ajoutez un tarif pour chaque produit, avec une période de facturation mensuelle récurrente : - Produit Premium : service Premium avec fonctionnalités supplémentaires - Prix : Appuyez sur **Payer 15 USD**. - Produit de base : service de base avec fonctionnalités minimales - Prix : Forfaitaire | 5 USD Après avoir créé vos tarifs, enregistrez les ID de tarif de manière à pouvoir les utiliser dans d’autres étapes. Les ID de tarif se présentent sous la forme suivante : `price_G0FvDp6vZvdwRZ`. Lorsque vous le souhaitez, cliquez sur le bouton **Copier en mode production** en haut à droite de la page pour dupliquer votre produit de l’[environnement de test en mode production](https://docs.stripe.com/keys.md#test-live-modes). #### API Vous pouvez utiliser l’API pour créer les[ produits](https://docs.stripe.com/api/products.md) et les[ prix](https://docs.stripe.com/api/prices.md). Créez le produit premium : ```curl curl https://api.stripe.com/v1/products \ -u "<>:" \ --data-urlencode "name=Billing Guide: Premium Service" \ -d "description=Premium service with extra features" ``` Créez le produit de base : ```curl curl https://api.stripe.com/v1/products \ -u "<>:" \ --data-urlencode "name=Billing Guide: Basic Service" \ -d "description=Basic service with minimum features" ``` Enregistrez l’ID de chaque produit. Les ID de produit se présentent sous la forme suivante : ```json { "id": "prod_H94k5odtwJXMtQ", "object": "product", "active": true, "attributes": [ ], "created": 1587577341, "description": "Premium service with extra features", "images": [ ], "livemode": false, "metadata": { }, "name": "Billing Guide: Premium Service", "statement_descriptor": null, "type": "service", "unit_label": null, "updated": 1587577341 } ``` Utilisez les ID de produit afin de créer un tarif pour chaque produit. La valeur du champ [unit_amount](https://docs.stripe.com/api/prices/object.md#price_object-unit_amount) est exprimé en centimes, donc `1500` = 15 USD, par exemple. Créer le prix premium : ```curl curl https://api.stripe.com/v1/prices \ -u "<>:" \ -d product={{PREMIUM_PRODUCT_ID}} \ -d unit_amount=1500 \ -d currency=usd \ -d "recurring[interval]=month" ``` Créer le prix basique : ```curl curl https://api.stripe.com/v1/prices \ -u "<>:" \ -d product={{BASIC_PRODUCT_ID}} \ -d unit_amount=500 \ -d currency=usd \ -d "recurring[interval]=month" ``` Enregistrez l’ID de chaque tarif de manière à pouvoir l’utiliser par la suite. Les ID de tarif se présentent sous la forme suivante : ```json { "id": "price_HGd7M3DV3IMXkC", "object": "price", "product": "prod_HGd6W1VUqqXGvr", "type": "recurring", "currency": "usd", "recurring": { "interval": "month", "interval_count": 1, "trial_period_days": null, "usage_type": "licensed" }, "active": true, "billing_scheme": "per_unit", "created": 1589319695, "livemode": false, "lookup_key": null, "metadata": {}, "nickname": null, "unit_amount": 1500, "unit_amount_decimal": "1500", "tiers": null, "tiers_mode": null, "transform_quantity": null } ``` Consultez des exemples d’autres [modèles tarifaires](https://docs.stripe.com/products-prices/pricing-models.md). ## Créer une session Checkout [Côté client] [Côté serveur] Ajoutez à votre site web un bouton de paiement qui appelle un endpoint côté serveur afin de créer une session Checkout. ```html Checkout
``` ### Paramètres de la session Checkout Vous trouverez une liste complète des paramètres disponibles sur la page [Créer une session](https://docs.stripe.com/api/checkout/sessions/create.md). Créez une session Checkout avec l’ID d’un [tarif](https://docs.stripe.com/api/prices.md) existant. Assurez-vous d’avoir défini le mode sur `subscription` et d’avoir transmis au moins un tarif récurrent. Vous pouvez ajouter des tarifs ponctuels en plus des tarifs récurrents. Après avoir créé la session Checkout, redirigez votre client vers l’[URL](https://docs.stripe.com/api/checkout/sessions/object.md#checkout_session_object-url) renvoyée dans la réponse. #### cURL ```bash curl https://api.stripe.com/v1/checkout/sessions \ -u <>: \ -d "payment_method_types[]"="us_bank_account" \ -d "line_items[][price]"="{{PRICE_ID}}" \ -d "line_items[][quantity]"=1 \ -d "mode"="subscription" \ -d "success_url"="https://example.com/success?session_id={CHECKOUT_SESSION_ID}" \ ``` Une fois le paiement effectué, votre client est redirigé vers `success_url`. Il s’agit d’une page de votre site Web indiquant au client que le paiement a réussi. Mettez l’ID de session à disposition sur votre page de confirmation de paiement en incluant la variable de modèle `{CHECKOUT_SESSION_ID}` dans l’URL `success_url`, comme illustré ci-dessus. Par défaut, les sessions Checkout expirent 24 heures après leur création. > Ne vous fiez pas uniquement à la redirection vers `success_url` pour détecter l’initiation d’un paiement, car : > > - Des utilisateurs malveillants pourraient accéder directement au `success_url` sans payer et obtenir l’accès à vos biens ou à vos services. - Après un paiement réussi, les clients peuvent fermer l’onglet de leur navigateur avant d’être redirigés vers `success_url`. ## Confirmer que le paiement a abouti Une fois que votre client a mené à bien son paiement, Stripe le redirige vers l’URL que vous avez spécifiée dans le paramètre `success_url`. En général, il s’agit d’une page de votre site Web qui l’informe que son paiement a abouti. Cependant, US bank account debit est un moyen de paiement à notification différée, ce qui signifie que les fonds ne sont pas immédiatement disponibles. Pour cette raison, il convient de retarder le *traitement* (Fulfillment is the process of providing the goods or services purchased by a customer, typically after payment is collected) de la commande jusqu’à ce que les fonds soient disponibles. Une fois le paiement effectué, l’état sous-jacent de la *PaymentIntent* (The Payment Intents API tracks the lifecycle of a customer checkout flow and triggers additional authentication steps when required by regulatory mandates, custom Radar fraud rules, or redirect-based payment methods) passe de `processing` à `succeeded`. Un paiement US bank account debit prend généralement four days pour que les fonds soient disponibles. Vous pouvez confirmer la réussite du paiement de différentes manières : #### Dashboard Les paiements réussis apparaissent dans la [liste des paiements](https://dashboard.stripe.com/payments) du Dashboard. Lorsque vous cliquez sur un paiement, vous accédez à la page des détails de ce paiement. La section **Récapitulatif du Checkout** contient les informations de facturation et la liste des articles achetés, que vous pouvez utiliser pour traiter manuellement la commande. ![](https://b.stripecdn.com/docs-statics-srv/assets/source.16d3029596357c80a8efdbbfe106108a.png) > Stripe peut vous aider à rester informé sur les paiements entrants en vous envoyant des notifications par e-mail chaque fois qu’un client effectue un paiement. Utilisez le Dashboard pour [configurer les notifications par e-mail](https://dashboard.stripe.com/settings/user). #### Webhooks Nous envoyons les événements de paiement suivants lorsque l’état du paiement change : | Nom de l’événement | Description | Étapes suivantes | | -------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------ | -------------------------------------------------------------------------- | | [checkout.session.completed](https://docs.stripe.com/api/events/types.md#event_types-checkout.session.completed) | Le client a autorisé le paiement par prélèvement en envoyant le formulaire Checkout. | Attendez que le paiement aboutisse ou échoue. | | [checkout.session.async_payment_succeeded](https://docs.stripe.com/api/events/types.md#event_types-checkout.session.async_payment_succeeded) | Le moyen de paiement différé a finalement abouti. | Traitez la commande de biens ou de services de votre client. | | [checkout.session.async_payment_failed](https://docs.stripe.com/api/events/types.md#event_types-checkout.session.async_payment_failed) | Le moyen de paiement différé a finalement échoué. | Contactez le client par e-mail et demandez-lui de retenter le paiement. | | [invoice.paid](https://docs.stripe.com/api/events/types.md#event_types-invoice.paid) | Le paiement du client a abouti. | Traitez la commande de biens ou de services de votre client. | | [invoice.payment_failed](https://docs.stripe.com/api/events/types.md#event_types-invoice.payment_failed) | Le paiement du client a été refusé, ou il a échoué pour une autre raison. | Contactez votre client par e-mail et demandez-lui de retenter le paiement. | Votre code webhook doit gérer tous ces événements Checkout. Chaque charge utile de webhook Checkout inclut l’[objet Checkout Session](https://docs.stripe.com/api/checkout/sessions.md) et les webhooks de facture incluent l’objet [Invoice](https://docs.stripe.com/api/invoices/object.md). Les deux contiennent des informations sur le *client* (Customer objects represent customers of your business. They let you reuse payment methods and give you the ability to track multiple payments) et le *PaymentIntent* (The Payment Intents API tracks the lifecycle of a customer checkout flow and triggers additional authentication steps when required by regulatory mandates, custom Radar fraud rules, or redirect-based payment methods). Stripe envoie le webhook `checkout.session.completed` à votre serveur avant de rediriger votre client. Votre confirmation du webhook (tout code d’état `2xx`) déclenche la redirection du client vers l’URL `success_url`. Si Stripe ne reçoit pas de confirmation dans les 10 secondes suivant la réussite d’un paiement, votre client est automatiquement redirigé vers la page `success_url`. Affichez un message de confirmation sur votre page `success_url` en précisant à votre client que sa commande sera traitée dans quelques jours, car US bank account debit n’est pas un moyen de paiement instantané. Nous vous recommandons [d’utiliser des webhooks](https://docs.stripe.com/webhooks.md) pour confirmer que le paiement a abouti et exécuter les biens et services que le client a acheté. Ci-dessous est un exemple d’endpoint de webhook qui gère la réussite et l’échec d’un paiement : #### Ruby ```ruby # Don't put any keys in code. See https://docs.stripe.com/keys-best-practices. # Find your keys at https://dashboard.stripe.com/apikeys. Stripe.api_key = '<>' # You can find your endpoint's secret in your webhook settings endpoint_secret = 'whsec_...' # Using Sinatra post '/webhook' do payload = request.body.read event = nil # Verify webhook signature and extract the event # See https://stripe.com/docs/webhooks#verify-events for more information. sig_header = request.env['HTTP_STRIPE_SIGNATURE'] begin event = Stripe::Webhook.construct_event( payload, sig_header, endpoint_secret ) rescue JSON::ParserError => e # Invalid payload status 400 return rescue Stripe::SignatureVerificationError => e # Invalid signature status 400 return end case event['type'] when 'checkout.session.completed' session = event['data']['object'] subscription_id = session.subscription # Find the subscription or save it to your database. # invoice.paid may have fired before this so there # could already be a subscription. find_or_create_subscription(subscription_id) when 'invoice.paid' invoice = event['data']['object'] subscription_id = invoice.parent.subscription_details.subscription # Find the subscription or save it to your database. # checkout.session.completed may not have fired yet # so we may need to create the subscription. subscription = find_or_create_subscription(subscription_id) # Fulfill the purchase fulfill_order(invoice) # Record that the subscription has been paid for # this payment period. invoice.paid will fire every # time there is a payment made for this subscription. record_as_paid_for_this_period(subscription) when 'invoice.payment_failed' invoice = event['data']['object'] # Send an email to the customer asking them to retry their payment email_customer_about_failed_payment(invoice) end status 200 end ``` Vous pouvez obtenir des informations concernant le client, le paiement et l’abonnement en récupérant les objets `Customer`, `PaymentIntent`, o `Subscription` référencés par les propriétés `customer`, `payment_intent`, et `subscription` dans la charge utile du webhook. ### Récupération des postes de facture à partir d’un webhook Par défaut, les webhooks Checkout ne renvoient pas de `line_items`. Pour récupérer les postes créés avec la session Checkout, effectuez une autre requête avec l’ID de session Checkout : #### curl ```bash curl https://api.stripe.com/v1/checkout/sessions/{{CHECKOUT_SESSION_ID}}/line_items \ -u <>: ``` #### CLI Stripe ```bash stripe get /v1/checkout/sessions/{{CHECKOUT_SESSION_ID}}/line_items ``` ### Test des webhooks en local Pour tester des webhooks localement, vous pouvez utiliser l’[interface de ligne de commande Stripe](https://docs.stripe.com/stripe-cli.md). Après l’avoir installée, vous pouvez transférer les événements à votre serveur : ```bash stripe listen --forward-to localhost:4242/webhook Ready! Your webhook signing secret is '{{WEBHOOK_SIGNING_SECRET}}' (^C to quit) ``` En savoir plus sur [la configuration des webhooks](https://docs.stripe.com/webhooks.md). #### Plugins tiers Vous pouvez utiliser des plugins comme [Zapier](https://stripe.com/works-with/zapier) pour automatiser la mise à jour de vos systèmes de réalisation des achats avec les informations provenant des paiements Stripe. Voici quelques exemples d’automatisation prise en charge par les plugins : - Mise à jour des feuilles de calcul utilisées pour le suivi de commandes suite à des paiements ayant abouti - Mise à jour des systèmes de gestion d’inventaire suite à des paiements ayant abouti - Déclenchement de notifications aux équipes internes du service client en utilisant des applications de messagerie ou de chat ## Tester votre intégration Découvrez comment tester des scénarios avec des vérifications instantanées à l’aide de [Financial Connections](https://docs.stripe.com/financial-connections/testing.md#web-how-to-use-test-accounts). ### Envoyer des e-mails de transaction dans un environnement de test Une fois que vous avez collecté les coordonnées bancaires et accepté un mandat, envoyez les courriels de confirmation du mandat et de vérification du microversement dans un *environnement de bac à sable* (A sandbox is an isolated test environment that allows you to test Stripe functionality in your account without affecting your live integration. Use sandboxes to safely experiment with new features and changes). Si votre domaine est **{domain}** et votre nom d’utilisateur est **{username}**, utilisez le format d’adresse e-mail suivant pour envoyer des e-mails de transaction de test : **{username}+test\_email@{domain}**. Par exemple, si votre domaine est **example.com** et que votre nom d’utilisateur est **info**, utilisez le format **info+test\_email@example.com** pour tester les paiements ACH Direct Debit. Ce format garantit que les e-mails sont acheminés correctement. Si vous n’incluez pas le suffixe **+test\_email**, nous n’enverrons pas l’e-mail. > Pour déclencher ces e-mails pendant le test, vous devez d’abord [activer votre compte Stripe](https://docs.stripe.com/get-started/account/activate.md). ### Numéros de comptes de test Stripe fournit plusieurs numéros de compte de test et les tokens correspondants que vous pouvez utiliser pour vous assurer que votre intégration pour les comptes bancaires saisis manuellement est prête à passer en mode production. | Numéro de compte | Token | Numéro de routage | Comportement | | ---------------- | -------------------------------------- | ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `000123456789` | `pm_usBankAccount_success` | `110000000` | Le paiement aboutit. | | `000111111113` | `pm_usBankAccount_accountClosed` | `110000000` | Le paiement échoue parce que le compte est clôturé. | | `000000004954` | `pm_usBankAccount_riskLevelHighest` | `110000000` | Le paiement est bloqué par Radar en raison d’un [risque élevé de fraude](https://docs.stripe.com/radar/risk-evaluation.md#high-risk). | | `000111111116` | `pm_usBankAccount_noAccount` | `110000000` | Le paiement échoue car aucun compte n’est trouvé. | | `000222222227` | `pm_usBankAccount_insufficientFunds` | `110000000` | Le paiement échoue en raison de fonds insuffisants. | | `000333333335` | `pm_usBankAccount_debitNotAuthorized` | `110000000` | Le paiement échoue parce que les débits ne sont pas autorisés. | | `000444444440` | `pm_usBankAccount_invalidCurrency` | `110000000` | Le paiement échoue en raison d’une devise non valide. | | `000666666661` | `pm_usBankAccount_failMicrodeposits` | `110000000` | Le paiement ne parvient pas à envoyer les microversements. | | `000555555559` | `pm_usBankAccount_dispute` | `110000000` | Le paiement déclenche un litige. | | `000000000009` | `pm_usBankAccount_processing` | `110000000` | Le traitement du paiement est indéfini. Utile pour tester { % si $checkoutSessions %}[Expiration de la session de paiement](https://docs.stripe.com/api/checkout/sessions/expire.md){ % else / %}[Annulation de PaymentIntent](https://docs.stripe.com/api/payment_intents/cancel.md){ % /if %}. | | `000777777771` | `pm_usBankAccount_weeklyLimitExceeded` | `110000000` | Le paiement échoue, car son montant entraîne un dépassement de la limite hebdomadaire de volume de paiement du compte. | | `000888888885` | | `110000000` | Le paiement échoue en raison d’un [numéro de compte tokenisé](https://docs.stripe.com/financial-connections/tokenized-account-numbers.md) désactivé. | Avant d’effectuer les transactions de test, vous devez vérifier tous les comptes de test pour lesquels le paiement aboutit ou échoue automatiquement. Pour ce faire, utilisez les codes de libellé ou les montants de microversements de test ci-dessous. ### Tester des codes de libellé et des montants de microversements Pour simuler différents scénarios, utilisez ces montants de microversements *ou* ces codes de libellé 0.01. | Valeurs de microversement | Valeurs de code de libellé 0.01 | Scénario | | ------------------------- | ------------------------------- | ----------------------------------------------------------------------- | | `32` et `45` | SM11AA | Simule la vérification du compte. | | `10` et `11` | SM33CC | Simule le dépassement du nombre de tentatives de vérification autorisé. | | `40` et `41` | SM44DD | Simule l’expiration du délai de validité d’un microversement. | ### Comportement de règlement des tests Les transactions de test sont réglées instantanément et ajoutées à votre solde de test disponible. Ce comportement diffère de celui du mode production, où les transactions peuvent prendre [plusieurs jours](https://docs.stripe.com/billing/subscriptions/ach-debit.md#timing) pour être réglées dans votre solde disponible. ## Autres considérations ### Échec de la vérification par micro-versements Lorsqu’un compte bancaire est en attente de vérification par microversements, la vérification du client peut échouer pour trois raisons : - L’envoi des microversements au compte bancaire du client a échoué (en général, ce problème signifie que le compte bancaire est clôturé ou non disponible, ou que le numéro du compte bancaire est incorrect). - Les 10 tentatives de vérification du compte effectuées par le client ont échoué. Une fois cette limite atteinte, le compte bancaire ne peut plus être vérifié ni utilisé. - Le client n’a pas vérifié son compte bancaire dans le délai de 10 jours prévu. Si la vérification du compte bancaire échoue pour l’une de ces raisons, vous pouvez [gérer l’événement `checkout.session.async_payment_failed`](https://docs.stripe.com/api/events/types.md?event_types-invoice.payment_succeeded=#event_types-checkout.session.async_payment_failed) pour contacter le client et lui proposer de passer une nouvelle commande. ## Optional: Vérification instantanée uniquement Par défaut, les paiements par prélèvement automatique ACH permettent à vos clients d’utiliser la vérification instantanée du compte bancaire ou les microversements. Vous pouvez aussi exiger la vérification instantanée du compte bancaire uniquement en utilisant le paramètre `payment_method_options[us_bank_account][verification_method]` lorsque vous créez la session Checkout. #### Accounts v2 ```curl curl https://api.stripe.com/v1/checkout/sessions \ -u "<>:" \ -d mode=subscription \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d "payment_method_types[0]=card" \ -d "payment_method_types[1]=us_bank_account" \ -d "payment_method_options[us_bank_account][verification_method]=instant" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][0]=payment_method" \ -d "line_items[0][price]={{PRICE_ID}}" \ -d "line_items[0][quantity]=1" \ --data-urlencode "success_url=https://example.com/success" ``` #### Customers v1 ```curl curl https://api.stripe.com/v1/checkout/sessions \ -u "<>:" \ -d mode=subscription \ -d "customer={{CUSTOMER_ID}}" \ -d "payment_method_types[0]=card" \ -d "payment_method_types[1]=us_bank_account" \ -d "payment_method_options[us_bank_account][verification_method]=instant" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][0]=payment_method" \ -d "line_items[0][price]={{PRICE_ID}}" \ -d "line_items[0][quantity]=1" \ --data-urlencode "success_url=https://example.com/success" ``` ## See also - [Personnaliser votre intégration](https://docs.stripe.com/payments/checkout/customization.md) - [Gérer les abonnements avec le portail client](https://docs.stripe.com/billing/subscriptions/build-subscriptions.md?payment-ui=checkout&ui=stripe-hosted)