Checkout

# Configurer des paiements PayPal futurs Découvrez comment enregistrer des informations PayPal pour débiter vos clients ultérieurement. Configurez des paiements PayPal futurs afin d’enregistrer les informations de paiement des clients pour les abonnements, les paiements différés et simplifier les futurs achats. Découvrez comment activer et utiliser les paiements récurrents avec PayPal par le biais de Stripe. ## Activer les paiements récurrents Stripe active automatiquement les paiements récurrents pour la plupart des utilisateurs lorsqu’ils [activent les paiements PayPal](https://docs.stripe.com/payments/paypal/activate.md) dans le Dashboard Stripe. Cependant, en raison des politiques de PayPal et des restrictions régionales, certains utilisateurs peuvent avoir besoin d’activer manuellement les paiements récurrents. C’est le cas notamment pour les utilisateurs qui ont configuré leur compte avant l’introduction de l’activation automatique. Pour activer manuellement les paiements récurrents : 1. Accédez à vos [paramètres des moyens de paiement](https://dashboard.stripe.com/settings/payment_methods). 1. Cliquez sur **PayPal** > **Activer** dans la section **Paiements récurrents**. Une fois que vous activez les paiements récurrents, l’accès apparaît comme **en attente** dans le Dashboard. L’accès est généralement disponible sous cinq jours ouvrables. Une fois l’accès accordé, les paiements récurrents sont disponibles dans vos [paramètres PayPal](https://dashboard.stripe.com/settings/payment_methods). Dans les environnements de test, les paiements récurrents sont activés par défaut. Utilisez [Stripe Checkout](https://docs.stripe.com/payments/checkout.md) pour recueillir à l’avance des informations de paiement PayPal et déterminez ultérieurement la date et le montant du paiement. Utilisez cette méthode pour : - Enregistrer des moyens de paiement dans un portefeuille pour faciliter les futurs achats - Encaisser des surtaxes après la fourniture d’un service - [Démarrer une période d’essai gratuit dans le cadre d’un abonnement](https://docs.stripe.com/billing/subscriptions/trials.md) ## Configurer Stripe [Côté serveur] Pour commencer, vous devez créer un compte Stripe. [Inscrivez-vous maintenant](https://dashboard.stripe.com/register). Utilisez nos bibliothèques officielles pour accéder à l’API Stripe 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 ou récupérer un objet Customer avant la configuration [Côté serveur] Pour que la réutilisation d’un moyen de paiement PayPal soit possible pour de futurs paiements, celui-ci doit être associé à 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). Vous devez créer un objet Customer lorsque votre client crée un compte auprès de votre entreprise. En associant l’ID de l’objet Customer à votre propre représentation interne de ce client, vous pourrez par la suite récupérer et utiliser les informations stockées concernant son moyen de paiement. Si votre client n’a pas créé de compte, il vous est toujours possible de lui créer un objet Customer sans attendre, que vous associerez ultérieurement à votre représentation interne de ce compte client. ```curl curl -X POST https://api.stripe.com/v1/customers \ -u "<>:" ``` ## Créer une session Checkout [Côté client] [Côté serveur] Pour que vous puissiez accepter les paiements PayPal, votre client doit préalablement vous autoriser à utiliser son compte PayPal pour ses paiements futurs via Stripe Checkout. Ajoutez sur votre site Web un bouton de paiement qui appelle un endpoint côté serveur afin de créer une [session Checkout](https://docs.stripe.com/api/checkout/sessions.md). ```html Checkout ``` Créez une session Checkout en mode `setup` pour recueillir les informations requises. Après avoir créé la session Checkout, redirigez votre client vers l’[URL](https://docs.stripe.com/api/checkout/sessions/object.md#checkout_session_object-url) renvoyée dans la réponse. #### curl ```bash curl https://api.stripe.com/v1/checkout/sessions \ -u <>: \ -d "payment_method_types[]"="paypal" \ -d mode=setup \ -d customer="{{CUSTOMER_ID}}" \ -d success_url="https://example.com/success?session_id={CHECKOUT_SESSION_ID}" \ ``` Quand votre client fournit les informations de son moyen de paiement, il est redirigé vers l’URL `success_url`, une page de votre site Web qui l’informe que son moyen de paiement a bien été enregistré. Mettez l’ID de session à disposition sur votre page de confirmation de paiement en incluant la variable de modèle `{CHECKOUT_SESSION_ID}` dans l’URL `success_url`, comme illustré ci-dessus. > Ne vous fiez pas uniquement à la redirection vers `success_url` pour détecter l’initiation d’un paiement, car : > > - Des utilisateurs malveillants pourraient accéder directement au `success_url` sans payer et obtenir l’accès à vos biens ou à vos services. - Après un paiement réussi, les clients peuvent fermer l’onglet de leur navigateur avant d’être redirigés vers `success_url`. ## Récupérer le moyen de paiement [Côté serveur] Une fois que le client a soumis ses informations de paiement, récupérez l’objet [PaymentMethod](https://docs.stripe.com/payments/payment-methods.md). Un *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) stocke les informations PayPal account du client pour ses paiements ultérieurs. Vous pouvez récupérer cet objet de manière synchrone en utilisant la `success_url` ou de manière asynchrone au moyen de *webhooks* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests). La décision de récupérer l’objet PaymentMethod de manière synchrone ou asynchrone dépend de votre tolérance aux abandons de paiement. En effet, il peut arriver que le client n’aboutisse pas au `success_url` à l’issue de son paiement (il peut par exemple lui arriver de fermer l’onglet de son navigateur avant que la redirection n’intervienne). L’utilisation de webhooks vous permet d’éviter que votre intégration ne subisse ce type d’abandon. #### Webhooks Gérez des webhooks `checkout.session.completed`, qui contiennent un objet Session. Pour en savoir plus, consultez la page sur la [configuration de webhooks](https://docs.stripe.com/webhooks.md). Voici un exemple de réponse `checkout.session.completed` : ```json { "id": "evt_1Ep24XHssDVaQm2PpwS19Yt0", "object": "event", "api_version": "2019-03-14", "created": 1561420781, "data": { "object": { "id": "cs_test_MlZAaTXUMHjWZ7DcXjusJnDU4MxPalbtL5eYrmS2GKxqscDtpJq8QM0k", "object": "checkout.session", "billing_address_collection": null, "client_reference_id": null, "customer": null, "customer_email": null, "display_items": [], "mode": "setup","setup_intent": "seti_1EzVO3HssDVaQm2PJjXHmLlM", "submit_type": null, "subscription": null, "success_url": "https://example.com/success" } }, "livemode": false, "pending_webhooks": 1, "request": { "id": null, "idempotency_key": null }, "type": "checkout.session.completed" } ``` Notez la valeur de la clé `setup_intent`, qui est l’identifiant du SetupIntent créé avec la Checkout Session. Un [SetupIntent](https://docs.stripe.com/payments/setup-intents.md) est un objet utilisé pour configurer les informations du client PayPal account pour les futurs paiements. [Récupérez](https://docs.stripe.com/api/setup_intents/retrieve.md) l’objet SetupIntent avec l’ID. L’objet renvoyé contient l’identifiant `payment_method`. ```curl curl https://api.stripe.com/v1/setup_intents/seti_1EzVO3HssDVaQm2PJjXHmLlM \ -u "<>:" ``` #### URL après paiement réussi Récupération du `session_id` depuis l’URL lorsque l’utilisateur est redirigé vers votre site et [récupération](https://docs.stripe.com/api/checkout/sessions/retrieve.md) de l’objet Session. ```curl curl -G https://api.stripe.com/v1/checkout/sessions/{{SESSION_ID}} \ -u "<>:" \ -d "expand[]=setup_intent" ``` > Pour faire en sorte que le `session_id` soit disponible depuis l’URL, incluez la variable de modèle `session_id={CHECKOUT_SESSION_ID}` dans le `success_url` lors de la création de la session Checkout. Notez le SetupIntent créé pendant la Checkout Session. Un [SetupIntent](https://docs.stripe.com/payments/setup-intents.md) est un objet utilisé pour configurer les informations du client PayPal account pour les futurs paiements. L’objet renvoyé contient l’identifiant `payment_method`. ## Gérer les événements post-configuration [Côté serveur] Pour confirmer la bonne autorisation d’un contrat de facturation par votre client, il est préférable d’utiliser une méthode telle que les [webhooks](https://docs.stripe.com/payments/payment-intents/verifying-status.md#webhooks) plutôt que d’attendre que votre client se rende sur la page d’état du paiement. Lorsqu’un client autorise le contrat de facturation, le SetupIntent émet un événement *webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) [setup_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-setup_intent.succeeded). Si un client n’autorise pas correctement le contrat de facturation, le SetupIntent émet l’événement webhook [setup_intent.setup_failed](https://docs.stripe.com/api/events/types.md#event_types-setup_intent.setup_failed) et revient à l’état `requires_payment_method`. Si un client révoque le contrat de facturation depuis son compte PayPal, cela génère un événement [mandate.updated](https://docs.stripe.com/api/events/types.md#event_types-mandate.updated). ## Tester l'intégration Testez votre intégration PayPal avec vos [clés API de test](https://docs.stripe.com/keys.md#test-live-modes) en accédant à la page de redirection. Vous pouvez tester l’aboutissement du paiement en l’authentifiant sur la page de redirection. Le PaymentIntent passera alors de l’état `requires_action` à `succeeded`. Pour tester un échec d’authentification de l’utilisateur, utilisez vos clés API de test et accédez à la page de redirection. Sur cette page, cliquez sur **Échec du paiement test**. Votre PaymentIntent bascule alors de l’état `requires_action` à `requires_payment_method`. ## Utiliser le moyen de paiement pour les paiements ultérieurs [Côté serveur] Au moment de débiter votre client hors session, utilisez les ID des objets *Customer* (Customer objects represent customers of your business. They let you reuse payment methods and give you the ability to track multiple payments) et *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) pour créer un [PaymentIntent](https://docs.stripe.com/api/payment_intents.md). Pour trouver un instrument `paypal` à débiter, affichez la [liste](https://docs.stripe.com/api/payment_methods/list.md) des objets PaymentMethod associés à votre client. ```curl curl -G https://api.stripe.com/v1/payment_methods \ -u "<>:" \ -d customer={{CUSTOMER_ID}} \ -d type=paypal ``` Après avoir obtenu les ID de Customer et de PaymentMethod, créez un PaymentIntent indiquant le montant et la devise du paiement. Définissez quelques autres paramètres afin d’effectuer le *paiement hors session* (A payment is described as off-session if it occurs without the direct involvement of the customer, using previously-collected payment information) : - Définissez [off_session](https://docs.stripe.com/api/payment_intents/confirm.md#confirm_payment_intent-off_session) sur `true` pour indiquer que le client n’est pas dans votre tunnel de paiement lors de cette tentative de paiement. Dans ce cas, le PaymentIntent renvoie une erreur si une authentification est requise. - Assignez la valeur `true` à la propriété [confirm](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-confirm) du PaymentIntent, ce qui aura pour effet de générer immédiatement une confirmation lors de la création du PaymentIntent. - Renseignez l’ID du PaymentMethod dans [payment_method](https://docs.stripe.com/api.md#create_payment_intent-payment_method) et l’ID du client dans [customer](https://docs.stripe.com/api.md#create_payment_intent-customer). ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=eur \ -d customer={{CUSTOMER_ID}} \ -d "payment_method_types[]=paypal" \ -d payment_method={{PAYMENT_METHOD_ID}} \ -d off_session=true \ -d confirm=true ``` ## Annulation d'un moyen de paiement initiée par l'utilisateur [Côté serveur] Les clients peuvent annuler leur abonnement (contrat de facturation) via leur compte PayPal. Dans ce cas, Stripe émet un webhook [mandat.updated](https://docs.stripe.com/api/events/types.md#event_types-mandate.updated). Tous les PaymentIntents ultérieurs utilisant ce moyen de paiement enregistré échoueront tant qu’il n’existera pas de moyen de paiement associé à un mandat actif. Si un paiement échoue, l’état de l’objet abonnement passe à l’état configuré dans vos [paramètres d’encaissement automatique](https://docs.stripe.com/invoicing/automatic-collection.md). Informez votre client de l’échec du paiement et [débitez-le à l’aide d’un autre moyen de paiement](https://docs.stripe.com/billing/subscriptions/overview.md#requires-payment-method). ## Optional: Supprimer un compte PayPal enregistré [Côté serveur] Vous pouvez utiliser l’API [Detach](https://docs.stripe.com/api/payment_methods/detach.md) pour supprimer le compte PayPal enregistré d’un client de ses moyens de paiement. Quand vous dissociez un moyen de paiement PayPal, cela révoque le [mandat](https://docs.stripe.com/api/mandates.md) correspondant et génère un appel à l’API PayPal afin d’annuler le contrat de facturation PayPal associé. ```curl curl -X POST https://api.stripe.com/v1/payment_methods/{{PAYMENT_METHOD_ID}}/detach \ -u "<>:" ``` # API directe > This is a API directe for when payment-ui is direct-api. View the full page at https://docs.stripe.com/payments/paypal/set-up-future-payments?payment-ui=direct-api. Vous pouvez utiliser l’API [Setup Intents](https://docs.stripe.com/api/setup_intents.md) pour collecter à l’avance les données d’un moyen de paiement PayPal, en vue d’un paiement dont la date et le montant seront déterminés ultérieurement. Utilisez-la pour : - Enregistrer des moyens de paiement dans un portefeuille pour faciliter les futurs achats - Encaisser des surtaxes après la fourniture d’un service - [Démarrer une période d’essai gratuit dans le cadre d’un abonnement](https://docs.stripe.com/billing/subscriptions/trials.md) ## Configurer Stripe [Côté serveur] Pour commencer, vous devez créer un compte Stripe. [Inscrivez-vous maintenant](https://dashboard.stripe.com/register). Utilisez nos bibliothèques officielles pour accéder à l’API Stripe 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 ou récupérer un objet Customer avant la configuration [Côté serveur] Pour que la réutilisation d’un moyen de paiement PayPal soit possible pour de futurs paiements, celui-ci doit être associé à 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). Vous devez créer un objet Customer lorsque votre client crée un compte auprès de votre entreprise. En associant l’ID de l’objet Customer à votre propre représentation interne de ce client, vous pourrez par la suite récupérer et utiliser les informations stockées concernant son moyen de paiement. Si votre client n’a pas créé de compte, il vous est toujours possible de lui créer un objet Customer sans attendre, que vous associerez ultérieurement à votre représentation interne de ce compte client. ```curl curl -X POST https://api.stripe.com/v1/customers \ -u "<>:" ``` ## Créer un SetupIntent [Côté serveur] Un [SetupIntent](https://docs.stripe.com/api/setup_intents.md) est un objet qui représente votre intention de configurer le moyen de paiement de votre client en vue de paiements futurs et qui suit les étapes de cette configuration. Créez un [SetupIntent](https://docs.stripe.com/api/setup_intents.md) sur votre serveur en définissant l’attribut [payment_method_types](https://docs.stripe.com/api/setup_intents/create.md#create_setup_intent-payment_method_types) sur `paypal` et en indiquant l’[id](https://docs.stripe.com/api/customers/object.md#customer_object-id) de l’objet *Customer* (Customer objects represent customers of your business. They let you reuse payment methods and give you the ability to track multiple payments). ```curl curl https://api.stripe.com/v1/setup_intents \ -u "<>:" \ -d "customer={{CUSTOMER_ID}}" \ -d "payment_method_types[]=paypal" \ -d "payment_method_data[type]=paypal" ``` Le SetupIntent contient une clé [client_secret](https://docs.stripe.com/api/setup_intents/object.md#setup_intent_object-client_secret), une clé unique que vous devez transmettre à Stripe côté client afin de rediriger votre client vers PayPal pour que celui-ci autorise le mandat. ## Rediriger votre client [Côté client] Lorsqu’un client tente de configurer son compte PayPal pour les prochains paiements, nous vous conseillons d’utiliser [Stripe.js](https://docs.stripe.com/js.md) pour confirmer le SetupIntent. Stripe.js est notre bibliothèque JavaScript de base pour le développement de tunnels de paiement. Elle gère automatiquement les opérations complexes telles que la redirection décrite ci-dessous, et vous permet d’ajouter facilement d’autres moyens de paiement à votre intégration par la suite. Intégrez le script Stripe.js à votre page de paiement en l’ajoutant en haut de votre fichier HTML. ```html Checkout ``` 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('<>', {} ); ``` Pour confirmer la configuration côté client, transmettez la clé secrète du client de l’objet SetupIntent créé à l’étape 3. La clé secrète du client est distincte de vos clés API, qui authentifient les requêtes à l’API Stripe. Cette clé doit être utilisée avec prudence, car elle peut servir à finaliser le paiement. Elle ne doit être ni enregistrée, ni intégrée dans des URL, ni dévoilée à d’autres personne que votre client. ### Confirmer la configuration PayPal Afin de vous autoriser à utiliser son compte PayPal pour ses prochains paiements, votre client sera redirigé vers la page du contrat de facturation PayPal, où il devra donner son approbation avant d’être redirigé vers votre site Web. Utilisez [stripe.confirmPayPalSetup](https://docs.stripe.com/js/setup_intents/confirm_paypal_setup) pour gérer la redirection vers PayPal et finaliser la configuration. Ajoutez une URL `return_url` à cette fonction pour indiquer à Stripe vers quelle page rediriger l’utilisateur une fois que ce dernier approuve le contrat de facturation sur le site Web de PayPal. ```javascript // Redirects away from the client const {error} = await stripe.confirmPayPalSetup( '{{SETUP_INTENT_CLIENT_SECRET}}', { return_url: 'https://example.com/setup/complete', mandate_data: { customer_acceptance: { type: 'online', online: { infer_from_client: true } } }, } ); if (error) { // Inform the customer that there was an error. } ``` Vous trouverez l’ID du payeur du moyen de paiement et l’ID du contrat de facturation sur le [mandat](https://docs.stripe.com/api/mandates/.md) ainsi généré, sous la propriété [payment_method_details](https://docs.stripe.com/api/mandates/object.md#mandate_object-payment_method_details-paypal). Vous trouverez également l’adresse e-mail et l’ID de payeur de l’acheteur dans la propriété [paypal](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-paypal) de [PaymentMethod](https://docs.stripe.com/api/payment_methods.md). | Champ | Valeur | | ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- | | `payer_email` | L’adresse e-mail du payeur sur son compte PayPal. | | `payer_id` | L’identifiant unique du compte PayPal du payeur. | | `billing_agreement_id` | L’ID de contrat de facturation PayPal (BAID). Il s’agit d’un identifiant généré par PayPal et qui représente le mandat entre l’entreprise et le client. | ## Surveiller les webhooks [Côté serveur] Pour confirmer la bonne autorisation d’un contrat de facturation par votre client, il est préférable d’utiliser une méthode telle que les [webhooks](https://docs.stripe.com/payments/payment-intents/verifying-status.md#webhooks) plutôt que d’attendre que votre client se rende sur la page d’état du paiement. Lorsqu’un client autorise le contrat de facturation, le SetupIntent émet un événement *webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) [setup_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-setup_intent.succeeded). Si un client n’autorise pas correctement le contrat de facturation, le SetupIntent émet l’événement webhook [setup_intent.setup_failed](https://docs.stripe.com/api/events/types.md#event_types-setup_intent.setup_failed) et revient à l’état `requires_payment_method`. Si un client révoque le contrat de facturation depuis son compte PayPal, cela génère un événement [mandate.updated](https://docs.stripe.com/api/events/types.md#event_types-mandate.updated). ## Débiter des paiements hors session avec un moyen de paiement PayPal enregistré [Côté serveur] Au moment de débiter votre client hors session, utilisez les ID des objets *Customer* (Customer objects represent customers of your business. They let you reuse payment methods and give you the ability to track multiple payments) et *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) pour créer un [PaymentIntent](https://docs.stripe.com/api/payment_intents.md). Pour trouver un instrument `paypal` à débiter, affichez la [liste](https://docs.stripe.com/api/payment_methods/list.md) des objets PaymentMethod associés à votre client. ```curl curl -G https://api.stripe.com/v1/payment_methods \ -u "<>:" \ -d customer={{CUSTOMER_ID}} \ -d type=paypal ``` Après avoir obtenu les ID de Customer et de PaymentMethod, créez un PaymentIntent indiquant le montant et la devise du paiement. Définissez quelques autres paramètres afin d’effectuer le *paiement hors session* (A payment is described as off-session if it occurs without the direct involvement of the customer, using previously-collected payment information) : - Définissez [off_session](https://docs.stripe.com/api/payment_intents/confirm.md#confirm_payment_intent-off_session) sur `true` pour indiquer que le client n’est pas dans votre tunnel de paiement lors de cette tentative de paiement. Dans ce cas, le PaymentIntent renvoie une erreur si une authentification est requise. - Assignez la valeur `true` à la propriété [confirm](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-confirm) du PaymentIntent, ce qui aura pour effet de générer immédiatement une confirmation lors de la création du PaymentIntent. - Renseignez l’ID du PaymentMethod dans [payment_method](https://docs.stripe.com/api.md#create_payment_intent-payment_method) et l’ID du client dans [customer](https://docs.stripe.com/api.md#create_payment_intent-customer). ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=eur \ -d customer={{CUSTOMER_ID}} \ -d "payment_method_types[]=paypal" \ -d payment_method={{PAYMENT_METHOD_ID}} \ -d off_session=true \ -d confirm=true ``` ## Débiter des paiements pendant une session avec un moyen de paiement PayPal enregistré [Côté client] Au moment de débiter votre client pendant une session, utilisez les ID des objets *Customer* (Customer objects represent customers of your business. They let you reuse payment methods and give you the ability to track multiple payments) et *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) pour créer un [PaymentIntent](https://docs.stripe.com/api/payment_intents.md). Pour trouver un instrument `paypal` à débiter, [listez les PaymentMethods](https://docs.stripe.com/api/payment_methods/list.md) associés à votre objet Customer. ```curl curl -G https://api.stripe.com/v1/payment_methods \ -u "<>:" \ -d customer={{CUSTOMER_ID}} \ -d type=paypal ``` Après avoir obtenu les ID du Customer et du PaymentMethod, créez un PaymentIntent en spécifiant le montant et la devise du paiement : ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=eur \ -d customer={{CUSTOMER_ID}} \ -d "payment_method_types[]=paypal" \ -d payment_method={{PAYMENT_METHOD_ID}} ``` À l’aide du SDK Stripe.js, appelez la fonction [confirmPayPalPayment](https://docs.stripe.com/js/payment_intents/confirm_paypal_payment) pour exécuter le PaymentIntent créé : ```javascript // Confirms the on-session payment const {error} = await stripe.confirmPayPalPayment( '{{PAYMENT_INTENT_CLIENT_SECRET}}', {payment_method: '{{PAYMENT_METHOD_ID}}'} // Note: return_url is not required here because the PayPal payment method was // previously set up using either a SetupIntent or a PaymentIntent with setup_future_usage ); if (error) { // Inform the customer that there was an error. } ``` > **Remarque** : le paramètre `return_url` est requis sous condition pour `confirmPayPalPayment` : > > - Cela n’est *pas nécessaire* lors de l’utilisation d’un moyen de paiement PayPal qui était auparavant configuré avec un SetupIntent ou un PaymentIntent avec`setup_future_usage`. - Cela est *obligatoire* pour tous les autres cas, y compris lors de la création d’un nouveau moyen de paiement pendant une session sur PayPal. ## Annulation d'un moyen de paiement initiée par l'utilisateur [Côté serveur] Les clients peuvent annuler leur abonnement (contrat de facturation) via leur compte PayPal. Dans ce cas, Stripe émet un webhook [mandat.updated](https://docs.stripe.com/api/events/types.md#event_types-mandate.updated). Tous les PaymentIntents ultérieurs utilisant ce moyen de paiement enregistré échoueront tant qu’il n’existera pas de moyen de paiement associé à un mandat actif. Si un paiement échoue, l’état de l’objet abonnement passe à l’état configuré dans vos [paramètres d’encaissement automatique](https://docs.stripe.com/invoicing/automatic-collection.md). Informez votre client de l’échec du paiement et [débitez-le à l’aide d’un autre moyen de paiement](https://docs.stripe.com/billing/subscriptions/overview.md#requires-payment-method). ## Optional: Configurer des paiements PayPal futurs et les capturer [Côté serveur] Lorsque vous créez un [PaymentIntent](https://docs.stripe.com/api/payment_intents.md), vous pouvez également débiter votre client tout en configurant le moyen de paiement PayPal en vue d’une utilisation ultérieure. Définissez [setup_future_usage](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-setup_future_usage) sur `off_session` pour indiquer que vous souhaitez configurer le moyen de paiement en vue d’une utilisation ultérieure. ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=eur \ -d "payment_method_types[]=paypal" \ -d setup_future_usage=off_session ``` ## Optional: Gérer la redirection PayPal manuellement [Côté serveur] Nous vous recommandons de recourir à Stripe.js pour gérer les redirections et autorisations de facturation PayPal côté client avec `confirmPayPalSetup`. Le recours à Stripe.js vous permet d’ajouter facilement de nouveaux moyens de paiement à votre intégration par la suite. Toutefois, vous pouvez aussi rediriger manuellement vos clients sur votre serveur en procédant comme suit : Vous pouvez *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) l’objet SetupIntent à sa création en configurant `confirm: true` et en fournissant des données sur le mandat dans le paramètre [mandate_data](https://docs.stripe.com/api/setup_intents/create.md#create_setup_intent-mandate_data). Vous devez fournir une URL `return_url` à la confirmation du SetupIntent afin d’indiquer à Stripe vers quelle page rediriger l’utilisateur une fois le paiement effectué sur le site Web ou l’application mobile de PayPal. ```curl curl https://api.stripe.com/v1/setup_intents \ -u "<>:" \ -d "customer={{CUSTOMER_ID}}" \ -d "payment_method_types[]=paypal" \ -d "payment_method_data[type]=paypal" \ -d usage=off_session \ -d "mandate_data[customer_acceptance][type]=online" \ -d "mandate_data[customer_acceptance][online][ip_address]={{IP_ADDRESS}}" \ -d "mandate_data[customer_acceptance][online][user_agent]={{USER_AGENT}}" \ -d confirm=true \ --data-urlencode "return_url=https://example.com/setup/complete" ``` Vérifiez que l’état du SetuptIntent est bien `requires_action` et que le type de `next_action` est `redirect_to_url`. ```json { "id": "seti_1IQ9hjJJahOk1vSNevPWnhEN", "object": "setup_intent","status": "requires_action", "next_action": { "type": "redirect_to_url", "redirect_to_url": { "url": "https://hooks.stripe.com/...", "return_url": "https://example.com/setup/complete" } }, "application": null, "cancellation_reason": null, "client_secret": "seti_1IQ9hjJJahOk1vSNevPWnhEN_secret_J2EAlI0GQbQKV9tg7ITRcUWRBiAwvUV", "created": 1614597263, "customer": null, "description": null, "last_setup_error": null, "latest_attempt": "setatt_1IQ9hkJJahOk1vSN0rsCpnLI", "livemode": false, "mandate": null, "metadata": {}, "next_action": null, "on_behalf_of": null, "payment_method": "pm_1IQ9hjJJahOk1vSNDc5lQWia", "payment_method_options": {}, "payment_method_types": ["paypal"], "single_use_mandate": null, "usage": "off_session" } ``` Redirigez le client vers l’URL fournie dans la propriété `next_action.redirect_to_url.url`. L’exemple de code fourni ici n’a qu’une valeur illustrative : la méthode de redirection peut différer sur votre framework web. #### Ruby ```ruby if setup_intent.status == 'requires_action' && setup_intent.next_action.type == 'redirect_to_url' url = setup_intent.next_action.redirect_to_url.url redirect(url) end ``` À l’issue du processus d’autorisation, le client est redirigé vers `return_url` configurée à l’étape 1. Les paramètres de requête `setup_intent` et `setup_intent_client_secret` de l’URL sont inclus et vous pouvez transmettre vos propres paramètres de requête, comme indiqué plus haut. ## Optional: Gérer manuellement l'intégration des bibliothèques de risques pour les paiements en session [Côté serveur] Nous vous recommandons d’utiliser Stripe.js pour gérer les paiements en session avec un moyen de paiement PayPal enregistré, car il est doté d’une intégration [Fraudnet](https://developer.paypal.com/limited-release/fraudnet/). Cependant, vous pouvez aussi confirmer les PaymentIntents de PayPal manuellement sur votre serveur en suivant ces étapes : Intégrez les bibliothèques de risques de PayPal ([Fraudnet](https://developer.paypal.com/limited-release/fraudnet/) pour le Web et [Magnes](https://developer.paypal.com/limited-release/magnes/) pour mobile) pour autoriser PayPal à collecter les données relatives aux risques lorsque l’acheteur est connecté sur la session de paiement. Cela réduit les risques de fraude et peut augmenter le taux de conversion des paiements pendant une session. Vous avez besoin de l’ID des métadonnées du client (également appelé ID de corrélation des risques) utilisé pour initialiser la bibliothèque lors de l’appel à l’API à Stripe. Une fois la bibliothèque chargée, vous pouvez créer un PaymentIntent avec l’ID des métadonnées du client, le montant et la devise du paiement : ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=eur \ -d customer={{CUSTOMER_ID}} \ -d "payment_method_types[]=paypal" \ -d "payment_method_options[paypal][risk_correlation_id]={{RISK_CORRELATION_ID}}" \ -d confirm=true \ -d payment_method={{PAYMENT_METHOD_ID}} ``` Vous recevrez un code de message `paypal_risk_correlation_id_missing` en cas d’échec de transmission du paramètre [risk_correlation_id](https://docs.stripe.com/api/payment_intents/confirm.md#confirm_payment_intent-payment_method_options-paypal-risk_correlation_id) au moment où vous confirmez un paiement pendant une session. ## Optional: Supprimer un compte PayPal enregistré [Côté serveur] Vous pouvez utiliser l’API [Detach](https://docs.stripe.com/api/payment_methods/detach.md) pour supprimer le compte PayPal enregistré d’un client de ses moyens de paiement. Quand vous dissociez un moyen de paiement PayPal, cela révoque le [mandat](https://docs.stripe.com/api/mandates.md) correspondant et génère un appel à l’API PayPal afin d’annuler le contrat de facturation PayPal associé. ```curl curl -X POST https://api.stripe.com/v1/payment_methods/{{PAYMENT_METHOD_ID}}/detach \ -u "<>:" ``` # 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/paypal/set-up-future-payments?payment-ui=mobile&platform=ios. Vous pouvez utiliser l’API [Setup Intents](https://docs.stripe.com/api/setup_intents.md) pour collecter à l’avance les données d’un moyen de paiement PayPal, en vue d’un paiement dont la date et le montant seront déterminés ultérieurement. Utilisez-la pour : ## Créer ou récupérer un Customer [Côté serveur] Pour réutiliser un moyen de paiement PayPal en vue de paiements futurs, vous devez l’associer à 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). Créez un objet Customer lorsque votre client crée un compte auprès votre entreprise. En associant l’ID de l’objet Customer à votre propre représentation interne de ce client, vous pourrez par la suite récupérer et utiliser les informations du moyen de paiement enregistré. Si votre client n’a pas créé de compte, vous pouvez tout de même lui créer un objet Customer, puis l’associer à votre représentation interne de ce compte du client par la suite. ```curl curl -X POST https://api.stripe.com/v1/customers \ -u "<>:" ``` ## Créer un SetupIntent [Côté serveur] Un [SetupIntent](https://docs.stripe.com/api/setup_intents.md) est un objet qui représente votre intention de configurer le moyen de paiement de votre client en vue de paiements futurs et qui suit les étapes de cette configuration. Créez un [SetupIntent](https://docs.stripe.com/api/setup_intents.md) sur votre serveur en définissant l’attribut [payment_method_types](https://docs.stripe.com/api/setup_intents/create.md#create_setup_intent-payment_method_types) sur `paypal` et en indiquant l’[id](https://docs.stripe.com/api/customers/object.md#customer_object-id) de l’objet *Customer* (Customer objects represent customers of your business. They let you reuse payment methods and give you the ability to track multiple payments). ```curl curl https://api.stripe.com/v1/setup_intents \ -u "<>:" \ -d "customer={{CUSTOMER_ID}}" \ -d "payment_method_types[]=paypal" \ -d "payment_method_data[type]=paypal" ``` Le SetupIntent contient une clé [client_secret](https://docs.stripe.com/api/setup_intents/object.md#setup_intent_object-client_secret), une clé unique que vous devez transmettre à Stripe côté client afin de rediriger votre client vers PayPal pour que celui-ci autorise le mandat. ## Collecter les informations du moyen de paiement [Côté client] #### Swift ```swift // PayPal doesn't require additional parameters so we only need to pass the initialized // STPPaymentMethodPayPalParams instance to STPPaymentMethodParams let payPal = STPPaymentMethodPayPalParams() let paymentMethodParams = STPPaymentMethodParams(payPal: payPal, billingDetails: nil, metadata: nil) ``` ## Soumettre le paiement à Stripe [Côté client] Récupérez la clé secrète du client auprès du SetupIntent que vous avez créé, puis appelez le [STPPaymentHandler confirmSetupIntent](https://stripe.dev/stripe-ios/stripe-payments/Classes/STPPaymentHandler.html#/c:objc\(cs\)STPPaymentHandler\(im\)confirmSetupIntent:withAuthenticationContext:completion:). Une vue Web s’affiche pour permettre au client de finaliser le paiement dans PayPal. Une fois l’opération terminée, le bloc de finalisation est appelé avec le résultat du paiement. #### Swift ```swift let setupIntentParams = STPSetupIntentConfirmParams(clientSecret: setupIntentClientSecret) setupIntentParams.paymentMethodParams = paymentMethodParams setupIntentParams.returnURL = "payments-example://stripe-redirect" STPPaymentHandler.shared().confirmSetupIntent(withParams: setupIntentParams, authenticationContext: self) { (handlerStatus, setupIntent, error) in switch handlerStatus { case .succeeded: // Setup succeeded case .canceled: // Setup was canceled case .failed: // Setup failed @unknown default: fatalError() } } ``` ## Surveiller les webhooks [Côté serveur] Pour confirmer la bonne autorisation d’un contrat de facturation par votre client, il est préférable d’utiliser une méthode telle que les [webhooks](https://docs.stripe.com/payments/payment-intents/verifying-status.md#webhooks) plutôt que d’attendre que votre client se rende sur la page d’état du paiement. Lorsqu’un client autorise le contrat de facturation, le SetupIntent émet un événement *webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) [setup_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-setup_intent.succeeded). Si un client n’autorise pas correctement le contrat de facturation, le SetupIntent émet l’événement webhook [setup_intent.setup_failed](https://docs.stripe.com/api/events/types.md#event_types-setup_intent.setup_failed) et revient à l’état `requires_payment_method`. Si un client révoque le contrat de facturation depuis son compte PayPal, cela génère un événement [mandate.updated](https://docs.stripe.com/api/events/types.md#event_types-mandate.updated). ## Débiter des paiements hors session avec un moyen de paiement PayPal enregistré [Côté serveur] Au moment de débiter votre client hors session, utilisez les ID des objets *Customer* (Customer objects represent customers of your business. They let you reuse payment methods and give you the ability to track multiple payments) et *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) pour créer un [PaymentIntent](https://docs.stripe.com/api/payment_intents.md). Pour trouver un instrument `paypal` à débiter, affichez la [liste](https://docs.stripe.com/api/payment_methods/list.md) des objets PaymentMethod associés à votre client. ```curl curl -G https://api.stripe.com/v1/payment_methods \ -u "<>:" \ -d customer={{CUSTOMER_ID}} \ -d type=paypal ``` Après avoir obtenu les ID de Customer et de PaymentMethod, créez un PaymentIntent indiquant le montant et la devise du paiement. Définissez quelques autres paramètres afin d’effectuer le *paiement hors session* (A payment is described as off-session if it occurs without the direct involvement of the customer, using previously-collected payment information) : - Définissez [off_session](https://docs.stripe.com/api/payment_intents/confirm.md#confirm_payment_intent-off_session) sur `true` pour indiquer que le client n’est pas dans votre tunnel de paiement lors de cette tentative de paiement. Dans ce cas, le PaymentIntent renvoie une erreur si une authentification est requise. - Assignez la valeur `true` à la propriété [confirm](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-confirm) du PaymentIntent, ce qui aura pour effet de générer immédiatement une confirmation lors de la création du PaymentIntent. - Renseignez l’ID du PaymentMethod dans [payment_method](https://docs.stripe.com/api.md#create_payment_intent-payment_method) et l’ID du client dans [customer](https://docs.stripe.com/api.md#create_payment_intent-customer). ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=eur \ -d customer={{CUSTOMER_ID}} \ -d "payment_method_types[]=paypal" \ -d payment_method={{PAYMENT_METHOD_ID}} \ -d off_session=true \ -d confirm=true ``` ## Annulation d'un moyen de paiement initiée par l'utilisateur [Côté serveur] Les clients peuvent annuler leur abonnement (contrat de facturation) via leur compte PayPal. Dans ce cas, Stripe émet un webhook [mandat.updated](https://docs.stripe.com/api/events/types.md#event_types-mandate.updated). Tous les PaymentIntents ultérieurs utilisant ce moyen de paiement enregistré échoueront tant qu’il n’existera pas de moyen de paiement associé à un mandat actif. Si un paiement échoue, l’état de l’objet abonnement passe à l’état configuré dans vos [paramètres d’encaissement automatique](https://docs.stripe.com/invoicing/automatic-collection.md). Informez votre client de l’échec du paiement et [débitez-le à l’aide d’un autre moyen de paiement](https://docs.stripe.com/billing/subscriptions/overview.md#requires-payment-method). ## Optional: Configurer des paiements PayPal futurs et les capturer [Côté serveur] Lorsque vous créez un [PaymentIntent](https://docs.stripe.com/api/payment_intents.md), vous pouvez également débiter votre client tout en configurant le moyen de paiement PayPal en vue d’une utilisation ultérieure. Définissez [setup_future_usage](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-setup_future_usage) sur `off_session` pour indiquer que vous souhaitez configurer le moyen de paiement en vue d’une utilisation ultérieure. ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=eur \ -d "payment_method_types[]=paypal" \ -d setup_future_usage=off_session ``` ## Optional: Gérer manuellement l'intégration des bibliothèques de risques pour les paiements en session [Côté serveur] Nous vous recommandons d’utiliser Stripe.js pour gérer les paiements en session avec un moyen de paiement PayPal enregistré, car il est doté d’une intégration [Fraudnet](https://developer.paypal.com/limited-release/fraudnet/). Cependant, vous pouvez aussi confirmer les PaymentIntents de PayPal manuellement sur votre serveur en suivant ces étapes : Intégrez les bibliothèques de risques de PayPal ([Fraudnet](https://developer.paypal.com/limited-release/fraudnet/) pour le Web et [Magnes](https://developer.paypal.com/limited-release/magnes/) pour mobile) pour autoriser PayPal à collecter les données relatives aux risques lorsque l’acheteur est connecté sur la session de paiement. Cela réduit les risques de fraude et peut augmenter le taux de conversion des paiements pendant une session. Vous avez besoin de l’ID des métadonnées du client (également appelé ID de corrélation des risques) utilisé pour initialiser la bibliothèque lors de l’appel à l’API à Stripe. Une fois la bibliothèque chargée, vous pouvez créer un PaymentIntent avec l’ID des métadonnées du client, le montant et la devise du paiement : ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=eur \ -d customer={{CUSTOMER_ID}} \ -d "payment_method_types[]=paypal" \ -d "payment_method_options[paypal][risk_correlation_id]={{RISK_CORRELATION_ID}}" \ -d confirm=true \ -d payment_method={{PAYMENT_METHOD_ID}} ``` Vous recevrez un code de message `paypal_risk_correlation_id_missing` en cas d’échec de transmission du paramètre [risk_correlation_id](https://docs.stripe.com/api/payment_intents/confirm.md#confirm_payment_intent-payment_method_options-paypal-risk_correlation_id) au moment où vous confirmez un paiement pendant une session. ## Optional: Supprimer un compte PayPal enregistré [Côté serveur] Vous pouvez utiliser l’API [Detach](https://docs.stripe.com/api/payment_methods/detach.md) pour supprimer le compte PayPal enregistré d’un client de ses moyens de paiement. Quand vous dissociez un moyen de paiement PayPal, cela révoque le [mandat](https://docs.stripe.com/api/mandates.md) correspondant et génère un appel à l’API PayPal afin d’annuler le contrat de facturation PayPal associé. ```curl curl -X POST https://api.stripe.com/v1/payment_methods/{{PAYMENT_METHOD_ID}}/detach \ -u "<>:" ``` # 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/paypal/set-up-future-payments?payment-ui=mobile&platform=android. Vous pouvez utiliser l’API [Setup Intents](https://docs.stripe.com/api/setup_intents.md) pour collecter à l’avance les données d’un moyen de paiement PayPal, en vue d’un paiement dont la date et le montant seront déterminés ultérieurement. Utilisez-la pour : - Enregistrer des moyens de paiement dans un portefeuille pour faciliter les futurs achats - Encaisser des surtaxes après la fourniture d’un service - [Démarrer une période d’essai gratuit dans le cadre d’un abonnement](https://docs.stripe.com/billing/subscriptions/trials.md) ## Configurer Stripe [Côté serveur] [Côté client] Tout d’abord, il vous faut un compte Stripe. [Inscrivez-vous](https://dashboard.stripe.com/register). ### Côté serveur Pour cette intégration, votre serveur doit être doté d’endpoints qui communiquent avec l’API Stripe. Utilisez les bibliothèques officielles pour accéder à l’API Stripe depuis votre serveur : #### 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 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` au bloc `dependencies` de votre fichier [app/build.gradle](https://developer.android.com/studio/build/dependencies) : #### Kotlin ```kotlin plugins { id("com.android.application") } android { ... } dependencies { // ... // Stripe Android SDK implementation("com.stripe:stripe-android:23.2.0") // Include the financial connections SDK to support US bank account as a payment method implementation("com.stripe:financial-connections:23.2.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` : #### Kotlin ```kotlin import com.stripe.android.PaymentConfiguration class MyApp : Application() { override fun onCreate() { super.onCreate() PaymentConfiguration.init( applicationContext, "<>" ) } } ``` > 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. Les échantillons de code de Stripe utilisent également [OkHttp](https://github.com/square/okhttp) et [GSON](https://github.com/google/gson) pour envoyer des requêtes HTTP à un serveur. ## Créer ou récupérer un Customer [Côté serveur] Pour réutiliser un moyen de paiement PayPal en vue de paiements futurs, vous devez l’associer à 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). Créez un objet Customer lorsque votre client crée un compte auprès votre entreprise. En associant l’ID de l’objet Customer à votre propre représentation interne de ce client, vous pourrez par la suite récupérer et utiliser les informations du moyen de paiement enregistré. Si votre client n’a pas créé de compte, vous pouvez tout de même lui créer un objet Customer, puis l’associer à votre représentation interne de ce compte du client par la suite. ```curl curl -X POST https://api.stripe.com/v1/customers \ -u "<>:" ``` ## Créer un SetupIntent [Côté serveur] Un [SetupIntent](https://docs.stripe.com/api/setup_intents.md) est un objet qui représente votre intention de configurer le moyen de paiement de votre client en vue de paiements futurs et qui suit les étapes de cette configuration. Créez un [SetupIntent](https://docs.stripe.com/api/setup_intents.md) sur votre serveur en définissant l’attribut [payment_method_types](https://docs.stripe.com/api/setup_intents/create.md#create_setup_intent-payment_method_types) sur `paypal` et en indiquant l’[id](https://docs.stripe.com/api/customers/object.md#customer_object-id) de l’objet *Customer* (Customer objects represent customers of your business. They let you reuse payment methods and give you the ability to track multiple payments). ```curl curl https://api.stripe.com/v1/setup_intents \ -u "<>:" \ -d "customer={{CUSTOMER_ID}}" \ -d "payment_method_types[]=paypal" \ -d "payment_method_data[type]=paypal" ``` Le SetupIntent contient une clé [client_secret](https://docs.stripe.com/api/setup_intents/object.md#setup_intent_object-client_secret), une clé unique que vous devez transmettre à Stripe côté client afin de rediriger votre client vers PayPal pour que celui-ci autorise le mandat. ## Envoyer les informations du moyen de paiement à Stripe [Côté client] Récupérez la clé secrète du client dans le SetupIntent que vous avez créé et appelez la méthode [confirm de PaymentLauncher](https://stripe.dev/stripe-android/payments-core/com.stripe.android.payments.paymentlauncher/-payment-launcher/confirm.html). Une page Web s’affiche dans laquelle le client peut finaliser la configuration avec PayPal. Une fois l’opération terminée, le `PaymentResultCallback` fourni est appelé avec le résultat du paiement. #### Kotlin ```kotlin class PayPalSetupActivity : AppCompatActivity() { // ... private val paymentLauncher: PaymentLauncher by lazy { val paymentConfiguration = PaymentConfiguration.getInstance(this) PaymentLauncher.create( activity = this, publishableKey = paymentConfiguration.publishableKey, stripeAccountId = paymentConfiguration.stripeAccountId, callback = ::onPaymentResult, ) } override fun onCreate(savedInstanceState: Bundle?) { // … startCheckout() } private fun startCheckout() { // Create a SetupIntent on your backend and return the client_secret here val setupIntentClientSecret = // … val payPalPayParams = PaymentMethodCreateParams.createPayPal() val confirmParams = ConfirmSetupIntentParams.create( paymentMethodCreateParams = payPalPayParams, clientSecret = setupIntentClientSecret, // Add a mandate ID or MandateDataParams… ) paymentLauncher.confirm(confirmParams) } private fun onPaymentResult(paymentResult: PaymentResult) { // Handle the setup result… } } ``` ## Surveiller les webhooks [Côté serveur] Pour confirmer la bonne autorisation d’un contrat de facturation par votre client, il est préférable d’utiliser une méthode telle que les [webhooks](https://docs.stripe.com/payments/payment-intents/verifying-status.md#webhooks) plutôt que d’attendre que votre client se rende sur la page d’état du paiement. Lorsqu’un client autorise le contrat de facturation, le SetupIntent émet un événement *webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) [setup_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-setup_intent.succeeded). Si un client n’autorise pas correctement le contrat de facturation, le SetupIntent émet l’événement webhook [setup_intent.setup_failed](https://docs.stripe.com/api/events/types.md#event_types-setup_intent.setup_failed) et revient à l’état `requires_payment_method`. Si un client révoque le contrat de facturation depuis son compte PayPal, cela génère un événement [mandate.updated](https://docs.stripe.com/api/events/types.md#event_types-mandate.updated). ## Débiter des paiements hors session avec un moyen de paiement PayPal enregistré [Côté serveur] Au moment de débiter votre client hors session, utilisez les ID des objets *Customer* (Customer objects represent customers of your business. They let you reuse payment methods and give you the ability to track multiple payments) et *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) pour créer un [PaymentIntent](https://docs.stripe.com/api/payment_intents.md). Pour trouver un instrument `paypal` à débiter, affichez la [liste](https://docs.stripe.com/api/payment_methods/list.md) des objets PaymentMethod associés à votre client. ```curl curl -G https://api.stripe.com/v1/payment_methods \ -u "<>:" \ -d customer={{CUSTOMER_ID}} \ -d type=paypal ``` Après avoir obtenu les ID de Customer et de PaymentMethod, créez un PaymentIntent indiquant le montant et la devise du paiement. Définissez quelques autres paramètres afin d’effectuer le *paiement hors session* (A payment is described as off-session if it occurs without the direct involvement of the customer, using previously-collected payment information) : - Définissez [off_session](https://docs.stripe.com/api/payment_intents/confirm.md#confirm_payment_intent-off_session) sur `true` pour indiquer que le client n’est pas dans votre tunnel de paiement lors de cette tentative de paiement. Dans ce cas, le PaymentIntent renvoie une erreur si une authentification est requise. - Assignez la valeur `true` à la propriété [confirm](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-confirm) du PaymentIntent, ce qui aura pour effet de générer immédiatement une confirmation lors de la création du PaymentIntent. - Renseignez l’ID du PaymentMethod dans [payment_method](https://docs.stripe.com/api.md#create_payment_intent-payment_method) et l’ID du client dans [customer](https://docs.stripe.com/api.md#create_payment_intent-customer). ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=eur \ -d customer={{CUSTOMER_ID}} \ -d "payment_method_types[]=paypal" \ -d payment_method={{PAYMENT_METHOD_ID}} \ -d off_session=true \ -d confirm=true ``` ## Annulation d'un moyen de paiement initiée par l'utilisateur [Côté serveur] Les clients peuvent annuler leur abonnement (contrat de facturation) via leur compte PayPal. Dans ce cas, Stripe émet un webhook [mandat.updated](https://docs.stripe.com/api/events/types.md#event_types-mandate.updated). Tous les PaymentIntents ultérieurs utilisant ce moyen de paiement enregistré échoueront tant qu’il n’existera pas de moyen de paiement associé à un mandat actif. Si un paiement échoue, l’état de l’objet abonnement passe à l’état configuré dans vos [paramètres d’encaissement automatique](https://docs.stripe.com/invoicing/automatic-collection.md). Informez votre client de l’échec du paiement et [débitez-le à l’aide d’un autre moyen de paiement](https://docs.stripe.com/billing/subscriptions/overview.md#requires-payment-method). ## Optional: Configurer des paiements PayPal futurs et les capturer [Côté serveur] Lorsque vous créez un [PaymentIntent](https://docs.stripe.com/api/payment_intents.md), vous pouvez également débiter votre client tout en configurant le moyen de paiement PayPal en vue d’une utilisation ultérieure. Définissez [setup_future_usage](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-setup_future_usage) sur `off_session` pour indiquer que vous souhaitez configurer le moyen de paiement en vue d’une utilisation ultérieure. ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=eur \ -d "payment_method_types[]=paypal" \ -d setup_future_usage=off_session ``` ## Optional: Gérer manuellement l'intégration des bibliothèques de risques pour les paiements en session [Côté serveur] Nous vous recommandons d’utiliser Stripe.js pour gérer les paiements en session avec un moyen de paiement PayPal enregistré, car il est doté d’une intégration [Fraudnet](https://developer.paypal.com/limited-release/fraudnet/). Cependant, vous pouvez aussi confirmer les PaymentIntents de PayPal manuellement sur votre serveur en suivant ces étapes : Intégrez les bibliothèques de risques de PayPal ([Fraudnet](https://developer.paypal.com/limited-release/fraudnet/) pour le Web et [Magnes](https://developer.paypal.com/limited-release/magnes/) pour mobile) pour autoriser PayPal à collecter les données relatives aux risques lorsque l’acheteur est connecté sur la session de paiement. Cela réduit les risques de fraude et peut augmenter le taux de conversion des paiements pendant une session. Vous avez besoin de l’ID des métadonnées du client (également appelé ID de corrélation des risques) utilisé pour initialiser la bibliothèque lors de l’appel à l’API à Stripe. Une fois la bibliothèque chargée, vous pouvez créer un PaymentIntent avec l’ID des métadonnées du client, le montant et la devise du paiement : ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=eur \ -d customer={{CUSTOMER_ID}} \ -d "payment_method_types[]=paypal" \ -d "payment_method_options[paypal][risk_correlation_id]={{RISK_CORRELATION_ID}}" \ -d confirm=true \ -d payment_method={{PAYMENT_METHOD_ID}} ``` Vous recevrez un code de message `paypal_risk_correlation_id_missing` en cas d’échec de transmission du paramètre [risk_correlation_id](https://docs.stripe.com/api/payment_intents/confirm.md#confirm_payment_intent-payment_method_options-paypal-risk_correlation_id) au moment où vous confirmez un paiement pendant une session. ## Optional: Supprimer un compte PayPal enregistré [Côté serveur] Vous pouvez utiliser l’API [Detach](https://docs.stripe.com/api/payment_methods/detach.md) pour supprimer le compte PayPal enregistré d’un client de ses moyens de paiement. Quand vous dissociez un moyen de paiement PayPal, cela révoque le [mandat](https://docs.stripe.com/api/mandates.md) correspondant et génère un appel à l’API PayPal afin d’annuler le contrat de facturation PayPal associé. ```curl curl -X POST https://api.stripe.com/v1/payment_methods/{{PAYMENT_METHOD_ID}}/detach \ -u "<>:" ```