# Accepter un virement bancaire Utilisez l'API Payment Intents pour accepter les paiements par virements bancaires. Si votre intégration utilise des factures, consultez [Envoyer une facture avec des instructions de virement bancaire](https://docs.stripe.com/invoicing/bank-transfer.md). La première fois que vous acceptez un paiement par virement bancaire, Stripe génère un compte bancaire virtuel pour le client, que vous pouvez ensuite partager directement avec lui. Tous les futurs paiements par virement bancaire de ce client seront envoyés vers ce compte bancaire. Dans certains pays, Stripe vous fournit également un numéro de référence de virement unique que votre client peut associer à chaque virement afin de rapprocher le virement et les paiements en attente. Notez que certains pays limitent le nombre de numéros de comptes bancaires virtuels que vous pouvez créer gratuitement. ![](https://b.stripecdn.com/docs-statics-srv/assets/without-invoices-diagram-1.a17fe04695ef532427f25a9e1276ee2e.svg) Aperçu des paiements par virement bancaire ## Gérer les paiements insuffisants et les trop-perçus Avec les paiements par virement bancaire, il peut arriver que le montant des fonds envoyés par le client soit inférieur ou supérieur à celui attendu. Si la somme est insuffisante, Stripe règle partiellement le PaymentIntent ouvert. Les factures ne font pas l’objet d’un règlement partiel et restent ouvertes jusqu’à ce que les fonds entrants couvrent l’intégralité de leur montant. Si le client envoie un montant supérieur au montant attendu, Stripe tente de rapprocher les fonds entrants avec un paiement en cours et conservera le montant excédentaire restant dans le solde de trésorerie du client. En savoir davantage sur [comment Stripe gère les opérations de rapprochement](https://docs.stripe.com/payments/customer-balance/reconciliation.md). ![](https://b.stripecdn.com/docs-statics-srv/assets/without-invoices-diagram-2.464fe916d5822422144c8aea0f31ed45.svg) ![](https://b.stripecdn.com/docs-statics-srv/assets/without-invoices-diagram-3.b1992851a5f3492d14eaa35e336b0e9f.svg) ## Gérer plusieurs paiements ou factures ouvert(e)s Vous pouvez avoir plusieurs paiements ou factures ouvert(e)s payables par virement bancaire. Par défaut, Stripe tentera de [rapprocher automatiquement](https://docs.stripe.com/payments/customer-balance/reconciliation.md) le virement bancaire en utilisant certaines informations telles que le code de référence du virement ou le montant viré. Vous pouvez désactiver le rapprochement automatique et [rapprocher manuellement](https://docs.stripe.com/payments/customer-balance/reconciliation.md#cash-manual-reconciliation) des paiements et des factures. Vous pouvez contourner le rapprochement automatique, selon le client, en définissant le [mode de rapprochement](https://docs.stripe.com/api/customers/create.md#create_customer-cash_balance-settings-reconciliation_mode) sur manuel. # Elements ## Configurer Stripe [Côté serveur] Pour commencer, vous devez [créer un compte](https://dashboard.stripe.com/register) Stripe. Utilisez nos bibliothèques officielles pour accéder à l’API Stripe à partir de 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 ou récupérer un objet Customer [Côté serveur] Vous devez associer un objet associé à votre client à chaque paiement par virement bancaire à des fins de rapprochement. Si vous possédez déjà un objet associé au client, vous pouvez ignorer cette étape. Sinon, créez un nouvel objet. > #### Utiliser l’API Accounts v2 pour représenter les clients > > L’API Accounts v2 est généralement disponible pour les utilisateurs de Connect et en aperçu public pour les autres utilisateurs de Stripe. Si vous avez accès à l’aperçu Accounts v2, vous devez spécifier une [version d’aperçu](https://docs.stripe.com/api-v2-overview.md#sdk-and-api-versioning) dans votre code. > > Pour accéder à l’aperçu Accounts v2, rendez-vous sur [aperçus et fonctionnalités de Account](https://dashboard.stripe.com/settings/previews) dans votre Dashboard et activez **Moyens de paiement réutilisables pour les virements internationaux**. > > Dans la plupart des cas d’usage, nous vous recommandons de [modéliser vos clients en tant qu’objets Account configurés par le client](https://docs.stripe.com/accounts-v2/use-accounts-as-customers.md), plutôt que d’utiliser des objets [Customer](https://docs.stripe.com/api/customers.md). Créez un [Account](https://docs.stripe.com/api/v2/core/accounts/create.md#v2_create_accounts-configuration-customer) ou un [Customer](https://docs.stripe.com/api/customers/create.md) configuré par le client lorsque votre client crée un compte auprès de votre entreprise, ou lors de l’enregistrement d’un moyen de paiement. Associez l’ID de l’objet à votre propre représentation interne d’un client. Créez un nouveau client ou récupérez un client existant pour l’associer à ce paiement. #### Accounts v2 ```curl curl -X POST https://api.stripe.com/v2/core/accounts \ -H "Authorization: Bearer <>" \ -H "Stripe-Version: 2026-08-26.preview" \ --json '{ "contact_email": "jenny.rosen@example.com", "display_name": "Jenny Rosen", "configuration": { "customer": {} }, "include": [ "configuration.customer" ] }' ``` #### Customers v1 ```curl curl https://api.stripe.com/v1/customers \ -u "<>:" \ -d "name=Jenny Rosen" \ --data-urlencode "email=jenny.rosen@example.com" ``` ## Créer un PaymentIntent [Côté serveur] Un [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) est un objet qui représente votre intention d’encaisser un paiement client et qui suit le cycle de vie du processus de paiement étape par étape. Créez un `PaymentIntent` sur le serveur et précisez le montant à encaisser ainsi que la devise. Vous devez également renseigner le paramètre [customer](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-customer) ou [customer_account](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-customer_account) de la requête de création du `PaymentIntent`. Les virements bancaires ne sont pas disponibles sur les `PayentIntents` qui ne sont pas associés à un client. #### Gérer les moyens de paiement depuis le Dashboard Avant de créer un Payment Intent, veillez à activer les **virements bancaires** dans les [paramètres des moyens de paiement](https://dashboard.stripe.com/settings/payment_methods) de votre Dashboard. > Avec les [moyens de paiement dynamiques](https://docs.stripe.com/payments/payment-methods/dynamic-payment-methods.md), Stripe gère l’affichage des moyens de paiement admissibles en fonction de facteurs tels que le montant de la transaction, la devise et le tunnel de paiement. #### Accounts v2 #### États-Unis ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d currency=usd \ -d "automatic_payment_methods[enabled]=true" ``` #### Royaume-Uni ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d currency=gbp \ -d "automatic_payment_methods[enabled]=true" ``` #### UE ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d currency=eur \ -d "automatic_payment_methods[enabled]=true" ``` Pour localiser l’IBAN affiché au client, définissez la propriété [`identity.individual.address`](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-identity-individual-address) ou [modifiez le compte dans le Dashboard](https://docs.stripe.com/invoicing/customer.md#edit-a-customer). Nous prenons en charge la localisation de l’IBAN pour  : - Si vous n’avez pas configuré de pays pour votre client, ou si son pays ne prend pas en charge la localisation par IBAN, nous utilisons par défaut le pays de votre compte Stripe. - Si la localisation de l’IBAN n’est pas prise en charge pour le pays de votre compte Stripe, nous utilisons `IE`. > La création de numéros de comptes bancaires virtuels localisés (VBAN) n’est actuellement pas disponible pour l’Espagne (ES). Utilisez plutôt des VBAN d’autres pays de l’UE. #### JP ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=19000 \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d currency=jpy \ -d "automatic_payment_methods[enabled]=true" \ --data-urlencode "return_url=https://example.com/return_url" ``` #### MX ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d currency=mxn \ -d "automatic_payment_methods[enabled]=true" \ --data-urlencode "return_url=https://example.com/return_url" ``` #### Customers v1 #### États-Unis ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d "customer={{CUSTOMER_ID}}" \ -d currency=usd \ -d "automatic_payment_methods[enabled]=true" ``` #### Royaume-Uni ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d "customer={{CUSTOMER_ID}}" \ -d currency=gbp \ -d "automatic_payment_methods[enabled]=true" ``` #### UE ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d "customer={{CUSTOMER_ID}}" \ -d currency=eur \ -d "automatic_payment_methods[enabled]=true" ``` Pour localiser le numéro IBAN affiché au client, vous pouvez configurer le pays du client en définissant la propriété [`address.country`](https://docs.stripe.com/api/customers/object.md#customer_object-address-country) ou en [modifiant le client dans le Dashboard](https://docs.stripe.com/invoicing/customer.md#edit-a-customer). Nous prenons en charge la localisation de l’IBAN pour  : - Si vous n’avez pas configuré de pays pour votre client, ou si son pays ne prend pas en charge la localisation IBAN, nous utilisons le pays de votre compte Stripe. - Si la localisation de l’IBAN n’est pas prise en charge pour le pays de votre compte Stripe, nous utilisons `IE`. > La création de numéros de comptes bancaires virtuels localisés (VBAN) n’est actuellement pas disponible pour l’Espagne (ES). Utilisez plutôt des VBAN d’autres pays de l’UE. #### JP ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=19000 \ -d "customer={{CUSTOMER_ID}}" \ -d currency=jpy \ -d "automatic_payment_methods[enabled]=true" \ --data-urlencode "return_url=https://example.com/return_url" ``` #### MX ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d "customer={{CUSTOMER_ID}}" \ -d currency=mxn \ -d "automatic_payment_methods[enabled]=true" \ --data-urlencode "return_url=https://example.com/return_url" ``` Dans la dernière version de l’API, la spécification du paramètre `automatic_payment_methods` est facultative, car Stripe active sa fonctionnalité par défaut. Si le solde du client suffit déjà à couvrir le montant du paiement, le PaymentIntent aboutit immédiatement et reçoit l’état `succeeded`. Les clients peuvent accumuler un solde lorsqu’ils versent par erreur un montant trop élevé lors d’une transaction, ce qui se produit fréquemment lors des paiements par virement bancaire. Vous devez [rapprocher les soldes des clients dans un délai précis en fonction de votre pays](https://docs.stripe.com/payments/customer-balance/reconciliation.md). #### Répertorier les moyens de paiement manuellement Pour spécifier manuellement les moyens de paiement avec l’API, indiquez l’ID de l’objet [Account](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-id) configuré par le client ou du [Customer](https://docs.stripe.com/api/customers/object.md#customer_object-id). #### Accounts v2 #### États-Unis ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d "allowed_payment_method_types[]=customer_balance" \ -d "payment_method_options[customer_balance][funding_type]=bank_transfer" \ -d "payment_method_options[customer_balance][bank_transfer][type]=us_bank_transfer" ``` Si le solde du client suffit déjà à couvrir le montant du paiement, le PaymentIntent aboutit immédiatement et reçoit l’état `succeeded`. Les clients peuvent accumuler un solde lorsqu’ils versent par erreur un montant trop élevé lors d’une transaction, ce qui se produit fréquemment lors des paiements par virement bancaire. Vous devez [rapprocher les soldes des clients dans un délai précis en fonction de votre pays](https://docs.stripe.com/payments/customer-balance/reconciliation.md). - Attribuez la valeur `bank_transfer` à l’attribut [funding_type](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-customer_balance-funding_type) afin d’indiquer la marche à suivre si le client ne dispose pas d’un solde suffisant pour couvrir le montant du paiement. - Attribuez la valeur `us_bank_transfer` à l’attribut [bank_transfer[type]](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-customer_balance-bank_transfer-type) afin de spécifier le type de virement bancaire qui pourra être utilisé pour le paiement. #### Royaume-Uni ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=gbp \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d "allowed_payment_method_types[]=customer_balance" \ -d "payment_method_options[customer_balance][funding_type]=bank_transfer" \ -d "payment_method_options[customer_balance][bank_transfer][type]=gb_bank_transfer" ``` Si le solde du client suffit déjà à couvrir le montant du paiement, le PaymentIntent aboutit immédiatement et reçoit l’état `succeeded`. Les clients peuvent accumuler un solde lorsqu’ils versent par erreur un montant trop élevé lors d’une transaction, ce qui se produit fréquemment lors des paiements par virement bancaire. Vous devez [rapprocher les soldes des clients dans un délai précis en fonction de votre pays](https://docs.stripe.com/payments/customer-balance/reconciliation.md). - Attribuez la valeur `bank_transfer` à l’attribut [funding_type](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-customer_balance-funding_type) afin d’indiquer la marche à suivre si le client ne dispose pas d’un solde suffisant pour couvrir le montant du paiement. - Attribuez la valeur `gb_bank_transfer` à l’attribut [bank_transfer[type]](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-customer_balance-bank_transfer-type) afin de spécifier le type de virement bancaire qui pourra être utilisé pour le paiement. #### UE ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=eur \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d "allowed_payment_method_types[]=customer_balance" \ -d "payment_method_options[customer_balance][funding_type]=bank_transfer" \ -d "payment_method_options[customer_balance][bank_transfer][type]=eu_bank_transfer" \ -d "payment_method_options[customer_balance][bank_transfer][eu_bank_transfer][country]=FR" ``` Si le solde du client suffit déjà à couvrir le montant du paiement, le PaymentIntent aboutit immédiatement et reçoit l’état `succeeded`. Les clients peuvent accumuler un solde lorsqu’ils versent par erreur un montant trop élevé lors d’une transaction, ce qui se produit fréquemment lors des paiements par virement bancaire. Vous devez [rapprocher les soldes des clients dans un délai précis en fonction de votre pays](https://docs.stripe.com/payments/customer-balance/reconciliation.md). - Attribuez la valeur `bank_transfer` à l’attribut [funding_type](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-customer_balance-funding_type) afin d’indiquer la marche à suivre si le client ne dispose pas d’un solde suffisant pour couvrir le montant du paiement. - Attribuez la valeur `eu_bank_transfer` à l’attribut [bank_transfer[type]](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-customer_balance-bank_transfer-type) afin de spécifier le type de virement bancaire qui pourra être utilisé pour le paiement. - Définissez [payment_method_options[customer_balance][bank_transfer][eu_bank_transfer][country]](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-customer_balance-bank_transfer-eu_bank_account-country) sur l’une des options suivantes : . L’IBAN que voit le client est localisé pour le pays choisi. > La création de numéros de comptes bancaires virtuels localisés (VBAN) n’est actuellement pas disponible pour l’Espagne (ES). Utilisez plutôt des VBAN d’autres pays de l’UE. #### JP ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=19000 \ -d currency=jpy \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d "allowed_payment_method_types[]=customer_balance" \ -d "payment_method_options[customer_balance][funding_type]=bank_transfer" \ -d "payment_method_options[customer_balance][bank_transfer][type]=jp_bank_transfer" ``` Si le solde du client suffit déjà à couvrir le montant du paiement, le PaymentIntent aboutit immédiatement et reçoit l’état `succeeded`. Les clients peuvent accumuler un solde lorsqu’ils versent par erreur un montant trop élevé lors d’une transaction, ce qui se produit fréquemment lors des paiements par virement bancaire. Vous devez [rapprocher les soldes des clients dans un délai précis en fonction de votre pays](https://docs.stripe.com/payments/customer-balance/reconciliation.md). - Attribuez la valeur `bank_transfer` à l’attribut [funding_type](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-customer_balance-funding_type) afin d’indiquer la marche à suivre si le client ne dispose pas d’un solde suffisant pour couvrir le montant du paiement. - Attribuez la valeur `jp_bank_transfer` à l’attribut [bank_transfer[type]](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-customer_balance-bank_transfer-type) afin de spécifier le type de virement bancaire qui pourra être utilisé pour le paiement. #### MX ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=mxn \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d "allowed_payment_method_types[]=customer_balance" \ -d "payment_method_options[customer_balance][funding_type]=bank_transfer" \ -d "payment_method_options[customer_balance][bank_transfer][type]=mx_bank_transfer" ``` Si le solde du client suffit déjà à couvrir le montant du paiement, le PaymentIntent aboutit immédiatement et reçoit l’état `succeeded`. Les clients peuvent accumuler un solde lorsqu’ils versent par erreur un montant trop élevé lors d’une transaction, ce qui se produit fréquemment lors des paiements par virement bancaire. Vous devez [rapprocher les soldes des clients dans un délai précis en fonction de votre pays](https://docs.stripe.com/payments/customer-balance/reconciliation.md). - Attribuez la valeur `bank_transfer` à l’attribut [funding_type](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-customer_balance-funding_type) afin d’indiquer la marche à suivre si le client ne dispose pas d’un solde suffisant pour couvrir le montant du paiement. - Attribuez la valeur `mx_bank_transfer` à l’attribut [bank_transfer[type]](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-customer_balance-bank_transfer-type) afin de spécifier le type de virement bancaire qui pourra être utilisé pour le paiement. #### Customers v1 #### États-Unis ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d "customer={{CUSTOMER_ID}}" \ -d "allowed_payment_method_types[]=customer_balance" \ -d "payment_method_options[customer_balance][funding_type]=bank_transfer" \ -d "payment_method_options[customer_balance][bank_transfer][type]=us_bank_transfer" ``` Si le solde du client suffit déjà à couvrir le montant du paiement, le PaymentIntent aboutit immédiatement et reçoit l’état `succeeded`. Les clients peuvent accumuler un solde lorsqu’ils versent par erreur un montant trop élevé lors d’une transaction, ce qui se produit fréquemment lors des paiements par virement bancaire. Vous devez [rapprocher les soldes des clients dans un délai précis en fonction de votre pays](https://docs.stripe.com/payments/customer-balance/reconciliation.md). - Attribuez la valeur `bank_transfer` à l’attribut [funding_type](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-customer_balance-funding_type) afin d’indiquer la marche à suivre si le client ne dispose pas d’un solde suffisant pour couvrir le montant du paiement. - Attribuez la valeur `us_bank_transfer` à l’attribut [bank_transfer[type]](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-customer_balance-bank_transfer-type) afin de spécifier le type de virement bancaire qui pourra être utilisé pour le paiement. #### Royaume-Uni ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=gbp \ -d "customer={{CUSTOMER_ID}}" \ -d "allowed_payment_method_types[]=customer_balance" \ -d "payment_method_options[customer_balance][funding_type]=bank_transfer" \ -d "payment_method_options[customer_balance][bank_transfer][type]=gb_bank_transfer" ``` Si le solde du client suffit déjà à couvrir le montant du paiement, le PaymentIntent aboutit immédiatement et reçoit l’état `succeeded`. Les clients peuvent accumuler un solde lorsqu’ils versent par erreur un montant trop élevé lors d’une transaction, ce qui se produit fréquemment lors des paiements par virement bancaire. Vous devez [rapprocher les soldes des clients dans un délai précis en fonction de votre pays](https://docs.stripe.com/payments/customer-balance/reconciliation.md). - Attribuez la valeur `bank_transfer` à l’attribut [funding_type](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-customer_balance-funding_type) afin d’indiquer la marche à suivre si le client ne dispose pas d’un solde suffisant pour couvrir le montant du paiement. - Attribuez la valeur `gb_bank_transfer` à l’attribut [bank_transfer[type]](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-customer_balance-bank_transfer-type) afin de spécifier le type de virement bancaire qui pourra être utilisé pour le paiement. #### UE ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=eur \ -d "customer={{CUSTOMER_ID}}" \ -d "allowed_payment_method_types[]=customer_balance" \ -d "payment_method_options[customer_balance][funding_type]=bank_transfer" \ -d "payment_method_options[customer_balance][bank_transfer][type]=eu_bank_transfer" \ -d "payment_method_options[customer_balance][bank_transfer][eu_bank_transfer][country]=FR" ``` Si le solde du client suffit déjà à couvrir le montant du paiement, le PaymentIntent aboutit immédiatement et reçoit l’état `succeeded`. Les clients peuvent accumuler un solde lorsqu’ils versent par erreur un montant trop élevé lors d’une transaction, ce qui se produit fréquemment lors des paiements par virement bancaire. Vous devez [rapprocher les soldes des clients dans un délai précis en fonction de votre pays](https://docs.stripe.com/payments/customer-balance/reconciliation.md). - Attribuez la valeur `bank_transfer` à l’attribut [funding_type](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-customer_balance-funding_type) afin d’indiquer la marche à suivre si le client ne dispose pas d’un solde suffisant pour couvrir le montant du paiement. - Attribuez la valeur `eu_bank_transfer` à l’attribut [bank_transfer[type]](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-customer_balance-bank_transfer-type) afin de spécifier le type de virement bancaire qui pourra être utilisé pour le paiement. - Définissez [payment_method_options[customer_balance][bank_transfer][eu_bank_transfer][country]](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-customer_balance-bank_transfer-eu_bank_account-country) sur l’une des options suivantes : . L’IBAN que voit le client est localisé pour le pays choisi. > La création de numéros de comptes bancaires virtuels localisés (VBAN) n’est actuellement pas disponible pour l’Espagne (ES). Utilisez plutôt des VBAN d’autres pays de l’UE. #### JP ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=19000 \ -d currency=jpy \ -d "customer={{CUSTOMER_ID}}" \ -d "allowed_payment_method_types[]=customer_balance" \ -d "payment_method_options[customer_balance][funding_type]=bank_transfer" \ -d "payment_method_options[customer_balance][bank_transfer][type]=jp_bank_transfer" ``` Si le solde du client suffit déjà à couvrir le montant du paiement, le PaymentIntent aboutit immédiatement et reçoit l’état `succeeded`. Les clients peuvent accumuler un solde lorsqu’ils versent par erreur un montant trop élevé lors d’une transaction, ce qui se produit fréquemment lors des paiements par virement bancaire. Vous devez [rapprocher les soldes des clients dans un délai précis en fonction de votre pays](https://docs.stripe.com/payments/customer-balance/reconciliation.md). - Attribuez la valeur `bank_transfer` à l’attribut [funding_type](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-customer_balance-funding_type) afin d’indiquer la marche à suivre si le client ne dispose pas d’un solde suffisant pour couvrir le montant du paiement. - Attribuez la valeur `jp_bank_transfer` à l’attribut [bank_transfer[type]](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-customer_balance-bank_transfer-type) afin de spécifier le type de virement bancaire qui pourra être utilisé pour le paiement. #### MX ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=mxn \ -d "customer={{CUSTOMER_ID}}" \ -d "allowed_payment_method_types[]=customer_balance" \ -d "payment_method_options[customer_balance][funding_type]=bank_transfer" \ -d "payment_method_options[customer_balance][bank_transfer][type]=mx_bank_transfer" ``` Si le solde du client suffit déjà à couvrir le montant du paiement, le PaymentIntent aboutit immédiatement et reçoit l’état `succeeded`. Les clients peuvent accumuler un solde lorsqu’ils versent par erreur un montant trop élevé lors d’une transaction, ce qui se produit fréquemment lors des paiements par virement bancaire. Vous devez [rapprocher les soldes des clients dans un délai précis en fonction de votre pays](https://docs.stripe.com/payments/customer-balance/reconciliation.md). - Attribuez la valeur `bank_transfer` à l’attribut [funding_type](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-customer_balance-funding_type) afin d’indiquer la marche à suivre si le client ne dispose pas d’un solde suffisant pour couvrir le montant du paiement. - Attribuez la valeur `mx_bank_transfer` à l’attribut [bank_transfer[type]](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-customer_balance-bank_transfer-type) afin de spécifier le type de virement bancaire qui pourra être utilisé pour le paiement. > Spécifiez toujours `allowed_payment_method_types` lors de la création d’un paiement. Vous ne pouvez pas utiliser `customer_balance` pour les [paiements futurs](https://docs.stripe.com/payments/save-and-reuse.md). ## Collecter les informations de paiement [Côté client] Collectez les informations de paiement du client avec le [Payment Element](https://docs.stripe.com/payments/payment-element.md). Le Payment Element est un composant d’interface utilisateur préconfiguré qui simplifie la collecte des informations pour de nombreux moyens de paiement. Le Payment Element contient un iframe qui envoie les informations de paiement à Stripe de manière sécurisée via une connexion HTTPS. Évitez de placer le Payment Element dans un autre iframe, car certains moyens de paiement nécessitent une redirection vers une autre page pour la confirmation du paiement. Si vous choisissez d’utiliser un iframe et que vous souhaitez accepter Apple Pay ou Google Pay, l’attribut [allow](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#attr-allowpaymentrequest) de l’iframe doit être défini sur égal à `"payment *"`. Pour que votre intégration fonctionne, l’adresse de la page de paiement doit commencer par `https://` et non par `http://`. Vous pouvez tester votre intégration sans utiliser le protocole HTTPS, mais n’oubliez pas de l’[activer](https://docs.stripe.com/security/guide.md#tls) lorsque vous souhaitez commencer à accepter des paiements réels. #### HTML + JS ### Configurer Stripe.js Le composant Element Payment est automatiquement disponible en tant que fonctionnalité de Stripe.js. Intégrez le script Stripe.js à votre page de paiement en l’ajoutant entre les balises `head` de votre fichier HTML. Chargez toujours Stripe.js directement à partir de js.stripe.com pour maintenir votre conformité PCI. Vous ne devez pas inclure le script dans une offre groupée ni en héberger de copie. ```html Checkout ``` Créez une instance de Stripe 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('<>'); ``` ### Ajouter le Payment Element à votre page de paiement Le composant Element Payment doit avoir un emplacement dédié dans votre page de paiement. Créez un nœud DOM (conteneur) vide doté d’un ID unique dans votre formulaire de paiement : ```html
``` Lors du chargement du formulaire précédent, créez une instance du composant Payment Element et intégrez-la au nœud DOM conteneur. Lorsque vous créez l’instance [Elements](https://docs.stripe.com/js/elements_object/create), transmettez la [clé secrète du client](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) définie à l’étape précédente dans les `options` : 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. ```javascript const options = { clientSecret: '{{CLIENT_SECRET}}', // Fully customizable with appearance API. appearance: {/*...*/}, }; // Set up Stripe.js and Elements to use in checkout form, passing the client secret obtained in a previous step const elements = stripe.elements(options); // Create and mount the Payment Element const paymentElementOptions = { layout: 'accordion'}; const paymentElement = elements.create('payment', paymentElementOptions); paymentElement.mount('#payment-element'); ``` #### React ### Configurer Stripe.js Installez [React Stripe.js](https://www.npmjs.com/package/@stripe/react-stripe-js) et le [chargeur Stripe.js](https://www.npmjs.com/package/@stripe/stripe-js) à partir du registre public npm : ```bash npm install --save @stripe/react-stripe-js @stripe/stripe-js ``` ### Ajouter le fournisseur Elements à votre page de paiement et le configurer Pour utiliser le composant Element Payment, enveloppez le composant de votre page de paiement dans un [fournisseur Elements](https://docs.stripe.com/sdks/stripejs-react.md?ui=elements#elements-provider). Appelez `loadStripe` avec votre clé publiable et transmettez la `Promise` renvoyée au fournisseur `Elements`. Transmettez également la [clé secrète du client](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) de l’étape précédente en tant qu’`options` au fournisseur `Elements`. ```jsx import React from 'react'; import ReactDOM from 'react-dom'; import {Elements} from '@stripe/react-stripe-js'; import {loadStripe} from '@stripe/stripe-js'; import CheckoutForm from './CheckoutForm'; // Make sure to call `loadStripe` outside of a component's render to avoid // recreating the `Stripe` object on every render. const stripePromise = loadStripe('<>'); function App() { const options = { // passing the client secret obtained in step 3 clientSecret: '{{CLIENT_SECRET}}', // Fully customizable with appearance API. appearance: {/*...*/}, }; return ( ); }; ReactDOM.render(, document.getElementById('root')); ``` ### Ajouter le composant Element Payment Utilisez le composant `PaymentElement` pour créer votre formulaire : ```jsx import React from 'react'; import {PaymentElement} from '@stripe/react-stripe-js'; const CheckoutForm = () => { return (
); }; export default CheckoutForm; ``` Stripe Elements est un ensemble de composants d’interface utilisateur modulables. Pour personnaliser davantage votre formulaire ou collecter d’autres informations client, consultez la [documentation relative à Elements](https://docs.stripe.com/payments/elements.md). Le composant Payment Element affiche un formulaire dynamique qui permet à votre client de choisir un moyen de paiement. Pour chaque moyen de paiement, le formulaire demande automatiquement au client de renseigner toutes les informations de paiement nécessaires. ### Personnaliser l’apparence Personnalisez le Payment Element pour qu’il corresponde à l’apparence de votre site en ajoutant l’[objet Appearance](https://docs.stripe.com/js/elements_object/create#stripe_elements-options-appearance) dans `options` lors de la création du fournisseur `Elements`. ### Collecter les adresses Par défaut, le Payment Element ne collecte que les informations nécessaires à la facturation. Certaines opérations, telles que le [calcul des taxes](https://docs.stripe.com/api/tax/calculations/create.md) ou la saisie des informations de livraison, nécessitent l’adresse complète de votre client. Vous pouvez : - Utilisez l’[Address Element](https://docs.stripe.com/elements/address-element.md) pour tirer parti des fonctionnalités de saisie automatique et de localisation et recueillir l’adresse complète de votre client. Cela permet de garantir un calcul des taxes le plus précis possible. - Recueillez l’adresse à l’aide de votre propre formulaire personnalisé. Après la confirmation, votre client voit automatiquement s’afficher une fenêtre modale contenant les détails du virement bancaire. ## Soumettre le paiement à Stripe [Côté client] Utilisez [stripe.confirmPayment](https://docs.stripe.com/js/payment_intents/confirm_payment) pour effectuer le paiement à l’aide des informations du composant Payment Element. Ajoutez un paramètre [return_url](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-return_url) à cette fonction pour indiquer la page vers laquelle Stripe doit rediriger l’utilisateur à l’issue du paiement. Votre utilisateur peut être redirigé en premier lieu vers un site intermédiaire, comme une page d’autorisation bancaire, avant d’être redirigé vers la page spécifiée par le paramètre `return_url`. L’utilisateur sera immédiatement redirigé vers la page `return_url` après un paiement réussi par carte. Si vous ne souhaitez pas effectuer de redirection à la fin des paiements par carte, vous pouvez assigner au paramètre [redirect](https://docs.stripe.com/js/payment_intents/confirm_payment#confirm_payment_intent-options-redirect) la valeur `if_required`. De cette manière, seuls les clients qui choisissent un moyen de paiement avec redirection seront redirigés. #### HTML + JS ```javascript const form = document.getElementById('payment-form'); form.addEventListener('submit', async (event) => { event.preventDefault(); const {error} = await stripe.confirmPayment({ //`Elements` instance that was used to create the Payment Element elements, confirmParams: { return_url: 'https://example.com/order/123/complete', }, }); if (error) { // This point will only be reached if there is an immediate error when // confirming the payment. Show error to your customer (for example, payment // details incomplete) const messageContainer = document.querySelector('#error-message'); messageContainer.textContent = error.message; } else { // Your customer will be redirected to your `return_url`. For some payment // methods like iDEAL, your customer will be redirected to an intermediate // site first to authorize the payment, then redirected to the `return_url`. } }); ``` #### React Pour appeler [stripe.confirmPayment](https://docs.stripe.com/js/payment_intents/confirm_payment) depuis votre composant de formulaire de paiement, utilisez les hooks [useStripe](https://docs.stripe.com/sdks/stripejs-react.md?ui=elements#usestripe-hook) et [useElements](https://docs.stripe.com/sdks/stripejs-react.md?ui=elements#useelements-hook). Si vous préférez les composants de classe traditionnels aux hooks, vous pouvez utiliser un [ElementsConsumer](https://docs.stripe.com/sdks/stripejs-react.md?ui=elements#elements-consumer). ```jsx import React, {useState} from 'react'; import {useStripe, useElements, PaymentElement} from '@stripe/react-stripe-js'; const CheckoutForm = () => { const stripe = useStripe(); const elements = useElements(); const [errorMessage, setErrorMessage] = useState(null); const handleSubmit = async (event) => { // We don't want to let default form submission happen here, // which would refresh the page. event.preventDefault(); if (!stripe || !elements) { // Stripe.js hasn't yet loaded. // Make sure to disable form submission until Stripe.js has loaded. return; } const {error} = await stripe.confirmPayment({ //`Elements` instance that was used to create the Payment Element elements, confirmParams: { return_url: 'https://example.com/order/123/complete', }, }); if (error) { // This point will only be reached if there is an immediate error when // confirming the payment. Show error to your customer (for example, payment // details incomplete) setErrorMessage(error.message); } else { // Your customer will be redirected to your `return_url`. For some payment // methods like iDEAL, your customer will be redirected to an intermediate // site first to authorize the payment, then redirected to the `return_url`. } }; return (
{/* Show error message to your customers */} {errorMessage &&
{errorMessage}
} ); }; export default CheckoutForm; ``` Veillez à ce que le paramètre `return_url` corresponde à une page de votre site web qui indique l’état du paiement. Lorsque Stripe redirige le client vers la page `return_url`, nous fournissons les paramètres de requête d’URL suivants : | Paramètre | Description | | ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------- | | `payment_intent` | L’identifiant unique du `PaymentIntent`. | | `payment_intent_client_secret` | La [clé secrète du client](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) de l’objet `PaymentIntent`. | > Si vous disposez d’outils qui assurent le suivi de la session navigateur du client, vous devrez peut-être ajouter le domaine `stripe.com` à la liste d’exclusion des sites référents. Les redirections font que certains outils créent de nouvelles sessions, ce qui empêche le suivi de la session dans son ensemble. Utilisez l’un des paramètres de requête pour récupérer le PaymentIntent. Consultez l’[état du PaymentIntent](https://docs.stripe.com/payments/paymentintents/lifecycle.md) pour déterminer les informations à présenter à vos clients. Vous pouvez également ajouter vos propres paramètres de requête lorsque vous ajoutez l’URL `return_url` ; ils seront conservés tout au long du processus de redirection. #### HTML + JS ```javascript // Initialize Stripe.js using your publishable key const stripe = Stripe('<>'); // Retrieve the "payment_intent_client_secret" query parameter appended to // your return_url by Stripe.js const clientSecret = new URLSearchParams(window.location.search).get( 'payment_intent_client_secret' ); // Retrieve the PaymentIntent stripe.retrievePaymentIntent(clientSecret).then(({paymentIntent}) => { const message = document.querySelector('#message') // Inspect the PaymentIntent `status` to indicate the status of the payment // to your customer. // // Some payment methods will [immediately succeed or fail][0] upon // confirmation, while others will first enter a `processing` state. // // [0]: https://stripe.com/docs/payments/payment-methods#payment-notification switch (paymentIntent.status) { case 'succeeded': message.innerText = 'Success! Payment received.'; break; case 'processing': message.innerText = "Payment processing. We'll update you when payment is received."; break; case 'requires_payment_method': message.innerText = 'Payment failed. Please try another payment method.'; // Redirect your user back to your payment page to attempt collecting // payment again break; default: message.innerText = 'Something went wrong.'; break; } }); ``` #### React ```jsx import React, {useState, useEffect} from 'react'; import {useStripe} from '@stripe/react-stripe-js'; const PaymentStatus = () => { const stripe = useStripe(); const [message, setMessage] = useState(null); useEffect(() => { if (!stripe) { return; } // Retrieve the "payment_intent_client_secret" query parameter appended to // your return_url by Stripe.js const clientSecret = new URLSearchParams(window.location.search).get( 'payment_intent_client_secret' ); // Retrieve the PaymentIntent stripe .retrievePaymentIntent(clientSecret) .then(({paymentIntent}) => { // Inspect the PaymentIntent `status` to indicate the status of the payment // to your customer. // // Some payment methods will [immediately succeed or fail][0] upon // confirmation, while others will first enter a `processing` state. // // [0]: https://stripe.com/docs/payments/payment-methods#payment-notification switch (paymentIntent.status) { case 'succeeded': setMessage('Success! Payment received.'); break; case 'processing': setMessage("Payment processing. We'll update you when payment is received."); break; case 'requires_payment_method': // Redirect your user back to your payment page to attempt collecting // payment again setMessage('Payment failed. Please try another payment method.'); break; default: setMessage('Something went wrong.'); break; } }); }, [stripe]); return message; }; export default PaymentStatus; ``` ### Collecter les informations du wallet Si vous acceptez Apple Pay ou Google Pay, appelez [elements.submit()](https://docs.stripe.com/js/elements/submit) au début de votre gestionnaire de soumission. Cela déclenche la validation du formulaire et affiche la page de paiement native pour que votre client puisse autoriser le paiement. #### HTML + JS ```javascript form.addEventListener('submit', async (event) => { event.preventDefault(); // Trigger form validation and wallet collection const {error: submitError} = await elements.submit(); if (submitError) { handleError(submitError); return; } // Confirm the payment }); ``` #### React ```jsx const handleSubmit = async (event) => { event.preventDefault(); if (!stripe || !elements) { // Stripe.js hasn't yet loaded. // Make sure to disable form submission until Stripe.js has loaded. return; } // Trigger form validation and wallet collection const {error: submitError} = await elements.submit(); if (submitError) { handleError(submitError); return; } // Confirm the payment }; ``` ## Optional: Envoyer des instructions sur les paiements par e-mail Vous pouvez activer les e-mails d’instruction sur les paiements par virement bancaire depuis le [Dashboard](https://dashboard.stripe.com/settings/emails). Une fois que vous avez activé les e-mails d’instruction sur les paiements, Stripe envoie un e-mail à votre client dans les cas suivants°: - Un PaymentIntent est confirmé, mais le client ne dispose pas d’un solde suffisant. - Le client envoie un virement bancaire mais ne dispose pas de fonds suffisants pour finaliser les paiements en attente. Un e-mail d’instruction sur les paiements par virement bancaire contient le montant dû, les informations bancaires pour le transfert de fonds, ainsi qu’un lien vers la page d’instructions hébergée par Stripe. > Dans un environnement de test, seules les adresses e-mail associées à un compte Stripe reçoivent des instructions sur les paiements par e-mail. ## Confirmer l'aboutissement du PaymentIntent Le PaymentIntent reste à l’état `requires_action` jusqu’à ce que les fonds arrivent sur le compte bancaire. Dès réception du paiement, l’état du PaymentIntent associé passe de `requires_action` à `succeeded`. Votre endpoint *webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) doit être configuré pour recevoir l’événement `payment_intent.partially_funded`. Stripe envoie cet événement si des fonds sont appliqués à un PaymentIntent mais que le paiement reste incomplet. Notez que lorsque vous confirmez un PaymentIntent pour la première fois et qu’il passe à l’état `requires_action`, Stripe envoie `payment_intent.requires_action` à la place, même si des fonds du solde client existant ont été appliqués au même moment. Vous pouvez [ajouter un webhook depuis le Dashboard](https://dashboard.stripe.com/webhooks/create). Vous pouvez aussi utiliser l’[API Webhook Endpoints](https://docs.stripe.com/api/webhook_endpoints.md) pour recevoir l’événement [payment_intent.partially_funded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.partially_funded). > La [CLI Stripe](https://docs.stripe.com/cli.md) ne prend pas en charge le déclenchement d’événements de la version bêta de l’API tels que `payment_intent.partially_funded`. Les événements suivants sont envoyés durant le flux de financement du paiement lorsque le PaymentIntent est mis à jour : | Événement | Description | Étapes suivantes | | --------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `payment_intent.requires_action` | Envoyé pendant la confirmation lorsque le solde du client ne dispose pas de fonds suffisants pour rapprocher le PaymentIntent, le PaymentIntent passe à l’état `requires_action`. | Demandez à votre client d’effectuer un virement bancaire correspondant au montant `amount_remaining`. | | `payment_intent.partially_funded` | Le client a fait un virement bancaire qui a été appliqué au PaymentIntent, mais cela n’a pas suffi à finaliser le paiement. Cela peut arriver si le client a viré un montant trop faible, si les frais bancaires ont réduit le montant reçu, ou si un solde client restant a été appliqué au PaymentIntent. Les PaymentIntents partiellement remboursés ne sont pas visibles dans le solde de votre compte tant que le paiement n’a pas été effectué. | Demandez à votre client de réaliser un autre virement bancaire correspondant au nouveau `amount_remaining` pour finaliser le paiement. Si vous souhaitez effectuer le paiement avec les fonds partiellement appliqués, vous pouvez mettre à jour le champ `amount` et [confirmer](https://docs.stripe.com/api/payment_intents/confirm.md) à nouveau le PaymentIntent. | | `payment_intent.succeeded` | Le paiement du client a abouti. | Traitez la commande de biens ou de services du client. | > Lorsque vous modifiez le montant d’un PaymentIntent partiellement financé, les fonds sont reversés sur le solde du client. Si d’autres PaymentIntents sont ouverts, Stripe les finance automatiquement. Si le client est configuré pour le rapprochement manuel, vous devez [utiliser les fonds](https://docs.stripe.com/api/payment_intents/apply_customer_balance.md) à nouveau. Nous vous recommandons d’[utiliser des webhooks](https://docs.stripe.com/payments/payment-intents/verifying-status.md#webhooks) afin de confirmer que le paiement a abouti et pour signaler au client que le paiement a été effectué. ### Exemple de code #### Ruby ```ruby require 'json' # Using Sinatra post '/webhook' do payload = request.body.read event = nil begin event = Stripe::Event.construct_from( JSON.parse(payload, symbolize_names: true) ) rescue JSON::ParserError => e # Invalid payload status 400 return end # Handle the event case event.type when 'payment_intent.requires_action' payment_intent = event.data.object # contains a Stripe::PaymentIntent # The payment intent was not fully funded due to insufficient funds # on the customer balance. Define and call a method to handle the payment intent. # handle_payment_intent_requires_action(payment_intent) when 'payment_intent.partially_funded' payment_intent = event.data.object # contains a Stripe::PaymentIntent # Then define and call a method to handle the payment intent being partially funded. # handle_payment_intent_partially_funded(payment_intent) when 'payment_intent.succeeded' payment_intent = event.data.object # contains a Stripe::PaymentIntent # Then define and call a method to handle the successful payment intent. # handle_payment_intent_succeeded(payment_intent) else puts "Unhandled event type: #{event.type}" end status 200 end ``` ### Consulter les paiements en attente sur le Dashboard Vous pouvez consulter les PaymentIntents associés à des virements bancaires en attente dans le [Dashboard](https://dashboard.stripe.com/payments) en appliquant le filtre **En attente de financement** au champ **État**. ## Tester votre intégration Vous pouvez tester votre intégration en simulant un virement bancaire entrant à l’aide de l’API, du Dashboard ou d’une version bêta de l’interface de ligne de commande Stripe. > #### Considérations relatives à Accounts v2 > > L’API Accounts v2 est généralement disponible pour les utilisateurs Connect, et en version bêta publique pour les autres utilisateurs Stripe. Si vous participez à la [version bêta d’Accounts v2](https://docs.stripe.com/accounts-v2/use-accounts-as-customers.md), vous devez [spécifier une version bêta](https://docs.stripe.com/api-v2-overview.md#sdk-and-api-versioning) dans votre code. > > Pour simuler un virement bancaire entrant pour un [Account](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-configuration-customer) configuré pour un client, utilisez l’endpoint Test Helpers avec l’ID de l’`Account` comme paramètre de chemin au lieu de l’ID du `Customer`, par exemple `v1/test_helpers/customers/acct_xxxxx/fund_cash_balance`. #### Dashboard Pour simuler un virement bancaire à l’aide du Dashboard, accédez à la page du client dans le *environnement de test* (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). Dans la section **Moyens de paiement**, cliquez sur **Ajouter** et sélectionnez **Ajouter des fonds au solde disponible (mode test uniquement)**. #### Inscription des utilisateurs reposant sur l'API Pour simuler un virement bancaire à l’aide de l’API : #### États-Unis ```bash curl https://api.stripe.com/v1/test_helpers/customers/{{CUSTOMER_ID}}/fund_cash_balance \ -X POST \ -u <>: \ -d "reference"="REF-4242" \ -d "amount"="1000" \ -d "currency"="usd" ``` #### Royaume-Uni ```bash curl https://api.stripe.com/v1/test_helpers/customers/{{CUSTOMER_ID}}/fund_cash_balance \ -X POST \ -u <>: \ -d "reference"="REF-4242" \ -d "amount"="1000" \ -d "currency"="gbp" ``` #### UE ```bash curl https://api.stripe.com/v1/test_helpers/customers/{{CUSTOMER_ID}}/fund_cash_balance \ -X POST \ -u <>: \ -d "reference"="REF-4242" \ -d "amount"="1000" \ -d "currency"="eur" ``` #### Japon ```bash curl https://api.stripe.com/v1/test_helpers/customers/{{CUSTOMER_ID}}/fund_cash_balance \ -X POST \ -u <>: \ -d "amount"="1000" \ -d "currency"="jpy" ``` #### Mexique ```bash curl https://api.stripe.com/v1/test_helpers/customers/{{CUSTOMER_ID}}/fund_cash_balance \ -X POST \ -u <>: \ -d "reference"="123456" \ -d "amount"="1000" \ -d "currency"="mxn" ``` #### CLI Stripe Pour simuler un virement bancaire avec l’interface de ligne de commande Stripe : 1. [Installer l’interface de ligne de commande Stripe](https://docs.stripe.com/cli.md). 2. Connectez-vous à l’interface de ligne de commande en utilisant le même compte que pour vous connecter au Dashboard Stripe. ```bash stripe login ``` 3. Simulez un virement bancaire entrant pour un client existant. #### États-Unis ```bash stripe test_helpers customers fund_cash_balance "{{CUSTOMER_ID}}" \ --amount=1099 \ --reference=DVGBG97TZ6ZV \ --currency=usd ``` Le paramètre `reference` est facultatif et simule la valeur renseignée par le client pour le champ de référence du virement bancaire. #### Royaume-Uni ```bash stripe test_helpers customers fund_cash_balance "{{CUSTOMER_ID}}" \ --amount=1099 \ --reference=DVGBG97TZ6ZV \ --currency=gbp ``` Le paramètre `reference` est facultatif et simule la valeur renseignée par le client pour le champ de référence du virement bancaire. #### UE ```bash stripe test_helpers customers fund_cash_balance "{{CUSTOMER_ID}}" \ --amount=1099 \ --reference=DVGBG97TZ6ZV \ --currency=eur ``` Le paramètre `reference` est facultatif et simule la valeur renseignée par le client pour le champ de référence du virement bancaire. #### Japon ```bash stripe test_helpers customers fund_cash_balance "{{CUSTOMER_ID}}" \ --amount=1000 \ --currency=jpy ``` #### Mexique ```bash stripe test_helpers customers fund_cash_balance "{{CUSTOMER_ID}}" \ --amount=1099 \ --reference=123456 \ --currency=mxn ``` Le paramètre `reference` est facultatif et simule la valeur renseignée par le client pour le champ de référence du virement bancaire. ## Gestion des problèmes de disponibilité temporaires Les codes d’erreur suivants indiquent que des problèmes temporaires affectent la disponibilité du moyen de paiement : | Code | Description | Gestion | | ------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `payment_method_rate_limit_exceeded` | Un trop grand nombre de requêtes successives ont été effectuées pour ce moyen de paiement, dont les limites sont plus strictes que les [limites de débit à l’échelle de l’API](https://docs.stripe.com/rate-limits.md). | Lorsque de nombreux clients tentent d’utiliser le même moyen de paiement (par exemple, pendant la période des soldes), ces erreurs peuvent perdurer pendant plusieurs requêtes API. Dans ce cas, demandez à vos utilisateurs de choisir un autre moyen de paiement. | > Si vous prévoyez une utilisation intensive, que ce soit de manière générale ou pour un événement à venir, veillez à nous prévenir aussitôt que possible.