# Paiements BLIK Découvrez comment accepter les paiements effectués à l'aide de BLIK, un moyen de paiement très répandu en Pologne. # Checkout > This is a Checkout for when payment-ui is checkout. View the full page at https://docs.stripe.com/payments/blik/accept-a-payment?payment-ui=checkout. > Stripe peut automatiquement proposer les moyens de paiement pertinents à vos clients en évaluant la devise, les restrictions liées aux moyens de paiement et d’autres paramètres. > > - Suivez le guide [Accepter un paiement](https://docs.stripe.com/payments/accept-a-payment.md?payment-ui=checkout&ui=stripe-hosted) pour créer une intégration de paiement qui utilise des [moyens de paiement dynamiques](https://docs.stripe.com/payments/payment-methods/dynamic-payment-methods.md). - Si vous ne souhaitez pas utiliser de moyens de paiement dynamiques, suivez les étapes ci-dessous pour configurer manuellement les moyens de paiement dans votre intégration Checkout. BLIK est un moyen de paiement [à usage unique](https://docs.stripe.com/payments/payment-methods.md#usage) qui oblige les clients à [authentifier](https://docs.stripe.com/payments/payment-methods.md#customer-actions) leurs paiements. Lorsque les clients souhaitent payer en ligne avec BLIK, ils demandent un code à six chiffres à leur application bancaire et le saisissent dans le formulaire d’encaissement du paiement. La banque adresse une notification push à votre client sur son téléphone portable, l’invitant à autoriser le paiement dans son application bancaire. Le code BLIK est valable 2 minutes, votre client a 60 secondes pour autoriser le paiement après l’avoir initié. Au-delà, le code expire, et un nouveau code BLIK doit alors être demandé. En général, les clients autorisent les paiements BLIK en moins de 10 secondes. ## Déterminer la compatibilité **Lieux d’implantation pris en charge** : AT, AU, BE, BG, CA, CH, CY, CZ, DE, DK, EE, ES, FI, FR, GB, GR, HR, HU, IE, IS, IT, LI, LT, LU, LV, MT, NL, NO, PL, PT, RO, SE, SG, SI, SK, US **Devises prises en charge** : `pln` **Devises de règlement** : `pln` **Mode de paiement** : Yes **Mode de configuration** : Not yet **Mode d’abonnement** : Not yet Pour prendre en charge les paiements BLIK, une session Checkout doit remplir toutes les conditions suivantes : - Le *tarif* (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) de tous les postes doit être indiqué en złotys (code de devise `pln`). ## Accepter un paiement > Ce guide s’appuie sur l’intégration de base de Checkout permettant d’[accepter un paiement](https://docs.stripe.com/payments/accept-a-payment.md?ui=stripe-hosted). Il vous guide tout au long de l’activation de BLIK et vous montre les différences entre l’acceptation de paiements à l’aide de moyens de paiement dynamiques et la configuration manuelle des moyens de paiement. ### Activer le moyen de paiement BLIK Lors de la création d’une nouvelle [session Checkout](https://docs.stripe.com/api/checkout/sessions.md), vous devez : 1. Ajouter `blik` à la liste `payment_method_types`. 1. Veillez à ce que tous vos `line_items` utilisent la devise `pln`. #### Page hébergée par Stripe ```curl curl https://api.stripe.com/v1/checkout/sessions \ -u "<>:" \ -d "line_items[0][price_data][currency]=pln" \ -d "line_items[0][price_data][product_data][name]=T-shirt" \ -d "line_items[0][price_data][unit_amount]=2000" \ -d "line_items[0][quantity]=1" \ -d mode=payment \ -d "payment_method_types[0]=card" \ -d "payment_method_types[1]=blik" \ --data-urlencode "success_url=https://example.com/success" ``` #### Formulaire intégré ```curl curl https://api.stripe.com/v1/checkout/sessions \ -u "<>:" \ -d "line_items[0][price_data][currency]=pln" \ -d "line_items[0][price_data][product_data][name]=T-shirt" \ -d "line_items[0][price_data][unit_amount]=2000" \ -d "line_items[0][quantity]=1" \ -d mode=payment \ -d "payment_method_types[0]=card" \ -d "payment_method_types[1]=blik" \ --data-urlencode "return_url=https://example.com/return" \ -d ui_mode=embedded_page ``` #### Composants intégrés ```curl curl https://api.stripe.com/v1/checkout/sessions \ -u "<>:" \ -d "line_items[0][price_data][currency]=pln" \ -d "line_items[0][price_data][product_data][name]=T-shirt" \ -d "line_items[0][price_data][unit_amount]=2000" \ -d "line_items[0][quantity]=1" \ -d mode=payment \ -d "payment_method_types[0]=card" \ -d "payment_method_types[1]=blik" \ --data-urlencode "return_url=https://example.com/return" \ -d ui_mode=elements ``` ### Ce que vos clients voient Dans leur application bancaire, les clients voient quatre lignes pour chaque transaction BLIK : - Si vous avez fourni une valeur pour [payment_intent_data.description](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-payment_intent_data-description), les deux premières lignes l’affichent (max 70 caractères). - Si vous avez fourni une valeur pour [payment_intent_data.statement_descriptor](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-payment_intent_data-statement_descriptor) (généralement, un ID de commande), la ligne 3 l’affiche (max 22 caractères). - La quatrième ligne présente automatiquement l’URL de votre site web. ### Traiter vos commandes Maintenant que vous savez accepter des paiements, découvrez comment [traiter les commandes](https://docs.stripe.com/checkout/fulfillment.md). ## Tester votre intégration Lors du test de votre intégration Checkout, sélectionnez le moyen de paiement BLIK, puis cliquez sur le bouton **Payer**. Utilisez un *environnement de test* (A sandbox is an isolated test environment that allows you to test Stripe functionality in your account without affecting your live integration. Use sandboxes to safely experiment with new features and changes) pour tester un paiement réussi en saisissant un code à 6 chiffres (tel que `123456`) dans le formulaire de paiement. ## Gérer les litiges et les remboursements Le délai de remboursement applicable aux paiements BLIK est limité à 13 mois après le paiement initial. Les *clients* (Customer objects represent customers of your business. They let you reuse payment methods and give you the ability to track multiple payments) ont la possibilité de contester un paiement auprès de leur banque au cours des 13 mois suivant le paiement initial, et aucun recours n’est possible. En savoir plus sur les [litiges liés à des paiements BLIK](https://docs.stripe.com/payments/blik.md#disputed-payments). ## Optional: Simuler des échecs en environnement de test Les paiements BLIK peuvent échouer pour diverses raisons. Les échecs peuvent être liés à des erreurs immédiates (par exemple, le code a expiré ou n’est pas valide), à des erreurs différées (par exemple, refus de la banque) ou à une expiration (par exemple, le client ne répond pas dans les temps). Vous pouvez simuler chacun de ces échecs en transmettant des valeurs `email` de différents types (documentées ci-dessous) lors de la création du `PaymentIntent`, dans les [informations de facturation](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_data-billing_details), avec n’importe quel code BLIK à 6 chiffres. Vous pouvez saisir l’`email`dans la section des coordonnées de la page Checkout. ### Échecs immédiats | Code d’échec | Explication | Type de l’adresse e-mail | | ---------------------------------- | ------------------------------------------------------------------------------------------------------------------- | ------------------------ | | `payment_method_invalid_parameter` | Le code transmis n’était pas un code BLIK valide. | `.*invalid_code@.*` | | `payment_method_invalid_parameter` | Le code transmis a expiré. Les codes BLIK expirent après 2 minutes. Veuillez demander au client un autre code. | `.*expired_code@.*` | ### Refus (retard de 8 s) | Code d’échec | Explication | Type de l’adresse e-mail | | --------------------------------- | ----------------------------------------------------------------------------------------- | ------------------------- | | `payment_method_provider_decline` | Le paiement a été refusé, car la limite de paiement de ce compte bancaire a été atteinte. | `.*limit_exceeded@.*` | | `payment_method_provider_decline` | Le compte bancaire n’est pas suffisamment approvisionné pour finaliser l’achat. | `.*insufficient_funds@.*` | | `payment_method_provider_decline` | Le client a refusé ce paiement. | `.*customer_declined@.*` | | `payment_method_provider_decline` | La banque du client a refusé le paiement pour un motif inconnu. | `.*bank_declined@.*` | | `payment_method_provider_decline` | Le paiement a été refusé pour un motif inconnu. | `.*blik_declined@.*` | ### Expiration (délai de 60 secondes) | Code d’échec | Explication | Type de l’adresse e-mail | | --------------------------------- | --------------------------------------------------------------------------------- | ------------------------ | | `payment_method_provider_timeout` | Le client n’a pas approuvé ce paiement dans le délai imparti de 60 secondes. | `.*customer_timeout@.*` | | `payment_method_provider_timeout` | La requête envoyée à la banque du client a expiré. | `.*bank_timeout@.*` | | `payment_method_provider_timeout` | La requête envoyée au réseau BLIK a expiré. | `.*blik_timeout@.*` | ## See also - [En savoir plus sur BLIK](https://docs.stripe.com/payments/blik.md) - [Exécution Checkout](https://docs.stripe.com/checkout/fulfillment.md) - [Personnalisation de Checkout](https://docs.stripe.com/payments/checkout/customization.md) # API Direct > This is a API Direct for when payment-ui is direct-api. View the full page at https://docs.stripe.com/payments/blik/accept-a-payment?payment-ui=direct-api. > Nous vous recommandons de suivre le guide [Accepter un paiement](https://docs.stripe.com/payments/accept-a-payment.md), sauf si vous devez exécuter la confirmation manuelle côté serveur, ou si votre intégration requiert la présentation de moyens de paiement de manière distincte. Si vous avez déjà intégré Elements, consultez le [Guide de migration du Payment Element](https://docs.stripe.com/payments/payment-element/migration.md). BLIK est un moyen de paiement [à usage unique](https://docs.stripe.com/payments/payment-methods.md#usage) qui oblige les clients à [authentifier](https://docs.stripe.com/payments/payment-methods.md#customer-actions) leurs paiements. Lorsque les clients souhaitent payer en ligne avec BLIK, ils demandent un code à six chiffres à leur application bancaire et le saisissent dans le formulaire d’encaissement du paiement. La banque adresse une notification push à votre client sur son téléphone portable, l’invitant à autoriser le paiement dans son application bancaire. Le code BLIK est valable 2 minutes, votre client a 60 secondes pour autoriser le paiement après l’avoir initié. Au-delà, le code expire, et un nouveau code BLIK doit alors être demandé. En général, les clients autorisent les paiements BLIK en moins de 10 secondes. ## Configurer Stripe [Côté serveur] Pour commencer, vous devez [créer un compte](https://dashboard.stripe.com/register) Stripe. Utilisez nos bibliothèques officielles pour accéder à l’API Stripe 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 un PaymentIntent [Côté serveur] Un [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) est un objet qui représente votre intention d’encaisser le paiement émis par un client et suit le cycle de vie du processus de paiement étape par étape. Pour commencer, créez un `PaymentIntent` sur votre serveur et précisez le montant à encaisser ainsi que la devise `pln` (la seule devise prise en charge par BLIK). Si vous avez déjà créé une intégration à l’aide de l’[API Payment Intents](https://docs.stripe.com/payments/payment-intents.md), ajoutez `blik` à la liste des [types de moyens de paiement](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) pour votre `PaymentIntent`. ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=pln \ -d "payment_method_types[]=blik" \ --data-urlencode "description=A description of what you're selling" \ -d statement_descriptor=ORDER_123 ``` ### Récupérer la clé secrète du client Le PaymentIntent contient une *clé secrète* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)) à utiliser côté client pour finaliser le processus de paiement en toute sécurité. Vous pouvez adopter différentes approches pour transmettre cette clé secrète côté client. #### Application monopage Récupérez la clé secrète du client à partir d’un endpoint sur votre serveur, à l’aide de la fonction `fetch` du navigateur. Cette approche est recommandée si votre côté client est une application d’une seule page, en particulier si elle repose sur un framework front-end moderne tel que React. Créez l’endpoint de serveur qui gère la clé secrète du client : #### Ruby ```ruby get '/secret' do intent = # ... Create or retrieve the PaymentIntent {client_secret: intent.client_secret}.to_json end ``` Récupérez ensuite la clé secrète du client à l’aide JavaScript côté client : ```javascript (async () => { const response = await fetch('/secret'); const {client_secret: clientSecret} = await response.json(); // Render the form using the clientSecret })(); ``` #### Rendu côté serveur Transmettez la clé secrète à votre client depuis votre serveur. Cette approche fonctionne mieux si votre application génère du contenu statique sur le serveur avant de l’envoyer sur le navigateur. Ajoutez le [client_secret](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) à votre formulaire de paiement. Dans votre code côté serveur, récupérez la clé secrète du client à partir du PaymentIntent : #### Ruby ```erb
``` ```ruby get '/checkout' do @intent = # ... Fetch or create the PaymentIntent erb :checkout end ``` ## Collecter les données du moyen de paiement [Côté client] Pour soumettre le paiement à Stripe, vous devez confirmer le PaymentIntent en utilisant le code BLIK à 6 chiffres du client. Vous pouvez récupérer ce code en créant un formulaire permettant au client de le saisir. #### HTML + JS ```html
``` #### React #### npm Installez [React Stripe.js](https://www.npmjs.com/package/@stripe/react-stripe-js) et le [chargeur Stripe.js](https://www.npmjs.com/package/@stripe/stripe-js) à partir du registre public npm. ```bash npm install --save @stripe/react-stripe-js @stripe/stripe-js ``` #### umd Nous fournissons également une version UMD pour les sites qui n’utilisent pas npm ni de modules. Incluez le script Stripe.js, qui exporte une fonction `Stripe` globale, ainsi que la version UMD de React Stripe.js, qui exporte un objet `ReactStripe` global. Chargez toujours le script Stripe.js directement à partir de **js.stripe.com** pour maintenir votre conformité PCI. Vous ne devez pas inclure le script dans un lot ni en héberger de copie. ```html ``` > La [démo sur CodeSandbox](https://codesandbox.io/s/react-stripe-official-q1loc?fontsize=14&hidenavigation=1&theme=dark) vous permet de tester React Stripe.js sans créer de projet. ### Ajouter Stripe.js et Elements à votre page Pour intégrer Stripe.js et éventuellement utiliser des composants Elements pour d’autres moyens de paiement, wrappez la racine de votre application React dans un [fournisseur Elements](https://docs.stripe.com/sdks/stripejs-react.md#elements-provider). Appelez `loadStripe` avec votre clé publiable et transmettez l’élément `Promise` renvoyé au fournisseur `Elements`. ```jsx import React from 'react'; import ReactDOM from 'react-dom'; import {Elements} from '@stripe/react-stripe-js'; import {loadStripe} from '@stripe/stripe-js'; import CheckoutForm from './CheckoutForm'; // Make sure to call `loadStripe` outside of a component’s render to avoid // recreating the `Stripe` object on every render. const stripePromise = loadStripe('<>'); function App() { return ( ); }; ReactDOM.render(, document.getElementById('root')); ``` ### Créer un formulaire d’acceptation des paiements Si vous comptez utiliser le hook [useStripe](https://docs.stripe.com/sdks/stripejs-react.md#usestripe-hook) pour accéder aux fonctionnalités de Stripe.js, vous pouvez créer un composant React normal. Si vous préférez les composants de classe traditionnels aux hooks, vous pouvez utiliser un [ElementsConsumer](https://docs.stripe.com/sdks/stripejs-react.md#elements-consumer). #### Hooks ```jsx import React from 'react'; import {useStripe} from '@stripe/react-stripe-js'; export default function CheckoutForm() { return (
); } ``` #### Composants de classe ```jsx import React from 'react'; import {ElementsConsumer} from '@stripe/react-stripe-js'; class CheckoutForm extends React.Component { render() { const {stripe} = this.props; return (
); } } export default function InjectedCheckoutForm() { return ( {({stripe, elements}) => ( )} ); } ``` ## Soumettre le paiement à Stripe [Côté client] Utilisez l’objet PaymentIntent de l’[étape 2](https://docs.stripe.com/payments/blik/accept-a-payment.md#web-create-payment-intent) et le code BLIK à 6 chiffres récupéré à l’[étape 3](https://docs.stripe.com/payments/blik/accept-a-payment.md#web-collect-payment-method-details) pour *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) le PaymentIntent. Ce faisant, vous confirmez que le client souhaite payer avec le *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) spécifié. Une fois que l’objet PaymentIntent a été confirmé, il lance un paiement. Au lieu de transmettre au client l’objet PaymentIntent dans son intégralité, utilisez la [clé secrète du client](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret). Cette clé est différente de vos clés API qui servent à authentifier les requêtes à l’API Stripe. Utilisez la clé secrète du client avec prudence, car elle peut servir à mener à bien le paiement. Ne l’enregistrez pas, ne l’intégrez pas dans des URL et ne la dévoilez à personne d’autre que votre client. De plus, comme le code BLIK à 6 chiffres n’est valide que 2 minutes, vous ne pouvez le transmettre dans les options de moyen de paiement qu’au moment de la confirmation du PaymentIntent. Dans un *environnement de test* (A sandbox is an isolated test environment that allows you to test Stripe functionality in your account without affecting your live integration. Use sandboxes to safely experiment with new features and changes), n’importe quel code à 6 chiffres fonctionne. #### HTML + JS Lorsqu’un client clique pour payer avec Blik, utilisez Stripe.js pour soumettre le paiement à Stripe. [Stripe.js](https://docs.stripe.com/payments/elements.md) est la bibliothèque JavaScript de base pour créer les tunnels de paiement : elle gère automatiquement les opérations complexes telles que la redirection décrite ci-dessous, et facilite l’extension de votre intégration à d’autres moyens de paiement. Incluez le script Stripe.js sur votre page de paiement en l’ajoutant à la section `head` 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('<>'); ``` Utilisez [stripe.confirmBlikPayment](https://docs.stripe.com/js/payment_intents/confirm_blik_payment) pour confirmer le paiement. `confirmBlikPayment` n’est renvoyé que lors de l’échec ou de la réussite de la confirmation. Si vous souhaitez implémenter votre propre logique de mise à jour de l’état du paiement, vous pouvez désactiver l’interrogation Stripe.js de l’API en définissant le paramètre `handleActions` sur `false`. ```javascript const form = document.getElementById('payment-form'); const codeInput = document.getElementById('code'); form.addEventListener('submit', (event) => { event.preventDefault(); const {error} = await stripe.confirmBlikPayment( '{{PAYMENT_INTENT_CLIENT_SECRET}}', { payment_method: { blik: {}, }, payment_method_options: { blik: { code: code.value, }, }, } ); }); ``` #### React Lorsqu’un client clique pour payer avec Blik, utilisez Stripe.js pour soumettre le paiement à Stripe. [Stripe.js](https://docs.stripe.com/payments/elements.md) est la bibliothèque JavaScript de base pour créer les tunnels de paiement : elle gère automatiquement les opérations complexes telles que la redirection décrite ci-dessous, et facilite l’extension de votre intégration à d’autres moyens de paiement. Incluez le script Stripe.js sur votre page de paiement en l’ajoutant à la section `head` 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('<>'); ``` Utilisez [stripe.confirmBlikPayment](https://docs.stripe.com/js/payment_intents/confirm_blik_payment) pour confirmer le paiement. `confirmBlikPayment` n’est renvoyé que lors de l’échec ou la réussite de la confirmation. Vous pouvez désactiver l’interrogation de l’API en définissant le paramètre `handleActions` sur `false`. #### Hooks Pour appeler `stripe.confirmBlikPayment` depuis votre composant de formulaire de paiement, utilisez le hook [useStripe](https://docs.stripe.com/sdks/stripejs-react.md#usestripe-hook). ```jsx import React from 'react'; import {useStripe} from '@stripe/react-stripe-js'; export default function CheckoutForm() { const stripe = useStripe(); const handleSubmit = async (event) => { // We don't want to let default form submission happen here, // which would refresh the page. event.preventDefault(); if (!stripe) { // Stripe.js hasn't yet loaded. // Make sure to disable form submission until Stripe.js has loaded. return; } // For brevity, this example is using uncontrolled components for // the code input. In a real world app you will // probably want to use controlled components. // https://reactjs.org/docs/uncontrolled-components.html // https://reactjs.org/docs/forms.html#controlled-components const code = event.target['code']; const {error} = await stripe.confirmBlikPayment('{{PAYMENT_INTENT_CLIENT_SECRET}}', { payment_method: { blik: {}, }, payment_method_options: { blik: { code, }, }, }); if (error) { // Show error to your customer. console.log(error.message); } // Otherwise the customer will be redirected away from your // page to complete the payment with their bank. }; return (
); } ``` #### Composants de classe ```jsx import React from 'react'; import {ElementsConsumer} from '@stripe/react-stripe-js'; class CheckoutForm extends React.Component { handleSubmit = async (event) => { // We don't want to let default form submission happen here, // which would refresh the page. event.preventDefault(); const {stripe} = this.props if (!stripe) { // Stripe.js hasn't yet loaded. // Make sure to disable form submission until Stripe.js has loaded. return; } // For brevity, this example is using uncontrolled components for // the accountholder's name. In a real world app you will // probably want to use controlled components. // https://reactjs.org/docs/uncontrolled-components.html // https://reactjs.org/docs/forms.html#controlled-components const code = event.target['code']; const {error} = await stripe.confirmBlikPayment('{{PAYMENT_INTENT_CLIENT_SECRET}}', { payment_method: { blik: {}, }, payment_method_options: { blik: { code, }, }, }); if (error) { // Show error to your customer. console.log(error.message); } // Otherwise the customer will be redirected away from your // page to complete the payment with their bank. }; render() { const {stripe} = this.props; return (
); } } export default function InjectedCheckoutForm() { return ( {({stripe, elements}) => ( )} ); } ``` Une fois le PaymentIntent confirmé avec des paramètres valides, son `status` devient `requires_action`. `next_action` a le type `blik_authorize` : cela signifie que la prochaine étape est accomplie par le client, qui dispose de 60 secondes pour confirmer le paiement dans son application bancaire. Nous recommandons d’afficher un décompte ou une boîte de dialogue invitant le client à autoriser le paiement dans le délai imparti. ### Ce que vos clients voient Dans leur application bancaire, les clients voient quatre lignes pour chaque transaction BLIK : - Si vous avez fourni une valeur pour `description` lors de la création du PaymentIntent, les deux premières lignes l’affichent (70 caractères max.). - Si vous avez fourni une valeur pour `statement_descriptor` (généralement un ID de commande), elle est affichée sur la ligne 3 (22 caractères max.). - La quatrième ligne présente automatiquement l’URL de votre site web. ## Traiter la commande [Côté serveur] [Utilisez une méthode telle que les webhooks](https://docs.stripe.com/payments/payment-intents/verifying-status.md#webhooks) pour gérer le *traitement* (Fulfillment is the process of providing the goods or services purchased by a customer, typically after payment is collected) de la commande. Lorsque votre client effectue le paiement, l’état du `PaymentIntent` passe à `succeeded` et le PaymentIntent envoie l’événement *webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded). À défaut de paiement, le `PaymentIntent` envoie l’événement webhook [payment_intent.payment_failed](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.payment_failed) et repasse à l’état `requires_payment_method`. ## Optional: Simuler des échecs en environnement de test Les paiements BLIK peuvent échouer pour diverses raisons. Les échecs peuvent être liés à des erreurs immédiates (par exemple, le code a expiré ou n’est pas valide), à des erreurs différées (par exemple, refus de la banque) ou à une expiration (par exemple, le client ne répond pas dans les temps). Vous pouvez simuler chacun de ces échecs en transmettant des valeurs `email` de différents types (documentées ci-dessous) lors de la création du `PaymentIntent`, dans les [informations de facturation](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_data-billing_details), avec n’importe quel code BLIK à 6 chiffres. Lors de la confirmation du `PaymentIntent` côté serveur, une requête simulant un code BLIK invalide se présenterait comme suite : #### curl ```bash curl https://api.stripe.com/v1/payment_intents/{{PAYMENT_INTENT_ID}}/confirm \ -u <>: \ -d "payment_method_data[type]"="blik" \ -d "payment_method_options[blik][code]"="{{CODE}}" \ -d "payment_method_data[billing_details][email]"="invalid_code@example.com" ``` ### Échecs immédiats | Code d’échec | Explication | Type de l’adresse e-mail | | ---------------------------------- | ------------------------------------------------------------------------------------------------------------------- | ------------------------ | | `payment_method_invalid_parameter` | Le code transmis n’était pas un code BLIK valide. | `.*invalid_code@.*` | | `payment_method_invalid_parameter` | Le code transmis a expiré. Les codes BLIK expirent après 2 minutes. Veuillez demander au client un autre code. | `.*expired_code@.*` | ### Refus (retard de 8 s) | Code d’échec | Explication | Type de l’adresse e-mail | | --------------------------------- | ----------------------------------------------------------------------------------------- | ------------------------- | | `payment_method_provider_decline` | Le paiement a été refusé, car la limite de paiement de ce compte bancaire a été atteinte. | `.*limit_exceeded@.*` | | `payment_method_provider_decline` | Le compte bancaire n’est pas suffisamment approvisionné pour finaliser l’achat. | `.*insufficient_funds@.*` | | `payment_method_provider_decline` | Le client a refusé ce paiement. | `.*customer_declined@.*` | | `payment_method_provider_decline` | La banque du client a refusé le paiement pour un motif inconnu. | `.*bank_declined@.*` | | `payment_method_provider_decline` | Le paiement a été refusé pour un motif inconnu. | `.*blik_declined@.*` | ### Expiration (délai de 60 secondes) | Code d’échec | Explication | Type de l’adresse e-mail | | --------------------------------- | --------------------------------------------------------------------------------- | ------------------------ | | `payment_method_provider_timeout` | Le client n’a pas approuvé ce paiement dans le délai imparti de 60 secondes. | `.*customer_timeout@.*` | | `payment_method_provider_timeout` | La requête envoyée à la banque du client a expiré. | `.*bank_timeout@.*` | | `payment_method_provider_timeout` | La requête envoyée au réseau BLIK a expiré. | `.*blik_timeout@.*` | # 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/blik/accept-a-payment?payment-ui=mobile&platform=ios. BLIK est un moyen de paiement [à usage unique](https://docs.stripe.com/payments/payment-methods.md#usage) qui oblige les clients à [authentifier](https://docs.stripe.com/payments/payment-methods.md#customer-actions) leurs paiements. Lorsque les clients souhaitent payer en ligne avec BLIK, ils demandent un code à six chiffres à leur application bancaire et le saisissent dans le formulaire d’encaissement du paiement. La banque adresse une notification push à votre client sur son téléphone portable, l’invitant à autoriser le paiement dans son application bancaire. Le code BLIK est valable 2 minutes, votre client a 60 secondes pour autoriser le paiement après l’avoir initié. Au-delà, le code expire, et un nouveau code BLIK doit alors être demandé. En général, les clients autorisent les paiements BLIK en moins de 10 secondes. ## 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 iOS de Stripe](https://github.com/stripe/stripe-ios) est disponible en open source et [fait l’objet d’une documentation complète](https://stripe.dev/stripe-ios/index.html). Il est également compatible avec les applications prenant en charge iOS 13 et les versions ultérieures. #### Swift Package Manager Pour installer le SDK, veuillez suivre les étapes ci-dessous : 1. Dans Xcode, sélectionnez **File** > **Add Package Dependencies…** puis saisissez `https://github.com/stripe/stripe-ios-spm` en tant qu’URL du référentiel. 1. Sélectionnez le dernier numéro de version, visible sur notre [page des versions](https://github.com/stripe/stripe-ios/releases). 1. Ajoutez le produit **StripePaymentsUI** à la [cible de votre application](https://developer.apple.com/documentation/swift_packages/adding_package_dependencies_to_your_app). #### CocoaPods 1. Si vous ne l’avez pas encore fait, installez la version la plus récente de [CocoaPods](https://guides.cocoapods.org/using/getting-started.html). 1. Si vous n’avez pas de fichier [Podfile](https://guides.cocoapods.org/syntax/podfile.html), exécutez la commande suivante pour en créer un : ```bash pod init ``` 1. Ajoutez cette ligne à votre `Podfile` : ```podfile pod 'StripePaymentsUI' ``` 1. Exécutez la commande suivante : ```bash pod install ``` 1. À partir de maintenant, n’oubliez pas d’utiliser le fichier .xcworkspace au lieu du fichier .xcodeproj pour ouvrir votre projet dans Xcode. 1. Pour mettre à jour ultérieurement le SDK vers la version la plus récente, il vous suffit d’exécuter : ```bash pod update StripePaymentsUI ``` #### Carthage 1. Si vous ne l’avez pas encore fait, installez la version la plus récente de [Carthage](https://github.com/Carthage/Carthage#installing-carthage). 1. Ajoutez cette ligne à votre `Cartfile` : ```cartfile github "stripe/stripe-ios" ``` 1. Suivez les [instructions d’installation de Carthage](https://github.com/Carthage/Carthage#if-youre-building-for-ios-tvos-or-watchos). Veillez à intégrer tous les cadres requis listés [ici](https://github.com/stripe/stripe-ios/tree/master/StripePaymentsUI/README.md#manual-linking). 1. Pour mettre à jour ultérieurement le SDK vers la version la plus récente, exécutez la commande suivante : ```bash carthage update stripe-ios --platform ios ``` #### Cadre manuel 1. Accédez à notre [page des versions GitHub](https://github.com/stripe/stripe-ios/releases/latest), puis téléchargez et décompressez **Stripe.xcframework.zip**. 1. Faites glisser **StripePaymentsUI.xcframework** vers la section **Embedded Binaries (Fichiers binaires incorporés)** des paramètres **General (Général)** de votre projet Xcode. Veillez à sélectionner **Copy items if needed (Copier les éléments si nécessaire)**. 1. Répétez l’étape 2 pour tous les cadres requis listés [ici](https://github.com/stripe/stripe-ios/tree/master/StripePaymentsUI/README.md#manual-linking). 1. À l’avenir, pour mettre à jour vers la version la plus récente de notre SDK, répétez les étapes 1 à 3. > 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-ios/releases) sur GitHub. Pour recevoir une notification lors de la publication d’une nouvelle version, [surveillez les versions](https://help.github.com/en/articles/watching-and-unwatching-releases-for-a-repository#watching-releases-for-a-repository) à partir du référentiel. Configurez le SDK avec votre [clé publiable](https://dashboard.stripe.com/test/apikeys) Stripe au démarrage de votre application. Cela lui permet d’envoyer des requêtes à l’API Stripe. #### Swift ```swift import UIKitimportStripePaymentsUI @main class AppDelegate: UIResponder, UIApplicationDelegate { func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {StripeAPI.defaultPublishableKey = "<>" // do any other necessary launch configuration return true } } ``` > Utilisez vos [clés de test](https://docs.stripe.com/keys.md#obtain-api-keys) lors de vos activités de test et de développement et vos clés du [mode production](https://docs.stripe.com/keys.md#test-live-modes) pour la publication de votre application. ## Créer un PaymentIntent [Server-side,Client-side] A [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) is an object that represents your intent to collect payment from a customer and tracks the lifecycle of the payment process through each stage. ### Server-side First, create a `PaymentIntent` on your server and specify the amount to collect and the `pln` currency (BLIK doesn’t support other currencies). Add `blik` to the list of [payment method types](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) for your `PaymentIntent`. ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=pln \ -d "payment_method_types[]=blik" \ --data-urlencode "description=A description of what you're selling" \ -d statement_descriptor=ORDER_123 ``` ### Client-side On the client, request a PaymentIntent from your server and store its client secret. #### Swift ```swift class CheckoutViewController: UIViewController { var paymentIntentClientSecret: String? func startCheckout() { // Request a PaymentIntent from your server and store its client secret } } ``` ## Collect payment method details [Client-side] In your app, collect the required 6-digit BLIK code from the customer. Create a [STPConfirmBLIKOptions](https://stripe.dev/stripe-ios/stripe-payments/Classes/STPConfirmBLIKOptions.html) with the BLIK code. #### Swift ```swift let blikOptions = STPConfirmBLIKOptions(code: "777123") ``` ## Submit the payment to Stripe [Client-side] Retrieve the client secret from the PaymentIntent you created in step 2 and the 6-digit BLIK code you collected in step 3 to call [STPPaymentHandler confirmPayment](https://stripe.dev/stripe-ios/stripe-payments/Classes/STPPaymentHandler.html#/c:@M@StripePayments@objc\(cs\)STPPaymentHandler\(im\)confirmPayment:withAuthenticationContext:completion:). #### Swift ```swift ​​let paymentIntentParams = STPPaymentIntentParams(clientSecret: paymentIntentClientSecret) ​​paymentIntentParams.paymentMethodParams = STPPaymentMethodParams( ​​ blik: STPPaymentMethodBLIKParams(), billingDetails: nil, ​​ metadata: nil ​​) let confirmPaymentMethodOptions = STPConfirmPaymentMethodOptions() confirmPaymentMethodOptions.blikOptions = blikOptions paymentIntentParams.paymentMethodOptions = confirmPaymentMethodOptions STPPaymentHandler.shared().confirmPayment(paymentIntentParams, with: self) { (handlerStatus, paymentIntent, error) in switch handlerStatus { case .succeeded: // Show a timer or a dialog to your customer to prompt them to authorize the payment. // Poll your server or Stripe API for the PaymentIntent status update case .canceled: // Payment was canceled case .failed: // Payment failed @unknown default: fatalError() } } ``` After confirmation with valid parameters, the status of the PaymentIntent becomes `requires_action` and calls the completion block with succeeded handlerStatus. The `next_action` has the `blik_authorize` type: this means that the next step is completed by your customer, who has 60 seconds to confirm the payment inside their mobile banking app. We recommend: - Showing a timer or dialog to your customer to prompt them to authorize the payment - Polling your server or Stripe API for the PaymentIntent status update - Displaying the payment confirmation to your customer as soon as the PaymentIntent status updates to `succeeded` ## Optional: Handle post-payment events Stripe envoie un événement [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded) à l’issue du paiement. Utilisez le Dashboard, un *webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) personnalisé ou une solution partenaire pour recevoir ces événements et exécuter des actions, comme envoyer une confirmation de commande par e-mail à votre client, enregistrer la vente dans une base de données ou lancer un workflow de livraison. Plutôt que d’attendre un rappel de votre client, écoutez ces événements. En effet, côté client, l’acheteur pourrait fermer la fenêtre de son navigateur ou quitter l’application avant l’exécution du rappel. Des personnes malveillantes peuvent en profiter pour manipuler la réponse. Si vous configurez votre intégration de manière à écouter les événements asynchrones, cela vous permettra également d’accepter de nouveaux moyens de paiement plus facilement à l’avenir. Apprenez-en davantage sur les [différences entre les différents moyens de paiement pris en charge](https://stripe.com/payments/payment-methods-guide). - **Gérer les événements manuellement dans le Dashboard** Utilisez le Dashboard pour [afficher vos paiements de test dans le Dashboard](https://dashboard.stripe.com/test/payments), envoyer des reçus par e-mail, gérer les virements ou réessayer les paiements échoués. - **Créer un webhook personnalisé** [Build a custom webhook](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook) handler to listen for events and build custom asynchronous payment flows. Test and debug your webhook integration locally with the Stripe CLI. - **Intégrer une application prédéfinie** Gérez les événements commerciaux courants, tels que l’[automatisation](https://stripe.partners/?f_category=automation) ou le [marketing et les ventes](https://stripe.partners/?f_category=marketing-and-sales), en intégrant une application partenaire. ## Optional: Simulate failures in a sandbox Les paiements BLIK peuvent échouer pour diverses raisons. Les échecs peuvent être liés à des erreurs immédiates (par exemple, le code a expiré ou n’est pas valide), à des erreurs différées (par exemple, refus de la banque) ou à une expiration (par exemple, le client ne répond pas dans les temps). Vous pouvez simuler chacun de ces échecs en transmettant des valeurs `email` de différents types (documentées ci-dessous) lors de la création du `PaymentIntent`, dans les [informations de facturation](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_data-billing_details), avec n’importe quel code BLIK à 6 chiffres. ### Échecs immédiats | Code d’échec | Explication | Type de l’adresse e-mail | | ---------------------------------- | ------------------------------------------------------------------------------------------------------------------- | ------------------------ | | `payment_method_invalid_parameter` | Le code transmis n’était pas un code BLIK valide. | `.*invalid_code@.*` | | `payment_method_invalid_parameter` | Le code transmis a expiré. Les codes BLIK expirent après 2 minutes. Veuillez demander au client un autre code. | `.*expired_code@.*` | ### Refus (retard de 8 s) | Code d’échec | Explication | Type de l’adresse e-mail | | --------------------------------- | ----------------------------------------------------------------------------------------- | ------------------------- | | `payment_method_provider_decline` | Le paiement a été refusé, car la limite de paiement de ce compte bancaire a été atteinte. | `.*limit_exceeded@.*` | | `payment_method_provider_decline` | Le compte bancaire n’est pas suffisamment approvisionné pour finaliser l’achat. | `.*insufficient_funds@.*` | | `payment_method_provider_decline` | Le client a refusé ce paiement. | `.*customer_declined@.*` | | `payment_method_provider_decline` | La banque du client a refusé le paiement pour un motif inconnu. | `.*bank_declined@.*` | | `payment_method_provider_decline` | Le paiement a été refusé pour un motif inconnu. | `.*blik_declined@.*` | ### Expiration (délai de 60 secondes) | Code d’échec | Explication | Type de l’adresse e-mail | | --------------------------------- | --------------------------------------------------------------------------------- | ------------------------ | | `payment_method_provider_timeout` | Le client n’a pas approuvé ce paiement dans le délai imparti de 60 secondes. | `.*customer_timeout@.*` | | `payment_method_provider_timeout` | La requête envoyée à la banque du client a expiré. | `.*bank_timeout@.*` | | `payment_method_provider_timeout` | La requête envoyée au réseau BLIK a expiré. | `.*blik_timeout@.*` | # 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/blik/accept-a-payment?payment-ui=mobile&platform=android. BLIK est un moyen de paiement [à usage unique](https://docs.stripe.com/payments/payment-methods.md#usage) qui oblige les clients à [authentifier](https://docs.stripe.com/payments/payment-methods.md#customer-actions) leurs paiements. Lorsque les clients souhaitent payer en ligne avec BLIK, ils demandent un code à six chiffres à leur application bancaire et le saisissent dans le formulaire d’encaissement du paiement. La banque adresse une notification push à votre client sur son téléphone portable, l’invitant à autoriser le paiement dans son application bancaire. Le code BLIK est valable 2 minutes, votre client a 60 secondes pour autoriser le paiement après l’avoir initié. Au-delà, le code expire, et un nouveau code BLIK doit alors être demandé. En général, les clients autorisent les paiements BLIK en moins de 10 secondes. ## 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. ## Create a PaymentIntent [Server-side,Client-side] A [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) is an object that represents your intent to collect payment from a customer and tracks the lifecycle of the payment process through each stage. ### Server-side First, create a `PaymentIntent` on your server and specify the amount to collect and the `pln` currency (BLIK doesn’t support other currencies). Add `blik` to the list of [payment method types](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) for your `PaymentIntent`. ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=pln \ -d "payment_method_types[]=blik" \ --data-urlencode "description=A description of what you're selling" \ -d statement_descriptor=ORDER_123 ``` ### Client-side On the client, request a PaymentIntent from your server and store its client secret. #### Kotlin ```kotlin class BlikPaymentActivity: AppCompatActivity() { private lateinit var paymentIntentClientSecret: String override fun onCreate(savedInstanceState: Bundle?) { // ... startCheckout() } private fun startCheckout() { // Request a PaymentIntent from your server and store its client secret } } ``` ## Collect payment method details [Client-side] In your app, collect the required 6-digit BLIK code from the customer. Create a `PaymentMethodOptionsParams` with the BLIK code. #### Kotlin ```kotlin val paymentMethodOptionsParams = PaymentMethodOptionsParams.Blik(code = "777123"), ``` ## Submit the payment to Stripe [Client-side] Retrieve the client secret from the PaymentIntent you created in step 2 and the 6-digit BLIK code you collected in step 3 and call [PaymentLauncher confirm](https://stripe.dev/stripe-android/payments-core/com.stripe.android.payments.paymentlauncher/-payment-launcher/index.html#74063765%2FFunctions%2F-1622557690). #### Kotlin ```kotlin class BlikPaymentActivity : AppCompatActivity() { // ... private lateinit var paymentIntentClientSecret: String private val paymentLauncher: PaymentLauncher by lazy { PaymentLauncher.Companion.create( this, PaymentConfiguration.getInstance(applicationContext).publishableKey, PaymentConfiguration.getInstance(applicationContext).stripeAccountId, ::onPaymentResult ) } private fun startCheckout() { // ... val confirmParams = ConfirmPaymentIntentParams .createWithPaymentMethodCreateParams( paymentMethodCreateParams = PaymentMethodCreateParams.createBlik(), clientSecret = paymentIntentClientSecret, paymentMethodOptions = paymentMethodOptionsParams ) paymentLauncher.confirm(confirmParams) } private fun onPaymentResult(paymentResult: PaymentResult) { val message = when (paymentResult) { is PaymentResult.Completed -> { // Show a timer or a dialog to your customer to prompt them to authorize the payment. // Poll your server or Stripe API for the PaymentIntent status update } is PaymentResult.Canceled -> { "Canceled!" } is PaymentResult.Failed -> { // This string comes from the PaymentIntent's error message. // See here: https://stripe.com/docs/api/payment_intents/object#payment_intent_object-last_payment_error-message "Failed: " + paymentResult.throwable.message } } } } ``` After confirmation with valid parameters, the status of the PaymentIntent becomes `requires_action` and `onPaymentResult` is called with `PaymentResult.Completed`. The `next_action` has the `blik_authorize` type: this means that the next step is completed by your customer, who has 60 seconds to confirm the payment inside their mobile banking app. We recommend: - Showing a timer or dialog to your customer to prompt them to authorize the payment - Polling your server or Stripe API for the PaymentIntent status update - Displaying the payment confirmation to your customer as soon as the PaymentIntent status updates to `succeeded` ## Optional: Handle post-payment events Stripe envoie un événement [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded) à l’issue du paiement. Utilisez le Dashboard, un *webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) personnalisé ou une solution partenaire pour recevoir ces événements et exécuter des actions, comme envoyer une confirmation de commande par e-mail à votre client, enregistrer la vente dans une base de données ou lancer un workflow de livraison. Plutôt que d’attendre un rappel de votre client, écoutez ces événements. En effet, côté client, l’acheteur pourrait fermer la fenêtre de son navigateur ou quitter l’application avant l’exécution du rappel. Des personnes malveillantes peuvent en profiter pour manipuler la réponse. Si vous configurez votre intégration de manière à écouter les événements asynchrones, cela vous permettra également d’accepter de nouveaux moyens de paiement plus facilement à l’avenir. Apprenez-en davantage sur les [différences entre les différents moyens de paiement pris en charge](https://stripe.com/payments/payment-methods-guide). - **Gérer les événements manuellement dans le Dashboard** Utilisez le Dashboard pour [afficher vos paiements de test dans le Dashboard](https://dashboard.stripe.com/test/payments), envoyer des reçus par e-mail, gérer les virements ou réessayer les paiements échoués. - **Créer un webhook personnalisé** [Build a custom webhook](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook) handler to listen for events and build custom asynchronous payment flows. Test and debug your webhook integration locally with the Stripe CLI. - **Intégrer une application prédéfinie** Gérez les événements commerciaux courants, tels que l’[automatisation](https://stripe.partners/?f_category=automation) ou le [marketing et les ventes](https://stripe.partners/?f_category=marketing-and-sales), en intégrant une application partenaire. ## Optional: Simulate failures in a sandbox Les paiements BLIK peuvent échouer pour diverses raisons. Les échecs peuvent être liés à des erreurs immédiates (par exemple, le code a expiré ou n’est pas valide), à des erreurs différées (par exemple, refus de la banque) ou à une expiration (par exemple, le client ne répond pas dans les temps). Vous pouvez simuler chacun de ces échecs en transmettant des valeurs `email` de différents types (documentées ci-dessous) lors de la création du `PaymentIntent`, dans les [informations de facturation](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_data-billing_details), avec n’importe quel code BLIK à 6 chiffres. ### Échecs immédiats | Code d’échec | Explication | Type de l’adresse e-mail | | ---------------------------------- | ------------------------------------------------------------------------------------------------------------------- | ------------------------ | | `payment_method_invalid_parameter` | Le code transmis n’était pas un code BLIK valide. | `.*invalid_code@.*` | | `payment_method_invalid_parameter` | Le code transmis a expiré. Les codes BLIK expirent après 2 minutes. Veuillez demander au client un autre code. | `.*expired_code@.*` | ### Refus (retard de 8 s) | Code d’échec | Explication | Type de l’adresse e-mail | | --------------------------------- | ----------------------------------------------------------------------------------------- | ------------------------- | | `payment_method_provider_decline` | Le paiement a été refusé, car la limite de paiement de ce compte bancaire a été atteinte. | `.*limit_exceeded@.*` | | `payment_method_provider_decline` | Le compte bancaire n’est pas suffisamment approvisionné pour finaliser l’achat. | `.*insufficient_funds@.*` | | `payment_method_provider_decline` | Le client a refusé ce paiement. | `.*customer_declined@.*` | | `payment_method_provider_decline` | La banque du client a refusé le paiement pour un motif inconnu. | `.*bank_declined@.*` | | `payment_method_provider_decline` | Le paiement a été refusé pour un motif inconnu. | `.*blik_declined@.*` | ### Expiration (délai de 60 secondes) | Code d’échec | Explication | Type de l’adresse e-mail | | --------------------------------- | --------------------------------------------------------------------------------- | ------------------------ | | `payment_method_provider_timeout` | Le client n’a pas approuvé ce paiement dans le délai imparti de 60 secondes. | `.*customer_timeout@.*` | | `payment_method_provider_timeout` | La requête envoyée à la banque du client a expiré. | `.*bank_timeout@.*` | | `payment_method_provider_timeout` | La requête envoyée au réseau BLIK a expiré. | `.*blik_timeout@.*` |