Multicore: The Core Payment Functionality
Within the Multicore platform, payments are processed via multiple Transaction Gateway Units (TGUs).
This development goes beyond just technical infrastructure. New features and payment functionalities are made available by PAY. exclusively on the Multicore Platform. For merchants and integration partners, this means it's important to keep their PAY. integration up to date.
What is Multicore?
With the Multicore Platform, PAY. can process transactions via multiple Transaction Gateway Units. Via connect.pay.nl, multiple TGUs are available for processing transactions. In addition, there are other cores that can be used, among other things, as an alternative or backup route.
The goal of this is a modern and flexible infrastructure for processing payments. An up-to-date Multicore integration can, among other things, benefit from higher availability, access to new payment methods, and faster payment processing
Fallback routing
PAY. can route payments from older integrations via the Multicore infrastructure. This allows us to ensure that certain functionalities of the new platform can also be used for these transactions.
Routing is not the same as full Multicore support
Not every merchant is already using a PAY. integration that has been updated for Multicore. When a merchant still uses an older or non-updated integration, PAY. can route the payments to the Multicore infrastructure.
As a result, a merchant doesn't immediately lose access to new functionalities. Behind the scenes, PAY. ensures that the payment is forwarded to the infrastructure where these functionalities are available.
When an outdated integration itself doesn't have the right Multicore or fallback capabilities, PAY. can still forward a payment to the new infrastructure, but this does not automatically create the same redundancy and availability as with a fully updated Multicore integration.
However, this routing should not be seen as a replacement for an up-to-date Multicore integration. For this additional routing, a surcharge per transaction may be charged.
This is because the availability benefits of Multicore also depend on the way the integration itself is set up. PAY. therefore advises integrations to be able to use multiple TGUs for the most important part of the checkout – the actual payment.
New features only on Multicore
PAY. continuously develops the payment platform. To prevent new functionalities from also having to be built and maintained on older technical architectures, new features are rolled out exclusively on the Multicore Platform.
This means that a merchant with an outdated PAY. integration will not automatically be able to directly use all new capabilities in the long run.
Where possible, PAY. can route such payments so that functionalities of the Multicore Platform can still be applied. However, this extra routing layer is intended as a transitional measure and not as a structural alternative to updating an integration.
It is therefore explicitly not a surcharge with which a merchant automatically “buys” higher availability. The routing ensures that PAY. can forward the payment via the correct infrastructure and, where possible, make new functionalities available.
Updating remains the best solution
For merchants, the structural solution is therefore simple: make sure the PAY. integration is updated to a current version that fully supports the Multicore Platform.
This not only avoids an additional surcharge on legacy processing, but also allows the integration to directly benefit from the further development of the PAY. platform.
An up-to-date Multicore integration provides access to:
- new features and payment functionalities;
- new payment methods;
- the current PAY. APIs;
- multiple Transaction Gateway Units;
- better options for fallback and redundancy;
- further optimizations in payment processing.
PAY. therefore advises merchants and technical integration partners not to keep relying on routing from older integrations, but to actively migrate their connection to Multicore.
Multicore is not just a route for payments, but the technical foundation on which PAY. further develops its payment platform.
Updating to Multicore is simple
Updating an existing PAY. integration to Multicore doesn't have to be an extensive technical project. The setup and operation of transaction processing are largely the same as those of the old platform. For existing integrations, this means that much of the current logic and processes can be retained.
A complete rebuild of the payment integration is therefore not necessary in most cases. It's mainly about updating the connection so that transactions can be processed directly via the Multicore infrastructure.
To further simplify the switch, PAY. makes SDKs available, which allow developers to easily integrate the PAY. API into their application. This makes it relatively easy to update an existing integration to the current technical standard.
The step to Multicore is therefore smaller than it might seem: the familiar setup of transaction processing largely remains in place, SDKs are available to simplify implementation, and the integration is then ready for the further development of the PAY. platform.
Our plugins have also been updated
Are you using a standard PAY. plugin? Then the switch is even easier. The PAY. plugins have now been updated for the new infrastructure, and the current versions can already be downloaded.
We therefore advise merchants who use a PAY. plugin to check whether they have the most recent version installed. By updating the plugin, the integration can directly make use of the current PAY. infrastructure, without a completely new payment integration having to be developed for this.