Overview

Mollie is a popular payment service provider that allows businesses to accept payments online seamlessly. As e-commerce continues to grow, the need for reliable and versatile payment solutions has never been more critical. Mollie supports various payment methods, including credit cards, PayPal, and local options like iDEAL, catering to diverse customer preferences and regulatory requirements.

This integration is particularly beneficial for businesses operating in multiple countries, as it enables them to accept payments in different currencies. By leveraging Mollie's API, developers can create a flexible checkout experience that not only improves user satisfaction but also increases conversion rates. This article focuses on implementing Mollie Payments in an ASP.NET Core application, specifically highlighting multi-currency transactions and the iDEAL payment method.

Prerequisites

• ASP.NET Core: Familiarity with ASP.NET Core framework and its structure.
• Mollie Account: A live or test account with Mollie to obtain API keys for integration.
• Visual Studio: An IDE for developing ASP.NET Core applications.
• Basic Knowledge of REST APIs: Understanding how to make HTTP requests and handle responses.

Setting Up Mollie in ASP.NET Core

The first step in integrating Mollie Payments is to install the Mollie API client library. This library facilitates communication with Mollie's API and simplifies the payment process.

dotnet add package Mollie.Api --version 2.0.0

This command adds the Mollie API client to your ASP.NET Core project. After installing the package, configure the MollieClient in the Startup.cs class.

public void ConfigureServices(IServiceCollection services)
{
    services.AddHttpClient();
    services.AddSingleton(new MollieClient("your_api_key"));
}

In this code snippet, we first add the HttpClient service, which Mollie's API client relies on for making HTTP requests. Then, we create a singleton instance of MollieClient, passing in the API key obtained from the Mollie dashboard. This setup allows us to use the Mollie client throughout the application.

Using the MollieClient

Once the client is configured, you can use it to create a payment. Below is an example of how to initiate a payment with Mollie.

public async Task CreatePayment(decimal amount, string currency)
{
    var mollieClient = new MollieClient("your_api_key");
    var payment = await mollieClient.Payments.CreateAsync(new PaymentCreateOptions
    {
        Amount = new Amount { Currency = currency, Value = amount.ToString("0.00") },
        Description = "Order #12345",
        RedirectUrl = "https://yourwebsite.com/return",
        WebhookUrl = "https://yourwebsite.com/webhook"
    });
    return Redirect(payment.Links.Checkout.Href);
}

This method creates a payment request with the specified amount and currency. The PaymentCreateOptions class allows you to set properties such as the description, redirect URL after payment completion, and a webhook URL for asynchronous payment notifications.

Multi-Currency Support

Multi-currency support is essential for businesses operating internationally. Mollie allows you to accept payments in various currencies, making it easier for customers to pay in their local currency. To implement multi-currency support, you must handle currency selection based on the user's location or preferences.

When creating a payment, ensure that the currency is valid and supported by Mollie. You can retrieve the list of supported currencies via the Mollie API.

public async Task> GetSupportedCurrencies()
{
    var mollieClient = new MollieClient("your_api_key");
    var paymentMethods = await mollieClient.PaymentMethods.AllAsync();
    return paymentMethods.Select(pm => pm.Currency).Distinct().ToList();
}

This function retrieves all available payment methods and extracts the distinct currencies from them. By using this method, you can dynamically populate a currency selection dropdown in your application.

Validating Currency

When users select a currency, validate that it is supported by Mollie before proceeding with the payment. This ensures that you do not encounter issues during the payment process.

public bool IsCurrencyValid(string currency, List supportedCurrencies)
{
    return supportedCurrencies.Contains(currency);
}

This simple method checks if the provided currency exists in the list of supported currencies, preventing potential errors during payment processing.

Implementing iDEAL Payments

iDEAL is a widely used payment method in the Netherlands, allowing customers to pay directly from their bank accounts. To implement iDEAL payments, you need to specify it as the payment method when creating the payment request.

First, ensure you have iDEAL enabled in your Mollie account. Then, modify the payment creation method to specify iDEAL as the payment method.

public async Task CreateIDealPayment(decimal amount, string currency)
{
    var mollieClient = new MollieClient("your_api_key");
    var payment = await mollieClient.Payments.CreateAsync(new PaymentCreateOptions
    {
        Amount = new Amount { Currency = currency, Value = amount.ToString("0.00") },
        Description = "Order #12345",
        RedirectUrl = "https://yourwebsite.com/return",
        WebhookUrl = "https://yourwebsite.com/webhook",
        Method = PaymentMethod.Ideal
    });
    return Redirect(payment.Links.Checkout.Href);
}

