# Accepter un paiement par prélèvement automatique ACH

Créez un formulaire de paiement personnalisé ou utilisez Stripe Checkout pour accepter des paiements à l'aide d'un compte bancaire américain.

# Paiement

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

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

Les utilisateurs de Stripe aux États-Unis peuvent utiliser Checkout en mode paiement pour accepter les paiements par prélèvement automatique ACH.

Une session Checkout affiche les détails de l’intention d’achat de votre client. Vous créez une session pour permettre à votre client de s’acquitter de son règlement. Une fois le client redirigé vers votre session Checkout, Stripe lui présente un formulaire de paiement qui lui permet de finaliser son achat. Lorsque l’achat est finalisé, il est redirigé vers votre site.

Avec Checkout, vous pouvez créer une session Checkout en utilisant `us_bank_account` comme type de moyen de paiement pour suivre et gérer les états du paiement jusqu’à ce qu’il aboutisse.

> Le prélèvement automatique ACH est un moyen de paiement à [notification différée](https://docs.stripe.com/payments/payment-methods.md#payment-notification), ce qui signifie que les fonds ne sont pas immédiatement disponibles après le paiement. Il faut généralement compter 4 jours ouvrables pour qu’un paiement arrive sur votre compte.

## Déterminer la compatibilité

**Lieux d’implantation pris en charge** : US

**Devises prises en charge** : `usd`

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

**Mode de paiement** : Yes

**Mode de configuration** : Yes

**Mode d’abonnement** : Yes

Pour prendre en charge les paiements par prélèvement automatique ACH, assurez-vous d’exprimer les *Prices* (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 de facture en dollars américains (code de devise `usd`).

## Créer ou récupérer un objet Customer [Recommandé] [Côté serveur]

> #### Utiliser l’API Accounts v2 pour représenter les clients
> 
> L’API Accounts v2 est généralement disponible pour les utilisateurs de Connect et en aperçu public pour les autres utilisateurs de Stripe. Si vous avez accès à l’aperçu Accounts v2, vous devez [spécifier une version d’aperçu](https://docs.stripe.com/api-v2-overview.md#sdk-and-api-versioning) dans votre code.
> 
> Pour demander l’accès à l’aperçu Accounts v2, 
> 
> Dans la plupart des cas d’usage, nous vous recommandons de [modéliser vos clients en tant qu’objets Account configurés par le client](https://docs.stripe.com/connect/use-accounts-as-customers.md), plutôt que d’utiliser des objets [Customer](https://docs.stripe.com/api/customers.md).

#### Accounts v2

Créez un objet [Account](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-configuration-customer) configuré par le client lorsque votre utilisateur crée un compte auprès de votre entreprise, ou récupérez un `Account` existant associé à cet utilisateur. L’association de l’ID de l’objet `Account` à votre propre représentation interne d’un client vous permet de récupérer et d’utiliser ultérieurement les informations de moyen de paiement enregistrées. Ajoutez une adresse e-mail à l’`objet Account` pour activer [l’optimisation des utilisateurs connus](https://docs.stripe.com/financial-connections/fundamentals.md#return-user-optimization) de Financial Connections.

```curl
curl -X POST https://api.stripe.com/v2/core/accounts \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-03-25.preview" \
  --json '{
    "contact_email": "{{CUSTOMER_EMAIL}}"
  }'
```

#### Customers&nbsp;v1

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) lorsque votre client crée un compte auprès de votre entreprise, ou récupérez l’objet `Customer` existant associé à cet utilisateur. L’association de l’ID de l’objet `Customer` à votre propre représentation interne d’un client vous permet de récupérer et d’utiliser ultérieurement les informations de paiement enregistrées. Ajoutez une adresse e-mail à l’objet `Customer` pour activer [l’optimisation des utilisateurs connus](https://docs.stripe.com/financial-connections/fundamentals.md#return-user-optimization) de Financial Connections.

```curl
curl https://api.stripe.com/v1/customers \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d email={{CUSTOMER_EMAIL}}
```

## Accepter un paiement

> Avant d’utiliser ce guide, commencez par créer une intégration permettant d’[accepter un paiement](https://docs.stripe.com/payments/accept-a-payment.md?integration=checkout) avec Checkout.

Ce guide vous explique comment activer l’ACH Direct Debit et vous montre les différences entre accepter des paiements à l’aide de moyens de paiement dynamiques et configurer manuellement ces derniers.

### Activer les prélèvements automatiques ACH comme moyen de paiement

Lors de la création d’une nouvelle [session Checkout](https://docs.stripe.com/api/checkout/sessions.md), vous devez&nbsp;:

1. Ajouter `us_bank_account` à la liste des `payment_method_types`.
1. Veiller à ce que tous vos postes de facture `line_items` utilisent la devise `usd`.

#### Une page hébergée par Stripe

#### Accounts&nbsp;v2

```curl
curl https://api.stripe.com/v1/checkout/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "customer_account={{CUSTOMERACCOUNT_ID}}" \
  -d "line_items[0][price_data][currency]=usd" \
  -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]=us_bank_account" \
  --data-urlencode "success_url=https://example.com/success"
```

#### Customers&nbsp;v1

```curl
curl https://api.stripe.com/v1/checkout/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "customer={{CUSTOMER_ID}}" \
  -d "line_items[0][price_data][currency]=usd" \
  -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]=us_bank_account" \
  --data-urlencode "success_url=https://example.com/success"
```

#### Formulaire intégré

#### Accounts&nbsp;v2

```curl
curl https://api.stripe.com/v1/checkout/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "customer_account={{CUSTOMERACCOUNT_ID}}" \
  -d "line_items[0][price_data][currency]=usd" \
  -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]=us_bank_account" \
  --data-urlencode "return_url=https://example.com/return" \
  -d ui_mode=embedded_page
```

#### Customers&nbsp;v1

```curl
curl https://api.stripe.com/v1/checkout/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "customer={{CUSTOMER_ID}}" \
  -d "line_items[0][price_data][currency]=usd" \
  -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]=us_bank_account" \
  --data-urlencode "return_url=https://example.com/return" \
  -d ui_mode=embedded_page
```

Pour en savoir plus sur les frais Financial Connections, consultez les [Tarifs](https://stripe.com/financial-connections#pricing).

Par défaut, lors de la collecte des coordonnées bancaires, [Financial Connections](https://docs.stripe.com/financial-connections.md) est utilisé pour vérifier instantanément le compte de votre client. Une option de secours comprenant la saisie manuelle du numéro de compte et la vérification par microversement peut être utilisée. Consultez la [documentation relative à Financial Connections](https://docs.stripe.com/financial-connections/ach-direct-debit-payments.md) pour savoir comment configurer Financial Connections et accéder à des données de compte supplémentaires de façon à optimiser votre intégration ACH. Par exemple, vous pouvez utiliser Financial Connections pour consulter le solde d’un compte avant d’initier le paiement ACH.

> Pour accéder à des données supplémentaires après qu’un client a authentifié son compte, celui-ci doit associer de nouveau son compte avec des autorisations étendues.

Si le client opte pour la vérification par microversements au lieu de la vérification par Financial Connections, Stripe envoie automatiquement deux versements de faible montant au compte bancaire indiqué. Ces versements apparaissent sur le relevé bancaire en ligne du client sous deux&nbsp;jours ouvrables. Le client reçoit alors un lien par e-mail afin confirmer ces montants et vérifier son compte bancaire auprès de Stripe. Une fois la vérification terminée, le traitement du paiement commence.

Nous vous recommandons d’inclure le paramètre [payment_intent_data.setup_future_usage](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-setup_future_usage) avec une valeur définie sur `off_session` lors de la création d’une session en mode paiement pour les prélèvements ACH Direct Debit afin de pouvoir [enregistrer les informations du moyen de paiement](https://docs.stripe.com/payments/accept-a-payment.md?payment-ui=checkout&ui=stripe-hosted#save-payment-method-details).

### Traiter vos commandes

Après avoir accepté un paiement, découvrez comment [réaliser les commandes](https://docs.stripe.com/checkout/fulfillment.md).

## Tester votre intégration

Découvrez comment tester des scénarios avec des vérifications instantanées à l’aide de [Financial Connections](https://docs.stripe.com/financial-connections/testing.md#web-how-to-use-test-accounts).

### Envoyer des e-mails de transaction dans un environnement de test

Une fois que vous avez collecté les coordonnées bancaires et accepté un mandat, envoyez les courriels de confirmation du mandat et de vérification du microversement dans un *environnement de bac à sable* (A sandbox is an isolated test environment that allows you to test Stripe functionality in your account without affecting your live integration. Use sandboxes to safely experiment with new features and changes).

Si votre domaine est **{domain}** et votre nom d’utilisateur est **{username}**, utilisez le format d’adresse e-mail suivant pour envoyer des e-mails de transaction de test&nbsp;: **{username}+test\_email@{domain}**.

Par exemple, si votre domaine est **example.com** et que votre nom d’utilisateur est **info**, utilisez le format **info+test\_email@example.com** pour tester les paiements ACH Direct Debit. Ce format garantit que les e-mails sont acheminés correctement. Si vous n’incluez pas le suffixe **+test\_email**, nous n’enverrons pas l’e-mail.

> Vous devez [configurer votre compte Stripe](https://docs.stripe.com/get-started/account/set-up.md) avant de pouvoir déclencher ces e-mails pendant les tests.

### Numéros de comptes de test

Stripe fournit plusieurs numéros de compte de test et les tokens correspondants que vous pouvez utiliser pour vous assurer que votre intégration pour les comptes bancaires saisis manuellement est prête à passer en mode production.

| Numéro de compte | Token                                  | Numéro de routage | Comportement                                                                                                                                                                                                                                                                                                         |
| ---------------- | -------------------------------------- | ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `000123456789`   | `pm_usBankAccount_success`             | `110000000`       | Le paiement aboutit.                                                                                                                                                                                                                                                                                                 |
| `000111111113`   | `pm_usBankAccount_accountClosed`       | `110000000`       | Le paiement échoue parce que le compte est clôturé.                                                                                                                                                                                                                                                                  |
| `000000004954`   | `pm_usBankAccount_riskLevelHighest`    | `110000000`       | Le paiement est bloqué par Radar en raison d’un [risque élevé de fraude](https://docs.stripe.com/radar/risk-evaluation.md#high-risk).                                                                                                                                                                                |
| `000111111116`   | `pm_usBankAccount_noAccount`           | `110000000`       | Le paiement échoue car aucun compte n’est trouvé.                                                                                                                                                                                                                                                                    |
| `000222222227`   | `pm_usBankAccount_insufficientFunds`   | `110000000`       | Le paiement échoue en raison de fonds insuffisants.                                                                                                                                                                                                                                                                  |
| `000333333335`   | `pm_usBankAccount_debitNotAuthorized`  | `110000000`       | Le paiement échoue parce que les débits ne sont pas autorisés.                                                                                                                                                                                                                                                       |
| `000444444440`   | `pm_usBankAccount_invalidCurrency`     | `110000000`       | Le paiement échoue en raison d’une devise non valide.                                                                                                                                                                                                                                                                |
| `000666666661`   | `pm_usBankAccount_failMicrodeposits`   | `110000000`       | Le paiement ne parvient pas à envoyer les microversements.                                                                                                                                                                                                                                                           |
| `000555555559`   | `pm_usBankAccount_dispute`             | `110000000`       | Le paiement déclenche un litige.                                                                                                                                                                                                                                                                                     |
| `000000000009`   | `pm_usBankAccount_processing`          | `110000000`       | Le traitement du paiement est indéfini. Utile pour tester {&nbsp;% si $checkoutSessions %}[Expiration de la session de paiement](https://docs.stripe.com/api/checkout/sessions/expire.md){&nbsp;% else /&nbsp;%}[Annulation de PaymentIntent](https://docs.stripe.com/api/payment_intents/cancel.md){&nbsp;% /if %}. |
| `000777777771`   | `pm_usBankAccount_weeklyLimitExceeded` | `110000000`       | Le paiement échoue, car son montant entraîne un dépassement de la limite hebdomadaire de volume de paiement du compte.                                                                                                                                                                                               |
| `000888888885`   |                                        | `110000000`       | Le paiement échoue en raison d’un [numéro de compte tokenisé](https://docs.stripe.com/financial-connections/tokenized-account-numbers.md) désactivé.                                                                                                                                                                 |

Avant d’effectuer les transactions de test, vous devez vérifier tous les comptes de test pour lesquels le paiement aboutit ou échoue automatiquement. Pour ce faire, utilisez les codes de libellé ou les montants de microversements de test ci-dessous.

### Tester des codes de libellé et des montants de microversements

Pour simuler différents scénarios, utilisez ces montants de microversements *ou* ces codes de libellé 0.01.

| Valeurs de microversement | Valeurs de code de libellé 0.01 | Scénario                                                                |
| ------------------------- | ------------------------------- | ----------------------------------------------------------------------- |
| `32` et `45`              | SM11AA                          | Simule la vérification du compte.                                       |
| `10` et `11`              | SM33CC                          | Simule le dépassement du nombre de tentatives de vérification autorisé. |
| `40` et `41`              | SM44DD                          | Simule l’expiration du délai de validité d’un microversement.           |

### Comportement de règlement des tests

Les transactions de test sont réglées instantanément et ajoutées à votre solde de test disponible. Ce comportement diffère de celui du mode production, où les transactions peuvent prendre [plusieurs jours](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#timing) pour être réglées dans votre solde disponible.

## Autres considérations

### Échec de la vérification des microversements

Lorsqu’un compte bancaire est en attente de vérification par microversements, la vérification du client peut échouer pour trois raisons&nbsp;:

- L’envoi des microversements au compte bancaire du client a échoué (en général, ce problème signifie que le compte bancaire est clôturé ou non disponible, ou que le numéro du compte bancaire est incorrect).
- Les 10&nbsp;tentatives de vérification du compte effectuées par le client ont échoué. Une fois cette limite atteinte, le compte bancaire ne peut plus être vérifié ni utilisé.
- Le client n’a pas vérifié son compte bancaire dans le délai de 10&nbsp;jours prévu.

Si la vérification du compte bancaire échoue pour l’une de ces raisons, vous pouvez [gérer l’événement `checkout.session.async_payment_failed`](https://docs.stripe.com/api/events/types.md?event_types-invoice.payment_succeeded=#event_types-checkout.session.async_payment_failed) pour contacter le client et lui proposer de passer une nouvelle commande.

## Optional: Vérification instantanée uniquement

Par défaut, les paiements par prélèvement automatique ACH permettent à vos clients d’utiliser la vérification instantanée du compte bancaire ou les microversements. Vous pouvez aussi exiger la vérification instantanée du compte bancaire en utilisant le paramètre `payment_method_options[us_bank_account][verification_method]` lorsque vous créez la Checkout Session.

#### Accounts&nbsp;v2

```curl
curl https://api.stripe.com/v1/checkout/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d mode=payment \
  -d "customer_account={{CUSTOMERACCOUNT_ID}}" \
  -d "payment_method_types[0]=card" \
  -d "payment_method_types[1]=us_bank_account" \
  -d "payment_method_options[us_bank_account][verification_method]=instant" \
  -d "payment_method_options[us_bank_account][financial_connections][permissions][0]=payment_method" \
  -d "line_items[0][price_data][currency]=usd" \
  -d "line_items[0][price_data][unit_amount]=2000" \
  -d "line_items[0][price_data][product_data][name]=T-shirt" \
  -d "line_items[0][quantity]=1" \
  --data-urlencode "success_url=https://example.com/success"
```

#### Customers&nbsp;v1

```curl
curl https://api.stripe.com/v1/checkout/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d mode=payment \
  -d "customer={{CUSTOMER_ID}}" \
  -d "payment_method_types[0]=card" \
  -d "payment_method_types[1]=us_bank_account" \
  -d "payment_method_options[us_bank_account][verification_method]=instant" \
  -d "payment_method_options[us_bank_account][financial_connections][permissions][0]=payment_method" \
  -d "line_items[0][price_data][currency]=usd" \
  -d "line_items[0][price_data][unit_amount]=2000" \
  -d "line_items[0][price_data][product_data][name]=T-shirt" \
  -d "line_items[0][quantity]=1" \
  --data-urlencode "success_url=https://example.com/success"
```

## Optional: Accéder aux données d'un compte bancaire Financial Connections

Vous ne pouvez accéder aux données Financial Connections que si vous demandez des [autorisations](https://docs.stripe.com/financial-connections/fundamentals.md#data-permissions) d’accès supplémentaires lors de la création de votre PaymentIntent .

Une fois que votre client a terminé le tunnel de paiement, l’objet PaymentMethod `us_bank_account` renvoyé inclut un ID de [financial_connections_account](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-us_bank_account-financial_connections_account) correspondant à un [compte Financial Connections](https://docs.stripe.com/api/financial_connections/accounts.md). Utilisez cet ID pour accéder aux données du compte.

> Les comptes bancaires que vos clients associent par saisie manuelle ou par le biais de microversements n’ont pas d’ID `financial_connections_account` au niveau du moyen de paiement.

Pour déterminer l’ID du compte Financial Connections, récupérez la session Checkout et développez l’attribut `payment_intent.payment_method`&nbsp;:

```curl
curl -G https://api.stripe.com/v1/checkout/sessions/{{CHECKOUTSESSION_ID}} \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "expand[]=payment_intent.payment_method"
```

```json
{
  "id": "{{CHECKOUT_SESSION_ID}}",
  "object": "checkout.session",
  // ...
  "payment_intent": {
    "id": "{{PAYMENT_INTENT_ID}}",
    "object": "payment_intent",
    // ...
    "payment_method": {
      "id": "{{PAYMENT_METHOD_ID}}",
      // ...
      "type": "us_bank_account",
      "us_bank_account": {
        "account_holder_type": "individual",
        "account_type": "checking",
        "bank_name": "TEST BANK","financial_connections_account": "{{FINANCIAL_CONNECTIONS_ACCOUNT_ID}}",
        "fingerprint": "q9qchffggRjlX2tb",
        "last4": "6789",
        "routing_number": "110000000"
      }
    }
    // ...
  }
}
```

Découvrez comment utiliser des données de compte supplémentaires pour optimiser votre intégration ACH avec [Financial Connections](https://docs.stripe.com/financial-connections/ach-direct-debit-payments.md#optimize).

## Optional: Résoudre les litiges [Côté serveur]

En règle générale, les clients peuvent [contester un paiement ACH Direct Debit](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#resolving-disputes) auprès de leur banque sous 60&nbsp;jours calendaires après un prélèvement sur un compte personnel, ou sous 2&nbsp;jours ouvrables pour un compte professionnel. Dans de rares cas, le client peut contester un paiement par prélèvement en dehors de ces délais de litige standard.

Lorsqu’un client conteste un paiement, Stripe envoie un événement webhook [charge.dispute.closed](https://docs.stripe.com/api/events/types.md#event_types-charge.dispute.closed), et l’autorisation du PaymentMethod est révoquée.

Il peut parfois arriver que Stripe reçoive un échec de paiement ACH de la banque alors que le PaymentIntent est déjà passé à l’état `succeeded`. Quand cela se produit, Stripe créée un litige dont le paramètre `reason` (motif) peut être&nbsp;:

- `insufficient_funds`
- `incorrect_account_details`
- `bank_can't_process`

Dans ce cas de figure, Stripe prélève des frais d’échec de paiement.

Les futurs paiements qui réutilisent ce PaymentMethod renvoient l’erreur suivante&nbsp;:

```javascript
{
  "error": {
    "message": "This PaymentIntent requires a mandate, but no existing mandate was found. Collect mandate acceptance from the customer and try again, providing acceptance data in the mandate_data parameter.",
    "payment_intent": {
      ...
    }
    "type": "invalid_request_error"
  }
}
```

Cette erreur comporte un PaymentIntent à l’état `requires_confirmation`. Pour que le paiement aboutisse, vous devez&nbsp;:

1. Résolvez le litige avec le client afin d’éviter toute contestation lors de futurs paiements.
1. Confirmez de nouveau l’autorisation de votre client.

Pour confirmer l’autorisation de paiement, vous pouvez [collecter la confirmation du mandat de votre client en ligne avec Stripe.js](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md?platform=web#web-collect-mandate-and-submit) ou confirmer l’autorisation avec votre client hors ligne à l’aide de l’API Stripe.

> Si un client conteste plusieurs paiements issus du même compte bancaire, Stripe bloque son compte. Contactez le [service Support de Stripe](https://support.stripe.com/?contact=true) pour obtenir une solution.

```curl
curl https://api.stripe.com/v1/payment_intents/{{PAYMENT_INTENT_ID}}/confirm \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "mandate_data[customer_acceptance][type]=offline"
```

## Optional: Référence du paiement

Le numéro de référence du paiement est une valeur générée par la banque qui permet au titulaire du compte bancaire d’utiliser sa banque pour localiser des fonds. Lorsque le paiement aboutit, Stripe fournit le numéro de référence du paiement dans le Dashboard, ainsi que dans l’[objet Charge](https://docs.stripe.com/api/charges/object.md).

| État du paiement | Valeur de référence du paiement           |
| ---------------- | ----------------------------------------- |
| En attente       | Indisponibles                             |
| En échec         | Indisponibles                             |
| Réussi           | Disponible (par exemple, 091000015001234) |

De plus, lorsque vous recevez le webhook `charge.succeeded`, consultez le contenu de `payment_method_details` pour localiser la [payment_reference](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-us_bank_account-payment_reference).

L’exemple d’événement suivant montre le rendu d’un paiement ACH abouti avec un numéro de référence de paiement.

#### charge-succeeded

```json
{
  "id": "{{EVENT_ID}}",
  "object": "event",
  // omitted some fields in the example
  "type": "charge.succeeded",
  "data": {
    "object": {
      "id": "{{PAYMENT_ID}}",
      "object": "charge",
      //...
    "paid": true,
    "payment_intent": "{{PAYMENT_INTENT_ID}}",
    "payment_method": "{{PAYMENT_METHOD_ID}}",
    "payment_method_details": {
      "type": "us_bank_account",
      "us_bank_account": {
        "account_holder_type": "individual",
        "account_type": "checking",
        "bank_name": "TEST BANK",
        "fingerprint": "Ih3foEnRvLXShyfB",
        "last4": "1000","payment_reference": "091000015001234",
        "routing_number": "110000000"
        }
      }
      // ...
    }
  }
}
```

Consultez le contenu de `destination_details` pour localiser la [référence du remboursement](https://docs.stripe.com/api/refunds/object.md#refund_object-destination_details-us_bank_transfer-reference) associée aux paiements ACH remboursés.

L’exemple d’événement suivant montre le rendu d’un remboursement de paiement ACH abouti avec un numéro de référence de remboursement. En savoir plus sur les [remboursements](https://docs.stripe.com/refunds.md).

#### charge-refund-updated

```json
{
  "id": "{{EVENT_ID}}",
  "object": "event",
  "type": "charge.refund.updated",
  "data": {
    "object": {
      "id": "{{REFUND_ID}}",
      "object": "refund",
      //...
    "payment_intent": "{{PAYMENT_INTENT_ID}}",
    "destination_details": {
      "type": "us_bank_transfer",
      "us_bank_transfer": {"reference": "091000015001111",
        "reference_status": "available"
        }
      }
      // ...
    }
  }
}
```

## Optional: Configurer la date de prélèvement du client [Côté serveur]

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

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

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

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

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

> Vous ne pouvez pas définir le [verification method](https://docs.stripe.com/api/checkout/sessions/object.md#checkout_session_object-payment_method_options-us_bank_account-verification_method) to `microdeposits` lors de l’utilisation d’un [target date](https://docs.stripe.com/api/checkout/sessions/object.md#checkout_session_object-payment_method_options-us_bank_account-target_date), car le processus de vérification pourrait prendre plus de temps que prévu, ce qui entraînerait des retards dans les paiements.

## See also

- [Enregistrer les coordonnées de prélèvement automatique ACH pour les futurs paiements](https://docs.stripe.com/payments/ach-direct-debit/set-up-payment.md)


# API Checkout Sessions

> This is a API Checkout Sessions for when payment-ui is elements and api-integration is checkout. View the full page at https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment?payment-ui=elements&api-integration=checkout.

Pour déterminer quelle API répond aux besoins de votre entreprise, consultez la section[guide de comparaison](https://docs.stripe.com/payments/checkout-sessions-and-payment-intents-comparison.md).

Utilisez le [Payment Element](https://docs.stripe.com/payments/payment-element.md) pour intégrer un formulaire de paiement Stripe personnalisé sur votre site Web ou application et proposer des moyens de paiement à vos clients. Pour les configurations et personnalisations avancées, consultez le guide d’intégration [Accepter un Paiement](https://docs.stripe.com/payments/accept-a-payment.md).

Avant d’utiliser le prélèvement automatique ACH dans votre intégration de l’Element Payment, prenez connaissance des considérations suivantes relatives au ACH Direct Debit&nbsp;:

- En savoir plus sur la [collecte des mandats](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#mandate-collection).
- Choisissez le mode de [vérification des comptes bancaires](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#bank-verification).

> #### Utiliser l’API Accounts v2 pour représenter les clients
> 
> L’API Accounts&nbsp;v2 est généralement disponible pour les utilisateurs de Connect et en aperçu public pour les autres utilisateurs de Stripe. Si vous avez accès à l’aperçu Accounts&nbsp;v2, vous devez [spécifier une version d’aperçu](https://docs.stripe.com/api-v2-overview.md#sdk-and-api-versioning) dans votre code.
> 
> Pour demander l’accès à l’aperçu Accounts&nbsp;v2, 
> 
> Dans la plupart des cas d’usage, nous vous recommandons de [modéliser vos clients en tant qu’objets Account configurés par le client](https://docs.stripe.com/connect/use-accounts-as-customers.md), plutôt que d’utiliser des objets [Customer](https://docs.stripe.com/api/customers.md).

### Collecte des mandats

Lorsque vous acceptez des paiements ACH, vous devez comprendre les mandats.

À moins que vous n’utilisiez une intégration API directe, Stripe gère la collecte et le stockage des mandats pour votre entreprise afin de garantir le respect des exigences réglementaires. Lorsqu’un client accepte le mandat au cours du processus de paiement, Stripe stocke automatiquement ces informations et vous pouvez y accéder à partir de votre Dashboard.

## Configurez le serveur [Côté serveur]

Utilisez les bibliothèques officielles de Stripe pour accéder à l’API depuis votre application.

#### Ruby

```bash
# Available as a gem
sudo gem install stripe
```

```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```

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

Ajoutez à votre serveur un endpoint qui crée un objet [Checkout Session](https://docs.stripe.com/api/checkout/sessions/create.md) et renvoie la [clé secrète du client](https://docs.stripe.com/api/checkout/sessions/object.md#checkout_session_object-client_secret) à votre front-end. Une session Checkout représente la session d’un client qui paie des achats ponctuels ou des abonnements. Les sessions Checkout expirent 24&nbsp;heures après leur création.

Nous recommandons d’utiliser des [méthodes de paiement dynamiques](https://docs.stripe.com/payments/payment-methods/dynamic-payment-methods.md) pour afficher automatiquement les moyens de paiement les plus pertinents à chaque client, afin d’optimiser le taux de conversion. Vous pouvez également [lister manuellement les méthodes de paiement](https://docs.stripe.com/payments/payment-methods/integration-options.md#listing-payment-methods-manually), ce qui désactive les options dynamiques.

#### Gérer les moyens de paiement dans le Dashboard

#### TypeScript

```javascript
import express, {Express} from 'express';

const app: Express = express();

app.post('/create-checkout-session', async (req: Express.Request, res: Express.Response) => {
  const session = await stripe.checkout.sessions.create({
    line_items: [
      {
        price_data: {
          currency: 'usd',
          product_data: {
            name: 'T-shirt',
          },
          unit_amount: 2000,
        },
        quantity: 1,
      },
    ],
    mode: 'payment',ui_mode: 'elements',
    // The URL of your payment completion page
    return_url: 'https://example.com/return?session_id={CHECKOUT_SESSION_ID}'
  });

  res.json({checkoutSessionClientSecret: session.client_secret});
});

app.listen(3000, () => {
  console.log('Running on port 3000');
});
```

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

Pour répertorier manuellement un moyen de paiement, spécifiez-le dans [payment_method_types](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-payment_method_types) lorsque vous créez un [Checkout Session](https://docs.stripe.com/api/checkout/sessions.md). Si vous avez `line_items` dans différentes devises, vous devez créer des Checkout Sessions séparés.

#### TypeScript

```javascript
import express, {Express} from 'express';

const app: Express = express();

app.post('/create-checkout-session', async (req: Express.Request, res: Express.Response) => {
  const session = await stripe.checkout.sessions.create({
    line_items: [
      {
        price_data: {
          currency: 'usd',
          product_data: {
            name: 'T-shirt',
          },
          unit_amount: 1099,
        },
        quantity: 1,
      },
    ],
    mode: 'payment',
    ui_mode: 'elements',
    payment_method_types: ['us_bank_account'],
    return_url: 'https://example.com/return?session_id={CHECKOUT_SESSION_ID}'
  });

  res.json({checkoutSessionClientSecret: session.client_secret});
});

app.listen(3000, () => {
  console.log('Running on port 3000');
});
```

## Configurer le front-end [Côté client]

#### HTML + 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 un lot ni en héberger de copie.

Assurez-vous que vous utilisez la dernière version de Stripe.js en incluant la balise script suivante `<script src=“https://js.stripe.com/dahlia/stripe.js”></script>`. En savoir plus sur la [gestion de la version Stripe.js](https://docs.stripe.com/sdks/stripejs-versioning.md).

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

> Stripe propose un paquet npm que vous pouvez utiliser pour charger Stripe.js en tant que module. Consultez le [projet sur GitHub](https://github.com/stripe/stripe-js). La version [7.0.0](https://www.npmjs.com/package/%40stripe/stripe-js/v/7.0.0) ou une version ultérieure est requise.

Initialisez stripe.js.

```js
// 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>>',
);
```

#### React

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. Vous avez besoin d’au moins la version&nbsp;5.0.0 pour React Stripe.js et la version&nbsp;8.0.0 pour le chargeur Stripe.js.

```bash
npm install --save @stripe/react-stripe-js@^5.0.0 @stripe/stripe-js@^8.0.0
```

Initialisez une instance `stripe` sur votre front-end avec votre clé publique.

```javascript
import {loadStripe} from '@stripe/stripe-js';
const stripe = loadStripe("<<YOUR_PUBLISHABLE_KEY>>");
```

## Initialiser Checkout [Côté client]

#### HTML + JS

Appelez [initCheckoutElementsSdk](https://docs.stripe.com/js/custom_checkout/init), en transmettant `clientSecret`.

`initCheckoutElementsSdk` renvoie un objet [Checkout](https://docs.stripe.com/js/custom_checkout) contenant les données de la Session Checkout et les méthodes pour les mettre à jour.

Lisez le `total` et les `lineItems` de [actions.getSession()](https://docs.stripe.com/js/custom_checkout/session), et affichez-les dans votre interface utilisateur. Cela vous permet d’activer de nouvelles fonctionnalités avec un minimum de modifications de code. Par exemple, l’ajout de [prix manuels des devises](https://docs.stripe.com/payments/custom/localize-prices/manual-currency-prices.md) ne nécessite aucune modification de l’interface utilisateur si vous affichez le `total`.

```html
<div id="checkout-container"></div>
```

```javascript
const clientSecret = fetch('/create-checkout-session', {method: 'POST'})
  .then((response) => response.json())
  .then((json) => json.client_secret);

const checkout = stripe.initCheckoutElementsSdk({clientSecret});
const loadActionsResult = await checkout.loadActions();

if (loadActionsResult.type === 'success') {
  const session = loadActionsResult.actions.getSession();
  const checkoutContainer = document.getElementById('checkout-container');

  checkoutContainer.append(JSON.stringify(session.lineItems, null, 2));
  checkoutContainer.append(document.createElement('br'));
  checkoutContainer.append(`Total: ${session.total.total.amount}`);
}
```

#### React

Encapsulez votre application avec le composant [CheckoutElementsProvider](https://docs.stripe.com/js/react_stripe_js/checkout/checkout_provider), en lui transmettant `clientSecret` et l’instance `stripe`.

```jsx
import React from 'react';
import {CheckoutElementsProvider} from '@stripe/react-stripe-js/checkout';
import CheckoutForm from './CheckoutForm';

const clientSecret = fetch('/create-checkout-session', {method: 'POST'})
  .then((response) => response.json())
  .then((json) => json.client_secret);

const App = () => {
  return (
    <CheckoutElementsProvider
      stripe={stripe}options={{clientSecret}}
    >
      <CheckoutForm />
    </CheckoutElementsProvider>
  );
};

export default App;
```

Accédez à l’objet [Checkout](https://docs.stripe.com/js/custom_checkout) dans votre composant de formulaire de paiement en utilisant le hook `useCheckout()`. L’objet `Checkout` contient les données de la Checkout Session et les méthodes pour la mettre à jour.

Lisez le `total` et les `lineItems` de l’objet `Checkout`, et affichez-les dans votre interface utilisateur. Cela vous permet d’activer des fonctionnalités avec un minimum de modifications de code. Par exemple, l’ajout de [prix manuels des devises](https://docs.stripe.com/payments/custom/localize-prices/manual-currency-prices.md) ne nécessite aucune modification de l’interface utilisateur si vous affichez le `total`.

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

const CheckoutForm = () => {const checkoutState = useCheckout();

  if (checkoutState.type === 'loading') {
    return (
      <div>Loading...</div>
    );
  }

  if (checkoutState.type === 'error') {
    return (
      <div>Error: {checkoutState.error.message}</div>
    );
  }

  return (
    <form>{JSON.stringify(checkoutState.checkout.lineItems, null, 2)}
      {/* A formatted total amount */}
      Total: {checkoutState.checkout.total.total.amount}
    </form>
  );
};
```

## Collecter les adresses e-mail des clients [Côté client]

#### HTML + JS

Vous devez fournir une adresse e-mail client valide lors d’une Checkout Session.

Ces instructions créent une saisie d’e-mail et utilisent [updateEmail](https://docs.stripe.com/js/custom_checkout/update_email) à partir de l’objet `Checkout`.

Vous pouvez également&nbsp;:

- Transmettez [customer_email](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-customer_email), [customer_account](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-customer_account) (pour les clients représentés en tant qu’objets `Account` configurés par le client) ou [customer](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-customer) (pour les clients représentés en tant qu’objets `Customer`) lors de la création de la Checkout Session. Stripe valide les e-mails fournis de cette manière.
- Transmettre un e-mail que vous avez déjà validé sur [checkout.confirm](https://docs.stripe.com/js/custom_checkout/confirm).

```html
<input type="text" id="email" />
<div id="email-errors"></div>
```

```javascript
const checkout = stripe.initCheckoutElementsSdk({clientSecret});
const loadActionsResult = await checkout.loadActions();

if (loadActionsResult.type === 'success') {
  const {actions} = loadActionsResult;
  const emailInput = document.getElementById('email');
  const emailErrors = document.getElementById('email-errors');

  emailInput.addEventListener('input', () => {
    // Clear any validation errors
    emailErrors.textContent = '';
  });

  emailInput.addEventListener('blur', () => {
    const newEmail = emailInput.value;actions.updateEmail(newEmail).then((result) => {
      if (result.error) {
        emailErrors.textContent = result.error.message;
      }
    });
  });
}
```

#### React

Vous devez fournir une adresse e-mail client valide lors d’une Checkout Session.

Ces instructions créent une saisie d’e-mail et utilisent [updateEmail](https://docs.stripe.com/js/react_stripe_js/checkout/update_email) à partir de l’objet `Checkout`.

Vous pouvez également&nbsp;:

- Transmettez [customer_email](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-customer_email), [customer_account](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-customer_account) (pour les clients représentés en tant qu’objets `Account` configurés par le client) ou [customer](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-customer) (pour les clients représentés en tant qu’objets `Customer`) lors de la création de la Checkout Session. Stripe valide les e-mails fournis de cette manière.
- Transmettre une adresse e-mail que vous avez déjà validée avec [confirm](https://docs.stripe.com/js/react_stripe_js/checkout/confirm).

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

const EmailInput = () => {
  const checkoutState = useCheckout();
  const [email, setEmail] = React.useState('');
  const [error, setError] = React.useState(null);

  if (checkoutState.type === 'loading') {
    return (
      <div>Loading...</div>
    );
  } else if (checkoutState.type === 'error') {
    return (
      <div>Error: {checkoutState.error.message}</div>
    );
  }

  const handleBlur = () => {checkoutState.checkout.updateEmail(email).then((result) => {
      if (result.type === 'error') {
        setError(result.error);
      }
    })
  };

  const handleChange = (e) => {
    setError(null);
    setEmail(e.target.value);
  };

  return (
    <div>
      <label htmlFor="checkout-form-email">Email</label>
      <input
        id="checkout-form-email"
        type="email"
        value={email}
        onChange={handleChange}
        onBlur={handleBlur}
      />
      {error && <div>{error.message}</div>}
    </div>
  );
};

export default EmailInput;
```

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

Collectez les informations de paiement de votre client à l’aide de [Payment Element](https://docs.stripe.com/payments/payment-element.md). Payment 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

Tout d’abord, créez un élément DOM de conteneur pour monter le composant [Payment Element](https://docs.stripe.com/payments/payment-element.md). Créez ensuite une instance du `Payment Element` à l’aide de [checkout.createPaymentElement](https://docs.stripe.com/js/custom_checkout/create_payment_element) et montez-la en appelant [element.mount](https://docs.stripe.com/js/element/mount) et en fournissant soit un sélecteur CSS, soit l’élément DOM du conteneur.

```html
<div id="payment-element"></div>
```

```javascript
const paymentElement = checkout.createPaymentElement();
paymentElement.mount('#payment-element');
```

Consultez la [documentation Stripe.js](https://docs.stripe.com/js/custom_checkout/create_payment_element#custom_checkout_create_payment_element-options) pour connaître les options prises en charge.

Vous pouvez [personnaliser l’apparence](https://docs.stripe.com/payments/checkout/customization/appearance.md) de tous les Elements en transmettant [elementsOptions.appearance](https://docs.stripe.com/js/custom_checkout/init#custom_checkout_init-options-elementsOptions-appearance) lors de l’initialisation de Checkout sur le front-end.

#### React

Montez le composant [Payment Element](https://docs.stripe.com/payments/payment-element.md) dans le [CheckoutElementsProvider](https://docs.stripe.com/js/react_stripe_js/checkout/checkout_provider).

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

const CheckoutForm = () => {
  const checkoutState = useCheckout();

  if (checkoutState.type === 'loading') {
    return (
      <div>Loading...</div>
    );
  }

  if (checkoutState.type === 'error') {
    return (
      <div>Error: {checkoutState.error.message}</div>
    );
  }

  return (
    <form>

      {JSON.stringify(checkoutState.checkout.lineItems, null, 2)}
      {/* A formatted total amount */}
      Total: {checkoutState.checkout.total.total.amount}
<PaymentElement options={{layout: 'accordion'}}/>
    </form>
  );
};

export default CheckoutForm;
```

Consultez la [documentation Stripe.js](https://docs.stripe.com/js/custom_checkout/create_payment_element#custom_checkout_create_payment_element-options) pour connaître les options prises en charge.

Vous pouvez [personnaliser l’apparence](https://docs.stripe.com/payments/checkout/customization/appearance.md) de tous les Elements en transmettant [elementsOptions.appearance](https://docs.stripe.com/js/react_stripe_js/checkout/checkout_provider#react_checkout_provider-options-elementsOptions-appearance) au composant [CheckoutElementsProvider](https://docs.stripe.com/js/react_stripe_js/checkout/checkout_provider).

## Vérifier les comptes bancaires

#### Item 1

Pour en savoir plus sur les frais de Financial Connections, consultez les [Tarifs](https://stripe.com/financial-connections#pricing).

La vérification du compte bancaire utilise par défaut la vérification automatique pour collecter les informations de paiement via [Financial Connections](https://docs.stripe.com/financial-connections.md). Aucune modification n’est nécessaire pour l’utiliser. Vous pouvez modifier votre méthode de vérification en définissant `payment_method_options[us_bank_account][verification_method]` lors de la création de Checkout Session sur `instant` pour que tous les utilisateurs vérifient leurs comptes bancaires avec Financial Connections. Pour apprendre à configurer Financial Connections et accéder à des données supplémentaires du compte, comme vérifier le solde d’un compte avant d’initier un paiement, consultez la documentation [Financial Connections](https://docs.stripe.com/financial-connections.md).

#### Automatique (par défaut)

Par défaut, lors de la collecte des coordonnées bancaires, [Financial Connections](https://docs.stripe.com/financial-connections.md) vérifie instantanément le compte de votre client. Si la vérification instantanée n’est pas possible, la saisie manuelle du numéro de compte et la vérification par microversements sont utilisées.

> Pour accéder à des données supplémentaires après qu’un client a authentifié son compte, celui-ci doit associer de nouveau son compte avec des autorisations étendues. Cette authentification a lieu une fois par client, et l’autorisation qu’elle accorde est réutilisable.

**Vérification par microversements**Tous les clients ne peuvent pas vérifier leur compte bancaire instantanément. Cette section ne s’applique que si votre client a choisi de se désinscrire du flux de vérification instantanée à l’étape précédente. Dans ce cas, Stripe envoie plutôt 1 à 2&nbsp;microversements sur le compte bancaire d’un client pour vérification. Ces dépôts prennent 1 à 2&nbsp;jours ouvrables pour apparaître sur le relevé en ligne du client.

Il existe deux types de microversements&nbsp;:

- **Code de libellé** (par défaut)&nbsp;: Stripe envoie un microversement de 0,01&nbsp;USD sur le compte bancaire du client avec un `descriptor_code` unique à 6&nbsp;chiffres qui commence par SM. Votre client utilise ce code pour vérifier son compte bancaire.
- **Montant**&nbsp;: Stripe envoie deux microversements distincts sur le compte bancaire du client avec un code de libellé indiquant `ACCTVERIFY`. Votre client utilise les montants de ces versements pour vérifier son compte bancaire.

**Échec de la vérification par microversements**Lorsqu’un compte bancaire est en attente de vérification par microversements, la vérification pour plusieurs raisons&nbsp;:

- Les microversements ne sont pas parvenus au compte bancaire du client (en général, ce problème signifie que le compte bancaire est clôturé ou non disponible, ou que le numéro du compte bancaire est incorrect).
- Le client dépasse la limite de tentatives de vérification pour le compte. Le dépassement de cette limite signifie que le compte bancaire ne peut plus être vérifié ou utilisé.
- Le client n’a pas effectué la vérification sous 10&nbsp;jours.

#### Instantané

Vous pouvez obliger tous vos clients à vérifier leurs comptes bancaires avec Financial Connections en utilisant la vérification instantanée.

Pour utiliser la vérification instantanée, définissez le paramètre `payment_method_options[us_bank_account][verification_method]` sur `instant` lorsque vous créez une session Checkout.

#### Accounts&nbsp;v2

```curl
curl https://api.stripe.com/v1/checkout/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "customer_account={{CUSTOMERACCOUNT_ID}}" \
  -d "line_items[0][price_data][currency]=usd" \
  -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 ui_mode=elements \
  -d "payment_method_options[us_bank_account][verification_method]=instant" \
  -d "payment_method_options[us_bank_account][financial_connections][permissions][0]=payment_method" \
  --data-urlencode "return_url=https://example.com/return?session_id={CHECKOUT_SESSION_ID}"
```

#### Customers&nbsp;v1

```curl
curl https://api.stripe.com/v1/checkout/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "customer={{CUSTOMER_ID}}" \
  -d "line_items[0][price_data][currency]=usd" \
  -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 ui_mode=elements \
  -d "payment_method_options[us_bank_account][verification_method]=instant" \
  -d "payment_method_options[us_bank_account][financial_connections][permissions][0]=payment_method" \
  --data-urlencode "return_url=https://example.com/return?session_id={CHECKOUT_SESSION_ID}"
```

Côté client, l’Element Payment créé par `checkout.createPaymentElement()` utilise automatiquement la méthode de vérification configurée dans le Checkout Session. Aucune configuration supplémentaire n’est nécessaire.

#### Item 2

Pour en savoir plus sur les frais de Financial Connections, consultez les [Tarifs](https://stripe.com/financial-connections#pricing).

La vérification du compte bancaire utilise par défaut la vérification automatique pour collecter les informations de paiement via [Financial Connections](https://docs.stripe.com/financial-connections.md). Aucune modification n’est nécessaire pour l’utiliser. Vous pouvez modifier votre méthode de vérification en définissant `payment_method_options[us_bank_account][verification_method]` lors de la création de Checkout Session sur `instant` pour que tous les utilisateurs vérifient leurs comptes bancaires avec Financial Connections. Pour apprendre à configurer Financial Connections et accéder à des données supplémentaires du compte, comme vérifier le solde d’un compte avant d’initier un paiement, consultez la documentation [Financial Connections](https://docs.stripe.com/financial-connections.md).

#### Automatique (par défaut)

Par défaut, lors de la collecte des coordonnées bancaires, [Financial Connections](https://docs.stripe.com/financial-connections.md) vérifie instantanément le compte de votre client. Si la vérification instantanée n’est pas possible, la saisie manuelle du numéro de compte et la vérification par microversements sont utilisées.

> Pour accéder à des données supplémentaires après qu’un client a authentifié son compte, celui-ci doit associer de nouveau son compte avec des autorisations étendues. Cette authentification a lieu une fois par client, et l’autorisation qu’elle accorde est réutilisable.

**Vérification par microversements**Tous les clients ne peuvent pas vérifier leur compte bancaire instantanément. Cette section ne s’applique que si votre client a choisi de se désinscrire du flux de vérification instantanée à l’étape précédente. Dans ce cas, Stripe envoie plutôt 1 à 2&nbsp;microversements sur le compte bancaire d’un client pour vérification. Ces dépôts prennent 1 à 2&nbsp;jours ouvrables pour apparaître sur le relevé en ligne du client.

Il existe deux types de microversements&nbsp;:

- **Code de libellé** (par défaut)&nbsp;: Stripe envoie un microversement de 0,01&nbsp;USD sur le compte bancaire du client avec un `descriptor_code` unique à 6&nbsp;chiffres qui commence par SM. Votre client utilise ce code pour vérifier son compte bancaire.
- **Montant**&nbsp;: Stripe envoie deux microversements distincts sur le compte bancaire du client avec un code de libellé indiquant `ACCTVERIFY`. Votre client utilise les montants de ces versements pour vérifier son compte bancaire.

**Échec de la vérification par microversements**Lorsqu’un compte bancaire est en attente de vérification par microversements, la vérification pour plusieurs raisons&nbsp;:

- Les microversements ne sont pas parvenus au compte bancaire du client (en général, ce problème signifie que le compte bancaire est clôturé ou non disponible, ou que le numéro du compte bancaire est incorrect).
- Le client dépasse la limite de tentatives de vérification pour le compte. Le dépassement de cette limite signifie que le compte bancaire ne peut plus être vérifié ou utilisé.
- Le client n’a pas effectué la vérification sous 10&nbsp;jours.

#### Instantané

Vous pouvez obliger tous vos clients à vérifier leurs comptes bancaires avec Financial Connections en utilisant la vérification instantanée.

Pour utiliser la vérification instantanée, définissez le paramètre `payment_method_options[us_bank_account][verification_method]` sur `instant` lorsque vous créez une session Checkout.

#### Accounts&nbsp;v2

```curl
curl https://api.stripe.com/v1/checkout/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "customer_account={{CUSTOMERACCOUNT_ID}}" \
  -d "line_items[0][price_data][currency]=usd" \
  -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 ui_mode=elements \
  -d "payment_method_types[0]=card" \
  -d "payment_method_types[1]=us_bank_account" \
  -d "payment_method_options[us_bank_account][verification_method]=instant" \
  -d "payment_method_options[us_bank_account][financial_connections][permissions][0]=payment_method" \
  --data-urlencode "return_url=https://example.com/return?session_id={CHECKOUT_SESSION_ID}"
```

#### Customers&nbsp;v1

```curl
curl https://api.stripe.com/v1/checkout/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "customer={{CUSTOMER_ID}}" \
  -d "line_items[0][price_data][currency]=usd" \
  -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 ui_mode=elements \
  -d "payment_method_types[0]=card" \
  -d "payment_method_types[1]=us_bank_account" \
  -d "payment_method_options[us_bank_account][verification_method]=instant" \
  -d "payment_method_options[us_bank_account][financial_connections][permissions][0]=payment_method" \
  --data-urlencode "return_url=https://example.com/return?session_id={CHECKOUT_SESSION_ID}"
```

Côté client, l’Element Payment créé par `checkout.createPaymentElement()` utilise automatiquement la méthode de vérification configurée dans le Checkout Session. Aucune configuration supplémentaire n’est nécessaire.

## Soumettez le paiement [Côté client]

#### HTML + JS

Affichez un bouton **Payer** qui appelle [confirm](https://docs.stripe.com/js/custom_checkout/confirm) depuis l’instance `Checkout` pour soumettre le paiement.

```html
<button id="pay-button">Pay</button>
<div id="confirm-errors"></div>
```

```js
const checkout = stripe.initCheckoutElementsSdk({clientSecret});

checkout.on('change', (session) => {
  document.getElementById('pay-button').disabled = !session.canConfirm;
});

const loadActionsResult = await checkout.loadActions();

if (loadActionsResult.type === 'success') {
  const {actions} = loadActionsResult;
  const button = document.getElementById('pay-button');
  const errors = document.getElementById('confirm-errors');
  button.addEventListener('click', () => {
    // Clear any validation errors
    errors.textContent = '';

    actions.confirm().then((result) => {
      if (result.type === 'error') {
        errors.textContent = result.error.message;
      }
    });
  });
}
```

#### React

Affichez un bouton **Payer** qui appelle [confirm](https://docs.stripe.com/js/custom_checkout/confirm) depuis [useCheckout](https://docs.stripe.com/js/react_stripe_js/checkout/use_checkout) pour soumettre le paiement.

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

const PayButton = () => {
  const checkoutState = useCheckout();
  const [loading, setLoading] = React.useState(false);
  const [error, setError] = React.useState(null);

  if (checkoutState.type !== "success") {
    return null;
  }

  const handleClick = () => {
    setLoading(true);checkoutState.checkout.confirm().then((result) => {
      if (result.type === 'error') {
        setError(result.error)
      }
      setLoading(false);
    })
  };

  return (
    <div>
      <button disabled={!checkoutState.checkout.canConfirm || loading} onClick={handleClick}>
        Pay
      </button>
      {error && <div>{error.message}</div>}
    </div>
  )
};

export default PayButton;
```

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

Stripe envoie un événement [checkout.session.async_payment_succeeded](https://docs.stripe.com/api/events/types.md#event_types-checkout.session.async_payment_succeeded) lorsque le paiement est terminé. Utilisez le Dashboard, un {&nbsp;% glossary term="webhook&nbsp;» %}webhook{&nbsp;% /glossary %} personnalisé, ou une solution partenaire pour recevoir ces événements et exécuter des actions, telles que l’envoi d’un e-mail de confirmation de commande à votre client, l’enregistrement de la vente dans une base de données ou le démarrage d’un flux de travail d’expédition.

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

  [Créez un gestionnaire de webhooks personnalisé](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook) pour écouter les événements et concevoir des flux de paiement asynchrones sur mesure. Testez et déboguez votre intégration de webhooks en local avec la 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.

## Tester votre intégration

Découvrez comment tester des scénarios avec des vérifications instantanées à l’aide de [Financial Connections](https://docs.stripe.com/financial-connections/testing.md#web-how-to-use-test-accounts).

### Envoyer des e-mails de transaction dans un environnement de test

Une fois que vous avez collecté les coordonnées bancaires et accepté un mandat, envoyez les courriels de confirmation du mandat et de vérification du microversement dans un *environnement de bac à sable* (A sandbox is an isolated test environment that allows you to test Stripe functionality in your account without affecting your live integration. Use sandboxes to safely experiment with new features and changes).

Si votre domaine est **{domain}** et votre nom d’utilisateur est **{username}**, utilisez le format d’adresse e-mail suivant pour envoyer des e-mails de transaction de test&nbsp;: **{username}+test\_email@{domain}**.

Par exemple, si votre domaine est **example.com** et que votre nom d’utilisateur est **info**, utilisez le format **info+test\_email@example.com** pour tester les paiements ACH Direct Debit. Ce format garantit que les e-mails sont acheminés correctement. Si vous n’incluez pas le suffixe **+test\_email**, nous n’enverrons pas l’e-mail.

> Vous devez [configurer votre compte Stripe](https://docs.stripe.com/get-started/account/set-up.md) avant de pouvoir déclencher ces e-mails pendant les tests.

### Numéros de comptes de test

Stripe fournit plusieurs numéros de compte de test et les tokens correspondants que vous pouvez utiliser pour vous assurer que votre intégration pour les comptes bancaires saisis manuellement est prête à passer en mode production.

| Numéro de compte | Token                                  | Numéro de routage | Comportement                                                                                                                                                                                                                                                                                                         |
| ---------------- | -------------------------------------- | ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `000123456789`   | `pm_usBankAccount_success`             | `110000000`       | Le paiement aboutit.                                                                                                                                                                                                                                                                                                 |
| `000111111113`   | `pm_usBankAccount_accountClosed`       | `110000000`       | Le paiement échoue parce que le compte est clôturé.                                                                                                                                                                                                                                                                  |
| `000000004954`   | `pm_usBankAccount_riskLevelHighest`    | `110000000`       | Le paiement est bloqué par Radar en raison d’un [risque élevé de fraude](https://docs.stripe.com/radar/risk-evaluation.md#high-risk).                                                                                                                                                                                |
| `000111111116`   | `pm_usBankAccount_noAccount`           | `110000000`       | Le paiement échoue car aucun compte n’est trouvé.                                                                                                                                                                                                                                                                    |
| `000222222227`   | `pm_usBankAccount_insufficientFunds`   | `110000000`       | Le paiement échoue en raison de fonds insuffisants.                                                                                                                                                                                                                                                                  |
| `000333333335`   | `pm_usBankAccount_debitNotAuthorized`  | `110000000`       | Le paiement échoue parce que les débits ne sont pas autorisés.                                                                                                                                                                                                                                                       |
| `000444444440`   | `pm_usBankAccount_invalidCurrency`     | `110000000`       | Le paiement échoue en raison d’une devise non valide.                                                                                                                                                                                                                                                                |
| `000666666661`   | `pm_usBankAccount_failMicrodeposits`   | `110000000`       | Le paiement ne parvient pas à envoyer les microversements.                                                                                                                                                                                                                                                           |
| `000555555559`   | `pm_usBankAccount_dispute`             | `110000000`       | Le paiement déclenche un litige.                                                                                                                                                                                                                                                                                     |
| `000000000009`   | `pm_usBankAccount_processing`          | `110000000`       | Le traitement du paiement est indéfini. Utile pour tester {&nbsp;% si $checkoutSessions %}[Expiration de la session de paiement](https://docs.stripe.com/api/checkout/sessions/expire.md){&nbsp;% else /&nbsp;%}[Annulation de PaymentIntent](https://docs.stripe.com/api/payment_intents/cancel.md){&nbsp;% /if %}. |
| `000777777771`   | `pm_usBankAccount_weeklyLimitExceeded` | `110000000`       | Le paiement échoue, car son montant entraîne un dépassement de la limite hebdomadaire de volume de paiement du compte.                                                                                                                                                                                               |
| `000888888885`   |                                        | `110000000`       | Le paiement échoue en raison d’un [numéro de compte tokenisé](https://docs.stripe.com/financial-connections/tokenized-account-numbers.md) désactivé.                                                                                                                                                                 |

Avant d’effectuer les transactions de test, vous devez vérifier tous les comptes de test pour lesquels le paiement aboutit ou échoue automatiquement. Pour ce faire, utilisez les codes de libellé ou les montants de microversements de test ci-dessous.

### Tester des codes de libellé et des montants de microversements

Pour simuler différents scénarios, utilisez ces montants de microversements *ou* ces codes de libellé 0.01.

| Valeurs de microversement | Valeurs de code de libellé 0.01 | Scénario                                                                |
| ------------------------- | ------------------------------- | ----------------------------------------------------------------------- |
| `32` et `45`              | SM11AA                          | Simule la vérification du compte.                                       |
| `10` et `11`              | SM33CC                          | Simule le dépassement du nombre de tentatives de vérification autorisé. |
| `40` et `41`              | SM44DD                          | Simule l’expiration du délai de validité d’un microversement.           |

### Comportement de règlement des tests

Les transactions de test sont réglées instantanément et ajoutées à votre solde de test disponible. Ce comportement diffère de celui du mode production, où les transactions peuvent prendre [plusieurs jours](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#timing) pour être réglées dans votre solde disponible.

## Optional: Accéder aux données d'un compte bancaire Financial Connections

Vous ne pouvez accéder aux données Financial Connections que si vous demandez des [autorisations](https://docs.stripe.com/financial-connections/fundamentals.md#data-permissions) d’accès supplémentaires lors de la création de votre PaymentIntent .

Une fois que votre client a terminé le tunnel de paiement, l’objet PaymentMethod `us_bank_account` renvoyé inclut un ID de [financial_connections_account](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-us_bank_account-financial_connections_account) correspondant à un [compte Financial Connections](https://docs.stripe.com/api/financial_connections/accounts.md). Utilisez cet ID pour accéder aux données du compte.

> Les comptes bancaires que vos clients associent par saisie manuelle ou par le biais de microversements n’ont pas d’ID `financial_connections_account` au niveau du moyen de paiement.

Pour déterminer l’ID du compte Financial Connections, récupérez la session Checkout et développez l’attribut `payment_intent.payment_method`&nbsp;:

```curl
curl -G https://api.stripe.com/v1/checkout/sessions/{{CHECKOUTSESSION_ID}} \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "expand[]=payment_intent.payment_method"
```

```json
{
  "id": "{{CHECKOUT_SESSION_ID}}",
  "object": "checkout.session",
  // ...
  "payment_intent": {
    "id": "{{PAYMENT_INTENT_ID}}",
    "object": "payment_intent",
    // ...
    "payment_method": {
      "id": "{{PAYMENT_METHOD_ID}}",
      // ...
      "type": "us_bank_account",
      "us_bank_account": {
        "account_holder_type": "individual",
        "account_type": "checking",
        "bank_name": "TEST BANK","financial_connections_account": "{{FINANCIAL_CONNECTIONS_ACCOUNT_ID}}",
        "fingerprint": "q9qchffggRjlX2tb",
        "last4": "6789",
        "routing_number": "110000000"
      }
    }
    // ...
  }
}
```

Découvrez comment utiliser des données de compte supplémentaires pour optimiser votre intégration ACH avec [Financial Connections](https://docs.stripe.com/financial-connections/ach-direct-debit-payments.md#optimize).

## Optional: Résoudre les litiges [Côté serveur]

En règle générale, les clients peuvent [contester un paiement ACH Direct Debit](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#resolving-disputes) auprès de leur banque sous 60&nbsp;jours calendaires après un prélèvement sur un compte personnel, ou sous 2&nbsp;jours ouvrables pour un compte professionnel. Dans de rares cas, le client peut contester un paiement par prélèvement en dehors de ces délais de litige standard.

Lorsqu’un client conteste un paiement, Stripe envoie un événement webhook [charge.dispute.closed](https://docs.stripe.com/api/events/types.md#event_types-charge.dispute.closed), et l’autorisation du PaymentMethod est révoquée.

Il peut parfois arriver que Stripe reçoive un échec de paiement ACH de la banque alors que le PaymentIntent est déjà passé à l’état `succeeded`. Quand cela se produit, Stripe créée un litige dont le paramètre `reason` (motif) peut être&nbsp;:

- `insufficient_funds`
- `incorrect_account_details`
- `bank_can't_process`

Dans ce cas de figure, Stripe prélève des frais d’échec de paiement.

Les futurs paiements qui réutilisent ce PaymentMethod renvoient l’erreur suivante&nbsp;:

```javascript
{
  "error": {
    "message": "This PaymentIntent requires a mandate, but no existing mandate was found. Collect mandate acceptance from the customer and try again, providing acceptance data in the mandate_data parameter.",
    "payment_intent": {
      ...
    }
    "type": "invalid_request_error"
  }
}
```

Cette erreur comporte un PaymentIntent à l’état `requires_confirmation`. Pour que le paiement aboutisse, vous devez&nbsp;:

1. Résolvez le litige avec le client afin d’éviter toute contestation lors de futurs paiements.
1. Confirmez de nouveau l’autorisation de votre client.

Pour confirmer l’autorisation de paiement, vous pouvez [collecter la confirmation du mandat de votre client en ligne avec Stripe.js](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md?platform=web#web-collect-mandate-and-submit) ou confirmer l’autorisation avec votre client hors ligne à l’aide de l’API Stripe.

> Si un client conteste plusieurs paiements issus du même compte bancaire, Stripe bloque son compte. Contactez le [service Support de Stripe](https://support.stripe.com/?contact=true) pour obtenir une solution.

```curl
curl https://api.stripe.com/v1/payment_intents/{{PAYMENT_INTENT_ID}}/confirm \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "mandate_data[customer_acceptance][type]=offline"
```

## Optional: Référence du paiement

Le numéro de référence du paiement est une valeur générée par la banque qui permet au titulaire du compte bancaire d’utiliser sa banque pour localiser des fonds. Lorsque le paiement aboutit, Stripe fournit le numéro de référence du paiement dans le Dashboard, ainsi que dans l’[objet Charge](https://docs.stripe.com/api/charges/object.md).

| État du paiement | Valeur de référence du paiement           |
| ---------------- | ----------------------------------------- |
| En attente       | Indisponibles                             |
| En échec         | Indisponibles                             |
| Réussi           | Disponible (par exemple, 091000015001234) |

De plus, lorsque vous recevez le webhook `charge.succeeded`, consultez le contenu de `payment_method_details` pour localiser la [payment_reference](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-us_bank_account-payment_reference).

L’exemple d’événement suivant montre le rendu d’un paiement ACH abouti avec un numéro de référence de paiement.

#### charge-succeeded

```json
{
  "id": "{{EVENT_ID}}",
  "object": "event",
  // omitted some fields in the example
  "type": "charge.succeeded",
  "data": {
    "object": {
      "id": "{{PAYMENT_ID}}",
      "object": "charge",
      //...
    "paid": true,
    "payment_intent": "{{PAYMENT_INTENT_ID}}",
    "payment_method": "{{PAYMENT_METHOD_ID}}",
    "payment_method_details": {
      "type": "us_bank_account",
      "us_bank_account": {
        "account_holder_type": "individual",
        "account_type": "checking",
        "bank_name": "TEST BANK",
        "fingerprint": "Ih3foEnRvLXShyfB",
        "last4": "1000","payment_reference": "091000015001234",
        "routing_number": "110000000"
        }
      }
      // ...
    }
  }
}
```

Consultez le contenu de `destination_details` pour localiser la [référence du remboursement](https://docs.stripe.com/api/refunds/object.md#refund_object-destination_details-us_bank_transfer-reference) associée aux paiements ACH remboursés.

L’exemple d’événement suivant montre le rendu d’un remboursement de paiement ACH abouti avec un numéro de référence de remboursement. En savoir plus sur les [remboursements](https://docs.stripe.com/refunds.md).

#### charge-refund-updated

```json
{
  "id": "{{EVENT_ID}}",
  "object": "event",
  "type": "charge.refund.updated",
  "data": {
    "object": {
      "id": "{{REFUND_ID}}",
      "object": "refund",
      //...
    "payment_intent": "{{PAYMENT_INTENT_ID}}",
    "destination_details": {
      "type": "us_bank_transfer",
      "us_bank_transfer": {"reference": "091000015001111",
        "reference_status": "available"
        }
      }
      // ...
    }
  }
}
```

## Optional: Configurer la date de prélèvement du client [Côté serveur]

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

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

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

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

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

> Vous ne pouvez pas définir le [verification method](https://docs.stripe.com/api/checkout/sessions/object.md#checkout_session_object-payment_method_options-us_bank_account-verification_method) to `microdeposits` lors de l’utilisation d’un [target date](https://docs.stripe.com/api/checkout/sessions/object.md#checkout_session_object-payment_method_options-us_bank_account-target_date), car le processus de vérification pourrait prendre plus de temps que prévu, ce qui entraînerait des retards dans les paiements.


# API Payment Intents

> This is a API Payment Intents for when payment-ui is elements and api-integration is paymentintents. View the full page at https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment?payment-ui=elements&api-integration=paymentintents.

Pour déterminer quelle API répond aux besoins de votre entreprise, consultez la section[guide de comparaison](https://docs.stripe.com/payments/checkout-sessions-and-payment-intents-comparison.md).

Utilisez le [Payment Element](https://docs.stripe.com/payments/payment-element.md) pour intégrer un formulaire de paiement Stripe personnalisé sur votre site Web ou application et proposer des moyens de paiement à vos clients. Pour les configurations et personnalisations avancées, consultez le guide d’intégration [Accepter un Paiement](https://docs.stripe.com/payments/accept-a-payment.md).

Avant d’utiliser le prélèvement automatique ACH dans votre intégration Payment Element, renseignez-vous sur les points suivants spécifiques au prélèvement automatique ACH&nbsp;:

- En savoir plus sur la [collecte des mandats](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#mandate-collection).
- Choisissez le mode de [vérification des comptes bancaires](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#bank-verification).

### Collecte des mandats

Lorsque vous acceptez des paiements ACH, vous devez comprendre les mandats.

À moins que vous n’utilisiez une intégration API directe, Stripe gère la collecte et le stockage des mandats pour votre entreprise afin de garantir le respect des exigences réglementaires. Lorsqu’un client accepte le mandat au cours du processus de paiement, Stripe stocke automatiquement ces informations et vous pouvez y accéder à partir de votre Dashboard.

## Configurer Stripe [Côté serveur]

Pour commencer, [créez un compte Stripe](https://dashboard.stripe.com/register).

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

#### Ruby

```bash
# Available as a gem
sudo gem install stripe
```

```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```

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

Utilisez Payment Element pour recueillir les informations de paiement du client. Payment Element est un composant d’interface utilisateur préconfiguré qui simplifie la collecte des informations de paiement pour différents moyens de paiement.

Le Payment Element contient un iframe qui envoie les informations de paiement à Stripe de manière sécurisée via une connexion HTTPS. Évitez de placer le Payment Element dans un autre iframe, car certains moyens de paiement nécessitent une redirection vers une autre page pour la confirmation du paiement.

Pour que votre intégration fonctionne, l’adresse de la page de paiement doit commencer par `https://` et non par `http://`. Vous pouvez tester votre intégration sans utiliser le protocole HTTPS, mais n’oubliez pas de l’[activer](https://docs.stripe.com/security/guide.md#tls) lorsque vous souhaitez commencer à accepter des paiements réels.

#### HTML + JS

### Configurer Stripe.js

Payment Element est automatiquement disponible en tant que fonctionnalité de Stripe.js. Intégrez le script Stripe.js à votre page de paiement en l’ajoutant 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 un lot 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 composant Payment&nbsp;Element à votre page de paiement

Pour ajouter le Payment Element à votre page de paiement, créez un nœud DOM (conteneur) vide avec un identifiant 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>
```

Vous pouvez gérer les moyens de paiement à partir du Dashboard ou répertorier manuellement les moyens de paiement que vous souhaitez rendre disponibles lorsque vous créez le [Payment Element](https://docs.stripe.com/js/elements_object/create_without_intent).

#### Gérer les moyens de paiement dans le Dashboard

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

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

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

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

Pour répertorier manuellement les moyens de paiement disponibles, ajoutez chacun d’entre eux à l’attribut `PaymentMethodTypes` dans `options` lorsque vous créez le [Payment Element](https://docs.stripe.com/js/elements_object/create_without_intent).

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

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

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

#### React

### Configurer Stripe.js

Installez React Stripe.js et le chargeur Stripe.js à partir du [registre npm public](https://www.npmjs.com/package/@stripe/react-stripe-js).

```bash
npm install --save @stripe/react-stripe-js @stripe/stripe-js
```

### Ajouter et configurer le fournisseur Elements sur votre page de paiement

Pour utiliser le composant Payment 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é publiable et transmettez le `Promise` renvoyé au fournisseur `Elements`.

Vous pouvez gérer les moyens de paiement à partir du Dashboard ou répertorier manuellement les moyens de paiement que vous souhaitez rendre disponibles lorsque vous créez le [Payment Element](https://docs.stripe.com/js/elements_object/create_without_intent).

#### Gérer les moyens de paiement dans le Dashboard

```jsx
import React from 'react';
import ReactDOM from 'react-dom';
import {Elements} from '@stripe/react-stripe-js';
import {loadStripe} from '@stripe/stripe-js';

import CheckoutForm from './CheckoutForm';

// Make sure to call `loadStripe` outside of a component’s render to avoid
// recreating the `Stripe` object on every render.
const stripePromise = loadStripe('<<YOUR_PUBLISHABLE_KEY>>');

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

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

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

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

Pour répertorier manuellement les moyens de paiement disponibles, ajoutez chacun d’entre eux à l’attribut `payment_method_types` lorsque vous créez le [Payment Element](https://docs.stripe.com/js/elements_object/create_without_intent).

```jsx
import React from 'react';
import ReactDOM from 'react-dom';
import {Elements} from '@stripe/react-stripe-js';
import {loadStripe} from '@stripe/stripe-js';

import CheckoutForm from './CheckoutForm';

// Make sure to call `loadStripe` outside of a component’s render to avoid
// recreating the `Stripe` object on every render.
const stripePromise = loadStripe('<<YOUR_PUBLISHABLE_KEY>>');

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

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

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

### Ajouter le composant Payment Element

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

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

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

export default CheckoutForm;
```

Vous pouvez personnaliser le Payment&nbsp;Element pour l’adapter au design de votre site en transmettant l’[objet Appearance](https://docs.stripe.com/elements/appearance-api.md) dans `options` lors de la création du fournisseur `Elements`.

### Collecter les adresses

Par défaut, le Payment Element ne collecte que les informations nécessaires à la facturation. Certaines opérations, telles que le [calcul des taxes](https://docs.stripe.com/api/tax/calculations/create.md) ou la saisie des informations de livraison, nécessitent l’adresse complète de votre client. Vous pouvez&nbsp;:

- Utilisez l’[Address Element](https://docs.stripe.com/elements/address-element.md) pour tirer parti des fonctionnalités de saisie automatique et de localisation et recueillir l’adresse complète de votre client. Cela permet de garantir un calcul des taxes le plus précis possible.
- Recueillez l’adresse à l’aide de votre propre formulaire personnalisé.

## Vérifier les comptes bancaires

#### Item 1

Pour en savoir plus sur les frais de Financial Connections, consultez les [Tarifs](https://stripe.com/financial-connections#pricing).

La vérification du compte bancaire utilise par défaut la vérification automatique pour recueillir les informations de paiement via [Financial Connections](https://docs.stripe.com/financial-connections.md). Aucune modification n’est nécessaire pour l’utiliser. Vous pouvez modifier votre [verification_method](https://docs.stripe.com/js/elements_object/create_without_intent#stripe_elements_no_intent-options-paymentMethodOptions-us_bank_account-verification_method) sur `instantané` pour que tous les utilisateurs vérifient leurs comptes bancaires avec Financial Connections. Pour savoir comment configurer Financial Connections et accéder à des données de compte supplémentaires, comme vérifier le solde d’un compte avant d’initier un paiement, consultez la documentation [Financial Connections](https://docs.stripe.com/financial-connections.md).

#### Automatique (par défaut)

Par défaut, lors de la collecte des coordonnées bancaires, [Financial Connections](https://docs.stripe.com/financial-connections.md) vérifie instantanément le compte de votre client. Si la vérification instantanée n’est pas possible, la saisie manuelle du numéro de compte et la vérification par microversements sont utilisées.

> Pour accéder à des données supplémentaires après qu’un client a authentifié son compte, celui-ci doit associer de nouveau son compte avec des autorisations étendues. Cette authentification a lieu une fois par client, et l’autorisation qu’elle accorde est réutilisable.

**Vérification par microversements**Tous les clients ne peuvent pas vérifier leur compte bancaire instantanément. Cette section ne s’applique que si votre client a choisi de se désinscrire du flux de vérification instantanée à l’étape précédente. Dans ce cas, Stripe envoie plutôt 1 à 2&nbsp;microversements sur le compte bancaire d’un client pour vérification. Ces dépôts prennent 1 à 2&nbsp;jours ouvrables pour apparaître sur le relevé en ligne du client.

Il existe deux types de microversements&nbsp;:

- **Code de libellé** (par défaut)&nbsp;: Stripe envoie un microversement de 0,01&nbsp;USD sur le compte bancaire du client avec un `descriptor_code` unique à 6&nbsp;chiffres qui commence par SM. Votre client utilise ce code pour vérifier son compte bancaire.
- **Montant**&nbsp;: Stripe envoie deux microversements distincts sur le compte bancaire du client avec un code de libellé indiquant `ACCTVERIFY`. Votre client utilise les montants de ces versements pour vérifier son compte bancaire.

**Échec de la vérification par microversements**Lorsqu’un compte bancaire est en attente de vérification par microversements, la vérification pour plusieurs raisons&nbsp;:

- Les microversements ne sont pas parvenus au compte bancaire du client (en général, ce problème signifie que le compte bancaire est clôturé ou non disponible, ou que le numéro du compte bancaire est incorrect).
- Le client dépasse la limite de tentatives de vérification pour le compte. Le dépassement de cette limite signifie que le compte bancaire ne peut plus être vérifié ou utilisé.
- Le client n’a pas effectué la vérification sous 10&nbsp;jours.

#### Vérification instantanée

Vous pouvez obliger tous vos clients à vérifier leurs comptes bancaires avec Financial Connections en utilisant la vérification instantanée.

Pour utiliser la vérification instantanée, définissez le paramètre [verification_method](https://docs.stripe.com/js/elements_object/create_without_intent#stripe_elements_no_intent-options-paymentMethodOptions-us_bank_account-verification_method) sur `instantané` lorsque vous créez un [Element Payment](https://docs.stripe.com/js/elements_object/create_without_intent).

#### HTML + JS

```js
const options = {
  mode: 'payment',
  amount: 1099,
  currency: 'usd',paymentMethodOptions: {
    us_bank_account: {
      verification_method: "instant"
    }
  }
  appearance: {/*...*/},
};

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

// Create and mount the Payment Element
const paymentElement = elements.create('payment');
paymentElement.mount('#payment-element');
```

#### React

```jsx
import React from 'react';
import ReactDOM from 'react-dom';
import {Elements} from '@stripe/react-stripe-js';
import {loadStripe} from '@stripe/stripe-js';

import CheckoutForm from './CheckoutForm';

// Make sure to call `loadStripe` outside of a component’s render to avoid
// recreating the `Stripe` object on every render.
const stripePromise = loadStripe('<<YOUR_PUBLISHABLE_KEY>>');

function App() {
  const options = {
    mode: 'payment',
    amount: 1099,
    currency: 'usd',paymentMethodOptions: {
      us_bank_account: {
        verification_method: "instant"
      }
    }
    // Fully customizable with appearance API.
    appearance: {/*...*/},
  };

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

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

### Ajouter le composant Payment Element

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

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

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

export default CheckoutForm;
```

#### Item 2

Pour en savoir plus sur les frais de Financial Connections, consultez les [Tarifs](https://stripe.com/financial-connections#pricing).

La vérification du compte bancaire utilise par défaut la vérification automatique pour recueillir les informations de paiement via [Financial Connections](https://docs.stripe.com/financial-connections.md). Aucune modification n’est nécessaire pour l’utiliser. Vous pouvez modifier votre [verification_method](https://docs.stripe.com/js/elements_object/create_without_intent#stripe_elements_no_intent-options-paymentMethodOptions-us_bank_account-verification_method) sur `instantané` pour que tous les utilisateurs vérifient leurs comptes bancaires avec Financial Connections. Pour savoir comment configurer Financial Connections et accéder à des données de compte supplémentaires, comme vérifier le solde d’un compte avant d’initier un paiement, consultez la documentation [Financial Connections](https://docs.stripe.com/financial-connections.md).

#### Automatique (par défaut)

Par défaut, lors de la collecte des coordonnées bancaires, [Financial Connections](https://docs.stripe.com/financial-connections.md) vérifie instantanément le compte de votre client. Si la vérification instantanée n’est pas possible, la saisie manuelle du numéro de compte et la vérification par microversements sont utilisées.

> Pour accéder à des données supplémentaires après qu’un client a authentifié son compte, celui-ci doit associer de nouveau son compte avec des autorisations étendues. Cette authentification a lieu une fois par client, et l’autorisation qu’elle accorde est réutilisable.

**Vérification par microversements**Tous les clients ne peuvent pas vérifier leur compte bancaire instantanément. Cette section ne s’applique que si votre client a choisi de se désinscrire du flux de vérification instantanée à l’étape précédente. Dans ce cas, Stripe envoie plutôt 1 à 2&nbsp;microversements sur le compte bancaire d’un client pour vérification. Ces dépôts prennent 1 à 2&nbsp;jours ouvrables pour apparaître sur le relevé en ligne du client.

Il existe deux types de microversements&nbsp;:

- **Code de libellé** (par défaut)&nbsp;: Stripe envoie un microversement de 0,01&nbsp;USD sur le compte bancaire du client avec un `descriptor_code` unique à 6&nbsp;chiffres qui commence par SM. Votre client utilise ce code pour vérifier son compte bancaire.
- **Montant**&nbsp;: Stripe envoie deux microversements distincts sur le compte bancaire du client avec un code de libellé indiquant `ACCTVERIFY`. Votre client utilise les montants de ces versements pour vérifier son compte bancaire.

**Échec de la vérification par microversements**Lorsqu’un compte bancaire est en attente de vérification par microversements, la vérification pour plusieurs raisons&nbsp;:

- Les microversements ne sont pas parvenus au compte bancaire du client (en général, ce problème signifie que le compte bancaire est clôturé ou non disponible, ou que le numéro du compte bancaire est incorrect).
- Le client dépasse la limite de tentatives de vérification pour le compte. Le dépassement de cette limite signifie que le compte bancaire ne peut plus être vérifié ou utilisé.
- Le client n’a pas effectué la vérification sous 10&nbsp;jours.

#### Vérification instantanée

Vous pouvez obliger tous vos clients à vérifier leurs comptes bancaires avec Financial Connections en utilisant la vérification instantanée.

Pour utiliser la vérification instantanée, définissez le paramètre [verification_method](https://docs.stripe.com/js/elements_object/create_without_intent#stripe_elements_no_intent-options-paymentMethodOptions-us_bank_account-verification_method) sur `instantané` lorsque vous créez un [Element Payment](https://docs.stripe.com/js/elements_object/create_without_intent).

#### HTML + JS

```js
const options = {
  mode: 'payment',
  amount: 1099,
  payment_method_types: ["card", "us_bank_account"],
  currency: 'usd',paymentMethodOptions: {
    us_bank_account: {
      verification_method: "instant"
    }
  }
  appearance: {/*...*/},
};

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

// Create and mount the Payment Element
const paymentElement = elements.create('payment');
paymentElement.mount('#payment-element');
```

#### React

```jsx
import React from 'react';
import ReactDOM from 'react-dom';
import {Elements} from '@stripe/react-stripe-js';
import {loadStripe} from '@stripe/stripe-js';

import CheckoutForm from './CheckoutForm';

// Make sure to call `loadStripe` outside of a component’s render to avoid
// recreating the `Stripe` object on every render.
const stripePromise = loadStripe('<<YOUR_PUBLISHABLE_KEY>>');

function App() {
  const options = {
    mode: 'payment',
    amount: 1099,
    currency: 'usd',
    payment_method_types: `us_bank_account`,paymentMethodOptions: {
      us_bank_account: {
        verification_method: "instant"
      }
    }
    // Fully customizable with appearance API.
    appearance: {/*...*/},
  };

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

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

### Ajouter le composant Payment Element

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

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

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

export default CheckoutForm;
```

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

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

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

Lorsque le client envoie votre formulaire de paiement, utilisez un *PaymentIntent* (The Payment Intents API tracks the lifecycle of a customer checkout flow and triggers additional authentication steps when required by regulatory mandates, custom Radar fraud rules, or redirect-based payment methods) pour faciliter le processus de confirmation et de paiement. Créez un PaymentIntent sur votre serveur avec les paramètres `amount` et `currency`. Pour éviter que des clients malveillants ne choisissent eux-mêmes leurs tarifs, fixez systématiquement le montant à débiter côté serveur (un environnement sécurisé) plutôt que côté client.

Un objet `PaymentIntent` contient une *clé secrète du client* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)). Renvoyez cette valeur côté client afin que Stripe.js l’utilise pour finaliser le processus de paiement en toute sécurité.

#### Accounts&nbsp;v2

#### Ruby

```ruby
require 'stripe'
# Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
client = Stripe::StripeClient.new('<<YOUR_SECRET_KEY>>')

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

#### Customers&nbsp;v1

#### Ruby

```ruby
require 'stripe'
# Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
client = Stripe::StripeClient.new('<<YOUR_SECRET_KEY>>')

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

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

Lorsque le client envoie votre formulaire de paiement, utilisez un *PaymentIntent* (The Payment Intents API tracks the lifecycle of a customer checkout flow and triggers additional authentication steps when required by regulatory mandates, custom Radar fraud rules, or redirect-based payment methods) pour faciliter le processus de confirmation et de paiement. Créez un PaymentIntent sur votre serveur avec un `amount`, une `currency` et un ou plusieurs moyens de paiement à l’aide de `payment_method_types`. Pour éviter que des clients malveillants ne puissent définir eux-mêmes leurs tarifs, fixez systématiquement le montant à débiter côté serveur (un environnement sécurisé) plutôt que côté client.

L’objet PaymentIntent contient une *clé secrète du client* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)). Renvoyez cette valeur côté client afin que Stripe.js l’utilise pour finaliser le processus de paiement en toute sécurité.

#### Ruby

```ruby
require 'stripe'
# Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
client = Stripe::StripeClient.new('<<YOUR_SECRET_KEY>>')

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

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

Utilisez [stripe.confirmPayment](https://docs.stripe.com/js/payment_intents/confirm_payment) pour finaliser le paiement à l’aide des informations du composant Payment&nbsp;Element.

Ajoutez un paramètre [return_url](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-return_url) à cette fonction pour indiquer à Stripe où rediriger l’utilisateur une fois le paiement effectué. Dans un premier temps, votre utilisateur sera peut-être redirigé vers un site intermédiaire, comme une page d’autorisation bancaire, avant d’être redirigé vers l’URL `return_url`. Une fois le paiement par carte abouti, l’utilisateur est immédiatement redirigé vers l’URL `return_url`.

Si vous ne souhaitez pas effectuer de redirection à la fin des paiements par carte, vous pouvez définir le paramètre [redirect](https://docs.stripe.com/js/payment_intents/confirm_payment#confirm_payment_intent-options-redirect) sur `if_required`. De cette manière, seuls les clients qui choisissent un moyen de paiement avec redirection seront redirigés.

#### HTML + JS

```javascript

const form = document.getElementById('payment-form');
const submitBtn = document.getElementById('submit');

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

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

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

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

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

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

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

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

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

```

#### React

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

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

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

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

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

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

    setLoading(true);

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

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

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

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

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

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

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

## Tester votre intégration

Découvrez comment tester des scénarios avec des vérifications instantanées à l’aide de [Financial Connections](https://docs.stripe.com/financial-connections/testing.md#web-how-to-use-test-accounts).

### Envoyer des e-mails de transaction dans un environnement de test

Une fois que vous avez collecté les coordonnées bancaires et accepté un mandat, envoyez les courriels de confirmation du mandat et de vérification du microversement dans un *environnement de bac à sable* (A sandbox is an isolated test environment that allows you to test Stripe functionality in your account without affecting your live integration. Use sandboxes to safely experiment with new features and changes).

Si votre domaine est **{domain}** et votre nom d’utilisateur est **{username}**, utilisez le format d’adresse e-mail suivant pour envoyer des e-mails de transaction de test&nbsp;: **{username}+test\_email@{domain}**.

Par exemple, si votre domaine est **example.com** et que votre nom d’utilisateur est **info**, utilisez le format **info+test\_email@example.com** pour tester les paiements ACH Direct Debit. Ce format garantit que les e-mails sont acheminés correctement. Si vous n’incluez pas le suffixe **+test\_email**, nous n’enverrons pas l’e-mail.

> Vous devez [configurer votre compte Stripe](https://docs.stripe.com/get-started/account/set-up.md) avant de pouvoir déclencher ces e-mails pendant les tests.

### Numéros de comptes de test

Stripe fournit plusieurs numéros de compte de test et les tokens correspondants que vous pouvez utiliser pour vous assurer que votre intégration pour les comptes bancaires saisis manuellement est prête à passer en mode production.

| Numéro de compte | Token                                  | Numéro de routage | Comportement                                                                                                                                                                                                                                                                                                         |
| ---------------- | -------------------------------------- | ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `000123456789`   | `pm_usBankAccount_success`             | `110000000`       | Le paiement aboutit.                                                                                                                                                                                                                                                                                                 |
| `000111111113`   | `pm_usBankAccount_accountClosed`       | `110000000`       | Le paiement échoue parce que le compte est clôturé.                                                                                                                                                                                                                                                                  |
| `000000004954`   | `pm_usBankAccount_riskLevelHighest`    | `110000000`       | Le paiement est bloqué par Radar en raison d’un [risque élevé de fraude](https://docs.stripe.com/radar/risk-evaluation.md#high-risk).                                                                                                                                                                                |
| `000111111116`   | `pm_usBankAccount_noAccount`           | `110000000`       | Le paiement échoue car aucun compte n’est trouvé.                                                                                                                                                                                                                                                                    |
| `000222222227`   | `pm_usBankAccount_insufficientFunds`   | `110000000`       | Le paiement échoue en raison de fonds insuffisants.                                                                                                                                                                                                                                                                  |
| `000333333335`   | `pm_usBankAccount_debitNotAuthorized`  | `110000000`       | Le paiement échoue parce que les débits ne sont pas autorisés.                                                                                                                                                                                                                                                       |
| `000444444440`   | `pm_usBankAccount_invalidCurrency`     | `110000000`       | Le paiement échoue en raison d’une devise non valide.                                                                                                                                                                                                                                                                |
| `000666666661`   | `pm_usBankAccount_failMicrodeposits`   | `110000000`       | Le paiement ne parvient pas à envoyer les microversements.                                                                                                                                                                                                                                                           |
| `000555555559`   | `pm_usBankAccount_dispute`             | `110000000`       | Le paiement déclenche un litige.                                                                                                                                                                                                                                                                                     |
| `000000000009`   | `pm_usBankAccount_processing`          | `110000000`       | Le traitement du paiement est indéfini. Utile pour tester {&nbsp;% si $checkoutSessions %}[Expiration de la session de paiement](https://docs.stripe.com/api/checkout/sessions/expire.md){&nbsp;% else /&nbsp;%}[Annulation de PaymentIntent](https://docs.stripe.com/api/payment_intents/cancel.md){&nbsp;% /if %}. |
| `000777777771`   | `pm_usBankAccount_weeklyLimitExceeded` | `110000000`       | Le paiement échoue, car son montant entraîne un dépassement de la limite hebdomadaire de volume de paiement du compte.                                                                                                                                                                                               |
| `000888888885`   |                                        | `110000000`       | Le paiement échoue en raison d’un [numéro de compte tokenisé](https://docs.stripe.com/financial-connections/tokenized-account-numbers.md) désactivé.                                                                                                                                                                 |

Avant d’effectuer les transactions de test, vous devez vérifier tous les comptes de test pour lesquels le paiement aboutit ou échoue automatiquement. Pour ce faire, utilisez les codes de libellé ou les montants de microversements de test ci-dessous.

### Tester des codes de libellé et des montants de microversements

Pour simuler différents scénarios, utilisez ces montants de microversements *ou* ces codes de libellé 0.01.

| Valeurs de microversement | Valeurs de code de libellé 0.01 | Scénario                                                                |
| ------------------------- | ------------------------------- | ----------------------------------------------------------------------- |
| `32` et `45`              | SM11AA                          | Simule la vérification du compte.                                       |
| `10` et `11`              | SM33CC                          | Simule le dépassement du nombre de tentatives de vérification autorisé. |
| `40` et `41`              | SM44DD                          | Simule l’expiration du délai de validité d’un microversement.           |

### Comportement de règlement des tests

Les transactions de test sont réglées instantanément et ajoutées à votre solde de test disponible. Ce comportement diffère de celui du mode production, où les transactions peuvent prendre [plusieurs jours](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#timing) pour être réglées dans votre solde disponible.

## Codes d’erreur

Le tableau suivant détaille les codes d’erreur courants et les actions recommandées&nbsp;:

| Code d’erreur                                             | Action recommandée                                                                                                                                                                                                                                                                                                                                                                                                                |
| --------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `payment_intent_invalid_currency`                         | Spécifiez une devise prise en charge.                                                                                                                                                                                                                                                                                                                                                                                             |
| `missing_required_parameter`                              | Consultez le message d’erreur pour en savoir plus sur le paramètre requis.                                                                                                                                                                                                                                                                                                                                                        |
| `payment_intent_payment_attempt_failed`                   | Ce code peut apparaître dans le champ [last_payment_error.code](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-last_payment_error-code) d’un PaymentIntent. Consultez le message d’erreur pour connaître la raison détaillée de l’échec et obtenir une suggestion de traitement de l’erreur.                                                                                                         |
| `payment_intent_authentication_failure`                   | Ce code peut apparaître dans le champ [last_payment_error.code](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-last_payment_error-code) d’un PaymentIntent. Consultez le message d’erreur pour connaître le motif détaillé de l’échec et obtenir une suggestion sur la gestion de l’erreur. Cette erreur se produit lorsque vous déclenchez manuellement un échec lors du test de votre intégration. |
| `payment_intent_redirect_confirmation_without_return_url` | Précisez une `return_url` lors de la confirmation d’un PaymentIntent.                                                                                                                                                                                                                                                                                                                                                             |

## Optional: Accéder aux données d'un compte bancaire Financial Connections

Pour en savoir plus sur les frais de Financial Connections, consultez les [Tarifs](https://stripe.com/financial-connections#pricing).

Vous ne pouvez accéder aux données [Financial Connections](https://docs.stripe.com/financial-connections.md) que si vous demandez des [autorisations](https://docs.stripe.com/financial-connections/fundamentals.md#data-permissions) d’accès supplémentaires lors de la création de votre Payment Intent.

Une fois que votre client a terminé le [flux d’authentification Stripe Financial Connections](https://docs.stripe.com/financial-connections/fundamentals.md#authentication-flow), l’objet PaymentMethod `us_bank_account` renvoyé inclut un ID de [financial_connections_account](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-us_bank_account-financial_connections_account) correspondant à un [compte Financial Connections](https://docs.stripe.com/api/financial_connections/accounts.md). Utilisez cet ID pour accéder aux données du compte.

> Les comptes bancaires que vos clients associent par saisie manuelle ou par le biais de microversements n’ont pas d’ID de `financial_connections_account` au niveau du moyen de paiement.

Pour déterminer l’ID du compte Financial Connections, récupérez le PaymentIntent et développez l’attribut `payment_intent.payment_method`&nbsp;:

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

```json
{
  "payment_intent": {
    "id": "{{PAYMENT_INTENT_ID}}",
    "object": "payment_intent",
    // ...
    "payment_method": {
      "id": "{{PAYMENT_METHOD_ID}}",
      // ...
      "type": "us_bank_account",
      "us_bank_account": {
        "account_holder_type": "individual",
        "account_type": "checking",
        "bank_name": "TEST BANK","financial_connections_account": "{{FINANCIAL_CONNECTIONS_ACCOUNT_ID}}",
        "fingerprint": "q9qchffggRjlX2tb",
        "last4": "6789",
        "routing_number": "110000000"
      }
    }
    // ...
  }
}
```

## Optional: Résoudre les litiges [Côté serveur]

En règle générale, les clients peuvent [contester un paiement ACH Direct Debit](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#resolving-disputes) auprès de leur banque sous 60&nbsp;jours calendaires après un prélèvement sur un compte personnel, ou sous 2&nbsp;jours ouvrables pour un compte professionnel. Dans de rares cas, le client peut contester un paiement par prélèvement en dehors de ces délais de litige standard.

Lorsqu’un client conteste un paiement, Stripe envoie un événement webhook [charge.dispute.closed](https://docs.stripe.com/api/events/types.md#event_types-charge.dispute.closed), et l’autorisation du PaymentMethod est révoquée.

Il peut parfois arriver que Stripe reçoive un échec de paiement ACH de la banque alors que le PaymentIntent est déjà passé à l’état `succeeded`. Quand cela se produit, Stripe créée un litige dont le paramètre `reason` (motif) peut être&nbsp;:

- `insufficient_funds`
- `incorrect_account_details`
- `bank_can't_process`

Dans ce cas de figure, Stripe prélève des frais d’échec de paiement.

Les futurs paiements qui réutilisent ce PaymentMethod renvoient l’erreur suivante&nbsp;:

```javascript
{
  "error": {
    "message": "This PaymentIntent requires a mandate, but no existing mandate was found. Collect mandate acceptance from the customer and try again, providing acceptance data in the mandate_data parameter.",
    "payment_intent": {
      ...
    }
    "type": "invalid_request_error"
  }
}
```

Cette erreur comporte un PaymentIntent à l’état `requires_confirmation`. Pour que le paiement aboutisse, vous devez&nbsp;:

1. Résolvez le litige avec le client afin d’éviter toute contestation lors de futurs paiements.
1. Confirmez de nouveau l’autorisation de votre client.

Pour confirmer l’autorisation de paiement, vous pouvez [collecter la confirmation du mandat de votre client en ligne avec Stripe.js](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md?platform=web#web-collect-mandate-and-submit) ou confirmer l’autorisation avec votre client hors ligne à l’aide de l’API Stripe.

> Si un client conteste plusieurs paiements issus du même compte bancaire, Stripe bloque son compte. Contactez le [service Support de Stripe](https://support.stripe.com/?contact=true) pour obtenir une solution.

```curl
curl https://api.stripe.com/v1/payment_intents/{{PAYMENT_INTENT_ID}}/confirm \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "mandate_data[customer_acceptance][type]=offline"
```

## Optional: Référence du paiement

Le numéro de référence du paiement est une valeur générée par la banque qui permet au titulaire du compte bancaire d’utiliser sa banque pour localiser des fonds. Lorsque le paiement aboutit, Stripe fournit le numéro de référence du paiement dans le Dashboard, ainsi que dans l’[objet Charge](https://docs.stripe.com/api/charges/object.md).

| État du paiement | Valeur de référence du paiement           |
| ---------------- | ----------------------------------------- |
| En attente       | Indisponibles                             |
| En échec         | Indisponibles                             |
| Réussi           | Disponible (par exemple, 091000015001234) |

De plus, lorsque vous recevez le webhook `charge.succeeded`, consultez le contenu de `payment_method_details` pour localiser la [payment_reference](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-us_bank_account-payment_reference).

L’exemple d’événement suivant montre le rendu d’un paiement ACH abouti avec un numéro de référence de paiement.

#### charge-succeeded

```json
{
  "id": "{{EVENT_ID}}",
  "object": "event",
  // omitted some fields in the example
  "type": "charge.succeeded",
  "data": {
    "object": {
      "id": "{{PAYMENT_ID}}",
      "object": "charge",
      //...
    "paid": true,
    "payment_intent": "{{PAYMENT_INTENT_ID}}",
    "payment_method": "{{PAYMENT_METHOD_ID}}",
    "payment_method_details": {
      "type": "us_bank_account",
      "us_bank_account": {
        "account_holder_type": "individual",
        "account_type": "checking",
        "bank_name": "TEST BANK",
        "fingerprint": "Ih3foEnRvLXShyfB",
        "last4": "1000","payment_reference": "091000015001234",
        "routing_number": "110000000"
        }
      }
      // ...
    }
  }
}
```

Consultez le contenu de `destination_details` pour localiser la [référence du remboursement](https://docs.stripe.com/api/refunds/object.md#refund_object-destination_details-us_bank_transfer-reference) associée aux paiements ACH remboursés.

L’exemple d’événement suivant montre le rendu d’un remboursement de paiement ACH abouti avec un numéro de référence de remboursement. En savoir plus sur les [remboursements](https://docs.stripe.com/refunds.md).

#### charge-refund-updated

```json
{
  "id": "{{EVENT_ID}}",
  "object": "event",
  "type": "charge.refund.updated",
  "data": {
    "object": {
      "id": "{{REFUND_ID}}",
      "object": "refund",
      //...
    "payment_intent": "{{PAYMENT_INTENT_ID}}",
    "destination_details": {
      "type": "us_bank_transfer",
      "us_bank_transfer": {"reference": "091000015001111",
        "reference_status": "available"
        }
      }
      // ...
    }
  }
}
```

## Optional: Configurer la date de prélèvement du client [Côté serveur]

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

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

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

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

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

> Vous ne pouvez pas définir la [méthode de vérification](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-payment_method_options--us_bank_account-verification_method) sur `microdeposits` lorsque vous utilisez une [date butoir](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-payment_method_options-us_bank_account-target_date), car le processus de vérification pourrait dépasser la date butoir, entraînant un retard des paiements.


# API Direct

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

Voici les différentes étapes nécessaires pour accepter des paiements par prélèvement automatique ACH sur votre site Web&nbsp;:

- Création d’un objet de suivi du paiement
- Collecter des informations sur un moyen de paiement avec les vérifications instantanées activées par [Stripe Financial Connections](https://docs.stripe.com/financial-connections.md)
- Soumission du paiement à Stripe pour traitement
- Vérification du compte bancaire de votre client

Le prélèvement automatique ACH est un moyen de paiement à [notification différée](https://docs.stripe.com/payments/payment-methods.md#payment-notification), ce qui signifie que les fonds ne sont pas immédiatement disponibles après le paiement. Il faut généralement compter 4&nbsp;jours ouvrables pour qu’un paiement arrive sur votre compte.

Stripe utilise l’objet de paiement, le [Payment Intent](https://docs.stripe.com/payments/payment-intents.md), pour suivre et gérer l’ensemble des états du paiement jusqu’à son aboutissement.

> #### Utiliser l’API Accounts v2 pour représenter les clients
> 
> L’API Accounts&nbsp;v2 est généralement disponible pour les utilisateurs de Connect et en aperçu public pour les autres utilisateurs de Stripe. Si vous avez accès à l’aperçu Accounts&nbsp;v2, vous devez [spécifier une version d’aperçu](https://docs.stripe.com/api-v2-overview.md#sdk-and-api-versioning) dans votre code.
> 
> Pour demander l’accès à l’aperçu Accounts&nbsp;v2, 
> 
> Dans la plupart des cas d’usage, nous vous recommandons de [modéliser vos clients en tant qu’objets Account configurés par le client](https://docs.stripe.com/connect/use-accounts-as-customers.md), plutôt que d’utiliser des objets [Customer](https://docs.stripe.com/api/customers.md).

## Configurer Stripe [Côté serveur]

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

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

#### Ruby

```bash
# Available as a gem
sudo gem install stripe
```

```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```

## Créer ou récupérer un objet Customer [Recommandé] [Côté serveur]

> #### Utiliser l’API Accounts v2 pour représenter les clients
> 
> L’API Accounts&nbsp;v2 est généralement disponible pour les utilisateurs de Connect et en aperçu public pour les autres utilisateurs de Stripe. Si vous avez accès à l’aperçu Accounts&nbsp;v2, vous devez [spécifier une version d’aperçu](https://docs.stripe.com/api-v2-overview.md#sdk-and-api-versioning) dans votre code.
> 
> Pour demander l’accès à l’aperçu Accounts&nbsp;v2, 
> 
> Dans la plupart des cas d’usage, nous vous recommandons de [modéliser vos clients en tant qu’objets Account configurés par le client](https://docs.stripe.com/connect/use-accounts-as-customers.md), plutôt que d’utiliser des objets [Customer](https://docs.stripe.com/api/customers.md).

#### Accounts&nbsp;v2

Créez un objet [Account](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-configuration-customer) configuré par le client lorsque votre utilisateur crée un compte auprès de votre entreprise, ou récupérez un `Account` existant associé à cet utilisateur. L’association de l’ID de l’objet `Account` à votre propre représentation interne d’un client vous permet de récupérer et d’utiliser ultérieurement les informations de moyen de paiement enregistrées. Ajoutez une adresse e-mail à l’`objet Account` pour activer [l’optimisation des utilisateurs connus](https://docs.stripe.com/financial-connections/fundamentals.md#return-user-optimization) de Financial Connections.

```curl
curl -X POST https://api.stripe.com/v2/core/accounts \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-03-25.preview" \
  --json '{
    "contact_email": "{{CUSTOMER_EMAIL}}"
  }'
```

#### Customers&nbsp;v1

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) lorsque votre client crée un compte auprès de votre entreprise, ou récupérez l’objet `Customer` existant associé à cet utilisateur. L’association de l’ID de l’objet `Customer` à votre propre représentation interne d’un client vous permet de récupérer et d’utiliser ultérieurement les informations de paiement enregistrées. Ajoutez une adresse e-mail à l’objet `Customer` pour activer [l’optimisation des utilisateurs connus](https://docs.stripe.com/financial-connections/fundamentals.md#return-user-optimization) de Financial Connections.

```curl
curl https://api.stripe.com/v1/customers \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d email={{CUSTOMER_EMAIL}}
```

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

Un [PaymentIntent](https://docs.stripe.com/api/payment_intents.md) est un objet qui représente votre intention d’encaisser le paiement d’un client et qui suit le cycle de vie du processus de paiement étape par étape.

Créez un PaymentIntent sur votre serveur et indiquez le montant à collecter et la devise `usd`. Si vous avez déjà une intégration utilisant l’API Payment Intents, ajoutez `us_bank_account` à la liste des [types de moyens de paiement](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) pour votre PaymentIntent. Précisez l’ID du client.

Si vous souhaitez réutiliser le moyen de paiement dans le futur, fournissez le paramètre [setup_future_usage](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-setup_future_usage) avec la valeur `off_session`.

Pour en savoir plus sur les frais Financial Connections, consultez les [Tarifs](https://stripe.com/financial-connections#pricing).

Par défaut, lors de la collecte des coordonnées bancaires, [Financial Connections](https://docs.stripe.com/financial-connections.md) est utilisé pour vérifier instantanément le compte de votre client. Une option de secours comprenant la saisie manuelle du numéro de compte et la vérification par microversement peut être utilisée. Consultez la [documentation relative à Financial Connections](https://docs.stripe.com/financial-connections/ach-direct-debit-payments.md) pour savoir comment configurer Financial Connections et accéder à des données de compte supplémentaires de façon à optimiser votre intégration ACH. Par exemple, vous pouvez utiliser Financial Connections pour consulter le solde d’un compte avant d’initier le paiement ACH.

> Pour accéder à des données supplémentaires après qu’un client a authentifié son compte, celui-ci doit associer de nouveau son compte avec des autorisations étendues.

#### Accounts&nbsp;v2

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d setup_future_usage=off_session \
  -d "customer_account={{CUSTOMERACCOUNT_ID}}" \
  -d "payment_method_types[]=us_bank_account"
```

#### Customers&nbsp;v1

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d setup_future_usage=off_session \
  -d "customer={{CUSTOMER_ID}}" \
  -d "payment_method_types[]=us_bank_account"
```

### 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 du moyen de paiement [Côté client]

Lorsqu’un client clique pour payer avec ACH Direct Debit, nous vous recommandons d’utiliser Stripe.js pour soumettre le paiement à Stripe. [Stripe.js](https://docs.stripe.com/payments/elements.md) est notre bibliothèque JavaScript de base pour créer les tunnels de paiement&nbsp;: elle gère automatiquement les opérations complexes d’intégration et vous permettra de facilement étendre votre intégration à d’autres moyens de paiement par la suite.

Intégrez le script Stripe.js à votre page de paiement en l’ajoutant entre les balises `head` de votre fichier HTML.

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

Créez une instance de Stripe.js avec le code JavaScript suivant sur votre page de paiement.

```javascript
// Set your publishable key. Remember to change this to your live publishable key in production!
// See your keys here: https://dashboard.stripe.com/apikeys
const stripe = Stripe('<<YOUR_PUBLISHABLE_KEY>>');
```

Plutôt que d’envoyer la totalité de l’objet PaymentIntent au client, utilisez sa *clé secrète* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)) provenant de l’étape précédente. Il ne s’agit pas de vos clés API qui authentifient les requêtes de l’API de Stripe.

Utilisez la clé secrète du client avec prudence, car elle peut servir à finaliser le paiement. Ne l’enregistrez pas, ne l’intégrez pas dans des URL et ne la dévoilez à personne d’autre que votre client.

Utilisez [stripe.collectBankAccountForPayment](https://docs.stripe.com/js/payment_intents/collect_bank_account_for_payment)  pour collecter les coordonnées bancaires avec [Financial Connections](https://docs.stripe.com/financial-connections.md), créer un objet *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) et l’associer au PaymentIntent. Pour créer un PaymentMethod par prélèvement automatique ACH, vous devez obligatoirement inclure le nom du titulaire du compte dans le paramètre `billing_details`.

```javascript
// Use the form that already exists on the web page.
const paymentMethodForm = document.getElementById('payment-method-form');
const confirmationForm = document.getElementById('confirmation-form');

paymentMethodForm.addEventListener('submit', (ev) => {
  ev.preventDefault();
  const accountHolderNameField = document.getElementById('account-holder-name-field');
  const emailField = document.getElementById('email-field');

  // Calling this method will open the instant verification dialog.
  stripe.collectBankAccountForPayment({
    clientSecret: clientSecret,
    params: {
      payment_method_type: 'us_bank_account',
      payment_method_data: {
        billing_details: {
          name: accountHolderNameField.value,
          email: emailField.value,
        },
      },
    },
    expand: ['payment_method'],
  })
  .then(({paymentIntent, error}) => {
    if (error) {
      console.error(error.message);
      // PaymentMethod collection failed for some reason.
    } else if (paymentIntent.status === 'requires_payment_method') {
      // Customer canceled the hosted verification modal. Present them with other
      // payment method type options.
    } else if (paymentIntent.status === 'requires_confirmation') {
      // We collected an account - possibly instantly verified, but possibly
      // manually-entered. Display payment method details and mandate text
      // to the customer and confirm the intent once they accept
      // the mandate.
      confirmationForm.show();
    }
  });
});
```

Le [flux d’authentification de Financial Connections](https://docs.stripe.com/financial-connections/fundamentals.md#authentication-flow) gère automatiquement la collecte et la vérification des informations de compte bancaire. Lorsque votre client termine le flux d’authentification, le *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) est automatiquement associé au PaymentIntent, et créée un compte [Financial Connections](https://docs.stripe.com/api/financial_connections/accounts.md).

> Les comptes bancaires que vos clients associent par saisie manuelle ou par le biais de microversements ne fourniront pas d’accès à certaines données supplémentaires comme le solde, le propriétaire et les transactions.



Afin de proposer une expérience utilisateur optimale quel que soit l’appareil utilisé, définissez le paramètre `minimum-scale` de la fenêtre d’affichage de votre page sur 1 à l’aide de la balise `meta`.

```html
<meta name="viewport" content="width=device-width, minimum-scale=1" />
```

## Optional: Accéder aux données sur un compte bancaire Financial Connections [Côté serveur]

Vous ne pouvez accéder aux données Financial Connections que si vous demandez des [autorisations](https://docs.stripe.com/financial-connections/fundamentals.md#data-permissions) d’accès supplémentaires lors de la création de votre PaymentIntent .

Une fois que votre client a terminé le [flux d’authentification Stripe Financial Connections](https://docs.stripe.com/financial-connections/fundamentals.md#authentication-flow), l’objet PaymentMethod `us_bank_account` renvoyé inclut un ID de [financial_connections_account](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-us_bank_account-financial_connections_account) correspondant à un [compte Financial Connections](https://docs.stripe.com/api/financial_connections/accounts.md). Utilisez cet ID pour accéder aux données du compte.

> Les comptes bancaires que vos clients associent par saisie manuelle ou par le biais de microversements n’ont pas d’ID `financial_connections_account` au niveau du moyen de paiement.

Pour déterminer l’ID du compte Financial Connections, récupérez le PaymentIntent et développez l’attribut `payment_method`&nbsp;:

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

```json
{
  "id": "{{PAYMENT_INTENT_ID}}",
  "object": "payment_intent",
  // ...
  "payment_method": {
    "id": "{{PAYMENT_METHOD_ID}}",
    // ...
    "type": "us_bank_account"
    "us_bank_account": {
      "account_holder_type": "individual",
      "account_type": "checking",
      "bank_name": "TEST BANK","financial_connections_account": "{{FINANCIAL_CONNECTIONS_ACCOUNT_ID}}",
      "fingerprint": "q9qchffggRjlX2tb",
      "last4": "6789",
      "routing_number": "110000000"
    }
  }
  // ...
}

```

Si vous avez choisi de recevoir des autorisations `balances`, nous vous recommandons de vérifier l’état du solde à ce moment-là afin de vous assurer de disposer de fonds suffisants avant de confirmer un paiement.

Découvrez comment utiliser des données de compte supplémentaires pour optimiser votre intégration ACH avec [Financial Connections](https://docs.stripe.com/financial-connections/ach-direct-debit-payments.md#optimize).

## Collecter l'accusé de réception du mandat et effectuer le paiement [Côté client]

Avant de pouvoir initier le paiement, vous devez obtenir l’autorisation de votre client en affichant les conditions du mandat pour qu’il les accepte.

Pour vous conformer aux règles de la Nacha, vous devez obtenir l’autorisation d’initier le paiement auprès de votre client. Pour ce faire, présentez-lui les conditions du mandat et demandez-lui de les accepter. Pour en savoir plus, consultez la page sur les [mandats](https://docs.stripe.com/payments/ach-direct-debit.md#mandates).

Lorsque le client accepte les conditions du mandat, vous devez confirmer le PaymentIntent. Utilisez [stripe.confirmUsBankAccountPayment](https://docs.stripe.com/js/payment_intents/confirm_us_bank_account_payment) pour mener à bien le paiement une fois que le client a soumis le formulaire.

```javascript
confirmationForm.addEventListener('submit', (ev) => {
  ev.preventDefault();
  stripe.confirmUsBankAccountPayment(clientSecret)
  .then(({paymentIntent, error}) => {
    if (error) {
      console.error(error.message);
      // The payment failed for some reason.
    } else if (paymentIntent.status === "requires_payment_method") {
      // Confirmation failed. Attempt again with a different payment method.
    } else if (paymentIntent.status === "processing") {
      // Confirmation succeeded! The account will be debited.
      // Display a message to customer.
    } else if (paymentIntent.next_action?.type === "verify_with_microdeposits") {
      // The account needs to be verified through microdeposits.
      // Display a message to consumer with next steps (consumer waits for
      // microdeposits, then enters a statement descriptor code on a page sent to them through email).
    }
  });
});
```

> [stripe.confirmUsBankAccountPayment](https://docs.stripe.com/js/payment_intents/confirm_us_bank_account_payment) peut prendre plusieurs secondes pour s’exécuter. Pendant ce temps, désactivez toute nouvelle soumission de votre formulaire et affichez un indicateur d’attente (par exemple un spinner). Si vous recevez une erreur, affichez-la au client, réactivez le formulaire et masquez l’indicateur d’attente.

Sauf échec de l’opération, Stripe renvoie un objet PaymentIntent présentant l’un des états suivants&nbsp;:

| Statut            | Description                                                                              | Étapes suivantes                                                                                                                                                                     |
| ----------------- | ---------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `requires_action` | Une action supplémentaire est requise pour finaliser la vérification du compte bancaire. | Étape 6&nbsp;: [Vérification des comptes bancaires à l’aide de microversements](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#web-verify-with-microdeposits) |
| `processing`      | Le compte bancaire a été vérifié instantanément ou la vérification n’est pas nécessaire. | Étape 7&nbsp;: [Confirmation du succès du PaymentIntent](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#web-confirm-paymentintent-succeeded)                  |

Après avoir confirmé le PaymentIntent, un e-mail de confirmation du mandat et les coordonnées bancaires recueillies doivent être envoyés à votre client. Par défaut, Stripe gère cette étape, mais vous pouvez choisir d’[envoyer des notifications personnalisées](https://docs.stripe.com/payments/ach-direct-debit.md#mandate-and-microdeposit-emails) si vous préférez.

## Vérifier le compte bancaire à l'aide de microversements [Côté client]

Tous les clients ne peuvent pas vérifier instantanément le compte bancaire. Cette étape ne s’applique que si votre client a choisi de se désinscrire du flux de vérification instantanée dans l’étape précédente.

Dans ce cas, Stripe envoie un microversement `descriptor_code` ou `amount` si un problème survient au cours de la vérification du compte bancaire. Ces microversements apparaissent sur le relevé en ligne du client sous 1 à 2&nbsp;jours ouvrables.

- **Code de libellé**&nbsp;: Stripe envoie un microversement unique de 0,01&nbsp;USD sur le compte bancaire du client avec un `descriptor_code` unique à 6&nbsp;chiffres qui commence par SM. Votre client utilise cette chaîne pour vérifier son compte bancaire.
- **Montant**&nbsp;: Stripe envoie deux microversements distincts sur le compte bancaire du client avec un code de libellé indiquant `ACCTVERIFY`. Votre client utilise les montants de ces versements pour vérifier son compte bancaire.

L’appel [stripe.confirmUsBankAccountPayment](https://docs.stripe.com/js/payment_intents/confirm_us_bank_account_payment) effectué à l’étape précédente renvoie un PaymentIntent avec l’état `requires_action`. Le champ `next_action` du PaymentIntent contient des informations utiles à la vérification.

```javascript
next_action: {
  type: "verify_with_microdeposits",
  verify_with_microdeposits: {
    arrival_date: 1647586800,
    hosted_verification_url: "https://payments.stripe.com/…",
    microdeposit_type: "descriptor_code"
  }
}
```

Si vous avez fourni une [adresse e-mail de facturation](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-billing_details-email), Stripe utilise cette dernière pour notifier votre client de la date d’arrivée prévue des versements. L’e-mail envoyé inclut un lien vers la page de vérification hébergée par Stripe, sur laquelle il peut confirmer les montants des versements et effectuer la vérification.

> Les tentatives de vérification sont limitées à dix pour les microversements basés sur des libellés et à trois pour ceux basés sur des montants. Si vous atteignez cette limite, nous ne pouvons plus vérifier le compte bancaire. En outre, les vérifications à l’aide de microversements expirent au bout de 10&nbsp;jours. Si vous ne vérifiez pas les microversements pendant ce laps de temps, le PaymentIntent réitère sa demande d’informations sur le moyen de paiement. En informant clairement vos clients sur le fonctionnement de ces microversements, vous évitez d’éventuels problèmes liés à la vérification.

### Facultatif&nbsp;: Envoi de notifications personnalisées par e-mail

Si vous le souhaitez, vous pouvez envoyer des [notifications personnalisées par e-mail](https://docs.stripe.com/payments/ach-direct-debit.md#mandate-and-microdeposit-emails) à votre client. Après avoir configuré les e-mails personnalisés, vous devez préciser comment le client doit répondre à l’e-mail de vérification. Pour ce faire, choisissez *une* des options suivantes&nbsp;:

- Utilisez la page de vérification hébergée par Stripe. Pour ce faire, utilisez l’URL `verify_with_microdeposits[hosted_verification_url]` de l’objet [next_action](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-next_action-verify_with_microdeposits-hosted_verification_url) pour diriger votre client vers la procédure de vérification.

- Si vous préférez ne pas utiliser la page de vérification hébergée par Stripe, créez un formulaire sur votre site. Vos clients pourront ensuite utiliser ce formulaire pour vous transmettre les montants des microversements et vérifier le compte bancaire à l’aide de [Stripe.js](https://docs.stripe.com/js/payment_intents/verify_microdeposits_for_payment).

  - Configurez au moins le formulaire pour qu’il gère le paramètre `descriptor code`, qui comporte une chaîne à 6&nbsp;chiffres à des fins de vérification.
  - Stripe recommande également de configurer votre formulaire pour gérer le paramètre `amounts`, car certaines banques utilisées par vos clients peuvent l’exiger.

  Les intégrations transmettent uniquement le code de libellé, `descriptor_code`, *ou* les montants, `amounts`. Pour savoir quel paramètre votre intégration utilise, vérifiez la valeur de `verify_with_microdeposits[microdeposit_type]` dans l’objet `next_action`.

```javascript
stripe.verifyMicrodepositsForPayment(clientSecret, {
  // Provide either a descriptor_code OR amounts, not both
  descriptor_code: 'SMT86W',
  amounts: [32, 45],
});
```

Dès que le compte bancaire a été vérifié, Stripe renvoie l’objet PaymentIntent avec l’état `status` défini sur `processing`, et envoie un événement *webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) [payment_intent.processing](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.processing).

La vérification peut échouer pour plusieurs raisons. L’échec peut se produire de manière synchrone comme une réponse d’erreur directe, ou de manière asynchrone à travers un événement webhook [payment_intent.payment_failed](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.failed) (voir les exemples ci-après).

#### Erreur synchrone

```json
{
  "error": {
    "code": "payment_method_microdeposit_verification_amounts_mismatch",
    "message": "The amounts provided do not match the amounts that were sent to the bank account. You have {attempts_remaining} verification attempts remaining.",
    "type": "invalid_request_error"
  }
}
```

#### Événement de webhook

```javascript
{
  "object": {
    "id": "pi_1234",
    "object": "payment_intent",
    "customer": "cus_0246",
    ...
    "last_payment_error": {
      "code": "payment_method_microdeposit_verification_attempts_exceeded",
      "message": "You have exceeded the number of allowed verification attempts.",
    },
    ...
    "status": "requires_payment_method"
  }
}
```

| Code d’erreur                                                | Synchrone ou asynchrone                                      | Message                                                                                                                                     | Changement d’état                                                                                |
| ------------------------------------------------------------ | ------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
| `payment_method_microdeposit_failed`                         | De façon synchrone ou asynchrone via un événement de webhook | Les microversements ont échoué. Veuillez vérifier la validité des numéros de compte, de l’établissement et de transit fournis.              | `status` est à l’état `requires_payment_method` et le paramètre `last_payment_error` est défini. |
| `payment_method_microdeposit_verification_amounts_mismatch`  | De façon synchrone                                           | Les montants fournis ne correspondent pas à ceux envoyés au compte bancaire. Il vous reste {attempts_remaining} tentatives de vérification. | Inchangé                                                                                         |
| `payment_method_microdeposit_verification_attempts_exceeded` | De façon synchrone ou asynchrone via un événement de webhook | Dépassement du nombre de tentatives de vérification autorisé                                                                                | `status` est à l’état `requires_payment_method` et le paramètre `last_payment_error` est défini. |
| `payment_method_microdeposit_verification_timeout`           | De façon asynchrone via un événement de webhook              | Expiration du microversement. Le client n’a pas vérifié son compte bancaire dans le délai de 10&nbsp;jours prévu.                           | `status` est à l’état `requires_payment_method` et le paramètre `last_payment_error` est défini. |

## Confirmer l'aboutissement du PaymentIntent [Côté serveur]

Le prélèvement automatique ACH est un moyen de paiement à [notification différée](https://docs.stripe.com/payments/payment-methods.md#payment-notification). Ceci signifie que pour recevoir une notification du succès ou de l’échec d’un paiement, il faut compter jusqu’à quatre jours ouvrables après le déclenchement du prélèvement sur le compte du client.

Initialement, le PaymentIntent que vous créez présente l’état `processing`. Une fois le paiement abouti, l’état du PaymentIntent passe de `processing` à `succeeded`.

Nous vous recommandons d’utiliser des [webhooks](https://docs.stripe.com/payments/payment-intents/verifying-status.md#webhooks) afin de *confirmer* (Confirming an intent indicates that the customer intends to use the current or provided payment method. Upon confirmation, the intent attempts to initiate the portions of the flow that have real-world side effects) que le paiement a réussi et d’informer le client que le paiement a été effectué. Vous pouvez également afficher les événements sur le [Dashboard Stripe](https://dashboard.stripe.com/events).

#### Événements PaymentIntent

Les événements suivants sont envoyés lorsque le PaymentIntent change d’état&nbsp;:

| Événement                       | Description                                                                                                                    | Étape suivante                                                                                                                                                                                                                                                                                                                       |
| ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `payment_intent.processing`     | Le paiement du client a bien été envoyé à Stripe.                                                                              | Attendez que le paiement aboutisse ou échoue.                                                                                                                                                                                                                                                                                        |
| `payment_intent.succeeded`      | Le paiement du client a abouti.                                                                                                | Traitez la commande de biens ou de services.                                                                                                                                                                                                                                                                                         |
| `payment_intent.payment_failed` | Le paiement du client a été refusé. Ceci peut aussi s’appliquer en cas d’échec de la vérification à l’aide de microversements. | Envoyez un e-mail ou une notification push au client pour lui demander d’utiliser un autre moyen de paiement. Si le webhook a été envoyé suite à l’échec de la vérification à l’aide de micro-versements, l’utilisateur doit à nouveau saisir ses coordonnées bancaires. De nouveaux micro-versements seront déposés sur son compte. |

#### Événements de paiement

Vous pouvez également utiliser des webhooks Charge supplémentaires pour suivre l’état du paiement. Dès réception du webhook `charge.updated`, le paiement ne peut plus être annulé.

Les événements suivants sont envoyés lorsque le paiement change d’état&nbsp;:

| Événement          | Description                                                                                                                                                                           | Étape suivante                                                                                 |
| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- |
| `charge.pending`   | Le paiement du client a bien été créé.                                                                                                                                                | Attendez que le paiement initié soit traité.                                                   |
| `charge.updated`   | Le paiement du client a été mis à jour. Il peut être émis lorsqu’une nouvelle opération sur solde est créée, qu’une description ou que des métadonnées de paiement sont mises à jour. | Attendez que le paiement aboutisse ou échoue.                                                  |
| `charge.succeeded` | Le paiement du client a abouti et les fonds sont disponibles sur votre solde.                                                                                                         | Traitez la commande de biens ou de services.                                                   |
| `charge.failed`    | Le paiement du client a échoué.                                                                                                                                                       | Vérifiez le failure_code et le failure_message du paiement pour déterminer la marche à suivre. |

## Tester votre intégration

Découvrez comment tester des scénarios avec des vérifications instantanées à l’aide de [Financial Connections](https://docs.stripe.com/financial-connections/testing.md#web-how-to-use-test-accounts).

### Envoyer des e-mails de transaction dans un environnement de test

Une fois que vous avez collecté les coordonnées bancaires et accepté un mandat, envoyez les courriels de confirmation du mandat et de vérification du microversement dans un *environnement de bac à sable* (A sandbox is an isolated test environment that allows you to test Stripe functionality in your account without affecting your live integration. Use sandboxes to safely experiment with new features and changes).

Si votre domaine est **{domain}** et votre nom d’utilisateur est **{username}**, utilisez le format d’adresse e-mail suivant pour envoyer des e-mails de transaction de test&nbsp;: **{username}+test\_email@{domain}**.

Par exemple, si votre domaine est **example.com** et que votre nom d’utilisateur est **info**, utilisez le format **info+test\_email@example.com** pour tester les paiements ACH Direct Debit. Ce format garantit que les e-mails sont acheminés correctement. Si vous n’incluez pas le suffixe **+test\_email**, nous n’enverrons pas l’e-mail.

> Vous devez [configurer votre compte Stripe](https://docs.stripe.com/get-started/account/set-up.md) avant de pouvoir déclencher ces e-mails pendant les tests.

### Numéros de comptes de test

Stripe fournit plusieurs numéros de compte de test et les tokens correspondants que vous pouvez utiliser pour vous assurer que votre intégration pour les comptes bancaires saisis manuellement est prête à passer en mode production.

| Numéro de compte | Token                                  | Numéro de routage | Comportement                                                                                                                                                                                                                                                                                                         |
| ---------------- | -------------------------------------- | ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `000123456789`   | `pm_usBankAccount_success`             | `110000000`       | Le paiement aboutit.                                                                                                                                                                                                                                                                                                 |
| `000111111113`   | `pm_usBankAccount_accountClosed`       | `110000000`       | Le paiement échoue parce que le compte est clôturé.                                                                                                                                                                                                                                                                  |
| `000000004954`   | `pm_usBankAccount_riskLevelHighest`    | `110000000`       | Le paiement est bloqué par Radar en raison d’un [risque élevé de fraude](https://docs.stripe.com/radar/risk-evaluation.md#high-risk).                                                                                                                                                                                |
| `000111111116`   | `pm_usBankAccount_noAccount`           | `110000000`       | Le paiement échoue car aucun compte n’est trouvé.                                                                                                                                                                                                                                                                    |
| `000222222227`   | `pm_usBankAccount_insufficientFunds`   | `110000000`       | Le paiement échoue en raison de fonds insuffisants.                                                                                                                                                                                                                                                                  |
| `000333333335`   | `pm_usBankAccount_debitNotAuthorized`  | `110000000`       | Le paiement échoue parce que les débits ne sont pas autorisés.                                                                                                                                                                                                                                                       |
| `000444444440`   | `pm_usBankAccount_invalidCurrency`     | `110000000`       | Le paiement échoue en raison d’une devise non valide.                                                                                                                                                                                                                                                                |
| `000666666661`   | `pm_usBankAccount_failMicrodeposits`   | `110000000`       | Le paiement ne parvient pas à envoyer les microversements.                                                                                                                                                                                                                                                           |
| `000555555559`   | `pm_usBankAccount_dispute`             | `110000000`       | Le paiement déclenche un litige.                                                                                                                                                                                                                                                                                     |
| `000000000009`   | `pm_usBankAccount_processing`          | `110000000`       | Le traitement du paiement est indéfini. Utile pour tester {&nbsp;% si $checkoutSessions %}[Expiration de la session de paiement](https://docs.stripe.com/api/checkout/sessions/expire.md){&nbsp;% else /&nbsp;%}[Annulation de PaymentIntent](https://docs.stripe.com/api/payment_intents/cancel.md){&nbsp;% /if %}. |
| `000777777771`   | `pm_usBankAccount_weeklyLimitExceeded` | `110000000`       | Le paiement échoue, car son montant entraîne un dépassement de la limite hebdomadaire de volume de paiement du compte.                                                                                                                                                                                               |
| `000888888885`   |                                        | `110000000`       | Le paiement échoue en raison d’un [numéro de compte tokenisé](https://docs.stripe.com/financial-connections/tokenized-account-numbers.md) désactivé.                                                                                                                                                                 |

Avant d’effectuer les transactions de test, vous devez vérifier tous les comptes de test pour lesquels le paiement aboutit ou échoue automatiquement. Pour ce faire, utilisez les codes de libellé ou les montants de microversements de test ci-dessous.

### Tester des codes de libellé et des montants de microversements

Pour simuler différents scénarios, utilisez ces montants de microversements *ou* ces codes de libellé 0.01.

| Valeurs de microversement | Valeurs de code de libellé 0.01 | Scénario                                                                |
| ------------------------- | ------------------------------- | ----------------------------------------------------------------------- |
| `32` et `45`              | SM11AA                          | Simule la vérification du compte.                                       |
| `10` et `11`              | SM33CC                          | Simule le dépassement du nombre de tentatives de vérification autorisé. |
| `40` et `41`              | SM44DD                          | Simule l’expiration du délai de validité d’un microversement.           |

### Comportement de règlement des tests

Les transactions de test sont réglées instantanément et ajoutées à votre solde de test disponible. Ce comportement diffère de celui du mode production, où les transactions peuvent prendre [plusieurs jours](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#timing) pour être réglées dans votre solde disponible.

## Optional: Vérification instantanée uniquement [Côté serveur]

Par défaut, le paiement à l’aide d’un compte bancaire américain permet à vos clients d’utiliser la vérification instantanée du compte bancaire ou les microversements. Vous pouvez aussi exiger la vérification instantanée du compte bancaire uniquement en utilisant le paramètre [verification_method](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-us_bank_account-verification_method) à la création du PaymentIntent.

#### Accounts&nbsp;v2

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d setup_future_usage=off_session \
  -d "customer_account={{CUSTOMERACCOUNT_ID}}" \
  -d "payment_method_types[]=us_bank_account" \
  -d "payment_method_options[us_bank_account][verification_method]=instant" \
  -d "payment_method_options[us_bank_account][financial_connections][permissions][]=payment_method" \
  -d "payment_method_options[us_bank_account][financial_connections][permissions][]=balances"
```

#### Customers&nbsp;v1

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d setup_future_usage=off_session \
  -d "customer={{CUSTOMER_ID}}" \
  -d "payment_method_types[]=us_bank_account" \
  -d "payment_method_options[us_bank_account][verification_method]=instant" \
  -d "payment_method_options[us_bank_account][financial_connections][permissions][]=payment_method" \
  -d "payment_method_options[us_bank_account][financial_connections][permissions][]=balances"
```

Ainsi, vous n’avez pas besoin de gérer la vérification à l’aide de microversements. Cependant, si la vérification instantanée échoue, l’état du PaymentIntent est `requires_payment_method`, indiquant l’échec de la vérification instantanée du compte bancaire de votre client.

## Optional: Vérification à l'aide de microversements uniquement [Côté serveur]

Par défaut, le paiement à l’aide d’un compte bancaire américain permet à vos clients d’utiliser la vérification instantanée du compte bancaire ou les microversements. Vous pouvez aussi exiger la vérification du compte bancaire à l’aide de microversements uniquement en utilisant le paramètre [verification_method](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-us_bank_account-verification_method) à la création du PaymentIntent.

> Si vous utilisez un formulaire de paiement personnalisé, vous devez développer votre propre interface utilisateur pour collecter les coordonnées bancaires des clients. De la même manière, si vous désactivez l’envoi d’e-mails par Stripe en cas de microversements, vous devez développer votre propre interface utilisateur pour que votre client puisse confirmer le code ou le montant du microversement.

#### Accounts&nbsp;v2

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d setup_future_usage=off_session \
  -d "customer_account={{CUSTOMERACCOUNT_ID}}" \
  -d "payment_method_types[]=us_bank_account" \
  -d "payment_method_options[us_bank_account][verification_method]=microdeposits"
```

#### Customers&nbsp;v1

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d setup_future_usage=off_session \
  -d "customer={{CUSTOMER_ID}}" \
  -d "payment_method_types[]=us_bank_account" \
  -d "payment_method_options[us_bank_account][verification_method]=microdeposits"
```

Collectez ensuite le compte bancaire de votre client avec votre propre formulaire et appelez [stripe.confirmUsBankAccountPayment](https://docs.stripe.com/js/payment_intents/confirm_us_bank_account_payment) avec ces informations pour mener à bien le PaymentIntent.

```javascript
var form = document.getElementById('payment-form');
var accountholderName = document.getElementById('accountholder-name');
var email = document.getElementById('email');
var accountNumber = document.getElementById('account-number');
var routingNumber = document.getElementById('routing-number');
var accountHolderType= document.getElementById('account-holder-type');

var submitButton = document.getElementById('submit-button');
var clientSecret = submitButton.dataset.secret;

form.addEventListener('submit', function(event) {
  event.preventDefault();

  stripe.confirmUsBankAccountPayment(clientSecret, {
    payment_method: {
      billing_details: {
        name: accountholderName.value,
        email: email.value,
      },
      us_bank_account: {
        account_number: accountNumber.value,
        routing_number: routingNumber.value,
        account_holder_type: accountHolderType.value, // 'individual' or 'company'
      },
    },
  })
  .then(({paymentIntent, error}) => {
    if (error) {
      // Inform the customer that there was an error.
      console.log(error.message);
    } else {
      // Handle next step based on the intent's status.
      console.log("PaymentIntent ID: " + paymentIntent.id);
      console.log("PaymentIntent status: " + paymentIntent.status);
    }
  });
});
```

## Optional: Résoudre les litiges [Côté serveur]

En règle générale, les clients peuvent [contester un paiement ACH Direct Debit](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#resolving-disputes) auprès de leur banque sous 60&nbsp;jours calendaires après un prélèvement sur un compte personnel, ou sous 2&nbsp;jours ouvrables pour un compte professionnel. Dans de rares cas, le client peut contester un paiement par prélèvement en dehors de ces délais de litige standard.

Lorsqu’un client conteste un paiement, Stripe envoie un événement webhook [charge.dispute.closed](https://docs.stripe.com/api/events/types.md#event_types-charge.dispute.closed), et l’autorisation du PaymentMethod est révoquée.

Il peut parfois arriver que Stripe reçoive un échec de paiement ACH de la banque alors que le PaymentIntent est déjà passé à l’état `succeeded`. Quand cela se produit, Stripe créée un litige dont le paramètre `reason` (motif) peut être&nbsp;:

- `insufficient_funds`
- `incorrect_account_details`
- `bank_can't_process`

Dans ce cas de figure, Stripe prélève des frais d’échec de paiement.

Les futurs paiements qui réutilisent ce PaymentMethod renvoient l’erreur suivante&nbsp;:

```javascript
{
  "error": {
    "message": "This PaymentIntent requires a mandate, but no existing mandate was found. Collect mandate acceptance from the customer and try again, providing acceptance data in the mandate_data parameter.",
    "payment_intent": {
      ...
    }
    "type": "invalid_request_error"
  }
}
```

Cette erreur comporte un PaymentIntent à l’état `requires_confirmation`. Pour que le paiement aboutisse, vous devez&nbsp;:

1. Résolvez le litige avec le client afin d’éviter toute contestation lors de futurs paiements.
1. Confirmez de nouveau l’autorisation de votre client.

Pour confirmer l’autorisation de paiement, vous pouvez [collecter la confirmation du mandat de votre client en ligne avec Stripe.js](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md?platform=web#web-collect-mandate-and-submit) ou confirmer l’autorisation avec votre client hors ligne à l’aide de l’API Stripe.

> Si un client conteste plusieurs paiements issus du même compte bancaire, Stripe bloque son compte. Contactez le [service Support de Stripe](https://support.stripe.com/?contact=true) pour obtenir une solution.

```curl
curl https://api.stripe.com/v1/payment_intents/{{PAYMENT_INTENT_ID}}/confirm \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "mandate_data[customer_acceptance][type]=offline"
```

## Optional: Référence du paiement

Le numéro de référence du paiement est une valeur générée par la banque qui permet au titulaire du compte bancaire d’utiliser sa banque pour localiser des fonds. Lorsque le paiement aboutit, Stripe fournit le numéro de référence du paiement dans le Dashboard, ainsi que dans l’[objet Charge](https://docs.stripe.com/api/charges/object.md).

| État du paiement | Valeur de référence du paiement           |
| ---------------- | ----------------------------------------- |
| En attente       | Indisponibles                             |
| En échec         | Indisponibles                             |
| Réussi           | Disponible (par exemple, 091000015001234) |

De plus, lorsque vous recevez le webhook `charge.succeeded`, consultez le contenu de `payment_method_details` pour localiser la [payment_reference](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-us_bank_account-payment_reference).

L’exemple d’événement suivant montre le rendu d’un paiement ACH abouti avec un numéro de référence de paiement.

#### charge-succeeded

```json
{
  "id": "{{EVENT_ID}}",
  "object": "event",
  // omitted some fields in the example
  "type": "charge.succeeded",
  "data": {
    "object": {
      "id": "{{PAYMENT_ID}}",
      "object": "charge",
      //...
    "paid": true,
    "payment_intent": "{{PAYMENT_INTENT_ID}}",
    "payment_method": "{{PAYMENT_METHOD_ID}}",
    "payment_method_details": {
      "type": "us_bank_account",
      "us_bank_account": {
        "account_holder_type": "individual",
        "account_type": "checking",
        "bank_name": "TEST BANK",
        "fingerprint": "Ih3foEnRvLXShyfB",
        "last4": "1000","payment_reference": "091000015001234",
        "routing_number": "110000000"
        }
      }
      // ...
    }
  }
}
```

Consultez le contenu de `destination_details` pour localiser la [référence du remboursement](https://docs.stripe.com/api/refunds/object.md#refund_object-destination_details-us_bank_transfer-reference) associée aux paiements ACH remboursés.

L’exemple d’événement suivant montre le rendu d’un remboursement de paiement ACH abouti avec un numéro de référence de remboursement. En savoir plus sur les [remboursements](https://docs.stripe.com/refunds.md).

#### charge-refund-updated

```json
{
  "id": "{{EVENT_ID}}",
  "object": "event",
  "type": "charge.refund.updated",
  "data": {
    "object": {
      "id": "{{REFUND_ID}}",
      "object": "refund",
      //...
    "payment_intent": "{{PAYMENT_INTENT_ID}}",
    "destination_details": {
      "type": "us_bank_transfer",
      "us_bank_transfer": {"reference": "091000015001111",
        "reference_status": "available"
        }
      }
      // ...
    }
  }
}
```

## Optional: Configurer la date de prélèvement du client [Côté serveur]

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

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

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

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

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

## See also

- [Enregistrer les coordonnées ACH Direct Debit pour les futurs paiements](https://docs.stripe.com/payments/ach-direct-debit/set-up-payment.md)


# iOS

> This is a iOS for when payment-ui is mobile and platform is ios. View the full page at https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment?payment-ui=mobile&platform=ios.

> #### Utiliser l’API Accounts v2 pour représenter les clients
> 
> L’API Accounts&nbsp;v2 est généralement disponible pour les utilisateurs de Connect et en aperçu public pour les autres utilisateurs de Stripe. Si vous avez accès à l’aperçu Accounts&nbsp;v2, vous devez [spécifier une version d’aperçu](https://docs.stripe.com/api-v2-overview.md#sdk-and-api-versioning) dans votre code.
> 
> Pour demander l’accès à l’aperçu Accounts&nbsp;v2, 
> 
> Dans la plupart des cas d’usage, nous vous recommandons de [modéliser vos clients en tant qu’objets Account configurés par le client](https://docs.stripe.com/connect/use-accounts-as-customers.md), plutôt que d’utiliser des objets [Customer](https://docs.stripe.com/api/customers.md).

Voici les différentes étapes nécessaires pour accepter des paiements par prélèvement automatique ACH sur votre application&nbsp;:

- Création d’un objet de suivi du paiement
- Collecter des informations sur un moyen de paiement avec les vérifications instantanées activées par [Stripe Financial Connections](https://docs.stripe.com/financial-connections.md)
- Soumission du paiement à Stripe pour traitement
- Vérification du compte bancaire de votre client

> Le prélèvement automatique ACH est un moyen de paiement à [notification différée](https://docs.stripe.com/payments/payment-methods.md#payment-notification), ce qui signifie que les fonds ne sont pas immédiatement disponibles après le paiement. Il faut généralement compter 4&nbsp;jours ouvrables pour qu’un paiement arrive sur votre compte.

Stripe utilise l’objet de paiement, le [Payment Intent](https://docs.stripe.com/payments/payment-intents.md), pour suivre et gérer l’ensemble des états du paiement jusqu’à son aboutissement.

Le [SDK iOS](https://github.com/stripe/stripe-ios) est disponible en open source et [fait l’objet d’une documentation complète](https://stripe.dev/stripe-ios/index.html). Il est également compatible avec les applications prenant en charge iOS 13 et les versions ultérieures.

#### Swift Package Manager

Pour installer le SDK&nbsp;:

1. Dans Xcode, sélectionnez **File** > **Add Package Dependencies…** puis saisissez `https://github.com/stripe/stripe-ios-spm` en tant qu’URL du référentiel.
1. Sélectionnez le dernier numéro de version, visible sur notre [page des versions](https://github.com/stripe/stripe-ios/releases).
1. Ajoutez les produits **StripePayments** et **StripeFinancialConnections** à la [cible de votre application](https://developer.apple.com/documentation/swift_packages/adding_package_dependencies_to_your_app).

#### CocoaPods

1. Si vous ne l’avez pas encore fait, installez la version la plus récente de [CocoaPods](https://guides.cocoapods.org/using/getting-started.html).
1. Si vous n’avez pas de fichier [Podfile](https://guides.cocoapods.org/syntax/podfile.html), exécutez la commande suivante pour en créer un&nbsp;:
   ```bash
   pod init
   ```
1. Ajoutez cette ligne à votre fichier `Podfile`&nbsp;:
   ```podfile
   pod 'Stripe'
   pod 'StripeFinancialConnections'
   ```
1. Exécutez la commande suivante&nbsp;:
   ```bash
   pod install
   ```
1. À partir de maintenant, n’oubliez pas d’utiliser le fichier .xcworkspace au lieu du fichier .xcodeproj pour ouvrir votre projet dans Xcode.
1. À l’avenir, pour mettre à jour le SDK vers la version la plus récente, exécutez&nbsp;:
   ```bash
   pod update Stripe
   pod update StripeFinancialConnections
   ```

#### Carthage

1. Si vous ne l’avez pas encore fait, installez la version la plus récente de [Carthage](https://github.com/Carthage/Carthage#installing-carthage).
1. Ajoutez cette ligne à votre fichier `Cartfile`&nbsp;:
   ```cartfile
   github "stripe/stripe-ios"
   ```
1. Suivez les [instructions d’installation de Carthage](https://github.com/Carthage/Carthage#if-youre-building-for-ios-tvos-or-watchos). Veillez à intégrer tous les cadres requis listés [ici](https://github.com/stripe/stripe-ios#releases).
1. Outre les frameworks requis répertoriés dans la liste ci-dessus, assurez-vous d’inclure le framework **StripeFinancialConnections**.
1. À l’avenir, pour mettre à niveau le SDK vers la version la plus récente, exécutez la commande suivante&nbsp;:
   ```bash
   carthage update stripe-ios --platform ios
   ```

#### Cadre manuel

1. Accédez à notre [page des versions GitHub](https://github.com/stripe/stripe-ios/releases/latest), puis téléchargez et décompressez **Stripe.xcframework.zip**.
1. Faites glisser **Stripe.xcframework** vers la section **Embedded Binaries** (Binaires embarqués) des paramètres **General** (Général) de votre projet Xcode. Veillez à sélectionner **Copy items if needed** (Copier les éléments si nécessaire).
1. Répétez l’étape&nbsp;2 pour **StripeFinancialConnections.xcframework**
1. Répétez l’étape&nbsp;2 pour tous les cadres requis listés [ici](https://github.com/stripe/stripe-ios#releases).
1. À l’avenir, pour mettre à niveau notre SDK vers la version la plus récente, répétez les étapes&nbsp;1 à 3.

> Pour en savoir plus sur la version la plus récente du SDK et ses versions antérieures, consultez la page [Releases](https://github.com/stripe/stripe-ios/releases) sur GitHub. Pour recevoir une notification lors de la publication d’une nouvelle version, [suivez les versions du référentiel](https://help.github.com/en/articles/watching-and-unwatching-releases-for-a-repository#watching-releases-for-a-repository).

Configurez le SDK avec votre [clé publiable](https://dashboard.stripe.com/test/apikeys) Stripe au démarrage de votre application. Cela lui permet d’envoyer des requêtes à l’API Stripe.

#### Swift

```swift
import UIKitimportStripeFinancialConnections

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {StripeAPI.defaultPublishableKey = "<<YOUR_PUBLISHABLE_KEY>>"
        // do any other necessary launch configuration
        return true
    }
}
```

> Utilisez vos [clés de test](https://docs.stripe.com/keys.md#obtain-api-keys) lors de vos activités de test et de développement et vos clés du [mode production](https://docs.stripe.com/keys.md#test-live-modes) pour la publication de votre application.

Stripe vous permet de vérifier instantanément le compte bancaire d’un client. Si vous souhaitez récupérer des données supplémentaires sur un compte, [inscrivez-vous pour accéder aux données](https://dashboard.stripe.com/financial-connections/application) avec [Stripe Financial Connections](https://docs.stripe.com/financial-connections.md).

Stripe Financial Connections permet à vos clients de partager de manière sécurisée leurs données financières en associant leurs comptes financiers à votre entreprise. Utilisez Financial Connections pour accéder aux données financières autorisées par les clients telles que les numéros de compte et de routage tokenisés, les données de solde, les informations sur la propriété et les données de transaction.

L’accès à ces données vous permet d’effectuer des actions comme la vérification des soldes avant d’initier un paiement afin de réduire le risque d’un échec du paiement dû à des fonds insuffisants.

Financial Connections permet à vos utilisateurs de connecter leurs comptes en moins d’étapes grâce à Link. Ils peuvent ainsi enregistrer et réutiliser leurs coordonnées bancaires auprès des entreprises Stripe.

## Créer ou récupérer un objet Customer [Recommandé] [Côté serveur]

> #### Utiliser l’API Accounts v2 pour représenter les clients
> 
> L’API Accounts&nbsp;v2 est généralement disponible pour les utilisateurs de Connect et en aperçu public pour les autres utilisateurs de Stripe. Si vous avez accès à l’aperçu Accounts&nbsp;v2, vous devez [spécifier une version d’aperçu](https://docs.stripe.com/api-v2-overview.md#sdk-and-api-versioning) dans votre code.
> 
> Pour demander l’accès à l’aperçu Accounts&nbsp;v2, 
> 
> Dans la plupart des cas d’usage, nous vous recommandons de [modéliser vos clients en tant qu’objets Account configurés par le client](https://docs.stripe.com/connect/use-accounts-as-customers.md), plutôt que d’utiliser des objets [Customer](https://docs.stripe.com/api/customers.md).

#### Accounts&nbsp;v2

Créez un objet [Account](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-configuration-customer) configuré par le client lorsque votre utilisateur crée un compte auprès de votre entreprise, ou récupérez un `Account` existant associé à cet utilisateur. L’association de l’ID de l’objet `Account` à votre propre représentation interne d’un client vous permet de récupérer et d’utiliser ultérieurement les informations de moyen de paiement enregistrées. Ajoutez une adresse e-mail à l’`objet Account` pour activer [l’optimisation des utilisateurs connus](https://docs.stripe.com/financial-connections/fundamentals.md#return-user-optimization) de Financial Connections.

```curl
curl -X POST https://api.stripe.com/v2/core/accounts \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-03-25.preview" \
  --json '{
    "contact_email": "{{CUSTOMER_EMAIL}}"
  }'
```

#### Customers&nbsp;v1

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) lorsque votre client crée un compte auprès de votre entreprise, ou récupérez l’objet `Customer` existant associé à cet utilisateur. L’association de l’ID de l’objet `Customer` à votre propre représentation interne d’un client vous permet de récupérer et d’utiliser ultérieurement les informations de paiement enregistrées. Ajoutez une adresse e-mail à l’objet `Customer` pour activer [l’optimisation des utilisateurs connus](https://docs.stripe.com/financial-connections/fundamentals.md#return-user-optimization) de Financial Connections.

```curl
curl https://api.stripe.com/v1/customers \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d email={{CUSTOMER_EMAIL}}
```

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

Un [PaymentIntent](https://docs.stripe.com/api/payment_intents.md) est un objet qui représente votre intention d’encaisser le paiement d’un client et qui suit le cycle de vie du processus de paiement étape par étape.

### Côté serveur

Tout d’abord, créez un PaymentIntent sur votre serveur et spécifiez le montant à collecter et la devise `usd`. Si vous possédez déjà une autre intégration utilisant l’API Payment Intents, ajoutez `us_bank_account` à la liste des [types de moyens de paiement](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) de votre PaymentIntent. Sinon, précisez aussi l’[ID](https://docs.stripe.com/api/customers/object.md#customer_object-id) de l’objet Customer.

Si vous souhaitez réutiliser le moyen de paiement dans le futur, fournissez le paramètre [setup_future_usage](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-setup_future_usage) avec la valeur `off_session`.

Pour en savoir plus sur les frais Financial Connections, consultez les [Tarifs](https://stripe.com/financial-connections#pricing).

Par défaut, lors de la collecte des coordonnées bancaires, [Financial Connections](https://docs.stripe.com/financial-connections.md) est utilisé pour vérifier instantanément le compte de votre client. Une option de secours comprenant la saisie manuelle du numéro de compte et la vérification par microversement peut être utilisée. Consultez la [documentation relative à Financial Connections](https://docs.stripe.com/financial-connections/ach-direct-debit-payments.md) pour savoir comment configurer Financial Connections et accéder à des données de compte supplémentaires de façon à optimiser votre intégration ACH. Par exemple, vous pouvez utiliser Financial Connections pour consulter le solde d’un compte avant d’initier le paiement ACH.

> Pour accéder à des données supplémentaires après qu’un client a authentifié son compte, celui-ci doit associer de nouveau son compte avec des autorisations étendues.

#### Accounts&nbsp;v2

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d setup_future_usage=off_session \
  -d "customer_account={{CUSTOMERACCOUNT_ID}}" \
  -d "payment_method_types[]=us_bank_account"
```

#### Customers&nbsp;v1

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d setup_future_usage=off_session \
  -d "customer={{CUSTOMER_ID}}" \
  -d "payment_method_types[]=us_bank_account"
```

### Côté client

Le PaymentIntent renvoyé contient une *clé secrète du client* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)) que vous pouvez envoyer au client pour une exécution sécurisée du processus de paiement au lieu de lui transmettre la totalité de l’objet PaymentIntent. Côté client, demandez un PaymentIntent à votre serveur et sauvegardez la clé secrète du client qu’il contient.

#### Swift

```swift
import UIKit
import StripePayments

class CheckoutViewController: UIViewController {
  var paymentIntentClientSecret: String?

  func startCheckout() {
      // Request a PaymentIntent from your server and store its client secret
  }
}
```

## Configurer une URL de redirection [Côté client]

Le client peut quitter votre application pour s’authentifier (par exemple, dans Safari ou dans son application bancaire). Pour lui permettre de revenir automatiquement sur votre application après s’être authentifié, [configurez un schéma d’URL personnalisé](https://developer.apple.com/documentation/xcode/defining-a-custom-url-scheme-for-your-app) et configurez votre délégué d’application pour qu’il transmette l’URL au SDK. Stripe ne prend pas en charge les [liens universels](https://developer.apple.com/documentation/xcode/allowing-apps-and-websites-to-link-to-your-content).

> Stripe peut ajouter des paramètres supplémentaires à l’URL de redirection fournie. Assurez-vous que les URL de redirection comportant des paramètres supplémentaires ne sont pas rejetées par votre code.

#### SceneDelegate

#### Swift

```swift
// This method handles opening custom URL schemes (for example, "your-app://stripe-redirect")
func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
    guard let url = URLContexts.first?.url else {
        return
    }
    let stripeHandled = StripeAPI.handleURLCallback(with: url)
    if (!stripeHandled) {
        // This was not a Stripe url – handle the URL normally as you would
    }
}

```

#### AppDelegate

#### Swift

```swift
// This method handles opening custom URL schemes (for example, "your-app://stripe-redirect")
func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey: Any] = [:]) -> Bool {
    let stripeHandled = StripeAPI.handleURLCallback(with: url)
    if (stripeHandled) {
        return true
    } else {
        // This was not a Stripe url – handle the URL normally as you would
    }
    return false
}
```

#### SwiftUI

#### Swift

```swift

@main
struct MyApp: App {
  var body: some Scene {
    WindowGroup {
      Text("Hello, world!").onOpenURL { incomingURL in
          let stripeHandled = StripeAPI.handleURLCallback(with: incomingURL)
          if (!stripeHandled) {
            // This was not a Stripe url – handle the URL normally as you would
          }
        }
    }
  }
}
```

## Collecter les informations du moyen de paiement [Côté client]

Pour que le paiement aboutisse avec les prélèvements automatiques ACH, vous devez renseigner un nom de client et son adresse e-mail (facultatif). Dans votre application, collectez les informations de facturation requises auprès de votre client&nbsp;:

- Nom complet (prénom et nom)
- Adresse e-mail

Pour créer vos paramètres requis et appeler `collectBankAccountForPayment`, utilisez la fonction de classe `collectUSBankAccountParams` dans `STPCollectBankAccountParams`. Il est nécessaire d’inclure le nom du titulaire du compte dans le paramètre `billing_details` pour créer un PaymentMethod par prélèvement automatique ACH.

Créez une instance de `STPBankAccountCollector` pour appeler `collectBankAccountForPayment` afin de collecter les coordonnées bancaires, puis créez un *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs), et associez-le au PaymentIntent.

#### Swift

```swift
// Build params
let collectParams = STPCollectBankAccountParams.collectUSBankAccountParams(with: name, email: email)

// (optional) Configure the style
let style: STPBankAccountCollectorUserInterfaceStyle = .alwaysLight
let bankAccountCollector = STPBankAccountCollector(style: style)

// Calling this method will display a modal for collecting bank account information
bankAccountCollector.collectBankAccountForPayment(clientSecret: clientSecret,
                                                  returnURL: "https://your-app-domain.com/stripe-redirect",
                                                  params: collectParams,
                                                  from: self) { intent, error in
    guard let intent = intent else {
        // handle error
        return
    }
    if case .requiresPaymentMethod = intent.status {
        // Customer canceled the Financial Connections modal. Present them with other
        // payment method type options.
    } else if case .requiresConfirmation = intent.status {
        // We collected an account - possibly instantly verified, but possibly
        // manually-entered. Display payment method details and mandate text
        // to the customer and confirm the intent once they accept
        // the mandate.
    }
}
```

Cela charge une fenêtre modale sur la page qui gère la collecte et la vérification des coordonnées bancaires. Une fois le chargement terminé, le *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) est automatiquement associé au PaymentIntent.

## Optional: Accéder aux données sur un compte bancaire Financial Connections [Côté serveur]

Vous ne pouvez accéder aux données Financial Connections que si vous demandez des [autorisations](https://docs.stripe.com/financial-connections/fundamentals.md#data-permissions) d’accès supplémentaires lors de la création de votre PaymentIntent .

Une fois que votre client a terminé le [flux d’authentification Stripe Financial Connections](https://docs.stripe.com/financial-connections/fundamentals.md#authentication-flow), l’objet PaymentMethod `us_bank_account` renvoyé inclut un ID de [financial_connections_account](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-us_bank_account-financial_connections_account) correspondant à un [compte Financial Connections](https://docs.stripe.com/api/financial_connections/accounts.md). Utilisez cet ID pour accéder aux données du compte.

> Les comptes bancaires que vos clients associent par saisie manuelle ou par le biais de microversements n’ont pas d’ID `financial_connections_account` au niveau du moyen de paiement.

Pour déterminer l’ID du compte Financial Connections, récupérez le PaymentIntent et développez l’attribut `payment_method`&nbsp;:

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

```json
{
  "id": "{{PAYMENT_INTENT_ID}}",
  "object": "payment_intent",
  // ...
  "payment_method": {
    "id": "{{PAYMENT_METHOD_ID}}",
    // ...
    "type": "us_bank_account"
    "us_bank_account": {
      "account_holder_type": "individual",
      "account_type": "checking",
      "bank_name": "TEST BANK","financial_connections_account": "{{FINANCIAL_CONNECTIONS_ACCOUNT_ID}}",
      "fingerprint": "q9qchffggRjlX2tb",
      "last4": "6789",
      "routing_number": "110000000"
    }
  }
  // ...
}

```

Si vous avez choisi de recevoir des autorisations `balances`, nous vous recommandons de vérifier l’état du solde à ce moment-là afin de vous assurer de disposer de fonds suffisants avant de confirmer un paiement.

Découvrez comment utiliser des données de compte supplémentaires pour optimiser votre intégration ACH avec [Financial Connections](https://docs.stripe.com/financial-connections/ach-direct-debit-payments.md#optimize).

## Collecter l'accusé de réception du mandat et effectuer le paiement [Côté client]

Avant de pouvoir initier le paiement, vous devez obtenir l’autorisation de votre client. Pour ce faire, présentez-lui les conditions du mandat et demandez-lui de les accepter.

Pour vous conformer aux règles de la *Nacha* (Nacha is the governing body that oversees the ACH network), vous devez obtenir l’autorisation d’initier le paiement auprès de votre client. Pour ce faire, présentez-lui les conditions du mandat et demandez-lui de les accepter. Pour en savoir plus, consultez la page sur les [mandats](https://docs.stripe.com/payments/ach-direct-debit.md#mandates).

Lorsque le client accepte les conditions du mandat, vous devez confirmer le PaymentIntent. Utilisez `confirmPayment` pour mener à bien le paiement une fois que le client a soumis le formulaire.

#### Swift

```swift
let paymentIntentParams = STPPaymentIntentParams(clientSecret: clientSecret,
                                            paymentMethodType: .USBankAccount)

STPPaymentHandler.shared().confirmPayment(
    paymentIntentParams, with: self
) { (status, intent, error) in
    switch status {
    case .failed:
        // Payment failed
    case .canceled:
        // Payment was canceled
    case .succeeded:
        // Payment succeeded
    @unknown default:
        fatalError()
    }
}
```

> `confirmPayment` peut prendre plusieurs secondes pour s’exécuter. Pendant ce temps, désactivez toute nouvelle soumission de votre formulaire et affichez un indicateur d’attente (par exemple un spinner). Si vous recevez une erreur, affichez-la au client, réactivez le formulaire et masquez l’indicateur d’attente.

Sauf échec de l’opération, Stripe renvoie un objet PaymentIntent présentant l’un des états suivants&nbsp;:

| État              | Description                                                                              | Étapes suivantes                                                                                                                                                                     |
| ----------------- | ---------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `requires_action` | Une action supplémentaire est requise pour finaliser la vérification du compte bancaire. | Étape 6&nbsp;: [Vérification des comptes bancaires à l’aide de microversements](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#ios-verify-with-microdeposits) |
| `processing`      | Le compte bancaire a été vérifié instantanément ou la vérification n’est pas nécessaire. | Étape 7&nbsp;: [Confirmation du succès du PaymentIntent](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#ios-confirm-paymentintent-succeeded)                  |

Après avoir confirmé le PaymentIntent, un e-mail de confirmation du mandat et les coordonnées bancaires recueillies doivent être envoyés à votre client. Par défaut, Stripe gère cette étape, mais vous pouvez choisir d’[envoyer des notifications personnalisées](https://docs.stripe.com/payments/ach-direct-debit.md#mandate-and-microdeposit-emails) si vous préférez.

## Vérifier le compte bancaire à l'aide de microversements [Côté client]

Tous les clients ne peuvent pas vérifier instantanément le compte bancaire. Cette étape ne s’applique que si votre client a choisi de se désinscrire du flux de vérification instantanée dans l’étape précédente.

Dans ce cas, Stripe envoie un microversement `descriptor_code` ou `amount` si un problème survient au cours de la vérification du compte bancaire. Ces microversements apparaissent sur le relevé en ligne du client sous 1 à 2&nbsp;jours ouvrables.

- **Code de libellé**&nbsp;: Stripe envoie un microversement unique de 0,01&nbsp;USD sur le compte bancaire du client avec un `descriptor_code` unique à 6&nbsp;chiffres qui commence par SM. Votre client utilise cette chaîne pour vérifier son compte bancaire.
- **Montant**&nbsp;: Stripe envoie deux microversements distincts sur le compte bancaire du client avec un code de libellé indiquant `ACCTVERIFY`. Votre client utilise les montants de ces versements pour vérifier son compte bancaire.

Le résultat de l’appel de méthode `confirmPayment` dans la configuration précédente est un PaymentIntent avec l’état `requires_action`. Le PaymentIntent contient un champ [next_action](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-next_action-verify_with_microdeposits) qui contient des informations utiles à la vérification.

Si vous avez fourni une [adresse e-mail de facturation](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-billing_details-email), Stripe utilise cette dernière pour notifier votre client de la date d’arrivée prévue des versements. L’e-mail envoyé inclut un lien vers la page de vérification hébergée par Stripe, sur laquelle il peut confirmer les montants des versements et effectuer la vérification.

> Les tentatives de vérification sont limitées à dix pour les microversements basés sur des libellés et à trois pour ceux basés sur des montants. Si vous atteignez cette limite, nous ne pouvons plus vérifier le compte bancaire. En outre, les vérifications à l’aide de microversements expirent au bout de 10&nbsp;jours. Si vous ne vérifiez pas les microversements pendant ce laps de temps, le PaymentIntent réitère sa demande d’informations sur le moyen de paiement. En informant clairement vos clients sur le fonctionnement de ces microversements, vous évitez d’éventuels problèmes liés à la vérification.

### Facultatif&nbsp;: Envoyer des notifications personnalisées par e-mail

Vous pouvez également envoyer des [notifications personnalisées par e-mail](https://docs.stripe.com/payments/ach-direct-debit.md#mandate-and-microdeposit-emails) à votre client. Après avoir configuré les e-mails personnalisés, vous devez préciser comment le client doit répondre à l’e-mail de vérification. Pour ce faire, choisissez *une* des options suivantes&nbsp;:

- Utilisez la page de vérification hébergée par Stripe. Pour ce faire, utilisez l’URL `verify_with_microdeposits[hosted_verification_url]` de l’objet [next_action](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-next_action-verify_with_microdeposits-hosted_verification_url) pour diriger votre client vers la procédure de vérification.

- Si vous préférez ne pas utiliser la page de vérification hébergée par Stripe, créez un formulaire dans votre application. Vos clients peuvent ensuite l’utiliser pour vous transmettre les montants des microversements et pour vérifier le compte bancaire à l’aide du SDK iOS.

  - Configurez le formulaire de manière à ce qu’il gère au moins le paramètre `descriptor code`, qui comporte une chaîne à 6&nbsp;chiffres à des fins de vérification.
  - Stripe recommande également de configurer votre formulaire pour gérer le paramètre `amounts`, car certaines banques utilisées par vos clients peuvent l’exiger.

  Les intégrations transmettent uniquement les paramètres `descriptor_code` *ou* `amounts`. Pour savoir lequel utilise votre intégration, vérifiez la valeur de `verify_with_microdeposits[microdeposit_type]` dans l’objet `next_action`.

#### Swift

```swift
// Use if you are using a descriptor code, do not use if you are using amounts
STPAPIClient.shared.verifyPaymentIntentWithMicrodeposits(clientSecret: clientSecret,
                                                         descriptorCode: descriptorCode,
                                                         completion: { intent, error in
})

// Use if you are using amounts, do not use if you are using descriptor code
STPAPIClient.shared.verifyPaymentIntentWithMicrodeposits(clientSecret: clientSecret,
                                                         firstAmount: firstAmount,
                                                         secondAmount: secondAmount,
                                                         completion: { intent, error in
})
```

Lorsque le compte bancaire est vérifié, Stripe renvoie l’objet PaymentIntent avec un `status` défini sur `processing`.

La vérification peut échouer pour différentes raisons. L’échec se produit de manière synchrone et vous en êtes informé par un message d’erreur.

```json
{
  "error": {
    "code": "payment_method_microdeposit_verification_amounts_mismatch",
    "message": "The amounts provided do not match the amounts that were sent to the bank account. You have {attempts_remaining} verification attempts remaining.",
    "type": "invalid_request_error"
  }
}
```

| Code d’erreur                                                | Message                                                                                                                                       | Changement d’état                                                                                |
| ------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
| `payment_method_microdeposit_failed`                         | Les microversements ont échoué. Veuillez vérifier la validité des numéros de compte, d’établissement et de transit fournis.                   | `status` est à l’état `requires_payment_method` et le paramètre `last_payment_error` est défini. |
| `payment_method_microdeposit_verification_amounts_mismatch`  | Les montants fournis ne correspondent pas à ceux envoyés au compte bancaire. Il vous reste {attempts_remaining} tentative(s) de vérification. | Inchangé                                                                                         |
| `payment_method_microdeposit_verification_attempts_exceeded` | Nombre de tentatives de vérification autorisées dépassé                                                                                       | `status` est à l’état `requires_payment_method` et le paramètre `last_payment_error` est défini. |

## Confirmer l'aboutissement du PaymentIntent [Côté serveur]

Le prélèvement automatique ACH est un moyen de paiement à [notification différée](https://docs.stripe.com/payments/payment-methods.md#payment-notification). Ceci signifie que pour recevoir une notification du succès ou de l’échec d’un paiement, il faut compter jusqu’à quatre jours ouvrables après le déclenchement du prélèvement sur le compte du client.

Initialement, le PaymentIntent que vous créez présente l’état `processing`. Une fois le paiement abouti, l’état du PaymentIntent passe de `processing` à `succeeded`.

Nous vous recommandons d’utiliser des [webhooks](https://docs.stripe.com/payments/payment-intents/verifying-status.md#webhooks) afin de *confirmer* (Confirming an intent indicates that the customer intends to use the current or provided payment method. Upon confirmation, the intent attempts to initiate the portions of the flow that have real-world side effects) que le paiement a réussi et d’informer le client que le paiement a été effectué. Vous pouvez également afficher les événements sur le [Dashboard Stripe](https://dashboard.stripe.com/events).

#### Événements PaymentIntent

Les événements suivants sont envoyés lorsque le PaymentIntent change d’état&nbsp;:

| Événement                       | Description                                                                                                                    | Étape suivante                                                                                                                                                                                                                                                                                                                       |
| ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `payment_intent.processing`     | Le paiement du client a bien été envoyé à Stripe.                                                                              | Attendez que le paiement aboutisse ou échoue.                                                                                                                                                                                                                                                                                        |
| `payment_intent.succeeded`      | Le paiement du client a abouti.                                                                                                | Traitez la commande de biens ou de services.                                                                                                                                                                                                                                                                                         |
| `payment_intent.payment_failed` | Le paiement du client a été refusé. Ceci peut aussi s’appliquer en cas d’échec de la vérification à l’aide de microversements. | Envoyez un e-mail ou une notification push au client pour lui demander d’utiliser un autre moyen de paiement. Si le webhook a été envoyé suite à l’échec de la vérification à l’aide de micro-versements, l’utilisateur doit à nouveau saisir ses coordonnées bancaires. De nouveaux micro-versements seront déposés sur son compte. |

#### Événements de paiement

Vous pouvez également utiliser des webhooks Charge supplémentaires pour suivre l’état du paiement. Dès réception du webhook `charge.updated`, le paiement ne peut plus être annulé.

Les événements suivants sont envoyés lorsque le paiement change d’état&nbsp;:

| Événement          | Description                                                                                                                                                                           | Étape suivante                                                                                 |
| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- |
| `charge.pending`   | Le paiement du client a bien été créé.                                                                                                                                                | Attendez que le paiement initié soit traité.                                                   |
| `charge.updated`   | Le paiement du client a été mis à jour. Il peut être émis lorsqu’une nouvelle opération sur solde est créée, qu’une description ou que des métadonnées de paiement sont mises à jour. | Attendez que le paiement aboutisse ou échoue.                                                  |
| `charge.succeeded` | Le paiement du client a abouti et les fonds sont disponibles sur votre solde.                                                                                                         | Traitez la commande de biens ou de services.                                                   |
| `charge.failed`    | Le paiement du client a échoué.                                                                                                                                                       | Vérifiez le failure_code et le failure_message du paiement pour déterminer la marche à suivre. |

## Tester votre intégration

Découvrez comment tester des scénarios avec des vérifications instantanées à l’aide de [Financial Connections](https://docs.stripe.com/financial-connections/testing.md#web-how-to-use-test-accounts).

### Envoyer des e-mails de transaction dans un environnement de test

Une fois que vous avez collecté les coordonnées bancaires et accepté un mandat, envoyez les courriels de confirmation du mandat et de vérification du microversement dans un *environnement de bac à sable* (A sandbox is an isolated test environment that allows you to test Stripe functionality in your account without affecting your live integration. Use sandboxes to safely experiment with new features and changes).

Si votre domaine est **{domain}** et votre nom d’utilisateur est **{username}**, utilisez le format d’adresse e-mail suivant pour envoyer des e-mails de transaction de test&nbsp;: **{username}+test\_email@{domain}**.

Par exemple, si votre domaine est **example.com** et que votre nom d’utilisateur est **info**, utilisez le format **info+test\_email@example.com** pour tester les paiements ACH Direct Debit. Ce format garantit que les e-mails sont acheminés correctement. Si vous n’incluez pas le suffixe **+test\_email**, nous n’enverrons pas l’e-mail.

> Vous devez [configurer votre compte Stripe](https://docs.stripe.com/get-started/account/set-up.md) avant de pouvoir déclencher ces e-mails pendant les tests.

### Numéros de comptes de test

Stripe fournit plusieurs numéros de compte de test et les tokens correspondants que vous pouvez utiliser pour vous assurer que votre intégration pour les comptes bancaires saisis manuellement est prête à passer en mode production.

| Numéro de compte | Token                                  | Numéro de routage | Comportement                                                                                                                                                                                                                                                                                                         |
| ---------------- | -------------------------------------- | ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `000123456789`   | `pm_usBankAccount_success`             | `110000000`       | Le paiement aboutit.                                                                                                                                                                                                                                                                                                 |
| `000111111113`   | `pm_usBankAccount_accountClosed`       | `110000000`       | Le paiement échoue parce que le compte est clôturé.                                                                                                                                                                                                                                                                  |
| `000000004954`   | `pm_usBankAccount_riskLevelHighest`    | `110000000`       | Le paiement est bloqué par Radar en raison d’un [risque élevé de fraude](https://docs.stripe.com/radar/risk-evaluation.md#high-risk).                                                                                                                                                                                |
| `000111111116`   | `pm_usBankAccount_noAccount`           | `110000000`       | Le paiement échoue car aucun compte n’est trouvé.                                                                                                                                                                                                                                                                    |
| `000222222227`   | `pm_usBankAccount_insufficientFunds`   | `110000000`       | Le paiement échoue en raison de fonds insuffisants.                                                                                                                                                                                                                                                                  |
| `000333333335`   | `pm_usBankAccount_debitNotAuthorized`  | `110000000`       | Le paiement échoue parce que les débits ne sont pas autorisés.                                                                                                                                                                                                                                                       |
| `000444444440`   | `pm_usBankAccount_invalidCurrency`     | `110000000`       | Le paiement échoue en raison d’une devise non valide.                                                                                                                                                                                                                                                                |
| `000666666661`   | `pm_usBankAccount_failMicrodeposits`   | `110000000`       | Le paiement ne parvient pas à envoyer les microversements.                                                                                                                                                                                                                                                           |
| `000555555559`   | `pm_usBankAccount_dispute`             | `110000000`       | Le paiement déclenche un litige.                                                                                                                                                                                                                                                                                     |
| `000000000009`   | `pm_usBankAccount_processing`          | `110000000`       | Le traitement du paiement est indéfini. Utile pour tester {&nbsp;% si $checkoutSessions %}[Expiration de la session de paiement](https://docs.stripe.com/api/checkout/sessions/expire.md){&nbsp;% else /&nbsp;%}[Annulation de PaymentIntent](https://docs.stripe.com/api/payment_intents/cancel.md){&nbsp;% /if %}. |
| `000777777771`   | `pm_usBankAccount_weeklyLimitExceeded` | `110000000`       | Le paiement échoue, car son montant entraîne un dépassement de la limite hebdomadaire de volume de paiement du compte.                                                                                                                                                                                               |
| `000888888885`   |                                        | `110000000`       | Le paiement échoue en raison d’un [numéro de compte tokenisé](https://docs.stripe.com/financial-connections/tokenized-account-numbers.md) désactivé.                                                                                                                                                                 |

Avant d’effectuer les transactions de test, vous devez vérifier tous les comptes de test pour lesquels le paiement aboutit ou échoue automatiquement. Pour ce faire, utilisez les codes de libellé ou les montants de microversements de test ci-dessous.

### Tester des codes de libellé et des montants de microversements

Pour simuler différents scénarios, utilisez ces montants de microversements *ou* ces codes de libellé 0.01.

| Valeurs de microversement | Valeurs de code de libellé 0.01 | Scénario                                                                |
| ------------------------- | ------------------------------- | ----------------------------------------------------------------------- |
| `32` et `45`              | SM11AA                          | Simule la vérification du compte.                                       |
| `10` et `11`              | SM33CC                          | Simule le dépassement du nombre de tentatives de vérification autorisé. |
| `40` et `41`              | SM44DD                          | Simule l’expiration du délai de validité d’un microversement.           |

### Comportement de règlement des tests

Les transactions de test sont réglées instantanément et ajoutées à votre solde de test disponible. Ce comportement diffère de celui du mode production, où les transactions peuvent prendre [plusieurs jours](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#timing) pour être réglées dans votre solde disponible.

## Optional: Vérification instantanée uniquement [Côté serveur]

Par défaut, le paiement à l’aide d’un compte bancaire américain permet à vos clients d’utiliser la vérification instantanée du compte bancaire ou les microversements. Vous pouvez aussi exiger la vérification instantanée du compte bancaire uniquement en utilisant le paramètre [verification_method](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-us_bank_account-verification_method) à la création du PaymentIntent.

#### Accounts&nbsp;v2

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d setup_future_usage=off_session \
  -d "customer_account={{CUSTOMERACCOUNT_ID}}" \
  -d "payment_method_types[]=us_bank_account" \
  -d "payment_method_options[us_bank_account][verification_method]=instant" \
  -d "payment_method_options[us_bank_account][financial_connections][permissions][]=payment_method" \
  -d "payment_method_options[us_bank_account][financial_connections][permissions][]=balances"
```

#### Customers&nbsp;v1

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d setup_future_usage=off_session \
  -d "customer={{CUSTOMER_ID}}" \
  -d "payment_method_types[]=us_bank_account" \
  -d "payment_method_options[us_bank_account][verification_method]=instant" \
  -d "payment_method_options[us_bank_account][financial_connections][permissions][]=payment_method" \
  -d "payment_method_options[us_bank_account][financial_connections][permissions][]=balances"
```

Ainsi, vous n’avez pas besoin de gérer la vérification à l’aide de microversements. Cependant, si la vérification instantanée échoue, l’état du PaymentIntent est `requires_payment_method`, indiquant l’échec de la vérification instantanée du compte bancaire de votre client.

## Optional: Vérification à l'aide de microversements uniquement [Côté serveur]

Par défaut, le paiement à l’aide d’un compte bancaire américain permet à vos clients d’utiliser la vérification instantanée du compte bancaire ou les microversements. Vous pouvez aussi exiger la vérification du compte bancaire à l’aide de microversements uniquement en utilisant le paramètre [verification_method](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-us_bank_account-verification_method) à la création du PaymentIntent.

> Si vous utilisez un formulaire de paiement personnalisé, vous devez développer votre propre interface utilisateur pour collecter les coordonnées bancaires des clients. De la même manière, si vous désactivez l’envoi d’e-mails par Stripe en cas de microversements, vous devez développer votre propre interface utilisateur pour que votre client puisse confirmer le code ou le montant du microversement.

#### Accounts&nbsp;v2

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d setup_future_usage=off_session \
  -d "customer_account={{CUSTOMERACCOUNT_ID}}" \
  -d "payment_method_types[]=us_bank_account" \
  -d "payment_method_options[us_bank_account][verification_method]=microdeposits"
```

#### Customers&nbsp;v1

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d setup_future_usage=off_session \
  -d "customer={{CUSTOMER_ID}}" \
  -d "payment_method_types[]=us_bank_account" \
  -d "payment_method_options[us_bank_account][verification_method]=microdeposits"
```

Collectez ensuite le compte bancaire de votre client avec votre propre formulaire et appelez [stripe.confirmUsBankAccountPayment](https://docs.stripe.com/js/payment_intents/confirm_us_bank_account_payment) avec ces informations pour mener à bien le PaymentIntent.

```javascript
var form = document.getElementById('payment-form');
var accountholderName = document.getElementById('accountholder-name');
var email = document.getElementById('email');
var accountNumber = document.getElementById('account-number');
var routingNumber = document.getElementById('routing-number');
var accountHolderType= document.getElementById('account-holder-type');

var submitButton = document.getElementById('submit-button');
var clientSecret = submitButton.dataset.secret;

form.addEventListener('submit', function(event) {
  event.preventDefault();

  stripe.confirmUsBankAccountPayment(clientSecret, {
    payment_method: {
      billing_details: {
        name: accountholderName.value,
        email: email.value,
      },
      us_bank_account: {
        account_number: accountNumber.value,
        routing_number: routingNumber.value,
        account_holder_type: accountHolderType.value, // 'individual' or 'company'
      },
    },
  })
  .then(({paymentIntent, error}) => {
    if (error) {
      // Inform the customer that there was an error.
      console.log(error.message);
    } else {
      // Handle next step based on the intent's status.
      console.log("PaymentIntent ID: " + paymentIntent.id);
      console.log("PaymentIntent status: " + paymentIntent.status);
    }
  });
});
```

## Optional: Référence du paiement

Le numéro de référence du paiement est une valeur générée par la banque qui permet au titulaire du compte bancaire d’utiliser sa banque pour localiser des fonds. Lorsque le paiement aboutit, Stripe fournit le numéro de référence du paiement dans le Dashboard, ainsi que dans l’[objet Charge](https://docs.stripe.com/api/charges/object.md).

| État du paiement | Valeur de référence du paiement           |
| ---------------- | ----------------------------------------- |
| En attente       | Indisponibles                             |
| En échec         | Indisponibles                             |
| Réussi           | Disponible (par exemple, 091000015001234) |

De plus, lorsque vous recevez le webhook `charge.succeeded`, consultez le contenu de `payment_method_details` pour localiser la [payment_reference](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-us_bank_account-payment_reference).

L’exemple d’événement suivant montre le rendu d’un paiement ACH abouti avec un numéro de référence de paiement.

#### charge-succeeded

```json
{
  "id": "{{EVENT_ID}}",
  "object": "event",
  // omitted some fields in the example
  "type": "charge.succeeded",
  "data": {
    "object": {
      "id": "{{PAYMENT_ID}}",
      "object": "charge",
      //...
    "paid": true,
    "payment_intent": "{{PAYMENT_INTENT_ID}}",
    "payment_method": "{{PAYMENT_METHOD_ID}}",
    "payment_method_details": {
      "type": "us_bank_account",
      "us_bank_account": {
        "account_holder_type": "individual",
        "account_type": "checking",
        "bank_name": "TEST BANK",
        "fingerprint": "Ih3foEnRvLXShyfB",
        "last4": "1000","payment_reference": "091000015001234",
        "routing_number": "110000000"
        }
      }
      // ...
    }
  }
}
```

Consultez le contenu de `destination_details` pour localiser la [référence du remboursement](https://docs.stripe.com/api/refunds/object.md#refund_object-destination_details-us_bank_transfer-reference) associée aux paiements ACH remboursés.

L’exemple d’événement suivant montre le rendu d’un remboursement de paiement ACH abouti avec un numéro de référence de remboursement. En savoir plus sur les [remboursements](https://docs.stripe.com/refunds.md).

#### charge-refund-updated

```json
{
  "id": "{{EVENT_ID}}",
  "object": "event",
  "type": "charge.refund.updated",
  "data": {
    "object": {
      "id": "{{REFUND_ID}}",
      "object": "refund",
      //...
    "payment_intent": "{{PAYMENT_INTENT_ID}}",
    "destination_details": {
      "type": "us_bank_transfer",
      "us_bank_transfer": {"reference": "091000015001111",
        "reference_status": "available"
        }
      }
      // ...
    }
  }
}
```

## See also

- [Enregistrer les coordonnées de prélèvement automatique ACH pour les futurs paiements](https://docs.stripe.com/payments/ach-direct-debit/set-up-payment.md)


# Android

> This is a Android for when payment-ui is mobile and platform is android. View the full page at https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment?payment-ui=mobile&platform=android.

> #### Utiliser l’API Accounts v2 pour représenter les clients
> 
> L’API Accounts&nbsp;v2 est généralement disponible pour les utilisateurs de Connect et en aperçu public pour les autres utilisateurs de Stripe. Si vous avez accès à l’aperçu Accounts&nbsp;v2, vous devez [spécifier une version d’aperçu](https://docs.stripe.com/api-v2-overview.md#sdk-and-api-versioning) dans votre code.
> 
> Pour demander l’accès à l’aperçu Accounts&nbsp;v2, 
> 
> Dans la plupart des cas d’usage, nous vous recommandons de [modéliser vos clients en tant qu’objets Account configurés par le client](https://docs.stripe.com/connect/use-accounts-as-customers.md), plutôt que d’utiliser des objets [Customer](https://docs.stripe.com/api/customers.md).

Voici les différentes étapes nécessaires pour accepter des paiements par prélèvement automatique ACH sur votre application&nbsp;:

- Création d’un objet de suivi du paiement
- Collecter des informations sur un moyen de paiement avec les vérifications instantanées activées par [Stripe Financial Connections](https://docs.stripe.com/financial-connections.md)
- Soumission du paiement à Stripe à des fins de traitement
- Vérification du compte bancaire de votre client

> Le prélèvement automatique ACH est un moyen de paiement à [notification différée](https://docs.stripe.com/payments/payment-methods.md#payment-notification), ce qui signifie que les fonds ne sont pas immédiatement disponibles après le paiement. Il faut généralement compter 4&nbsp;jours ouvrables pour qu’un paiement arrive sur votre compte.

Stripe utilise l’objet de paiement, le [Payment Intent](https://docs.stripe.com/payments/payment-intents.md), pour suivre et gérer l’ensemble des états du paiement jusqu’à son aboutissement.

Le [SDK Stripe Android](https://github.com/stripe/stripe-android) est disponible en open source et [fait l’objet d’une documentation complète](https://stripe.dev/stripe-android/).

Pour installer le SDK, ajoutez `stripe-android` et `financial-connections` au bloc `dependencies` de votre fichier [app/build.gradle](https://developer.android.com/studio/build/dependencies)&nbsp;:

#### Kotlin

```kotlin
plugins {
    id("com.android.application")
}

android { ... }

dependencies {
  // ...

  // Stripe Android SDK
  implementation("com.stripe:stripe-android:23.5.0")
  // Include the financial connections SDK to support US bank account as a payment method
  implementation("com.stripe:financial-connections:23.5.0")

  // Financial Connections SDK
  implementation("com.stripe:financial-connections:23.5.0")
}
```

> Pour obtenir de plus amples informations sur la version la plus récente du SDK et ses versions antérieures, consultez la page des [versions](https://github.com/stripe/stripe-android/releases) sur GitHub. Pour savoir quand une nouvelle version est disponible, [surveillez les versions du référentiel](https://docs.github.com/en/github/managing-subscriptions-and-notifications-on-github/configuring-notifications#configuring-your-watch-settings-for-an-individual-repository).

Configurez le SDK avec votre [clé publique](https://dashboard.stripe.com/apikeys) Stripe de façon à ce qu’il puisse envoyer des requêtes à l’API Stripe, par exemple à la sous-classe `Application`&nbsp;:

#### Kotlin

```kotlin
import com.stripe.android.PaymentConfiguration

class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        PaymentConfiguration.init(
            applicationContext,
            "<<YOUR_PUBLISHABLE_KEY>>"
        )
    }
}
```

> Utilisez vos [clés de test](https://docs.stripe.com/keys.md#obtain-api-keys) lors de vos activités de test et de développement et vos clés du [mode production](https://docs.stripe.com/keys.md#test-live-modes) pour la publication de votre application.

## Créer ou récupérer un objet Customer [Recommandé] [Côté serveur]

> #### Utiliser l’API Accounts v2 pour représenter les clients
> 
> L’API Accounts&nbsp;v2 est généralement disponible pour les utilisateurs de Connect et en aperçu public pour les autres utilisateurs de Stripe. Si vous avez accès à l’aperçu Accounts&nbsp;v2, vous devez [spécifier une version d’aperçu](https://docs.stripe.com/api-v2-overview.md#sdk-and-api-versioning) dans votre code.
> 
> Pour demander l’accès à l’aperçu Accounts&nbsp;v2, 
> 
> Dans la plupart des cas d’usage, nous vous recommandons de [modéliser vos clients en tant qu’objets Account configurés par le client](https://docs.stripe.com/connect/use-accounts-as-customers.md), plutôt que d’utiliser des objets [Customer](https://docs.stripe.com/api/customers.md).

#### Accounts&nbsp;v2

Créez un objet [Account](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-configuration-customer) configuré par le client lorsque votre utilisateur crée un compte auprès de votre entreprise, ou récupérez un `Account` existant associé à cet utilisateur. L’association de l’ID de l’objet `Account` à votre propre représentation interne d’un client vous permet de récupérer et d’utiliser ultérieurement les informations de moyen de paiement enregistrées. Ajoutez une adresse e-mail à l’`objet Account` pour activer [l’optimisation des utilisateurs connus](https://docs.stripe.com/financial-connections/fundamentals.md#return-user-optimization) de Financial Connections.

```curl
curl -X POST https://api.stripe.com/v2/core/accounts \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-03-25.preview" \
  --json '{
    "contact_email": "{{CUSTOMER_EMAIL}}"
  }'
```

#### Customers&nbsp;v1

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) lorsque votre client crée un compte auprès de votre entreprise, ou récupérez l’objet `Customer` existant associé à cet utilisateur. L’association de l’ID de l’objet `Customer` à votre propre représentation interne d’un client vous permet de récupérer et d’utiliser ultérieurement les informations de paiement enregistrées. Ajoutez une adresse e-mail à l’objet `Customer` pour activer [l’optimisation des utilisateurs connus](https://docs.stripe.com/financial-connections/fundamentals.md#return-user-optimization) de Financial Connections.

```curl
curl https://api.stripe.com/v1/customers \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d email={{CUSTOMER_EMAIL}}
```

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

Un [PaymentIntent](https://docs.stripe.com/api/payment_intents.md) est un objet qui représente votre intention d’encaisser le paiement d’un client et qui suit le cycle de vie du processus de paiement étape par étape.

### Côté serveur

Tout d’abord, créez un PaymentIntent sur votre serveur et spécifiez le montant à collecter et la devise `usd`. Si vous possédez déjà une autre intégration utilisant l’API Payment Intents, ajoutez `us_bank_account` à la liste des [types de moyens de paiement](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) de votre PaymentIntent. Sinon, précisez aussi l’[ID](https://docs.stripe.com/api/customers/object.md#customer_object-id) de l’objet Customer.

Si vous souhaitez réutiliser le moyen de paiement dans le futur, fournissez le paramètre [setup_future_usage](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-setup_future_usage) avec la valeur `off_session`.

Pour en savoir plus sur les frais Financial Connections, consultez les [Tarifs](https://stripe.com/financial-connections#pricing).

Par défaut, lors de la collecte des coordonnées bancaires, [Financial Connections](https://docs.stripe.com/financial-connections.md) est utilisé pour vérifier instantanément le compte de votre client. Une option de secours comprenant la saisie manuelle du numéro de compte et la vérification par microversement peut être utilisée. Consultez la [documentation relative à Financial Connections](https://docs.stripe.com/financial-connections/ach-direct-debit-payments.md) pour savoir comment configurer Financial Connections et accéder à des données de compte supplémentaires de façon à optimiser votre intégration ACH. Par exemple, vous pouvez utiliser Financial Connections pour consulter le solde d’un compte avant d’initier le paiement ACH.

> Pour accéder à des données supplémentaires après qu’un client a authentifié son compte, celui-ci doit associer de nouveau son compte avec des autorisations étendues.

#### Accounts&nbsp;v2

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d setup_future_usage=off_session \
  -d "customer_account={{CUSTOMERACCOUNT_ID}}" \
  -d "payment_method_types[]=us_bank_account"
```

#### Customers&nbsp;v1

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d setup_future_usage=off_session \
  -d "customer={{CUSTOMER_ID}}" \
  -d "payment_method_types[]=us_bank_account"
```

### Côté client

Le PaymentIntent renvoyé contient une *clé secrète du client* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)) que vous pouvez envoyer au client pour une exécution sécurisée du processus de paiement au lieu de lui transmettre la totalité de l’objet PaymentIntent. Côté client, demandez un PaymentIntent à votre serveur et sauvegardez la clé secrète du client qu’il contient.

#### Kotlin

```kotlin
import androidx.appcompat.app.AppCompatActivity

class CheckoutActivity : AppCompatActivity() {
    private lateinit var paymentIntentClientSecret: String

    fun startCheckout() {
        // Request a PaymentIntent from your server and store its client secret
    }
}
```

## Collecter les informations du moyen de paiement [Côté client]

Pour que le paiement aboutisse avec les prélèvements automatiques ACH, vous devez renseigner un nom de client et son adresse e-mail (facultatif). Dans votre application, collectez les informations de facturation requises auprès de votre client&nbsp;:

- Nom complet (prénom et nom)
- Adresse e-mail

Utilisez `CollectBankAccountConfiguration.USBankAccount` pour créer les paramètres requis pour appeler `presentWithPaymentIntent`.

Initialisez une instance `CollectBankAccountLauncher` dans la méthode onCreate de votre activité Checkout, en transférant une méthode pour gérer le résultat. Poursuivez alors avec un appel à `presentWithPaymentIntent`afin de collecter les coordonnées bancaires, de créer un *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) et d’associer la PaymentMethod à la PaymentIntent.

#### Kotlin

```kotlin
import androidx.appcompat.app.AppCompatActivity

class CheckoutActivity : AppCompatActivity() {
    private lateinit var paymentIntentClientSecret: String
    private lateinit var collectBankAccountLauncher CollectBankAccountLauncher

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Create collector
        collectBankAccountLauncher = CollectBankAccountLauncher.create(
            this
        ) { result: CollectBankAccountResult ->
            when (result) {
                is CollectBankAccountResult.Completed -> {
                    val intent = result.response.intent
                    if (intent.status === StripeIntent.Status.RequiresPaymentMethod) {
                        // Customer canceled the Financial Connections modal. Present them with other
                        // payment method type options.
                    } else if (intent.status === StripeIntent.Status.RequiresConfirmation) {
                        // We collected an account - possibly instantly verified, but possibly
                        // manually-entered. Display payment method details and mandate text
                        // to the customer and confirm the intent once they accept
                        // the mandate.
                    }
                }
                is CollectBankAccountResult.Cancelled -> {
                    // handle cancellation
                }
                is CollectBankAccountResult.Failed -> {
                    // handle error
                    print("Error: ${result.error}")
                }
            }
        }
    }

    fun startCheckout() {
        // ...

        // Build params
        val configuration: CollectBankAccountConfiguration =
            CollectBankAccountConfiguration.USBankAccount(
                name,
                email
            )

        // Calling this method will trigger the Financial Connections modal to be displayed
        collectBankAccountLauncher.presentWithPaymentIntent(
            publishableKey,
            paymentIntentClientSecret,
            collectParams
        )
    }
}
```

Cela charge une fenêtre modale sur la page qui gère la collecte et la vérification des coordonnées bancaires. Une fois le chargement terminé, le *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) est automatiquement associé au PaymentIntent.

## Optional: Personnaliser le formulaire [Côté client]

### Mode sombre

Par défaut, `CollectBankAccountLauncher` s’ajuste automatiquement en fonction des paramètres d’affichage du système de l’utilisateur (mode clair et foncé). Vous pouvez changer cela en définissant le mode clair ou sombre dans votre application&nbsp;:

#### Kotlin

```kotlin
// force dark
AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_YES)
// force light
AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_NO)
```

## Optional: Accéder aux données sur un compte bancaire Financial Connections [Côté serveur]

Vous ne pouvez accéder aux données Financial Connections que si vous demandez des [autorisations](https://docs.stripe.com/financial-connections/fundamentals.md#data-permissions) d’accès supplémentaires lors de la création de votre PaymentIntent .

Une fois que votre client a terminé le [flux d’authentification Stripe Financial Connections](https://docs.stripe.com/financial-connections/fundamentals.md#authentication-flow), l’objet PaymentMethod `us_bank_account` renvoyé inclut un ID de [financial_connections_account](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-us_bank_account-financial_connections_account) correspondant à un [compte Financial Connections](https://docs.stripe.com/api/financial_connections/accounts.md). Utilisez cet ID pour accéder aux données du compte.

> Les comptes bancaires que vos clients associent par saisie manuelle ou par le biais de microversements n’ont pas d’ID `financial_connections_account` au niveau du moyen de paiement.

Pour déterminer l’ID du compte Financial Connections, récupérez le PaymentIntent et développez l’attribut `payment_method`&nbsp;:

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

```json
{
  "id": "{{PAYMENT_INTENT_ID}}",
  "object": "payment_intent",
  // ...
  "payment_method": {
    "id": "{{PAYMENT_METHOD_ID}}",
    // ...
    "type": "us_bank_account"
    "us_bank_account": {
      "account_holder_type": "individual",
      "account_type": "checking",
      "bank_name": "TEST BANK","financial_connections_account": "{{FINANCIAL_CONNECTIONS_ACCOUNT_ID}}",
      "fingerprint": "q9qchffggRjlX2tb",
      "last4": "6789",
      "routing_number": "110000000"
    }
  }
  // ...
}

```

Si vous avez choisi de recevoir des autorisations `balances`, nous vous recommandons de vérifier l’état du solde à ce moment-là afin de vous assurer de disposer de fonds suffisants avant de confirmer un paiement.

Découvrez comment utiliser des données de compte supplémentaires pour optimiser votre intégration ACH avec [Financial Connections](https://docs.stripe.com/financial-connections/ach-direct-debit-payments.md#optimize).

## Collecter l'accusé de réception du mandat et effectuer le paiement [Côté client]

Avant de pouvoir initier le paiement, vous devez obtenir l’autorisation de votre client. Pour ce faire, présentez-lui les conditions du mandat et demandez-lui de les accepter.

Pour vous conformer aux règles de la *Nacha* (Nacha is the governing body that oversees the ACH network), vous devez obtenir l’autorisation d’initier le paiement auprès de votre client. Pour ce faire, présentez-lui les conditions du mandat et demandez-lui de les accepter. Pour en savoir plus, consultez la page sur les [mandats](https://docs.stripe.com/payments/ach-direct-debit.md#mandates).

Lorsque le client accepte les conditions du mandat, vous devez confirmer le Payment. Utilisez `confirm` pour mener à bien le paiement une fois que le client a soumis le formulaire.

#### Kotlin

```kotlin
class CheckoutActivity : AppCompatActivity() {
    // ...
    private lateinit var paymentIntentClientSecret: String
    private val paymentLauncher: PaymentLauncher by lazy {
        val paymentConfiguration = PaymentConfiguration.getInstance(applicationContext)
        PaymentLauncher.Companion.create(
            this,
            paymentConfiguration.publishableKey,
            paymentConfiguration.stripeAccountId,
            ::onPaymentResult
        )
    }

    private fun startCheckout() {
        // ...

        val confirmParams = ConfirmPaymentIntentParams.create(
            clientSecret = paymentIntentClientSecret,
            paymentMethodType = PaymentMethod.Type.USBankAccount
        )
        paymentLauncher.confirm(confirmParams)
    }

    private fun onPaymentResult(paymentResult: PaymentResult) {
        when (paymentResult) {
            is PaymentResult.Completed -> {
                // show success UI
            }
            is PaymentResult.Canceled -> {
                // handle cancel flow
            }
            is PaymentResult.Failed -> {
                // handle failures
                // (for example, the customer might need to choose a new payment
                // method)
            }
        }
    }
}
```

> `confirm` peut prendre plusieurs secondes pour s’exécuter. Pendant ce temps, désactivez toute nouvelle soumission de votre formulaire et affichez un indicateur d’attente (par exemple un spinner). Si vous recevez une erreur, affichez-la au client, réactivez le formulaire et masquez l’indicateur d’attente.

Sauf échec de l’opération, Stripe renvoie un objet PaymentIntent présentant l’un des états suivants&nbsp;:

| État              | Description                                                                              | Étapes suivantes                                                                                                                                                                         |
| ----------------- | ---------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `requires_action` | Une action supplémentaire est requise pour finaliser la vérification du compte bancaire. | Étape 5&nbsp;: [Vérification des comptes bancaires à l’aide de microversements](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#android-verify-with-microdeposits) |
| `processing`      | Le compte bancaire a été vérifié instantanément ou la vérification n’est pas nécessaire. | Étape 6&nbsp;: [Confirmation du succès du PaymentIntent](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#android-confirm-paymentintent-succeeded)                  |

Après avoir confirmé Payment, un e-mail de confirmation du mandat et les coordonnées bancaires recueillies doivent être envoyés à votre client. Par défaut, Stripe gère cette étape, mais vous pouvez choisir d’[envoyer des notifications personnalisées](https://docs.stripe.com/payments/ach-direct-debit.md#mandate-and-microdeposit-emails) si vous préférez.

## Vérifier le compte bancaire à l'aide de microversements [Côté client]

Tous les clients ne peuvent pas vérifier instantanément le compte bancaire. Cette étape ne s’applique que si votre client a choisi de se désinscrire du flux de vérification instantanée dans l’étape précédente.

Dans ce cas, Stripe envoie un microversement `descriptor_code` ou `amount` si un problème survient au cours de la vérification du compte bancaire. Ces microversements apparaissent sur le relevé en ligne du client sous 1 à 2&nbsp;jours ouvrables.

- **Code de libellé**&nbsp;: Stripe envoie un microversement unique de 0,01&nbsp;USD sur le compte bancaire du client avec un `descriptor_code` unique à 6&nbsp;chiffres qui commence par SM. Votre client utilise cette chaîne pour vérifier son compte bancaire.
- **Montant**&nbsp;: Stripe envoie deux microversements distincts sur le compte bancaire du client avec un code de libellé indiquant `ACCTVERIFY`. Votre client utilise les montants de ces versements pour vérifier son compte bancaire.

Le résultat de l’appel de méthode `confirmPayment` dans la configuration précédente est un PaymentIntent avec l’état `requires_action`. Le PaymentIntent contient un champ [next_action](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-next_action-verify_with_microdeposits) qui contient des informations utiles à la vérification.

Si vous avez fourni une [adresse e-mail de facturation](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-billing_details-email), Stripe utilise cette dernière pour notifier votre client de la date d’arrivée prévue des versements. L’e-mail envoyé inclut un lien vers la page de vérification hébergée par Stripe, sur laquelle il peut confirmer les montants des versements et effectuer la vérification.

> Les tentatives de vérification sont limitées à dix pour les microversements basés sur des libellés et à trois pour ceux basés sur des montants. Si vous atteignez cette limite, nous ne pouvons plus vérifier le compte bancaire. En outre, les vérifications à l’aide de microversements expirent au bout de 10&nbsp;jours. Si vous ne vérifiez pas les microversements pendant ce laps de temps, le PaymentIntent réitère sa demande d’informations sur le moyen de paiement. En informant clairement vos clients sur le fonctionnement de ces microversements, vous évitez d’éventuels problèmes liés à la vérification.

### Facultatif&nbsp;: Envoyer des notifications personnalisées par e-mail

Vous pouvez également envoyer des [notifications personnalisées par e-mail](https://docs.stripe.com/payments/ach-direct-debit.md#mandate-and-microdeposit-emails) à votre client. Après avoir configuré les e-mails personnalisés, vous devez préciser comment le client doit répondre à l’e-mail de vérification. Pour ce faire, choisissez *une* des options suivantes&nbsp;:

- Utilisez la page de vérification hébergée par Stripe. Pour ce faire, utilisez l’URL `verify_with_microdeposits[hosted_verification_url]` de l’objet [next_action](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-next_action-verify_with_microdeposits-hosted_verification_url) pour diriger votre client vers la procédure de vérification.

- Si vous préférez ne pas utiliser la page de vérification hébergée par Stripe, créez un formulaire dans votre application. Vos clients peuvent ensuite l’utiliser pour vous transmettre les montants des microversements et pour vérifier le compte bancaire à l’aide du SDK Android.

  - Configurez le formulaire de manière à ce qu’il gère au moins le paramètre `descriptor code`, qui comporte une chaîne à 6&nbsp;chiffres à des fins de vérification.
  - Stripe recommande également de configurer votre formulaire pour gérer le paramètre `amounts`, car certaines banques utilisées par vos clients peuvent l’exiger.

  Les intégrations transmettent uniquement les paramètres `descriptor_code` *ou* `amounts`. Pour savoir lequel utilise votre intégration, vérifiez la valeur de `verify_with_microdeposits[microdeposit_type]` dans l’objet `next_action`.

#### Kotlin

```kotlin
// Use if you are using a descriptor code, do not use if you are using amounts
fun verifyPaymentIntentWithMicrodeposits(
    clientSecret: String,
    descriptorCode: String,
    callback: ApiResultCallback<PaymentIntent>
)

// Use if you are using amounts, do not use if you are using descriptor code
fun verifyPaymentIntentWithMicrodeposits(
    clientSecret: String,
    firstAmount: Int,
    secondAmount: Int,
    callback: ApiResultCallback<PaymentIntent>
)
```

Lorsque le compte bancaire est vérifié, Stripe renvoie l’objet PaymentIntent avec un `status` défini sur `processing`.

La vérification peut échouer pour différentes raisons. L’échec se produit de manière synchrone et vous en êtes informé par un message d’erreur.

```json
{
  "error": {
    "code": "payment_method_microdeposit_verification_amounts_mismatch",
    "message": "The amounts provided do not match the amounts that were sent to the bank account. You have {attempts_remaining} verification attempts remaining.",
    "type": "invalid_request_error"
  }
}
```

| Code d’erreur                                                | Message                                                                                                                                       | Changement d’état                                                                                       |
| ------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- |
| `payment_method_microdeposit_failed`                         | Les microversements ont échoué. Veuillez vérifier la validité des numéros de compte, d’établissement et de transit fournis.                   | `status` présente la valeur `requires_payment_method`, et le paramètre `last_payment_error` est défini. |
| `payment_method_microdeposit_verification_amounts_mismatch`  | Les montants fournis ne correspondent pas à ceux envoyés au compte bancaire. Il vous reste {attempts_remaining} tentative(s) de vérification. | Inchangé                                                                                                |
| `payment_method_microdeposit_verification_attempts_exceeded` | Nombre de tentatives de vérification autorisées dépassé                                                                                       | `status` présente la valeur `requires_payment_method`, et le paramètre `last_payment_error` est défini. |

## Confirmer l'aboutissement du PaymentIntent [Côté serveur]

Le prélèvement automatique ACH est un moyen de paiement à [notification différée](https://docs.stripe.com/payments/payment-methods.md#payment-notification). Ceci signifie que pour recevoir une notification du succès ou de l’échec d’un paiement, il faut compter jusqu’à quatre jours ouvrables après le déclenchement du prélèvement sur le compte du client.

Initialement, le PaymentIntent que vous créez présente l’état `processing`. Une fois le paiement abouti, l’état du PaymentIntent passe de `processing` à `succeeded`.

Nous vous recommandons d’utiliser des [webhooks](https://docs.stripe.com/payments/payment-intents/verifying-status.md#webhooks) afin de *confirmer* (Confirming an intent indicates that the customer intends to use the current or provided payment method. Upon confirmation, the intent attempts to initiate the portions of the flow that have real-world side effects) que le paiement a réussi et d’informer le client que le paiement a été effectué. Vous pouvez également afficher les événements sur le [Dashboard Stripe](https://dashboard.stripe.com/events).

#### Événements PaymentIntent

Les événements suivants sont envoyés lorsque le PaymentIntent change d’état&nbsp;:

| Événement                       | Description                                                                                                                    | Étape suivante                                                                                                                                                                                                                                                                                                                       |
| ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `payment_intent.processing`     | Le paiement du client a bien été envoyé à Stripe.                                                                              | Attendez que le paiement aboutisse ou échoue.                                                                                                                                                                                                                                                                                        |
| `payment_intent.succeeded`      | Le paiement du client a abouti.                                                                                                | Traitez la commande de biens ou de services.                                                                                                                                                                                                                                                                                         |
| `payment_intent.payment_failed` | Le paiement du client a été refusé. Ceci peut aussi s’appliquer en cas d’échec de la vérification à l’aide de microversements. | Envoyez un e-mail ou une notification push au client pour lui demander d’utiliser un autre moyen de paiement. Si le webhook a été envoyé suite à l’échec de la vérification à l’aide de micro-versements, l’utilisateur doit à nouveau saisir ses coordonnées bancaires. De nouveaux micro-versements seront déposés sur son compte. |

#### Événements de paiement

Vous pouvez également utiliser des webhooks Charge supplémentaires pour suivre l’état du paiement. Dès réception du webhook `charge.updated`, le paiement ne peut plus être annulé.

Les événements suivants sont envoyés lorsque le paiement change d’état&nbsp;:

| Événement          | Description                                                                                                                                                                           | Étape suivante                                                                                 |
| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- |
| `charge.pending`   | Le paiement du client a bien été créé.                                                                                                                                                | Attendez que le paiement initié soit traité.                                                   |
| `charge.updated`   | Le paiement du client a été mis à jour. Il peut être émis lorsqu’une nouvelle opération sur solde est créée, qu’une description ou que des métadonnées de paiement sont mises à jour. | Attendez que le paiement aboutisse ou échoue.                                                  |
| `charge.succeeded` | Le paiement du client a abouti et les fonds sont disponibles sur votre solde.                                                                                                         | Traitez la commande de biens ou de services.                                                   |
| `charge.failed`    | Le paiement du client a échoué.                                                                                                                                                       | Vérifiez le failure_code et le failure_message du paiement pour déterminer la marche à suivre. |

## Tester votre intégration

Découvrez comment tester des scénarios avec des vérifications instantanées à l’aide de [Financial Connections](https://docs.stripe.com/financial-connections/testing.md#web-how-to-use-test-accounts).

### Envoyer des e-mails de transaction dans un environnement de test

Une fois que vous avez collecté les coordonnées bancaires et accepté un mandat, envoyez les courriels de confirmation du mandat et de vérification du microversement dans un *environnement de bac à sable* (A sandbox is an isolated test environment that allows you to test Stripe functionality in your account without affecting your live integration. Use sandboxes to safely experiment with new features and changes).

Si votre domaine est **{domain}** et votre nom d’utilisateur est **{username}**, utilisez le format d’adresse e-mail suivant pour envoyer des e-mails de transaction de test&nbsp;: **{username}+test\_email@{domain}**.

Par exemple, si votre domaine est **example.com** et que votre nom d’utilisateur est **info**, utilisez le format **info+test\_email@example.com** pour tester les paiements ACH Direct Debit. Ce format garantit que les e-mails sont acheminés correctement. Si vous n’incluez pas le suffixe **+test\_email**, nous n’enverrons pas l’e-mail.

> Vous devez [configurer votre compte Stripe](https://docs.stripe.com/get-started/account/set-up.md) avant de pouvoir déclencher ces e-mails pendant les tests.

### Numéros de comptes de test

Stripe fournit plusieurs numéros de compte de test et les tokens correspondants que vous pouvez utiliser pour vous assurer que votre intégration pour les comptes bancaires saisis manuellement est prête à passer en mode production.

| Numéro de compte | Token                                  | Numéro de routage | Comportement                                                                                                                                                                                                                                                                                                         |
| ---------------- | -------------------------------------- | ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `000123456789`   | `pm_usBankAccount_success`             | `110000000`       | Le paiement aboutit.                                                                                                                                                                                                                                                                                                 |
| `000111111113`   | `pm_usBankAccount_accountClosed`       | `110000000`       | Le paiement échoue parce que le compte est clôturé.                                                                                                                                                                                                                                                                  |
| `000000004954`   | `pm_usBankAccount_riskLevelHighest`    | `110000000`       | Le paiement est bloqué par Radar en raison d’un [risque élevé de fraude](https://docs.stripe.com/radar/risk-evaluation.md#high-risk).                                                                                                                                                                                |
| `000111111116`   | `pm_usBankAccount_noAccount`           | `110000000`       | Le paiement échoue car aucun compte n’est trouvé.                                                                                                                                                                                                                                                                    |
| `000222222227`   | `pm_usBankAccount_insufficientFunds`   | `110000000`       | Le paiement échoue en raison de fonds insuffisants.                                                                                                                                                                                                                                                                  |
| `000333333335`   | `pm_usBankAccount_debitNotAuthorized`  | `110000000`       | Le paiement échoue parce que les débits ne sont pas autorisés.                                                                                                                                                                                                                                                       |
| `000444444440`   | `pm_usBankAccount_invalidCurrency`     | `110000000`       | Le paiement échoue en raison d’une devise non valide.                                                                                                                                                                                                                                                                |
| `000666666661`   | `pm_usBankAccount_failMicrodeposits`   | `110000000`       | Le paiement ne parvient pas à envoyer les microversements.                                                                                                                                                                                                                                                           |
| `000555555559`   | `pm_usBankAccount_dispute`             | `110000000`       | Le paiement déclenche un litige.                                                                                                                                                                                                                                                                                     |
| `000000000009`   | `pm_usBankAccount_processing`          | `110000000`       | Le traitement du paiement est indéfini. Utile pour tester {&nbsp;% si $checkoutSessions %}[Expiration de la session de paiement](https://docs.stripe.com/api/checkout/sessions/expire.md){&nbsp;% else /&nbsp;%}[Annulation de PaymentIntent](https://docs.stripe.com/api/payment_intents/cancel.md){&nbsp;% /if %}. |
| `000777777771`   | `pm_usBankAccount_weeklyLimitExceeded` | `110000000`       | Le paiement échoue, car son montant entraîne un dépassement de la limite hebdomadaire de volume de paiement du compte.                                                                                                                                                                                               |
| `000888888885`   |                                        | `110000000`       | Le paiement échoue en raison d’un [numéro de compte tokenisé](https://docs.stripe.com/financial-connections/tokenized-account-numbers.md) désactivé.                                                                                                                                                                 |

Avant d’effectuer les transactions de test, vous devez vérifier tous les comptes de test pour lesquels le paiement aboutit ou échoue automatiquement. Pour ce faire, utilisez les codes de libellé ou les montants de microversements de test ci-dessous.

### Tester des codes de libellé et des montants de microversements

Pour simuler différents scénarios, utilisez ces montants de microversements *ou* ces codes de libellé 0.01.

| Valeurs de microversement | Valeurs de code de libellé 0.01 | Scénario                                                                |
| ------------------------- | ------------------------------- | ----------------------------------------------------------------------- |
| `32` et `45`              | SM11AA                          | Simule la vérification du compte.                                       |
| `10` et `11`              | SM33CC                          | Simule le dépassement du nombre de tentatives de vérification autorisé. |
| `40` et `41`              | SM44DD                          | Simule l’expiration du délai de validité d’un microversement.           |

### Comportement de règlement des tests

Les transactions de test sont réglées instantanément et ajoutées à votre solde de test disponible. Ce comportement diffère de celui du mode production, où les transactions peuvent prendre [plusieurs jours](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#timing) pour être réglées dans votre solde disponible.

## Optional: Vérification instantanée uniquement [Côté serveur]

Par défaut, le paiement à l’aide d’un compte bancaire américain permet à vos clients d’utiliser la vérification instantanée du compte bancaire ou les microversements. Vous pouvez aussi exiger la vérification instantanée du compte bancaire uniquement en utilisant le paramètre [verification_method](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-us_bank_account-verification_method) à la création du PaymentIntent.

#### Accounts&nbsp;v2

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d setup_future_usage=off_session \
  -d "customer_account={{CUSTOMERACCOUNT_ID}}" \
  -d "payment_method_types[]=us_bank_account" \
  -d "payment_method_options[us_bank_account][verification_method]=instant" \
  -d "payment_method_options[us_bank_account][financial_connections][permissions][]=payment_method" \
  -d "payment_method_options[us_bank_account][financial_connections][permissions][]=balances"
```

#### Customers&nbsp;v1

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d setup_future_usage=off_session \
  -d "customer={{CUSTOMER_ID}}" \
  -d "payment_method_types[]=us_bank_account" \
  -d "payment_method_options[us_bank_account][verification_method]=instant" \
  -d "payment_method_options[us_bank_account][financial_connections][permissions][]=payment_method" \
  -d "payment_method_options[us_bank_account][financial_connections][permissions][]=balances"
```

Ainsi, vous n’avez pas besoin de gérer la vérification à l’aide de microversements. Cependant, si la vérification instantanée échoue, l’état du PaymentIntent est `requires_payment_method`, indiquant l’échec de la vérification instantanée du compte bancaire de votre client.

## Optional: Vérification à l'aide de microversements uniquement [Côté serveur]

Par défaut, le paiement à l’aide d’un compte bancaire américain permet à vos clients d’utiliser la vérification instantanée du compte bancaire ou les microversements. Vous pouvez aussi exiger la vérification du compte bancaire à l’aide de microversements uniquement en utilisant le paramètre [verification_method](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-us_bank_account-verification_method) à la création du PaymentIntent.

> Si vous utilisez un formulaire de paiement personnalisé, vous devez développer votre propre interface utilisateur pour collecter les coordonnées bancaires des clients. De la même manière, si vous désactivez l’envoi d’e-mails par Stripe en cas de microversements, vous devez développer votre propre interface utilisateur pour que votre client puisse confirmer le code ou le montant du microversement.

#### Accounts&nbsp;v2

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d setup_future_usage=off_session \
  -d "customer_account={{CUSTOMERACCOUNT_ID}}" \
  -d "payment_method_types[]=us_bank_account" \
  -d "payment_method_options[us_bank_account][verification_method]=microdeposits"
```

#### Customers&nbsp;v1

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d setup_future_usage=off_session \
  -d "customer={{CUSTOMER_ID}}" \
  -d "payment_method_types[]=us_bank_account" \
  -d "payment_method_options[us_bank_account][verification_method]=microdeposits"
```

Collectez ensuite le compte bancaire de votre client avec votre propre formulaire et appelez [stripe.confirmUsBankAccountPayment](https://docs.stripe.com/js/payment_intents/confirm_us_bank_account_payment) avec ces informations pour mener à bien le PaymentIntent.

```javascript
var form = document.getElementById('payment-form');
var accountholderName = document.getElementById('accountholder-name');
var email = document.getElementById('email');
var accountNumber = document.getElementById('account-number');
var routingNumber = document.getElementById('routing-number');
var accountHolderType= document.getElementById('account-holder-type');

var submitButton = document.getElementById('submit-button');
var clientSecret = submitButton.dataset.secret;

form.addEventListener('submit', function(event) {
  event.preventDefault();

  stripe.confirmUsBankAccountPayment(clientSecret, {
    payment_method: {
      billing_details: {
        name: accountholderName.value,
        email: email.value,
      },
      us_bank_account: {
        account_number: accountNumber.value,
        routing_number: routingNumber.value,
        account_holder_type: accountHolderType.value, // 'individual' or 'company'
      },
    },
  })
  .then(({paymentIntent, error}) => {
    if (error) {
      // Inform the customer that there was an error.
      console.log(error.message);
    } else {
      // Handle next step based on the intent's status.
      console.log("PaymentIntent ID: " + paymentIntent.id);
      console.log("PaymentIntent status: " + paymentIntent.status);
    }
  });
});
```

## Optional: Référence du paiement

Le numéro de référence du paiement est une valeur générée par la banque qui permet au titulaire du compte bancaire d’utiliser sa banque pour localiser des fonds. Lorsque le paiement aboutit, Stripe fournit le numéro de référence du paiement dans le Dashboard, ainsi que dans l’[objet Charge](https://docs.stripe.com/api/charges/object.md).

| État du paiement | Valeur de référence du paiement           |
| ---------------- | ----------------------------------------- |
| En attente       | Indisponibles                             |
| En échec         | Indisponibles                             |
| Réussi           | Disponible (par exemple, 091000015001234) |

De plus, lorsque vous recevez le webhook `charge.succeeded`, consultez le contenu de `payment_method_details` pour localiser la [payment_reference](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-us_bank_account-payment_reference).

L’exemple d’événement suivant montre le rendu d’un paiement ACH abouti avec un numéro de référence de paiement.

#### charge-succeeded

```json
{
  "id": "{{EVENT_ID}}",
  "object": "event",
  // omitted some fields in the example
  "type": "charge.succeeded",
  "data": {
    "object": {
      "id": "{{PAYMENT_ID}}",
      "object": "charge",
      //...
    "paid": true,
    "payment_intent": "{{PAYMENT_INTENT_ID}}",
    "payment_method": "{{PAYMENT_METHOD_ID}}",
    "payment_method_details": {
      "type": "us_bank_account",
      "us_bank_account": {
        "account_holder_type": "individual",
        "account_type": "checking",
        "bank_name": "TEST BANK",
        "fingerprint": "Ih3foEnRvLXShyfB",
        "last4": "1000","payment_reference": "091000015001234",
        "routing_number": "110000000"
        }
      }
      // ...
    }
  }
}
```

Consultez le contenu de `destination_details` pour localiser la [référence du remboursement](https://docs.stripe.com/api/refunds/object.md#refund_object-destination_details-us_bank_transfer-reference) associée aux paiements ACH remboursés.

L’exemple d’événement suivant montre le rendu d’un remboursement de paiement ACH abouti avec un numéro de référence de remboursement. En savoir plus sur les [remboursements](https://docs.stripe.com/refunds.md).

#### charge-refund-updated

```json
{
  "id": "{{EVENT_ID}}",
  "object": "event",
  "type": "charge.refund.updated",
  "data": {
    "object": {
      "id": "{{REFUND_ID}}",
      "object": "refund",
      //...
    "payment_intent": "{{PAYMENT_INTENT_ID}}",
    "destination_details": {
      "type": "us_bank_transfer",
      "us_bank_transfer": {"reference": "091000015001111",
        "reference_status": "available"
        }
      }
      // ...
    }
  }
}
```

## See also

- [Enregistrer les coordonnées du ACH Direct Debit pour les futurs paiements](https://docs.stripe.com/payments/ach-direct-debit/set-up-payment.md)


# React Native

> This is a React Native for when payment-ui is mobile and platform is react-native. View the full page at https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment?payment-ui=mobile&platform=react-native.

> #### Utiliser l’API Accounts v2 pour représenter les clients
> 
> L’API Accounts&nbsp;v2 est généralement disponible pour les utilisateurs de Connect et en aperçu public pour les autres utilisateurs de Stripe. Si vous avez accès à l’aperçu Accounts&nbsp;v2, vous devez [spécifier une version d’aperçu](https://docs.stripe.com/api-v2-overview.md#sdk-and-api-versioning) dans votre code.
> 
> Pour demander l’accès à l’aperçu Accounts&nbsp;v2, 
> 
> Dans la plupart des cas d’usage, nous vous recommandons de [modéliser vos clients en tant qu’objets Account configurés par le client](https://docs.stripe.com/connect/use-accounts-as-customers.md), plutôt que d’utiliser des objets [Customer](https://docs.stripe.com/api/customers.md).

Voici les différentes étapes nécessaires pour accepter des paiements par prélèvement automatique ACH sur votre application&nbsp;:

- Création d’un objet de suivi du paiement
- Collecte des informations du moyen de paiement
- Soumission du paiement à Stripe pour traitement
- Vérification du compte bancaire de votre client

Pour représenter le paiement, Stripe utilise un [PaymentIntent](https://docs.stripe.com/payments/payment-intents.md), lequel permet de suivre et de gérer l’ensemble des états du paiement jusqu’à ce qu’il aboutisse.

> Le prélèvement automatique ACH est un moyen de paiement à [notification différée](https://docs.stripe.com/payments/payment-methods.md#payment-notification), ce qui signifie que les fonds ne sont pas immédiatement disponibles après le paiement. Il faut généralement compter 4&nbsp;jours ouvrables pour qu’un paiement arrive sur votre compte.

## Configurer Stripe [Côté serveur] [Côté client]

### Côté serveur

Pour cette intégration, votre serveur doit être doté d’endpoints qui communiquent avec l’API Stripe. Utilisez nos bibliothèques officielles pour accéder à l’API Stripe depuis votre serveur&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'
```

### Côté client

Le [SDK React Native](https://github.com/stripe/stripe-react-native) est disponible en open source et fait l’objet d’une documentation complète. En interne, il utilise des SDK [Android](https://github.com/stripe/stripe-android) et [iOS natifs](https://github.com/stripe/stripe-ios). Pour installer le SDK React Native de Stripe, exécutez l’une des commandes suivantes dans le répertoire de votre projet (selon le gestionnaire de paquets que vous utilisez)&nbsp;:

#### yarn

```bash
yarn add @stripe/stripe-react-native
```

#### npm

```bash
npm install @stripe/stripe-react-native
```

Ensuite, installez les autres dépendances nécessaires&nbsp;:

- Pour iOS, accédez au directeur **ios** et exécutez `pod install` pour vous assurer que vous installez également les dépendances natives requises.
- Pour Android, il n’y a plus de dépendances à installer.

> Nous vous recommandons de suivre le [guide officiel de TypeScript](https://reactnative.dev/docs/typescript#adding-typescript-to-an-existing-project) pour ajouter la prise en charge de TypeScript.

### Initialisation de Stripe

Pour initialiser Stripe dans votre application React&nbsp;Native, wrappez votre écran de paiement avec le composant `StripeProvider` ou utilisez la méthode d’initialisation `initStripe`. Seule la [clé publiable](https://docs.stripe.com/keys.md#obtain-api-keys) de l’API dans `publishableKey` est nécessaire. L’exemple suivant montre comment initialiser Stripe à l’aide du composant `StripeProvider`.

```jsx
import { useState, useEffect } from 'react';
import { StripeProvider } from '@stripe/stripe-react-native';

function App() {
  const [publishableKey, setPublishableKey] = useState('');

  const fetchPublishableKey = async () => {
    const key = await fetchKey(); // fetch key from your server here
    setPublishableKey(key);
  };

  useEffect(() => {
    fetchPublishableKey();
  }, []);

  return (
    <StripeProvider
      publishableKey={publishableKey}
      merchantIdentifier="merchant.identifier" // required for Apple Pay
      urlScheme="your-url-scheme" // required for 3D Secure and bank redirects
    >
      {/* Your app code here */}
    </StripeProvider>
  );
}
```

> Utilisez vos [clés de test](https://docs.stripe.com/keys.md#obtain-api-keys) d’API lors de vos activités de test et de développement, et vos clés du [mode production](https://docs.stripe.com/keys.md#test-live-modes) pour la publication de votre application.

Stripe vous permet de vérifier instantanément le compte bancaire d’un client. Si vous souhaitez récupérer des données supplémentaires sur un compte, [inscrivez-vous pour accéder aux données](https://dashboard.stripe.com/financial-connections/application) avec [Stripe Financial Connections](https://docs.stripe.com/financial-connections.md).

Stripe Financial Connections permet à vos clients de partager de manière sécurisée leurs données financières en associant leurs comptes financiers à votre entreprise. Utilisez Financial Connections pour accéder aux données financières autorisées par les clients telles que les numéros de compte et de routage tokenisés, les données de solde, les informations sur la propriété et les données de transaction.

L’accès à ces données vous permet d’effectuer des actions comme la vérification des soldes avant d’initier un paiement afin de réduire le risque d’un échec du paiement dû à des fonds insuffisants.

Financial Connections permet à vos utilisateurs de connecter leurs comptes en moins d’étapes grâce à Link. Ils peuvent ainsi enregistrer et réutiliser leurs coordonnées bancaires auprès des entreprises Stripe.

## Créer ou récupérer un objet Customer [Recommandé] [Côté serveur]

> #### Utiliser l’API Accounts v2 pour représenter les clients
> 
> L’API Accounts&nbsp;v2 est généralement disponible pour les utilisateurs de Connect et en aperçu public pour les autres utilisateurs de Stripe. Si vous avez accès à l’aperçu Accounts&nbsp;v2, vous devez [spécifier une version d’aperçu](https://docs.stripe.com/api-v2-overview.md#sdk-and-api-versioning) dans votre code.
> 
> Pour demander l’accès à l’aperçu Accounts&nbsp;v2, 
> 
> Dans la plupart des cas d’usage, nous vous recommandons de [modéliser vos clients en tant qu’objets Account configurés par le client](https://docs.stripe.com/connect/use-accounts-as-customers.md), plutôt que d’utiliser des objets [Customer](https://docs.stripe.com/api/customers.md).

#### Accounts&nbsp;v2

Créez un objet [Account](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-configuration-customer) configuré par le client lorsque votre utilisateur crée un compte auprès de votre entreprise, ou récupérez un `Account` existant associé à cet utilisateur. L’association de l’ID de l’objet `Account` à votre propre représentation interne d’un client vous permet de récupérer et d’utiliser ultérieurement les informations de moyen de paiement enregistrées. Ajoutez une adresse e-mail à l’`objet Account` pour activer [l’optimisation des utilisateurs connus](https://docs.stripe.com/financial-connections/fundamentals.md#return-user-optimization) de Financial Connections.

```curl
curl -X POST https://api.stripe.com/v2/core/accounts \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-03-25.preview" \
  --json '{
    "contact_email": "{{CUSTOMER_EMAIL}}"
  }'
```

#### Customers&nbsp;v1

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) lorsque votre client crée un compte auprès de votre entreprise, ou récupérez l’objet `Customer` existant associé à cet utilisateur. L’association de l’ID de l’objet `Customer` à votre propre représentation interne d’un client vous permet de récupérer et d’utiliser ultérieurement les informations de paiement enregistrées. Ajoutez une adresse e-mail à l’objet `Customer` pour activer [l’optimisation des utilisateurs connus](https://docs.stripe.com/financial-connections/fundamentals.md#return-user-optimization) de Financial Connections.

```curl
curl https://api.stripe.com/v1/customers \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d email={{CUSTOMER_EMAIL}}
```

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

Un [PaymentIntent](https://docs.stripe.com/api/payment_intents.md) est un objet qui représente votre intention d’encaisser le paiement d’un client et qui suit le cycle de vie du processus de paiement étape par étape.

### Côté serveur

Tout d’abord, créez un PaymentIntent sur votre serveur et spécifiez le montant à collecter et la devise `usd`. Si vous possédez déjà une autre intégration utilisant l’API Payment Intents, ajoutez `us_bank_account` à la liste des [types de moyens de paiement](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) de votre PaymentIntent. Précisez aussi l’[ID](https://docs.stripe.com/api/customers/object.md#customer_object-id) de l’objet Customer.

Si vous souhaitez réutiliser le moyen de paiement dans le futur, fournissez le paramètre [setup_future_usage](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-setup_future_usage) avec la valeur `off_session`.

Pour en savoir plus sur les frais Financial Connections, consultez les [Tarifs](https://stripe.com/financial-connections#pricing).

Par défaut, lors de la collecte des coordonnées bancaires, [Financial Connections](https://docs.stripe.com/financial-connections.md) est utilisé pour vérifier instantanément le compte de votre client. Une option de secours comprenant la saisie manuelle du numéro de compte et la vérification par microversement peut être utilisée. Consultez la [documentation relative à Financial Connections](https://docs.stripe.com/financial-connections/ach-direct-debit-payments.md) pour savoir comment configurer Financial Connections et accéder à des données de compte supplémentaires de façon à optimiser votre intégration ACH. Par exemple, vous pouvez utiliser Financial Connections pour consulter le solde d’un compte avant d’initier le paiement ACH.

> Pour accéder à des données supplémentaires après qu’un client a authentifié son compte, celui-ci doit associer de nouveau son compte avec des autorisations étendues.

#### Accounts&nbsp;v2

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d setup_future_usage=off_session \
  -d "customer_account={{CUSTOMERACCOUNT_ID}}" \
  -d "payment_method_types[]=us_bank_account"
```

#### Customers&nbsp;v1

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d setup_future_usage=off_session \
  -d "customer={{CUSTOMER_ID}}" \
  -d "payment_method_types[]=us_bank_account"
```

### Côté client

Un PaymentIntent contient une *clé secrète du client* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)). Au lieu de transmettre la totalité de l’objet PaymentIntent, vous pouvez utiliser la clé secrète du client dans votre application React Native pour finaliser le processus de paiement en toute sécurité. Dans votre application, demandez un PaymentIntent auprès de votre serveur et sauvegardez sa clé secrète du client.

```javascript
function PaymentScreen() {
  // ...

  const fetchIntentClientSecret = async () => {
    const response = await fetch(`${API_URL}/create-intent`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        // This is an example request body, the parameters you pass are up to you
        customer: '<CUSTOMER_ID>',
        product: '<PRODUCT_ID>',
      }),
    });
    const {clientSecret} = await response.json();

    return clientSecret;
  };

  return <View>...</View>;
}
```

## Collecter les informations du moyen de paiement [Côté client]

Plutôt que d’envoyer la totalité de l’objet PaymentIntent au client, utilisez sa *clé secrète* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)) provenant de l’étape précédente. Il ne s’agit pas de vos clés API qui authentifient les requêtes de l’API de Stripe.

Utilisez la clé secrète du client avec prudence, car elle peut servir à finaliser le paiement. Ne l’enregistrez pas, ne l’intégrez pas dans des URL et ne la dévoilez à personne d’autre que votre client.

Utilisez [collectBankAccountForPayment](https://docs.stripe.com/js/payment_intents/collect_bank_account_for_payment) pour recueillir les coordonnées bancaires, créer un *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs), et rattacher ce PaymentMethod au PaymentIntent. Vous devez inclure le nom du titulaire du compte dans le paramètre `billingDetails` pour créer un PaymentMethod ACH Direct Debit.

```javascript
import {collectBankAccountForPayment} from '@stripe/stripe-react-native';

export default function MyPaymentScreen() {
  const [name, setName] = useState('');

  const handleCollectBankAccountPress = async () => {
    // Fetch the intent client secret from the backend.
    // See `fetchIntentClientSecret()`'s implementation above.
    const {clientSecret} = await fetchIntentClientSecret();

    const {paymentIntent, error} = await collectBankAccountForPayment(
      clientSecret,
      {
        paymentMethodType: 'USBankAccount',
        paymentMethodData: {
          billingDetails: {
            name: "John Doe",
          },
        },
      },
    );

    if (error) {
      Alert.alert(`Error code: ${error.code}`, error.message);
    } else if (paymentIntent) {
      Alert.alert('Payment status:', paymentIntent.status);
      if (paymentIntent.status === PaymentIntents.Status.RequiresConfirmation) {
        // The next step is to call `confirmPayment`
      } else if (
        paymentIntent.status === PaymentIntents.Status.RequiresAction
      ) {
        // The next step is to call `verifyMicrodepositsForPayment`
      }
    }
  };

  return (
    <PaymentScreen>
      <TextInput
        placeholder="Name"
        onChange={(value) => setName(value.nativeEvent.text)}
      />
      <Button
        onPress={handleCollectBankAccountPress}
        title="Collect bank account"
      />
    </PaymentScreen>
  );
}
```

Cela charge une fenêtre modale sur la page qui gère la collecte et la vérification des informations du compte bancaire. Une fois le chargement terminé, le *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) est automatiquement rattaché au PaymentIntent.

## Optional: Personnaliser le collecteur de comptes bancaires [Côté client]

### Mode sombre

Par défaut, le collecteur de compte bancaire bascule automatiquement entre les couleurs compatibles avec le mode clair et sombre en fonction des paramètres de l’appareil. Si votre application ne prend pas en charge le mode clair ou sombre, vous pouvez définir `style` sur `alwaysLight` ou `alwaysDark`, respectivement.

```javascript
const {session, error} = await collectBankAccountForPayment(
   clientSecret,
   {
     style: 'alwaysLight',
   },
);
```

Pour obtenir une apparence toujours claire ou toujours sombre dans votre application Android, utilisez la classe`AppCompatDelegate` d’Android. Notre interface utilisateur respecte automatiquement ce paramètre.

#### Kotlin

```kotlin
// force dark
AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_YES)
// force light
AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_NO)
```

## Configurer une URL de redirection (iOS uniquement) [Côté client]

Lorsqu’un client quitte votre application (par exemple, pour s’authentifier dans Safari ou dans son application bancaire), donnez-lui un moyen de revenir automatiquement dans votre application. De nombreux types de moyens de paiement *nécessitent* une URL de redirection. Si vous n’en fournissez pas, nous ne pourrons pas présenter à vos utilisateurs les moyens de paiement nécessitant une URL de redirection, même si vous les avez activés.

Pour fournir une URL de redirection&nbsp;:

1. [Enregistrez](https://developer.apple.com/documentation/xcode/defining-a-custom-url-scheme-for-your-app#Register-your-URL-scheme) une URL personnalisée. Les liens universels ne sont pas pris en charge.
1. [Configurez](https://reactnative.dev/docs/linking) votre URL personnalisée.
1. Configurez votre composant racine pour qu’il transfère l’URL au SDK de Stripe, comme illustré ci-dessous.

> Si vous utilisez Expo, [définissez votre schéma](https://docs.expo.io/guides/linking/#in-a-standalone-app) dans le fichier `app.json`.

```jsx
import { useEffect, useCallback } from 'react';
import { Linking } from 'react-native';
import { useStripe } from '@stripe/stripe-react-native';

export default function MyApp() {
  const { handleURLCallback } = useStripe();

  const handleDeepLink = useCallback(
    async (url: string | null) => {
      if (url) {
        const stripeHandled = await handleURLCallback(url);
        if (stripeHandled) {
          // This was a Stripe URL - you can return or add extra handling here as you see fit
        } else {
          // This was NOT a Stripe URL – handle as you normally would
        }
      }
    },
    [handleURLCallback]
  );

  useEffect(() => {
    const getUrlAsync = async () => {
      const initialUrl = await Linking.getInitialURL();
      handleDeepLink(initialUrl);
    };

    getUrlAsync();

    const deepLinkListener = Linking.addEventListener(
      'url',
      (event: { url: string }) => {
        handleDeepLink(event.url);
      }
    );

    return () => deepLinkListener.remove();
  }, [handleDeepLink]);

  return (
    <View>
      <AwesomeAppComponent />
    </View>
  );
}
```

Pour plus d’informations sur les schémas d’URL natifs, consultez la documentation [Android](https://developer.android.com/training/app-links/deep-linking) et [iOS](https://developer.apple.com/documentation/xcode/allowing_apps_and_websites_to_link_to_your_content/defining_a_custom_url_scheme_for_your_app).

## Optional: Accéder aux données sur un compte bancaire Financial Connections [Côté serveur]

Vous ne pouvez accéder aux données Financial Connections que si vous demandez des [autorisations](https://docs.stripe.com/financial-connections/fundamentals.md#data-permissions) d’accès supplémentaires lors de la création de votre PaymentIntent .

Une fois que votre client a terminé le [flux d’authentification Stripe Financial Connections](https://docs.stripe.com/financial-connections/fundamentals.md#authentication-flow), l’objet PaymentMethod `us_bank_account` renvoyé inclut un ID de [financial_connections_account](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-us_bank_account-financial_connections_account) correspondant à un [compte Financial Connections](https://docs.stripe.com/api/financial_connections/accounts.md). Utilisez cet ID pour accéder aux données du compte.

> Les comptes bancaires que vos clients associent par saisie manuelle ou par le biais de microversements n’ont pas d’ID `financial_connections_account` au niveau du moyen de paiement.

Pour déterminer l’ID du compte Financial Connections, récupérez le PaymentIntent et développez l’attribut `payment_method`&nbsp;:

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

```json
{
  "id": "{{PAYMENT_INTENT_ID}}",
  "object": "payment_intent",
  // ...
  "payment_method": {
    "id": "{{PAYMENT_METHOD_ID}}",
    // ...
    "type": "us_bank_account"
    "us_bank_account": {
      "account_holder_type": "individual",
      "account_type": "checking",
      "bank_name": "TEST BANK","financial_connections_account": "{{FINANCIAL_CONNECTIONS_ACCOUNT_ID}}",
      "fingerprint": "q9qchffggRjlX2tb",
      "last4": "6789",
      "routing_number": "110000000"
    }
  }
  // ...
}

```

Si vous avez choisi de recevoir des autorisations `balances`, nous vous recommandons de vérifier l’état du solde à ce moment-là afin de vous assurer de disposer de fonds suffisants avant de confirmer un paiement.

Découvrez comment utiliser des données de compte supplémentaires pour optimiser votre intégration ACH avec [Financial Connections](https://docs.stripe.com/financial-connections/ach-direct-debit-payments.md#optimize).

## Collecter l'accusé de réception du mandat et effectuer le paiement [Côté client]

Avant de pouvoir initier le paiement, vous devez obtenir l’autorisation de votre client. Pour ce faire, présentez-lui les conditions du mandat et demandez-lui de les accepter.

Pour vous conformer aux règles de la Nacha, vous devez obtenir l’autorisation d’initier le paiement auprès de votre client. Pour ce faire, présentez-lui les conditions du mandat et demandez-lui de les accepter. Pour en savoir plus, consultez la page sur les [mandats](https://docs.stripe.com/payments/ach-direct-debit.md#mandates).

Lorsque le client accepte les conditions du mandat, vous devez confirmer le PaymentIntent. Utilisez `confirmPayment` pour confirmer l’intention de payement.

```javascript
import {confirmPayment} from '@stripe/stripe-react-native';

export default function MyPaymentScreen() {
  const [name, setName] = useState('');

  const handleCollectBankAccountPress = async () => {
    // See above
  };

  const handlePayPress = async () => {
    // use the same clientSecret as earlier, see above
    const {error, paymentIntent} = await confirmPayment(clientSecret, {
      paymentMethodType: 'USBankAccount',
    });

    if (error) {
      Alert.alert(`Error code: ${error.code}`, error.message);
    } else if (paymentIntent) {
      if (paymentIntent.status === PaymentIntents.Status.Processing) {
        // The debit has been successfully submitted and is now processing
      } else if (
        paymentIntent.status === PaymentIntents.Status.RequiresAction &&
        paymentIntent?.nextAction?.type === 'verifyWithMicrodeposits'
      ) {
        // The payment must be verified with `verifyMicrodepositsForPayment`
      } else {
        Alert.alert('Payment status:', paymentIntent.status);
      }
    }
  };

  return (
    <PaymentScreen>
      <TextInput
        placeholder="Name"
        onChange={(value) => setName(value.nativeEvent.text)}
      />
      <Button
        onPress={handleCollectBankAccountPress}
        title="Collect bank account"
      />
      <Button onPress={handlePayPress} title="Pay" />
    </PaymentScreen>
  );
}
```

Sauf échec de l’opération, Stripe renvoie un objet PaymentIntent présentant l’un des états suivants&nbsp;:

| État             | Description                                                                              | Étapes suivantes                                                                                                                                                                                                    |
| ---------------- | ---------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `RequiresAction` | La vérification du compte bancaire requiert une action supplémentaire.                   | Étape 6&nbsp;: [Vérification des comptes bancaires à l’aide de microversements](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md?platform=react-native#react-native-verify-with-microdeposits) |
| `Processing`     | Le compte bancaire a été vérifié instantanément ou la vérification n’est pas nécessaire. | Étape 7&nbsp;: [Confirmation du succès du PaymentIntent](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md?platform=react-native#confirm-paymentintent-succeeded)                               |

Après avoir confirmé le PaymentIntent, un e-mail de confirmation du mandat et les coordonnées bancaires recueillies doivent être envoyés à votre client. Par défaut, Stripe gère cette étape, mais vous pouvez choisir d’[envoyer des notifications personnalisées](https://docs.stripe.com/payments/ach-direct-debit.md#mandate-and-microdeposit-emails) si vous préférez.

## Vérifier le compte bancaire à l'aide de microversements [Côté client]

Tous les clients ne peuvent pas instantanément vérifier leur compte bancaire. Stripe envoie alors automatiquement un microversement au compte bancaire. Ce versement peut apparaître après un à deux&nbsp;jours ouvrables sur le relevé bancaire en ligne du client. Ce versement peut prendre une des deux formes suivantes&nbsp;:

- **Code de libellé**&nbsp;: Stripe envoie un microversement unique de 0,01&nbsp;USD sur le compte bancaire du client avec un `descriptorCode` unique à 6&nbsp;chiffres qui commence par SM. Votre client utilise cette chaîne pour vérifier son compte bancaire.
- **Montant**&nbsp;: Stripe envoie deux microversements distincts sur le compte bancaire du client avec un code de libellé indiquant `ACCTVERIFY`. Votre client utilise les montants de ces versements pour vérifier son compte bancaire.

Si l’appel `confirmPayment` effectué à l’étape précédente renvoie un PaymentIntent avec l’état `requiresAction`, le champ `nextAction` du PaymentIntent contient des informations utiles à la vérification.

```javascript
nextAction: {
  type: 'verifyWithMicrodeposits';
  redirectUrl: "https://payments.stripe.com/…",
  microdepositType: "descriptor_code";
  arrivalDate: "1647586800";
}
```

Si vous avez fourni une [adresse e-mail de facturation](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-billing_details-email), Stripe l’utilise pour notifier votre client de la date d’arrivée prévue des versements. L’e-mail envoyé inclut un lien vers la page de vérification hébergée par Stripe, sur laquelle il peut confirmer les montants des versements et effectuer la vérification.

> Les tentatives de vérification sont limitées à dix pour les microversements basés sur des libellés et à trois pour ceux basés sur des montants. Si vous atteignez cette limite, nous ne pouvons plus vérifier le compte bancaire. En outre, les vérifications à l’aide de microversements expirent au bout de 10&nbsp;jours. Si vous ne vérifiez pas les microversements pendant ce laps de temps, le PaymentIntent réitère sa demande d’informations sur le moyen de paiement. En informant clairement vos clients sur le fonctionnement de ces microversements, vous évitez d’éventuels problèmes liés à la vérification.

Lorsque vous savez que le payement a l’état `requiresAction`et que `nextAction` est de type `verifyWithMicrodeposits`, vous pouvez finaliser la vérification d’un compte bancaire de deux manières différentes&nbsp;:

1. Contrôlez directement les versements dans votre application en appelant `verifyMicrodepositsForPayment` après avoir récupéré les montants ou le code du libellé.

```javascript
import { verifyMicrodepositsForPayment } from '@stripe/stripe-react-native';

export default function MyPaymentScreen() {
  const [verificationText, setVerificationText] = useState('');

  return (
    <TextInput
      placeholder="Descriptor code or comma-separated amounts"
      onChange={(value) => setVerificationText(value.nativeEvent.text)} // Validate and store your user's verification input
    />
    <Button
      title="Verify microdeposit"
      onPress={async () => {
        const { paymentIntent, error } =
          await verifyMicrodepositsForPayment(secret, {
            // Provide either the descriptorCode OR amounts, not both
            descriptorCode: verificationText,
            amounts: verificationText,
          });

        if (error) {
          Alert.alert(`Error code: ${error.code}`, error.message);
        } else if (paymentIntent) {
          Alert.alert('Payment status:', paymentIntent.status);
        }
      }}
    />
  );
}
```

1. Utilisez la page de vérification hébergée par Stripe que nous vous fournissons automatiquement. Pour cela, utilisez l’URL `nextAction[redirectUrl]` dans l’objet `nextAction` (voir ci-dessus) pour rediriger votre client vers la procédure de vérification.

```javascript
const {error, paymentIntent} = await confirmPayment(clientSecret, {
  paymentMethodType: 'USBankAccount',
});

if (error) {
  Alert.alert(`Error code: ${error.code}`, error.message);
} else if (paymentIntent) {
  if (
    paymentIntent.status === PaymentIntents.Status.RequiresAction &&
    paymentIntent?.nextAction?.type === 'verifyWithMicrodeposits'
  ) {
    // Open the Stripe-hosted verification page
    Linking.openURL(paymentIntent.nextAction.redirectUrl);
  }
}
```

Dès que le compte bancaire a été vérifié, Stripe renvoie l’objet PaymentIntent avec l’état `status` défini sur `Processing`, et envoie un événement *webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) [payment_intent.processing](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.processing).

La vérification peut échouer pour plusieurs raisons. L’échec peut se produire de manière synchrone comme une réponse d’erreur directe, ou de manière asynchrone à travers un événement webhook [payment_intent.payment_failed](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.failed) (voir les exemples ci-après).

#### Erreur synchrone

```json
{
  "error": {
    "code": "payment_method_microdeposit_verification_amounts_mismatch",
    "message": "The amounts provided do not match the amounts that were sent to the bank account. You have {attempts_remaining} verification attempts remaining.",
    "type": "invalid_request_error"
  }
}
```

#### Événement webhook

```javascript
{
  "object": {
    "id": "pi_1234",
    "object": "payment_intent",
    "customer": "cus_0246",
    ...
    "last_payment_error": {
      "code": "payment_method_microdeposit_verification_attempts_exceeded",
      "message": "You have exceeded the number of allowed verification attempts.",
    },
    ...
    "status": "requires_payment_method"
  }
}
```

| Code d’erreur                                                | Synchrone ou asynchrone                                   | Message                                                                                                                                          | Changement d’état                                                                                       |
| ------------------------------------------------------------ | --------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------- |
| `payment_method_microdeposit_failed`                         | De façon synchrone ou asynchrone via un événement webhook | Les microversements ont échoué. Veuillez vérifier la validité des numéros de compte, de l’établissement et de transit fournis.                   | `status` présente la valeur `requires_payment_method`, et le paramètre `last_payment_error` est défini. |
| `payment_method_microdeposit_verification_amounts_mismatch`  | De façon synchrone                                        | Les montants fournis ne correspondent pas à ceux envoyés au compte bancaire. Il vous reste {attempts_remaining}&nbsp;tentatives de vérification. | Inchangé                                                                                                |
| `payment_method_microdeposit_verification_attempts_exceeded` | De façon synchrone ou asynchrone via un événement webhook | Nombre de tentatives de vérification autorisées dépassé                                                                                          | `status` présente la valeur `requires_payment_method`, et le paramètre `last_payment_error` est défini. |
| `payment_method_microdeposit_verification_timeout`           | De façon asynchrone via un événement webhook              | Expiration des microversements. Le client n’a pas vérifié son compte bancaire dans le délai prévu de 10&nbsp;jours.                              | `status` présente la valeur `requires_payment_method`, et le paramètre `last_payment_error` est défini. |

## Confirmer l'aboutissement du PaymentIntent [Côté serveur]

Le prélèvement automatique ACH est un moyen de paiement à [notification différée](https://docs.stripe.com/payments/payment-methods.md#payment-notification). Ceci signifie que pour recevoir une notification du succès ou de l’échec d’un paiement, il faut compter jusqu’à quatre jours ouvrables après le déclenchement du prélèvement sur le compte du client.

Initialement, le PaymentIntent que vous créez présente l’état `processing`. Une fois le paiement abouti, l’état du PaymentIntent passe de `processing` à `succeeded`.

Nous vous recommandons d’utiliser des [webhooks](https://docs.stripe.com/payments/payment-intents/verifying-status.md#webhooks) afin de *confirmer* (Confirming an intent indicates that the customer intends to use the current or provided payment method. Upon confirmation, the intent attempts to initiate the portions of the flow that have real-world side effects) que le paiement a réussi et d’informer le client que le paiement a été effectué. Vous pouvez également afficher les événements sur le [Dashboard Stripe](https://dashboard.stripe.com/events).

#### Événements PaymentIntent

Les événements suivants sont envoyés lorsque le PaymentIntent change d’état&nbsp;:

| Événement                       | Description                                                                                                                    | Étape suivante                                                                                                                                                                                                                                                                                                                       |
| ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `payment_intent.processing`     | Le paiement du client a bien été envoyé à Stripe.                                                                              | Attendez que le paiement aboutisse ou échoue.                                                                                                                                                                                                                                                                                        |
| `payment_intent.succeeded`      | Le paiement du client a abouti.                                                                                                | Traitez la commande de biens ou de services.                                                                                                                                                                                                                                                                                         |
| `payment_intent.payment_failed` | Le paiement du client a été refusé. Ceci peut aussi s’appliquer en cas d’échec de la vérification à l’aide de microversements. | Envoyez un e-mail ou une notification push au client pour lui demander d’utiliser un autre moyen de paiement. Si le webhook a été envoyé suite à l’échec de la vérification à l’aide de micro-versements, l’utilisateur doit à nouveau saisir ses coordonnées bancaires. De nouveaux micro-versements seront déposés sur son compte. |

#### Événements de paiement

Vous pouvez également utiliser des webhooks Charge supplémentaires pour suivre l’état du paiement. Dès réception du webhook `charge.updated`, le paiement ne peut plus être annulé.

Les événements suivants sont envoyés lorsque le paiement change d’état&nbsp;:

| Événement          | Description                                                                                                                                                                           | Étape suivante                                                                                 |
| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- |
| `charge.pending`   | Le paiement du client a bien été créé.                                                                                                                                                | Attendez que le paiement initié soit traité.                                                   |
| `charge.updated`   | Le paiement du client a été mis à jour. Il peut être émis lorsqu’une nouvelle opération sur solde est créée, qu’une description ou que des métadonnées de paiement sont mises à jour. | Attendez que le paiement aboutisse ou échoue.                                                  |
| `charge.succeeded` | Le paiement du client a abouti et les fonds sont disponibles sur votre solde.                                                                                                         | Traitez la commande de biens ou de services.                                                   |
| `charge.failed`    | Le paiement du client a échoué.                                                                                                                                                       | Vérifiez le failure_code et le failure_message du paiement pour déterminer la marche à suivre. |

## Tester votre intégration

Découvrez comment tester des scénarios avec des vérifications instantanées à l’aide de [Financial Connections](https://docs.stripe.com/financial-connections/testing.md#web-how-to-use-test-accounts).

### Envoyer des e-mails de transaction dans un environnement de test

Une fois que vous avez collecté les coordonnées bancaires et accepté un mandat, envoyez les courriels de confirmation du mandat et de vérification du microversement dans un *environnement de bac à sable* (A sandbox is an isolated test environment that allows you to test Stripe functionality in your account without affecting your live integration. Use sandboxes to safely experiment with new features and changes).

Si votre domaine est **{domain}** et votre nom d’utilisateur est **{username}**, utilisez le format d’adresse e-mail suivant pour envoyer des e-mails de transaction de test&nbsp;: **{username}+test\_email@{domain}**.

Par exemple, si votre domaine est **example.com** et que votre nom d’utilisateur est **info**, utilisez le format **info+test\_email@example.com** pour tester les paiements ACH Direct Debit. Ce format garantit que les e-mails sont acheminés correctement. Si vous n’incluez pas le suffixe **+test\_email**, nous n’enverrons pas l’e-mail.

> Vous devez [configurer votre compte Stripe](https://docs.stripe.com/get-started/account/set-up.md) avant de pouvoir déclencher ces e-mails pendant les tests.

### Numéros de comptes de test

Stripe fournit plusieurs numéros de compte de test et les tokens correspondants que vous pouvez utiliser pour vous assurer que votre intégration pour les comptes bancaires saisis manuellement est prête à passer en mode production.

| Numéro de compte | Token                                  | Numéro de routage | Comportement                                                                                                                                                                                                                                                                                                         |
| ---------------- | -------------------------------------- | ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `000123456789`   | `pm_usBankAccount_success`             | `110000000`       | Le paiement aboutit.                                                                                                                                                                                                                                                                                                 |
| `000111111113`   | `pm_usBankAccount_accountClosed`       | `110000000`       | Le paiement échoue parce que le compte est clôturé.                                                                                                                                                                                                                                                                  |
| `000000004954`   | `pm_usBankAccount_riskLevelHighest`    | `110000000`       | Le paiement est bloqué par Radar en raison d’un [risque élevé de fraude](https://docs.stripe.com/radar/risk-evaluation.md#high-risk).                                                                                                                                                                                |
| `000111111116`   | `pm_usBankAccount_noAccount`           | `110000000`       | Le paiement échoue car aucun compte n’est trouvé.                                                                                                                                                                                                                                                                    |
| `000222222227`   | `pm_usBankAccount_insufficientFunds`   | `110000000`       | Le paiement échoue en raison de fonds insuffisants.                                                                                                                                                                                                                                                                  |
| `000333333335`   | `pm_usBankAccount_debitNotAuthorized`  | `110000000`       | Le paiement échoue parce que les débits ne sont pas autorisés.                                                                                                                                                                                                                                                       |
| `000444444440`   | `pm_usBankAccount_invalidCurrency`     | `110000000`       | Le paiement échoue en raison d’une devise non valide.                                                                                                                                                                                                                                                                |
| `000666666661`   | `pm_usBankAccount_failMicrodeposits`   | `110000000`       | Le paiement ne parvient pas à envoyer les microversements.                                                                                                                                                                                                                                                           |
| `000555555559`   | `pm_usBankAccount_dispute`             | `110000000`       | Le paiement déclenche un litige.                                                                                                                                                                                                                                                                                     |
| `000000000009`   | `pm_usBankAccount_processing`          | `110000000`       | Le traitement du paiement est indéfini. Utile pour tester {&nbsp;% si $checkoutSessions %}[Expiration de la session de paiement](https://docs.stripe.com/api/checkout/sessions/expire.md){&nbsp;% else /&nbsp;%}[Annulation de PaymentIntent](https://docs.stripe.com/api/payment_intents/cancel.md){&nbsp;% /if %}. |
| `000777777771`   | `pm_usBankAccount_weeklyLimitExceeded` | `110000000`       | Le paiement échoue, car son montant entraîne un dépassement de la limite hebdomadaire de volume de paiement du compte.                                                                                                                                                                                               |
| `000888888885`   |                                        | `110000000`       | Le paiement échoue en raison d’un [numéro de compte tokenisé](https://docs.stripe.com/financial-connections/tokenized-account-numbers.md) désactivé.                                                                                                                                                                 |

Avant d’effectuer les transactions de test, vous devez vérifier tous les comptes de test pour lesquels le paiement aboutit ou échoue automatiquement. Pour ce faire, utilisez les codes de libellé ou les montants de microversements de test ci-dessous.

### Tester des codes de libellé et des montants de microversements

Pour simuler différents scénarios, utilisez ces montants de microversements *ou* ces codes de libellé 0.01.

| Valeurs de microversement | Valeurs de code de libellé 0.01 | Scénario                                                                |
| ------------------------- | ------------------------------- | ----------------------------------------------------------------------- |
| `32` et `45`              | SM11AA                          | Simule la vérification du compte.                                       |
| `10` et `11`              | SM33CC                          | Simule le dépassement du nombre de tentatives de vérification autorisé. |
| `40` et `41`              | SM44DD                          | Simule l’expiration du délai de validité d’un microversement.           |

### Comportement de règlement des tests

Les transactions de test sont réglées instantanément et ajoutées à votre solde de test disponible. Ce comportement diffère de celui du mode production, où les transactions peuvent prendre [plusieurs jours](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#timing) pour être réglées dans votre solde disponible.

## Optional: Vérification instantanée uniquement [Côté serveur]

Par défaut, le paiement à l’aide d’un compte bancaire américain permet à vos clients d’utiliser la vérification instantanée du compte bancaire ou les microversements. Vous pouvez aussi exiger la vérification instantanée du compte bancaire uniquement en utilisant le paramètre [verification_method](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-us_bank_account-verification_method) à la création du PaymentIntent.

#### Accounts&nbsp;v2

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d setup_future_usage=off_session \
  -d "customer_account={{CUSTOMERACCOUNT_ID}}" \
  -d "payment_method_types[]=us_bank_account" \
  -d "payment_method_options[us_bank_account][verification_method]=instant" \
  -d "payment_method_options[us_bank_account][financial_connections][permissions][]=payment_method" \
  -d "payment_method_options[us_bank_account][financial_connections][permissions][]=balances"
```

#### Customers&nbsp;v1

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d setup_future_usage=off_session \
  -d "customer={{CUSTOMER_ID}}" \
  -d "payment_method_types[]=us_bank_account" \
  -d "payment_method_options[us_bank_account][verification_method]=instant" \
  -d "payment_method_options[us_bank_account][financial_connections][permissions][]=payment_method" \
  -d "payment_method_options[us_bank_account][financial_connections][permissions][]=balances"
```

Ainsi, vous n’avez pas besoin de gérer la vérification à l’aide de microversements. Cependant, si la vérification instantanée échoue, l’état du PaymentIntent est `requires_payment_method`, indiquant l’échec de la vérification instantanée du compte bancaire de votre client.

## Optional: Vérification à l'aide de microversements uniquement [Côté serveur]

Par défaut, le paiement à l’aide d’un compte bancaire américain permet à vos clients d’utiliser la vérification instantanée du compte bancaire ou les microversements. Vous pouvez aussi exiger la vérification du compte bancaire à l’aide de microversements uniquement en utilisant le paramètre [verification_method](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-us_bank_account-verification_method) à la création du PaymentIntent.

> Si vous utilisez un formulaire de paiement personnalisé, vous devez développer votre propre interface utilisateur pour collecter les coordonnées bancaires des clients. De la même manière, si vous désactivez l’envoi d’e-mails par Stripe en cas de microversements, vous devez développer votre propre interface utilisateur pour que votre client puisse confirmer le code ou le montant du microversement.

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d setup_future_usage=off_session \
  -d customer={{CUSTOMER_ID}} \
  -d "payment_method_types[]=us_bank_account" \
  -d "payment_method_options[us_bank_account][verification_method]=microdeposits"
```

## Optional: Référence du paiement

Le numéro de référence du paiement est une valeur générée par la banque qui permet au titulaire du compte bancaire d’utiliser sa banque pour localiser des fonds. Lorsque le paiement aboutit, Stripe fournit le numéro de référence du paiement dans le Dashboard, ainsi que dans l’[objet Charge](https://docs.stripe.com/api/charges/object.md).

| État du paiement | Valeur de référence du paiement           |
| ---------------- | ----------------------------------------- |
| En attente       | Indisponibles                             |
| En échec         | Indisponibles                             |
| Réussi           | Disponible (par exemple, 091000015001234) |

De plus, lorsque vous recevez le webhook `charge.succeeded`, consultez le contenu de `payment_method_details` pour localiser la [payment_reference](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-us_bank_account-payment_reference).

L’exemple d’événement suivant montre le rendu d’un paiement ACH abouti avec un numéro de référence de paiement.

#### charge-succeeded

```json
{
  "id": "{{EVENT_ID}}",
  "object": "event",
  // omitted some fields in the example
  "type": "charge.succeeded",
  "data": {
    "object": {
      "id": "{{PAYMENT_ID}}",
      "object": "charge",
      //...
    "paid": true,
    "payment_intent": "{{PAYMENT_INTENT_ID}}",
    "payment_method": "{{PAYMENT_METHOD_ID}}",
    "payment_method_details": {
      "type": "us_bank_account",
      "us_bank_account": {
        "account_holder_type": "individual",
        "account_type": "checking",
        "bank_name": "TEST BANK",
        "fingerprint": "Ih3foEnRvLXShyfB",
        "last4": "1000","payment_reference": "091000015001234",
        "routing_number": "110000000"
        }
      }
      // ...
    }
  }
}
```

Consultez le contenu de `destination_details` pour localiser la [référence du remboursement](https://docs.stripe.com/api/refunds/object.md#refund_object-destination_details-us_bank_transfer-reference) associée aux paiements ACH remboursés.

L’exemple d’événement suivant montre le rendu d’un remboursement de paiement ACH abouti avec un numéro de référence de remboursement. En savoir plus sur les [remboursements](https://docs.stripe.com/refunds.md).

#### charge-refund-updated

```json
{
  "id": "{{EVENT_ID}}",
  "object": "event",
  "type": "charge.refund.updated",
  "data": {
    "object": {
      "id": "{{REFUND_ID}}",
      "object": "refund",
      //...
    "payment_intent": "{{PAYMENT_INTENT_ID}}",
    "destination_details": {
      "type": "us_bank_transfer",
      "us_bank_transfer": {"reference": "091000015001111",
        "reference_status": "available"
        }
      }
      // ...
    }
  }
}
```


# Vue Web

> This is a Vue Web for when payment-ui is mobile and platform is webview. View the full page at https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment?payment-ui=mobile&platform=webview.

> #### Utiliser l’API Accounts v2 pour représenter les clients
> 
> L’API Accounts&nbsp;v2 est généralement disponible pour les utilisateurs de Connect et en aperçu public pour les autres utilisateurs de Stripe. Si vous avez accès à l’aperçu Accounts&nbsp;v2, vous devez [spécifier une version d’aperçu](https://docs.stripe.com/api-v2-overview.md#sdk-and-api-versioning) dans votre code.
> 
> Pour demander l’accès à l’aperçu Accounts&nbsp;v2, 
> 
> Dans la plupart des cas d’usage, nous vous recommandons de [modéliser vos clients en tant qu’objets Account configurés par le client](https://docs.stripe.com/connect/use-accounts-as-customers.md), plutôt que d’utiliser des objets [Customer](https://docs.stripe.com/api/customers.md).

> Nous vous recommandons de suivre le guide [Accepter un paiement](https://docs.stripe.com/payments/accept-a-payment.md), sauf si vous devez exécuter la confirmation manuelle côté serveur, ou si votre intégration requiert la présentation de moyens de paiement de manière distincte. Si vous avez déjà intégré Elements, consultez le [Guide de migration du Payment&nbsp;Element](https://docs.stripe.com/payments/payment-element/migration.md).

Voici les différentes étapes nécessaires pour accepter des paiements par prélèvement automatique ACH sur la vue Web de votre application&nbsp;:

- Création d’un objet de suivi du paiement
- Gestion des potentielles redirections OAuth de la vue Web
- Collecte des informations du moyen de paiement
- Soumission du paiement à Stripe à des fins de traitement
- Vérification du compte bancaire de votre client

> Le prélèvement automatique ACH est un moyen de paiement à [notification différée](https://docs.stripe.com/payments/payment-methods.md#payment-notification), ce qui signifie que les fonds ne sont pas immédiatement disponibles après le paiement. Il faut généralement compter 4&nbsp;jours ouvrables pour qu’un paiement arrive sur votre compte.

Stripe utilise l’objet de paiement, le [Payment Intent](https://docs.stripe.com/payments/payment-intents.md), pour suivre et gérer l’ensemble des états du paiement jusqu’à son aboutissement.

Avant de commencer, veillez à disposer d’un accès à la bêta du moyen de paiement par prélèvement automatique ACH. Si vous ne pouvez pas encore y accéder, contactez votre gestionnaire de compte pour en demander l’accès.

## Aperçu [Côté client]

Pour intégrer Financial Connections dans une vue Web, commencez par l’un de nos exemples d’applications WebView&nbsp;:

- [WebView Android](https://github.com/stripe/stripe-android/blob/master/financial-connections-example/src/main/java/com/stripe/android/financialconnections/example/FinancialConnectionsWebviewExampleActivity.kt)
- [iOS WKWebview](https://github.com/stripe/stripe-ios/blob/master/Example/FinancialConnections%20Example/FinancialConnections%20Example/WebViewViewController.swift)

Ces exemples d’applications sont entièrement fonctionnels (à la fois sur les simulateurs et sur les appareils physiques) et contiennent tout le code nécessaire pour configurer Financial Connections et gérer les événements envoyés à votre application via des URL de redirection HTTP.

## Configurez Stripe [Côté serveur]

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

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

#### Ruby

```bash
# Available as a gem
sudo gem install stripe
```

```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```

## Créer ou récupérer un objet Customer [Recommandé] [Côté serveur]

> #### Utiliser l’API Accounts v2 pour représenter les clients
> 
> L’API Accounts&nbsp;v2 est généralement disponible pour les utilisateurs de Connect et en aperçu public pour les autres utilisateurs de Stripe. Si vous avez accès à l’aperçu Accounts&nbsp;v2, vous devez [spécifier une version d’aperçu](https://docs.stripe.com/api-v2-overview.md#sdk-and-api-versioning) dans votre code.
> 
> Pour demander l’accès à l’aperçu Accounts&nbsp;v2, 
> 
> Dans la plupart des cas d’usage, nous vous recommandons de [modéliser vos clients en tant qu’objets Account configurés par le client](https://docs.stripe.com/connect/use-accounts-as-customers.md), plutôt que d’utiliser des objets [Customer](https://docs.stripe.com/api/customers.md).

#### Accounts&nbsp;v2

Créez un objet [Account](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-configuration-customer) configuré par le client lorsque votre utilisateur crée un compte auprès de votre entreprise, ou récupérez un `Account` existant associé à cet utilisateur. L’association de l’ID de l’objet `Account` à votre propre représentation interne d’un client vous permet de récupérer et d’utiliser ultérieurement les informations de moyen de paiement enregistrées. Ajoutez une adresse e-mail à l’`objet Account` pour activer [l’optimisation des utilisateurs connus](https://docs.stripe.com/financial-connections/fundamentals.md#return-user-optimization) de Financial Connections.

```curl
curl -X POST https://api.stripe.com/v2/core/accounts \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-03-25.preview" \
  --json '{
    "contact_email": "{{CUSTOMER_EMAIL}}"
  }'
```

#### Customers&nbsp;v1

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) lorsque votre client crée un compte auprès de votre entreprise, ou récupérez l’objet `Customer` existant associé à cet utilisateur. L’association de l’ID de l’objet `Customer` à votre propre représentation interne d’un client vous permet de récupérer et d’utiliser ultérieurement les informations de paiement enregistrées. Ajoutez une adresse e-mail à l’objet `Customer` pour activer [l’optimisation des utilisateurs connus](https://docs.stripe.com/financial-connections/fundamentals.md#return-user-optimization) de Financial Connections.

```curl
curl https://api.stripe.com/v1/customers \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d email={{CUSTOMER_EMAIL}}
```

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

Un [PaymentIntent](https://docs.stripe.com/api/payment_intents.md) est un objet qui représente votre intention d’encaisser le paiement d’un client et qui suit le cycle de vie du processus de paiement étape par étape.

Créez un PaymentIntent sur votre serveur&nbsp;:

1. Indiquez le montant à collecter et la devise `usd`.
1. Ajoutez `us_bank_account` à la liste des [types de moyens de paiement](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types).
1. Spécifiez l’[ID](https://docs.stripe.com/api/customers/object.md#customer_object-id) de l’objet Customer.
1. Définissez le paramètre [data `permissions`](https://docs.stripe.com/financial-connections/fundamentals.md#data-permissions) pour inclure `payment_method`, ainsi que toute autre autorisation requise pour répondre à votre cas d’usage.
1. Définissez le paramètre `return_url`, qui vous permet de rediriger vos clients vers votre application s’ils se connectent à leur banque avec OAuth dans le navigateur d’origine.
| iOS                                                         | Android                                                             |
| ----------------------------------------------------------- | ------------------------------------------------------------------- |
| L’URL return_url doit être un lien universel de type https. | Le return_url doit être un lien vers une application Android https. |
1. Si vous souhaitez réutiliser le moyen de paiement dans le futur, fournissez le paramètre [setup_future_usage](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-setup_future_usage) avec la valeur `off_session`.

L’exemple de code suivant montre comment créer un [PaymentIntent](https://docs.stripe.com/api/payment_intents.md) optimisé pour WebView, y compris la demande d’autorisation `payment_method`&nbsp;:

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d setup_future_usage=off_session \
  -d "customer={{CUSTOMER_ID}}" \
  -d "payment_method_types[]=us_bank_account" \
  -d "payment_method_options[us_bank_account][financial_connections][permissions][]=payment_method" \
  --data-urlencode "payment_method_options[us_bank_account][financial_connections][return_url]=https://stripe.com"
```

### 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 du moyen de paiement [Côté client]

Lorsqu’un client clique pour payer avec ACH Direct Debit, nous vous recommandons d’utiliser Stripe.js pour soumettre le paiement à Stripe. [Stripe.js](https://docs.stripe.com/payments/elements.md) est notre bibliothèque JavaScript de base pour créer les tunnels de paiement&nbsp;: elle gère automatiquement les opérations complexes d’intégration et vous permettra de facilement étendre votre intégration à d’autres moyens de paiement par la suite.

Intégrez le script Stripe.js à votre page de paiement en l’ajoutant entre les balises `head` de votre fichier HTML.

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

Créez une instance de Stripe.js avec le code JavaScript suivant sur votre page de paiement.

```javascript
// Set your publishable key. Remember to change this to your live publishable key in production!
// See your keys here: https://dashboard.stripe.com/apikeys
const stripe = Stripe('<<YOUR_PUBLISHABLE_KEY>>');
```

Plutôt que d’envoyer la totalité de l’objet PaymentIntent au client, utilisez sa *clé secrète* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)) provenant de l’étape précédente. Il ne s’agit pas de vos clés API qui authentifient les requêtes de l’API de Stripe.

Utilisez la clé secrète du client avec prudence, car elle peut servir à finaliser le paiement. Ne l’enregistrez pas, ne l’intégrez pas dans des URL et ne la dévoilez à personne d’autre que votre client.

Utilisez [stripe.collectBankAccountForPayment](https://docs.stripe.com/js/payment_intents/collect_bank_account_for_payment)  pour collecter les coordonnées bancaires avec [Financial Connections](https://docs.stripe.com/financial-connections.md), créer un objet *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) et l’associer au PaymentIntent. Pour créer un PaymentMethod par prélèvement automatique ACH, vous devez obligatoirement inclure le nom du titulaire du compte dans le paramètre `billing_details`.

```javascript
// Use the form that already exists on the web page.
const paymentMethodForm = document.getElementById('payment-method-form');
const confirmationForm = document.getElementById('confirmation-form');

paymentMethodForm.addEventListener('submit', (ev) => {
  ev.preventDefault();
  const accountHolderNameField = document.getElementById('account-holder-name-field');
  const emailField = document.getElementById('email-field');

  // Calling this method will open the instant verification dialog.
  stripe.collectBankAccountForPayment({
    clientSecret: clientSecret,
    params: {
      payment_method_type: 'us_bank_account',
      payment_method_data: {
        billing_details: {
          name: accountHolderNameField.value,
          email: emailField.value,
        },
      },
    },
    expand: ['payment_method'],
  })
  .then(({paymentIntent, error}) => {
    if (error) {
      console.error(error.message);
      // PaymentMethod collection failed for some reason.
    } else if (paymentIntent.status === 'requires_payment_method') {
      // Customer canceled the hosted verification modal. Present them with other
      // payment method type options.
    } else if (paymentIntent.status === 'requires_confirmation') {
      // We collected an account - possibly instantly verified, but possibly
      // manually-entered. Display payment method details and mandate text
      // to the customer and confirm the intent once they accept
      // the mandate.
      confirmationForm.show();
    }
  });
});
```

Le [flux d’authentification de Financial Connections](https://docs.stripe.com/financial-connections/fundamentals.md#authentication-flow) gère automatiquement la collecte et la vérification des informations de compte bancaire. Lorsque votre client termine le flux d’authentification, le *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) est automatiquement associé au PaymentIntent, et créée un compte [Financial Connections](https://docs.stripe.com/api/financial_connections/accounts.md).

> Les comptes bancaires que vos clients associent par saisie manuelle ou par le biais de microversements ne fourniront pas d’accès à certaines données supplémentaires comme le solde, le propriétaire et les transactions.



Afin de proposer une expérience utilisateur optimale quel que soit l’appareil utilisé, définissez le paramètre `minimum-scale` de la fenêtre d’affichage de votre page sur 1 à l’aide de la balise `meta`.

```html
<meta name="viewport" content="width=device-width, minimum-scale=1" />
```

### Gérer les redirections OAuth sur votre application mobile

En plus d’inclure Stripe.js sur votre page avec vue Web intégrée, votre application devra peut-être gérer la redirection de vos clients vers leur navigateur mobile d’origine pour la connexion OAuth.

> À compter du 1er&nbsp;janvier&nbsp;2024, toutes les intégrations basées sur des vues Web devront gérer correctement l’authentification sécurisée des établissements et les redirections d’applications, sous peine d’affecter votre flux d’autorisation Financial Connections. Reportez-vous aux instructions iOS ou Android ci-dessus.

#### Android

Sur Android, votre application doit enregistrer un [filtre d’intention](https://developer.android.com/guide/components/intents-filters) pour la `return_url` précédemment définie dans votre manifeste.

En savoir plus sur la [gestion des liens sur Android](https://developer.android.com/training/app-links).

```xml
<activity
    android:name="...">

    <intent-filter>
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />

        <!-- Data structure to listen for "https://stripe.com" URL -->
        <data android:scheme="http" />
        <data android:scheme="https" />

        <data android:host="stripe.com" />
    </intent-filter>
</activity>
```

Enregistrez un [WebViewClient](https://developer.android.com/reference/android/webkit/WebViewClient) sur votre WebView. Vous pouvez remplacer `shouldOverrideUrlLoading` pour ouvrir les pages de connexion OAuth dans un onglet personnalisé ou une instance de navigateur sécurisée&nbsp;:

```kotlin
val webViewClient = object : WebViewClient() {
  override fun shouldOverrideUrlLoading(
      view: WebView,
      webResourceRequest: WebResourceRequest
  ): Boolean {
      val url = webResourceRequest.url.toString()
      CustomTabsIntent.Builder().build().launchUrl(view.context, Uri.parse(url))
      return true
  }
}
// ...

// register the web view client on your WebView
myWebView.webViewClient = webViewClient
```

#### iOS

Sur iOS, votre application doit être équipée pour gérer la tentative d’ouverture d’une fenêtre OAuth par WebView. Ce processus consiste à tenter d’ouvrir l’URL dans une application bancaire ou, à défaut de prise en charge, dans une instance de navigateur sécurisée.

Lorsque `WKWebView` intercepte une nouvelle requête de fenêtre, essayez d’abord d’ouvrir l’URL en tant que lien universel. Les liens universels permettent aux applications bancaires installées sur l’appareil de l’utilisateur de gérer directement les URL qui leur sont associées, ce qui simplifie le processus d’authentification. Cette méthode améliore la sécurité et la praticité pour l’utilisateur en s’appuyant sur les applications existantes et approuvées déjà sur l’appareil.

Si l’ouverture de l’URL en tant que lien universel échoue, soit parce qu’aucune application bancaire n’est installée, soit parce que le lien n’est pas reconnu, l’application doit se rabattre sur l’utilisation de `ASWebAuthenticationSession`. Cette session facilite le flux d’authentification au sein d’un navigateur sécurisé intégré à l’application qui garantit le traitement sécurisé des informations sensibles. `ASWebAuthenticationSession` imite le navigateur natif, ce qui permet aux utilisateurs de s’authentifier sans quitter l’application.

```swift
class ViewController: UIViewController {
  private var webAuthenticationSession: ASWebAuthenticationSession?

  override func viewDidLoad() {
      super.viewDidLoad()

      // Initialize and configure your WKWebView
      let webView = WKWebView(frame: .zero, configuration: WKWebViewConfiguration())

      // Load your website URL
      webView.load(URLRequest(url: URL(string: "https://yourwebsite.com")!))

      // Add the web view to the view
      view.addSubview(webView)

      // Important: Assign a `uiDelegate` to handle redirects
      webView.uiDelegate = self
  }
}

extension ViewController: WKUIDelegate {
  func webView(
      _ webView: WKWebView,
      createWebViewWith configuration: WKWebViewConfiguration,
      for navigationAction: WKNavigationAction,
      windowFeatures: WKWindowFeatures
  ) -> WKWebView? {
      // Check if the link is attempting to open in a new window.
      // This is typically the case for a banking partner's authentication flow.
      let isAttemptingToOpenLinkInNewWindow = navigationAction.targetFrame?.isMainFrame != true

      if isAttemptingToOpenLinkInNewWindow, let url = navigationAction.request.url {
          // Attempt to open the URL as a universal link.
          // Universal links allow apps on the device to handle specific URLs directly.
          UIApplication.shared.open(
              url,
              options: [.universalLinksOnly: true],
              completionHandler: { [weak self] success in
                  guard let self else { return }
                  if success {
                      // App-to-app flow:
                      // The URL was successfully opened in a banking application that supports universal links.
                      print("Successfully opened the authentication URL in a bank app: \(url)")
                  } else {
                      // Fallback for when no compatible bank app is found:
                      // Create an `ASWebAuthenticationSession` to handle the authentication in a secure in-app browser
                      self.launchInSecureBrowser(url: url)
                  }
              })
      }
      return nil
  }

  private func launchInSecureBrowser(url: URL) {
    let redirectURL = URL(string: "https://yourwebsite.com")!
    let webAuthenticationSession = ASWebAuthenticationSession(
        url: url,
        callbackURLScheme: redirectURL.scheme,
        completionHandler: { redirectURL, error in
            if let error {
                if
                    (error as NSError).domain == ASWebAuthenticationSessionErrorDomain,
                    (error as NSError).code == ASWebAuthenticationSessionError.canceledLogin.rawValue
                {
                    print("User manually closed the browser by pressing 'Cancel' at the top-left corner.")
                } else {
                    print("Received an error from ASWebAuthenticationSession: \(error)")
                }
            } else {
                // IMPORTANT NOTE:
                // The browser will automatically close when
                // the `callbackURLScheme` is called.
                print("Received a redirect URL: \(redirectURL?.absoluteString ?? "null")")
            }
        }
    )
    // Store the session reference to prevent premature deallocation
    self.webAuthenticationSession = webAuthenticationSession

    // Set the presentation context provider to handle the browser's UI presentation
    webAuthenticationSession.presentationContextProvider = self

    // Use an ephemeral session to enhance privacy
    // This also disables the initial Apple alert about signing in to another app
    webAuthenticationSession.prefersEphemeralWebBrowserSession = true

    // Initiate the authentication session
    webAuthenticationSession.start()
  }
}
```

Une fois que votre client s’est connecté à l’environnement de sa banque et qu’il a autorisé l’accès à ses comptes, Stripe le redirige vers l’URL `return_url` pour le faire revenir dans votre application. À ce stade, votre client peut reprendre et terminer le processus de collecte d’informations du compte bancaire.

## Collecter l'accusé de réception du mandat et effectuer le paiement [Côté client]

Avant de pouvoir initier le paiement, vous devez obtenir l’autorisation de votre client en affichant les conditions du mandat pour qu’il les accepte.

Pour vous conformer aux règles de la Nacha, vous devez obtenir l’autorisation d’initier le paiement auprès de votre client. Pour ce faire, présentez-lui les conditions du mandat et demandez-lui de les accepter. Pour en savoir plus, consultez la page sur les [mandats](https://docs.stripe.com/payments/ach-direct-debit.md#mandates).

Lorsque le client accepte les conditions du mandat, vous devez confirmer le PaymentIntent. Utilisez [stripe.confirmUsBankAccountPayment](https://docs.stripe.com/js/payment_intents/confirm_us_bank_account_payment) pour mener à bien le paiement une fois que le client a soumis le formulaire.

```javascript
confirmationForm.addEventListener('submit', (ev) => {
  ev.preventDefault();
  stripe.confirmUsBankAccountPayment(clientSecret)
  .then(({paymentIntent, error}) => {
    if (error) {
      console.error(error.message);
      // The payment failed for some reason.
    } else if (paymentIntent.status === "requires_payment_method") {
      // Confirmation failed. Attempt again with a different payment method.
    } else if (paymentIntent.status === "processing") {
      // Confirmation succeeded! The account will be debited.
      // Display a message to customer.
    } else if (paymentIntent.next_action?.type === "verify_with_microdeposits") {
      // The account needs to be verified through microdeposits.
      // Display a message to consumer with next steps (consumer waits for
      // microdeposits, then enters a statement descriptor code on a page sent to them through email).
    }
  });
});
```

> [stripe.confirmUsBankAccountPayment](https://docs.stripe.com/js/payment_intents/confirm_us_bank_account_payment) peut prendre plusieurs secondes pour s’exécuter. Pendant ce temps, désactivez toute nouvelle soumission de votre formulaire et affichez un indicateur d’attente (par exemple un spinner). Si vous recevez une erreur, affichez-la au client, réactivez le formulaire et masquez l’indicateur d’attente.

Sauf échec de l’opération, Stripe renvoie un objet PaymentIntent présentant l’un des états suivants&nbsp;:

| Statut            | Description                                                                              | Étapes suivantes                                                                                                                                                                     |
| ----------------- | ---------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `requires_action` | Une action supplémentaire est requise pour finaliser la vérification du compte bancaire. | Étape 6&nbsp;: [Vérification des comptes bancaires à l’aide de microversements](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#web-verify-with-microdeposits) |
| `processing`      | Le compte bancaire a été vérifié instantanément ou la vérification n’est pas nécessaire. | Étape 7&nbsp;: [Confirmation du succès du PaymentIntent](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#web-confirm-paymentintent-succeeded)                  |

Après avoir confirmé le PaymentIntent, un e-mail de confirmation du mandat et les coordonnées bancaires recueillies doivent être envoyés à votre client. Par défaut, Stripe gère cette étape, mais vous pouvez choisir d’[envoyer des notifications personnalisées](https://docs.stripe.com/payments/ach-direct-debit.md#mandate-and-microdeposit-emails) si vous préférez.

## Vérifier le compte bancaire à l'aide de microversements [Côté client]

Tous les clients ne peuvent pas vérifier instantanément le compte bancaire. Cette étape ne s’applique que si votre client a choisi de se désinscrire du flux de vérification instantanée dans l’étape précédente.

Dans ce cas, Stripe envoie un microversement `descriptor_code` ou `amount` si un problème survient au cours de la vérification du compte bancaire. Ces microversements apparaissent sur le relevé en ligne du client sous 1 à 2&nbsp;jours ouvrables.

- **Code de libellé**&nbsp;: Stripe envoie un microversement unique de 0,01&nbsp;USD sur le compte bancaire du client avec un `descriptor_code` unique à 6&nbsp;chiffres qui commence par SM. Votre client utilise cette chaîne pour vérifier son compte bancaire.
- **Montant**&nbsp;: Stripe envoie deux microversements distincts sur le compte bancaire du client avec un code de libellé indiquant `ACCTVERIFY`. Votre client utilise les montants de ces versements pour vérifier son compte bancaire.

L’appel [stripe.confirmUsBankAccountPayment](https://docs.stripe.com/js/payment_intents/confirm_us_bank_account_payment) effectué à l’étape précédente renvoie un PaymentIntent avec l’état `requires_action`. Le champ `next_action` du PaymentIntent contient des informations utiles à la vérification.

```javascript
next_action: {
  type: "verify_with_microdeposits",
  verify_with_microdeposits: {
    arrival_date: 1647586800,
    hosted_verification_url: "https://payments.stripe.com/…",
    microdeposit_type: "descriptor_code"
  }
}
```

Si vous avez fourni une [adresse e-mail de facturation](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-billing_details-email), Stripe utilise cette dernière pour notifier votre client de la date d’arrivée prévue des versements. L’e-mail envoyé inclut un lien vers la page de vérification hébergée par Stripe, sur laquelle il peut confirmer les montants des versements et effectuer la vérification.

> Les tentatives de vérification sont limitées à dix pour les microversements basés sur des libellés et à trois pour ceux basés sur des montants. Si vous atteignez cette limite, nous ne pouvons plus vérifier le compte bancaire. En outre, les vérifications à l’aide de microversements expirent au bout de 10&nbsp;jours. Si vous ne vérifiez pas les microversements pendant ce laps de temps, le PaymentIntent réitère sa demande d’informations sur le moyen de paiement. En informant clairement vos clients sur le fonctionnement de ces microversements, vous évitez d’éventuels problèmes liés à la vérification.

### Facultatif&nbsp;: Envoi de notifications personnalisées par e-mail

Si vous le souhaitez, vous pouvez envoyer des [notifications personnalisées par e-mail](https://docs.stripe.com/payments/ach-direct-debit.md#mandate-and-microdeposit-emails) à votre client. Après avoir configuré les e-mails personnalisés, vous devez préciser comment le client doit répondre à l’e-mail de vérification. Pour ce faire, choisissez *une* des options suivantes&nbsp;:

- Utilisez la page de vérification hébergée par Stripe. Pour ce faire, utilisez l’URL `verify_with_microdeposits[hosted_verification_url]` de l’objet [next_action](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-next_action-verify_with_microdeposits-hosted_verification_url) pour diriger votre client vers la procédure de vérification.

- Si vous préférez ne pas utiliser la page de vérification hébergée par Stripe, créez un formulaire sur votre site. Vos clients pourront ensuite utiliser ce formulaire pour vous transmettre les montants des microversements et vérifier le compte bancaire à l’aide de [Stripe.js](https://docs.stripe.com/js/payment_intents/verify_microdeposits_for_payment).

  - Configurez au moins le formulaire pour qu’il gère le paramètre `descriptor code`, qui comporte une chaîne à 6&nbsp;chiffres à des fins de vérification.
  - Stripe recommande également de configurer votre formulaire pour gérer le paramètre `amounts`, car certaines banques utilisées par vos clients peuvent l’exiger.

  Les intégrations transmettent uniquement le code de libellé, `descriptor_code`, *ou* les montants, `amounts`. Pour savoir quel paramètre votre intégration utilise, vérifiez la valeur de `verify_with_microdeposits[microdeposit_type]` dans l’objet `next_action`.

```javascript
stripe.verifyMicrodepositsForPayment(clientSecret, {
  // Provide either a descriptor_code OR amounts, not both
  descriptor_code: 'SMT86W',
  amounts: [32, 45],
});
```

Dès que le compte bancaire a été vérifié, Stripe renvoie l’objet PaymentIntent avec l’état `status` défini sur `processing`, et envoie un événement *webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) [payment_intent.processing](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.processing).

La vérification peut échouer pour plusieurs raisons. L’échec peut se produire de manière synchrone comme une réponse d’erreur directe, ou de manière asynchrone à travers un événement webhook [payment_intent.payment_failed](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.failed) (voir les exemples ci-après).

#### Erreur synchrone

```json
{
  "error": {
    "code": "payment_method_microdeposit_verification_amounts_mismatch",
    "message": "The amounts provided do not match the amounts that were sent to the bank account. You have {attempts_remaining} verification attempts remaining.",
    "type": "invalid_request_error"
  }
}
```

#### Événement de webhook

```javascript
{
  "object": {
    "id": "pi_1234",
    "object": "payment_intent",
    "customer": "cus_0246",
    ...
    "last_payment_error": {
      "code": "payment_method_microdeposit_verification_attempts_exceeded",
      "message": "You have exceeded the number of allowed verification attempts.",
    },
    ...
    "status": "requires_payment_method"
  }
}
```

| Code d’erreur                                                | Synchrone ou asynchrone                                      | Message                                                                                                                                     | Changement d’état                                                                                |
| ------------------------------------------------------------ | ------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
| `payment_method_microdeposit_failed`                         | De façon synchrone ou asynchrone via un événement de webhook | Les microversements ont échoué. Veuillez vérifier la validité des numéros de compte, de l’établissement et de transit fournis.              | `status` est à l’état `requires_payment_method` et le paramètre `last_payment_error` est défini. |
| `payment_method_microdeposit_verification_amounts_mismatch`  | De façon synchrone                                           | Les montants fournis ne correspondent pas à ceux envoyés au compte bancaire. Il vous reste {attempts_remaining} tentatives de vérification. | Inchangé                                                                                         |
| `payment_method_microdeposit_verification_attempts_exceeded` | De façon synchrone ou asynchrone via un événement de webhook | Dépassement du nombre de tentatives de vérification autorisé                                                                                | `status` est à l’état `requires_payment_method` et le paramètre `last_payment_error` est défini. |
| `payment_method_microdeposit_verification_timeout`           | De façon asynchrone via un événement de webhook              | Expiration du microversement. Le client n’a pas vérifié son compte bancaire dans le délai de 10&nbsp;jours prévu.                           | `status` est à l’état `requires_payment_method` et le paramètre `last_payment_error` est défini. |

## Confirmer l'aboutissement du PaymentIntent [Côté serveur]

Le prélèvement automatique ACH est un moyen de paiement à [notification différée](https://docs.stripe.com/payments/payment-methods.md#payment-notification). Ceci signifie que pour recevoir une notification du succès ou de l’échec d’un paiement, il faut compter jusqu’à quatre jours ouvrables après le déclenchement du prélèvement sur le compte du client.

Initialement, le PaymentIntent que vous créez présente l’état `processing`. Une fois le paiement abouti, l’état du PaymentIntent passe de `processing` à `succeeded`.

Nous vous recommandons d’utiliser des [webhooks](https://docs.stripe.com/payments/payment-intents/verifying-status.md#webhooks) afin de *confirmer* (Confirming an intent indicates that the customer intends to use the current or provided payment method. Upon confirmation, the intent attempts to initiate the portions of the flow that have real-world side effects) que le paiement a réussi et d’informer le client que le paiement a été effectué. Vous pouvez également afficher les événements sur le [Dashboard Stripe](https://dashboard.stripe.com/events).

#### Événements PaymentIntent

Les événements suivants sont envoyés lorsque le PaymentIntent change d’état&nbsp;:

| Événement                       | Description                                                                                                                    | Étape suivante                                                                                                                                                                                                                                                                                                                       |
| ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `payment_intent.processing`     | Le paiement du client a bien été envoyé à Stripe.                                                                              | Attendez que le paiement aboutisse ou échoue.                                                                                                                                                                                                                                                                                        |
| `payment_intent.succeeded`      | Le paiement du client a abouti.                                                                                                | Traitez la commande de biens ou de services.                                                                                                                                                                                                                                                                                         |
| `payment_intent.payment_failed` | Le paiement du client a été refusé. Ceci peut aussi s’appliquer en cas d’échec de la vérification à l’aide de microversements. | Envoyez un e-mail ou une notification push au client pour lui demander d’utiliser un autre moyen de paiement. Si le webhook a été envoyé suite à l’échec de la vérification à l’aide de micro-versements, l’utilisateur doit à nouveau saisir ses coordonnées bancaires. De nouveaux micro-versements seront déposés sur son compte. |

#### Événements de paiement

Vous pouvez également utiliser des webhooks Charge supplémentaires pour suivre l’état du paiement. Dès réception du webhook `charge.updated`, le paiement ne peut plus être annulé.

Les événements suivants sont envoyés lorsque le paiement change d’état&nbsp;:

| Événement          | Description                                                                                                                                                                           | Étape suivante                                                                                 |
| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- |
| `charge.pending`   | Le paiement du client a bien été créé.                                                                                                                                                | Attendez que le paiement initié soit traité.                                                   |
| `charge.updated`   | Le paiement du client a été mis à jour. Il peut être émis lorsqu’une nouvelle opération sur solde est créée, qu’une description ou que des métadonnées de paiement sont mises à jour. | Attendez que le paiement aboutisse ou échoue.                                                  |
| `charge.succeeded` | Le paiement du client a abouti et les fonds sont disponibles sur votre solde.                                                                                                         | Traitez la commande de biens ou de services.                                                   |
| `charge.failed`    | Le paiement du client a échoué.                                                                                                                                                       | Vérifiez le failure_code et le failure_message du paiement pour déterminer la marche à suivre. |

## Tester votre intégration

Découvrez comment tester des scénarios avec des vérifications instantanées à l’aide de [Financial Connections](https://docs.stripe.com/financial-connections/testing.md#web-how-to-use-test-accounts).

### Envoyer des e-mails de transaction dans un environnement de test

Une fois que vous avez collecté les coordonnées bancaires et accepté un mandat, envoyez les courriels de confirmation du mandat et de vérification du microversement dans un *environnement de bac à sable* (A sandbox is an isolated test environment that allows you to test Stripe functionality in your account without affecting your live integration. Use sandboxes to safely experiment with new features and changes).

Si votre domaine est **{domain}** et votre nom d’utilisateur est **{username}**, utilisez le format d’adresse e-mail suivant pour envoyer des e-mails de transaction de test&nbsp;: **{username}+test\_email@{domain}**.

Par exemple, si votre domaine est **example.com** et que votre nom d’utilisateur est **info**, utilisez le format **info+test\_email@example.com** pour tester les paiements ACH Direct Debit. Ce format garantit que les e-mails sont acheminés correctement. Si vous n’incluez pas le suffixe **+test\_email**, nous n’enverrons pas l’e-mail.

> Vous devez [configurer votre compte Stripe](https://docs.stripe.com/get-started/account/set-up.md) avant de pouvoir déclencher ces e-mails pendant les tests.

### Numéros de comptes de test

Stripe fournit plusieurs numéros de compte de test et les tokens correspondants que vous pouvez utiliser pour vous assurer que votre intégration pour les comptes bancaires saisis manuellement est prête à passer en mode production.

| Numéro de compte | Token                                  | Numéro de routage | Comportement                                                                                                                                                                                                                                                                                                         |
| ---------------- | -------------------------------------- | ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `000123456789`   | `pm_usBankAccount_success`             | `110000000`       | Le paiement aboutit.                                                                                                                                                                                                                                                                                                 |
| `000111111113`   | `pm_usBankAccount_accountClosed`       | `110000000`       | Le paiement échoue parce que le compte est clôturé.                                                                                                                                                                                                                                                                  |
| `000000004954`   | `pm_usBankAccount_riskLevelHighest`    | `110000000`       | Le paiement est bloqué par Radar en raison d’un [risque élevé de fraude](https://docs.stripe.com/radar/risk-evaluation.md#high-risk).                                                                                                                                                                                |
| `000111111116`   | `pm_usBankAccount_noAccount`           | `110000000`       | Le paiement échoue car aucun compte n’est trouvé.                                                                                                                                                                                                                                                                    |
| `000222222227`   | `pm_usBankAccount_insufficientFunds`   | `110000000`       | Le paiement échoue en raison de fonds insuffisants.                                                                                                                                                                                                                                                                  |
| `000333333335`   | `pm_usBankAccount_debitNotAuthorized`  | `110000000`       | Le paiement échoue parce que les débits ne sont pas autorisés.                                                                                                                                                                                                                                                       |
| `000444444440`   | `pm_usBankAccount_invalidCurrency`     | `110000000`       | Le paiement échoue en raison d’une devise non valide.                                                                                                                                                                                                                                                                |
| `000666666661`   | `pm_usBankAccount_failMicrodeposits`   | `110000000`       | Le paiement ne parvient pas à envoyer les microversements.                                                                                                                                                                                                                                                           |
| `000555555559`   | `pm_usBankAccount_dispute`             | `110000000`       | Le paiement déclenche un litige.                                                                                                                                                                                                                                                                                     |
| `000000000009`   | `pm_usBankAccount_processing`          | `110000000`       | Le traitement du paiement est indéfini. Utile pour tester {&nbsp;% si $checkoutSessions %}[Expiration de la session de paiement](https://docs.stripe.com/api/checkout/sessions/expire.md){&nbsp;% else /&nbsp;%}[Annulation de PaymentIntent](https://docs.stripe.com/api/payment_intents/cancel.md){&nbsp;% /if %}. |
| `000777777771`   | `pm_usBankAccount_weeklyLimitExceeded` | `110000000`       | Le paiement échoue, car son montant entraîne un dépassement de la limite hebdomadaire de volume de paiement du compte.                                                                                                                                                                                               |
| `000888888885`   |                                        | `110000000`       | Le paiement échoue en raison d’un [numéro de compte tokenisé](https://docs.stripe.com/financial-connections/tokenized-account-numbers.md) désactivé.                                                                                                                                                                 |

Avant d’effectuer les transactions de test, vous devez vérifier tous les comptes de test pour lesquels le paiement aboutit ou échoue automatiquement. Pour ce faire, utilisez les codes de libellé ou les montants de microversements de test ci-dessous.

### Tester des codes de libellé et des montants de microversements

Pour simuler différents scénarios, utilisez ces montants de microversements *ou* ces codes de libellé 0.01.

| Valeurs de microversement | Valeurs de code de libellé 0.01 | Scénario                                                                |
| ------------------------- | ------------------------------- | ----------------------------------------------------------------------- |
| `32` et `45`              | SM11AA                          | Simule la vérification du compte.                                       |
| `10` et `11`              | SM33CC                          | Simule le dépassement du nombre de tentatives de vérification autorisé. |
| `40` et `41`              | SM44DD                          | Simule l’expiration du délai de validité d’un microversement.           |

### Comportement de règlement des tests

Les transactions de test sont réglées instantanément et ajoutées à votre solde de test disponible. Ce comportement diffère de celui du mode production, où les transactions peuvent prendre [plusieurs jours](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#timing) pour être réglées dans votre solde disponible.

## Optional: Vérification instantanée uniquement [Côté serveur]

Par défaut, le paiement à l’aide d’un compte bancaire américain permet à vos clients d’utiliser la vérification instantanée du compte bancaire ou les microversements. Vous pouvez aussi exiger la vérification instantanée du compte bancaire uniquement en utilisant le paramètre [verification_method](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-us_bank_account-verification_method) à la création du PaymentIntent.

#### Accounts&nbsp;v2

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d setup_future_usage=off_session \
  -d "customer_account={{CUSTOMERACCOUNT_ID}}" \
  -d "payment_method_types[]=us_bank_account" \
  -d "payment_method_options[us_bank_account][verification_method]=instant" \
  -d "payment_method_options[us_bank_account][financial_connections][permissions][]=payment_method" \
  -d "payment_method_options[us_bank_account][financial_connections][permissions][]=balances"
```

#### Customers&nbsp;v1

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d setup_future_usage=off_session \
  -d "customer={{CUSTOMER_ID}}" \
  -d "payment_method_types[]=us_bank_account" \
  -d "payment_method_options[us_bank_account][verification_method]=instant" \
  -d "payment_method_options[us_bank_account][financial_connections][permissions][]=payment_method" \
  -d "payment_method_options[us_bank_account][financial_connections][permissions][]=balances"
```

Ainsi, vous n’avez pas besoin de gérer la vérification à l’aide de microversements. Cependant, si la vérification instantanée échoue, l’état du PaymentIntent est `requires_payment_method`, indiquant l’échec de la vérification instantanée du compte bancaire de votre client.

## Optional: Vérification à l'aide de microversements uniquement [Côté serveur]

Par défaut, le paiement à l’aide d’un compte bancaire américain permet à vos clients d’utiliser la vérification instantanée du compte bancaire ou les microversements. Vous pouvez aussi exiger la vérification du compte bancaire à l’aide de microversements uniquement en utilisant le paramètre [verification_method](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-us_bank_account-verification_method) à la création du PaymentIntent.

> Si vous utilisez un formulaire de paiement personnalisé, vous devez développer votre propre interface utilisateur pour collecter les coordonnées bancaires des clients. De la même manière, si vous désactivez l’envoi d’e-mails par Stripe en cas de microversements, vous devez développer votre propre interface utilisateur pour que votre client puisse confirmer le code ou le montant du microversement.

#### Accounts&nbsp;v2

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d setup_future_usage=off_session \
  -d "customer_account={{CUSTOMERACCOUNT_ID}}" \
  -d "payment_method_types[]=us_bank_account" \
  -d "payment_method_options[us_bank_account][verification_method]=microdeposits"
```

#### Customers&nbsp;v1

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d setup_future_usage=off_session \
  -d "customer={{CUSTOMER_ID}}" \
  -d "payment_method_types[]=us_bank_account" \
  -d "payment_method_options[us_bank_account][verification_method]=microdeposits"
```

Collectez ensuite le compte bancaire de votre client avec votre propre formulaire et appelez [stripe.confirmUsBankAccountPayment](https://docs.stripe.com/js/payment_intents/confirm_us_bank_account_payment) avec ces informations pour mener à bien le PaymentIntent.

```javascript
var form = document.getElementById('payment-form');
var accountholderName = document.getElementById('accountholder-name');
var email = document.getElementById('email');
var accountNumber = document.getElementById('account-number');
var routingNumber = document.getElementById('routing-number');
var accountHolderType= document.getElementById('account-holder-type');

var submitButton = document.getElementById('submit-button');
var clientSecret = submitButton.dataset.secret;

form.addEventListener('submit', function(event) {
  event.preventDefault();

  stripe.confirmUsBankAccountPayment(clientSecret, {
    payment_method: {
      billing_details: {
        name: accountholderName.value,
        email: email.value,
      },
      us_bank_account: {
        account_number: accountNumber.value,
        routing_number: routingNumber.value,
        account_holder_type: accountHolderType.value, // 'individual' or 'company'
      },
    },
  })
  .then(({paymentIntent, error}) => {
    if (error) {
      // Inform the customer that there was an error.
      console.log(error.message);
    } else {
      // Handle next step based on the intent's status.
      console.log("PaymentIntent ID: " + paymentIntent.id);
      console.log("PaymentIntent status: " + paymentIntent.status);
    }
  });
});
```

## Optional: Récupérer les informations sur le solde d'un compte bancaire Financial Connections

Pour éviter les échecs de paiement dus à des fonds insuffisants, nous vous recommandons de vérifier le solde de votre client avant d’effectuer un paiement. Avec l’autorisation de l’utilisateur, vous pouvez utiliser Financial Connections pour [accéder aux soldes du compte](https://docs.stripe.com/financial-connections/balances.md).

## Optional: Référence du paiement

Le numéro de référence du paiement est une valeur générée par la banque qui permet au titulaire du compte bancaire d’utiliser sa banque pour localiser des fonds. Lorsque le paiement aboutit, Stripe fournit le numéro de référence du paiement dans le Dashboard, ainsi que dans l’[objet Charge](https://docs.stripe.com/api/charges/object.md).

| État du paiement | Valeur de référence du paiement           |
| ---------------- | ----------------------------------------- |
| En attente       | Indisponibles                             |
| En échec         | Indisponibles                             |
| Réussi           | Disponible (par exemple, 091000015001234) |

De plus, lorsque vous recevez le webhook `charge.succeeded`, consultez le contenu de `payment_method_details` pour localiser la [payment_reference](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-us_bank_account-payment_reference).

L’exemple d’événement suivant montre le rendu d’un paiement ACH abouti avec un numéro de référence de paiement.

#### charge-succeeded

```json
{
  "id": "{{EVENT_ID}}",
  "object": "event",
  // omitted some fields in the example
  "type": "charge.succeeded",
  "data": {
    "object": {
      "id": "{{PAYMENT_ID}}",
      "object": "charge",
      //...
    "paid": true,
    "payment_intent": "{{PAYMENT_INTENT_ID}}",
    "payment_method": "{{PAYMENT_METHOD_ID}}",
    "payment_method_details": {
      "type": "us_bank_account",
      "us_bank_account": {
        "account_holder_type": "individual",
        "account_type": "checking",
        "bank_name": "TEST BANK",
        "fingerprint": "Ih3foEnRvLXShyfB",
        "last4": "1000","payment_reference": "091000015001234",
        "routing_number": "110000000"
        }
      }
      // ...
    }
  }
}
```

Consultez le contenu de `destination_details` pour localiser la [référence du remboursement](https://docs.stripe.com/api/refunds/object.md#refund_object-destination_details-us_bank_transfer-reference) associée aux paiements ACH remboursés.

L’exemple d’événement suivant montre le rendu d’un remboursement de paiement ACH abouti avec un numéro de référence de remboursement. En savoir plus sur les [remboursements](https://docs.stripe.com/refunds.md).

#### charge-refund-updated

```json
{
  "id": "{{EVENT_ID}}",
  "object": "event",
  "type": "charge.refund.updated",
  "data": {
    "object": {
      "id": "{{REFUND_ID}}",
      "object": "refund",
      //...
    "payment_intent": "{{PAYMENT_INTENT_ID}}",
    "destination_details": {
      "type": "us_bank_transfer",
      "us_bank_transfer": {"reference": "091000015001111",
        "reference_status": "available"
        }
      }
      // ...
    }
  }
}
```

## See also

- [Enregistrer les coordonnées ACH Direct Debit pour les futurs paiements](https://docs.stripe.com/payments/ach-direct-debit/set-up-payment.md)