Direct Support Site

Results for

icon-search-large No search results yet
Enter your search query above

1. Introduction

To create payments, you need to link your server to our platform via one of our integration modes.
Our Java SDK library is the ideal solution to connect to our platform if you prefer to do so with your own stand-alone system using Java language.

Choosing the Java SDK, you can:

To take full advantage of this SDK, make sure you meet these requirements:

  • Java 8 or higher
  • Maven/Gradle

Download the newest version of Java library and follow the installation instructions. You can download and install the latest version of the Java SDK by:

Find more details on GitHub. Also, check out all available SDK objects and properties in our Full API Reference. Once you are all set, read the next chapters on how to prepare and use the SDK.

This guide provides a general overview on the SDK’s functionalities. To see how they precisely work for the different integration modes, see the dedicated guides explaining every step with full code samples:

Target most up-to-date API base URL

We encourage you to always target the most up-to-date API base URL when sending requests to our platform. Have a look at our dedicated guides for a full overview:

To allow you a smooth transition, previous API base URLs remain available until further notice.

2. Initialise SDK

To connect your system to our platform by using the SDK, you need to initialise it at first.

Initialising requires you to

  • Create test/live account
  • Create properties file:
    
    direct.api.integrator=CompanyName
    direct.api.endpoint.host=ProperApiEndpoint
     # The properties below are optional and use the given values by default
    direct.api.endpoint.scheme=https
    direct.api.endpoint.port=-1
    direct.api.connectTimeout=10000
    direct.api.socketTimeout=10000
    direct.api.maxConnections=10
    direct.api.https.protocols=TLSv1.2
    direct.api.authorizationType=V1HMAC
  • Create an API Key and API Secret for the PSPID you wish to use for transaction processing
  • Initialise an instance of Client using the API Key / API Secret to set up the connection to our test/live platform

    Remember to pay attention to the environment you get the key set from. API Key and API Secret are different for test and live environments.

    The full path of the API endpoint for the test/live environment is

    • https://payment.preprod.direct.worldline-solutions.com/v2/
    • https://payment.direct.worldline-solutions.com/v2/


    As our SDKs always implement the latest version of our API, you can leave out "v2" in your code as shown in the example above

After initialisation, you can start processing transactions via your PSPID. Learn how this works in the dedicated chapter

Have a look at code samples of two connection methods covering the steps mentioned above:

  1. By using created properties file
    
    private ClientInterface client;
    
    private MerchantClientInterface merchantClient;
    
    public void initialiseSdk () {
     URI propertiesUri = getClass().getClassLoader().getResource("paymentprovider.properties").toURI();
     client = Factory.createClient(propertiesUri, "apiKey", "apiSecret");
     merchantClient = client.merchant("PSPID");
    }
    
  2. By using CommunicatorConfiguration
    
    CommunicatorConfiguration communicatorConfiguration =
    
     new CommunicatorConfiguration()
     .withApiKeyId("apiKey")
     .withSecretApiKey("apiSecret")
     .withApiEndpoint(URI.create("apiEndpoint"))
     .withIntegrator("integrator")
     .withAuthorizationType(AuthorizationType.V1HMAC);
    client = Factory.createClient(communicatorConfiguration);
    clientMerchant = client.merchant("PSPID");
    

If you are ready to switch to the live environment, substitute the endpoint link apiEndpoint = 'https://payment.preprod.direct.worldline-solutions.com' for the live environment apiEndpoint = 'https://payment.direct.worldline-solutions.com/'

The following table provides an overview of the arguments accepted by the individual instances:

Properties
  • string merchantId: Your PSPID in either our test environment/live environment. Make sure to use the correct API Key / API Secret together with the conjoining PSPID for your transactions request
  • string apiKey: The API Key you have defined in your PSPID to which you will send the transactions to
  • string apiSecret: The API Secret you have defined in your PSPID to which you will send the transactions to

    Check out our dedicated guide to learn all about API Key / API Secret

  • string apiEndpoint: It contains a link to either our test or live environment where your transaction requests are sent to

    The full path of the of API endpoint for test/live environment is

    • https://payment.preprod.direct.worldline-solutions.com/v2/
    • https://payment.direct.worldline-solutions.com/v2/

    respectively. As our SDKs always implement the latest version of our API, you can leave out "v2" in your code as shown in the example above

  • string integrator: Your (company) name or any unique identifier. We can use the value for debugging and tracking request you have sent to our platform. Therefore, we strongly suggest sending a value we can identify your requests easily in our logs
