If you have no server or you implement the logic for purchase processing on the client side, you can use the following ways:

1. WebSocket API.
2. Short-polling.

Get an order status on the client side using WebSocket API

The solution uses websockets to obtain order statuses without obtaining detailed information about the order. This method is preferable: only one connection is created between the client (for example, your website or mobile application) and the Xsolla server, so there is no additional load on either the client or the server.

Complete the following steps:

1. To allow the Xsolla websocket server and your client to identify order status messages, create a connection:

const client = new Centrifuge(
connectionURL,
{
data: {
  user_external_id: user_external_id,
  auth: auth,
  project_id: project_id
}
}
)
connectionURL - wss://ws-store.xsolla.com/connection/websocket
auth - user JWT token

2. To receive new messages about order statuses, subscribe to events using the client.on function:

client.on('publication', (ctx) => {
   //handle the status
});

3. Trigger actual connection establishment:

client.connect()

4. To receive the history of changes in order statuses, connect the API history method.

client.on('subscribed', function (ctx) {
   client.history(ctx.channel, { limit: -1, since: { offset: 0 }, reverse: false }).then(function (resp) {
resp.publications.forEach((ctx) => {
   /handle the status
});

   }, function (err) {
       //handle the status
   });
});

Message body example:

{
order_id: 59614241,
status: 'new'
}

The following order statuses are possible:

• New — order was created but not paid
• Paid — order is paid
• Done — order has been delivered (all receipts sent, deliveries made on Xsolla’s side, external platforms, etc.)
• Canceled — order is canceled and payment refunded to a user

Websocket usage recommendations:

• The maximum waiting time for a response via websocket is 5 minutes.
• The connection should be established when opening the payment interface.
• The connection should be aborted once the final order status is received, either Canceled or Done.
• If the websocket’s lifespan expires or if there are any issues with the connection, use short-polling.

  Short-polling

  To get detailed information about items in the order after switching to the status, call the Get order API.

  Note

  A periodic order status poll is used — a simple HTTP request that receives the order status and information about the order. The recommended delay between requests is 3 seconds.

The XsollaCatalog.Purchase method encapsulates several methods for tracking order status. The tracking mechanism is detailed in the documentation of enterprise-level SDK for Unity.

Additionally, you can implement the handling of the order status and content, which are passed to the onSuccess callback function of the purchase method.

When using the SDK, you can track the order status in the following ways:

• subscribe to order status changes
• request order status

Subscribe to order status changes

To subscribe to order status changes, use the getOrderStatus SDK method from the Store library and pass the following parameters to the method:

• listener — listener object of type OrderStatusListener.
• orderId — order ID received from the purchase via the shopping cart, one-click purchase, or purchase for virtual currency as the parameter.

SDK reference documentation

Learn more about SDK methods and its parameters.

Example of calling the XStore.getOrderStatus method:

XStore.getOrderStatus(object : OrderStatusListener() {

               override fun  onStatusUpdate(status: OrderResponse.Status) {

                   if(status == OrderResponse.Status.DONE) {

                       Log.d("MainActivity", "Success")

                   }

               }

               override fun  onFailure() {

                   Log.d("MainActivity", "Failure")

               }

           }, orderId)

We recommend to call XStore.getOrderStatus method when opening payment UI.

Purchase methods encapsulate several methods for tracking the order status. Tracking is performed according to the following algorithm:

1. A web socket connection is established.
2. If the web socket connection is established successfully and order status changes to done or cancel, tracking stops. If a web socket connection fails or the response contains incorrect data, the order status is tracked using short-polling.
3. Order status tracking continues with short-polling. A simple HTTP order status request is sent once every 3 seconds. Tracking stops if order status changes to done or cancel.

Request order status

To request the current status of the payment transaction, call the getOrder method from the Store library, passing the following parameters to it:

• orderId — the order ID, which was received when purchasing the item.

• callback — the callback for successfully retrieving order information. When implementing a callback, use the GetStatusCallback interface, and implement the onSuccess and onError methods.

• callback — the callback for successfully retrieving order information. When implementing a callback, use the GetStatusCallback interface, and implement the onSuccess and onError methods.

Example:

XPayments.getStatus(<token>, <isSandbox>, object : GetStatusCallback {
            override fun onSuccess(data: InvoicesDataResponse?) {
                Log.d(TAG, "onSuccess is fired. Result data = $data")
            }

           override fun onError(throwable: Throwable?, errorMessage: String?) {
                Log.d(TAG, "onError is fired. ErrorMessage = $errorMessage")
            }

})

You can track the order status using the CheckPendingOrder SDK method. Pass the following parameters to the method:

• AccessToken — the payment token, which was received when purchasing the item.
• OrderId — the order ID, which was received when purchasing the item.
• SuccessCallback — the successful payment callback.
• ErrorCallback — the request error callback.
• bIsUserInvolvedToPayment — whether the user is involved in the payment process. Pass true for purchasing with real currency, and false for free item purchasing and purchasing with virtual currency.

The tracking mechanism is detailed in the documentation of enterprise-level SDK for Unreal Engine.

To request the status and content of an order, call the CheckOrder SDK method, passing the following parameters to it:

• AccessToken — the payment token, which was received when purchasing the item.
• OrderId — the order ID, which was received when purchasing the item.
• SuccessCallback — the callback for successful order checking. The response contains the order status.
• ErrorCallback — the request error callback.