# Paiements PayTo

Découvrez PayTo, un nouveau moyen de paiement en temps réel en Australie.

PayTo est un moyen de paiement en temps réel en Australie permettant d’accepter les paiements uniques et récurrents. Lors d’un paiement avec PayTo, les clients s’[identifient et approuvent](https://docs.stripe.com/payments/payment-methods.md#customer-actions) les accords à l’aide de leur application bancaire mobile ou de leurs services bancaires en ligne.

Vous recevez une [notification différée](https://docs.stripe.com/payments/payment-methods.md#payment-notification) indiquant si le paiement a abouti ou échoué. Stripe envoie généralement une notification de l’état final du paiement dans les 60 secondes suivant l’autorisation du mandat.

# Checkout

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

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

#### 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_types[0]=card" \
  -d "payment_method_types[1]=payto" \
  --data-urlencode "success_url=https://example.com/success"
```

#### Formulaire intégré

```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_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}`                      | The PaymentIntent status transitions from `requires_action` to `processing` after 10 seconds, then transitions to `succeeded` after an additional 5 seconds.                                                                                                                                        |
| `{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`.                                                         |
| `{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_timeout` avec le code de refus de paiement `generic_decline`.                                                               |
| `{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`. |
| `{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`      | The PaymentIntent status transitions from `requires_action` to `processing` after 10 seconds, then transitions to `succeeded` after an additional 5 seconds.                                                                                                                                        |
| `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`.                                                         |
| `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_timeout` avec le code de refus de paiement `generic_decline`.                                                               |
| `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`. |
| `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/accept-a-payment?payment-ui=elements.

## 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 PaymentIntent [Côté serveur]

Un [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) est un objet qui représente votre intention d’encaisser le paiement d’un client et qui suit le processus de paiement. Pour créer un `PaymentIntent` qui accepte un moyen de paiement PayTo, spécifiez le montant à collecter, la devise `aud`, et sélectionnez `payto` dans la liste des [payment_method_types](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types). Si vous gérez une liste de types de moyens de paiement que vous transmettez lors de la création d’un `PaymentIntent`, ajoutez-y `payto`.

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1000 \
  -d currency=aud \
  -d "payment_method_types[]=payto"
```

### 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 [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;
```

## 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. 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',
  });

  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',
    });


    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;
```

## 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}`                      | The PaymentIntent status transitions from `requires_action` to `processing` after 10 seconds, then transitions to `succeeded` after an additional 5 seconds.                                                                                                                                        |
| `{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`.                                                         |
| `{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_timeout` avec le code de refus de paiement `generic_decline`.                                                               |
| `{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`. |
| `{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`      | The PaymentIntent status transitions from `requires_action` to `processing` after 10 seconds, then transitions to `succeeded` after an additional 5 seconds.                                                                                                                                        |
| `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`.                                                         |
| `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_timeout` avec le code de refus de paiement `generic_decline`.                                                               |
| `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`. |
| `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).

- **Gérer les événements manuellement dans le Dashboard**

  Utilisez le Dashboard pour [afficher vos paiements de test dans le Dashboard](https://dashboard.stripe.com/test/payments), envoyer des reçus par e-mail, gérer les virements ou réessayer les paiements échoués.

- **Créer un webhook personnalisé**

  [Build a custom webhook](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook) handler to listen for events and build custom asynchronous payment flows. Test and debug your webhook integration locally with the Stripe CLI.

- **Intégrer une application prédéfinie**

  Gérez les événements commerciaux courants, tels que l’[automatisation](https://stripe.partners/?f_category=automation) ou le [marketing et les ventes](https://stripe.partners/?f_category=marketing-and-sales), en intégrant une application partenaire.


# API Direct

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

## 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 PaymentIntent [Côté serveur]

Un [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) est un objet qui représente votre intention d’encaisser le paiement d’un client et qui suit le processus de paiement. Pour créer un `PaymentIntent` qui accepte un moyen de paiement PayTo, spécifiez le montant à collecter, la devise `aud`, et sélectionnez `payto` dans la liste des [payment_method_types](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types). Si vous gérez une liste de types de moyens de paiement que vous transmettez lors de la création d’un `PaymentIntent`, ajoutez-y `payto`.

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1000 \
  -d currency=aud \
  -d "payment_method_types[]=payto"
```

### 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 demande de paiement, et l’autorise ou la refuse dans son application bancaire.

```javascript
// Inititates the payment request notification to the customer
stripe.confirmPayToPayment(
  '{{PAYMENT_INTENT_CLIENT_SECRET}}',
  {
    payment_method: {
      billing_details: {
        // Name is required for all PayTo payments
        name: 'Jenny Rosen',
        // Email is required only for PayID payments, for refund processing
        email: 'jenny@example.com'
      },
      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 lorsque le PaymentIntent passe à l’état `succeeded`, ou lorsque le paiement échoue et le PaymentIntent renvoie l’état `requires_payment_method` Consultez la page dédiée au [cycle de vie des objets PaymentIntent](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, appelez l’[API PaymentIntents](https://docs.stripe.com/api/payment_intents/retrieve.md) pour récupérer vous-même l’état du PaymentIntent.

## 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}`                      | The PaymentIntent status transitions from `requires_action` to `processing` after 10 seconds, then transitions to `succeeded` after an additional 5 seconds.                                                                                                                                        |
| `{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`.                                                         |
| `{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_timeout` avec le code de refus de paiement `generic_decline`.                                                               |
| `{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`. |
| `{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`      | The PaymentIntent status transitions from `requires_action` to `processing` after 10 seconds, then transitions to `succeeded` after an additional 5 seconds.                                                                                                                                        |
| `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`.                                                         |
| `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_timeout` avec le code de refus de paiement `generic_decline`.                                                               |
| `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`. |
| `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).

- **Gérer les événements manuellement dans le Dashboard**

  Utilisez le Dashboard pour [afficher vos paiements de test dans le Dashboard](https://dashboard.stripe.com/test/payments), envoyer des reçus par e-mail, gérer les virements ou réessayer les paiements échoués.

- **Créer un webhook personnalisé**

  [Build a custom webhook](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook) handler to listen for events and build custom asynchronous payment flows. Test and debug your webhook integration locally with the Stripe CLI.

- **Intégrer une application prédéfinie**

  Gérez les événements commerciaux courants, tels que l’[automatisation](https://stripe.partners/?f_category=automation) ou le [marketing et les ventes](https://stripe.partners/?f_category=marketing-and-sales), en intégrant une application partenaire.