You can re-use a Client instance for different calls. You can use

  • The MerchantClient class object initialised in the example for all calls for that PSPID
  • The Client instance to create MerchantClients for different (or the same) PSPIDs


After you have initialised the SDK, you can send requests to our platform via your PSPID. Learn how to do this in the next chapter .

For transactions with no financial impact, use TEST-URL. The transactions will be sent to our test environment, thereby to your test account

For transactions with a financial impact, use the LIVE-URL. The transactions will be sent to our live environment, thereby to your live account

3. Use SDK

After the successful initialisation of the Client instance, you gain full access to our RESTful API. It enables you to:

  • Send requests for new transactions for any of our server integration modes
  • Get your transactions’ current status
  • Perform maintenance requests (i.e., captures, refunds) on existing transactions

Make sure that the payment method you would like to use is active in your test/live account. Check in the Back Office via Configuration > Payment methods 

Check out our test cases in GitHub, including full code samples, and our Full API Reference to learn what is possible.

IClient implements the IDisposable interface, allowing you to use it in using statements. This will release resources when they are no longer needed. Alternatively, we strongly suggest closing the connection manually.

ClientInterface extends the java.io.Closable interface, allowing you to use it in try-with-resources statements. This will release resources when they are no longer needed. Alternatively, we strongly suggest closing the connection manually:

client.closeIdleConnections(30, TimeUnit.MINUTES);

Below you may find some of the most common actions you can perform:

Create new transactions

To create a new transaction, you can use either the Client or MerchantClient instance for any of our integration modes to create a new transaction. It can be done through: 

  • Routing the request to your PSPID on our platform (for Client)
  • Creating a request for the respective integration mode

The SDK instance only keeps track of the data used to initialise it. It does not track neither active sessions nor previous requests. Your system is responsible for managing Direct sessions and payments

Sessions and payments do not impact other sessions and payments

Below you can find code samples related to particular integration modes:

Hosted Checkout Page

To use this integration mode, you need to create a CreateHostedCheckoutRequest call. It must contain at least an Order object.


/* 
 *…. Initialisation....
 */

// The example object of the AmountOfMoney 
AmountOfMoney amount = new AmountOfMoney()
.withAmount(100L)
.withCurrencyCode("EUR");
checkoutRequest.withOrder(new Order().withAmountOfMoney(amount));
CreateHostedCheckoutResponse response = hostedCheckoutClient.createHostedCheckout(checkoutRequest);
You can specify an optional returnUrl, which will be used to redirect your customer back to your website

This call returns a CreateHostedCheckout response. Store the hostedCheckoutId and RETURNMAC it contains, as well as any other information relevant for you. You will need these for steps described in the following chapters.

This response also contains a partialRedirectURL.

You have to concatenate the base URL "https://payment." with partialRedirectURL according to the formula

https://payment. + partialRedirectURL

and perform redirection of your customer to this URL. Once the customer visits the Hosted Checkout Page, the payment process continues there.

The newest version of our SDK also returns the full path in redirectURL, allowing you to skip concatenate the base URL "https://payment." with partialRedirectURL. Learn more more in our  Hosted Checkout Page  guide. 

Hosted Tokenization Page

To use this integration method, you need to

CreateHostedTokenizationRequest hostedTokenizationRequest = new CreateHostedTokenizationRequest();
CreateHostedTokenizationRequest createHostedTokenizationRequest =
hostedTokenizationRequest.withVariant("YourTemplate.html");
CreateHostedTokenizationResponse hostedTokenizationResponse = merchantClient.hostedTokenization()
.createHostedTokenization(createHostedTokenizationRequest);


From CreateHostedTokenizationResponse retrieve hostedTokenizationId and partialRedirectUrl. Use the  partialRedirectUrl for the iframe and the hostedTokenizationId or tokenId (see infobox) to create the actual payment via Server-to-server integration mode.

