User types

 alg: "HS256"
}.
{
 jti: "f69fbb80-2967-4985-afae-6cfe6c0786c4",
 sub: "john.smith@domain.com",
 stp: "email",
 iss: "e7de374f-e590-4429-ae2d-54be7e90a356",
 iat: 1582700204,
 exp: 1582700264,
 ski: "52",
 sid: "85a53925-7bbb-46be-84f8-2b00c4a48a4d"
}.
xqDTU5RYS-KJRL7zyuwra2PDfZBNDHI3bbZHHrjQUjA

liveChat('auth', '[personalizationToken]', function(error, result) {
  if (error) {
    ... // do process error
    console.log(error.code, error.message)
  } else {
  ... // no errors
  }
});

liveChat('logout', null, function(error, result) {
  if (error) {
    ... // do process error
    console.log(error.code, error.message)
  } else {
  ... // no errors
  }
});

// Download PHP-JWT: https://github.com/firebase/php-jwt
composer require firebase/php-jwt
use \Firebase\JWT\JWT;
$timestamp = time();
$securityKey = json_decode('Copied data from Infobip Live Chat Security Key');
$payload = {
  'jti' => 'random UNIQUE String',
  'stp' => '[email | msisdn | externalPersonId]',
  'sub' => '[email.@email.com | +PhoneNumber | ExtPersonID]',
  'iss' => 'Widget ID',
  'iat' => $timestamp,
  'exp' => $timestamp + 15,
  'ski' => $securityKey->id,
  'sid' => 'Session Identifier'
};
 $token = JWT::encode($payload, base64_decode($securityKey->key));

// Install jsonwebtoken: npm install jsonwebtoken --save-dev
var jwt = require('jsonwebtoken');
const securityKey = JSON.parse('Copied data from Infobip Live Chat Security Key');
const timestamp = Math.floor(date.getTime()/1000);
var payload = {
  jti: 'random UNIQUE String',
  stp: '[email | msisdn | externalPersonId]',
  sub: '[email.@email.com | +PhoneNumber | ExtPersonID]',
  iss: 'Widget ID',
  iat: timestamp,
  exp: timestamp + 15,
  ski: securityKey.id,
  sid: 'Session Identifier'
};
var token = jwt.sign(payload, Buffer.from(securityKey.key, 'base64'));

import com.fasterxml.jackson.databind.ObjectMapper;
import com.nimbusds.jose.JWSAlgorithm;
import com.nimbusds.jose.JWSHeader;
import com.nimbusds.jose.crypto.MACSigner;
import com.nimbusds.jwt.JWTClaimsSet;
import com.nimbusds.jwt.SignedJWT;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;

import java.time.Instant;
import java.util.*;

@Component
class PersonalisationTokenGenerator {
  // IMPORTANT: securityKey here it is a copied data from Infobip Live Chat Security Key
  public ResponseEntity authorize(String widgetId, String securityKey) {
    try {
      // simple example how personalizationToken issuing process could looks like:
      ObjectMapper objectMapper = new ObjectMapper();
      SecurityKeyHMAC secret = objectMapper.readValue(securityKey, SecurityKeyHMAC.class);
      MACSigner personalizationTokenSigner = new MACSigner(Base64.getDecoder().decode(secret.getKey()));
      JWTClaimsSet claimsSet = new JWTClaimsSet.Builder()
        // generate always UNIQUE ID because Infobip will remember it and not permit to use it twice! As ID can be used ant string
        .jwtID(UUID.randomUUID().toString())                                      // unique ID of this token. Mandatory
        .subject("example-email@infobip.com")                                     // person destination in Infobip People service. Mandatory
        .issuer(widgetId)                                                         // which widget it belongs. Mandatory
        .issueTime(new Date())                                                        // when created. Mandatory
        .expirationTime(Date.from(Instant.now().plusMillis(15000))) // Optional, e.g. when this token should be invalidated if not yet used,
        // if not set then by default token will be invalidated after 15 seconds after issueTime
        .claim("ski", secret.getId())                                                 // needs for security validation. Mandatory
        .claim("stp", "email")                                                   // type of person destination in Infobip People service. Mandatory
        .claim("sid", "Session identifier")                                      // unique session identifier. Optional
        .build();
      SignedJWT personalizedToken = new SignedJWT(new JWSHeader(JWSAlgorithm.HS256), claimsSet);
      personalizedToken.sign(personalizationTokenSigner);
      return ResponseEntity.ok(personalizedToken.serialize());
    } catch (Exception ex){
      // do some logging stuff
      ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
    }
    return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
  }
}

