# Accepter des paiements pour des biens numériques sur iOS à l'aide d'une page de paiement préconfigurée Ouvrez Stripe Checkout dans un navigateur pour vendre des biens numériques ou des abonnements dans l'application. > [Apprenez à construire une intégration similaire utilisant Managed Payments](https://docs.stripe.com/payments/managed-payments/set-up-mobile.md), la solution de *marchand officiel* (The legal entity responsible for facilitating the sale of products to a customer that handles any applicable regulations and liabilities, including sales taxes. In a Connect integration, it can be the platform or a connected account) de Stripe. Pour les applications iOS vendant des produits, contenus et abonnements numériques aux États-Unis, vous pouvez rediriger les clients vers une page de paiement externe pour accepter des paiements utilisant [Stripe Checkout](https://docs.stripe.com/payments/checkout.md). Utilisez la propriété [StoreKit Storefront](https://developer.apple.com/documentation/storekit/storefront) pour détecter la vitrine à partir de laquelle votre application a été téléchargée. Ce guide décrit comment accepter des paiements pour l’achat de crédits dans votre application iOS en redirigeant les clients vers une [page de paiement hébergée par Stripe](https://docs.stripe.com/checkout/quickstart.md). Pour les développeurs Android aux États-Unis, vous pouvez traiter les paiements intégrés directement à l’application à l’aide d’un prestataire de services de paiement tiers. Pour accepter les paiements intégrés directement à l’application avec Stripe, consultez la section [Paiements intégrés à l’application](https://docs.stripe.com/payments/mobile.md). Ce guide décrit uniquement le processus destiné aux développeurs iOS qui vendent des biens numériques intégrés à leurs applications. Utilisez le guide sur les [paiements dans les applications natives](https://docs.stripe.com/payments/mobile.md), si vous vendez : - Produits physiques - Biens et services destinés à la consommation en dehors de votre application - Services en temps réel de personne à personne entre deux individus Ce guide explique comment : - Collectez des informations de paiement avec Checkout. - Modélisez vos forfaits de crédits avec des *produits* (Products represent what your business sells—whether that's a good or a service), des *tarifs* (Prices define how much and how often to charge for products. This includes how much the product costs, what currency to use, and the interval if the price is for subscriptions) et des *clients* (Customer objects represent customers of your business. They let you reuse payment methods and give you the ability to track multiple payments). - Utilisez les *liens universels* (Use Universal links on iOS and macOS to link directly to in-app content. They're standard HTTPS links, so the same URL works for your website and your app) pour rediriger directement vers votre application depuis Checkout. - Surveillez des *webhooks* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) pour mettre à jour le solde de la devise du client dans l’application. ![Paiement ponctuel](https://b.stripecdn.com/docs-statics-srv/assets/one_time_hero.e9d6a86d35345553ed008f0bd442c6b2.png) Lien vers un site externe pour les paiements ponctuels ![Paiement récurrent](https://b.stripecdn.com/docs-statics-srv/assets/recurring_hero.6dff3f5076ca832cde57ac0757110291.png) Lien vers un site externe pour les paiements récurrents ou par abonnement ## Mode de fonctionnement Le diagramme suivant illustre le tunnel de paiement complet d’une application au web à un niveau élevé : Tunnel de paiement de haut niveau d’une application au web pour les achats in-app (See full diagram at https://docs.stripe.com/mobile/digital-goods/checkout) ## Ce qui n’est pas couvert Ce guide vous explique comment ajouter Stripe Checkout à côté de votre système d’achat actuel dans l’application. Il ne couvre pas les points suivants : - Authentification d’utilisateur. Si vous ne disposez pas encore d’un fournisseur d’authentification, vous pouvez faire appel à un tiers (par exemple, avec l’option [Se connecter avec Apple](https://developer.apple.com/sign-in-with-apple/) ou [Authentification Firebase](https://firebase.google.com/docs/auth)). - Achats dans l’application native. Pour implémenter des achats dans l’application avec StoreKit, consultez le [guide d’Apple sur les achats intégrés à l’application](https://developer.apple.com/in-app-purchase/). ## Configurer Stripe [Côté serveur] Tout d’abord, [inscrivez-vous](https://dashboard.stripe.com/register) pour créer un Compte Stripe. Ajoutez ensuite la bibliothèque d’API Stripe à votre back-end : #### 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' ``` Installez ensuite l’interface de ligne de commande Stripe. Cette dernière vous permet d’exécuter les tests [webhook](https://docs.stripe.com/webhooks.md#test-webhook) dont vous aurez besoin et vous pouvez l’utiliser pour créer vos produits et vos tarifs. Pour davantage d’options d’installation, consultez la page consacrée à l’[interface de ligne de commande Stripe](https://docs.stripe.com/stripe-cli.md). ## Créer des produits et des tarifs Créez vos *produits* (Products represent items your customer can subscribe to with a Subscription. An associated Price object describes the pricing and other terms of the subscription) et leurs *tarifs* (Prices define how much and how often to charge for products. This includes how much the product costs, what currency to use, and the interval if the price is for subscriptions) dans le Dashboard ou via l’interface de ligne de commande Stripe. Vous pouvez modéliser les biens numériques à l’aide de tarifs ponctuels et les abonnements à l’aide de tarifs récurrents. Vous pouvez également laisser votre client payer le montant de son choix (par exemple, pour décider du nombre de crédits à acheter), en sélectionnant **Les clients indiquent le montant à payer**. Cet exemple utilise un seul *produit* et un *tarif* pour représenter un lot de 100 coins. #### Dashboard Accédez à la page [Ajouter un produit](https://dashboard.stripe.com/test/products/create) et créez un pack de coins. Ajoutez un tarif ponctuel de 10 USD. - 100 coins : pack de 100 coins dans l’application - Tarif : modèle standard | 10 USD | Ponctuel Après avoir créé votre tarif, enregistrez son ID afin de pouvoir l’utiliser par la suite. L’ID de tarif se présente sous la forme suivante : `price_G0FvDp6vZvdwRZ`. Lorsque vous le souhaitez, cliquez sur le bouton **Copier en mode production** en haut à droite de la page pour dupliquer votre produit de l’[environnement de test en mode production](https://docs.stripe.com/keys.md#test-live-modes). #### Interface de ligne de commande Stripe Ensuite, créez les objets Product : ```bash stripe products create \ --name="100 coins" \ --description="Bundle of 100 in-app coins" ``` L’interface de ligne de commande Stripe renvoie les informations sur le produit, dont son ID. ```json { "id": "prod_H94k5odtwJXMtQ", "object": "product", "active": true, "attributes": [ ], "created": 1587577341, "description": "Bundle of 100 in-app coins", "images": [ ], "livemode": false, "metadata": { }, "name": "100 coins", "statement_descriptor": null, "type": "service", "unit_label": null, "updated": 1587577341 } ``` Utilisez les ID de produit pour créer un tarif propre à chaque produit. La valeur du champ `unit_amount` est exprimée en centimes (par exemple, `1000` = 10 USD). ```bash stripe prices create \ -d product=prod_H94k5odtwJXMtQ \ -d unit_amount=1000 \ -d currency=usd ``` Enregistrez l’ID de chaque tarif afin de pouvoir les utiliser par la suite. Ces ID se présentent sous la forme suivante : ```json { "id": "price_1Jh0tjEmNk5jCjFGCkLnNYGO", "object": "price", "active": true, "billing_scheme": "per_unit", "created": 1633391323, "currency": "usd", "livemode": false, "lookup_key": null, "metadata": { }, "nickname": null, "product": "prod_H94k5odtwJXMtQ", "recurring": null, "tax_behavior": "unspecified", "tiers_mode": null, "transform_quantity": null, "type": "one_time", "unit_amount": 1000, "unit_amount_decimal": "1000" } ``` ## Créer des clients [Côté serveur] Chaque fois que vous créez une session Checkout, 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) pour votre utilisateur si celui-ci n’existe pas encore. #### Node.js ```javascript // Don't put any keys in code. See https://docs.stripe.com/keys-best-practices. // Find your keys at https://dashboard.stripe.com/apikeys. const stripe = require('stripe')('<>'); // This assumes your app has an existing user database, which we'll call `myUserDB`. const user = myUserDB.getUser("jennyrosen"); if (!user.stripeCustomerID) { const customer = await stripe.customers.create({ name: user.name, email: user.email, }); // Set the user's Stripe Customer ID for later retrieval. user.stripeCustomerID = customer.id; } ``` > Veillez à conserver sur votre serveur l’association entre le compte d’utilisateur et l’ID de client Stripe. Sans cela, vous ne pourrez pas associer vos clients à des achats et vos clients ne pourront donc pas récupérer leurs achats. > > Si votre application ne dispose pas de fournisseur d’authentification, vous pouvez utiliser l’option [Se connecter avec Apple](https://developer.apple.com/sign-in-with-apple/). Vous pouvez [enregistrer les informations du moyen de paiement](https://docs.stripe.com/payments/save-during-payment.md?platform=checkout) pour que Checkout associe automatiquement ce moyen de paiement à l’objet Customer afin de pouvoir le réutiliser. ## Configurer des liens universels [Côté client] [Côté serveur] Les *liens universels* (Use Universal links on iOS and macOS to link directly to in-app content. They're standard HTTPS links, so the same URL works for your website and your app) autorisent Checkout à vous renvoyer directement vers votre application. Pour configurer un lien universel : 1. Ajoutez un fichier `apple-app-site-association` à votre domaine. 1. Ajoutez un droit de domaine associé à votre application. 1. Ajoutez une page de renvoi pour vos URL de redirection Checkout. #### Définissez les domaines associés Ajoutez un fichier à votre domaine sur **.well-known/apple-app-site-association** pour définir les URL que votre application peut gérer. Ajoutez l’ID d’application avec votre ID d’équipe que vous pourrez trouver sur la [page d’abonnement du portail développeur d’Apple](https://developer.apple.com/account). ```json { "applinks": { "apps": [], "details": [ { "appIDs": [ "A28BC3DEF9.com.example.MyApp1", "A28BC3DEF9.com.example.MyApp1-Debug" ], "components": [ { "/": "/checkout_redirect*", "comment": "Matches any URL whose path starts with /checkout_redirect" } ] } ] } } ``` Vous devez traiter le fichier avec le type MIME `application/json`. Utilisez `curl -I` pour confirmer le type de contenu. ```bash curl -I https://example.com/.well-known/apple-app-site-association ``` Pour en savoir plus, consultez la page d’Apple relative aux [domaines associés pris en charge](https://developer.apple.com/documentation/xcode/supporting-associated-domains). #### Ajouter un droit de domaine associé à votre application 1. Ouvrez le volet **Signatures et fonctionnalités** de la cible de votre application. 1. Cliquez sur **+ Fonctionnalité**, puis sélectionnez **Domaines associés**. 1. Ajoutez une entrée pour `applinks:example.com` à la liste **Domaines associés**. Pour en savoir plus sur les liens universels, consultez la page d’Apple sur les [liens universels pour les développeurs](https://developer.apple.com/ios/universal-links/). Bien qu’iOS intercepte les liens vers les URL définies dans votre fichier `apple-app-site-association`, il se peut que la redirection ne parvienne pas à ouvrir votre application. Assurez-vous de créer une [page de repli](https://docs.stripe.com/payments/checkout/custom-success-page.md?payment-ui=stripe-hosted) à votre `success_url`. Par exemple, vous pouvez [définir un schéma d’URL personnalisé pour votre application](https://developer.apple.com/documentation/xcode/defining-a-custom-url-scheme-for-your-app) et l’utiliser pour créer un lien de retour en cas d’échec du lien universel. ## Créer une session Checkout [Côté serveur] Une [session Checkout](https://docs.stripe.com/api/checkout/sessions/create.md) est la représentation programmatique de ce que votre client voit lorsqu’il est redirigé vers le formulaire de paiement. Les sessions Checkout expirent 24 heures après leur création. Configurez-le à l’aide des éléments suivants : - ID du client - ID du produit (paiement ponctuel ou abonnement) - Un `origin_context` défini sur `mobile_app` pour activer une interface utilisateur optimisée pour les achats interentreprises. - Une URL `success_url`, à savoir un *lien universel* (Use Universal links on iOS and macOS to link directly to in-app content. They're standard HTTPS links, so the same URL works for your website and your app) vers lequel rediriger votre client après avoir finalisé le paiement. > Créez la session de paiement avec `origin_context: "mobile_app"` pour accepter une interface utilisateur optimisée pour les achats interentreprises. Après avoir créé une session Checkout, renvoyez l’[URL](https://docs.stripe.com/api/checkout/sessions/object.md#checkout_session_object-url) contenue dans la réponse vers votre application. #### Paiement ponctuel #### Node.js ```javascript // This example sets up an endpoint using the Express framework. const express = require('express'); const app = express(); const stripe = require('stripe')('<>'); app.post('/create-checkout-session', async (req, res) => { // Fetch the Stripe customer ID for the customer associated with this request. // This assumes your app has an existing user database, which we'll call `myUserDB`. const user = myUserDB.getUserFromToken(req.query.token); const customerId = user.stripeCustomerID; // The price ID from the previous step const priceId = '{{PRICE_ID}}'; const session = await stripe.checkout.sessions.create({ line_items: [ { price: priceId, quantity: 1, }, ], mode: 'payment', origin_context: 'mobile_app', customer: customerId, success_url: 'https://example.com/checkout_redirect/success', }); res.json({url: session.url}); }); app.post('/login', async (req, res) => { // This assumes your app has an existing user database, which we'll call `myUserDB`. const token = myUserDB.login(req.body.login_details) res.json({token: token}) }); app.listen(4242, () => console.log(`Listening on port ${4242}!`)); ``` #### Abonnement #### Node.js ```javascript // This example sets up an endpoint using the Express framework. const express = require('express'); const app = express(); const stripe = require('stripe')('<>'); app.post('/create-checkout-session', async (req, res) => {// Fetch the Stripe customer ID for the customer associated with this request. // This assumes your app has an existing user database, which we'll call `myUserDB`. const user = myUserDB.getUserFromToken(req.query.token); const customerId = user.stripeCustomerID; // The price ID from the previous step const priceId = '{{SUBSCRIPTION_PRICE_ID}}'; const session = await stripe.checkout.sessions.create({ line_items: [ { price: priceId, quantity: 1, }, ], mode: 'subscription', origin_context: 'mobile_app', customer: customerId, success_url: 'https://example.com/checkout_redirect/success', }); res.json({url: session.url}); }); app.post('/login', async (req, res) => { // This assumes your app has an existing user database, which we'll call `myUserDB`. const token = myUserDB.login(req.body.login_details) res.json({token: token}) }); app.listen(4242, () => console.log(`Listening on port ${4242}!`)); ``` > [Apple Pay est activé par défaut](https://dashboard.stripe.com/settings/checkout) et s’affiche automatiquement dans Checkout lorsqu’un client utilise un appareil pris en charge. Vous pouvez accepter des moyens de paiement supplémentaires à l’aide de [moyens de paiement dynamiques](https://docs.stripe.com/payments/payment-methods/dynamic-payment-methods.md). ## Ouvrir Checkout dans Safari [Côté client] Ajoutez un bouton de paiement à votre application. Ce bouton : 1. Appelez un endpoint côté serveur pour créer une session Checkout. 1. Renvoie la session Checkout au client. 1. Ouvre l’URL de la session dans Safari. ```swift import Foundation import SwiftUI import StoreKit struct BuyCoinsView: View { @EnvironmentObject var myBackend: MyServer @State var paymentComplete = false var body: some View { // Check if payments are blocked by Parental Controls on this device. if !SKPaymentQueue.canMakePayments() { Text("Payments are disabled on this device.") } else { if paymentComplete { Text("Payment complete!") } else { Button { myBackend.createCheckoutSession { url in UIApplication.shared.open(url, options: [:], completionHandler: nil) } } label: { Text("Buy 100 coins") }.onOpenURL { url in // Handle the universal link from Checkout. if url.absoluteString.contains("success") { // The payment was completed. Show a success // page and fetch the latest customer entitlements // from your server. paymentComplete = true } } } } } } ``` ### Récupérer l’URL Checkout côté client Utilisez votre endpoint serveur pour récupérer la session de paiement. ```swift class MyServer: ObservableObject { // The cached login token var token: String? func createCheckoutSession(completion: @escaping (URL) -> Void) { // Send the login token to the `/create_checkout_session` endpoint let request = URLRequest(url: URL(string: "https://example.com/create-checkout-session?token=\(self.token)")!) let task = URLSession.shared.dataTask(with: request, completionHandler: { (data, response, error) in guard let unwrappedData = data, let json = try? JSONSerialization.jsonObject(with: unwrappedData, options: []) as? [String : Any], let urlString = json["url"] as? String, let url = URL(string: urlString) else { // Handle error return } DispatchQueue.main.async { // Call the completion block with the Checkout session URL returned from the backend completion(url) } }) task.resume() } func login() { // Login using the server and set the login token. let request = URLRequest(url: URL(string: "https://example.com/login")!) let task = URLSession.shared.dataTask(with: request, completionHandler: { (data, response, error) in guard let unwrappedData = data, let json = try? JSONSerialization.jsonObject(with: unwrappedData, options: []) as? [String : Any], let token = json["token"] as? String else { // Handle error return } self.token = token }) task.resume() } } ``` ## Gérer le traitement des commandes [Côté serveur] Une fois l’achat effectué, Stripe vous envoie un *webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) `checkout.session.completed`. Lorsque vous l’avez reçu, vous pouvez ajouter les coins au client sur votre serveur. Checkout redirige votre client vers l’URL `success_url` lorsque vous [confirmez avoir reçu l’événement](https://docs.stripe.com/webhooks.md#acknowledge-events-immediately). Si votre endpoint est hors service ou si l’événement n’est pas confirmé correctement, Checkout redirige le client vers l’URL `success_url` 10 secondes après la finalisation du paiement. Pour les tests, vous pouvez surveiller les événements dans le [Dashboard](https://dashboard.stripe.com/events) ou utiliser l’[interface de ligne de commande Stripe](https://docs.stripe.com/webhooks.md#test-webhook). Pour le mode production, configurez un endpoint de webhook et abonnez-vous aux types d’événement appropriés. Si vous ne connaissez pas votre clé `STRIPE_WEBHOOK_SECRET`, cliquez sur le [webhook](https://dashboard.stripe.com/webhooks) dans le Dashboard pour l’afficher. #### Node.js ```javascript // Don't put any keys in code. See https://docs.stripe.com/keys-best-practices. // Find your keys at https://dashboard.stripe.com/apikeys. const stripe = require('stripe')('<>'); app.post("/webhook", async (req, res) => { let data; let eventType; // Check if webhook signing is configured. const webhookSecret = "{{STRIPE_WEBHOOK_SECRET}}" // Exemple : whsec_c7681Dm if (webhookSecret) { // Retrieve the event by verifying the signature using the raw body and secret. let event; let signature = req.headers["stripe-signature"]; try { event = stripe.webhooks.constructEvent( req.body, signature, webhookSecret ); } catch (err) { console.log(`⚠️ Webhook signature verification failed.`); return res.sendStatus(400); } // Extract the object from the event. data = event.data; eventType = event.type; } else { // Webhook signing is recommended, but if the secret is not configured in `config.js`, // retrieve the event data directly from the request body. data = req.body.data; eventType = req.body.type; } switch (eventType) { case 'checkout.session.completed': const session = event.data.object; // Payment is successful. // Update the customer in your database to reflect this purchase. const user = myUserDB.userForStripeCustomerID(session.customer); user.addCoinsTransaction(100, session.id); break; default: // Unhandled event type } res.sendStatus(200); }); ``` ### Tests Testez votre bouton de paiement qui redirige votre client vers Stripe Checkout. 1. Cliquez sur le bouton de paiement qui vous redirige vers le formulaire de paiement Stripe Checkout. 1. Saisissez le numéro de carte de test 4242 4242 4242 4242, un code CVC à trois chiffres, une date d’expiration et un code postal valide. 1. Appuyez sur **Payer**. 1. Le webhook `checkout.session.completed` s’active et Stripe notifie votre serveur de la transaction. 1. Vous êtes redirigé(e) vers votre application. Si votre intégration ne fonctionne pas, consultez la section [Ressources de test supplémentaires](https://docs.stripe.com/mobile/digital-goods/checkout.md#additional-testing-resources) ci-dessous. ## Optional: Ressources de test supplémentaires Stripe met à votre disposition plusieurs cartes de test que vous pouvez utiliser pour vous assurer que votre intégration est prête à passer en production. Utilisez-les avec n’importe quels code CVC, code postal et date d’expiration future. | Numéro | Description | | ------------------- | ----------------------------------------------------------------------------------- | | 4242 4242 4242 4242 | Fait aboutir le paiement et le traite immédiatement. | | 4000 0000 0000 3220 | Effectue une authentification 3D Secure 2 pour que le paiement aboutisse. | | 4000 0000 0000 9995 | Échec systématique avec le code de refus de paiement `insufficient_funds`. | Pour obtenir la liste complète des cartes de test, consultez notre guide consacré aux [tests](https://docs.stripe.com/testing.md). ### Tester des liens universels Si votre lien universel ne vous renvoie pas vers votre application depuis Checkout, vérifiez que les logs `SharedWebCredentials` ne contiennent pas d’erreurs. 1. Ajouter un paramètre de débogage au droit de domaine associé - Ouvrez le volet **Signatures et fonctionnalités** de la cible de votre application. - Ajoutez le flag `?mode=developer` dans votre saisie pour votre domaine associé. *(Exemple : `applinks:example.com?mode=developer`)* 1. Passez l’appareil en mode développeur. - Exécutez une application de Xcode sur votre appareil pour activer le menu développeur. - Sur votre iPhone, ouvrez le volet **Réglages**, touchez **Développeur**, puis activez **Développement des domaines associés**. 1. Supprimez et désinstallez votre application. De cette manière, iOS récupérera à nouveau le fichier apple-app-site-association. 1. Finalisez le tunnel de paiement dans votre application. 1. Checkout vous redirige vers votre application. Si ce n’est pas le cas, lancez un diagnostic système. 1. Appuyez simultanément sur les boutons d’augmentation du volume, de réduction du volume et de marche/arrêt pendant 1 seconde, puis relâchez-les. Vous sentirez une courte vibration, mais aucun élément visuel ne s’affichera. 1. Patientez 5 minutes, puis accédez à **Paramètres** > **Confidentialité** > **Analyses et Amélioration** > **Données d’analyse**. Ensuite, faites défilez la page jusqu’au dernier fichier de diagnostic système de la liste. 1. Touchez le bouton de partage pour envoyer le fichier avec AirDrop sur votre ordinateur. 1. Ouvrez l’archive du diagnostic système, puis le fichier `swcutil_show.txt` 1. Recherchez l’ID de votre application dans ce fichier. Vous verrez une section contenant des informations de débogage pour votre application, dont un message d’erreur, le cas échéant. ``` Service: applinks App ID: Y28TH9SHX7.com.stripe.FruitStore App Version: 1.0 App PI: { v = 0, t = 0x8, u = 0xc98, db = E335D78F-D49E-4F19-A150-F657E50DEDAE, {length = 8, bytes = 0x980c000000000000} } Domain: example.com?mode=developer User Approval: unspecified Site/Fmwk Approval: unspecified Flags: developer Last Checked: 2021-09-23 18:16:58 +0000 Next Check: 2021-09-23 21:21:34 +0000 Error: Error Domain=NSCocoaErrorDomain Code=3840 "JSON text did not start with array or object and option to allow fragments not set. around line 1, column 0." UserInfo={NSDebugDescription=JSON text did not start with array or object and option to allow fragments not set. around line 1, column 0., NSJSONSerializationErrorIndex=0} Retries: 1 ``` ## Optional: Achats dans l’application avec Managed Payments Acceptez des paiements avec Managed Payments, qui peut gérer de nombreuses fonctions d’entreprises (telles que les taxes et les litiges) en votre nom. En savoir plus sur [comment utiliser Managed Payments](https://docs.stripe.com/payments/managed-payments/set-up-mobile.md), la solution de marchand officiel de Stripe, pour les achats in-app. ## See also - [Ajouter des réductions](https://docs.stripe.com/payments/checkout/discounts.md) - [Collecte des taxes](https://docs.stripe.com/payments/checkout/taxes.md) - [Collecte des numéros fiscaux](https://docs.stripe.com/tax/checkout/tax-ids.md) - [Personnaliser l’adaptation à votre marque](https://docs.stripe.com/payments/checkout/customization.md) - [Personnaliser votre page de confirmation de paiement](https://docs.stripe.com/payments/checkout/custom-success-page.md)