Przelewy24 payments medusa

Przelewy24 Payments for Medusa

A comprehensive payment provider plugin that enables Przelewy24 payments on Medusa V2 projects.

Table of Contents

• Features
• Prerequisites
• Installation
• Configuration
  • Configuration Options
  • Environment Variables
• Usage
• Client-Side Integration
• Supported Payment Methods
• Payment Flows
• Webhook Configuration
• Extending the Plugin
• Local Development and Customization
• License

Features

• Multiple Payment Methods: Supports a wide range of Przelewy24 payment methods including:

  • BLIK (Regular and One-Click)
  • Credit/Debit Cards
  • Bank Transfers
  • White Label Integration

• Modular Architecture: Multiple services in a single module provider for easy management.

• Webhook Support: Full support for Przelewy24 webhooks for real-time payment status updates.

• TypeScript Support: Full TypeScript implementation with proper types.

• Sandbox Mode: Built-in sandbox support for testing.

[!WARNING] > This plugin has not been tested on a live store. Please conduct thorough testing before using it in a production environment. GMI Software is not responsible for any missed or failed payments resulting from the use of this plugin. If you encounter any issues, please report them here.

Prerequisites

• Medusa server v2.4.0 or later
• Node.js v20 or later
• A Przelewy24 merchant account with API credentials.

[!NOTE] > You can get your API credentials from your Przelewy24 merchant panel

Installation

yarn add p24-medusa-plugin

Configuration

Add the provider to the @medusajs/payment module in your medusa-config.ts file:

1import { Modules } from "@medusajs/framework/utils";
2
3module.exports = defineConfig({
4  modules: [
5    {
6      resolve: "@medusajs/medusa/payment",
7      options: {
8        providers: [
9          {
10            resolve:
11              "@gmisoftware/przelewy24-payments-medusa/providers/przelewy24",
12            id: "przelewy24",
13            options: {
14              api_key: process.env.P24_API_KEY,
15              merchant_id: process.env.P24_MERCHANT_ID,
16              pos_id: process.env.P24_POS_ID,
17              crc: process.env.P24_CRC,
18              sandbox: process.env.P24_IS_SANDBOX,
19              frontend_url: process.env.MEDUSA_STORE_URL,
20              backend_url: process.env.MEDUSA_BACKEND_URL,
21            },
22          },
23        ],
24      },
25    },
26  ],
27  plugins: ["@gmisoftware/przelewy24-payments-medusa"],
28});

Configuration Options

Environment Variables

Create or update your .env file with the following variables:

1# P24 Configuration
2P24_MERCHANT_ID=your_merchant_id
3P24_POS_ID=your_pos_id
4P24_API_KEY=your_api_key
5P24_CRC=your_crc_key
6
7# URL Configuration
8FRONTEND_URL=https://your-frontend-domain.com
9BACKEND_URL=https://your-backend-domain.com

Usage

Once installed and configured, the Przelewy24 payment methods will be available in your Medusa admin. To enable them, log in to your Medusa Admin, browse to Settings > Regions, add or edit a region and select the desired P24 providers from the dropdown.

Make sure that the selected payment methods are enabled in your Przelewy24 merchant panel as well.

Client-Side Integration

To integrate with your storefront, you'll need to implement the payment flow according to Przelewy24's and Medusa's documentation. Here's a basic example:

BLIK Payment

BLIK payments use a two-phase flow:

Phase 1: Create Payment Session

1// Create payment session for BLIK
2const paymentSession = await medusa.payment.createPaymentSession({
3  provider_id: "p24-blik",
4  amount: 10000, // 100.00 PLN in grosze
5  currency_code: "PLN",
6  data: {
7    country: "PL", // Country code (defaults to "PL" if not provided)
8    language: "pl", // Language code (defaults to "pl" if not provided)
9  },
10  context: {
11    email: "customer@example.com",
12  },
13});
14
15// Response includes session_id and token, but no redirect_url
16console.log(paymentSession.data.session_id); // Use this for BLIK processing

Phase 2: Process BLIK Code