You can send either the tokenID or the hostedTokenizationId in your CreatePayment request. Learn more about using either option in the dedicated chapters of our Hosted Tokenization Page guide:


GetHostedTokenizationResponse getHostedTokenizationResponse = initializer.getClientMerchant().hostedTokenization().getHostedTokenization(hostedTokenizationId);
String tokenId = getHostedTokenizationResponse.getToken().getId();

// The example object of the AmountOfMoney 
AmountOfMoney amount = new AmountOfMoney() 
      .withAmount(100L) 
      .withCurrencyCode("EUR"); 

Order order = new Order().withAmountOfMoney(amount);
CardPaymentMethodSpecificInput paymentInput = new CardPaymentMethodSpecificInput().withToken(tokenId);

CreatePaymentRequest requestBody = new CreatePaymentRequest()
        .withCardPaymentMethodSpecificInput(paymentInput)
        .withOrder(order);
CreatePaymentResponse response = initializer.getClientMerchant().payments().createPayment(requestBody);

You can also send the tokenID instead of the hostedTokenizationId in your CreatePayment request. Learn more about using either option in the dedicated chapters of our Hosted Tokenization Page guide:

Server-to-server

A minimum paymentResponse requires you to set at least an Order object and a payment method:


// The example object of the AmountOfMoney 

AmountOfMoney amountOfMoney = new AmountOfMoney() 
        .withAmount(100L) 
        .withCurrencyCode("EUR"); 
Order order = new Order().withAmountOfMoney(amountOfMoney); 
 
// To get more test card data visit the website: Find more test data here 
Card card = new Card() 
         .withCvv("123") 
         .withCardNumber("5399999999999999") 
         .withCardholderName("Test Name") 
         .withExpiryDate("1236"); 
int paymentProductId = 3; 
 
PaymentsClientInterface paymentClient = merchantClient.payments(); 
CreatePaymentRequest createPaymentRequest = new CreatePaymentRequest(); 
 
CardPaymentMethodSpecificInput cardPaymentMethodSpecificInput = new CardPaymentMethodSpecificInput(); 
cardPaymentMethodSpecificInput.setCard(card); 
cardPaymentMethodSpecificInput.setPaymentProductId(paymentProductId) ; 
 
createPaymentRequest.setCardPaymentMethodSpecificInput(cardPaymentMethodSpecificInput); 
createPaymentRequest.setOrder(order); 
 
CreatePaymentResponse createPaymentResponse = paymentClient.createPayment(createPaymentRequest);

We have dedicated guides for each of the aforementioned integration modes:

The documents contain all crucial details you need to profit from the integration modes’ full potential, including full transaction flows, code samples and other useful features

Get transaction status

Our RESTful API allows you to request a transaction’s status anytime by one of our GET calls:

A GetPayment request looks like this: 


PaymentResponse paymentResponse = merchantClient.payments().getPayment(paymentId);
Properties
string paymentId: The 10-digit unique reference of your transaction on our platform. This reference can be retrieved from the CreatePaymentResponse or createHostedCheckoutResponse created in the previous section.

For more information about statuses visit the status documentation page.

Perform maintenance operation

To perform follow-up actions on existing transactions (i.e. captures or refunds), use our CapturePayment or RefundPayment API call respectively:

CapturePayment

Make sure to use the following classes:

  • CapturePaymentRequest

/* 
 *…. Initialisation....
 */
MerchantClientInterface merchantClient;

// Here you get paymentId you can use in further code
String paymentId = createPaymentResponse.getPayment().getId();
CapturePaymentRequest capturePaymentRequest = new CapturePaymentRequest();
capturePaymentRequest.withAmount(amount);
capturePaymentRequest.setIsFinal(true);

merchantClient.payments().capturePayment(paymentId, capturePaymentRequest);

RefundPayment

Make sure to use the following classes:

  • RefundRequest
  • AmountOfMoney

/*  
 *…. Initialisation.... 
 */ 
 
MerchantClientInterface merchantClient;

String paymentId;

