# Paiements par prélèvement automatique Bacs

Acceptez les paiements par prélèvement automatique Bacs de clients titulaires d'un compte bancaire au Le Royaume-Uni.

# Paiement

> This is a Paiement for when payment-ui is checkout. View the full page at https://docs.stripe.com/payments/bacs-debit/accept-a-payment?payment-ui=checkout.

> Stripe peut automatiquement proposer les moyens de paiement pertinents à vos clients en évaluant la devise, les restrictions liées aux moyens de paiement et d’autres paramètres.
> 
> - Suivez le guide [Accepter un paiement](https://docs.stripe.com/payments/accept-a-payment.md?payment-ui=checkout&ui=stripe-hosted) pour créer une intégration de paiement qui utilise des [moyens de paiement dynamiques](https://docs.stripe.com/payments/payment-methods/dynamic-payment-methods.md).
- Si vous ne souhaitez pas utiliser de moyens de paiement dynamiques, suivez les étapes ci-dessous pour configurer manuellement les moyens de paiement dans votre intégration Checkout.

Les utilisateurs de Stripe au Royaume-Uni peuvent utiliser [Checkout](https://docs.stripe.com/payments/checkout.md) en mode paiement pour accepter les paiements par prélèvement automatique Bacs.

Une [session Checkout](https://docs.stripe.com/api/checkout/sessions.md) représente les détails de l’intention d’achat de votre client. Vous créez une session Checkout lorsque votre client souhaite effectuer un paiement. Après avoir redirigé votre client vers une session Checkout, Stripe affiche un formulaire de paiement qui permet à votre client d’effectuer son achat. Une fois le paiement finalisé, Stripe redirige le client vers votre site.

## Configurer Stripe [Côté serveur]

Pour commencer, il vous faut un compte Stripe. [Inscrivez-vous](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 des produits et des tarifs

Pour pouvoir utiliser Checkout, vous devez d’abord créer un *produit* (Products represent what your business sells—whether that's a good or a service) et un *tarif* (Prices define how much and how often to charge for products. This includes how much the product costs, what currency to use, and the interval if the price is for subscriptions). Vous devez créer un produit pour chacune de vos marchandises ou chacun de vos niveaux de service. Un produit peut être associé à un ou plusieurs tarifs.

Par exemple, vous pouvez créer un *produit* T-shirt associé à deux *tarifs* dans deux devises différentes : 20 GBP et 25 EUR. Vous pouvez ainsi modifier et ajouter des tarifs sans devoir changer les détails des produits sous-jacents. Il est possible de créer un produit et un tarif via [l’API](https://docs.stripe.com/api/prices.md) ou dans [le Dashboard](https://dashboard.stripe.com/products).

Si vous déterminez votre tarif au moment du paiement (par exemple si le client fixe le montant d’une donation) ou si vous ne souhaitez pas créer de tarif en amont, vous pouvez également créer des [tarifs ponctuels](https://docs.stripe.com/payments/accept-a-payment.md?platform=web#redirect-customers) au moment de la création d’une session Checkout pour un produit existant.

> Si vous disposez d’une intégration Checkout existante qui n’utilise pas Prices, l’API Checkout a évolué depuis l’introduction de Prices. Vous pouvez utiliser ce [guide de migration](https://docs.stripe.com/payments/checkout/migrating-prices.md) pour procéder à une mise à niveau, ou bien [conserver votre intégration existante](https://support.stripe.com/questions/prices-api-and-existing-checkout-integrations) en l’état.

#### Dashboard

> Les produits créés en environnement de test peuvent être copiés en mode production pour vous éviter d’avoir à les recréer. Dans la vue Détails du produit du Dashboard, cliquez sur **Copier vers le mode production** en haut à droite. Vous ne pouvez effectuer cette opération qu’une seule fois par produit créé en environnement de test. Si vous modifiez un produit test par la suite, ces modifications ne seront pas répercutées en mode production.

Vérifiez que vous êtes dans un environnement de test, puis définissez les articles que vous souhaitez vendre. Pour créer un nouveau produit et un nouveau prix :

- Accédez à la section [Produits](https://dashboard.stripe.com/test/products) du Dashboard.
- Cliquez sur **Ajouter un produit**.
- Sélectionnez **Ponctuel** lors de la définition du tarif.

Le nom de produit, la description et l’image que vous indiquez sont présentées aux clients dans Checkout.

#### API

Lors de la création d’un [produit](https://docs.stripe.com/api/products.md) avec l’API, seul l’attribut `name` est obligatoire. Les attributs `name`, `description` et `images` que vous indiquez sont présentés aux clients sur Checkout.

```curl
curl https://api.stripe.com/v1/products \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d name=T-shirt
```

Ensuite, créez un objet [Price](https://docs.stripe.com/api/prices.md) pour définir le tarif de votre produit, c’est-à-dire son montant et sa devise. Les paiements par prélèvement automatique Bacs doivent être effectués en GBP.

```curl
curl https://api.stripe.com/v1/prices \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "product={{PRODUCT_ID}}" \
  -d unit_amount=2000 \
  -d currency=gbp
```

## Créer une session Checkout [Côté client] [Côté serveur]

Ajoutez sur votre site Web un bouton de paiement qui appelle un endpoint côté serveur afin de créer une session Checkout.

```html
<html>
  <head>
    <title>Checkout</title>
  </head>
  <body>
    <form action="/create-checkout-session" method="POST">
      <button type="submit">Checkout</button>
    </form>
  </body>
</html>
```

Créez une session Checkout avec [line_items](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-line_items). Les postes de facture représentent la liste des articles achetés par le client.

Lorsque votre client effectue son paiement avec succès, il est redirigé vers le `success_url`, une page de votre site web qui informe le client que les informations de paiement ont été correctement collectées et que son paiement est en cours de traitement.

Lorsque votre client clique sur votre logo dans une session Checkout sans effectuer de paiement, Checkout le redirige vers le site Web que le client consultait avant d’être redirigé vers Checkout.

Checkout peut accepter un paiement et enregistrer le moyen de paiement utilisé pour réutilisation ultérieure. Les moyens de paiement enregistrés ainsi peuvent être utilisés pour de futurs paiements à l’aide d’un [PaymentIntent](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method). Une fois la session Checkout créée, 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 <<YOUR_SECRET_KEY>>: \
  -d "payment_method_types[]"="bacs_debit" \
  -d "line_items[][price]"="{{PRICE_ID}}" \
  -d "line_items[][quantity]"=1 \
  -d "mode"="payment" \
  -d "customer"="{{CUSTOMER_ID}}" \
  -d "payment_intent_data[setup_future_usage]"="off_session" \
  -d "success_url"="https://example.com/success?session_id={CHECKOUT_SESSION_ID}"
```

> Les règles applicables aux prélèvements automatiques Bacs prévoient l’envoi obligatoire au client d’une [notification de prélèvement par e-mail](https://docs.stripe.com/payments/payment-methods/bacs-debit.md#debit-notifications) à la collecte initiale de ses informations de paiement et lorsque son compte est débité. Par défaut, ces e-mails sont envoyés automatiquement par Stripe.

La création d’une session Checkout renvoie un [ID de session](https://docs.stripe.com/api/checkout/sessions/object.md#checkout_session_object-id). Mettez l’ID de session à disposition sur votre page de confirmation en incluant le modèle de variable `{CHECKOUT_SESSION_ID}` dans l’URL `success_url`, comme illustré ci-dessus.

> Ne vous fiez pas uniquement à la redirection vers `success_url` pour détecter l’initiation d’un paiement, car&nbsp;:
> 
> - 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`.

## Gérer les événements post-paiement [Côté serveur]

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, le prélèvement automatique Bacs est un moyen de paiement à notification différée, ce qui signifie que les fonds ne sont pas immédiatement disponibles. Un paiement par prélèvement Bacs Direct Debit prend généralement 3&nbsp;jours ouvrables pour que les fonds soient disponibles. Pour cette raison, vous voudrez différer le *traitement de la commande* (Fulfillment is the process of providing the goods or services purchased by a customer, typically after payment is collected) jusqu’à ce que les fonds soient disponibles. Une fois le paiement réussi, le statut sous-jacent du *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`.

Les événements Checkout suivants sont envoyés lorsque l’état du paiement change&nbsp;:

| 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 paiement du client a abouti.                                                      | Traitez la commande de biens ou de services du client.                          |
| [checkout.session.async_payment_failed](https://docs.stripe.com/api/events/types.md#event_types-checkout.session.async_payment_failed)       | Le paiement du client a été refusé, ou il a échoué pour une autre raison.            | Contactez le client par e-mail et demandez-lui de passer une nouvelle commande. |

Votre code de *webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) doit gérer ces trois événements Checkout.

La charge utile de chaque webhook Checkout inclut l’objet [Session Checkout](https://docs.stripe.com/api/checkout/sessions.md), qui contient des informations sur l’objet *Customer* (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).

Le webhook `checkout.session.completed` est envoyé à votre serveur avant que votre client ne soit redirigé. Votre acceptation du webhook (tout code d’état `2xx`) déclenche la redirection du client vers la page `success_url`. Si Stripe ne reçoit pas de confirmation dans les 10&nbsp;secondes suivant un paiement ayant abouti, votre client est automatiquement redirigé vers la page `success_url`.

Sur votre page `success_url`, affichez un message de confirmation à votre client, en l’informant du délai de quelques jours qui vous sera nécessaire pour le traitement de sa commande, compte tenu du fait que les prélèvements automatiques Bacs ne sont pas instantanés.

Si vous acceptez les paiements instantanés (par carte bancaire, par exemple) en plus des paiements à notification différée, vous devrez modifier votre endpoint de webhook de façon à ce que les deux types de paiements soient gérés lors de la réception d’un événement `checkout.session.completed`.

#### 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.
client = Stripe::StripeClient.new('<<YOUR_SECRET_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']

    # Check if the order is paid (for example, from a card payment)
    payment_intent = client.v1.payment_intents.retrieve(session.payment_intent)
    # A delayed notification payment will have the status 'processing'
    order_paid = payment_intent.status == "succeeded"

    # Save an order in your database, marked as 'awaiting payment'
    create_order(session)

    if order_paid
      fulfill_order(session)
    end
  when 'checkout.session.async_payment_succeeded'
    session = event['data']['object']

    # Fulfill the purchase...
    fulfill_order(session)
  when 'checkout.session.async_payment_failed'
    session = event['data']['object']

    # Send an email to the customer asking them to retry their order
    email_customer_about_failed_payment(session)
  end

  status 200
end
```

Vous pouvez obtenir des informations concernant le client et le paiement en récupérant les objets Customer et PaymentIntent référencés par les propriétés `customer`, `payment_intent` dans la charge utile du webhook.

### 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&nbsp;:

```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).

## Tester l'intégration

À ce stade, vous disposez théoriquement d’une intégration de prélèvement automatique Bacs de base, capable de recueillir les coordonnées bancaires de vos clients et d’accepter leurs paiements.

Vous avez à votre disposition plusieurs [numéros de compte bancaire de test](https://docs.stripe.com/keys.md#test-live-modes) dans un *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) pour vérifier que cette intégration est prête.

| Code guichet | Numéro de compte | Description                                                                                                                                                                                                                                                        |
| ------------ | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| 108800       | 00012345         | Le paiement aboutit et l’état du PaymentIntent passe de `processing` à `succeeded`.                                                                                                                                                                                |
| 108800       | 90012345         | Le paiement aboutit au bout de trois&nbsp;minutes et l’état du PaymentIntent passe de `processing` à `succeeded`.                                                                                                                                                  |
| 108800       | 33333335         | Le paiement est accepté, puis échoue immédiatement avec le code d’échec `debit_not_authorized`, et le PaymentIntent passe de l’état `processing` à l’état `requires_payment_method`. Le Mandat devient `inactive` et le PaymentMethod ne peut plus être réutilisé. |
| 108800       | 93333335         | Le paiement échoue après trois minutes avec le code d’échec `debit_not_authorized`, et le PaymentIntent passe de l’état `processing` à l’état `requires_payment_method`. Le Mandat devient `inactive` et le PaymentMethod ne peut plus être utilisé.               |
| 108800       | 22222227         | Le paiement échoue avec un code d’échec `insufficient_funds` et le PaymentIntent bascule de `processing` à `requires_payment_method`. L’objet Mandate reste `active` et le PaymentMethod peut à nouveau être utilisé.                                              |
| 108800       | 92222227         | Le paiement échoue au bout de trois&nbsp;minutes avec un code d’échec `insufficient_funds` et le PaymentIntent bascule de `processing` à `requires_payment_method`. L’objet Mandate reste `active` et le PaymentMethod peut à nouveau être utilisé.                |
| 108800       | 55555559         | Le paiement aboutit au bout de trois&nbsp;minutes et l’état du PaymentIntent passe de `processing` à `succeeded`, mais un litige est immédiatement créé.                                                                                                           |
| 108800       | 00033333         | La création du moyen de paiement aboutit, mais le mandat est refusé par la banque du client et passe immédiatement à l’état inactif.                                                                                                                               |
| 108800       | 00044444         | La demande de configuration de Bacs Direct Debit échoue immédiatement en raison d’un numéro de compte invalide, et le client est invité à mettre à jour ses informations avant l’envoi. Les informations de paiement ne sont pas collectées.                       |
| 108800       | 34343434         | Le paiement échoue avec un code d’erreur `charge_exceeds_source_limit`, car le montant du paiement entraîne un dépassement de la limite hebdomadaire de volume de paiement du compte.                                                                              |
| 108800       | 12121212         | Le paiement échoue avec un code d’erreur `charge_exceeds_weekly_limit`, car le montant du paiement dépasse la limite du volume de transactions du compte.                                                                                                          |

Pour vos tests, vous pouvez utiliser l’un des numéros de compte fournis ci-dessus. Cependant, dans la mesure où le traitement des paiements par prélèvement automatique Bacs prend plusieurs jours, privilégiez les numéros de compte de test qui fonctionnent avec un délai de trois minutes, de manière à mieux simuler le comportement en situation réelle.

> Par défaut, Stripe envoie automatiquement des [e-mails](https://docs.stripe.com/payments/payment-methods/bacs-debit.md#debit-notifications) de notification au client lors de la collecte initiale de ses données de paiement et chaque fois qu’un débit est ensuite effectué sur son compte. Ces notifications ne sont pas envoyées dans les environnements de test.

## Échecs de paiement

Un paiement peut échouer pour de nombreuses raisons. Le motif d’un échec est indiqué par son [charge.failure_code](https://docs.stripe.com/api/charges/object.md#charge_object-failure_code). Seuls les paiements présentant certains codes d’échec peuvent être retentés. Lorsqu’une nouvelle tentative n’est pas possible, il convient de contacter votre client pour lui demander de renouveler son règlement avec un compte bancaire ou un moyen de paiement différent.

Les codes d’échec que nous envoyons actuellement pour les prélèvements automatiques Bacs sont indiqués ci-dessous. Cette liste est susceptible d’être enrichie à tout moment, et il importe donc de ne pas la considérer comme exhaustive dans le cadre du développement et de la maintenance de votre code.

| Code d’échec                | Description                                                                                                                                                                                                 | Nouvelle tentative possible |
| --------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------- |
| `account_closed`            | Le compte bancaire a été clôturé.                                                                                                                                                                           | Non                         |
| `bank_ownership_changed`    | Le compte a été transféré vers un nouveau prestataire de paiement (PSP). Vérifiez si on vous a communiqué les coordonnées du nouveau PSP. Sinon, vous devez obtenir un nouveau mandat de la part du client. | Non                         |
| `debit_not_authorized`      | Le client a informé sa banque que le paiement n’était pas autorisé ou la banque payeuse ne détient aucun mandat.                                                                                            | Non                         |
| `generic_could_not_process` | Ce paiement n’a pas pu être traité.                                                                                                                                                                         | Oui                         |
| `insufficient_funds`        | Le compte du client ne dispose pas de fonds suffisants pour couvrir le paiement.                                                                                                                            | Oui                         |
| `invalid_account_number`    | Le numéro de compte n’est pas valide. Cela peut signifier qu’il ne s’agit pas d’un compte en GBP ou que le compte ne peut pas traiter les paiements par prélèvement automatique.                            | Non                         |

Pour effectuer une nouvelle tentative de paiement, [confirmez le PaymentIntent](https://docs.stripe.com/api/payment_intents/confirm.md) à nouveau à l’aide du même *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs).

Pour mettre toutes les chances de votre côté que le paiement aboutisse, nous vous conseillons de contacter le payeur avant la nouvelle tentative.

## Optional: Configurer la date de prélèvement du client

Vous pouvez contrôler la date à laquelle Stripe débite le compte bancaire d’un client à l’aide du paramètre [target date](https://docs.stripe.com/api/checkout/sessions/object.md#checkout_session_object-payment_method_options-bacs_debit-target_date). La date cible doit être au moins trois jours dans le futur et ne pas dépasser 15&nbsp;jours à compter de la date actuelle.

La date cible permet de prévoir que l’argent quitte le compte du client à la date cible.

Les dates cibles qui répondent à l’un des critères suivants retardent le débit jusqu’au prochain jour ouvrable disponible&nbsp;:

- La date butoir est un week-end, un jour férié ou un autre jour non ouvrable.
- La date butoir est fixée moins de trois&nbsp;jours ouvrables dans le futur.

Ce paramètre fonctionne dans la mesure du possible. En effet, la banque de chaque client peut traiter les prélèvements à des dates différentes, en fonction des jours fériés locaux ou d’autres raisons.


# Elements

> This is a Elements for when payment-ui is elements. View the full page at https://docs.stripe.com/payments/bacs-debit/accept-a-payment?payment-ui=elements.

Pour accepter les paiements par prélèvement automatique Bacs sur votre site Web, vous devez créer un objet permettant de suivre le paiement, collecter les informations relatives au moyen de paiement et l’accusé de réception du mandat, soumettre le paiement à Stripe pour traitement et vérifier le compte bancaire de votre client.

Stripe utilise cet objet de paiement, appelé [PaymentIntent](https://docs.stripe.com/payments/payment-intents.md), pour suivre et gérer tous les états du paiement jusqu’à ce que celui-ci soit effectué.

## Configurer Stripe [Côté serveur]

Pour commencer, il vous faut un compte Stripe. [Inscrivez-vous](https://dashboard.stripe.com/register).

Utilisez nos bibliothèques officielles pour accéder à l’API Stripe depuis votre application&nbsp;:

#### 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]

Pour réutiliser un compte bancaire à l’occasion de paiements ultérieurs, le compte en question doit être associé à un objet *Customer* (Customer objects represent customers of your business. They let you reuse payment methods and give you the ability to track multiple payments).

Créez un objet `Customer` lorsque votre client crée un compte auprès de votre entreprise. L’association de l’ID de l’objet `Customer` à votre propre représentation interne d’un client vous permet de récupérer et d’utiliser ultérieurement les informations relatives aux moyens de paiement sauvegardé.

Créez ou récupérez un objet `Customer` afin de l’associer à ce paiement. Pour créer un nouvel objet `Customer`, ajoutez le code ci-après sur votre serveur créer un nouveau `Customer`&nbsp;:

```curl
curl -X POST https://api.stripe.com/v1/customers \
  -u "<<YOUR_SECRET_KEY>>:"
```

## Collecter les informations relatives au moyen de paiement

> Les règles relatives aux prélèvements automatiques Bacs prévoient l’acceptation d’un mandat de la part du client commande que Stripe puisse débiter son compte. Le [Payment Element](https://docs.stripe.com/payments/payment-element.md) collecter ce mandat lorsque vous acceptez les données de paiement du client. Aucune action n’est requise de votre part pour vous être conforme à cette exigence.

Vous êtes prêt à recueillir les informations de paiement de votre client à l’aide du composant Element Payment, un composant préconfiguré de l’interface utilisateur qui simplifie cette collecte 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.

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 Payment Element est automatiquement disponible en tant que fonctionnalité de Stripe.js. Intégrez le script Stripe.js à votre page de paiement en l’ajoutant au `head` votre fichier HTML. Chargez toujours Stripe.js directement à partir de js.stripe.com pour rester conforme aux normes PCI. N’incluez pas le script dans un lot et n’en hébergez pas de copie.

```html
<head>
  <title>Checkout</title>
  <script src="https://js.stripe.com/dahlia/stripe.js"></script>
</head>
```

Créez une instance de Stripe avec le code JavaScript suivant sur votre page de paiement&nbsp;:

```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('<<YOUR_PUBLISHABLE_KEY>>');
```

### Ajouter le composant Payment&nbsp;Element à votre page de paiement

Le Payment Element doit avoir un emplacement sur votre page de paiement. Créez un nœud DOM (conteneur) vide avec un ID unique dans votre formulaire de paiement&nbsp;:

```html
<form id="payment-form">
  <div id="payment-element">
    <!-- Elements will create form elements here -->
  </div>
  <button id="submit">Submit</button>
  <div id="error-message">
    <!-- Display error message to your customers here -->
  </div>
</form>
```

#### Contrôler les moyens de paiement dans le Dashboard

Une fois le formulaire ci-dessus chargé, créez une instance Elements avec les paramètres `mode`, `amount` et `currency`. Ces valeurs déterminent les moyens de paiement présentés à votre client. Pour proposer un nouveau moyen de paiement dans votre formulaire, veillez à l’activer dans le [Dashboard](https://dashboard.stripe.com/settings/payment_methods).

```javascript
const options = {mode:'payment',
  amount:1099,
  currency: 'gbp',
  // Fully customizable with appearance API.
  appearance: {/*...*/},
};

// Set up Stripe.js and Elements to use in checkout formconst elements = stripe.elements(options);

// Create and mount the Payment Element
const paymentElementOptions = { layout: 'accordion'};
const paymentElement = elements.create('payment', paymentElementOptions);
paymentElement.mount('#payment-element');
```

#### Répertorier manuellement les moyens de paiement

Pour lister manuellement les moyens de paiement que vous souhaitez proposer, ajoutez chacun d’eux à `paymentMethodTypes`.

Ensuite, créez une instance de l’Element Payment et montez-la sur le nœud DOM conteneur.

```javascript
const options = {mode:'payment',
  amount:1099,
  currency: 'gbp',
  paymentMethodTypes: ['bacs_debit'],
  // Fully customizable with appearance API.
  appearance: {/*...*/},
};

// Set up Stripe.js and Elements to use in checkout formconst 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 et configurer le fournisseur Elements sur votre page de paiement

Pour utiliser le composant Payment&nbsp;Element, incluez votre composant de page de paiement dans un [fournisseur Elements](https://docs.stripe.com/sdks/stripejs-react.md#elements-provider). Appelez `loadStripe` avec votre clé publique et transmettez le paramètre `Promise` renvoyé au fournisseur `Elements`.

#### Contrôler les moyens de paiement dans le Dashboard

Le fournisseur `Elements` accepte également les paramètres `mode`, `amount` et `currency`. Ces valeurs déterminent les moyens de paiement présentés à votre client. Pour proposer un nouveau moyen de paiement dans votre formulaire, veillez à l’activer dans le [Dashboard](https://dashboard.stripe.com/settings/payment_methods).

```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('<<YOUR_PUBLISHABLE_KEY>>');

function App() {
  const options = {mode:'payment',
    amount:1099,
    currency: 'gbp',
    // Fully customizable with appearance API.
    appearance: {/*...*/},
  };

  return (
    <Elements stripe={stripePromise} options={options}>
      <CheckoutForm />
    </Elements>
  );
};

ReactDOM.render(<App />, document.getElementById('root'));
```

#### Répertorier manuellement les moyens de paiement

```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('<<YOUR_PUBLISHABLE_KEY>>');

function App() {
  const options = {mode:'payment',
    amount:1099,
    currency: 'gbp',
    paymentMethodTypes: ['bacs_debit'],
    // Fully customizable with appearance API.
    appearance: {/*...*/},
  };

  return (
    <Elements stripe={stripePromise} options={options}>
      <CheckoutForm />
    </Elements>
  );
};

ReactDOM.render(<App />, document.getElementById('root'));
```

### Ajouter le composant Payment Element

Utilisez le composant `PaymentElement` pour créer votre formulaire.

```jsx
import React from 'react';
import {PaymentElement} from '@stripe/react-stripe-js';

const CheckoutForm = () => {
  return (
    <form><PaymentElement />
      <button>Submit</button>
    </form>
  );
};

export default CheckoutForm;
```

Vous pouvez personnaliser le Payment&nbsp;Element pour l’adapter au design de votre site en transmettant l’[objet Appearance](https://docs.stripe.com/elements/appearance-api.md) dans les `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&nbsp;:

- 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é.

## Créer un PaymentIntent [Côté serveur]

> #### Exécuter une logique métier personnalisée immédiatement avant la confirmation du paiement
> 
> Accédez à l’[étape&nbsp;5](https://docs.stripe.com/payments/finalize-payments-on-the-server.md?platform=web&type=payment#submit-payment) du guide «&nbsp;Finaliser&nbsp;» les paiements pour exécuter votre logique métier personnalisée immédiatement avant la confirmation du paiement. Sinon, suivez la procédure ci-dessous pour une intégration plus simple, qui utilise `stripe.confirmPayment` au niveau du client afin de confirmer le paiement et gérer les actions qui pourraient suivre.

#### Contrôler les moyens de paiement dans le Dashboard

Lorsque le client envoie votre formulaire de paiement, utilisez un *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) pour faciliter le processus de confirmation et de paiement. Créez un PaymentIntent sur votre serveur avec les paramètres `amount` et `currency`. Pour éviter que des clients malveillants ne choisissent eux-mêmes leurs tarifs, fixez systématiquement le montant à débiter côté serveur (un environnement sécurisé) plutôt que côté client.

Un objet `PaymentIntent` contient une *clé secrète du client* (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)). Renvoyez cette valeur côté client afin que Stripe.js l’utilise pour finaliser le processus de paiement en toute sécurité.

#### Accounts&nbsp;v2

#### Ruby

```ruby
require 'stripe'
client = Stripe::StripeClient.new('<<YOUR_SECRET_KEY>>')

post '/create-intent' do
  intent = client.v1.payment_intents.create({
    # To allow saving and retrieving payment methods, provide the customer's Account ID.
    customer_account: "{{CUSTOMER_ACCOUNT_ID}}",
    amount: 1099,
    currency: 'gbp',
  })
  {client_secret: intent.client_secret}.to_json
end
```

#### Customers&nbsp;v1

#### Ruby

```ruby
require 'stripe'
client = Stripe::StripeClient.new('<<YOUR_SECRET_KEY>>')

post '/create-intent' do
  intent = client.v1.payment_intents.create({
    # To allow saving and retrieving payment methods, provide the Customer ID.
    customer: customer.id,
    amount: 1099,
    currency: 'gbp',
  })
  {client_secret: intent.client_secret}.to_json
end
```

#### Répertorier manuellement les moyens de paiement

Lorsque le client envoie votre formulaire de paiement, utilisez un *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) pour faciliter le processus de confirmation et de paiement. Créez un PaymentIntent sur votre serveur avec un `amount`, une `currency` et un ou plusieurs moyens de paiement à l’aide de `payment_method_types`. Pour éviter que des clients malveillants ne puissent définir eux-mêmes leurs tarifs, fixez systématiquement le montant à débiter côté serveur (un environnement sécurisé) plutôt que côté client.

L’objet PaymentIntent contient une *clé secrète du client* (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)). Renvoyez cette valeur côté client afin que Stripe.js l’utilise pour finaliser le processus de paiement en toute sécurité.

#### Ruby

```ruby
require 'stripe'
client = Stripe::StripeClient.new('<<YOUR_SECRET_KEY>>')

post '/create-intent' do
  intent = client.v1.payment_intents.create({
    # To allow saving and retrieving payment methods, provide the Customer ID.
    customer: customer.id,
    amount: 1099,
    currency: 'gbp',
    payment_method_types: ['bacs_debit'],
  })
  {client_secret: intent.client_secret}.to_json
end
```

## Envoyer le paiement à Stripe [Côté client]

Utilisez [stripe.confirmPayment](https://docs.stripe.com/js/payment_intents/confirm_payment) pour finaliser le paiement à l’aide des informations du composant Payment&nbsp;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 à Stripe où rediriger l’utilisateur une fois le paiement effectué. Dans un premier temps, votre utilisateur sera peut-être redirigé vers un site intermédiaire, comme une page d’autorisation bancaire, avant d’être redirigé vers l’URL `return_url`. Une fois le paiement par carte abouti, l’utilisateur est immédiatement redirigé vers l’URL `return_url`.

Si vous ne souhaitez pas effectuer de redirection à la fin des paiements par carte, vous pouvez définir le paramètre [redirect](https://docs.stripe.com/js/payment_intents/confirm_payment#confirm_payment_intent-options-redirect) sur `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');
const submitBtn = document.getElementById('submit');

const handleError = (error) => {
  const messageContainer = document.querySelector('#error-message');
  messageContainer.textContent = error.message;
  submitBtn.disabled = false;
}

form.addEventListener('submit', async (event) => {
  // We don't want to let default form submission happen here,
  // which would refresh the page.
  event.preventDefault();

  // Prevent multiple form submissions
  if (submitBtn.disabled) {
    return;
  }

  // Disable form submission while loading
  submitBtn.disabled = true;

  // Trigger form validation and wallet collection
  const {error: submitError} = await elements.submit();
  if (submitError) {
    handleError(submitError);
    return;
  }

  // Create the PaymentIntent and obtain clientSecret
  const res = await fetch("/create-intent", {
    method: "POST",
  });

  const {client_secret: clientSecret} = await res.json();

  // Confirm the PaymentIntent using the details collected by the Payment Element
  const {error} = await stripe.confirmPayment({
    elements,
    clientSecret,
    confirmParams: {
      return_url: 'https://example.com/order/123/complete',
    },
  });

  if (error) {
    // This point is only reached if there's an immediate error when
    // confirming the payment. Show the error to your customer (for example, payment details incomplete)
    handleError(error);
  } else {
    // Your customer is redirected to your `return_url`. For some payment
    // methods like iDEAL, your customer is redirected to an intermediate
    // site first to authorize the payment, then redirected to the `return_url`.
  }
});

```

#### React

```jsx
import React, {useState} from 'react';
import {useStripe, useElements, PaymentElement} from '@stripe/react-stripe-js';

export default function CheckoutForm() {
  const stripe = useStripe();
  const elements = useElements();

  const [errorMessage, setErrorMessage] = useState();
  const [loading, setLoading] = useState(false);

  const handleError = (error) => {
    setLoading(false);
    setErrorMessage(error.message);
  }

  const handleSubmit = async (event) => {
    // We don't want to let default form submission happen here,
    // which would refresh the page.
    event.preventDefault();

    if (!stripe) {
      // Stripe.js hasn't yet loaded.
      // Make sure to disable form submission until Stripe.js has loaded.
      return;
    }

    setLoading(true);

    // Trigger form validation and wallet collection
    const {error: submitError} = await elements.submit();
    if (submitError) {
      handleError(submitError);
      return;
    }

    // Create the PaymentIntent and obtain clientSecret
    const res = await fetch("/create-intent", {
      method: "POST",
    });

    const {client_secret: clientSecret} = await res.json();

    // Confirm the PaymentIntent using the details collected by the Payment Element
    const {error} = await stripe.confirmPayment({
      elements,
      clientSecret,
      confirmParams: {
        return_url: 'https://example.com/order/123/complete',
      },
    });

    if (error) {
      // This point is only reached if there's an immediate error when
      // confirming the payment. Show the error to your customer (for example, payment details incomplete)
      handleError(error);
    } else {
      // Your customer is redirected to your `return_url`. For some payment
      // methods like iDEAL, your customer is redirected to an intermediate
      // site first to authorize the payment, then redirected to the `return_url`.
    }
  };

  return (
    <form onSubmit={handleSubmit}>
      <PaymentElement />
      <button type="submit" disabled={!stripe || loading}>
        Submit Payment
      </button>
      {errorMessage && <div>{errorMessage}</div>}
    </form>
  );
}
```

## Gérer les événements post-paiement

Le prélèvement automatique Bacs est un *moyen de paiement à notification différée* (A payment method that can't immediately return payment status when a customer attempts a transaction (for example, ACH debits). Businesses commonly hold an order in a pending state until payment is successful with these payment methods), de sorte que les fonds ne sont pas immédiatement disponibles.

### Calendrier

Avec Bacs Direct Debit, plusieurs jours ouvrables peuvent être nécessaires avant que les fonds soient disponibles sur votre solde Stripe. Le nombre de jours ouvrables nécessaires pour que les fonds soient disponibles est appelé «&nbsp;délai de règlement&nbsp;». Les paiements sont généralement soumis le jour même de leur création, mais ils sont traités le jour ouvrable suivant s’ils sont créés un jour non ouvrable ou après l’heure limite.

Vous pouvez accéder à `expected_debit_date` pour Bacs Direct Debit sous [payment_method_details](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details) pour [Charges](https://docs.stripe.com/api/charges/object.md). C’est la date estimée pour le débit des fonds. Cette estimation n’est pas garantie et la date réelle peut varier. Ces informations sont disponibles dans les réponses API et dans les événements webhook [charge.updated](https://docs.stripe.com/api/events/types.md#event_types-charge.updated), [charge.succeeded](https://docs.stripe.com/api/events/types.md#event_types-charge.succeeded) et [charge.failed](https://docs.stripe.com/api/events/types.md#event_types-charge.failed) lorsque la date de débit peut être déterminée.

Il faut compter 4&nbsp;jours ouvrés pour confirmer l’aboutissement ou l’échec d’un paiement par prélèvement automatique Bacs lorsque le mandat existe déjà, et 7&nbsp;jours ouvrés lorsque vous devez collecter un nouveau mandat.

Dans certains cas, la banque peut nous informer d’un échec de paiement après que le paiement a été marqué comme abouti sur votre compte Stripe. Le cas échéant, l’échec de paiement est identifié comme un litige et reçoit le code de motif approprié.

Le tableau suivant décrit les délais de règlement pour les paiements Bacs Direct Debit proposés par Stripe. `T+x` fait référence à `x` jours ouvrables après la soumission, qui peuvent différer de la date de création du paiement.

| Type de règlement | Paiement réussi  | Fonds disponibles | Heure limite        |
| ----------------- | ---------------- | ----------------- | ------------------- |
| Virement standard | T+3 at 21:00 UTC | T+4 at 00:00 UTC  | 20:00 Europe/London |

### Configurer des webhooks

Stripe envoie plusieurs événements pendant le processus de paiement et après sa finalisation. Utilisez l’[outil de webhook du Dashboard](https://dashboard.stripe.com/webhooks) ou suivez le [guide consacré aux webhooks](https://docs.stripe.com/webhooks/quickstart.md) pour recevoir ces événements et exécuter des actions, comme envoyer une confirmation de commande par e-mail à votre client, enregistrer la vente dans une base de données ou lancer un flux de livraison.

Pour les prélèvements automatiques Bacs, vous devez gérer l’événement [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded) afin de confirmer l’aboutissement du paiement. Stripe vous recommande également de gérer les événements [payment_intent.processing](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.processing) et [payment_intent.payment_failed](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.payment_failed).

Pour tester des webhooks en local, vous pouvez utiliser la [CLI Stripe](https://docs.stripe.com/stripe-cli.md). Après l’avoir installée, vous pouvez transférer des événements à votre serveur&nbsp;:

```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).

## Tester l'intégration

Vous avez à votre disposition plusieurs [numéros de compte bancaire de test](https://docs.stripe.com/keys.md#test-live-modes) dans un *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) pour vérifier que cette intégration est prête.

| Code guichet | Numéro de compte | Description                                                                                                                                                                                                                                                        |
| ------------ | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| 108800       | 00012345         | Le paiement aboutit et l’état du PaymentIntent passe de `processing` à `succeeded`.                                                                                                                                                                                |
| 108800       | 90012345         | Le paiement aboutit au bout de trois&nbsp;minutes et l’état du PaymentIntent passe de `processing` à `succeeded`.                                                                                                                                                  |
| 108800       | 33333335         | Le paiement est accepté, puis échoue immédiatement avec le code d’échec `debit_not_authorized`, et le PaymentIntent passe de l’état `processing` à l’état `requires_payment_method`. Le Mandat devient `inactive` et le PaymentMethod ne peut plus être réutilisé. |
| 108800       | 93333335         | Le paiement échoue après trois minutes avec le code d’échec `debit_not_authorized`, et le PaymentIntent passe de l’état `processing` à l’état `requires_payment_method`. Le Mandat devient `inactive` et le PaymentMethod ne peut plus être utilisé.               |
| 108800       | 22222227         | Le paiement échoue avec un code d’échec `insufficient_funds` et le PaymentIntent bascule de `processing` à `requires_payment_method`. L’objet Mandate reste `active` et le PaymentMethod peut à nouveau être utilisé.                                              |
| 108800       | 92222227         | Le paiement échoue au bout de trois&nbsp;minutes avec un code d’échec `insufficient_funds` et le PaymentIntent bascule de `processing` à `requires_payment_method`. L’objet Mandate reste `active` et le PaymentMethod peut à nouveau être utilisé.                |
| 108800       | 55555559         | Le paiement aboutit au bout de trois&nbsp;minutes et l’état du PaymentIntent passe de `processing` à `succeeded`, mais un litige est immédiatement créé.                                                                                                           |
| 108800       | 00033333         | La création du moyen de paiement aboutit, mais le mandat est refusé par la banque du client et passe immédiatement à l’état inactif.                                                                                                                               |
| 108800       | 00044444         | La demande de configuration de Bacs Direct Debit échoue immédiatement en raison d’un numéro de compte invalide, et le client est invité à mettre à jour ses informations avant l’envoi. Les informations de paiement ne sont pas collectées.                       |
| 108800       | 34343434         | Le paiement échoue avec un code d’erreur `charge_exceeds_source_limit`, car le montant du paiement entraîne un dépassement de la limite hebdomadaire de volume de paiement du compte.                                                                              |
| 108800       | 12121212         | Le paiement échoue avec un code d’erreur `charge_exceeds_weekly_limit`, car le montant du paiement dépasse la limite du volume de transactions du compte.                                                                                                          |

Pour vos tests, vous pouvez utiliser l’un des numéros de compte fournis ci-dessus. Cependant, dans la mesure où le traitement des paiements par prélèvement automatique Bacs prend plusieurs jours, privilégiez les numéros de compte de test qui fonctionnent avec un délai de trois minutes, de manière à mieux simuler le comportement en situation réelle.

> Par défaut, Stripe envoie automatiquement des [e-mails](https://docs.stripe.com/payments/payment-methods/bacs-debit.md#debit-notifications) de notification au client lors de la collecte initiale de ses données de paiement et chaque fois qu’un débit est ensuite effectué sur son compte. Ces notifications ne sont pas envoyées dans les environnements de test.

## Échecs de paiement

Les échecs de paiement peuvent être dus à diverses raisons. Le motif d’un échec est disponible via [charge.failure_code](https://docs.stripe.com/api/charges/object.md#charge_object-failure_code). Seuls les paiements présentant certains codes d’échec peuvent être retentés. Lorsqu’une nouvelle tentative de paiement échoue, il convient de contacter votre client pour lui demander de renouveler son règlement avec un compte bancaire ou un moyen de paiement différent.

Vous trouverez ci-dessous la liste des codes d’échec que nous envoyons actuellement pour les prélèvements automatiques Bacs. D’autres codes peuvent être ajoutés à tout moment&nbsp;; lors du développement et de la maintenance de votre code, vous ne devez donc pas supposer que seuls ces types existent.

| Code d’échec                | Description                                                                                                                                                                                                 | Nouvelle tentative possible |
| --------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------- |
| `account_closed`            | Le compte bancaire a été clôturé.                                                                                                                                                                           | Non                         |
| `bank_ownership_changed`    | Le compte a été transféré vers un nouveau prestataire de paiement (PSP). Vérifiez si on vous a communiqué les coordonnées du nouveau PSP. Sinon, vous devez obtenir un nouveau mandat de la part du client. | Non                         |
| `debit_not_authorized`      | Le client a informé sa banque que le paiement n’était pas autorisé ou que la banque payeuse ne détient aucun mandat.                                                                                        | Non                         |
| `generic_could_not_process` | Ce paiement n’a pas pu être traité.                                                                                                                                                                         | Oui                         |
| `insufficient_funds`        | Le compte du client ne dispose pas de fonds suffisants pour couvrir le paiement.                                                                                                                            | Oui                         |
| `invalid_account_number`    | Le numéro de compte n’est pas valide. Cela peut signifier qu’il ne s’agit pas d’un compte en GBP ou que le compte ne peut pas traiter les paiements par prélèvement automatique.                            | Non                         |

Pour effectuer une nouvelle tentative de paiement, [confirmez le PaymentIntent](https://docs.stripe.com/api/payment_intents/confirm.md) à nouveau à l’aide du même *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs).

Pour mettre toutes les chances de votre côté que le paiement aboutisse, nous vous conseillons de contacter le payeur avant la nouvelle tentative.

## Optional: Configurer la date de prélèvement du client

Vous pouvez contrôler la date à laquelle Stripe débite le compte bancaire d’un client à l’aide de la [date butoir](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-payment_method_options-bacs_debit-target_date). La date cible doit être fixée au moins trois jours dans le futur et pas plus de 15&nbsp;jours après la date actuelle.

La date butoir indique la date à laquelle les fonds doivent avoir quitté le compte du client. Vous pouvez [annuler un PaymentIntent](https://docs.stripe.com/api/payment_intents/cancel.md) créé avec une date butoir jusqu’à trois jours ouvrables avant la date configurée.

Si la date butoir indiquée répond à l’un des critères suivants, le débit a lieu le jour ouvrable suivant&nbsp;:

- La date butoir est un week-end, un jour férié ou un autre jour non ouvrable.
- La date butoir est fixée moins de trois&nbsp;jours ouvrables dans le futur.

Ce paramètre fonctionne dans la mesure du possible. En effet, la banque de chaque client peut traiter les prélèvements à des dates différentes, en fonction des jours fériés locaux ou d’autres raisons.

## Optional: Personnaliser les références de mandat à l’aide d’un préfixe

Vous pouvez personnaliser les références des mandats de prélèvement automatique Bacs afin de simplifier l’identification des mandats. Pour ce faire, fournissez la valeur facultative `payment_method_options.bacs_debit.mandate_options.reference_prefix`. Nous ajoutons le `reference_prefix` au début d’une séquence unique pour nous assurer que l’ensemble de la référence reste unique.

Le `reference_prefix` doit répondre aux exigences suivantes&nbsp;:

- Longueur maximale&nbsp;: 12 caractères
- Doit commencer par un chiffre ou une lettre majuscule
- Caractères autorisés&nbsp;:
  - Lettres majuscules
  - Chiffres
  - Espaces
  - Caractères spéciaux&nbsp;: `.`, `/`, `&`, `-`, `_`
- Ne peut pas commencer par `DDIC` ou `STRIPE`

Ajoutez tout délimiteur souhaité dans le préfixe, car nous n’en ajoutons pas par défaut. Nous réduisons les espaces de fin à un espace maximum. Avec un préfixe valide, la référence résultante comporte toujours 18&nbsp;caractères.

#### Payment Intent

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d currency=gbp \
  -d amount=100 \
  -d "payment_method_types[]=bacs_debit" \
  -d "payment_method_options[bacs_debit][mandate_options][reference_prefix]=EX4MPL3-"
```

#### Setup Intent

```curl
curl https://api.stripe.com/v1/setup_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "payment_method_types[]=bacs_debit" \
  -d "payment_method_options[bacs_debit][mandate_options][reference_prefix]=EX4MPL3-"
```

#### Checkout Session en mode paiement

```curl
curl https://api.stripe.com/v1/checkout/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d mode=payment \
  -d currency=gbp \
  -d "line_items[0][price_data][currency]=gbp" \
  -d "line_items[0][price_data][product_data][name]=Llama" \
  -d "line_items[0][price_data][unit_amount]=2000" \
  -d "line_items[0][quantity]=1" \
  -d "payment_method_types[0]=bacs_debit" \
  -d "payment_method_options[bacs_debit][mandate_options][reference_prefix]=EX4MPL3-"
```

#### Checkout Session en mode configuration

```curl
curl https://api.stripe.com/v1/checkout/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d mode=setup \
  -d "payment_method_types[]=bacs_debit" \
  -d "payment_method_options[bacs_debit][mandate_options][reference_prefix]=EX4MPL3-"
```

La référence générée ressemble à `EX4MPL3-19CNCI920C`.

| Code d’erreur                                  | Message                                                                                                                                                                                                                                                             |
| ---------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `invalid_bacs_mandate_reference_prefix_format` | La valeur de `reference_prefix` ne doit pas comporter plus de 12&nbsp;caractères et ne peut contenir que des lettres majuscules, des chiffres, des espaces ou les caractères spéciaux `/`, `_`, `-`, `&` et `.`. Elle ne peut pas commencer par `DDIC` ou `STRIPE`. |


## See also

- [Webhooks PaymentIntent](https://docs.stripe.com/payments/payment-intents/verifying-status.md#webhooks)
- [Gérer les mandats](https://docs.stripe.com/payments/payment-methods/bacs-debit.md#mandates)