This method is similar to the previous one but includes the Method property, set to PaymentMethod.Ideal. This tells Mollie to process the payment using the iDEAL method.

Handling iDEAL Payment Notifications

After a customer completes their payment, Mollie sends a notification to your webhook URL. You should handle this notification to update the order status in your application.

[HttpPost]
public async Task Webhook([FromBody] WebhookNotification notification)
{
    var mollieClient = new MollieClient("your_api_key");
    var payment = await mollieClient.Payments.GetAsync(notification.Id);
    if (payment.IsPaid())
    {
        // Update order status in your database
    }
    return Ok();
}

This method checks the payment status and updates the order in your database if the payment is successful. Ensure that your webhook URL is publicly accessible for Mollie to send notifications.

Edge Cases & Gotchas

When integrating with Mollie Payments, be aware of several edge cases and potential pitfalls. One common issue is handling currency conversions if you operate in multiple currencies. Ensure that the amount is accurately converted to the selected currency before sending the payment request.

Another common problem is not validating the payment status correctly. Always check the payment status after receiving a webhook notification. Failing to do so can lead to incorrect order statuses.

// Incorrect approach: Updating order status without checking payment status
if (notification.Status == "paid")
{
    // Update order status
}
// Correct approach: Always fetch payment details from Mollie before updating
var payment = await mollieClient.Payments.GetAsync(notification.Id);
if (payment.IsPaid())
{
    // Update order status
}

Performance & Best Practices

Optimizing the performance of your payment integration is crucial for providing a seamless user experience. One best practice is to cache the list of supported currencies and payment methods to reduce API calls. Fetch this data once during application startup and store it in memory.

public class CurrencyService
{
    private readonly List _supportedCurrencies;

    public CurrencyService(MollieClient mollieClient)
    {
        _supportedCurrencies = GetSupportedCurrencies(mollieClient).Result;
    }

    private async Task> GetSupportedCurrencies(MollieClient mollieClient)
    {
        var paymentMethods = await mollieClient.PaymentMethods.AllAsync();
        return paymentMethods.Select(pm => pm.Currency).Distinct().ToList();
    }
}

This service initializes the supported currencies only once and can be injected throughout your application, minimizing redundant API requests.

Real-World Scenario

Let's consider a realistic mini-project: an e-commerce website that allows users to purchase products using Mollie Payments with multi-currency support and iDEAL. Below is a simplified implementation of the checkout process.

public class CheckoutController : Controller
{
    private readonly MollieClient _mollieClient;
    private readonly CurrencyService _currencyService;

    public CheckoutController(MollieClient mollieClient, CurrencyService currencyService)
    {
        _mollieClient = mollieClient;
        _currencyService = currencyService;
    }

    public async Task Checkout(decimal amount, string currency)
    {
        if (!IsCurrencyValid(currency, _currencyService.SupportedCurrencies))
        {
            return BadRequest("Invalid currency");
        }

        var payment = await _mollieClient.Payments.CreateAsync(new PaymentCreateOptions
        {
            Amount = new Amount { Currency = currency, Value = amount.ToString("0.00") },
            Description = "Product Purchase",
            RedirectUrl = "https://yourwebsite.com/return",
            WebhookUrl = "https://yourwebsite.com/webhook",
            Method = PaymentMethod.Ideal
        });

        return Redirect(payment.Links.Checkout.Href);
    }

    [HttpPost]
    public async Task Webhook([FromBody] WebhookNotification notification)
    {
        var payment = await _mollieClient.Payments.GetAsync(notification.Id);
        if (payment.IsPaid())
        {
            // Update order status in the database
        }
        return Ok();
    }
}

This controller manages the checkout process, validating currency and creating payments. The webhook method updates the order status based on the payment result. This implementation serves as a solid foundation for an e-commerce checkout system.

Conclusion

• Understanding Mollie Payments: Integrating Mollie Payments in ASP.NET Core provides a flexible solution for handling online transactions.
• Multi-Currency Support: Implementing multi-currency functionality enhances user experience for international customers.
• iDEAL Integration: Adding iDEAL as a payment method caters to Dutch customers and boosts conversion rates.
• Best Practices: Caching data and validating payment statuses are crucial for optimizing performance and ensuring accuracy.
• Next Steps: Explore advanced features of Mollie API, such as subscriptions and refunds, to further enhance your payment integration.