class SecurityKeyHMAC {
  private long id;
  private String key;

  public long getId() {
    return id;
  }

  public void setId(long id) {
    this.id = id;
  }

  public String getKey() {
    return key;
  }

  public void setKey(String key) {
    this.key = key;
  }
}

import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
import com.nimbusds.jose.JWSAlgorithm
import com.nimbusds.jose.JWSHeader
import com.nimbusds.jose.crypto.MACSigner
import com.nimbusds.jwt.JWTClaimsSet
import com.nimbusds.jwt.SignedJWT
import org.springframework.http.HttpStatus
import org.springframework.http.ResponseEntity
import org.springframework.stereotype.Component
import java.time.Instant
import java.util.*

@Component
internal class PersonalisationTokenGenerator {
    // IMPORTANT: securityKey here it is a copied data from Infobip Live Chat Security Key
    fun authorize(widgetId: String?, securityKey: String?): ResponseEntity {
        try {
            // simple example how personalizationToken issuing process could looks like:
            val objectMapper = jacksonObjectMapper()
            val secret = objectMapper.readValue(securityKey, SecurityKeyHMAC::class.java)
            val personalizationTokenSigner = MACSigner(Base64.getDecoder().decode(secret.key))
            val claimsSet = JWTClaimsSet.Builder()                          // generate always UNIQUE ID because Infobip will remember it and not permit to use it twice! As ID can be used ant string
                .jwtID(UUID.randomUUID().toString())                        // unique ID of this token. Mandatory
                .subject("example-email@infobip.com")                       // person destination in Infobip People service. Mandatory
                .issuer(widgetId)                                                            // which widget it belongs. Mandatory
                .issueTime(Date())                                          // when created. Mandatory
                .expirationTime(Date.from(Instant.now().plusMillis(15000))) // Optional, e.g. when this token should be invalidated if not yet used,
                // if not set then by default token will be invalidated after 15 seconds after issueTime
                .claim("ski", secret.id)                                    // needs for security validation. Mandatory
                .claim("stp", "email")                                      // type of person destination in Infobip People service. Mandatory
                .claim("sid", "Session identifier")                         // unique session identifier. Optional
                .build()
            val personalizedToken = SignedJWT(JWSHeader(JWSAlgorithm.HS256), claimsSet)
            personalizedToken.sign(personalizationTokenSigner)
            return ResponseEntity.ok(personalizedToken.serialize())
        } catch (ex: Exception) {
            // do some logging stuff
            ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build()
        }
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build()
    }
}

data class SecurityKeyHMAC(val id: Long, val key: String)

// Download Swift-JWT: https://github.com/Kitura/Swift-JWT or any JSON Web Token library for Swift 
import SwiftJWT 
struct JWTClaims: Claims {
    let jti: String // random UNIQUE String. Mandatory.
    let sub: String // '[email.@email.com | +PhoneNumber | ExtPersonID]'. Mandatory.
    let stp: String // Define the above. ie: "email", "msisdn" or "externalPersonId". Mandatory.
    let iss: String // Livechat widget Id. Mandatory.
    let iat: Date // timestamp. Mandatory. Issue time when created. Mandatory.
    let exp: Date // timestamp. Optional, e.g. when this token should be invalidated if not yet used. Default of 15 seconds. Mandatory.
    let ski: String // securityKey.id (provided by livechat widget, different that widget id). Mandatory.
    let sid: String // 'Session Identifier'. Optional
}
let myHeader = Header()
let randomUniqueString = UUID().uuidString
let myClaims = JWTClaims(
    jti: randomUniqueString,
    sub: email,
    stp: "email",
    iss: widgetId,
    iat: Date(),
    exp: Date().addingTimeInterval(20), // 20 seconds after creation - recommended value
    ski: widgetKeyId,
    sid: randomUniqueString)
var myJWT = JWT(header: myHeader, claims: myClaims)
guard let secretKeyIdData = Data(base64Encoded: widgetSecretKeyId, options: .ignoreUnknownCharacters) else {
    print("Unable to decode the base64 secret key Id")
    return nil
}
let jwtSigner = JWTSigner.hs256(key: secretKeyIdData)
guard let signedJWT = try? myJWT.sign(using: jwtSigner) else {
    print("Unable to prepare the signed JWT to authenticate into the chat")
    return nil
}
// signedJWT is your JSON Web Token ready to use