# Pagos con BLIK Descubre cómo aceptar pagos con BLIK, un método de pago popular en Polonia. # Checkout > Stripe puede presentar automáticamente los métodos de pago pertinentes a tus clientes evaluando la moneda, las restricciones de los métodos de pago y otros parámetros. > > - Sigue la guía [Aceptar un pago](https://docs.stripe.com/payments/accept-a-payment.md?payment-ui=checkout&ui=stripe-hosted) para crear una integración de Checkout que utilice [métodos de pago dinámicos](https://docs.stripe.com/payments/payment-methods/dynamic-payment-methods.md). - Si no quieres utilizar métodos de pago dinámicos, sigue los pasos que se indican a continuación para configurar manualmente los métodos de pago en tu integración de Checkout. BLIK es un método de pago de [un solo uso](https://docs.stripe.com/payments/payment-methods.md#usage) que requiere que los clientes [autentiquen](https://docs.stripe.com/payments/payment-methods.md#customer-actions) sus pagos. Cuando los clientes quieren pagar por Internet con BLIK, solicitan un código de seis dígitos de su aplicación bancaria y lo introducen en el formulario de cobro del pago. El banco envía una notificación al móvil de tu cliente para autorizar el pago dentro de la aplicación bancaria. El código de BLIK es válido durante 2 minutos; los clientes tienen 60 segundos para autorizar el pago tras iniciarlo. Tras 60 segundos, se acaba el tiempo y deben solicitar un nuevo código de BLIK. Por lo general, los clientes aprueban los pagos de BLIK en menos de 10 segundos. ## Determina la compatibilidad **Ubicaciones de empresas aceptadas**: 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 **Divisas aceptadas**: `pln` **Divisas de pago**: `pln` **Modo de pago**: Yes **Modo de configuración**: Not yet **Modo de suscripción**: Not yet La sesión de Checkout debe cumplir con todas estas condiciones para aceptar pagos con BLIK: - Los *precios* (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 todas las partidas de la factura deben estar en Złoty (código de divisa `pln`). ## Aceptar un pago > Esta guía se basa en la integración fundamental de [aceptar un pago](https://docs.stripe.com/payments/accept-a-payment.md?ui=stripe-hosted) en Checkout. Esta guía te explica cómo habilitar BLIK y muestra las diferencias entre aceptar pagos mediante métodos de pago dinámicos y configurar manualmente los métodos de pago. ### Habilita BLIK como método de pago Al crear una nueva [Checkout Session](https://docs.stripe.com/api/checkout/sessions.md), debes: 1. Añade `blik` a la lista de `payment_method_types`. 1. Asegúrate de que todas tus `line_items` usen la divisa `pln`. #### Página alojada en 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" ``` #### Página completa integrada ```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 ``` #### Elements ```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 ``` ### Lo que ven los clientes Dentro de la aplicación bancaria, los clientes ven cuatro líneas relativas a cada transacción con BLIK: - Si ha proporcionado un valor para [payment_intent_data.description](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-payment_intent_data-description), las dos primeras líneas lo mostrarán (máximo 70 caracteres). - Si has proporcionado un valor para [payment_intent_data.statement_descriptor](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-payment_intent_data-statement_descriptor) (normalmente, un ID de pedido), se muestra en la línea 3 (máximo 22 caracteres). - La cuarta línea se completa automáticamente con la URL de tu sitio web. ### Completa tus pedidos Después de aceptar un pago, descubre cómo [completar los pedidos](https://docs.stripe.com/checkout/fulfillment.md). ## Prueba tu integración Al probar tu integración de Checkout, selecciona BLIK como método de pago y haz clic en el botón **Pagar**. Usa un *entorno de prueba* (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) para probar un pago satisfactorio introduciendo cualquier código de seis dígitos (como `123456`) en el formulario de pago. ## Gestiona los reembolsos y las disputas El período de reembolso de BLIK es de hasta 13 meses después del pago original. Los clientes pueden disputar un pago a través de su banco hasta 13 meses después del pago original y no existe proceso de apelación. Obtén más información sobre las [disputas de BLIK](https://docs.stripe.com/payments/blik.md#disputed-payments). ## Optional: Simula fallos en un entorno de prueba Los pagos de BLIK pueden dar error por diferentes motivos. Hay errores inmediatos (por ejemplo, el código ha vencido o no es válido), errores retrasados (el banco lo rechaza) o tiempo de espera agotado (el cliente no ha respondido a tiempo). Puedes simular cada escenario de error especificando los valores de `email` que coincidan con ciertos patrones (documentados a continuación) al crear el `PaymentIntent`, como parte de los [datos de facturación](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_data-billing_details), con cualquier código BLIK de 6 dígitos. Puedes introducir el `email` en la sección de información de contacto de la página de Checkout. ### Errores inmediatos | Código de error | Explicación | Patrón de correo electrónico | | ---------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | | `payment_method_invalid_parameter` | El código que se ha transmitido no era un código de BLIK válido. | `.*invalid_code@.*` | | `payment_method_invalid_parameter` | El código que se ha transmitido ha caducado. Los códigos de BLIK caducan cuando transcurren 2 minutos, debes solicitar otro código al cliente. | `.*expired_code@.*` | ### Rechazos (retraso de 8 segundos) | Código de error | Explicación | Patrón de correo electrónico | | --------------------------------- | ----------------------------------------------------------------------------------------- | ---------------------------- | | `payment_method_provider_decline` | El pago se ha rechazado porque se ha alcanzado el límite de pago en esta cuenta bancaria. | `.*limit_exceeded@.*` | | `payment_method_provider_decline` | La cuenta bancaria no tiene fondos suficientes para realizar la compra. | `.*insufficient_funds@.*` | | `payment_method_provider_decline` | El cliente ha rechazado este pago. | `.*customer_declined@.*` | | `payment_method_provider_decline` | El pago fue rechazado por el banco del cliente por un motivo desconocido. | `.*bank_declined@.*` | | `payment_method_provider_decline` | El pago ha sido rechazado por un motivo desconocido. | `.*blik_declined@.*` | ### Tiempos de espera (retraso de 60 segundos) | Código de error | Explicación | Patrón de correo electrónico | | --------------------------------- | ---------------------------------------------------------------------- | ---------------------------- | | `payment_method_provider_timeout` | El cliente no ha aprobado este pago dentro del plazo de 60 segundos. | `.*customer_timeout@.*` | | `payment_method_provider_timeout` | Se ha agotado el tiempo de espera de la petición al banco del cliente. | `.*bank_timeout@.*` | | `payment_method_provider_timeout` | Se ha agotado el tiempo de espera de la petición a la red BLIK. | `.*blik_timeout@.*` | ## See also - [Más información sobre BLIK](https://docs.stripe.com/payments/blik.md) - [Cumplimiento de Checkout](https://docs.stripe.com/checkout/fulfillment.md) - [Personaliza Checkout](https://docs.stripe.com/payments/checkout/customization.md) # API Direct > Te recomendamos que sigas la guía [Aceptar un pago](https://docs.stripe.com/payments/accept-a-payment.md) a menos que necesites usar la confirmación manual del lado del servidor o que tu integración requiera que presentes los métodos de pago de forma separada. Si ya has hecho la integración con Elements, consulta la [guía de migración de Payment Elements](https://docs.stripe.com/payments/payment-element/migration.md). BLIK es un método de pago de [un solo uso](https://docs.stripe.com/payments/payment-methods.md#usage) que requiere que los clientes [autentiquen](https://docs.stripe.com/payments/payment-methods.md#customer-actions) sus pagos. Cuando los clientes quieren pagar por Internet con BLIK, solicitan un código de seis dígitos de su aplicación bancaria y lo introducen en el formulario de cobro del pago. El banco envía una notificación al móvil de tu cliente para autorizar el pago dentro de la aplicación bancaria. El código de BLIK es válido durante 2 minutos; los clientes tienen 60 segundos para autorizar el pago tras iniciarlo. Tras 60 segundos, se acaba el tiempo y deben solicitar un nuevo código de BLIK. Por lo general, los clientes aprueban los pagos de BLIK en menos de 10 segundos. ## Configura Stripe [Lado del servidor] Primero, necesitas una cuenta de Stripe. [Regístrate ahora](https://dashboard.stripe.com/register). Usa nuestras bibliotecas oficiales para acceder a la API de Stripe desde tu aplicación: #### 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' ``` ## Crea un PaymentIntent [Lado del servidor] Un [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) es un objeto que representa tu intención de cobrarle un pago a un cliente y hace el seguimiento del ciclo de vida del proceso de pago en cada etapa. Primero, crea un `PaymentIntent` en tu servidor y especifica el importe por cobrar y la divisa `pln`, porque BLIK solo acepta `pln`. Si ya tienes una integración que usa la [API Payment Intents](https://docs.stripe.com/payments/payment-intents.md), añade `blik` a la lista de [tipos de métodos de pago](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) para tu `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 ``` ### Recupera el secreto del cliente El PaymentIntent incluye un *secreto de cliente* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)) que el lado del cliente utiliza para completar el proceso de pago de forma segura. Puedes usar diferentes métodos para pasar el secreto del cliente al lado del cliente. #### Aplicación de una sola página Recupera el secreto de cliente de un punto de conexión en tu servidor, utilizando la función `fetch` del navegador. Este enfoque es mejor si tu lado del cliente es una aplicación de una sola página, en particular una construida con un marco de front-end moderno como React. Crea el punto de conexión del servidor que se utiliza para el secreto de cliente: #### Ruby ```ruby get '/secret' do intent = # ... Create or retrieve the PaymentIntent {client_secret: intent.client_secret}.to_json end ``` Y luego busca el secreto del cliente con JavaScript del lado del cliente: ```javascript (async () => { const response = await fetch('/secret'); const {client_secret: clientSecret} = await response.json(); // Render the form using the clientSecret })(); ``` #### Renderización del lado del servidor Envía el secreto del cliente al cliente desde tu servidor. Este enfoque funciona mejor si tu aplicación genera contenido estático en el servidor antes de enviarlo al navegador. Añade el [client_secret](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) en tu formulario de proceso de compra. En el código del lado del servidor, recupera el secreto de cliente de PaymentIntent: #### Ruby ```erb
``` ```ruby get '/checkout' do @intent = # ... Fetch or create the PaymentIntent erb :checkout end ``` ## Recopila los datos del método de pago [Lado del cliente] Para enviarle el pago a Stripe, debes confirmar el PaymentIntent con el código BLIK de 6 dígitos de tu cliente. Puedes obtener este código creando un formulario para tu cliente en el que recopiles el código necesario. #### HTML + JS ```html
``` #### React #### npm Instala [React Stripe.js](https://www.npmjs.com/package/@stripe/react-stripe-js) y el [cargador de Stripe.js](https://www.npmjs.com/package/@stripe/stripe-js) desde el registro público npm. ```bash npm install --save @stripe/react-stripe-js @stripe/stripe-js ``` #### umd También proporcionamos una versión de UMD para sitios que no usan npm ni módulos. Incluye la secuencia de comandos de Stripe.js, que exporta la función global `Stripe`, y la versión de UMD de Stripe.js para React, que exporta el objeto global `ReactStripe`. Carga siempre la secuencia de comandos de Stripe.js directamente desde **js.stripe.com** para cumplir con la normativa PCI. No la incluyas en un paquete ni alojes una copia en tus sistemas. ```html ``` > La [demo en CodeSandbox](https://codesandbox.io/s/react-stripe-official-q1loc?fontsize=14&hidenavigation=1&theme=dark) te permite probar Stripe.js para React sin necesidad de crear un nuevo proyecto. ### Añade Stripe.js y Elements a tu página Para integrar Stripe.js y (de manera opcional) utilizar componentes Elements para otros métodos de pago, ajusta la raíz de tu aplicación React en un [proveedor Elements](https://docs.stripe.com/sdks/stripejs-react.md#elements-provider). Devuelve la llamada a `loadStripe` con tu clave publicable y transmite la `Promise` devuelta al proveedor `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')); ``` ### Crea una forma de aceptar pagos Si tienes previsto utilizar el hook [useStripe](https://docs.stripe.com/sdks/stripejs-react.md#usestripe-hook) para acceder a las funciones de Stripe.js, puedes crear un componente normal de React. Si prefieres componentes de clase tradicionales en lugar de hooks, puedes utilizar [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 (
); } ``` #### Componentes de clase ```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}) => ( )} ); } ``` ## Envía el pago a Stripe [Lado del cliente] Utiliza el objeto PaymentIntent del [paso 2](https://docs.stripe.com/payments/blik/accept-a-payment.md#web-create-payment-intent) y el código BLIK de 6 dígitos que recopilaste en el [paso 3](https://docs.stripe.com/payments/blik/accept-a-payment.md#web-collect-payment-method-details) para *confirmar* (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) el PaymentIntent; esto declara que el cliente tiene la intención de pagar con el *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) especificado. Una vez que se confirma el PaymentIntent, se inicia un pago. En lugar de enviar todo el objeto PaymentIntent al cliente, usa su [secreto de cliente](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret). Este secreto de cliente es diferente de las claves de API que autentican las peticiones a la API de Stripe. Gestiona el secreto de cliente con cuidado porque puede completar el cargo. No lo registres, no lo insertes en direcciones URL ni lo expongas a nadie excepto al cliente. Asimismo, como el código BLIK de seis dígitos solo es válido durante 2 minutos, solo puedes aprobarlo en las opciones del método de pago al confirmar el PaymentIntent. En un *entorno de prueba* (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), vale cualquier código de seis dígitos. #### HTML + JS Cuando un cliente haga clic para pagar con Blik, usa Stripe.js para enviar el pago a Stripe. [Stripe.js](https://docs.stripe.com/payments/elements.md) es nuestra biblioteca JavaScript principal para crear flujos de pago. Gestiona automáticamente las complejidades como los redireccionamientos descritos anteriormente, y te permite extender tu integración a otros métodos de pago. Incluye la secuencia de comandos de Stripe.js en tu página de finalización de compra al añadirlo al encabezado `head` de tu archivo HTML. ```html Checkout ``` Crea una instancia de Stripe.js con el siguiente JavaScript en tu página de finalización de compra. ```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('<>'); ``` Usa [stripe.confirmBlikPayment](https://docs.stripe.com/js/payment_intents/confirm_blik_payment) para confirmar el pago. `confirmBlikPayment` no lo devuelve hasta que se complete o falle la confirmación. Si deseas implementar tu propia lógica para actualizar el estado del pago, puedes deshabilitar el sondeo de Stripe.js de la API estableciendo el parámetro `handleActions` en `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 Cuando un cliente haga clic para pagar con Blik, usa Stripe.js para enviar el pago a Stripe. [Stripe.js](https://docs.stripe.com/payments/elements.md) es nuestra biblioteca JavaScript principal para crear flujos de pago. Gestiona automáticamente las complejidades como los redireccionamientos descritos anteriormente, y te permite extender tu integración a otros métodos de pago. Incluye la secuencia de comandos de Stripe.js en tu página de finalización de compra al añadirlo al encabezado `head` de tu archivo HTML. ```html Checkout ``` Crea una instancia de Stripe.js con el siguiente JavaScript en tu página de finalización de compra. ```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('<>'); ``` Usa [stripe.confirmBlikPayment](https://docs.stripe.com/js/payment_intents/confirm_blik_payment) para confirmar el pago. `confirmBlikPayment` no lo devuelve hasta que se complete o falle la confirmación. Puedes deshabilitar el sondeo de la API estableciendo el parámetro `handleActions` en `false`. #### Hooks Para llamar a `stripe.confirmBlikPayment` desde el componente de tu formulario de pago, utiliza el 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 (
); } ``` #### Componentes de clase ```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}) => ( )} ); } ``` Tras confirmar el PaymentIntent con los parámetros válidos, el `status` del PaymentIntent pasa a `requires_action`. El `next_action` tiene el tipo `blik_authorize`: esto significa que el siguiente paso lo completa tu cliente, que cuenta con 60 segundos para confirmar el pago en su aplicación bancaria del móvil. Te recomendamos que le muestres a tu cliente un temporizador o un cuadro de diálogo para indicarle que debe autorizar el pago en el plazo indicado. ### Lo que ven los clientes Dentro de la aplicación bancaria, los clientes ven cuatro líneas relativas a cada transacción con BLIK: - Si has proporcionado un valor para `description` al crear el PaymentIntent, se muestra en las primeras dos líneas (máx. 70 caracteres). - Si has proporcionado un valor para `statement_descriptor` (normalmente, un ID de pedido), se muestra en la línea 3 (máx. 22 caracteres). - La cuarta línea se completa automáticamente con la URL de tu sitio web. ## Completar el pedido [Lado del servidor] [Usa un método como los webhooks](https://docs.stripe.com/payments/payment-intents/verifying-status.md#webhooks) para gestionar la *ejecución* (Fulfillment is the process of providing the goods or services purchased by a customer, typically after payment is collected) del pedido. Cuando un cliente efectiviza el pago, el estado del `PaymentIntent` pasa a `succeeded` y envía el evento [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded) del *webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests). Si un cliente no paga, el `PaymentIntent` envía el evento de webhook [payment_intent.payment_failed](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.payment_failed) y vuelve al estado de `requires_payment_method`. ## Optional: Simula fallos en un entorno de prueba Los pagos de BLIK pueden dar error por diferentes motivos. Hay errores inmediatos (por ejemplo, el código ha vencido o no es válido), errores retrasados (el banco lo rechaza) o tiempo de espera agotado (el cliente no ha respondido a tiempo). Puedes simular cada escenario de error especificando los valores de `email` que coincidan con ciertos patrones (documentados a continuación) al crear el `PaymentIntent`, como parte de los [datos de facturación](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_data-billing_details), con cualquier código BLIK de 6 dígitos. Al confirmar el lado del servidor `PaymentIntent`, una solicitud que simula un código BLIK no válido se vería así: #### 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" ``` ### Errores inmediatos | Código de error | Explicación | Patrón de correo electrónico | | ---------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | | `payment_method_invalid_parameter` | El código que se ha transmitido no era un código de BLIK válido. | `.*invalid_code@.*` | | `payment_method_invalid_parameter` | El código que se ha transmitido ha caducado. Los códigos de BLIK caducan cuando transcurren 2 minutos, debes solicitar otro código al cliente. | `.*expired_code@.*` | ### Rechazos (retraso de 8 segundos) | Código de error | Explicación | Patrón de correo electrónico | | --------------------------------- | ----------------------------------------------------------------------------------------- | ---------------------------- | | `payment_method_provider_decline` | El pago se ha rechazado porque se ha alcanzado el límite de pago en esta cuenta bancaria. | `.*limit_exceeded@.*` | | `payment_method_provider_decline` | La cuenta bancaria no tiene fondos suficientes para realizar la compra. | `.*insufficient_funds@.*` | | `payment_method_provider_decline` | El cliente ha rechazado este pago. | `.*customer_declined@.*` | | `payment_method_provider_decline` | El pago fue rechazado por el banco del cliente por un motivo desconocido. | `.*bank_declined@.*` | | `payment_method_provider_decline` | El pago ha sido rechazado por un motivo desconocido. | `.*blik_declined@.*` | ### Tiempos de espera (retraso de 60 segundos) | Código de error | Explicación | Patrón de correo electrónico | | --------------------------------- | ---------------------------------------------------------------------- | ---------------------------- | | `payment_method_provider_timeout` | El cliente no ha aprobado este pago dentro del plazo de 60 segundos. | `.*customer_timeout@.*` | | `payment_method_provider_timeout` | Se ha agotado el tiempo de espera de la petición al banco del cliente. | `.*bank_timeout@.*` | | `payment_method_provider_timeout` | Se ha agotado el tiempo de espera de la petición a la red BLIK. | `.*blik_timeout@.*` | # iOS BLIK es un método de pago de [un solo uso](https://docs.stripe.com/payments/payment-methods.md#usage) que requiere que los clientes [autentiquen](https://docs.stripe.com/payments/payment-methods.md#customer-actions) sus pagos. Cuando los clientes quieren pagar por Internet con BLIK, solicitan un código de seis dígitos de su aplicación bancaria y lo introducen en el formulario de cobro del pago. El banco envía una notificación al móvil de tu cliente para autorizar el pago dentro de la aplicación bancaria. El código de BLIK es válido durante 2 minutos; los clientes tienen 60 segundos para autorizar el pago tras iniciarlo. Tras 60 segundos, se acaba el tiempo y deben solicitar un nuevo código de BLIK. Por lo general, los clientes aprueban los pagos de BLIK en menos de 10 segundos. ## Configurar Stripe [Lado del servidor] [Lado del cliente] Primero, necesitas una cuenta de Stripe. [Inscríbete ahora](https://dashboard.stripe.com/register). ### Lado del servidor Esta integración necesita puntos de conexión en tu servidor que se comuniquen con la API de Stripe. Usa las bibliotecas oficiales para acceder a la API de Stripe desde tu servidor: #### 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' ``` ### Lado del cliente El [SDK para iOS de Stripe](https://github.com/stripe/stripe-ios) es de código abierto, está [plenamente documentado](https://stripe.dev/stripe-ios/index.html) y es compatible con aplicaciones que admiten iOS 13 o posterior. #### Administrador de paquetes Swift Para instalar el SDK, sigue estos pasos: 1. En Xcode, elige **Archivo** > **Añadir dependencias de paquetes…** e introduce `https://github.com/stripe/stripe-ios-spm` como la URL del repositorio. 1. Selecciona el número de versión más reciente en nuestra [página de versiones](https://github.com/stripe/stripe-ios/releases). 1. Añade el producto **StripePaymentsUI** al [objetivo de tu aplicación](https://developer.apple.com/documentation/swift_packages/adding_package_dependencies_to_your_app). #### CocoaPods 1. Si aún no lo has hecho, instala la última versión de [CocoaPods](https://guides.cocoapods.org/using/getting-started.html). 1. Si no tienes un [Podfile](https://guides.cocoapods.org/syntax/podfile.html), ejecuta el siguiente comando para crear uno: ```bash pod init ``` 1. Añade esta línea a tu `Podfile`: ```podfile pod 'StripePaymentsUI' ``` 1. Ejecuta el siguiente comando: ```bash pod install ``` 1. De ahora en adelante, no olvides usar el archivo `.xcworkspace` en lugar del archivo `.xcodeproj` para abrir tu proyecto en Xcode. 1. En el futuro, para actualizar a la última versión del SDK, ejecuta lo siguiente: ```bash pod update StripePaymentsUI ``` #### Carthage 1. Si aún no lo has hecho, instala la última versión de [Carthage](https://github.com/Carthage/Carthage#installing-carthage). 1. Añade esta línea a tu `Cartfile`: ```cartfile github "stripe/stripe-ios" ``` 1. Sigue las [instrucciones de instalación de Carthage](https://github.com/Carthage/Carthage#if-youre-building-for-ios-tvos-or-watchos). Asegúrate de incrustar todos los frameworks obligatorios enumerados [aquí](https://github.com/stripe/stripe-ios/tree/master/StripePaymentsUI/README.md#manual-linking). 1. En el futuro, para actualizar a la última versión del SDK, ejecuta el siguiente comando: ```bash carthage update stripe-ios --platform ios ``` #### Plataforma manual 1. Ve a nuestra [página de versiones de GitHub](https://github.com/stripe/stripe-ios/releases/latest) y descarga y descomprime **Stripe.xcframework.zip**. 1. Arrastra **StripePaymentsUI.xcframework** a la sección **Binarios incrustados** de la configuración **General** de tu proyecto en Xcode. Asegúrate de seleccionar **Copiar elementos si es necesario**. 1. Repite el paso 2 para todos los frameworks obligatorios enumerados [here](https://github.com/stripe/stripe-ios/tree/master/StripePaymentsUI/README.md#manual-linking). 1. En el futuro, para actualizar a la última versión de nuestro SDK, repite los pasos 1 a 3. > Para obtener más información sobre la versión más reciente y sobre versiones anteriores del SDK, consulta la página [Versiones](https://github.com/stripe/stripe-ios/releases) en GitHub. Para recibir notificaciones cuando se publica una nueva versión, [consulta las versiones](https://help.github.com/en/articles/watching-and-unwatching-releases-for-a-repository#watching-releases-for-a-repository) del repositorio. Configura el SDK con tu [clave publicable](https://dashboard.stripe.com/test/apikeys) de Stripe al iniciar la aplicación para que tu aplicación haga solicitudes a la API de 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 } } ``` > Usa las [claves de prueba](https://docs.stripe.com/keys.md#obtain-api-keys) durante las pruebas y las tareas de desarrollo, y las claves del [modo activo](https://docs.stripe.com/keys.md#test-live-modes) cuando publiques tu aplicación. ## Cree un PaymentIntent [Lado del servidor] [Lado del cliente] Un [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) es un objeto que representa tu intención de cobrarle a un cliente y hace el seguimiento del ciclo de vida del proceso de pago en cada etapa. ### Lado del servidor Primero, crea un `PaymentIntent` en tu servidor y especifica el importe que hay que cobrar y la divisa `pln` (BLIK no admite otras divisas). Añade `blik` a la lista de [tipos de métodos](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) de pago para tu `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 ``` ### Lado del cliente En el lado del cliente, solicita un PaymentIntent desde tu servidor y almacena el secreto de cliente. #### Swift ```swift class CheckoutViewController: UIViewController { var paymentIntentClientSecret: String? func startCheckout() { // Request a PaymentIntent from your server and store its client secret } } ``` ## Recopila los datos del método de pago [Lado del cliente] En la aplicación, recopila del cliente el código BLIK requerido de 6 dígitos. Crea un [STPConfirmBLIKOptions](https://stripe.dev/stripe-ios/stripe-payments/Classes/STPConfirmBLIKOptions.html) con el código BLIK. #### Swift ```swift let blikOptions = STPConfirmBLIKOptions(code: "777123") ``` ## Envía el pago a Stripe [Lado del cliente] Recupera el secreto de cliente del PaymentIntent que has creado en el paso 2 y el código BLIK de 6 dígitos que has recopilado en el paso 3 para llamar al [STPPaymentHandler](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() } } ``` Tras la confirmación con los parámetros válidos, el estado del PaymentIntent pasa a `requires_action` y llama al bloque de finalización con handlerStatus satisfactorio. El `next_action` tiene el tipo `blik_authorize`: esto significa que el siguiente paso lo completa tu cliente, que cuenta con 60 segundos para confirmar el pago en su aplicación bancaria del móvil. Te recomendamos: - Mostrar un temporizador o un diálogo al cliente para pedirle que autorice el pago - Sondear tu servidor o la API de Stripe para la actualización del estado de PaymentIntent - Mostrar la confirmación del pago al cliente en cuanto el estado del PaymentIntent se actualice a `succeeded` ## Optional: Gestionar eventos posteriores al pago Stripe envía un evento [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded) cuando se completa el pago. Utiliza el Dashboard, un *webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) personalizado o una solución de socio para recibir estos eventos y ejecutar acciones como, por ejemplo, enviar un correo electrónico para confirmar el pedido al cliente, registrar la venta en una base de datos o iniciar el flujo de tareas de envío. Escucha estos eventos en lugar de esperar una devolución de llamada del cliente. Por su parte, el cliente puede cerrar la ventana del navegador o salir de la aplicación antes de que se ejecute la devolución de llamada y los clientes malintencionados podrían manipular la respuesta. Configurar tu integración para escuchar eventos asincrónicos también te ayudará a aceptar más métodos de pago en el futuro. Obtén más información sobre las [diferencias entre todos los métodos de pago aceptados](https://stripe.com/payments/payment-methods-guide). - **Gestiona eventos manualmente en el Dashboard** Utiliza el Dashboard para [ver tus pagos de prueba en el Dashboard](https://dashboard.stripe.com/test/payments), enviar recibos por correo electrónico, gestionar pagos o reintentar pagos fallidos. - **Crea un webhook personalizado** [Crea un webhook personalizado](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook) para escuchar eventos y crear flujos de pago asíncronos personalizados. Prueba y depura tu integración de webhooks de forma local con la CLI de Stripe. - **Integra una aplicación prediseñada** Gestiona eventos empresariales comunes, como la [automatización](https://stripe.partners/?f_category=automation) o la [comercialización y ventas](https://stripe.partners/?f_category=marketing-and-sales), integrando una aplicación asociada. ## Optional: Simula fallos en un entorno de prueba Los pagos de BLIK pueden dar error por diferentes motivos. Hay errores inmediatos (por ejemplo, el código ha vencido o no es válido), errores retrasados (el banco lo rechaza) o tiempo de espera agotado (el cliente no ha respondido a tiempo). Puedes simular cada escenario de error especificando los valores de `email` que coincidan con ciertos patrones (documentados a continuación) al crear el `PaymentIntent`, como parte de los [datos de facturación](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_data-billing_details), con cualquier código BLIK de 6 dígitos. ### Errores inmediatos | Código de error | Explicación | Patrón de correo electrónico | | ---------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | | `payment_method_invalid_parameter` | El código que se ha transmitido no era un código de BLIK válido. | `.*invalid_code@.*` | | `payment_method_invalid_parameter` | El código que se ha transmitido ha caducado. Los códigos de BLIK caducan cuando transcurren 2 minutos, debes solicitar otro código al cliente. | `.*expired_code@.*` | ### Rechazos (retraso de 8 segundos) | Código de error | Explicación | Patrón de correo electrónico | | --------------------------------- | ----------------------------------------------------------------------------------------- | ---------------------------- | | `payment_method_provider_decline` | El pago se ha rechazado porque se ha alcanzado el límite de pago en esta cuenta bancaria. | `.*limit_exceeded@.*` | | `payment_method_provider_decline` | La cuenta bancaria no tiene fondos suficientes para realizar la compra. | `.*insufficient_funds@.*` | | `payment_method_provider_decline` | El cliente ha rechazado este pago. | `.*customer_declined@.*` | | `payment_method_provider_decline` | El pago fue rechazado por el banco del cliente por un motivo desconocido. | `.*bank_declined@.*` | | `payment_method_provider_decline` | El pago ha sido rechazado por un motivo desconocido. | `.*blik_declined@.*` | ### Tiempos de espera (retraso de 60 segundos) | Código de error | Explicación | Patrón de correo electrónico | | --------------------------------- | ---------------------------------------------------------------------- | ---------------------------- | | `payment_method_provider_timeout` | El cliente no ha aprobado este pago dentro del plazo de 60 segundos. | `.*customer_timeout@.*` | | `payment_method_provider_timeout` | Se ha agotado el tiempo de espera de la petición al banco del cliente. | `.*bank_timeout@.*` | | `payment_method_provider_timeout` | Se ha agotado el tiempo de espera de la petición a la red BLIK. | `.*blik_timeout@.*` | # Android BLIK es un método de pago de [un solo uso](https://docs.stripe.com/payments/payment-methods.md#usage) que requiere que los clientes [autentiquen](https://docs.stripe.com/payments/payment-methods.md#customer-actions) sus pagos. Cuando los clientes quieren pagar por Internet con BLIK, solicitan un código de seis dígitos de su aplicación bancaria y lo introducen en el formulario de cobro del pago. El banco envía una notificación al móvil de tu cliente para autorizar el pago dentro de la aplicación bancaria. El código de BLIK es válido durante 2 minutos; los clientes tienen 60 segundos para autorizar el pago tras iniciarlo. Tras 60 segundos, se acaba el tiempo y deben solicitar un nuevo código de BLIK. Por lo general, los clientes aprueban los pagos de BLIK en menos de 10 segundos. ## Configurar Stripe [Lado del servidor] [Lado del cliente] Primero, necesitas una cuenta de Stripe. [Inscríbete ahora](https://dashboard.stripe.com/register). ### Lado del servidor Esta integración necesita puntos de conexión en tu servidor que se comuniquen con la API de Stripe. Usa las bibliotecas oficiales para acceder a la API de Stripe desde tu servidor: #### 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' ``` ### Lado del cliente El [SDK para Android de Stripe](https://github.com/stripe/stripe-android) es de código abierto y está [completamente documentado](https://stripe.dev/stripe-android/). Para instalar el SDK, añade `stripe-android` al bloque `dependencies` de tu archivo [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.9.1") // Include the financial connections SDK to support US bank account as a payment method implementation("com.stripe:financial-connections:23.9.1") } ``` > Para conocer detalles de la última versión y de versiones anteriores del SDK, consulta la página [Versiones](https://github.com/stripe/stripe-android/releases) de GitHub. Para recibir una notificación cuando se publique una nueva versión, [mira las versiones del repositorio](https://docs.github.com/en/github/managing-subscriptions-and-notifications-on-github/configuring-notifications#configuring-your-watch-settings-for-an-individual-repository). Configura el SDK con tu [clave publicable](https://dashboard.stripe.com/apikeys) de Stripe para que pueda hacer solicitudes a la API de Stripe, así como en tu subclase `Application`: #### Kotlin ```kotlin import com.stripe.android.PaymentConfiguration class MyApp : Application() { override fun onCreate() { super.onCreate() PaymentConfiguration.init( applicationContext, "<>" ) } } ``` > Usa las [claves de prueba](https://docs.stripe.com/keys.md#obtain-api-keys) durante las pruebas y las tareas de desarrollo, y las claves del [modo activo](https://docs.stripe.com/keys.md#test-live-modes) cuando publiques tu aplicación. Los ejemplos de Stripe también utilizan [OkHttp](https://github.com/square/okhttp) y [GSON](https://github.com/google/gson) para hacer solicitudes HTTP a un servidor. ## Cree un PaymentIntent [Lado del servidor] [Lado del cliente] Un [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) es un objeto que representa tu intención de cobrarle a un cliente y hace el seguimiento del ciclo de vida del proceso de pago en cada etapa. ### Lado del servidor Primero, crea un `PaymentIntent` en tu servidor y especifica el importe que hay que cobrar y la divisa `pln` (BLIK no admite otras divisas). Añade `blik` a la lista de [tipos de métodos](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) de pago para tu `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 ``` ### Lado del cliente En el lado del cliente, solicita un PaymentIntent desde tu servidor y almacena el secreto de cliente. #### 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 } } ``` ## Recopila los datos del método de pago [Lado del cliente] En la aplicación, copia del cliente el código requerido de BLIK de 6 dígitos. Crea un `PaymentMethodOptionsParams` con el código de BLIK. #### Kotlin ```kotlin val paymentMethodOptionsParams = PaymentMethodOptionsParams.Blik(code = "777123"), ``` ## Envía el pago a Stripe [Lado del cliente] Recupera el secreto de cliente del PaymentIntent que creaste en el paso 2 y el código de BLIK de 6 dígitos que copiaste en el paso 3 y llama al método de [confirmación del PaymentLauncher](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 } } } } ``` Tras la confirmación con los parámetros válidos, el estado del PaymentIntent pasa a `requires_action` `onPaymentResult`onPaymentResult`PaymentResult.Completed`. El `next_action` tiene el tipo `blik_authorize`: esto significa que el siguiente paso lo completa tu cliente, que cuenta con 60 segundos para confirmar el pago en su aplicación banca del móvil. Te recomendamos: - Mostrar un temporizador o un diálogo al cliente para pedirle que autorice el pago - Sondear tu servidor o la API de Stripe para la actualización del estado de PaymentIntent - Mostrar la confirmación del pago al cliente en cuanto el estado del PaymentIntent se actualice a `succeeded` ## Optional: Gestionar eventos posteriores al pago Stripe envía un evento [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded) cuando se completa el pago. Utiliza el Dashboard, un *webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) personalizado o una solución de socio para recibir estos eventos y ejecutar acciones como, por ejemplo, enviar un correo electrónico para confirmar el pedido al cliente, registrar la venta en una base de datos o iniciar el flujo de tareas de envío. Escucha estos eventos en lugar de esperar una devolución de llamada del cliente. Por su parte, el cliente puede cerrar la ventana del navegador o salir de la aplicación antes de que se ejecute la devolución de llamada y los clientes malintencionados podrían manipular la respuesta. Configurar tu integración para escuchar eventos asincrónicos también te ayudará a aceptar más métodos de pago en el futuro. Obtén más información sobre las [diferencias entre todos los métodos de pago aceptados](https://stripe.com/payments/payment-methods-guide). - **Gestiona eventos manualmente en el Dashboard** Utiliza el Dashboard para [ver tus pagos de prueba en el Dashboard](https://dashboard.stripe.com/test/payments), enviar recibos por correo electrónico, gestionar pagos o reintentar pagos fallidos. - **Crea un webhook personalizado** [Crea un webhook personalizado](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook) para escuchar eventos y crear flujos de pago asíncronos personalizados. Prueba y depura tu integración de webhooks de forma local con la CLI de Stripe. - **Integra una aplicación prediseñada** Gestiona eventos empresariales comunes, como la [automatización](https://stripe.partners/?f_category=automation) o la [comercialización y ventas](https://stripe.partners/?f_category=marketing-and-sales), integrando una aplicación asociada. ## Optional: Simula fallos en un entorno de prueba Los pagos de BLIK pueden dar error por diferentes motivos. Hay errores inmediatos (por ejemplo, el código ha vencido o no es válido), errores retrasados (el banco lo rechaza) o tiempo de espera agotado (el cliente no ha respondido a tiempo). Puedes simular cada escenario de error especificando los valores de `email` que coincidan con ciertos patrones (documentados a continuación) al crear el `PaymentIntent`, como parte de los [datos de facturación](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_data-billing_details), con cualquier código BLIK de 6 dígitos. ### Errores inmediatos | Código de error | Explicación | Patrón de correo electrónico | | ---------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | | `payment_method_invalid_parameter` | El código que se ha transmitido no era un código de BLIK válido. | `.*invalid_code@.*` | | `payment_method_invalid_parameter` | El código que se ha transmitido ha caducado. Los códigos de BLIK caducan cuando transcurren 2 minutos, debes solicitar otro código al cliente. | `.*expired_code@.*` | ### Rechazos (retraso de 8 segundos) | Código de error | Explicación | Patrón de correo electrónico | | --------------------------------- | ----------------------------------------------------------------------------------------- | ---------------------------- | | `payment_method_provider_decline` | El pago se ha rechazado porque se ha alcanzado el límite de pago en esta cuenta bancaria. | `.*limit_exceeded@.*` | | `payment_method_provider_decline` | La cuenta bancaria no tiene fondos suficientes para realizar la compra. | `.*insufficient_funds@.*` | | `payment_method_provider_decline` | El cliente ha rechazado este pago. | `.*customer_declined@.*` | | `payment_method_provider_decline` | El pago fue rechazado por el banco del cliente por un motivo desconocido. | `.*bank_declined@.*` | | `payment_method_provider_decline` | El pago ha sido rechazado por un motivo desconocido. | `.*blik_declined@.*` | ### Tiempos de espera (retraso de 60 segundos) | Código de error | Explicación | Patrón de correo electrónico | | --------------------------------- | ---------------------------------------------------------------------- | ---------------------------- | | `payment_method_provider_timeout` | El cliente no ha aprobado este pago dentro del plazo de 60 segundos. | `.*customer_timeout@.*` | | `payment_method_provider_timeout` | Se ha agotado el tiempo de espera de la petición al banco del cliente. | `.*bank_timeout@.*` | | `payment_method_provider_timeout` | Se ha agotado el tiempo de espera de la petición a la red BLIK. | `.*blik_timeout@.*` |