RefundRequest refundRequest = new RefundRequest();

// The example object of the AmountOfMoney
AmountOfMoney amountOfMoney = new AmountOfMoney()
.withAmount(100L)
.withCurrencyCode("EUR");
refundRequest.setAmountOfMoney(amountOfMoney);

// Get RefundResponse object
RefundResponse refundResponse = merchantClient.payments().refundPayment(paymentId, refundRequest);
Properties
string paymentId: The 10-digit unique reference of your transaction on our platform. This reference can be retrieved from the CreatePaymentResponse or createHostedCheckoutResponse created in the previous section.

4. Handle exceptions

If a transaction is rejected, our platform provides detailed information with an Exception instance. The affiliated HTTP status code also help you troubleshoot the error.

You can encounter two types of exceptions: transaction exceptions and HTTP exceptions.

Transaction exceptions

This kind of exception refers to transaction requests that are technically correct but were rejected by your customer’s issuer or your acquirer. If the transaction is returned in the exception, it means that it was created in our systems but not successfully processed. 

The following code samples use implicit methods provided as an example. You are expected to provide your own implementation for these or replace them with similar logic

Exception type /
HTTP status code
Code Sample
Rejected transactions / 
Various(see PaymentResponse object)
/* * Initialization.... */

CreatePaymentRequest createPaymentRequest = new CreatePaymentRequest();
String paymentId;
try {
CreatePaymentResponse createPaymentResponse = paymentClient.createPayment(createPaymentRequest);
paymentId = createPaymentResponse.getPayment().getId();
} catch (DeclinedPaymentException e) {

PaymentResponse payment = e.getCreatePaymentResult().getPayment();
paymentId = payment.getId();
String paymentStatus = payment.getStatus();
handleError(payment);
}
PaymentResponse paymentResponse = merchantClient.payments().getPayment(paymentId);

// Your code to check transaction status and handle errors
if (isNotSuccessful(paymentResponse)) {
handleError(paymentResponse);
}
Rejected Refund /
Various(see PaymentResponse object)
/* * Initialization.... */

String paymentId = createPaymentResponse.getPayment().getId();
String refundId;

RefundRequest refundRequest = new RefundRequest();

try {
RefundResponse refundResponse = merchantClient.payments().refundPayment(paymentId, refundRequest);
refundId = refundResponse.getId();
} catch (DeclinedRefundException e) {
RefundResponse refundResult = e.getRefundResult();
handleError(refundResult);
}
RefundsResponse refundResponse = merchantClient.payments().getRefunds(paymentId);

// Your code to check transaction status and handle errors
if (isNotSuccessful(refundResponse, refundId)) {
handleError(refundResponse);
}

$refundResponse = $merchantClient
    ->payments()
    ->refundPayment($paymentID, $refundRequest);

// Your code to check transaction status and
// handle errors
if (isNotSuccessful($refundResponse, $refundID)) {
   handleError($refundResponse);
}

HTTP exceptions

This kind of exception refers to various problems caused by technical errors in the API call or payment request.

You can combine any of the following code snippets with this standard CreatePayment request:

Make sure to use the following classes:
  • ApiException

/* 
 *…. Initialisation....
 */

CreatePaymentRequest createPaymentRequest = new CreatePaymentRequest(); 

// The example object of the AmountOfMoney
AmountOfMoney amountOfMoney = new AmountOfMoney()
.withAmount(100L)
.withCurrencyCode("EUR");

Order order = new Order().withAmountOfMoney(amountOfMoney);

CardPaymentMethodSpecificInput cardPaymentMethodSpecificInput = new CardPaymentMethodSpecificInput();

// The example object of the Card – you can find test cards on
// https://support.direct.ingenico.com/documentation/test-cases/
Card card = new Card()
.withCvv("123")
.withCardNumber("5399999999999999")
.withCardholderName("Test Name")
.withExpiryDate("1236");

cardPaymentMethodSpecificInput.setCard(card);
cardPaymentMethodSpecificInput.setPaymentProductId(3);

createPaymentRequest.setCardPaymentMethodSpecificInput(cardPaymentMethodSpecificInput);