1// Call internal API to process BLIK code
2const blikResponse = await fetch("/admin/plugin/blik", {
3  method: "POST",
4  headers: {
5    "Content-Type": "application/json",
6  },
7  body: JSON.stringify({
8    token: paymentSession.data.token, // Token from payment session
9    blikCode: "123456", // 6-digit BLIK code from user
10  }),
11});

Card Payment

1// Create payment session for cards
2const paymentSession = await medusa.payment.createPaymentSession({
3  provider_id: "p24-cards",
4  amount: 10000, // 100.00 PLN in grosze
5  currency_code: "PLN",
6  data: {
7    country: "PL", // Country code (defaults to "PL" if not provided)
8    language: "pl", // Language code (defaults to "pl" if not provided)
9  },
10  context: {
11    email: "customer@example.com",
12    billing_address: {
13      country_code: "PL",
14    },
15  },
16});
17
18// Redirect user to payment URL
19window.location.href = paymentSession.data.redirect_url;

General P24 Payment

1// Create payment session for general P24
2const paymentSession = await medusa.payment.createPaymentSession({
3  provider_id: "p24-general",
4  amount: 10000,
5  currency_code: "PLN",
6  data: {
7    country: "PL", // Country code (defaults to "PL" if not provided)
8    language: "pl", // Language code (defaults to "pl" if not provided)
9  },
10  context: {
11    email: "customer@example.com",
12  },
13});
14
15// Redirect user to P24 payment selection
16window.location.href = paymentSession.data.redirect_url;

Supported Payment Methods

The plugin currently supports the following Przelewy24 payment methods:

Payment Flows

1. BLIK Payment Flow

1. Phase 1: Frontend creates payment session via initiatePayment
2. Phase 2: Frontend collects BLIK code (6 digits) from customer
3. Phase 3: Frontend calls internal API /admin/plugin/blik with BLIK code
4. Phase 4: Backend calls P24 BLIK API to charge the payment
5. Phase 5: Customer confirms payment on mobile device
6. Phase 6: P24 sends webhook notification confirming payment
7. Phase 7: Order is completed

Note: BLIK payments don't use redirect URLs. The entire flow happens through API calls.

2. Card Payment Flow

1. Customer is redirected to P24 card payment page
2. Customer enters card details
3. Payment is processed
4. Customer is redirected back to store
5. Webhook notification confirms payment

3. General P24 Flow

1. Customer is redirected to P24 payment selection
2. Customer chooses payment method (bank transfer, etc.)
3. Payment is processed through chosen method
4. Customer is redirected back to store
5. Webhook notification confirms payment

Webhook Configuration

Webhook URLs

The plugin provides webhook endpoints for each provider:

• BLIK: {backend_url}/hooks/payment/p24-blik_p24-medusa-plugin
• Cards: {backend_url}/hooks/payment/p24-cards_p24-medusa-plugin
• General: {backend_url}/hooks/payment/p24-provider_p24-medusa-plugin

Return URL

• Return URL: {frontend_url}

Configure these URLs in your P24 merchant panel.

Note: The webhook URLs follow Medusa's pattern: {identifier}_{provider} where:

• identifier is the service's static identifier (e.g., p24-blik, p24-cards, p24-provider)
• provider is the package name (p24-medusa-plugin)

Extending the Plugin

To add support for additional Przelewy24 payment methods, create a new service in src/providers/przelewy24/services that extends the P24Base class:

1import P24Base from "../core/p24-base";
2import { PaymentOptions } from "../types";
3
4class P24NewMethodService extends P24Base {
5  static identifier = "p24-new-method";
6
7  get paymentCreateOptions(): PaymentOptions {
8    return {
9      method: "new_method",
10    };
11  }
12}
13
14export default P24NewMethodService;

Make sure to replace new_method with the actual Przelewy24 payment method ID.

Export your new service from src/providers/przelewy24/services/index.ts. Then add your new service to the list of services in src/providers/przelewy24/index.ts.

Local development and customization

In case you want to customize and test the plugin locally, refer to the Medusa Plugin docs.

License

MIT License

Contributing

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Add tests
5. Submit a pull request