# Accepter un paiement et enregistrer un mandat pour les futurs paiements PayTo

Comment collecter un paiement PayTo et autoriser de futurs paiements.

PayTo permet aux clients australiens d’[authentifier](https://docs.stripe.com/payments/payment-methods.md#customer-actions) les mandats de paiement PayTo ponctuels et récurrents dans leur application bancaire. Pour payer avec PayTo, les *clients* (Customer objects represent customers of your business. They let you reuse payment methods and give you the ability to track multiple payments) reçoivent une notification de demande de mandat en attente, donnent leur autorisation après lecture des conditions du mandat, puis retournent à votre application sur laquelle vous recevez une [notification différée](https://docs.stripe.com/payments/payment-methods.md#payment-notification) de l’échec ou de la réussite du paiement.

La mise en place d’un mandat PayTo pour les paiements futurs vous permet de percevoir les paiements récurrents à venir sans avoir à demander à nouveau l’autorisation du client. Les clients peuvent consulter, gérer, suspendre et annuler leurs mandats PayTo dans leurs applications bancaires.

> Stripe ne prend pas en charge la modification ou la suspension des mandats PayTo par les clients. Si un client tente de suspendre ou de modifier un mandat, nous annulons le mandat et vous envoyons un [webhook `mandate.updated`](https://docs.stripe.com/api/events/types.md#event_types-mandate.updated). Après avoir reçu le webhook, vous pouvez contacter votre client pour savoir pourquoi il a modifié son mandat, et mettre en place un nouveau mandat.

# Checkout

> This is a Checkout for when payment-ui is checkout. View the full page at https://docs.stripe.com/payments/payto/save-during-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.

## Déterminer la compatibilité

**Région du client** : Australia

**Devises prises en charge** : `aud`

**Devises de règlement** : `aud`

**Mode de paiement** : Yes

**Mode de configuration** : Yes

**Mode d’abonnement** : Yes

Pour prendre en charge les paiements PayTo dans Checkout, indiquez tous les *tarifs* (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) pour tous les postes en AUD (code devise `aud`).

## Accepter un paiement

> Ce guide s’appuie sur l’intégration fondamentale [accepter un paiement](https://docs.stripe.com/payments/accept-a-payment.md?ui=stripe-hosted) de Checkout.

pour activer payto comme moyen de paiement, créez une nouvelle [session Checkout](https://docs.stripe.com/api/checkout/sessions.md) :

1. Ajouter `payto` à la liste de `payment_method_types`.
1. Veiller à ce que tous vos `line_items` utilisent la devise `aud`
1. Spécifiez les conditions du mandat que vous souhaitez que votre client accepte en utilisant les [moyens de paiement](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-payment_method_options-payto) disponibles.

#### Page hébergée par Stripe

```curl
curl https://api.stripe.com/v1/checkout/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "line_items[0][price_data][currency]=aud" \
  -d "line_items[0][price_data][product_data][name]=T-shirt" \
  -d "line_items[0][price_data][unit_amount]=2000" \
  -d "line_items[0][quantity]=1" \
  -d mode=payment \
  -d "payment_method_options[payto][mandate_options][amount]=10000" \
  -d "payment_method_options[payto][mandate_options][amount_type]=maximum" \
  -d "payment_method_options[payto][mandate_options][payment_schedule]=adhoc" \
  -d "payment_method_options[payto][setup_future_usage]=off_session" \
  -d "payment_method_types[0]=card" \
  -d "payment_method_types[1]=payto" \
  --data-urlencode "success_url=https://example.com/success"
```

#### Page entièrement intégrée

```curl
curl https://api.stripe.com/v1/checkout/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "line_items[0][price_data][currency]=aud" \
  -d "line_items[0][price_data][product_data][name]=T-shirt" \
  -d "line_items[0][price_data][unit_amount]=2000" \
  -d "line_items[0][quantity]=1" \
  -d mode=payment \
  -d "payment_method_options[payto][mandate_options][amount]=10000" \
  -d "payment_method_options[payto][mandate_options][amount_type]=maximum" \
  -d "payment_method_options[payto][mandate_options][payment_schedule]=adhoc" \
  -d "payment_method_options[payto][setup_future_usage]=off_session" \
  -d "payment_method_types[0]=card" \
  -d "payment_method_types[1]=payto" \
  --data-urlencode "return_url=https://example.com/return" \
  -d ui_mode=embedded_page
```

### Traiter vos commandes

Maintenant que vous savez accepter des paiements, découvrez comment [traiter les commandes](https://docs.stripe.com/checkout/fulfillment.md).

## Tester votre intégration

Testez votre intégration PayTo avec vos clés API de test en utilisant les différents PayID de test et les coordonnées bancaires ci-dessous. Chaque combinaison donne lieu à un scénario différent auquel votre intégration pourrait être confrontée en mode production.

#### PayID

| PayID                                                    | Description                                                                                                                                                                                                                                                                                                                                    |
| -------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `{any_prefix}+succeed@{any_domain}`                      | L’état de la PaymentIntent passe de `requires_action` à `processing` au bout de 10&nbsp;secondes, puis à `succeeded` après 5&nbsp;secondes supplémentaires. Le mandat passe alors à l’état `active`.                                                                                                                                           |
| `{any_prefix}+decline@{any_domain}`                      | L’état de la PaymentIntent passe de `requires_action` à `requires_payment_method` au bout de 10&nbsp;secondes. Stripe renvoie le code d’erreur `payment_method_provider_decline` avec le code de refus de paiement `invalid_authorization`. Le mandat passe alors à l’état `inactive`.                                                         |
| `{any_prefix}+expire@{any_domain}`                       | L’état de la PaymentIntent passe de `requires_action` à `requires_payment_method` au bout de 10&nbsp;secondes. Stripe renvoie le code d’erreur `payment_method_provider_decline` avec le code de refus de paiement `generic_decline`. Le mandat passe alors à l’état `inactive`.                                                               |
| `{any_prefix}+insufficient_funds@{any_domain}`           | L’état de la PaymentIntent passe de `requires_action` à `processing` au bout de 10&nbsp;secondes, puis à `requires_payment_method` après 5&nbsp;secondes supplémentaires. Stripe renvoie le code d’erreur `payment_method_provider_decline` avec le code de refus de paiement `insufficient_funds`. Le mandat passe alors à l’état `inactive`. |
| `{any_prefix}+revoke@{any_domain}`                       | L’état de la PaymentIntent passe de `requires_action` à `processing` au bout de 10&nbsp;secondes, puis à `succeeded` après 5&nbsp;secondes supplémentaires. Le mandat est d’abord à l’état `active`, puis passe à l’état `inactive` au bout d’une minute.                                                                                      |
| `{any_prefix}+agreement_type_not_supported@{any_domain}` | L’état de la PaymentIntent passe de `requires_action` à `requires_payment_method` au bout de 10&nbsp;secondes. Stripe renvoie le code d’erreur `payment_method_provider_decline`. Le mandat passe alors à l’état `inactive`.                                                                                                                   |

#### Numéros de compte et BSB

| Numéro BSB | Numéro de compte | Description                                                                                                                                                                                                                                                                                                                                    |
| ---------- | ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `000000`   | `000123456`      | L’état de la PaymentIntent passe de `requires_action` à `processing` au bout de 10&nbsp;secondes, puis à `succeeded` après 5&nbsp;secondes supplémentaires. Le mandat passe alors à l’état `active`.                                                                                                                                           |
| `000000`   | `333333335`      | L’état de la PaymentIntent passe de `requires_action` à `requires_payment_method` au bout de 10&nbsp;secondes. Stripe renvoie le code d’erreur `payment_method_provider_decline` avec le code de refus de paiement `invalid_authorization`. Le mandat passe alors à l’état `inactive`.                                                         |
| `000000`   | `333333337`      | L’état de la PaymentIntent passe de `requires_action` à `requires_payment_method` au bout de 10&nbsp;secondes. Stripe renvoie le code d’erreur `payment_method_provider_decline` avec le code de refus de paiement `generic_decline`. Le mandat passe alors à l’état `inactive`.                                                               |
| `000000`   | `222222227`      | L’état de la PaymentIntent passe de `requires_action` à `processing` au bout de 10&nbsp;secondes, puis à `requires_payment_method` après 5&nbsp;secondes supplémentaires. Stripe renvoie le code d’erreur `payment_method_provider_decline` avec le code de refus de paiement `insufficient_funds`. Le mandat passe alors à l’état `inactive`. |
| `000000`   | `444444447`      | L’état de la PaymentIntent passe de `requires_action` à `processing` au bout de 10&nbsp;secondes, puis à `succeeded` après 5&nbsp;secondes supplémentaires. Le mandat est d’abord à l’état `active`, puis passe à l’état `inactive` au bout d’une minute.                                                                                      |
| `000000`   | `666666667`      | L’état de la PaymentIntent passe de `requires_action` à `requires_payment_method` au bout de 10&nbsp;secondes. Stripe renvoie le code d’erreur `payment_method_provider_decline`. Le mandat passe alors à l’état `inactive`.                                                                                                                   |


# Elements

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

Afin d’accepter les paiements PayTo, créez un objet [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) pour suivre un paiement, collecter les informations de paiement, puis soumettre le paiement à Stripe pour traitement. Stripe utilise le PaymentIntent pour suivre et gérer tous les états du paiement jusqu’à ce qu’il aboutisse. Utilisez l’ID du [Mandat](https://docs.stripe.com/api/mandates.md) collecté à partir de votre PaymentIntent PayTo initial pour créer des paiements ultérieurs.

## Configurer Stripe [Côté serveur]

Pour commencer, vous devez créer un compte Stripe. [S’inscrire](https://dashboard.stripe.com/register).

Pour accéder à l’API Stripe depuis votre application, utilisez nos bibliothèques officielles&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 un objet Customer [Côté serveur]

Créez 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) dès qu’un client crée un compte auprès de votre entreprise et associez-le à votre représentation interne de son compte. Vous pourrez ainsi récupérer et utiliser ultérieurement les informations enregistrées sur son moyen de paiement.

```curl
curl https://api.stripe.com/v1/customers \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "name=Jenny Rosen" \
  --data-urlencode "email=jenny@example.com"
```

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

Créez un PaymentIntent sur votre serveur et précisez le montant à encaisser et la devise dans les paramètres `amount` et `aud`, l’ID du client, et le paramètre `off_session` (hors session) comme argument pour la [configuration de l’utilisation future](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-setup_future_usage). Le montant minimal de paiement est de 0,50&nbsp;AUD, et PayTo ne prend pas en charge d’autres devises. Si vous avez déjà une intégration [API Payment Intents](https://docs.stripe.com/payments/payment-intents.md), ajoutez `payto` à la liste des [types de moyens de paiement](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types).

Vous pouvez spécifier les conditions du mandat pour le consentement de votre client dans les [options de moyen de paiement PayTo](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-payto).

> Le montant (`amount`) des options de moyen de paiement doit correspondre au champ `amount` du PaymentIntent, sauf si vous définissez l’attribut `amount_type` sur `maximum`. Dans ce cas, vous pouvez définir une valeur de moyens de paiement supérieure au PaymentIntent.

L’exemple de code suivant indique un montant de PaymentIntent de 10&nbsp;AUD, et un montant de 1500&nbsp;AUD pour les options de moyen de paiement, car le type de montant `amount_type` est `maximum`.

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1000 \
  -d currency=aud \
  -d "payment_method_types[]=payto" \
  -d customer={{CUSTOMER_ID}} \
  -d setup_future_usage=off_session \
  -d "payment_method_options[payto][mandate_options][amount_type]=maximum" \
  -d "payment_method_options[payto][mandate_options][payment_schedule]=annual" \
  -d "payment_method_options[payto][mandate_options][amount]=150000" \
  -d "payment_method_options[payto][mandate_options][payments_per_period]=13" \
  -d "payment_method_options[payto][mandate_options][end_date]=2036-12-25" \
  -d "payment_method_options[payto][mandate_options][purpose]=mortgage"
```

Stripe prend en charge différents types de mandats, avec des contrôles sur le montant, la durée, la fréquence et l’objet du mandat. Spécifiez des conditions de mandat qui correspondent autant que possible à vos exigences. Les clients voient ces conditions précises au moment de l’autorisation, donc leur exactitude peut améliorer votre taux de conversion.

Stripe détermine l’`objet` par défaut en fonction de votre *code de catégorie commerçant (MCC)* (A Merchant Category Code (MCC) is a four-digit number that classifies the type of goods or services a business offers). Remplacez ce champ en utilisant l’[une des valeurs valides](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-payto-mandate_options-purpose), si la valeur par défaut ne reflète pas fidèlement l’objet de l’accord. Vous pouvez vérifier la valeur par défaut dans l’objet [mandat](https://docs.stripe.com/api/mandates/object.md#mandate_object-payment_method_details-payto), lorsque vous ne spécifiez pas l’objectif.

### Récupérer la clé secrète du client

Le PaymentIntent contient une *clé secrète* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)) à utiliser côté client pour finaliser le processus de paiement en toute sécurité. Vous pouvez adopter différentes approches pour transmettre cette clé secrète côté client.

#### Application monopage

Récupérez la clé secrète du client à partir d’un endpoint sur votre serveur, à l’aide de la fonction `fetch` du navigateur. Cette approche est recommandée si votre côté client est une application d’une seule page, en particulier si elle repose sur un framework front-end moderne tel que React. Créez l’endpoint de serveur qui gère la clé secrète du client&nbsp;:

#### Ruby

```ruby
get '/secret' do
  intent = # ... Create or retrieve the PaymentIntent
  {client_secret: intent.client_secret}.to_json
end
```

Récupérez ensuite la clé secrète du client à l’aide JavaScript côté client&nbsp;:

```javascript
(async () => {
  const response = await fetch('/secret');
  const {client_secret: clientSecret} = await response.json();
  // Render the form using the clientSecret
})();
```

#### Rendu côté serveur

Transmettez la clé secrète à votre client depuis votre serveur. Cette approche fonctionne mieux si votre application génère du contenu statique sur le serveur avant de l’envoyer sur le navigateur.

Ajoutez le [client_secret](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) à votre formulaire de paiement. Dans votre code côté serveur, récupérez la clé secrète du client à partir du PaymentIntent&nbsp;:

#### Ruby

```erb
<form id="payment-form" data-secret="<%= @intent.client_secret %>">
  <button id="submit">Submit</button>
</form>
```

```ruby
get '/checkout' do
  @intent = # ... Fetch or create the PaymentIntent
  erb :checkout
end
```

## Collecter les informations de paiement et envoyer le paiement [Côté client]

Collectez les informations de paiement du client avec le [Payment&nbsp;Element](https://docs.stripe.com/payments/payment-element.md). Le Payment&nbsp;Element est un composant d’interface utilisateur préconfiguré qui simplifie la collecte des informations pour de nombreux moyens de paiement.

Le Payment&nbsp;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&nbsp;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
<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 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&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>
```

Lors du chargement du formulaire précédent, créez une instance du composant Payment&nbsp;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`&nbsp;:

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 stepconst elements = stripe.elements(options);
// Optional: Autofill user's saved payment methods. If the customer's
// email is known when the page is loaded, you can pass the email
// to the linkAuthenticationElement on mount:
//
//   linkAuthenticationElement.mount("#link-authentication-element",  {
//     defaultValues: {
//       email: 'jenny.rosen@example.com',
//     }
//   })

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

```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 Payment Element, enveloppez 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, puis transmettez au fournisseur `Elements` l’élément `Promise` renvoyé. 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 que `options`, toujours 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('<<YOUR_PUBLISHABLE_KEY>>');

function App() {
  const options = {
    // passing the client secret obtained in step 3
    clientSecret: '{{CLIENT_SECRET}}',
    // Fully customizable with appearance API.
    appearance: {/*...*/},
  };

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

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

### Ajouter le composant Element Payment

Utilisez le composant `PaymentElement` pour créer votre formulaire&nbsp;:

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

const CheckoutForm = () => {
  return (
    <form>
      // Optional: Autofill user's saved payment methods. If the customer's
      // email is known when the page is loaded, you can pass the email
      // to the linkAuthenticationElement
      //
      // <LinkAuthenticationElement id="link-authentication-element"
        // Prefill the email field like so:
        // options={{defaultValues: {email: 'foo@bar.com'}}}
      // /><PaymentElement />
      <button>Submit</button>
    </form>
  );
};

export default CheckoutForm;
```

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. Cela envoie une demande d’autorisation au client.

> L’exécution de la méthode `stripe.confirmPayment` peut prendre plusieurs secondes, le temps que le client autorise le paiement. Pendant ce temps, bloquez le renvoi de votre formulaire et affichez un indicateur d’attente. Si vous recevez une erreur, montrez-la au client, réactivez le formulaire et masquez l’indicateur d’attente.

#### HTML + JS

```javascript
const form = document.getElementById('payment-form');

form.addEventListener('submit', async (event) => {
  event.preventDefault();
const {error, paymentIntent} = await stripe.confirmPayment({
    //`Elements` instance that was used to create the Payment Element
    elements,
    redirect: 'if_required',
    confirmParams: {
      mandate_data: {
        customer_acceptance: {
          type: 'online',
          online: {
            infer_from_client: true,
          },
        },
      }
    },
  });

  const message = document.querySelector('#message')
  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)
    message.innerText = error.message;
  } else {
    // This will execute if the confirm request is successful, or if the
    // payment fails asynchronously.
    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

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#usestripe-hook) et [useElements](https://docs.stripe.com/sdks/stripejs-react.md#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#elements-consumer) à la place.

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

const CheckoutForm = () => {
  const stripe = useStripe();
  const elements = useElements();

  const [message, setMessage] = 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, paymentIntent} = await stripe.confirmPayment({
      //`Elements` instance that was used to create the Payment Element
      elements,
      redirect: 'if_required',
      confirmParams: {
        mandate_data: {
          customer_acceptance: {
            type: 'online',
            online: {
              infer_from_client: true,
            },
          },
        }
      },
    });


    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)
      setMessage(error.message);
    } else {
      // This will execute if the confirm request is successful, or if the
      // payment fails asynchronously.
      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':
          setMessage('Payment failed. Please try another payment method.');
          // Redirect your user back to your payment page to attempt collecting
          // payment again
          break;

        default:
          setMessage('Something went wrong.');
          break;
      }
    }
  };

  return (
    <form onSubmit={handleSubmit}>
      <PaymentElement />
      <button disabled={!stripe}>Submit</button>
      {/* Show message to your customers */}
      {message && <div>{message}</div>}
    </form>
  )
};

export default CheckoutForm;
```

## Débiter ultérieurement le moyen de paiement PayTo

Lorsque vous devez facturer à nouveau votre client, créez un nouveau PaymentIntent. Pour trouver l’ID du mandat, l’ID du client et l’ID du moyen de paiement, [récupérez](https://docs.stripe.com/api/payment_intents/retrieve.md) le PaymentIntent précédent et [développez](https://docs.stripe.com/api/expanding_objects.md) le champ `latest_charge`.

```curl
curl -G https://api.stripe.com/v1/payment_intents/{{PAYMENT_INTENT_ID}} \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "expand[]=latest_charge"
```

Consultez les ID voulus dans la réponse ci-dessous.

#### Json

```json
{
  // ...
  "customer": "cus_PW6rQWRGAaBD7z", // <---- Here's the customer
  "latest_charge": {
    "payment_method": "pm_1Ok4l9A8DuEjWaGwhB4SGrWh", // <---- Here's the payment method
    "payment_method_details": {
      "payto": {
        "bsb_number": null,
        "last4": null,
        "mandate": "mandate_1Ok4lVA8DuEjWaGwu0uTwI94", // <----- Here's the mandate
        "pay_id": "jenny@example.com"
      },
      "type": "payto"
    },
  },
  "payment_method_types": [
    "payto"
  ],
  // ...
}
```

Créez un PaymentIntent en indiquant l’ID du moyen de paiement, l’ID du mandat et l’ID du client.

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "payment_method_types[]=payto" \
  -d amount=1099 \
  -d currency=aud \
  -d "customer={{CUSTOMER_ID}}" \
  -d "payment_method={{PAYMENTMETHOD_ID}}" \
  -d "mandate={{MANDATE_ID}}" \
  -d confirm=true
```

## Tester votre intégration

Testez votre intégration PayTo avec vos clés API de test en utilisant les différents PayID de test et les coordonnées bancaires ci-dessous. Chaque combinaison donne lieu à un scénario différent auquel votre intégration pourrait être confrontée en mode production.

#### PayID

| PayID                                                    | Description                                                                                                                                                                                                                                                                                                                                    |
| -------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `{any_prefix}+succeed@{any_domain}`                      | L’état de la PaymentIntent passe de `requires_action` à `processing` au bout de 10&nbsp;secondes, puis à `succeeded` après 5&nbsp;secondes supplémentaires. Le mandat passe alors à l’état `active`.                                                                                                                                           |
| `{any_prefix}+decline@{any_domain}`                      | L’état de la PaymentIntent passe de `requires_action` à `requires_payment_method` au bout de 10&nbsp;secondes. Stripe renvoie le code d’erreur `payment_method_provider_decline` avec le code de refus de paiement `invalid_authorization`. Le mandat passe alors à l’état `inactive`.                                                         |
| `{any_prefix}+expire@{any_domain}`                       | L’état de la PaymentIntent passe de `requires_action` à `requires_payment_method` au bout de 10&nbsp;secondes. Stripe renvoie le code d’erreur `payment_method_provider_decline` avec le code de refus de paiement `generic_decline`. Le mandat passe alors à l’état `inactive`.                                                               |
| `{any_prefix}+insufficient_funds@{any_domain}`           | L’état de la PaymentIntent passe de `requires_action` à `processing` au bout de 10&nbsp;secondes, puis à `requires_payment_method` après 5&nbsp;secondes supplémentaires. Stripe renvoie le code d’erreur `payment_method_provider_decline` avec le code de refus de paiement `insufficient_funds`. Le mandat passe alors à l’état `inactive`. |
| `{any_prefix}+revoke@{any_domain}`                       | L’état de la PaymentIntent passe de `requires_action` à `processing` au bout de 10&nbsp;secondes, puis à `succeeded` après 5&nbsp;secondes supplémentaires. Le mandat est d’abord à l’état `active`, puis passe à l’état `inactive` au bout d’une minute.                                                                                      |
| `{any_prefix}+agreement_type_not_supported@{any_domain}` | L’état de la PaymentIntent passe de `requires_action` à `requires_payment_method` au bout de 10&nbsp;secondes. Stripe renvoie le code d’erreur `payment_method_provider_decline`. Le mandat passe alors à l’état `inactive`.                                                                                                                   |

#### Numéros de compte et BSB

| Numéro BSB | Numéro de compte | Description                                                                                                                                                                                                                                                                                                                                    |
| ---------- | ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `000000`   | `000123456`      | L’état de la PaymentIntent passe de `requires_action` à `processing` au bout de 10&nbsp;secondes, puis à `succeeded` après 5&nbsp;secondes supplémentaires. Le mandat passe alors à l’état `active`.                                                                                                                                           |
| `000000`   | `333333335`      | L’état de la PaymentIntent passe de `requires_action` à `requires_payment_method` au bout de 10&nbsp;secondes. Stripe renvoie le code d’erreur `payment_method_provider_decline` avec le code de refus de paiement `invalid_authorization`. Le mandat passe alors à l’état `inactive`.                                                         |
| `000000`   | `333333337`      | L’état de la PaymentIntent passe de `requires_action` à `requires_payment_method` au bout de 10&nbsp;secondes. Stripe renvoie le code d’erreur `payment_method_provider_decline` avec le code de refus de paiement `generic_decline`. Le mandat passe alors à l’état `inactive`.                                                               |
| `000000`   | `222222227`      | L’état de la PaymentIntent passe de `requires_action` à `processing` au bout de 10&nbsp;secondes, puis à `requires_payment_method` après 5&nbsp;secondes supplémentaires. Stripe renvoie le code d’erreur `payment_method_provider_decline` avec le code de refus de paiement `insufficient_funds`. Le mandat passe alors à l’état `inactive`. |
| `000000`   | `444444447`      | L’état de la PaymentIntent passe de `requires_action` à `processing` au bout de 10&nbsp;secondes, puis à `succeeded` après 5&nbsp;secondes supplémentaires. Le mandat est d’abord à l’état `active`, puis passe à l’état `inactive` au bout d’une minute.                                                                                      |
| `000000`   | `666666667`      | L’état de la PaymentIntent passe de `requires_action` à `requires_payment_method` au bout de 10&nbsp;secondes. Stripe renvoie le code d’erreur `payment_method_provider_decline`. Le mandat passe alors à l’état `inactive`.                                                                                                                   |

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

Stripe envoie un événement [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded) à l’issue du paiement. Utilisez le Dashboard, un *webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) personnalisé ou une solution partenaire 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 workflow de livraison.

Plutôt que d’attendre un rappel de votre client, écoutez ces événements. En effet, côté client, l’acheteur pourrait fermer la fenêtre de son navigateur ou quitter l’application avant l’exécution du rappel. Des personnes malveillantes peuvent en profiter pour manipuler la réponse. Si vous configurez votre intégration de manière à écouter les événements asynchrones, cela vous permettra également d’accepter de nouveaux moyens de paiement plus facilement à l’avenir. Apprenez-en davantage sur les [différences entre les différents moyens de paiement pris en charge](https://stripe.com/payments/payment-methods-guide).

### Recevoir des événements et exécuter des actions métier

Plusieurs options s’offrent à vous pour recevoir et exécuter des actions métier.

#### Manuellement

Utilisez le Dashboard pour consulter tous vos paiements Stripe, envoyer des reçus par e-mail, gérer les virements et relancer les paiements ayant échoué.

- [Afficher vos paiements tests dans le Dashboard](https://dashboard.stripe.com/test/payments)

#### Code personnalisé

Créez un gestionnaire de webhooks pour écouter des événements et créer des tunnels de paiement asynchrones personnalisés. Testez et déboguez votre intégration de webhooks en local, grâce à la CLI Stripe.

- [Créer un webhook personnalisé](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook)

#### Applications préconfigurées

Intégrez une application partenaire pour gérer les événements métier courants, comme l’[automatisation](https://stripe.partners/?f_category=automation), le [marketing ou les ventes](https://stripe.partners/?f_category=marketing-and-sales).


# API directe

> This is a API directe for when payment-ui is direct-api. View the full page at https://docs.stripe.com/payments/payto/save-during-payment?payment-ui=direct-api.

Afin d’accepter les paiements PayTo, créez un objet [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) pour suivre un paiement, collecter les informations de paiement, puis soumettre le paiement à Stripe pour traitement. Stripe utilise le PaymentIntent pour suivre et gérer tous les états du paiement jusqu’à ce qu’il aboutisse. Utilisez l’ID du [Mandat](https://docs.stripe.com/api/mandates.md) collecté à partir de votre PaymentIntent PayTo initial pour créer des paiements ultérieurs.

## Configurer Stripe [Côté serveur]

Pour commencer, vous devez créer un compte Stripe. [S’inscrire](https://dashboard.stripe.com/register).

Pour accéder à l’API Stripe depuis votre application, utilisez nos bibliothèques officielles&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 un objet Customer [Côté serveur]

Créez 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) dès qu’un client crée un compte auprès de votre entreprise et associez-le à votre représentation interne de son compte. Vous pourrez ainsi récupérer et utiliser ultérieurement les informations enregistrées sur son moyen de paiement.

```curl
curl https://api.stripe.com/v1/customers \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "name=Jenny Rosen" \
  --data-urlencode "email=jenny@example.com"
```

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

Créez un PaymentIntent sur votre serveur et précisez le montant à encaisser et la devise dans les paramètres `amount` et `aud`, l’ID du client, et le paramètre `off_session` (hors session) comme argument pour la [configuration de l’utilisation future](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-setup_future_usage). Le montant minimal de paiement est de 0,50&nbsp;AUD, et PayTo ne prend pas en charge d’autres devises. Si vous avez déjà une intégration [API Payment Intents](https://docs.stripe.com/payments/payment-intents.md), ajoutez `payto` à la liste des [types de moyens de paiement](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types).

Vous pouvez spécifier les conditions du mandat pour le consentement de votre client dans les [options de moyen de paiement PayTo](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-payto).

> Le montant (`amount`) des options de moyen de paiement doit correspondre au champ `amount` du PaymentIntent, sauf si vous définissez l’attribut `amount_type` sur `maximum`. Dans ce cas, vous pouvez définir une valeur de moyens de paiement supérieure au PaymentIntent.

L’exemple de code suivant indique un montant de PaymentIntent de 10&nbsp;AUD, et un montant de 1500&nbsp;AUD pour les options de moyen de paiement, car le type de montant `amount_type` est `maximum`.

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1000 \
  -d currency=aud \
  -d "payment_method_types[]=payto" \
  -d customer={{CUSTOMER_ID}} \
  -d setup_future_usage=off_session \
  -d "payment_method_options[payto][mandate_options][amount_type]=maximum" \
  -d "payment_method_options[payto][mandate_options][payment_schedule]=annual" \
  -d "payment_method_options[payto][mandate_options][amount]=150000" \
  -d "payment_method_options[payto][mandate_options][payments_per_period]=13" \
  -d "payment_method_options[payto][mandate_options][end_date]=2036-12-25" \
  -d "payment_method_options[payto][mandate_options][purpose]=mortgage"
```

Stripe prend en charge différents types de mandats, avec des contrôles sur le montant, la durée, la fréquence et l’objet du mandat. Spécifiez des conditions de mandat qui correspondent autant que possible à vos exigences. Les clients voient ces conditions précises au moment de l’autorisation, donc leur exactitude peut améliorer votre taux de conversion.

Stripe détermine l’`objet` par défaut en fonction de votre *code de catégorie commerçant (MCC)* (A Merchant Category Code (MCC) is a four-digit number that classifies the type of goods or services a business offers). Remplacez ce champ en utilisant l’[une des valeurs valides](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-payto-mandate_options-purpose), si la valeur par défaut ne reflète pas fidèlement l’objet de l’accord. Vous pouvez vérifier la valeur par défaut dans l’objet [mandat](https://docs.stripe.com/api/mandates/object.md#mandate_object-payment_method_details-payto), lorsque vous ne spécifiez pas l’objectif.

### Récupérer la clé secrète du client

Le PaymentIntent contient une *clé secrète* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)) à utiliser côté client pour finaliser le processus de paiement en toute sécurité. Vous pouvez adopter différentes approches pour transmettre cette clé secrète côté client.

#### Application monopage

Récupérez la clé secrète du client à partir d’un endpoint sur votre serveur, à l’aide de la fonction `fetch` du navigateur. Cette approche est recommandée si votre côté client est une application d’une seule page, en particulier si elle repose sur un framework front-end moderne tel que React. Créez l’endpoint de serveur qui gère la clé secrète du client&nbsp;:

#### Ruby

```ruby
get '/secret' do
  intent = # ... Create or retrieve the PaymentIntent
  {client_secret: intent.client_secret}.to_json
end
```

Récupérez ensuite la clé secrète du client à l’aide JavaScript côté client&nbsp;:

```javascript
(async () => {
  const response = await fetch('/secret');
  const {client_secret: clientSecret} = await response.json();
  // Render the form using the clientSecret
})();
```

#### Rendu côté serveur

Transmettez la clé secrète à votre client depuis votre serveur. Cette approche fonctionne mieux si votre application génère du contenu statique sur le serveur avant de l’envoyer sur le navigateur.

Ajoutez le [client_secret](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) à votre formulaire de paiement. Dans votre code côté serveur, récupérez la clé secrète du client à partir du PaymentIntent&nbsp;:

#### Ruby

```erb
<form id="payment-form" data-secret="<%= @intent.client_secret %>">
  <button id="submit">Submit</button>
</form>
```

```ruby
get '/checkout' do
  @intent = # ... Fetch or create the PaymentIntent
  erb :checkout
end
```

## Collecter les informations de paiement et envoyer le paiement [Côté client]

Lorsque vous confirmez le paiement, transmettez la clé secrète du client.

> La clé secrète du client doit être utilisée avec prudence, car elle permet d’accéder au PaymentIntent. Ne l’enregistrez pas, ne l’intégrez pas dans des URL et ne la dévoilez à personne d’autre que votre client.

Utilisez `stripe.confirmPayToPayment` pour initier l’autorisation de paiement auprès de votre client.

Le client reçoit une notification concernant la requête de mandat et autorise ou refuse la requête dans son application bancaire.

```javascript
// Inititates the mandate request notification to the customer
stripe.confirmPayToPayment(
  '{{PAYMENT_INTENT_CLIENT_SECRET}}',
  {
    payment_method: {
      payto: {
        // Either provide a PayID (typically an email or phone number)
        pay_id: 'jenny@example.com'
        // ...or provide bank account details
        account_number: '000123456',
        bsb_number: '000000'
      }
    }
  }
).then(function(result) {
  if (result.error) {
    // Inform the customer that there was an error.
    console.log(result.error.message);
  }
});
```

Par défaut, Stripe.js interroge le PaymentIntent pour récupérer ses mises à jour. La promesse renvoyée par `confirmPayToPayment` aboutit quand le PaymentIntent passe à l’état `succeeded` ou à l’état `requires_payment_method` en cas d’échec du paiement. Consultez la page dédiée au [cycle de vie des PaymentIntents](https://docs.stripe.com/payments/paymentintents/lifecycle.md) pour en savoir plus sur ces changements d’état.

Pour interroger l’état du paiement vous-même, désactivez l’interrogation automatique en paramétrant `handleActions: false`&nbsp;:

```javascript
stripe.confirmPayToPayment(
  '{{PAYMENT_INTENT_CLIENT_SECRET}}',
  {
    payment_method: {
      payto: {
        account_number: '000123456',
        bsb_number: '000000'
      }
    }
  },
  { handleActions: false } // <---- Like this
)
```

Dans ce cas, vous pouvez appeler l’[API PaymentIntents](https://docs.stripe.com/api/payment_intents/retrieve.md) pour récupérer vous-même l’état du PaymentIntent.

## Débiter ultérieurement le moyen de paiement PayTo

Lorsque vous devez facturer à nouveau votre client, créez un nouveau PaymentIntent. Pour trouver l’ID du mandat, l’ID du client et l’ID du moyen de paiement, [récupérez](https://docs.stripe.com/api/payment_intents/retrieve.md) le PaymentIntent précédent et [développez](https://docs.stripe.com/api/expanding_objects.md) le champ `latest_charge`.

```curl
curl -G https://api.stripe.com/v1/payment_intents/{{PAYMENT_INTENT_ID}} \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "expand[]=latest_charge"
```

Consultez les ID voulus dans la réponse ci-dessous.

#### Json

```json
{
  // ...
  "customer": "cus_PW6rQWRGAaBD7z", // <---- Here's the customer
  "latest_charge": {
    "payment_method": "pm_1Ok4l9A8DuEjWaGwhB4SGrWh", // <---- Here's the payment method
    "payment_method_details": {
      "payto": {
        "bsb_number": null,
        "last4": null,
        "mandate": "mandate_1Ok4lVA8DuEjWaGwu0uTwI94", // <----- Here's the mandate
        "pay_id": "jenny@example.com"
      },
      "type": "payto"
    },
  },
  "payment_method_types": [
    "payto"
  ],
  // ...
}
```

Créez un PaymentIntent en indiquant l’ID du moyen de paiement, l’ID du mandat et l’ID du client.

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "payment_method_types[]=payto" \
  -d amount=1099 \
  -d currency=aud \
  -d "customer={{CUSTOMER_ID}}" \
  -d "payment_method={{PAYMENTMETHOD_ID}}" \
  -d "mandate={{MANDATE_ID}}" \
  -d confirm=true
```

## Tester votre intégration

Testez votre intégration PayTo avec vos clés API de test en utilisant les différents PayID de test et les coordonnées bancaires ci-dessous. Chaque combinaison donne lieu à un scénario différent auquel votre intégration pourrait être confrontée en mode production.

#### PayID

| PayID                                                    | Description                                                                                                                                                                                                                                                                                                                                    |
| -------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `{any_prefix}+succeed@{any_domain}`                      | L’état de la PaymentIntent passe de `requires_action` à `processing` au bout de 10&nbsp;secondes, puis à `succeeded` après 5&nbsp;secondes supplémentaires. Le mandat passe alors à l’état `active`.                                                                                                                                           |
| `{any_prefix}+decline@{any_domain}`                      | L’état de la PaymentIntent passe de `requires_action` à `requires_payment_method` au bout de 10&nbsp;secondes. Stripe renvoie le code d’erreur `payment_method_provider_decline` avec le code de refus de paiement `invalid_authorization`. Le mandat passe alors à l’état `inactive`.                                                         |
| `{any_prefix}+expire@{any_domain}`                       | L’état de la PaymentIntent passe de `requires_action` à `requires_payment_method` au bout de 10&nbsp;secondes. Stripe renvoie le code d’erreur `payment_method_provider_decline` avec le code de refus de paiement `generic_decline`. Le mandat passe alors à l’état `inactive`.                                                               |
| `{any_prefix}+insufficient_funds@{any_domain}`           | L’état de la PaymentIntent passe de `requires_action` à `processing` au bout de 10&nbsp;secondes, puis à `requires_payment_method` après 5&nbsp;secondes supplémentaires. Stripe renvoie le code d’erreur `payment_method_provider_decline` avec le code de refus de paiement `insufficient_funds`. Le mandat passe alors à l’état `inactive`. |
| `{any_prefix}+revoke@{any_domain}`                       | L’état de la PaymentIntent passe de `requires_action` à `processing` au bout de 10&nbsp;secondes, puis à `succeeded` après 5&nbsp;secondes supplémentaires. Le mandat est d’abord à l’état `active`, puis passe à l’état `inactive` au bout d’une minute.                                                                                      |
| `{any_prefix}+agreement_type_not_supported@{any_domain}` | L’état de la PaymentIntent passe de `requires_action` à `requires_payment_method` au bout de 10&nbsp;secondes. Stripe renvoie le code d’erreur `payment_method_provider_decline`. Le mandat passe alors à l’état `inactive`.                                                                                                                   |

#### Numéros de compte et BSB

| Numéro BSB | Numéro de compte | Description                                                                                                                                                                                                                                                                                                                                    |
| ---------- | ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `000000`   | `000123456`      | L’état de la PaymentIntent passe de `requires_action` à `processing` au bout de 10&nbsp;secondes, puis à `succeeded` après 5&nbsp;secondes supplémentaires. Le mandat passe alors à l’état `active`.                                                                                                                                           |
| `000000`   | `333333335`      | L’état de la PaymentIntent passe de `requires_action` à `requires_payment_method` au bout de 10&nbsp;secondes. Stripe renvoie le code d’erreur `payment_method_provider_decline` avec le code de refus de paiement `invalid_authorization`. Le mandat passe alors à l’état `inactive`.                                                         |
| `000000`   | `333333337`      | L’état de la PaymentIntent passe de `requires_action` à `requires_payment_method` au bout de 10&nbsp;secondes. Stripe renvoie le code d’erreur `payment_method_provider_decline` avec le code de refus de paiement `generic_decline`. Le mandat passe alors à l’état `inactive`.                                                               |
| `000000`   | `222222227`      | L’état de la PaymentIntent passe de `requires_action` à `processing` au bout de 10&nbsp;secondes, puis à `requires_payment_method` après 5&nbsp;secondes supplémentaires. Stripe renvoie le code d’erreur `payment_method_provider_decline` avec le code de refus de paiement `insufficient_funds`. Le mandat passe alors à l’état `inactive`. |
| `000000`   | `444444447`      | L’état de la PaymentIntent passe de `requires_action` à `processing` au bout de 10&nbsp;secondes, puis à `succeeded` après 5&nbsp;secondes supplémentaires. Le mandat est d’abord à l’état `active`, puis passe à l’état `inactive` au bout d’une minute.                                                                                      |
| `000000`   | `666666667`      | L’état de la PaymentIntent passe de `requires_action` à `requires_payment_method` au bout de 10&nbsp;secondes. Stripe renvoie le code d’erreur `payment_method_provider_decline`. Le mandat passe alors à l’état `inactive`.                                                                                                                   |

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

Stripe envoie un événement [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded) à l’issue du paiement. Utilisez le Dashboard, un *webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) personnalisé ou une solution partenaire 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 workflow de livraison.

Plutôt que d’attendre un rappel de votre client, écoutez ces événements. En effet, côté client, l’acheteur pourrait fermer la fenêtre de son navigateur ou quitter l’application avant l’exécution du rappel. Des personnes malveillantes peuvent en profiter pour manipuler la réponse. Si vous configurez votre intégration de manière à écouter les événements asynchrones, cela vous permettra également d’accepter de nouveaux moyens de paiement plus facilement à l’avenir. Apprenez-en davantage sur les [différences entre les différents moyens de paiement pris en charge](https://stripe.com/payments/payment-methods-guide).

### Recevoir des événements et exécuter des actions métier

Plusieurs options s’offrent à vous pour recevoir et exécuter des actions métier.

#### Manuellement

Utilisez le Dashboard pour consulter tous vos paiements Stripe, envoyer des reçus par e-mail, gérer les virements et relancer les paiements ayant échoué.

- [Afficher vos paiements tests dans le Dashboard](https://dashboard.stripe.com/test/payments)

#### Code personnalisé

Créez un gestionnaire de webhooks pour écouter des événements et créer des tunnels de paiement asynchrones personnalisés. Testez et déboguez votre intégration de webhooks en local, grâce à la CLI Stripe.

- [Créer un webhook personnalisé](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook)

#### Applications préconfigurées

Intégrez une application partenaire pour gérer les événements métier courants, comme l’[automatisation](https://stripe.partners/?f_category=automation), le [marketing ou les ventes](https://stripe.partners/?f_category=marketing-and-sales).