try {
CreatePaymentResponse createPaymentResponse = paymentClient.createPayment(createPaymentRequest);
}
catch (ApiException e) {
// Refer to the list below to see how specific implementations of ApiException can be handled.
}

Exception type / 
HTTP status code
Code Sample
ValidationException
400
catch (ValidationException e) { 
System.err.println("Input validation error");
for (APIError error : e.getErrors()) {
if (error.getPropertyName() == null) {
System.err.println(error.getCode() + ": " + error.getMessage());
} else {
System.err.println(error.getPropertyName() + ": " + error.getCode() + ": " + error.getMessage());
}
}
}
AuthorizationException / 
403
catch (AuthorizationException e) { 
System.err.println("Authorization error");
for (APIError error : e.getErrors()) {
System.err.println(error.getCode() + ": " + error.getMessage());
}
}
IdempotenceException
409
catch (IdempotenceException e) { 
System.err.println("Idempotence error:");
for (APIError error : e.getErrors()) {
System.err.println(error.getCode() + ": " + error.getMessage());
}
}
ReferenceException
404/409/410
catch (ReferenceException e) { 
System.err.println("Incorrect object reference:");
for (APIError error : e.getErrors()) {
System.err.println(error.getCode() + ": " + error.getMessage());
}
}
DirectException
500/502/503
catch (DirectException e) { 
System.err.println("Error occurred at Direct or a downstream partner/acquirer:");
for (APIError error : e.getErrors()) {
System.err.println(error.getCode() + ": " + error.getMessage());
}
}
ApiException /
Any other codes
catch (ApiException e) { 
System.err.println("Platform error: ");
for (APIError error : e.getErrors()) {
System.err.println(error.getCode() + ": " + error.getMessage());
}
}
CommunicationException /
300 codes without a body or non-JSON response
catch (CommunicationException e) { 
System.err.println("Communication exception: " + e.getMessage());
}

HTTP status codes 

All our exceptions are linked to one or more HTTP status codes, indicating the root cause for many possible errors.

Status code Description Exception type
200

Successful
Our platform processed your request correctly

-
201

Created
Our platform processed your request correctly and created a new resource. We return the URI of this resource in the Location header of the response

-
204

No content
Our platform processed your request correctly

-
Various
paymentResult key is in the response

Payment Rejected
Either our platform or one of our downstream partners/acquirers rejected your request

DeclinedPaymentException
Various
payoutResult key is in the response

Payout Rejected
Either our platform or one of our downstream partners/acquirers rejected your request

DeclinedPayoutException

Various
refundResult key is in the response

Refund Rejected
Either our platform or one of our downstream partners/acquirers rejected your request

DeclinedRefundException
400

Bad Request
Your request contains errors, thus our platform cannot process it

ValidationException
403

Not Authorised
You are trying to do something that is not allowed or that you are not authorised to do

AuthorizationException
404

Not Found
The object you were trying to access could not be found on the server

ReferenceException
409

Conflict
Your idempotent request resulted in a conflict because of either: 

  • The first request has not finished yet
  • Your request resulted in a conflict. Either you submitted a duplicate request, or you are trying to create something with a duplicate key

IdempotenceException
ReferenceException

410

Gone
The object that you are trying to reach has been removed.

ReferenceException
500

Internal Server Error
An error occurred on our platform

DirectException
502 Bad Gateway
Our platform was unable to process a message from a downstream partner/acquirer
DirectException
503 Service Unavailable
The service that you are trying to reach is temporarily unavailable. Please try again later
DirectException
Other Unexpected error
An unexpected error has occurred
ApiException

5. Use additional features

The SDK has a lot more to offer. Have a look at the following features, as they will help you build the perfect solution.

Get available payment methods

Before you initiate the actual payment process, you send a GetPaymentProducts request to our platform. The response contains a list of available payment methods in your PSPID. Depending on your customers’ preferences, you can offer a selection on our Hosted Checkout Page or on your own webshop environment using subsequent CreatePayment requests.

Make sure to use the following classes:
  • GetPaymentProductsParams

/* 
 *…. Initialisation....
 */

