# Encaissement des paiements par carte Préparez votre application et votre back-end pour l'encaissement des paiements par carte à l'aide de Stripe Terminal. # Android Vous découvrez l’API Payment Intents ? Voici quelques ressources utiles : - [L’API Payment Intents](https://docs.stripe.com/payments/payment-intents.md) - [L’objet PaymentIntent](https://docs.stripe.com/api/payment_intents.md) - [Autres scénarios de paiement](https://docs.stripe.com/payments/more-payment-scenarios.md) La définition d’un tunnel de paiement dans votre application est nécessaire pour encaisser des paiements avec Stripe Terminal. Utilisez le SDK Stripe Terminal pour créer et mettre à jour un [PaymentIntent](https://docs.stripe.com/api.md#payment_intents), un objet représentant une session de paiement individuelle. Conçue pour résister aux défaillances, l’intégration Terminal divise le processus de paiement en plusieurs étapes, dont chacune peut être répétée en toute sécurité : 1. [Créer un PaymentIntent](https://docs.stripe.com/terminal/payments/collect-card-payment.md#create-payment) 2. [Traitement du paiement](https://docs.stripe.com/terminal/payments/collect-card-payment.md#process-payment). L’autorisation sur la carte du client a lieu lorsque le SDK traite le paiement. 3. (Facultatif) [Capturer le paiement](https://docs.stripe.com/terminal/payments/collect-card-payment.md#capture-payment) ## Créer un PaymentIntent [Côté client] [Côté serveur] La première étape dans l’encaissement d’un paiement consiste à démarrer le tunnel de paiement. Lorsque le client commence à payer, votre application doit créer un objet `PaymentIntent`. Celui-ci représente une nouvelle session de paiement sur Stripe. - [createPaymentIntent (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/create-payment-intent.html) Vous pouvez créer un `PaymentIntent` côté client ou côté serveur. Utilisez des [montants test](https://docs.stripe.com/terminal/references/testing.md#physical-test-cards) pour essayer d’obtenir des résultats différents. Un montant se terminant par `00` correspond à un paiement approuvé. > #### Ne recréez pas de PaymentIntents pour les cartes refusées > > Ne recréez pas un PaymentIntent en cas de refus de carte. Réutilisez plutôt le même PaymentIntent pour [éviter les doubles paiements](https://docs.stripe.com/terminal/payments/collect-card-payment.md#avoiding-double-charges). ### Côté client Créez un `PaymentIntent` pour votre client : #### Kotlin ```kotlin val params = PaymentIntentParameters.Builder() .setAmount(1000) .setCurrency("usd") .build() Terminal.getInstance().createPaymentIntent( params, object : PaymentIntentCallback { override fun onSuccess(paymentIntent: PaymentIntent) { // Placeholder for handling successful operation } override fun onFailure(e: TerminalException) { // Placeholder for handling exception } } ) ``` ### Côté serveur Vous pouvez créer le `PaymentIntent` sur votre serveur si les informations requises pour lancer un paiement ne sont pas facilement accessibles dans votre application. L’exemple suivant montre comment créer un `PaymentIntent` sur votre serveur : #### curl ```bash curl https://api.stripe.com/v1/payment_intents \ -u <>: \ -d "amount"=1000 \ -d "currency"="usd" \ -d "payment_method_types[]"="card_present" \ -d "capture_method"="manual" ``` Pour les paiements Terminal, le paramètre `payment_method_types` doit inclure l’option `card_present`. Vous pouvez contrôler le tunnel de paiement de la manière suivante : - Pour contrôler totalement le tunnel de paiement pour les paiements `card_present`, définissez le paramètre `capture_method` sur `manual`. Cela vous permet d’ajouter une étape de rapprochement avant la réalisation du paiement. - Pour capturer et autoriser simultanément des paiements, définissez le paramètre `capture_method` sur `automatic`. Pour accepter des paiements en Australie, vous devez définir lle paramètre `capture_method` sur `automatic` ou sur `manual_preferred`. Pour en savoir plus, consultez notre [documentation sur l’Australie](https://docs.stripe.com/terminal/payments/regional.md?integration-country=AU). Pour accepter les paiements Interac au Canada, vous devez également inclure `interac_present` dans `payment_method_types`. Pour en savoir plus, consultez notre [documentation sur le Canada](https://docs.stripe.com/terminal/payments/regional.md?integration-country=CA). Le `PaymentIntent` contient une [clé secrète du client](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret), une clé unique propre à chaque `PaymentIntent`. Pour utiliser la clé secrète du client, vous devez l’obtenir du `PaymentIntent` sur votre serveur et la [transmettre côté client](https://docs.stripe.com/payments/payment-intents.md#passing-to-client). #### Ruby ```ruby post '/create_payment_intent' do intent = # ... Create or retrieve the PaymentIntent {client_secret: intent.client_secret}.to_json end ``` - [retrievePaymentIntent (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/retrieve-payment-intent.html) Pour récupérer un `PaymentIntent`, utilisez la clé secrète du client pour appeler `retrievePaymentIntent`. Après avoir récupéré la `PaymentIntent`, utilisez-la pour appeler `processPaymentIntent`. #### Kotlin ```kotlin Terminal.getInstance().retrievePaymentIntent( clientSecret, object : PaymentIntentCallback { override fun onSuccess(paymentIntent: PaymentIntent) { // Placeholder for handling successful operation } override fun onFailure(e: TerminalException) { // Placeholder for handling exception } } ) ``` ## Traiter le paiement [Côté client] Vous pouvez traiter immédiatement un paiement avec la carte présentée par un client, ou bien vérifier les informations de carte avant de procéder au traitement du paiement. Dans la plupart des cas, nous recommandons un traitement immédiat, car l’intégration est plus simple et nécessite moins d’appels à l’API. Cependant, si vous souhaitez insérer votre propre logique métier avant d’autoriser la carte, utilisez le flux en deux étapes :collecter et confirmer. #### Traitement immédiat Après avoir créé une PaymentIntent, l’étape suivante consiste à traiter le paiement. Le lecteur invite le client à insérer ou à taper sa carte, puis tente d’autoriser le paiement. - [processPaymentIntent (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/process-payment-intent.html) Lors du traitement d’un paiement, le titulaire de la carte peut mettre quelques secondes à sortir sa carte de son wallet ou poser une question à l’opérateur lors du paiement. #### Kotlin ```kotlin val cancelable = Terminal.getInstance().processPaymentIntent( paymentIntent = paymentIntent, collectConfig = CollectPaymentIntentConfiguration.Builder().build(), confirmConfig = ConfirmPaymentIntentConfiguration.Builder().build(), callback = object : PaymentIntentCallback { override fun onSuccess(paymentIntent: PaymentIntent) { println("processPaymentIntent succeeded") // Notify your backend to capture the PaymentIntent if (paymentIntent.id != null) { ApiClient.capturePaymentIntent(paymentIntent.id) { error -> if (error != null) { println("capturePaymentIntent failed: $error") } else { println("capturePaymentIntent succeeded") } } } else { println("Payment collected offline") } } override fun onFailure(e: TerminalException) { println("processPaymentIntent failed: $e") } } ) ``` ### Annuler la collecte #### Annulation programmatique - [Cancelable (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-cancelable/index.html) Vous pouvez annuler le traitement d’une PaymentIntent à l’aide de l’objet `Cancelable` renvoyé par le SDK Android. #### Annulation initiée par le client - [setCustomerCancellation (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-collect-payment-intent-configuration/-builder/set-customer-cancellation.html) - [Annulation de la part du client (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-customer-cancellation/index.html) Par défaut, les lecteurs intelligents affichent aux clients un bouton d’annulation. Vous pouvez le désactiver en définissant `customerCancellation` sur `DISABLE_IF_AVAILABLE`. Appuyer sur le bouton d’annulation annule la transaction active. #### Kotlin ```kotlin Terminal.getInstance().collectPaymentMethod( paymentIntent, object : PaymentIntentCallback { override fun onSuccess(paymentIntent: PaymentIntent) { // Placeholder for handling successful operation } override fun onFailure(e: TerminalException) { // Placeholder for handling exception } }, CollectPaymentIntentConfiguration.Builder() .setCustomerCancellation(CustomerCancellation.DISABLE_IF_AVAILABLE) // turn OFF the cancel button, ON by default .build(), ) ``` ### Gérer les événements - [MobileReaderListener (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-mobile-reader-listener/index.html) Lorsque vous collectez un moyen de paiement à l’aide d’un lecteur tel que le [Stripe M2](https://docs.stripe.com/terminal/readers/stripe-m2.md)sans écran intégré, votre application doit être en mesure d’afficher les événements du processus de collecte du moyen de paiement aux utilisateurs. Ces événements aident les utilisateurs à encaisser les paiements (par exemple, réessayer une carte, essayer une autre carte ou utiliser une autre méthode de lecture). Au début d’une transaction, le SDK adresse une valeur `ReaderInputOptions`` au gestionnaire d'affichage du lecteur de votre application, précisant les types de saisie acceptables (par exemple,`Swipe`,`Insert`, ou`Tap`). Dans l’interface de paiement de l’application, invitez l’utilisateur à effectuer son paiement par carte selon l’une de ces options. Au cours de la transaction, le SDK peut recourir à l’application pour afficher d’autres messages à l’attention de l’utilisateur (`Réessayer la carte`, par exemple) en transmettant une valeur `ReaderDisplayMessage` au gestionnaire d’affichage du lecteur de votre application. Vérifiez que l’interface de paiement relaie bien ces messages à l’utilisateur. #### Kotlin ```kotlin class ReaderActivity : AppCompatActivity(), MobileReaderListener { // ... override fun onRequestReaderInput(options: ReaderInputOptions) { Toast.makeText(this, options.toString(), Toast.LENGTH_SHORT).show() } override fun onRequestReaderDisplayMessage(message: ReaderDisplayMessage) { Toast.makeText(this, message.toString(), Toast.LENGTH_SHORT).show() } // ... } ``` ### Encaisser des paiements avec Tap to Pay sur Android Lorsque votre application est prête à encaisser un paiement, le SDK Stripe Terminal Android prend en charge l’affichage pour gérer le processus d’encaissement. Après avoir appelé la méthode [process payment](https://docs.stripe.com/terminal/payments/collect-card-payment.md#process-payment), votre application reste en cours d’exécution. L’appareil Android affiche une invite en plein écran à l’attention du titulaire de la carte, lui demandant de présenter sa carte ou son wallet mobile basé sur la technologie NFC. En cas d’erreur de lecture de la carte, une invite de nouvelle tentative s’affiche. Une présentation réussie renvoie une indication de succès, puis le contrôle est rendu à votre application. ![Recouvrement des paiements Tap to Pay sur Android](https://b.stripecdn.com/docs-statics-srv/assets/ttpa-payment-collection.bd48493bc27d1f5ebb076aeeeaa43456.png) Encaissement des paiements - En cas de capture manuelle des paiements, un appel `processPayment` réussi génère une `PaymentIntent`à l’état `requires_capture`. - En cas de capture automatique d’un paiement, le `PaymentIntent` passe à l’état `succeeded`. Vous devez capturer un PaymentIntent manuellement sous deux jours, faute de quoi l’autorisation expire et les fonds sont restitués au client. ### Gérer les échecs - [TerminalException (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-terminal-exception/index.html) Lorsque le traitement d’un paiement échoue, le SDK renvoie une erreur comprenant la `PaymentIntent` mise à jour. Votre application doit examiner la `PaymentIntent` pour décider de la manière de résoudre l’erreur. | État de la PaymentIntent | Signification | Résolution | | ------------------------- | --------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `requires_payment_method` | Moyen de paiement refusé | Essayez de recueillir un moyen de paiement différent en appelant à nouveau `processPaymentIntent` avec la même `PaymentIntent`. | | `requires_confirmation` | Problème de connectivité temporaire | Appelez à nouveau `processPaymentIntent` avec la même `PaymentIntent` pour retenter la requête. | | `PaymentIntent` est `nil` | La requête envoyée à Stripe a expiré, l’état de `PaymentIntent` est inconnu | Réessayez de traiter la `PaymentIntent` initiale. N’en créez pas une nouvelle, car cela pourrait entraîner plusieurs autorisations pour le titulaire de la carte. | Si vous rencontrez plusieurs expirations du délai paiement à la suite, il se peut qu’il y ait un problème de connectivité. Assurez-vous que votre application est connectée à Internet. ### Évitez les doubles facturations L’objet `PaymentIntent` active les mouvements de fonds sur Stripe : utilisez un seul `PaymentIntent` pour représenter une transaction. Réutilisez le même `PaymentIntent` même après le refus d’une carte (par exemple, pour fonds insuffisants), afin que votre client puisse réessayer avec une autre carte. Si vous modifiez la `PaymentIntent`, vous devez appeler `processPaymentIntent` pour mettre à jour les informations de paiement sur le lecteur. Pour pouvoir être traitée par Stripe, une `PaymentIntent` doit être à l’état `requires_payment_method`. Une `PaymentIntent` autorisée, capturée ou annulée ne pourra pas être traitée par le lecteur. #### Collecter, inspecter et confirmer Une fois l’objet PaymentIntent créé, vous devez traiter le paiement. Le lecteur invite le client à insérer ou à présenter la carte, puis crée une PaymentMethod. ## Collecter un PaymentMethod - [collectPaymentMethod (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/collect-payment-method.html) Une fois que vous avez créé un `PaymentIntent`, il vous faut ensuite recueillir un moyen de paiement avec le SDK. Pour collecter un moyen de paiement, votre application doit être connectée à un lecteur. Le lecteur connecté attendra qu’une carte soit présentée après l’appel de votre application à l’objet `collectPaymentMethod`. #### Kotlin ```kotlin val cancelable = Terminal.getInstance().collectPaymentMethod( paymentIntent, object : PaymentIntentCallback { override fun onSuccess(paymentIntent: PaymentIntent) { // Placeholder for handling successful operation } override fun onFailure(e: TerminalException) { // Placeholder for handling exception } } ) ``` Cette méthode recueille les données chiffrées du moyen de paiement à l’aide du lecteur de carte connecté, et les associe au `PaymentIntent` local. ### Examen facultatif des informations du moyen de paiement - [CollectPaymentIntentConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-collect-payment-intent-configuration/index.html) - [CardPresentDetails (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-card-present-details/index.html) Vous pouvez également examiner les informations de moyen de paiement de la carte présentée et effectuer votre propre logique métier avant l’autorisation, ce qui peut être utile pour les cas d’usage avancés. Utilisez le paramètre `updatePaymentIntent` dans `CollectPaymentIntentConfiguration` pour attacher un `PaymentMethod` au `PaymentIntent` côté serveur. Ces données sont renvoyées dans la réponse `collectPaymentMethod`. #### Kotlin ```kotlin val collectConfig = CollectPaymentIntentConfiguration.Builder() .updatePaymentIntent(true) .build() val cancelable = Terminal.getInstance().collectPaymentMethod(paymentIntent, object : PaymentIntentCallback { override fun onSuccess(paymentIntent: PaymentIntent) { val pm = paymentIntent.paymentMethod val card = pm?.cardPresentDetails ?: pm?.interacPresentDetails // Placeholder for business logic on card before confirming paymentIntent } override fun onFailure(e: TerminalException) { // Placeholder for handling exception } } ) ``` Cette méthode permet d’associer les données chiffrées collectées concernant le moyen de paiement grâce à une modification de l’objet `PaymentIntent`. Elle ne nécessite aucune autorisation tant que vous n’avez pas confirmé le paiement. Après avoir sélectionné le moyen de paiement, vous devez autoriser ou annuler le paiement dans les 30 secondes. Si le SDK [fonctionne hors ligne](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md), le champ `paymentMethod` n’est pas présent dans l’objet `PaymentIntent`. À ce stade, vous pouvez accéder à des attributs tels que la marque de la carte, le financement et d’autres données utiles. Stripe tente de détecter si un wallet mobile est utilisé dans une transaction, comme indiqué dans l’attribut `wallet.type`. Cependant, l’attribut n’est pas renseigné si la banque émettrice de la carte ne prend pas en charge l’identification par lecteur d’un wallet mobile. La détection précise n’est donc pas garantie. Après l’autorisation à l’étape de [traitement du paiement](https://docs.stripe.com/terminal/payments/collect-card-payment.md#process-payment), Stripe reçoit des informations à jour provenant des réseaux et met à jour le `wallet.type`. ### Annuler la collecte #### Annulation programmatique - [Cancelable (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-cancelable/index.html) Vous pouvez annuler la collecte d’un moyen de paiement à l’aide de l’objet `Cancelable` renvoyé par le SDK Android. #### Annulation initiée par le client - [setCustomerCancellation (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-collect-payment-intent-configuration/-builder/set-customer-cancellation.html) - [Annulation de la part du client (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-customer-cancellation/index.html) Par défaut, les lecteurs intelligents affichent aux clients un bouton d’annulation. Vous pouvez le désactiver en définissant `customerCancellation` sur `DISABLE_IF_AVAILABLE`. Appuyer sur le bouton d’annulation annule la transaction active. #### Kotlin ```kotlin Terminal.getInstance().collectPaymentMethod( paymentIntent, object : PaymentIntentCallback { override fun onSuccess(paymentIntent: PaymentIntent) { // Placeholder for handling successful operation } override fun onFailure(e: TerminalException) { // Placeholder for handling exception } }, CollectPaymentIntentConfiguration.Builder() .setCustomerCancellation(CustomerCancellation.DISABLE_IF_AVAILABLE) // turn OFF the cancel button, ON by default .build(), ) ``` ### Gérer les événements - [MobileReaderListener (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-mobile-reader-listener/index.html) Lorsque vous collectez un moyen de paiement à l’aide d’un lecteur tel que le [Stripe M2](https://docs.stripe.com/terminal/readers/stripe-m2.md)sans écran intégré, votre application doit être en mesure d’afficher les événements du processus de collecte du moyen de paiement aux utilisateurs. Ces événements aident les utilisateurs à encaisser les paiements (par exemple, réessayer une carte, essayer une autre carte ou utiliser une autre méthode de lecture). Au début d’une transaction, le SDK adresse une valeur `ReaderInputOptions`` au gestionnaire d'affichage du lecteur de votre application, précisant les types de saisie acceptables (par exemple,`Swipe`,`Insert`, ou`Tap`). Dans l’interface de paiement de l’application, invitez l’utilisateur à effectuer son paiement par carte selon l’une de ces options. Au cours de la transaction, le SDK peut recourir à l’application pour afficher d’autres messages à l’attention de l’utilisateur (`Réessayer la carte`, par exemple) en transmettant une valeur `ReaderDisplayMessage` au gestionnaire d’affichage du lecteur de votre application. Vérifiez que l’interface de paiement relaie bien ces messages à l’utilisateur. #### Kotlin ```kotlin class ReaderActivity : AppCompatActivity(), MobileReaderListener { // ... override fun onRequestReaderInput(options: ReaderInputOptions) { Toast.makeText(this, options.toString(), Toast.LENGTH_SHORT).show() } override fun onRequestReaderDisplayMessage(message: ReaderDisplayMessage) { Toast.makeText(this, message.toString(), Toast.LENGTH_SHORT).show() } // ... } ``` ### Encaisser des paiements avec Tap to Pay sur Android Lorsque votre application est prête à encaisser un paiement, le SDK Stripe Terminal Android prend en charge l’affichage pour gérer le processus d’encaissement. Après avoir appelé la méthode [process payment](https://docs.stripe.com/terminal/payments/collect-card-payment.md#process-payment), votre application reste en cours d’exécution. L’appareil Android affiche une invite en plein écran à l’attention du titulaire de la carte, lui demandant de présenter sa carte ou son wallet mobile basé sur la technologie NFC. En cas d’erreur de lecture de la carte, une invite de nouvelle tentative s’affiche. Une présentation réussie renvoie une indication de succès, puis le contrôle est rendu à votre application. ![Recouvrement des paiements Tap to Pay sur Android](https://b.stripecdn.com/docs-statics-srv/assets/ttpa-payment-collection.bd48493bc27d1f5ebb076aeeeaa43456.png) Encaissement des paiements ## Confirmer la PaymentIntent - [confirmPaymentIntent (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/confirm-payment-intent.html) Après avoir collecté un moyen de paiement auprès du client, vous devez traiter le paiement avec le SDK. Au moment de procéder au paiement, appelez `confirmPaymentIntent` avec la `PaymentIntent` mise à jour lors de l’[étape précédente](https://docs.stripe.com/terminal/payments/collect-card-payment.md#collect-inspect-payment-method). - En cas de capture manuelle des paiements, un appel `confirmPayment` réussi génère une `PaymentIntent` à l’état `requires_capture`. - En cas de capture automatique d’un paiement, le `PaymentIntent` passe à l’état `succeeded`. Confirmez toujours les PaymentIntents à l’aide du SDK Terminal côté client. La confirmation côté serveur permet de contourner les interactions critiques, telles que les invites de code PIN, et peut entraîner des échecs de transaction. #### Kotlin ```kotlin val cancelable = Terminal.getInstance().confirmPaymentIntent( paymentIntent, object : PaymentIntentCallback { override fun onSuccess(paymentIntent: PaymentIntent) { // Placeholder handling successful operation } override fun onFailure(e: TerminalException) { // Placeholder for handling exception } } ) ``` Vous devez capturer un PaymentIntent manuellement sous deux jours, faute de quoi l’autorisation expire et les fonds sont restitués au client. ### Gérer les échecs - [TerminalException (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-terminal-exception/index.html) Lorsque le traitement d’un paiement échoue, le SDK renvoie une erreur comprenant la `PaymentIntent` mise à jour. Votre application doit examiner la `PaymentIntent` pour décider de la manière de résoudre l’erreur. | État du PaymentIntent | Signification | Résolution | | ------------------------- | --------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `requires_payment_method` | Moyen de paiement refusé | Essayez de collecter un autre moyen de paiement en appelant à nouveau `collectPaymentMethod` avec la même `PaymentIntent`. | | `requires_confirmation` | Problème de connectivité temporaire | Rappelez `confirmPaymentIntent` avec la même `PaymentIntent` pour retenter la requête. | | `PaymentIntent` est `nil` | La requête envoyée à Stripe a expiré, l’état de `PaymentIntent` est inconnu | Réessayez de confirmer la `PaymentIntent` initiale. N’en créez pas une nouvelle, car cela pourrait entraîner des autorisations multiples pour le titulaire de la carte. | Si vous rencontrez plusieurs expirations du délai paiement à la suite, il se peut qu’il y ait un problème de connectivité. Assurez-vous que votre application est connectée à Internet. ### Évitez les doubles facturations L’objet `PaymentIntent` active les mouvements de fonds sur Stripe : utilisez un seul `PaymentIntent` pour représenter une transaction. Réutilisez le même `PaymentIntent` même après le refus d’une carte (par exemple, pour fonds insuffisants), afin que votre client puisse réessayer avec une autre carte. Si vous modifiez la `PaymentIntent`, vous devez appeler l’objet `collectPaymentMethod` pour mettre à jour les informations de paiement sur le lecteur. Pour pouvoir être confirmée par Stripe, une `PaymentIntent` doit être à l’état `requires_payment_method`. Un lecteur ne pourra pas confirmer une `PaymentIntent` autorisée, capturée ou annulée. ## Capturer le paiement [Côté serveur] Si vous avez défini `capture_method` sur `manual` lors de la création du `PaymentIntent` à l’[étape 1](https://docs.stripe.com/terminal/payments/collect-card-payment.md#create-payment), le SDK renvoie à votre application un `PaymentIntent` autorisé, mais non capturé. En savoir plus sur la différence entre [autorisation et capture](https://docs.stripe.com/payments/place-a-hold-on-a-payment-method.md). Assurez-vous que votre application demande à votre back-end de capturer le paiement lorsqu’elle reçoit du SDK un `PaymentIntent` confirmé. Créez dans votre back-end un endpoint qui accepte un ID de `PaymentIntent` et envoie à l’API Stripe une demande de capture correspondante : ```curl curl -X POST https://api.stripe.com/v1/payment_intents/{{PAYMENT_INTENT_ID}}/capture \ -u "<>:" ``` Si l’appel de `capture` réussit, l’état du `PaymentIntent` passe à `succeeded`. Pour débiter les comptes connectés des frais de plateforme appropriés, inspectez chaque `PaymentIntent` et modifiez les frais de plateforme, si nécessaire, avant de capturer le paiement manuellement. ### Rapprocher les paiements Pour vérifier l’activité de paiement de votre entreprise, vous pouvez rapprocher les PaymentIntents avec votre système de commande interne sur votre serveur à la fin de chaque journée. Un `PaymentIntent` conservant l’état `requires_capture` peut signifier deux choses : **Autorisation inutile sur le relevé de carte bancaire de votre client** - Cause : l’utilisateur abandonne le tunnel de paiement de votre application au milieu d’une transaction - Solution : si le `PaymentIntent` non capturé n’est associé à aucune commande terminée sur votre serveur, vous pouvez l’[annuler](https://docs.stripe.com/api/payment_intents/cancel.md). Vous ne pouvez pas utiliser un `PaymentIntent` annulé pour effectuer des paiements. **Encaissement de fonds incomplet auprès d’un client** - Cause : échec de la requête de votre application signalant à votre back-end de capturer le paiement - Solution : si le `PaymentIntent` non capturé est associé à une commande terminée sur votre serveur, et aucun autre paiement n’a été encaissé pour la commande (par exemple, un paiement en espèces), vous pouvez le [capturer](https://docs.stripe.com/api/payment_intents/capture.md). ### Encaisser les pourboires (États-Unis uniquement) Aux États-Unis, les utilisateurs admissibles peuvent [collecter un pourboire sur le reçu lors de la capture des paiements](https://docs.stripe.com/terminal/features/collecting-tips/on-receipt.md).