// Prepare the request to get all active payment methods in your PSPID 
var queryParams = new GetPaymentProductsParams()
.withCountryCode("FR")
.withCurrencyCode("EUR");

// Send the request and get the response
GetPaymentProductsResponse paymentProductResponse = merchantClient.products().getPaymentProducts(queryParams);

Send idempotent requests

One of the main REST API features is its ability to detect and prevent sending requests (i.e. payment requests) accidentally twice. The SDK makes it very easy for you to ensure that you send only unique – idempotent – requests to our platform.

Use the additional argument paymentContext and set its property named idempotence  to a CreatePayment request. The SDK will send an X-GCS-Idempotence-Key header with the idempotence key as its value.

If you send requests this way to our platform, we will check the following

  • If you send subsequent request with the same idempotence key, the response contains an X-GCS-Idempotence-Request-Timestamp header. The SDK will set the idempotenceRequestTimestamp property of the paymentContext argument
  • If the first request is not finished yet, the RESTful Server API returns a  409 status code. Then the SDK throws an IdempotenceException with the original idempotence key and the idempotence request timestamp

/* 
 *…. Initialisation....
 */

CreatePaymentRequest createPaymentRequest = new CreatePaymentRequest(); 

String idempotenceKey = "YourKeyForThePayment";

var callContext = new CallContext();
callContext.withIdempotenceKey(idempotenceKey);

try {
var createPaymentResponse = merchantClient.payments().createPayment(createPaymentRequest, callContext);
} catch (IdempotenceException e) {
// a request with the same idempotenceKey is still in progress, try again after a short pause
// e.getIdempotenceRequestTimestamp() contains the value of the
// X-GCS-Idempotence-Request-Timestamp header
} finally {
Long idempotenceRequestTimestamp = callContext.getIdempotenceRequestTimestamp();
// idempotenceRequestTimestamp contains the value of the
// X-GCS-Idempotence-Request-Timestamp header
// if idempotenceRequestTimestamp is not empty, this was not the first request
}
If an idempotence key is sent for a call that does not support idempotence, the RESTful Server API will ignore the key and treat the request as a first request


Use logging

The SDK supports logging of requests, responses, and exceptions of the API communication. These can be helpful for troubleshooting or tracing individual steps in the payment flow.

To use this logging feature, you should implement the CommunicatorLogger interface.

The SDK offers two implementations of the logging feature:

  • System.out (SysOutCommunicatorLogger)
  • java.util.logging.Logger (JdkCOmmunicatorLogger)
Make sure to use the following classes:
  • ResourceLogger

You can enable/disable the logging by calling the enableLogging method on a ClientInterface object and provide the logger as an argument. You can subsequently disable the logger by calling the disableLogging method:


ClientInterface client = Factory.createClient(propertiesUrl.toURI(), "apiKeyId", "secretApiKey");

CommunicatorLogger logger = new JdkCommunicatorLogger(Logger.getLogger(...), Level.INFO);
client.enableLogging(logger);
//... Do some calls
client.disableLogging();
The SDK obfuscates sensitive data in the logger

Connection pooling

You can manage your network resources by limiting the number of possible connections the SDK creates and maintains. The Client instances created as discussed in the Initialise SDK chapter will have their own connection pool. The Client instances created with the same Communicator object share a connection pool.

If you use multiple Client instances to share a single connection pool, make sure to follow these steps:

  1. Create a shared Communicator . You can use the com.onlinepayments.Factory class 
  2. Create Client instances with that Communicator

/* 
 *…. Initialisation....
 */

/* Initialisation... */  
// Communicator instance
Communicator communicator = Factory.createCommunicator(propertiesUrl.toURI(), "apiKeyId", "secretApiKey");
// create one or more clients using the shared communicator
ClientInterface client = Factory.createClient(communicator);

Customise communication

A ClientInterface uses a Communicator to communicate with our platform. Communicator implementations transform a request object to a HTTP request and a HTTP response to a response object. If needed, you can extend this class. To instantiate a ClientInterface that uses your own implementation of Communicator, you can use the following code snippet:


Communicator communicator = new YourCommunicator();
ClientInterface client = Factory.createClient(communicator);

Providing your own implementation is not necessary for most cases. The functionality of the com.onlinepayments.defaultimpl.DefaultCommunicator is built on classes: Authenticator, Connection, Marshaller and MetaDataProvider. The implementation of these classes can easily be extended or replaced to fit your needs. 

Marshaller is used to marshal / unmarshal request and response objects to and from JSON, which you should not change. The other modules needed to communicate with the our platform are

  • The RESTful Server API endpoint URI
  • A Connection for one or more HTTP connections to our server
  • An Authenticator, to sign your requests
  • A MetaDataProvider, constructing the header with your server’s meta data

For your convenience, the CommunicatorBuilder class is provided to easily replace one or more of these modules. For example, to instantiate a ClientInterface that uses your own implementation of Connection, you can use the following code snippet:


/* 
 *…. Initialisation....
 */

Connection connection = new YourConnection();  
Communicator communicator = Factory.createCommunicatorBuilder(propertiesUrl.toURI(), "apiKeyId", "secretApiKey").withConnection(connection).build();
ClientInterface client = Factory.createClient(communicator);

Webhooks

The part of the SDK that handles the webhooks support is called the webhooks helper. It transparently handles both validation of signatures against the event bodies sent by the webhooks system (including finding the secret key for key IDs - not to be confused with the API Key and API Secret), and unmarshalling of these bodies to objects. This allows you to focus on the essentials, without going through all the additional information and extracting the desired ones by yourself. To learn more about webhooks, read our dedicated guide. 

Provide secret keys

Configure the "WebhooksKey" / "WebhooksKeySecret" and your server webhooks endpoints in the Merchant Portal:


String keyId = "WebhooksKey";
String secretKey = "WebhooksKeySecret";

Use InMemorySecretKeyStore.INSTANCE.storeSecretKey(keyId, secretKey) to store a secret key for a key ID.

You can add or remove keys using the following functions:

  • InMemorySecretKeyStore.INSTANCE.getSecretKey(keyId)
  • InMemorySecretKeyStore.INSTANCE.removeSecretKey(keyId) to remove the stored secret key for a key ID
  • InMemorySecretKeyStore.INSTANCE.clear() to remove all stored secret keys

If you require more advanced storage, e.g. using a database or file system, we recommend writing your own implementation. 

Initialise webhooks helper

Using an implementation of com.onlinepayments.webhooks.SecretKeyStore, create an instance of  com.onlinepayments.webhooks.WebhooksHelper:


WebhooksHelper helper = Webhooks.createHelper(InMemorySecretKeyStore. INSTANCE);

Use webhook helper

To process events received by a webhook, first call the unmarshal method of the WebhooksHelper object. It takes the following arguments: 

  • The body, as a string. This should be the raw body as received from the webhooks system

    String bodyOfRequest = "JSON_Body_Of_The_Request";

  • A list of request headers as received from the webhooks system. Below you will find an example of creating a list of request headers. It should contain two headers – for keyId and for signature:
    
    //Create RequestHeader for keyId  
    RequestHeader requestHeaderKeyId = new RequestHeader("X-GCS-KeyId", keyId);

    //Create RequestHeader for signature and validate it Mac mac = Mac.getInstance("HmacSHA256");
    SecretKeySpec key = new SecretKeySpec(secretKey.getBytes(StandardCharsets.UTF_8), "HmacSHA256"); mac.init(key);  byte[] unencodedResult = mac.doFinal(bodyOfRequest.getBytes(StandardCharsets.UTF_8)); String signature = org.apache.commons.codec.binary.Base64.encodeBase64String(unencodedResult);
    RequestHeader requestHeaderSignature = new RequestHeader("X-GCS-Signature", signature);
    //Create a list of RequestHeaders 
    List<RequestHeaders> requestHeaders = List.of(requestHeaderSignature, requestHeaderKeyId);


  • Now you can call a webhook helper to unmarshal incoming events which allow you to process data in your application:
    
    try {
    WebhooksEvent event = helper.unmarshal(bodyOfRequest, requestHeaders);
    } catch (SignatureValidationException e) {
    // Your code to handle error
    }